public override void OnDataChanged(DataEventBuffer dataEvents)
{
var dataEvent = Enumerable.Range(0, dataEvents.Count)
.Select(i => dataEvents.Get(i).JavaCast <IDataEvent>())
.FirstOrDefault(x => x.Type == DataEvent.TypeChanged && x.DataItem.Uri.Path.Equals(syncPath));
if (dataEvent == null)
{
return;
}
//get data from wearable
var dataMapItem = DataMapItem.FromDataItem(dataEvent.DataItem);
var map = dataMapItem.DataMap;
int heartRate = dataMapItem.DataMap.GetInt("heartratedata");
System.Diagnostics.Debug.WriteLine("luku: " + heartRate);
//send data to MainActivity
Intent intent = new Intent();
intent.SetAction(Intent.ActionSend);
intent.PutExtra("HeartRateFromWear", heartRate);
LocalBroadcastManager.GetInstance(this).SendBroadcast(intent);
}
public override void OnDataChanged(DataEventBuffer dataEvents)
{
// Only handle data changes if
// DataSync is on,
// App hasn't been setup yet,
// Or if we are setup but want to change location and sync data (SetupSyncActivity)
if (Settings.DataSync != WearableDataSync.Off || AcceptDataUpdates)
{
foreach (IDataEvent @event in dataEvents)
{
if (@event.Type == DataEvent.TypeChanged)
{
IDataItem item = @event.DataItem;
if (item.Uri.Path.CompareTo(WearableHelper.SettingsPath) == 0)
{
DataMap dataMap = DataMapItem.FromDataItem(item).DataMap;
UpdateSettings(dataMap);
}
else if (item.Uri.Path.CompareTo(WearableHelper.LocationPath) == 0)
{
DataMap dataMap = DataMapItem.FromDataItem(item).DataMap;
UpdateLocation(dataMap);
}
else if (item.Uri.Path.CompareTo(WearableHelper.WeatherPath) == 0)
{
DataMap dataMap = DataMapItem.FromDataItem(item).DataMap;
Task.Run(async() => await UpdateWeather(dataMap));
}
}
}
}
}
public override void OnDataChanged (DataEventBuffer buffer)
{
if (Log.IsLoggable (TAG, LogPriority.Debug))
Log.Debug (TAG, "OnDataChanged: " + buffer + " for " + PackageName);
for (int i = 0; i < buffer.Count; i++) {
IDataEvent e = Android.Runtime.Extensions.JavaCast<IDataEvent> (buffer.Get (i));
if (e.Type == DataEvent.TypeDeleted) {
Log.Info (TAG, e + " deleted");
} else if (e.Type == DataEvent.TypeChanged) {
bool alarmOn = (bool)DataMap.FromByteArray (e.DataItem.GetData ()).Get (FIELD_ALARM_ON);
if (!alarmOn) {
orig_volume = audio_manager.GetStreamVolume (Android.Media.Stream.Alarm);
media_player.Reset ();
audio_manager.SetStreamVolume (Android.Media.Stream.Alarm, max_volume, 0);
media_player.SetAudioStreamType (Android.Media.Stream.Alarm);
try {
media_player.SetDataSource (ApplicationContext, alarm_sound);
media_player.Prepare ();
} catch (IOException ex) {
Log.Error (TAG, "Failed to prepare media player to play alarm.", ex);
}
media_player.Start ();
} else {
audio_manager.SetStreamVolume (Android.Media.Stream.Alarm, orig_volume, 0);
if (media_player.IsPlaying)
media_player.Stop ();
}
}
}
buffer.Close ();
}
public override void OnDataChanged(DataEventBuffer dataEvents)
{
Console.WriteLine("Data Changed: " + dataEvents.Count);
for (int i = 0; i < dataEvents.Count; i++)
{
var d = dataEvents.Get(i).JavaCast <IDataEvent> ();
if (d.Type == DataEvent.TypeChanged)
{
try {
var settings = Settings.Deserialize(d.DataItem.GetData());
Settings = settings;
Settings.Save();
Console.WriteLine("Saved Settings... " + settings);
if (WatchfaceActivity != null)
{
try { WatchfaceActivity.UpdateSettings(); }
catch { }
}
} catch (Exception ex) {
Console.WriteLine("Bad Message Data: " + ex);
}
}
}
}
public override void OnDataChanged (DataEventBuffer dataEvents)
{
LOGD (Tag, "OnDataChanged: " + dataEvents);
IList events = FreezableUtils.FreezeIterable (dataEvents);
dataEvents.Close ();
if (!googleApiClient.IsConnected) {
ConnectionResult connectionResult = googleApiClient.BlockingConnect (30, TimeUnit.Seconds);
if (!connectionResult.IsSuccess) {
Log.Error (Tag, "DataLayerListenerService failed to connect to GoogleApiClient");
return;
}
}
// Loop through the events and send a message back to the node that created the data item
foreach (var ev in events) {
var e = ((Java.Lang.Object)ev).JavaCast<IDataEvent> ();
var uri = e.DataItem.Uri;
if (CountPath.Equals (CountPath)) {
// Get the node ID of the node that created the date item from the host portion of the Uri
string nodeId = uri.Host;
// Set the data of the message to the bytes of the Uri
byte[] payload = Encoding.UTF8.GetBytes (uri.ToString ());
// Send the rpc
WearableClass.MessageApi.SendMessage (googleApiClient, nodeId, DataItemReceivedPath, payload);
}
}
}
public void OnDataChanged(DataEventBuffer dataEvents)
{
var events = FreezableUtils.FreezeIterable(dataEvents);
dataEvents.Close();
foreach (var ev in events)
{
var dataEvent = ((Java.Lang.Object)ev).JavaCast <IDataEvent> ();
if (dataEvent.Type != DataEvent.TypeChanged)
{
continue;
}
var dataItem = dataEvent.DataItem;
if (!dataItem.Uri.Path.Equals(DigitalWatchFaceUtil.PathWithFeature))
{
continue;
}
var dataMapItem = DataMapItem.FromDataItem(dataItem);
var config = dataMapItem.DataMap;
if (Log.IsLoggable(Tag, LogPriority.Debug))
{
Log.Debug(Tag, "Config DataItem updated: " + config);
}
UpdateUiForConfigDataMap(config);
}
}
public override void OnDataChanged(DataEventBuffer dataEvents)
{
for (int i = 0; i < dataEvents.Count; i++)
{
var dataEvent = dataEvents.Get(i).JavaCast <IDataEvent> ();
if (dataEvent.Type == DataEvent.TypeChanged)
{
DataMap dataMap = DataMapItem.FromDataItem(dataEvent.DataItem).DataMap;
var content = dataMap.GetString(Constants.KeyContent);
var title = dataMap.GetString(Constants.KeyTitle);
if (Constants.WatchOnlyPath.Equals(dataEvent.DataItem.Uri.Path))
{
BuildWearableOnlyNotification(title, content, false);
}
else if (Constants.BothPath.Equals(dataEvent.DataItem.Uri.Path))
{
BuildWearableOnlyNotification(title, content, true);
}
}
else if (dataEvent.Type == DataEvent.TypeDeleted)
{
if (Log.IsLoggable(Tag, LogPriority.Debug))
{
Log.Debug(Tag, "DataItem deleted: " + dataEvent.DataItem.Uri.Path);
}
if (Constants.BothPath.Equals(dataEvent.DataItem.Uri.Path))
{
((NotificationManager)GetSystemService(NotificationService)).Cancel(Constants.BothId);
}
}
}
}
public override void OnDataChanged (DataEventBuffer dataEvents)
{
Console.WriteLine ("Data Changed: " + dataEvents.Count);
for (int i = 0; i < dataEvents.Count; i++) {
var d = dataEvents.Get (i).JavaCast<IDataEvent> ();
if (d.Type == DataEvent.TypeChanged) {
try {
var settings = Settings.Deserialize (d.DataItem.GetData ());
Settings = settings;
Settings.Save ();
Console.WriteLine ("Saved Settings... " + settings);
if (WatchfaceActivity != null) {
try { WatchfaceActivity.UpdateSettings (); }
catch { }
}
} catch (Exception ex) {
Console.WriteLine ("Bad Message Data: " + ex);
}
}
}
}
public override void OnDataChanged(DataEventBuffer dataEvents)
{
var setting = Settings.LoadSettings();
foreach (var dataEvent in dataEvents.ToEnumerable <IDataEvent>().Where(d => d.Type == DataEvent.TypeChanged))
{
var dataMapItem = DataMapItem.FromDataItem(dataEvent.DataItem);
var map = dataMapItem.DataMap;
switch (dataMapItem.Uri.Path)
{
case DataItemInfo.PathMode:
setting.Mode = (Settings.EMode)map.GetInt("0");
break;
case DataItemInfo.PathLeftCamera:
setting.LeftCamValue = map.GetInt("128");
break;
case DataItemInfo.PathRightCamera:
setting.RightCamValue = map.GetInt("128");
break;
}
}
}
public override void OnDataChanged(DataEventBuffer dataEvents)
{
if (Log.IsLoggable(Constants.TAG, LogPriority.Debug))
{
Log.Debug(Constants.TAG, "OnDataChanged: " + dataEvents + " for " + PackageName);
}
try
{
for (int i = 0; i < dataEvents.Count; i++)
{
var et = dataEvents.Get(i).JavaCast <IDataEvent> ();
if (et.Type == DataEvent.TypeDeleted)
{
DeleteDataItem(et.DataItem);
}
else if (et.Type == DataEvent.TypeChanged)
{
UpdateNotificationForDataItem(et.DataItem);
}
}
}
catch (Exception ex) {
if (Log.IsLoggable(Constants.TAG, LogPriority.Error))
{
Log.Error(Constants.TAG, "OnDataChanged error: " + ex);
}
}
}
public void OnDataChanged(DataEventBuffer dataEvents)
{
var events = FreezableUtils.FreezeIterable(dataEvents);
dataEvents.Close();
RunOnUiThread(() => {
foreach (var ev in events)
{
var e = ((Java.Lang.Object)ev).JavaCast <IDataEvent> ();
if (e.Type == DataEvent.TypeChanged)
{
var dataMap = DataMapItem.FromDataItem(e.DataItem).DataMap;
var questionWasAnswered = dataMap.GetBoolean(Constants.QUESTION_WAS_ANSWERED);
var questionWasDeleted = dataMap.GetBoolean(Constants.QUESTION_WAS_DELETED);
if (questionWasAnswered)
{
int questionIndex = dataMap.GetInt(Constants.QUESTION_INDEX);
bool questionCorrect = dataMap.GetBoolean(Constants.CHOSEN_ANSWER_CORRECT);
UpdateQuestionStatus(questionIndex, questionCorrect);
AskNextQuestionIfExists();
}
else if (questionWasDeleted)
{
int questionIndex = dataMap.GetInt(Constants.QUESTION_INDEX);
MarkQuestionLeftBlank(questionIndex);
AskNextQuestionIfExists();
}
}
}
});
}
public void OnDataChanged(DataEventBuffer dataEvents)
{
if (!googleApiClient.IsConnected)
{
var connectionResult = googleApiClient.BlockingConnect(30, TimeUnit.Seconds);
if (!connectionResult.IsSuccess)
{
Log.Error(Tag, "DataLayerListenerService failed to connect to GoogleApiClient");
return;
}
}
adapter.Timer.UserLoggedIn = true;
foreach (var data in dataEvents)
{
if (data != null && data.Type == DataEvent.TypeChanged && data.DataItem.Uri.Path == Common.TimeEntryListPath)
{
OnDataChanged(data.DataItem);
}
}
if (CollectionChanged != null)
{
CollectionChanged(this, EventArgs.Empty);
}
}
public override async void OnDataChanged(DataEventBuffer dataEvents)
{
LOGD(Tag, "OnDataChanged: " + dataEvents);
IList events = FreezableUtils.FreezeIterable(dataEvents);
dataEvents.Close();
if (!googleApiClient.IsConnected)
{
ConnectionResult connectionResult = googleApiClient.BlockingConnect(30, TimeUnit.Seconds);
if (!connectionResult.IsSuccess)
{
Log.Error(Tag, "DataLayerListenerService failed to connect to GoogleApiClient");
return;
}
}
// Loop through the events and send a message back to the node that created the data item
foreach (var ev in events)
{
var e = ((Java.Lang.Object)ev).JavaCast <IDataEvent> ();
var uri = e.DataItem.Uri;
if (CountPath.Equals(CountPath))
{
// Get the node ID of the node that created the date item from the host portion of the Uri
string nodeId = uri.Host;
// Set the data of the message to the bytes of the Uri
byte[] payload = Encoding.UTF8.GetBytes(uri.ToString());
// Send the rpc
await WearableClass.MessageApi.SendMessageAsync(googleApiClient, nodeId, DataItemReceivedPath, payload);
}
}
}
public void OnDataChanged(DataEventBuffer dataEvents)
{
var dataEvent = Enumerable.Range(0, dataEvents.Count)
.Select(i => dataEvents.Get(i).JavaCast<IDataEvent>())
.FirstOrDefault(de => de.Type == DataEvent.TypeChanged && de.DataItem.Uri.Path == TweetsPath + "/Answer");
if (dataEvent == null)
return;
var dataMapItem = DataMapItem.FromDataItem(dataEvent.DataItem);
var map = dataMapItem.DataMap;
var tweets = new List<Tweet>();
var data = map.GetDataMapArrayList("Tweets");
foreach (var d in data)
{
tweets.Add(new Tweet
{
ScreenName = d.GetString("ScreenName", "<no name>"),
Text = d.GetString("Text", "<no name>"),
CreatedAt = new DateTime(d.GetLong("CreatedAt", DateTime.Now.Ticks))
});
}
if (tweets.Any())
{
handler.Post(() =>
{
var adapter = new TweetAdapter(FragmentManager,
tweets);
viewPager.Adapter = adapter;
viewPager.OffscreenPageCount = 5;
progress.Visibility = ViewStates.Gone;
viewPager.Visibility = ViewStates.Visible;
});
}
}
public void OnDataChanged(DataEventBuffer dataEvents)
{
var dataEvent = Enumerable.Range(0, dataEvents.Count)
.Select(i => dataEvents.Get(i).JavaCast<IDataEvent>())
.FirstOrDefault(x => x.Type == DataEvent.TypeChanged && x.DataItem.Uri.Path.Equals(_syncPath));
if (dataEvent == null)
return;
//do stuffs here
}
public override void OnDataChanged (DataEventBuffer dataEvents)
{
if (!googleApiClient.IsConnected) {
ConnectionResult connectionResult = googleApiClient.BlockingConnect (30, TimeUnit.Seconds);
if (!connectionResult.IsSuccess) {
Log.Error (Tag, "DataLayerListenerService failed to connect to GoogleApiClient");
return;
}
}
}
public override void OnDataChanged(DataEventBuffer dataEvents)
{
base.OnDataChanged(dataEvents);
foreach (var ev in dataEvents)
{
var e = ((Java.Lang.Object)ev).JavaCast <IDataEvent>();
if (e.Type == DataEvent.TypeChanged)
{
String path = e.DataItem.Uri.Path;
if (path.StartsWith(StylistConstants.StatusPath + StylistConstants.AnswerPath, StringComparison.CurrentCulture))
{
DataMapItem dataMapItem = DataMapItem.FromDataItem(e.DataItem);
var statusDataMap = dataMapItem.DataMap.GetDataMap(StylistConstants.StatusKey);
bool loggedIn = statusDataMap.GetBoolean(StylistConstants.LoggedInKey);
bool isPro = statusDataMap.GetBoolean(StylistConstants.IsProKey);
if (StylistConstants.STRICT_CHECK)
{
if (!loggedIn)
{
var notLoggedInIntent = new Intent(Application.Context, typeof(NotAllowedActivity));
StartActivity(notLoggedInIntent);
Finish();
return;
}
else if (!isPro)
{
var NotProIntent = new Intent(Application.Context, typeof(NotAllowedActivity));
StartActivity(NotProIntent);
Finish();
return;
}
}
Intent intent = new Intent(Application.Context, typeof(WearListActivity));
StartActivity(intent);
Finish();
}
else
{
Log.Info(tag, "Unrecognized path: " + path);
}
}
else if (e.Type == DataEvent.TypeDeleted)
{
Log.Info("Unknown data event type", "Type = " + e.Type);
}
else
{
Log.Info("Unknown data event type", "Type = " + e.Type);
}
}
}
public override void OnDataChanged (DataEventBuffer dataEvents)
{
for (int i = 0; i < dataEvents.Count; i++) {
IDataEvent dataEvent = Java.Interop.JavaObjectExtensions.JavaCast<IDataEvent>(dataEvents.Get (i));
if (dataEvent.Type == DataEvent.TypeDeleted) {
if (Constants.BothPath.Equals (dataEvent.DataItem.Uri.Path)) {
// Notification on the phone should be dismissed
NotificationManagerCompat.From (this).Cancel (Constants.BothId);
}
}
}
}
private async Task OnDataChangedAsync(DataEventBuffer dataEvents)
{
if (localNodeId == null)
{
GoogleApiClient googleApiClient = new GoogleApiClient.Builder(this)
.AddApi(WearableClass.API)
.Build();
googleApiClient.Connect();
localNodeId = (await WearableClass.NodeApi.GetLocalNodeAsync(googleApiClient).ConfigureAwait(false)).Node.Id;
}
ISharedPreferences settings = string.IsNullOrEmpty(sharedPrefsName) ?
PreferenceManager.GetDefaultSharedPreferences(this) :
GetSharedPreferences(sharedPrefsName, FileCreationMode.Private);
ISharedPreferencesEditor editor = settings.Edit();
IDictionary <string, object> allPrefs = settings.All;
try
{
foreach (IDataEvent ev in dataEvents)
{
IDataItem dataItem = ev.DataItem;
Android.Net.Uri uri = dataItem.Uri;
var nodeId = uri.Host;
if (nodeId.Equals(localNodeId))
{
// Change originated on this device.
continue;
}
if (uri.Path.StartsWith(DATA_SETTINGS_PATH))
{
if (ev.Type == DataEvent.TypeDeleted)
{
DeleteItem(uri, editor, allPrefs);
}
else
{
SaveItem(dataItem, editor, allPrefs);
}
}
}
}
finally
{
// We don't use Apply() because we don't know what thread we're on.
editor.Commit();
}
base.OnDataChanged(dataEvents);
}
public override void OnDataChanged(DataEventBuffer dataEvents)
{
if (!googleApiClient.IsConnected)
{
ConnectionResult connectionResult = googleApiClient.BlockingConnect(30, TimeUnit.Seconds);
if (!connectionResult.IsSuccess)
{
Log.Error(Tag, "DataLayerListenerService failed to connect to GoogleApiClient");
return;
}
}
}
public void OnDataChanged(DataEventBuffer p0)
{
Console.WriteLine(string.Format("Communicator: Data changed ({0} data events)", p0.Count));
for (var i = 0; i < p0.Count; i++)
{
var dataEvent = p0.Get(i).JavaCast <IDataEvent>();
if (dataEvent.Type == DataEvent.TypeChanged && dataEvent.DataItem.Uri.Path == path)
{
DataReceived(DataMapItem.FromDataItem(dataEvent.DataItem).DataMap);
}
}
}
// Implementing IDataApiDataListener interface
// On data changed we want invoke event
public void OnDataChanged(DataEventBuffer p0)
{
Log.Info("my_log", "Communicator: Data changed (" + p0.Count + " data events)");
for (var i = 0; i < p0.Count; i++)
{
var dataEvent = p0.Get(i).JavaCast <IDataEvent>();
if (dataEvent.Type == DataEvent.TypeChanged && dataEvent.DataItem.Uri.Path == path)
{
DataReceived(DataMapItem.FromDataItem(dataEvent.DataItem).DataMap);
}
}
}
public void OnDataChanged(DataEventBuffer dataEvents)
{
var dataEvent = Enumerable.Range(0, dataEvents.Count)
.Select(i => JavaObjectExtensions.JavaCast <IDataEvent>(dataEvents.Get(i)))
.FirstOrDefault(x => x.Type == DataEvent.TypeChanged && x.DataItem.Uri.Path.Equals(MessagePath));
if (dataEvent == null)
{
return;
}
//do stuffs here
}
public void OnDataChanged(DataEventBuffer dataEvents)
{
Log.Debug(Tag, "On Data Changed");
foreach (var dataEvent in dataEvents)
{
var dataItem = dataEvent.DataItem;
if (dataItem.Uri.Path == "/xfit_watchface")
{
var dataMap = DataMapItem.FromDataItem(dataItem).DataMap;
displayStepCount = dataMap.GetBoolean("stepcount");
Invalidate(); // force redraw in case we're in ambient mode
}
}
}
public void OnDataChanged(DataEventBuffer dataEvents)
{
Log.Debug(Tag, "On Data Changed");
foreach (var dataEvent in dataEvents)
{
var dataItem = dataEvent.DataItem;
if (dataItem.Uri.Path == "/xfit_watchface")
{
var dataMap = DataMapItem.FromDataItem(dataItem).DataMap;
stepCountOn = dataMap.GetBoolean("stepcount");
UpdateUI();
}
}
}
public override void OnDataChanged(DataEventBuffer dataEvents)
{
for (int i = 0; i < dataEvents.Count; i++)
{
IDataEvent dataEvent = Java.Interop.JavaObjectExtensions.JavaCast <IDataEvent>(dataEvents.Get(i));
if (dataEvent.Type == DataEvent.TypeDeleted)
{
if (Constants.BothPath.Equals(dataEvent.DataItem.Uri.Path))
{
// Notification on the phone should be dismissed
NotificationManagerCompat.From(this).Cancel(Constants.BothId);
}
}
}
}
public void OnDataChanged(DataEventBuffer dataEvents)
{
Log.Debug(Tag, "On Data Changed");
foreach (var dataEvent in dataEvents)
{
var dataItem = dataEvent.DataItem;
if (dataItem.Uri.Path == "/xfit_watchface")
{
var dataMap = DataMapItem.FromDataItem(dataItem).DataMap;
displayStepCount = dataMap.GetBoolean("stepcount");
Invalidate(); // force redraw in case we're in ambient mode
}
}
}
public override void OnDataChanged(DataEventBuffer buffer)
{
if (Log.IsLoggable(TAG, LogPriority.Debug))
{
Log.Debug(TAG, "OnDataChanged: " + buffer + " for " + PackageName);
}
for (int i = 0; i < buffer.Count; i++)
{
IDataEvent e = Android.Runtime.Extensions.JavaCast <IDataEvent>(buffer.Get(i));
if (e.Type == DataEvent.TypeDeleted)
{
Log.Info(TAG, e + " deleted");
}
else if (e.Type == DataEvent.TypeChanged)
{
bool alarmOn = (bool)DataMap.FromByteArray(e.DataItem.GetData()).Get(FIELD_ALARM_ON);
if (!alarmOn)
{
orig_volume = audio_manager.GetStreamVolume(Android.Media.Stream.Alarm);
media_player.Reset();
max_volume = 0;
audio_manager.SetStreamVolume(Android.Media.Stream.Alarm, max_volume, 0);
media_player.SetAudioStreamType(Android.Media.Stream.Alarm);
try
{
media_player.SetDataSource(ApplicationContext, alarm_sound);
media_player.Prepare();
}
catch (IOException ex)
{
Log.Error(TAG, "Failed to prepare media player to play alarm.", ex);
}
media_player.Start();
}
else
{
audio_manager.SetStreamVolume(Android.Media.Stream.Alarm, orig_volume, 0);
if (media_player.IsPlaying)
{
media_player.Stop();
}
}
}
}
buffer.Close();
}
/// <summary>
/// Listens for DataItems added/deleted from the geofence service running on the companion
/// </summary>
public override void OnDataChanged (DataEventBuffer dataEvents)
{
if (Log.IsLoggable (Constants.TAG, LogPriority.Debug))
Log.Debug (Constants.TAG, "OnDataChanged: " + dataEvents + " for " + PackageName);
for (int i = 0; i < dataEvents.Count; i++) {
var dEvent = dataEvents.Get (i).JavaCast<IDataEvent> ();
if (dEvent.Type == DataEvent.TypeDeleted) {
CancelNotificationForDataItem (dEvent.DataItem);
} else if (dEvent.Type == DataEvent.TypeChanged) {
// The user has entered a geofence - post a notification!
String geofenceId = DataMap.FromByteArray (dEvent.DataItem.GetData ()).GetString (Constants.KEY_GEOFENCE_ID);
PostNotificationForGeofenceId (geofenceId, dEvent.DataItem.Uri);
}
}
}
public void OnDataChanged(DataEventBuffer dataEvents)
{
var dataEvent = Enumerable.Range(0, dataEvents.Count)
.Select(i => dataEvents.Get(i).JavaCast <IDataEvent> ())
.FirstOrDefault(de => de.Type == DataEvent.TypeChanged && de.DataItem.Uri.Path == SearchStationPath + "/Answer");
if (dataEvent == null)
{
return;
}
var dataMapItem = DataMapItem.FromDataItem(dataEvent.DataItem);
var map = dataMapItem.DataMap;
var data = map.GetDataMapArrayList("Stations");
ProcessRawStationData(data);
}
public void OnDataChanged(DataEventBuffer dataEvents)
{
var dataEvent = Enumerable.Range(0, dataEvents.Count)
.Select(i => dataEvents.Get(i).JavaCast <IDataEvent> ())
.FirstOrDefault(de => de.Type == DataEvent.TypeChanged && de.DataItem.Uri.Path == SearchStationPath + "/Answer");
if (dataEvent == null)
{
return;
}
var dataMapItem = DataMapItem.FromDataItem(dataEvent.DataItem);
var map = dataMapItem.DataMap;
var stations = new List <SimpleStation> ();
var data = map.GetDataMapArrayList("Stations");
foreach (var d in data)
{
stations.Add(new SimpleStation {
Id = d.GetInt("Id", 0),
Primary = d.GetString("Primary", "<no name>"),
Secondary = d.GetString("Secondary", "<no name>"),
Background = GetBitmapForAsset(d.GetAsset("Background")),
Bikes = d.GetInt("Bikes", 0),
Racks = d.GetInt("Racks", 0),
Distance = d.GetDouble("Distance", 0),
Lat = d.GetDouble("Lat", 0),
Lon = d.GetDouble("Lon", 0),
IsFavorite = d.GetBoolean("IsFavorite", false),
});
}
if (stations.Any())
{
handler.Post(() => {
adapter = new StationGridAdapter(FragmentManager,
stations,
this);
pager.Adapter = adapter;
pager.OffscreenPageCount = 5;
loading.Visibility = ViewStates.Invisible;
pager.Visibility = ViewStates.Visible;
countSwitch.Visibility = ViewStates.Visible;
dotsIndicator.Visibility = ViewStates.Visible;
});
}
}
public void OnDataChanged(DataEventBuffer dataEvents)
{
var dataEvent = Enumerable.Range(0, dataEvents.Count)
.Select(i => dataEvents.Get(i).JavaCast <IDataEvent>())
.FirstOrDefault(x => x.Type == DataEvent.TypeChanged && x.DataItem.Uri.Path.Equals(SYNC_PATH));
if (dataEvent == null)
{
return;
}
//get data from watch
var dataMapItem = DataMapItem.FromDataItem(dataEvent.DataItem);
var map = dataMapItem.DataMap;
tapCount = int.Parse(dataMapItem.DataMap.GetString("TapCounter"));
lblTapCounter.Text = tapCount.ToString();
}
public override void OnDataChanged(DataEventBuffer dataEvents)
{
var dataEvent = Enumerable.Range(0, dataEvents.Count)
.Select(i => dataEvents.Get(i).JavaCast<IDataEvent>())
.FirstOrDefault(x => x.Type == DataEvent.TypeChanged && x.DataItem.Uri.Path.Equals(_syncPath));
if (dataEvent == null)
return;
//get data from wearable
var dataMapItem = DataMapItem.FromDataItem(dataEvent.DataItem);
var map = dataMapItem.DataMap;
string message = dataMapItem.DataMap.GetString("Message");
Intent intent = new Intent();
intent.SetAction(Intent.ActionSend);
intent.PutExtra("WearMessage", message);
LocalBroadcastManager.GetInstance(this).SendBroadcast(intent);
}
public async void OnDataChanged(DataEventBuffer dataEvents)
{
DataLayerListenerService.LOGD(Tag, "OnDatachanged() : " + dataEvents);
IList events = FreezableUtils.FreezeIterable(dataEvents);
dataEvents.Release();
foreach (var ev in events)
{
var e = ((Java.Lang.Object)ev).JavaCast <IDataEvent> ();
if (e.Type == DataEvent.TypeChanged)
{
String path = e.DataItem.Uri.Path;
if (DataLayerListenerService.ImagePath.Equals(path))
{
DataMapItem dataMapItem = DataMapItem.FromDataItem(e.DataItem);
Asset photo = dataMapItem.DataMap.GetAsset(DataLayerListenerService.ImageKey);
Bitmap bitmap = await LoadBitmapFromAsset(googleApiClient, photo);
handler.Post(() => {
DataLayerListenerService.LOGD(Tag, "Setting background image..");
layout.SetBackgroundDrawable(new BitmapDrawable(Resources, bitmap));
});
}
else if (DataLayerListenerService.CountPath.Equals(path))
{
DataLayerListenerService.LOGD(Tag, "Data Chaged for CountPath");
GenerateEvent("DataItem Changed", e.DataItem.ToString());
}
else
{
DataLayerListenerService.LOGD(Tag, "Unrecognized path: " + path);
}
}
else if (e.Type == DataEvent.TypeDeleted)
{
GenerateEvent("DataItem Changed", e.DataItem.ToString());
}
else
{
DataLayerListenerService.LOGD("Unknown data event type", "Type = " + e.Type);
}
}
}
public override async void OnDataChanged (DataEventBuffer dataEvents)
{
if (Log.IsLoggable (Constants.TAG, LogPriority.Debug))
Log.Debug (Constants.TAG, "OnDataChanged: " + dataEvents + " for " + PackageName);
try
{
for (int i = 0; i < dataEvents.Count; i++) {
var et = dataEvents.Get (i).JavaCast <IDataEvent> ();
if (et.Type == DataEvent.TypeDeleted)
DeleteDataItem (et.DataItem);
else if (et.Type == DataEvent.TypeChanged)
await UpdateNotificationForDataItem (et.DataItem);
}
}
catch (Exception ex) {
if (Log.IsLoggable (Constants.TAG, LogPriority.Error))
Log.Error (Constants.TAG, "OnDataChanged error: " + ex);
}
}
/// <summary>
/// Receives data from handheld; this isn't really used, but is handy for connection tests and such
/// </summary>
/// <param name="dataEvents"></param>
public void OnDataChanged(DataEventBuffer dataEvents)
{
debugLog("Data changed");
dataStatusHandler.updateStatus("Data changed");
var dataEvent = Enumerable.Range(0, dataEvents.Count)
.Select(i => JavaObjectExtensions.JavaCast <IDataEvent>(dataEvents.Get(i)))
.FirstOrDefault(x => x.Type == DataEvent.TypeChanged && x.DataItem.Uri.Path.Equals(TestDataPath));
if (dataEvent == null)
{
return;
}
else
{
var dataMapItem = DataMapItem.FromDataItem(dataEvent.DataItem);
var map = dataMapItem.DataMap;
string message = dataMapItem.DataMap.GetString("Message");
debugLog("Test data actually received! message: " + message);
}
}
public override void OnDataChanged (DataEventBuffer dataEvents)
{
for (int i = 0; i < dataEvents.Count; i++) {
var dataEvent = dataEvents.Get (i).JavaCast<IDataEvent> ();
if (dataEvent.Type == DataEvent.TypeChanged) {
DataMap dataMap = DataMapItem.FromDataItem (dataEvent.DataItem).DataMap;
var content = dataMap.GetString (Constants.KeyContent);
var title = dataMap.GetString (Constants.KeyTitle);
if (Constants.WatchOnlyPath.Equals (dataEvent.DataItem.Uri.Path))
BuildWearableOnlyNotification (title, content, false);
else if (Constants.BothPath.Equals (dataEvent.DataItem.Uri.Path))
BuildWearableOnlyNotification (title, content, true);
} else if (dataEvent.Type == DataEvent.TypeDeleted) {
if (Log.IsLoggable (Tag, LogPriority.Debug))
Log.Debug (Tag, "DataItem deleted: " + dataEvent.DataItem.Uri.Path);
if (Constants.BothPath.Equals (dataEvent.DataItem.Uri.Path))
((NotificationManager)GetSystemService (NotificationService)).Cancel (Constants.BothId);
}
}
}
public override void OnDataChanged(DataEventBuffer dataEvents)
{
var dataEvent = Enumerable.Range(0, dataEvents.Count)
.Select(i => JavaObjectExtensions.JavaCast <IDataEvent>(dataEvents.Get(i)))
.FirstOrDefault(x => x.Type == DataEvent.TypeChanged && x.DataItem.Uri.Path.Equals(MessagePath));
if (dataEvent == null)
{
return;
}
//get data from wearable
var dataMapItem = DataMapItem.FromDataItem(dataEvent.DataItem);
var message = dataMapItem.DataMap.GetString("Message");
var intent = new Intent();
intent.SetAction(Intent.ActionSend);
intent.PutExtra("WearMessage", message);
LocalBroadcastManager.GetInstance(this).SendBroadcast(intent);
}
public void OnDataChanged (DataEventBuffer dataEvents)
{
if (!googleApiClient.IsConnected) {
var connectionResult = googleApiClient.BlockingConnect (30, TimeUnit.Seconds);
if (!connectionResult.IsSuccess) {
Log.Error (Tag, "DataLayerListenerService failed to connect to GoogleApiClient");
return;
}
}
adapter.Timer.UserLoggedIn = true;
foreach (var data in dataEvents) {
if (data != null && data.Type == DataEvent.TypeChanged && data.DataItem.Uri.Path == Common.TimeEntryListPath) {
OnDataChanged (data.DataItem);
}
}
if (CollectionChanged != null) {
CollectionChanged (this, EventArgs.Empty);
}
}
public void OnDataChanged(DataEventBuffer dataEvents)
{
var dataEvent = Enumerable.Range(0, dataEvents.Count)
.Select(i => dataEvents.Get(i).JavaCast <IDataEvent>())
.FirstOrDefault(de => de.Type == DataEvent.TypeChanged && de.DataItem.Uri.Path == TweetsPath + "/Answer");
if (dataEvent == null)
{
return;
}
var dataMapItem = DataMapItem.FromDataItem(dataEvent.DataItem);
var map = dataMapItem.DataMap;
var tweets = new List <Tweet>();
var data = map.GetDataMapArrayList("Tweets");
foreach (var d in data)
{
tweets.Add(new Tweet
{
ScreenName = d.GetString("ScreenName", "<no name>"),
Text = d.GetString("Text", "<no name>"),
CreatedAt = new DateTime(d.GetLong("CreatedAt", DateTime.Now.Ticks))
});
}
if (tweets.Any())
{
handler.Post(() =>
{
var adapter = new TweetAdapter(FragmentManager,
tweets);
viewPager.Adapter = adapter;
viewPager.OffscreenPageCount = 5;
progress.Visibility = ViewStates.Gone;
viewPager.Visibility = ViewStates.Visible;
});
}
}
/// <summary>
/// Listens for DataItems added/deleted from the geofence service running on the companion
/// </summary>
public override void OnDataChanged(DataEventBuffer dataEvents)
{
if (Log.IsLoggable(Constants.TAG, LogPriority.Debug))
{
Log.Debug(Constants.TAG, "OnDataChanged: " + dataEvents + " for " + PackageName);
}
for (int i = 0; i < dataEvents.Count; i++)
{
var dEvent = dataEvents.Get(i).JavaCast <IDataEvent> ();
if (dEvent.Type == DataEvent.TypeDeleted)
{
CancelNotificationForDataItem(dEvent.DataItem);
}
else if (dEvent.Type == DataEvent.TypeChanged)
{
// The user has entered a geofence - post a notification!
String geofenceId = DataMap.FromByteArray(dEvent.DataItem.GetData()).GetString(Constants.KEY_GEOFENCE_ID);
PostNotificationForGeofenceId(geofenceId, dEvent.DataItem.Uri);
}
}
}
public void OnDataChanged(DataEventBuffer dataEvents)
{
LOGD(Tag, "OnDataChanged: " + dataEvents);
var events = new List <IDataEvent> ();
events.AddRange(dataEvents);
//dataEvents.Close ();
RunOnUiThread(() => {
foreach (var ev in events)
{
if (ev.Type == DataEvent.TypeChanged)
{
dataItemListAdapter.Add(
new Event("DataItem Changed", ev.DataItem.ToString()));
}
else if (ev.Type == DataEvent.TypeDeleted)
{
dataItemListAdapter.Add(
new Event("DataItem Deleted", ev.DataItem.ToString()));
}
}
});
}
public void OnDataChanged(DataEventBuffer dataEvents)
{
LOGD(Tag, "OnDataChanged: " + dataEvents);
var events = FreezableUtils.FreezeIterable(dataEvents);
dataEvents.Close();
RunOnUiThread(() => {
foreach (var e in events)
{
var ev = ((Java.Lang.Object)e).JavaCast <IDataEvent>();
if (ev.Type == DataEvent.TypeChanged)
{
dataItemListAdapter.Add(
new Event("DataItem Changed", ev.DataItem.ToString()));
}
else if (ev.Type == DataEvent.TypeDeleted)
{
dataItemListAdapter.Add(
new Event("DataItem Deleted", ev.DataItem.ToString()));
}
}
});
}
public void OnDataChanged(DataEventBuffer dataEvents)
{
var events = FreezableUtils.FreezeIterable (dataEvents);
dataEvents.Close ();
foreach (var ev in events) {
var dataEvent = ((Java.Lang.Object)ev).JavaCast<IDataEvent> ();
if (dataEvent.Type != DataEvent.TypeChanged) {
continue;
}
var dataItem = dataEvent.DataItem;
if (!dataItem.Uri.Path.Equals (DigitalWatchFaceUtil.PathWithFeature)) {
continue;
}
var dataMapItem = DataMapItem.FromDataItem (dataItem);
var config = dataMapItem.DataMap;
if (Log.IsLoggable (Tag, LogPriority.Debug)) {
Log.Debug (Tag, "Config DataItem updated: " + config);
}
UpdateUiForConfigDataMap (config);
}
}
public override void OnDataChanged (DataEventBuffer eventBuffer)
{
var events = FreezableUtils.FreezeIterable (eventBuffer);
eventBuffer.Close ();
var google_api_client = new GoogleApiClientBuilder (this)
.AddApi (WearableClass.API)
.Build ();
var connectionResult = google_api_client.BlockingConnect (Constants.CONNECT_TIMEOUT_MS,
TimeUnit.Milliseconds);
if (!connectionResult.IsSuccess) {
Log.Error (TAG, "QuizListenerService failed to connect to GoogleApiClient.");
return;
}
foreach (var ev in events) {
var e = ((Java.Lang.Object)ev).JavaCast<IDataEvent> ();
if (e.Type == DataEvent.TypeChanged) {
var dataItem = e.DataItem;
var dataMap = DataMapItem.FromDataItem (dataItem).DataMap;
if (dataMap.GetBoolean (Constants.QUESTION_WAS_ANSWERED)
|| dataMap.GetBoolean (Constants.QUESTION_WAS_DELETED)) {
continue;
}
string question = dataMap.GetString (Constants.QUESTION);
int questionIndex = dataMap.GetInt (Constants.QUESTION_INDEX);
int questionNum = questionIndex + 1;
string[] answers = dataMap.GetStringArray (Constants.ANSWERS);
int correctAnswerIndex = dataMap.GetInt (Constants.CORRECT_ANSWER_INDEX);
Intent deleteOperation = new Intent (this, typeof(DeleteQuestionService));
deleteOperation.SetData (dataItem.Uri);
PendingIntent deleteIntent = PendingIntent.GetService (this, 0,
deleteOperation, PendingIntentFlags.UpdateCurrent);
//first page of notification contains question as Big Text.
var bigTextStyle = new Notification.BigTextStyle ()
.SetBigContentTitle (GetString (Resource.String.question, questionNum))
.BigText (question);
var builder = new Notification.Builder (this)
.SetStyle (bigTextStyle)
.SetSmallIcon (Resource.Drawable.ic_launcher)
.SetLocalOnly (true)
.SetDeleteIntent (deleteIntent);
//add answers as actions
var wearableOptions = new Notification.WearableExtender ();
for (int i = 0; i < answers.Length; i++) {
Notification answerPage = new Notification.Builder (this)
.SetContentTitle (question)
.SetContentText (answers [i])
.Extend (new Notification.WearableExtender ()
.SetContentAction (i))
.Build ();
bool correct = (i == correctAnswerIndex);
var updateOperation = new Intent (this, typeof(UpdateQuestionService));
//Give each intent a unique action.
updateOperation.SetAction ("question_" + questionIndex + "_answer_" + i);
updateOperation.SetData (dataItem.Uri);
updateOperation.PutExtra (UpdateQuestionService.EXTRA_QUESTION_INDEX, questionIndex);
updateOperation.PutExtra (UpdateQuestionService.EXTRA_QUESTION_CORRECT, correct);
var updateIntent = PendingIntent.GetService (this, 0, updateOperation,
PendingIntentFlags.UpdateCurrent);
Notification.Action action = new Notification.Action.Builder (
(int)question_num_to_drawable_id.Get (i), (string)null, updateIntent)
.Build ();
wearableOptions.AddAction (action).AddPage (answerPage);
}
builder.Extend (wearableOptions);
Notification notification = builder.Build ();
((NotificationManager)GetSystemService (NotificationService))
.Notify (questionIndex, notification);
} else if (e.Type == DataEvent.TypeDeleted) {
Android.Net.Uri uri = e.DataItem.Uri;
//URIs are in the form of "/question/0", "/question/1" etc.
//We use the question index as the notification id.
int notificationId = Java.Lang.Integer.ParseInt (uri.LastPathSegment);
((NotificationManager)GetSystemService (NotificationService))
.Cancel (notificationId);
}
((NotificationManager)GetSystemService (NotificationService))
.Cancel (QUIZ_REPORT_NOTIF_ID);
}
google_api_client.Disconnect ();
}
public void OnDataChanged(DataEventBuffer dataEvents)
{
var dataEvent = Enumerable.Range (0, dataEvents.Count)
.Select (i => dataEvents.Get (i).JavaCast<IDataEvent> ())
.FirstOrDefault (de => de.Type == DataEvent.TypeChanged && de.DataItem.Uri.Path == SearchStationPath + "/Answer");
if (dataEvent == null)
return;
var dataMapItem = DataMapItem.FromDataItem (dataEvent.DataItem);
var map = dataMapItem.DataMap;
var stations = new List<SimpleStation> ();
var data = map.GetDataMapArrayList ("Stations");
foreach (var d in data) {
stations.Add (new SimpleStation {
Id = d.GetInt ("Id", 0),
Primary = d.GetString ("Primary", "<no name>"),
Secondary = d.GetString ("Secondary", "<no name>"),
Background = GetBitmapForAsset (d.GetAsset ("Background")),
Bikes = d.GetInt ("Bikes", 0),
Racks = d.GetInt ("Racks", 0),
Distance = d.GetDouble ("Distance", 0),
Lat = d.GetDouble ("Lat", 0),
Lon = d.GetDouble ("Lon", 0),
IsFavorite = d.GetBoolean ("IsFavorite", false),
});
}
if (stations.Any ()) {
handler.Post (() => {
adapter = new StationGridAdapter (FragmentManager,
stations,
this);
pager.Adapter = adapter;
pager.OffscreenPageCount = 5;
loading.Visibility = ViewStates.Invisible;
pager.Visibility = ViewStates.Visible;
countSwitch.Visibility = ViewStates.Visible;
dotsIndicator.Visibility = ViewStates.Visible;
});
}
}
public void OnDataChanged (DataEventBuffer dataEvents)
{
var events = FreezableUtils.FreezeIterable (dataEvents);
dataEvents.Close ();
RunOnUiThread (() => {
foreach (var ev in events) {
var e = ((Java.Lang.Object)ev).JavaCast<IDataEvent> ();
if (e.Type == DataEvent.TypeChanged) {
var dataMap = DataMapItem.FromDataItem (e.DataItem).DataMap;
var questionWasAnswered = dataMap.GetBoolean (Constants.QUESTION_WAS_ANSWERED);
var questionWasDeleted = dataMap.GetBoolean (Constants.QUESTION_WAS_DELETED);
if (questionWasAnswered) {
int questionIndex = dataMap.GetInt (Constants.QUESTION_INDEX);
bool questionCorrect = dataMap.GetBoolean (Constants.CHOSEN_ANSWER_CORRECT);
UpdateQuestionStatus (questionIndex, questionCorrect);
AskNextQuestionIfExists ();
} else if (questionWasDeleted) {
int questionIndex = dataMap.GetInt (Constants.QUESTION_INDEX);
MarkQuestionLeftBlank (questionIndex);
AskNextQuestionIfExists ();
}
}
}
});
}
public void OnDataChanged(DataEventBuffer dataEvents)
{
Log.Debug(Tag, "On Data Changed");
foreach (var dataEvent in dataEvents)
{
var dataItem = dataEvent.DataItem;
if (dataItem.Uri.Path == "/xfit_watchface")
{
var dataMap = DataMapItem.FromDataItem(dataItem).DataMap;
stepCountOn = dataMap.GetBoolean("stepcount");
UpdateUI();
}
}
}
