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)
{
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);
}
protected override void OnHandleIntent(Intent intent)
{
google_api_client.BlockingConnect(TIME_OUT_MS, TimeUnit.Milliseconds);
Android.Net.Uri dataItemUri = intent.Data;
if (!google_api_client.IsConnected)
{
Log.Error(TAG, "Failed to update data item " + dataItemUri +
" because client is disconnected from Google Play Services");
return;
}
var dataItemResult = WearableClass.DataApi.GetDataItem(
google_api_client, dataItemUri).Await().JavaCast <IDataApiDataItemResult> ();
var putDataMapRequest = PutDataMapRequest.CreateFromDataMapItem(
DataMapItem.FromDataItem(dataItemResult.DataItem));
var dataMap = putDataMapRequest.DataMap;
//update quiz status variables
int questionIndex = intent.GetIntExtra(EXTRA_QUESTION_INDEX, -1);
bool chosenAnswerCorrect = intent.GetBooleanExtra(EXTRA_QUESTION_CORRECT, false);
dataMap.PutInt(Constants.QUESTION_INDEX, questionIndex);
dataMap.PutBoolean(Constants.CHOSEN_ANSWER_CORRECT, chosenAnswerCorrect);
dataMap.PutBoolean(Constants.QUESTION_WAS_ANSWERED, true);
PutDataRequest request = putDataMapRequest.AsPutDataRequest();
WearableClass.DataApi.PutDataItem(google_api_client, request).Await();
//remove this question notification
((NotificationManager)GetSystemService(NotificationService)).Cancel(questionIndex);
google_api_client.Disconnect();
}
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 OnResult(IDataApiDataItemResult dataItemResult)
{
if (dataItemResult.Status.IsSuccess)
{
var request = PutDataMapRequest.CreateFromDataMapItem(
DataMapItem.FromDataItem(dataItemResult.DataItem));
var dataMap = request.DataMap;
dataMap.PutBoolean(Constants.QUESTION_WAS_ANSWERED, false);
dataMap.PutBoolean(Constants.QUESTION_WAS_DELETED, false);
if (!act.has_question_been_asked && dataMap.GetInt(Constants.QUESTION_INDEX) == 0)
{
//ask the first question now.
WearableClass.DataApi.PutDataItem(act.google_api_client, request.AsPutDataRequest());
act.SetHasQuestionBeenAsked(true);
}
else
{
//enqueue future questions
act.future_questions.Add(new Question(dataMap.GetString(Constants.QUESTION),
dataMap.GetInt(Constants.QUESTION_INDEX), dataMap.GetStringArray(Constants.ANSWERS),
dataMap.GetInt(Constants.CORRECT_ANSWER_INDEX)));
}
}
else
{
Log.Error(TAG, "Failed to reset data item " + dataItemResult.DataItem.Uri);
}
}
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 async static Task <bool> ReadStepCountStatus(GoogleApiClient googleApiClient)
{
var nodeApiLocalNode = await WearableClass.NodeApi.GetLocalNodeAsync(googleApiClient);
if (nodeApiLocalNode == null || !nodeApiLocalNode.Status.IsSuccess || nodeApiLocalNode.Node == null)
{
// error
}
else
{
var localNode = nodeApiLocalNode.Node.Id;
var uri = new Android.Net.Uri.Builder()
.Scheme("wear")
.Path(PathWithFeature)
.Authority(localNode)
.Build();
var dataItemResult = await WearableClass.DataApi.GetDataItemAsync(googleApiClient, uri) as IDataApiDataItemResult;
if (dataItemResult == null || !dataItemResult.Status.IsSuccess || dataItemResult.DataItem == null)
{
// not found
}
else
{
var dataMapItem = DataMapItem.FromDataItem(dataItemResult.DataItem);
var stepCountOn = dataMapItem.DataMap.GetBoolean("stepcount");
return(stepCountOn);
}
}
return(true); // default is "ON"
}
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 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 static DataMapItem fromJson(dynamic array)
{
var newItem = new DataMapItem();
// name
newItem.ImageName = array["image_name"];
newItem.Name = array["name"];
return(newItem);
}
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);
}
}
}
// 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 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);
}
}
}
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 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 OnResult(Java.Lang.Object result)
{
var dataItemResult = result.JavaCast <IDataApiDataItemResult> ();
if (dataItemResult.Status.IsSuccess && dataItemResult.DataItem != null)
{
var configDataItem = dataItemResult.DataItem;
var dataMapItem = DataMapItem.FromDataItem(configDataItem);
SetupAllPickers(dataMapItem.DataMap);
}
else
{
SetupAllPickers(null);
}
}
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 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 static void OverwriteKeysInConfigDataMap(IGoogleApiClient googleApiClient, DataMap configKeysToOverwrite)
{
FetchConfigDataMap(googleApiClient,
new DataItemResultCallback(dataItemResult => {
var overwrittenConfig = new DataMap();
if (dataItemResult.DataItem != null)
{
var dataItem = dataItemResult.DataItem;
var dataMapItem = DataMapItem.FromDataItem(dataItem);
var currentConfig = dataMapItem.DataMap;
overwrittenConfig.PutAll(currentConfig);
}
overwrittenConfig.PutAll(configKeysToOverwrite);
DigitalWatchFaceUtil.PutConfigDataItem(googleApiClient, overwrittenConfig);
})
);
}
void UpdateConfigDataItemAndUiOnStartup()
{
DigitalWatchFaceUtil.FetchConfigDataMap(googleApiClient,
new DigitalWatchFaceUtil.DataItemResultCallback(dataItemResult => {
if (dataItemResult.DataItem != null)
{
var dataItem = dataItemResult.DataItem;
if (dataItem != null)
{
var dataMapItem = DataMapItem.FromDataItem(dataItem);
var startupConfig = dataMapItem.DataMap;
SetDefaultValuesForMissingKeys(startupConfig);
DigitalWatchFaceUtil.PutConfigDataItem(googleApiClient, startupConfig);
UpdateUiForConfigDataMap(startupConfig);
}
}
})
);
}
/// <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)
{
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);
}
private void OnDataChanged(IDataItem dataItem)
{
var map = DataMapItem.FromDataItem(dataItem).DataMap;
if (map.ContainsKey(Common.TimeEntryListKey))
{
var list = map.GetDataMapArrayList(Common.TimeEntryListKey);
if (list.Count == 0)
{
return;
}
timeEntries.Clear();
foreach (var mapItem in list)
{
var en = new SimpleTimeEntryData(mapItem);
timeEntries.Add(en);
}
adapter.Timer.TimerEnabled = true;
}
}
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;
});
}
}
protected override void OnHandleIntent(Intent intent)
{
google_api_client.BlockingConnect(Constants.CONNECT_TIMEOUT_MS, TimeUnit.Milliseconds);
Android.Net.Uri dataItemUri = intent.Data;
if (!google_api_client.IsConnected)
{
Log.Error(TAG, "Failed to update data item " + dataItemUri
+ " because client is disconnected from Google Play Services");
return;
}
var dataItemResult = WearableClass.DataApi.GetDataItem(
google_api_client, dataItemUri).Await().JavaCast <IDataApiDataItemResult>();
var putDataMapRequest = PutDataMapRequest
.CreateFromDataMapItem(DataMapItem.FromDataItem(dataItemResult.DataItem));
var dataMap = putDataMapRequest.DataMap;
dataMap.PutBoolean(Constants.QUESTION_WAS_DELETED, true);
var request = putDataMapRequest.AsPutDataRequest();
WearableClass.DataApi.PutDataItem(google_api_client, request).Await();
google_api_client.Disconnect();
}
public static AngiographyItem fromJson(dynamic array, String dataDir)
{
var newItem = new AngiographyItem();
// name
newItem.ImageName = array["image_name"];
newItem.Name = array["name"];
// upper layer
newItem.UpperLayer = MeasurementData.Ins.findBScanLayerByName(array["upper_layer"].Value);
newItem.UpperOffset = array["upper_offset"];
// lower layer
newItem.LowerLayer = MeasurementData.Ins.findBScanLayerByName(array["lower_layer"].Value);
newItem.LowerOffset = array["lower_offset"];
// data map list
var arrDataMap = array["data_map_list"];
List <DataMapItem> dataMapList = new List <DataMapItem>();
foreach (var item in arrDataMap)
{
var dataMapItem = DataMapItem.fromJson(item);
dataMapList.Add(dataMapItem);
}
newItem.DataMapList.Clear();
newItem.DataMapList.AddRange(dataMapList);
// additional data map
// - depth coded map
DataMapItem depthCodedMap = new DataMapItem();
depthCodedMap.Name = "Depth coded map";
depthCodedMap.ImageName = newItem.ImageName.Substring(0, newItem.ImageName.IndexOf('.')) + "_depthCodeMap.png";
depthCodedMap.parseDepthCodedMap(dataDir);
newItem.DataMapList.Add(depthCodedMap);
return(newItem);
}
private async Task SendWeatherRequest()
{
if (!(await Connect()))
{
LocalBroadcastManager.GetInstance(this).SendBroadcast(
new Intent(WearableHelper.ErrorPath));
return;
}
var data = await WearableClass.DataApi.GetDataItemAsync(
mGoogleApiClient, WearableHelper.GetWearDataUri(mPhoneNodeWithApp.Id, WearableHelper.WeatherPath));
if (!data.Status.IsSuccess || data.DataItem == null)
{
// Send message to device to get settings
var sendMessageResult = await WearableClass.MessageApi.SendMessageAsync(mGoogleApiClient, mPhoneNodeWithApp.Id,
WearableHelper.WeatherPath, new byte[0]);
}
else
{
// Update with data
await UpdateWeather(DataMapItem.FromDataItem(data.DataItem).DataMap);
}
}
private static void SaveItem(IDataItem dataItem, ISharedPreferencesEditor editor, IDictionary <string, object> allPrefs)
{
DataMap dataMap = DataMapItem.FromDataItem(dataItem).DataMap;
if (dataMap.KeySet().Count == 0 && dataItem.Uri.PathSegments.LastOrDefault() != PrefListener.KEY_SYNC_DONE)
{
// Testing has shown that when an item is deleted from the Data API, it
// will often come through as an empty TYPE_CHANGED rather than a TYPE_DELETED.
DeleteItem(dataItem.Uri, editor, allPrefs);
}
else
{
foreach (var key in dataMap.KeySet())
{
Java.Lang.Object value = dataMap.Get(key);
if (value == null)
{
if (allPrefs != null && value.Equals(allPrefs.ContainsKey(key)))
{
editor.Remove(key);
}
continue;
}
if (allPrefs != null && value.Equals(allPrefs[key]))
{
// No change to value.
continue;
}
if (key.Equals(KEY_TIMESTAMP))
{
continue;
}
if (value is Java.Lang.Boolean)
{
editor.PutBoolean(key, (bool)value);
}
else if (value is Java.Lang.Float)
{
editor.PutFloat(key, (float)value);
}
else if (value is Java.Lang.Integer)
{
editor.PutInt(key, (int)value);
}
else if (value is Java.Lang.Long)
{
editor.PutLong(key, (long)value);
}
else if (value is Java.Lang.String)
{
editor.PutString(key, (string)value);
}
else if (value is Java.Lang.Object javaValue && javaValue.Class.SimpleName == "String[]")
{
if (Build.VERSION.SdkInt >= BuildVersionCodes.Honeycomb)
{
editor.PutStringSet(key, (string[])value);
}
}
