public override void OnMessageReceived(IMessageEvent messageEvent){
if (messageEvent.Path.Equals (START_ACTIVITY_PATH)) {
var launchMain = new Intent (this, typeof(MainActivity));
launchMain.AddFlags (ActivityFlags.NewTask);
StartActivity (launchMain);
}
}
public override void OnMessageReceived(IMessageEvent messageEvent)
{
if (!messageEvent.Path.Equals (DigitalWatchFaceUtil.PathWithFeature)) {
return;
}
var rawData = messageEvent.GetData ();
// It's allowed that the message carries only some of the keys used in the config DataItem
// and skips the ones that we don't want to change.
var configKeysToOverwrite = DataMap.FromByteArray (rawData);
if (Log.IsLoggable (Tag, LogPriority.Debug)) {
Log.Debug (Tag, "Received watch face config message: " + configKeysToOverwrite);
}
if (googleApiClient == null) {
googleApiClient = new GoogleApiClientBuilder (this)
.AddConnectionCallbacks (this)
.AddOnConnectionFailedListener (this)
.AddApi (WearableClass.Api)
.Build ();
}
if (!googleApiClient.IsConnected) {
var connectionResult = googleApiClient.BlockingConnect (30, TimeUnit.Seconds);
if (!connectionResult.IsSuccess) {
Log.Error (Tag, "Failed to connect to GoogleApiClient.");
return;
}
}
DigitalWatchFaceUtil.OverwriteKeysInConfigDataMap (googleApiClient, configKeysToOverwrite);
}
public override void OnMessageReceived(IMessageEvent messageEvent)
{
base.OnMessageReceived(messageEvent);
if (!messageEvent.Path.StartsWith(TweetsPath))
return;
HandleMessage(messageEvent);
}
public override void OnMessageReceived (IMessageEvent messageEvent)
{
base.OnMessageReceived (messageEvent);
if (!messageEvent.Path.StartsWith (SearchStationPath)
&& !messageEvent.Path.StartsWith (ActionPrefixPath))
return;
HandleMessage (messageEvent);
}
async void HandleMessage(IMessageEvent message)
{
try
{
Android.Util.Log.Info("WearIntegration", "Received Message");
var client = new GoogleApiClientBuilder(this)
.AddApi(WearableClass.API)
.Build();
var result = client.BlockingConnect(30, Java.Util.Concurrent.TimeUnit.Seconds);
if (!result.IsSuccess)
return;
var path = message.Path;
try
{
if (path.StartsWith(TweetsPath))
{
var viewModel = new TwitterViewModel();
await viewModel.ExecuteLoadTweetsCommand();
var request = PutDataMapRequest.Create(TweetsPath + "/Answer");
var map = request.DataMap;
var tweetMap = new List<DataMap>();
foreach (var tweet in viewModel.Tweets)
{
var itemMap = new DataMap();
itemMap.PutLong("CreatedAt", tweet.CreatedAt.Ticks);
itemMap.PutString("ScreenName", tweet.ScreenName);
itemMap.PutString("Text", tweet.Text);
tweetMap.Add(itemMap);
}
map.PutDataMapArrayList("Tweets", tweetMap);
map.PutLong("UpdatedAt", DateTime.UtcNow.Ticks);
await WearableClass.DataApi.PutDataItem(client, request.AsPutDataRequest());
}
}
finally
{
client.Disconnect();
}
}
catch (Exception e)
{
Android.Util.Log.Error("WearIntegration", e.ToString());
}
}
public override void OnMessageReceived (IMessageEvent messageEvent)
{
LOGD (Tag, "OnMessageReceived: " + messageEvent);
// Check to see if the message is to start an activity
if (messageEvent.Path.Equals (StartActivityPath)) {
Intent startIntent = new Intent (this, typeof(MainActivity));
startIntent.AddFlags (ActivityFlags.NewTask);
StartActivity (startIntent);
}
}
public void OnMessageReceived (IMessageEvent messageEvent)
{
RunOnUiThread (() => {
if (messageEvent.Path.Equals (TIMER_SELECTED_PATH)) {
Toast.MakeText (ApplicationContext, Resource.String.toast_timer_selected,
ToastLength.Short).Show ();
} else if (messageEvent.Path.Equals (TIMER_FINISHED_PATH)) {
Toast.MakeText (ApplicationContext, Resource.String.toast_timer_finished,
ToastLength.Short).Show ();
}
});
}
GUIStyle GetMessageStyle(IMessageEvent e)
{
switch (e.priority)
{
case MessagePriority.Low:
return(LOW_PRIORTY);
case MessagePriority.Medium:
return(NORMAL_PRIORITY);
default:
return(HIGH_PRIORITY);
}
}
public void DroppingNetworkEvents()
{
int maxNumberOfNetworkEvents = 8;
TraceParams traceParams =
TraceParams.Default
.ToBuilder()
.SetMaxNumberOfMessageEvents(maxNumberOfNetworkEvents)
.Build();
ISpan span =
Span.StartSpan(
spanContext,
recordSpanOptions,
SPAN_NAME,
parentSpanId,
false,
traceParams,
startEndHandler,
timestampConverter,
testClock);
IMessageEvent networkEvent =
MessageEvent.Builder(MessageEventType.Received, 1).SetUncompressedMessageSize(3).Build();
for (int i = 0; i < 2 * maxNumberOfNetworkEvents; i++)
{
span.AddMessageEvent(networkEvent);
testClock.AdvanceTime(Duration.Create(0, 100));
}
ISpanData spanData = ((Span)span).ToSpanData();
Assert.Equal(maxNumberOfNetworkEvents, spanData.MessageEvents.DroppedEventsCount);
Assert.Equal(maxNumberOfNetworkEvents, spanData.MessageEvents.Events.Count());
var list = spanData.MessageEvents.Events.ToList();
for (int i = 0; i < maxNumberOfNetworkEvents; i++)
{
Assert.Equal(timestamp.AddNanos(100 * (maxNumberOfNetworkEvents + i)), list[i].Timestamp);
Assert.Equal(networkEvent, list[i].Event);
}
span.End();
spanData = ((Span)span).ToSpanData();
Assert.Equal(maxNumberOfNetworkEvents, spanData.MessageEvents.DroppedEventsCount);
Assert.Equal(maxNumberOfNetworkEvents, spanData.MessageEvents.Events.Count());
list = spanData.MessageEvents.Events.ToList();
for (int i = 0; i < maxNumberOfNetworkEvents; i++)
{
Assert.Equal(timestamp.AddNanos(100 * (maxNumberOfNetworkEvents + i)), list[i].Timestamp);
Assert.Equal(networkEvent, list[i].Event);
}
}
public virtual bool TryFindCommand(IMessageEvent e, out IVersaCommand command, out string matchedCommandText)
{
foreach (var comG in e.EventSpecificCommands.Concat(Groups))
{
if (!comG.TryFindCommand(GlobalPrefix, e, out command, out matchedCommandText))
{
continue;
}
RunStateArgs.OnNext(new CommandRunStateEventArgs(e, command, null, ECommandState.FoundCommand));
return(true);
}
command = default;
matchedCommandText = default;
return(false);
}
public void OnMessageReceived(IMessageEvent messageEvent)
{
RunOnUiThread(() => {
if (messageEvent.Path.Equals(TIMER_SELECTED_PATH))
{
Toast.MakeText(ApplicationContext, Resource.String.toast_timer_selected,
ToastLength.Short).Show();
}
else if (messageEvent.Path.Equals(TIMER_FINISHED_PATH))
{
Toast.MakeText(ApplicationContext, Resource.String.toast_timer_finished,
ToastLength.Short).Show();
}
});
}
public async void OnMessageReceived(IMessageEvent messageEvent)
{
await _requestLock.WaitAsync();
_requestLock.Release();
switch (messageEvent.Path)
{
case ListAuthenticatorsCapability:
await OnAuthenticatorListReceived(messageEvent.GetData());
break;
case ListCategoriesCapability:
await OnCategoriesListReceived(messageEvent.GetData());
break;
case ListCustomIconsCapability:
await OnCustomIconListReceived(messageEvent.GetData());
break;
case GetCustomIconCapability:
await OnCustomIconReceived(messageEvent.GetData());
break;
case GetPreferencesCapability:
OnPreferencesReceived(messageEvent.GetData());
break;
case RefreshCapability:
await OnRefreshRecieved();
break;
}
Interlocked.Increment(ref _responsesReceived);
var received = Interlocked.CompareExchange(ref _responsesReceived, 0, 0);
var required = Interlocked.CompareExchange(ref _responsesRequired, 0, 0);
if (received == required)
{
_responseLock.Release();
}
}
private byte[] SerializeMessagePackToFrame(IMessageEvent message)
{
try
{
var serializedMessage = MessagePackSerializer.Serialize(message, ContractlessStandardResolver.Instance);
var packetData = new byte[serializedMessage.Length + 2];
Buffer.BlockCopy(BitConverter.GetBytes((ushort)serializedMessage.Length), 0, packetData, 0, 2);
Buffer.BlockCopy(serializedMessage, 0, packetData, 2, serializedMessage.Length);
return(packetData);
}
catch (Exception ex)
{
_log.Warn($"Error while message has serialized:\n{ex}");
}
return(null);
}
public void OnMessageReceived(IMessageEvent messageEvent)
{
switch (messageEvent.Path)
{
case WearGetCodeCapability:
{
// Invalid position, return to list
if (messageEvent.GetData().Length == 0)
{
Finish();
return;
}
var json = Encoding.UTF8.GetString(messageEvent.GetData());
var update = JsonConvert.DeserializeObject <WearAuthenticatorCodeResponse>(json);
_timeRenew = update.TimeRenew;
var code = update.Code;
if (code == null)
{
code = "".PadRight(_digits, '-');
}
var spacesInserted = 0;
var groupSize = Math.Min(MaxCodeGroupSize, _digits / 2);
for (var i = 0; i < _digits; ++i)
{
if (i % groupSize == 0 && i > 0)
{
code = code.Insert(i + spacesInserted, " ");
spacesInserted++;
}
}
_codeTextView.Text = code;
UpdateProgressBar();
break;
}
case RefreshCapability:
Finish(); // We don't know what changed, just go back
break;
}
}
public virtual async Task <(bool, Task <(bool, IConditionalRule, string)>)> RunSupportedCommand(
IMessageEvent @event, IVersaCommand command, string matchedCommandLine)
{
switch (command)
{
case IVersaCommand <CommandContext> basicCommand:
RunStateArgs.OnNext(new CommandRunStateEventArgs(@event, command, null, ECommandState.BeforeContextConstruction));
var factory = @event.Services
.GetRequiredService <ICommandContextFactory <CommandContext> >();
var(context, additionalConditionFuncs) = await factory.ConfigureContextAsync(@event, basicCommand, matchedCommandLine).ConfigureAwait(false);
return(true, RunCommand(@event, context, basicCommand, @event.Services, additionalConditionFuncs));
default:
return(false, default);
}
}
async void HandleMessage (IMessageEvent message)
{
try {
Android.Util.Log.Info ("WearIntegration", "Received Message");
var client = new GoogleApiClientBuilder (this)
.AddApi (WearableClass.Api)
.AddApi (LocationServices.Api)
.Build ();
var result = client.BlockingConnect (30, Java.Util.Concurrent.TimeUnit.Seconds);
if (!result.IsSuccess)
return;
try {
var lastLocation = LocationServices.FusedLocationApi.GetLastLocation (client);
if (lastLocation == null)
return;
var stations = Hubway.Instance.LastStations;
if (stations == null)
stations = await Hubway.Instance.GetStations ();
var currentPoint = new GeoPoint {
Lat = lastLocation.Latitude,
Lon = lastLocation.Longitude
};
var nearestStations = Hubway.GetStationsAround (stations, currentPoint);
using (var stream = new System.IO.MemoryStream ()) {
GeoUtils.DumpLocation (currentPoint, stream);
StationUtils.DumpStations (nearestStations, stream);
var bytes = stream.ToArray ();
WearableClass.MessageApi.SendMessage (client,
message.SourceNodeId,
SearchStationPath + "/Answer",
bytes).Await ();
}
} finally {
client.Disconnect ();
}
} catch (Exception e) {
Android.Util.Log.Error ("WearIntegration", e.ToString ());
}
}
public async void OnMessageReceived(IMessageEvent messageEvent)
{
switch (messageEvent.Path)
{
case ListCapability:
{
var json = Encoding.UTF8.GetString(messageEvent.GetData());
_authenticatorListAdapter.Items = JsonConvert.DeserializeObject <List <WearAuthenticatorResponse> >(json);
if (_authenticatorListAdapter.Items.Count == 0)
{
AnimUtil.FadeInView(_emptyLayout, 200);
}
else
{
AnimUtil.FadeOutView(_emptyLayout, 200);
}
_authenticatorListAdapter.NotifyDataSetChanged();
var anim = new AlphaAnimation(0f, 1f)
{
Duration = 200
};
anim.AnimationEnd += (sender, e) =>
{
_authList.Visibility = ViewStates.Visible;
_authList.RequestFocus();
};
_authList.StartAnimation(anim);
_loadingLayout.Visibility = ViewStates.Invisible;
break;
}
case RefreshCapability:
await Refresh();
break;
}
}
public override void OnMessageReceived(IMessageEvent messageEvent)
{
base.OnMessageReceived(messageEvent);
if (messageEvent.Path.Equals(WearableHelper.ErrorPath))
{
LocalBroadcastManager.GetInstance(this)
.SendBroadcast(new Intent(WearableHelper.ErrorPath));
}
else if (messageEvent.Path.Equals(WearableHelper.IsSetupPath))
{
var data = messageEvent.GetData();
bool isDeviceSetup = BitConverter.ToBoolean(data, 0);
LocalBroadcastManager.GetInstance(this)
.SendBroadcast(new Intent(WearableHelper.IsSetupPath)
.PutExtra(EXTRA_DEVICESETUPSTATUS, isDeviceSetup)
.PutExtra(EXTRA_CONNECTIONSTATUS, (int)mConnectionStatus));
}
}
public override void OnMessageReceived(IMessageEvent messageEvent)
{
// base.OnMessageReceived(p0);
if (messageEvent.Path == MessageValue.PathStart)
{
var bcore = Encoding.UTF8.GetString(messageEvent.GetData());
Android.Util.Log.Debug("MsgListenerService", "Recv MsgAPI:" + bcore);
var intent = new Intent(this, typeof(ControllerService));
intent.PutExtra(ControllerService.ExtraKeyBcore, bcore);
StartService(intent);
}
else if (messageEvent.Path == MessageValue.PathStop)
{
var intent = new Intent(ControllerService.ActionKeyStop);
SendBroadcast(intent);
}
}
public override void AddMessageEvent(IMessageEvent messageEvent)
{
if (!Options.HasFlag(SpanOptions.RECORD_EVENTS))
{
return;
}
lock (_lock)
{
if (hasBeenEnded)
{
//logger.log(Level.FINE, "Calling addNetworkEvent() on an ended Span.");
return;
}
if (messageEvent == null)
{
throw new ArgumentNullException(nameof(messageEvent));
}
InitializedMessageEvents.AddEvent(new EventWithNanoTime <IMessageEvent>(clock.NowNanos, messageEvent));
}
}
public override async void OnMessageReceived(IMessageEvent messageEvent)
{
await _initTask.Value;
switch (messageEvent.Path)
{
case GetSyncBundleCapability:
await GetSyncBundle(messageEvent.SourceNodeId);
break;
case GetCustomIconCapability:
{
var id = Encoding.UTF8.GetString(messageEvent.GetData());
await GetCustomIcon(id, messageEvent.SourceNodeId);
break;
}
}
}
public override void OnMessageReceived(IMessageEvent messageEvent)
{
if (messageEvent.Path.Equals(WearableHelper.StartActivityPath))
{
Intent startIntent = new Intent(this, typeof(LaunchActivity))
.SetFlags(ActivityFlags.ClearTop | ActivityFlags.NewTask | ActivityFlags.ClearTask);
StartActivity(startIntent);
}
else if (messageEvent.Path.Equals(WearableHelper.SettingsPath))
{
Task.Run(async() => await CreateSettingsDataRequest(true));
}
else if (messageEvent.Path.Equals(WearableHelper.LocationPath))
{
Task.Run(async() => await CreateLocationDataRequest(true));
}
else if (messageEvent.Path.Equals(WearableHelper.WeatherPath))
{
var data = messageEvent.GetData();
bool force = false;
if (data != null && data.Length > 0)
{
force = BitConverter.ToBoolean(data, 0);
}
if (!force)
{
Task.Run(async() => await CreateWeatherDataRequest(true));
}
else
{
// Refresh weather data
WeatherWidgetService.EnqueueWork(this, new Intent(this, typeof(WeatherWidgetService))
.SetAction(WeatherWidgetService.ACTION_UPDATEWEATHER));
}
}
else if (messageEvent.Path.Equals(WearableHelper.IsSetupPath))
{
SendSetupStatus(messageEvent.SourceNodeId);
}
}
public async void OnMessageReceived(IMessageEvent messageEvent)
{
switch (messageEvent.Path)
{
case ListAuthenticatorsCapability:
await OnAuthenticatorListReceived(messageEvent.GetData());
break;
case ListCategoriesCapability:
await OnCategoriesListReceived(messageEvent.GetData());
break;
case ListCustomIconsCapability:
await OnCustomIconListReceived(messageEvent.GetData());
break;
case GetCustomIconCapability:
await OnCustomIconReceived(messageEvent.GetData());
break;
case RefreshCapability:
await Refresh();
break;
}
Interlocked.Add(ref _responsesReceived, 1);
var received = Interlocked.CompareExchange(ref _responsesReceived, 0, 0);
var required = Interlocked.CompareExchange(ref _responsesRequired, 0, 0);
if (received == required)
{
RunOnUiThread(UpdateViewState);
}
}
public void OnMessageReceived(IMessageEvent message)
{
if (!message.Path.EndsWith ("/Answer"))
return;
IList<Station> stations = null;
GeoPoint currentLocation;
using (var content = new System.IO.MemoryStream (message.GetData ())) {
currentLocation = GeoUtils.ParseFromStream (content);
stations = StationUtils.ParseStations (content);
}
if (stations != null) {
handler.Post (() => {
var adapter = new StationGridAdapter (FragmentManager, stations, currentLocation, ActionStatus);
pager.Adapter = adapter;
pager.OffscreenPageCount = 2;
label.Visibility = ViewStates.Gone;
pager.Visibility = ViewStates.Visible;
});
}
}
// Implementing IMessageApiMessageListener interface
// On message received we want invoke event
public void OnMessageReceived(IMessageEvent messageEvent)
{
var message = System.Text.Encoding.Default.GetString(messageEvent.GetData());
Log.Info("my_log", "Communicator: Message received \"" + message + "\"");
EventViewModel eventModel = new EventViewModel();
if (message.Contains("option") && message.ToString().ToCharArray().Length > ("option").Length)
{
Device.BeginInvokeOnMainThread(async() =>
{
await eventModel.setOption(message);
});
}
if (message.Contains("option"))
{
Device.BeginInvokeOnMainThread(async() => {
await eventModel.TriggerFeatureAsync();
});
}
MessageReceived(message);
}
public void OnMessageReceived(IMessageEvent e)
{
if (MessageTag.Equals(e.Path))
{
var msg = System.Text.Encoding.UTF8.GetString(e.GetData());
Log.Debug(Tag, msg);
var ringo = msg.Split(':');
var colorName = System.Drawing.Color.FromName(ringo[2]);
var colorRgb = Android.Graphics.Color.Rgb(colorName.R, colorName.G, colorName.B);
this.RunOnUiThread(() =>
{
var layout = FindViewById <LinearLayout>(Resource.Id.linear);
layout.SetBackgroundColor(colorRgb);
var status = FindViewById <TextView>(Resource.Id.status);
status.Text = string.Format("{0}月 - {1}", ringo[0], ringo[1]);
status.SetBackgroundColor(colorRgb);
status.SetTextColor(Color.Black);
});
}
}
public override void OnMessageReceived(IMessageEvent messageEvent)
{
string path = messageEvent.Path;
if (path.Equals(Constants.QUIZ_EXITED_PATH))
{
((NotificationManager)GetSystemService(NotificationService)).CancelAll();
}
if (path.Equals(Constants.QUIZ_ENDED_PATH) || path.Equals(Constants.QUIZ_EXITED_PATH))
{
var dataMap = DataMap.FromByteArray(messageEvent.GetData());
int numCorrect = dataMap.GetInt(Constants.NUM_CORRECT);
int numIncorrect = dataMap.GetInt(Constants.NUM_INCORRECT);
int numSkipped = dataMap.GetInt(Constants.NUM_SKIPPED);
var builder = new Notification.Builder(this)
.SetContentTitle(GetString(Resource.String.quiz_report))
.SetSmallIcon(Resource.Drawable.ic_launcher)
.SetLocalOnly(true);
var quizReportText = new SpannableStringBuilder();
AppendColored(quizReportText, numCorrect.ToString(), Resource.Color.dark_green);
quizReportText.Append(" " + GetString(Resource.String.correct) + "\n");
AppendColored(quizReportText, numIncorrect.ToString(), Resource.Color.dark_red);
quizReportText.Append(" " + GetString(Resource.String.incorrect) + "\n");
AppendColored(quizReportText, numSkipped.ToString(), Resource.Color.dark_yellow);
quizReportText.Append(" " + GetString(Resource.String.skipped) + "\n");
builder.SetContentText(quizReportText);
if (!path.Equals(Constants.QUIZ_EXITED_PATH))
{
builder.AddAction(Resource.Drawable.ic_launcher,
GetString(Resource.String.reset_quiz), GetResetQuizPendingIntent());
}
((NotificationManager)GetSystemService(NotificationService))
.Notify(QUIZ_REPORT_NOTIF_ID, builder.Build());
}
}
public override void OnMessageReceived(IMessageEvent messageEvent)
{
if (!messageEvent.Path.Equals(DigitalWatchFaceUtil.PathWithFeature))
{
return;
}
var rawData = messageEvent.GetData();
// It's allowed that the message carries only some of the keys used in the config DataItem
// and skips the ones that we don't want to change.
var configKeysToOverwrite = DataMap.FromByteArray(rawData);
if (Log.IsLoggable(Tag, LogPriority.Debug))
{
Log.Debug(Tag, "Received watch face config message: " + configKeysToOverwrite);
}
if (googleApiClient == null)
{
googleApiClient = new GoogleApiClientBuilder(this)
.AddConnectionCallbacks(this)
.AddOnConnectionFailedListener(this)
.AddApi(WearableClass.Api)
.Build();
}
if (!googleApiClient.IsConnected)
{
var connectionResult = googleApiClient.BlockingConnect(30, TimeUnit.Seconds);
if (!connectionResult.IsSuccess)
{
Log.Error(Tag, "Failed to connect to GoogleApiClient.");
return;
}
}
DigitalWatchFaceUtil.OverwriteKeysInConfigDataMap(googleApiClient, configKeysToOverwrite);
}
public async Task OnSubscriptionChanged(IMessageEvent message)
{
using (var scope = _serviceProvider.CreateScope())
{
var cache = scope.ServiceProvider.GetRequiredService <ICacheManager>();
switch (message.MessageType)
{
case (int)MessageEventType.RemoveKey:
await cache.RemoveAsync(message.Key);
break;
case (int)MessageEventType.RemoveByPrefix:
await cache.RemoveByPrefixAsync(message.Key);
break;
case (int)MessageEventType.ClearCache:
await cache.Clear();
break;
}
}
}
public override void OnMessageReceived(IMessageEvent messageEvent)
{
if (messageEvent.Path.Equals(START_ACTIVITY_PATH))
{
string message = messageEvent.GetData().GetString();
if (string.IsNullOrWhiteSpace(message))
{
var launchPage = new Intent(this, typeof(LaunchedFromHandheldActivity));
launchPage.AddFlags(ActivityFlags.NewTask);
StartActivity(launchPage);
}
else
{
// Start a new activity
var launchPage = new Intent(this, typeof(LaunchedFromHandheldWithDataActivity));
launchPage.PutExtra("WearMessage", message);
launchPage.AddFlags(ActivityFlags.NewTask);
StartActivity(launchPage);
}
}
else if (messageEvent.Path.Equals(START_ACTIVITY_PATH_IN_MAIN_ACTIVITY))
{
string message = messageEvent.GetData().GetString();
// Broadcast message to wearable activity for display
var messageIntent = new Intent();
messageIntent.SetAction(Intent.ActionSend);
messageIntent.PutExtra("message", message);
LocalBroadcastManager.GetInstance(this).SendBroadcast(messageIntent);
}
else
{
base.OnMessageReceived(messageEvent);
}
}
async void HandleMessage(IMessageEvent message)
{
try
{
Android.Util.Log.Info("WearIntegration", "Received Message");
var client = new GoogleApiClientBuilder(this).AddApi(WearableClass.Api).Build();
var result = client.BlockingConnect(30, Java.Util.Concurrent.TimeUnit.Seconds);
if (!result.IsSuccess)
{
return;
}
var path = message.Path;
try
{
if (path == answerYesPath)
{
_votingService.Vote(true);
}
else if (path == answerNoPath)
{
_votingService.Vote(false);
}
}
finally
{
client.Disconnect();
}
} catch (Exception e)
{
Android.Util.Log.Error("WearIntegration", e.ToString());
}
}
private void _rTCDataChannel_OnMessage(IMessageEvent Event)
{
Debug.WriteLine("[DataChannel] Conductor: It has passed message:", Event.Text);
}
public async override void OnMessageReceived (IMessageEvent messageEvent)
{
LOGD (Tag, "OnMessageReceived: " + messageEvent);
await HandleMessage (messageEvent);
base.OnMessageReceived (messageEvent);
}
public override void OnMessageReceived (IMessageEvent messageEvent)
{
if (Log.IsLoggable (Constants.TAG, LogPriority.Debug)) {
Log.Debug (Constants.TAG, "OnMessageReceived: " + messageEvent.Path
+ " " + messageEvent.GetData () + " for " + PackageName);
}
}
public override void AddMessageEvent(IMessageEvent messageEvent)
{
}
private async Task HandleMessage (IMessageEvent message)
{
try {
Log.Info ("WearIntegration", "Received Message");
googleApiClient.Connect();
if (!googleApiClient.IsConnected) {
Log.Info ("WearIntegration", "Connecting");
}
var authManager = ServiceContainer.Resolve<AuthManager> ();
if (!authManager.IsAuthenticated) {
Log.Info ("WearIntegration", "Is not authenticated");
NotifyNotLoggedIn();
return;
}
var path = message.Path;
try {
if (path == Common.StartStopTimeEntryPath) {
await WearDataProvider.StartStopTimeEntry (BaseContext);
await UpdateSharedTimeEntryList ();
} else if (path == Common.ContinueTimeEntryPath) {
var guid = Guid.Parse (Common.GetString (message.GetData()));
await StartEntry (guid);
await UpdateSharedTimeEntryList ();
} else if (path == Common.RequestSyncPath) {
Log.Info ("WearIntegration", "Sending sync data!");
await UpdateSharedTimeEntryList ();
} else if (path == Common.OpenHandheldPath) {
StartMainActivity ();
}
} catch (Exception e) {
Log.Error ("WearIntegration", e.ToString ());
}
} catch (Exception e) {
Log.Error ("WearIntegration", e.ToString ());
}
}
public bool Send(IMessageEvent message)
{
return(_contactService.IsPersonOnLine(message) ? _messageService.Send(message) : false);
}
public abstract void AddMessageEvent(IMessageEvent messageEvent);
public bool IsPersonOnLine(IMessageEvent message)
{
Console.WriteLine($"\n Checking if the person is on line.");
return(message.PersonName == "YAKOV");
}
internal static IMessageArgs GetArgs(IMessageEvent handler)
{
return null;
}
public override void OnMessageReceived (IMessageEvent messageEvent)
{
string path = messageEvent.Path;
if (path.Equals (Constants.QUIZ_EXITED_PATH)) {
((NotificationManager)GetSystemService (NotificationService)).CancelAll ();
}
if (path.Equals (Constants.QUIZ_ENDED_PATH) || path.Equals (Constants.QUIZ_EXITED_PATH)) {
var dataMap = DataMap.FromByteArray (messageEvent.GetData ());
int numCorrect = dataMap.GetInt (Constants.NUM_CORRECT);
int numIncorrect = dataMap.GetInt (Constants.NUM_INCORRECT);
int numSkipped = dataMap.GetInt (Constants.NUM_SKIPPED);
var builder = new Notification.Builder (this)
.SetContentTitle (GetString (Resource.String.quiz_report))
.SetSmallIcon (Resource.Drawable.ic_launcher)
.SetLocalOnly (true);
var quizReportText = new SpannableStringBuilder ();
AppendColored (quizReportText, numCorrect.ToString (), Resource.Color.dark_green);
quizReportText.Append (" " + GetString (Resource.String.correct) + "\n");
AppendColored (quizReportText, numIncorrect.ToString (), Resource.Color.dark_red);
quizReportText.Append (" " + GetString (Resource.String.incorrect) + "\n");
AppendColored (quizReportText, numSkipped.ToString (), Resource.Color.dark_yellow);
quizReportText.Append (" " + GetString (Resource.String.skipped) + "\n");
builder.SetContentText (quizReportText);
if (!path.Equals (Constants.QUIZ_EXITED_PATH)) {
builder.AddAction (Resource.Drawable.ic_launcher,
GetString (Resource.String.reset_quiz), GetResetQuizPendingIntent ());
}
((NotificationManager)GetSystemService (NotificationService))
.Notify (QUIZ_REPORT_NOTIF_ID, builder.Build ());
}
}
/// <summary>
/// Returns an header from an InfoEvent.
/// </summary>
/// <param name="Event"></param>
/// <returns></returns>
public short GetHeader(IMessageEvent Event)
{
using (DictionaryAdapter<string, short> DA = new DictionaryAdapter<string, short>(InfoEvents))
{
return DA.TryPopValue(Event.GetType().Name);
}
}
public void OnMessageReceived (IMessageEvent messageEvent)
{
if (messageEvent.Path.Equals (Constants.RESET_QUIZ_PATH)) {
RunOnUiThread (new Runnable (new Action (delegate() {
ResetQuiz ();
})));
}
}
/// <summary>
/// Called when messages are received, is not used in this project any longer
/// </summary>
/// <param name="ev"></param>
public void OnMessageReceived(IMessageEvent ev)
{
debugLog("Message received(This shouldn't happen anymore)");
}
public void GoSpanData_EndedSpan()
{
ISpan span =
Span.StartSpan(
spanContext,
recordSpanOptions,
SPAN_NAME,
parentSpanId,
false,
TraceParams.DEFAULT,
startEndHandler,
timestampConverter,
testClock);
span.PutAttribute(
"MySingleStringAttributeKey",
AttributeValue.StringAttributeValue("MySingleStringAttributeValue"));
span.PutAttributes(attributes);
testClock.AdvanceTime(Duration.Create(0, 100));
span.AddAnnotation(Annotation.FromDescription(ANNOTATION_DESCRIPTION));
testClock.AdvanceTime(Duration.Create(0, 100));
span.AddAnnotation(ANNOTATION_DESCRIPTION, attributes);
testClock.AdvanceTime(Duration.Create(0, 100));
IMessageEvent networkEvent =
MessageEvent.Builder(MessageEventType.RECEIVED, 1).SetUncompressedMessageSize(3).Build();
span.AddMessageEvent(networkEvent);
ILink link = Link.FromSpanContext(spanContext, LinkType.CHILD_LINKED_SPAN);
span.AddLink(link);
testClock.AdvanceTime(Duration.Create(0, 100));
span.End(EndSpanOptions.Builder().SetStatus(Status.CANCELLED).Build());
ISpanData spanData = ((Span)span).ToSpanData();
Assert.Equal(spanContext, spanData.Context);
Assert.Equal(SPAN_NAME, spanData.Name);
Assert.Equal(parentSpanId, spanData.ParentSpanId);
Assert.False(spanData.HasRemoteParent);
Assert.Equal(0, spanData.Attributes.DroppedAttributesCount);
Assert.Equal(expectedAttributes, spanData.Attributes.AttributeMap);
Assert.Equal(0, spanData.Annotations.DroppedEventsCount);
Assert.Equal(2, spanData.Annotations.Events.Count);
Assert.Equal(timestamp.AddNanos(100), spanData.Annotations.Events[0].Timestamp);
Assert.Equal(Annotation.FromDescription(ANNOTATION_DESCRIPTION), spanData.Annotations.Events[0].Event);
Assert.Equal(timestamp.AddNanos(200), spanData.Annotations.Events[1].Timestamp);
Assert.Equal(Annotation.FromDescriptionAndAttributes(ANNOTATION_DESCRIPTION, attributes), spanData.Annotations.Events[1].Event);
Assert.Equal(0, spanData.MessageEvents.DroppedEventsCount);
Assert.Equal(1, spanData.MessageEvents.Events.Count);
Assert.Equal(timestamp.AddNanos(300), spanData.MessageEvents.Events[0].Timestamp);
Assert.Equal(networkEvent, spanData.MessageEvents.Events[0].Event);
Assert.Equal(0, spanData.Links.DroppedLinksCount);
Assert.Equal(1, spanData.Links.Links.Count);
Assert.Equal(link, spanData.Links.Links[0]);
Assert.Equal(timestamp, spanData.StartTimestamp);
Assert.Equal(Status.CANCELLED, spanData.Status);
Assert.Equal(timestamp.AddNanos(400), spanData.EndTimestamp);
var startEndMock = Mock.Get <IStartEndHandler>(startEndHandler);
var spanBase = span as SpanBase;
startEndMock.Verify(s => s.OnStart(spanBase), Times.Once);
startEndMock.Verify(s => s.OnEnd(spanBase), Times.Once);
}
async void HandleMessage (IMessageEvent message)
{
try {
Android.Util.Log.Info ("WearIntegration", "Received Message");
var client = new GoogleApiClientBuilder (this)
.AddApi (LocationServices.API)
.AddApi (WearableClass.API)
.Build ();
var result = client.BlockingConnect (30, Java.Util.Concurrent.TimeUnit.Seconds);
if (!result.IsSuccess)
return;
var path = message.Path;
try {
var stations = Hubway.Instance.LastStations;
if (stations == null)
stations = await Hubway.Instance.GetStations ();
if (path.StartsWith (SearchStationPath)) {
var lastLocation = LocationServices.FusedLocationApi.GetLastLocation (client);
if (lastLocation == null)
return;
var currentPoint = new GeoPoint {
Lat = lastLocation.Latitude,
Lon = lastLocation.Longitude
};
var nearestStations = Hubway.GetStationsAround (stations, currentPoint, maxItems: 6, minDistance: double.MaxValue);
var favManager = FavoriteManager.Obtain (this);
var favorites = await favManager.GetFavoriteStationIdsAsync ();
var request = PutDataMapRequest.Create (SearchStationPath + "/Answer");
var map = request.DataMap;
var stationMap = new List<DataMap> ();
foreach (var station in nearestStations) {
var itemMap = new DataMap ();
itemMap.PutInt ("Id", station.Id);
var asset = await CreateWearAssetFrom (station);
itemMap.PutAsset ("Background", asset);
string secondary;
string primary = StationUtils.CutStationName (station.Name, out secondary);
itemMap.PutString ("Primary", primary);
itemMap.PutString ("Secondary", secondary);
var distance = GeoUtils.Distance (currentPoint, station.Location);
itemMap.PutDouble ("Distance", distance);
itemMap.PutDouble ("Lat", station.Location.Lat);
itemMap.PutDouble ("Lon", station.Location.Lon);
itemMap.PutInt ("Bikes", station.BikeCount);
itemMap.PutInt ("Racks", station.EmptySlotCount);
itemMap.PutBoolean ("IsFavorite", favorites.Contains (station.Id));
stationMap.Add (itemMap);
}
map.PutDataMapArrayList ("Stations", stationMap);
map.PutLong ("UpdatedAt", DateTime.UtcNow.Ticks);
await WearableClass.DataApi.PutDataItem (client, request.AsPutDataRequest ());
} else {
var uri = new Uri ("wear://watch" + path);
var query = uri.GetComponents (UriComponents.Query, UriFormat.Unescaped);
var parts = uri.GetComponents (UriComponents.Path, UriFormat.Unescaped).Split ('/');
var action = parts[parts.Length - 2];
var id = int.Parse (parts.Last ());
if (action == FavoriteAction) {
var favorites = FavoriteManager.Obtain (this);
handler.Post (() => {
if (query == "add")
favorites.AddToFavorite (id);
else
favorites.RemoveFromFavorite (id);
});
}
}
} finally {
client.Disconnect ();
}
} catch (Exception e) {
Android.Util.Log.Error ("WearIntegration", e.ToString ());
AnalyticsHelper.LogException ("WearIntegration", e);
}
}
public TopicSubscriber(string topic, IMessageEvent msgEvent)
{
_regex = new Regex(topic, RegexOptions.Compiled);
_msgEvent = msgEvent;
}
/// <summary>
/// 异步处理 - 发送到消息中间件
/// </summary>
private void AsyncHandle(IMessageEvent messageEvent)
{
MessageEventBus?.Publish(messageEvent);
}
public void OnMessageReceived (IMessageEvent messageEvent)
{
if (messageEvent.Path == Common.UserNotLoggedInPath) {
adapter.Timer.UserLoggedIn = false;
Task.Run (() => {
Task.Delay (RebindTime);
RequestSync();
});
}
}
