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); } } }
protected override async void OnCreate(Bundle savedInstanceState) { base.OnCreate(savedInstanceState); // Set our view from the "main" layout resource SetContentView(Resource.Layout.Main); _client = new GoogleApiClient.Builder(this) .AddConnectionCallbacks(this) .AddOnConnectionFailedListener(r => WriteLine("Connection failed")) .AddApi(NearbyClass.MessagesApi) .Build(); await Task.Run(() => _client.BlockingConnect()); var status = await NearbyClass.Messages.GetPermissionStatusAsync(_client); if (status.IsSuccess) { Subscribe(); } else { status.StartResolutionForResult(this, ConnectionResult.ResolutionRequired); } }
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) { 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); } }
/// <summary> /// Handles incoming intents /// </summary> /// <param name="intent">The intent sent by Location Services. This Intent is provided to Location Services (inside a PendingIntent) /// when AddGeofences() is called</param> protected override void OnHandleIntent(Android.Content.Intent intent) { // First check for errors var geofencingEvent = GeofencingEvent.FromIntent(intent); if (geofencingEvent.HasError) { int errorCode = geofencingEvent.ErrorCode; Log.Error(Constants.TAG, "Location Services error: " + errorCode); } else { // Get the type of Geofence transition (i.e. enter or exit in this sample). int transitionType = geofencingEvent.GeofenceTransition; // Create a DataItem when a user enters one of the geofences. The wearable app will receie this and create a // notification to prompt him/her to check in if (transitionType == Geofence.GeofenceTransitionEnter) { // Connect to the Google Api service in preparation for sending a DataItem mGoogleApiClient.BlockingConnect(Constants.CONNECTION_TIME_OUT_MS, TimeUnit.Milliseconds); // Get the geofence ID triggered. Note that only one geofence can be triggered at a time in this example, but in some cases // you might want to consider the full list of geofences triggered string triggeredGeofenceId = geofencingEvent.TriggeringGeofences[0].RequestId; // Create a DataItem with this geofence's id. The wearable can use this to create a notification PutDataMapRequest putDataMapRequest = PutDataMapRequest.Create(Constants.GEOFENCE_DATA_ITEM_PATH); putDataMapRequest.DataMap.PutString(Constants.KEY_GEOFENCE_ID, triggeredGeofenceId); if (mGoogleApiClient.IsConnected) { WearableClass.DataApi.PutDataItem( mGoogleApiClient, putDataMapRequest.AsPutDataRequest()).Await(); } else { Log.Error(Constants.TAG, "Failed to send data item: " + putDataMapRequest + " - disconnected from Google Play Services"); } mGoogleApiClient.Disconnect(); } else if (Geofence.GeofenceTransitionExit == transitionType) { // Delete the data item when leaving a geofence region mGoogleApiClient.BlockingConnect(Constants.CONNECTION_TIME_OUT_MS, TimeUnit.Milliseconds); WearableClass.DataApi.DeleteDataItems(mGoogleApiClient, Constants.GEOFENCE_DATA_ITEM_URI).Await(); mGoogleApiClient.Disconnect(); } } }
protected override void Initialize() { base.Initialize(); // check for availability of Google Play Services int googlePlayServicesAvailability = GoogleApiAvailability.Instance.IsGooglePlayServicesAvailable(Application.Context); if (googlePlayServicesAvailability != ConnectionResult.Success) { string message = "Google Play Services are not available on this device."; if (googlePlayServicesAvailability == ConnectionResult.ServiceVersionUpdateRequired) { message += " Please update your phone's Google Play Services app using the App Store. Then restart your study."; } message += " Email the study organizers and tell them you received the following error code: " + googlePlayServicesAvailability; // the problem we've encountered is potentially fixable, so do not throw a NotSupportedException, as doing this would // disable the probe and prevent any future restart attempts from succeeding. throw new Exception(message); } // connect awareness client _awarenessApiClient = new GoogleApiClient.Builder(Application.Context).AddApi(Awareness.Api) .AddConnectionCallbacks( bundle => { SensusServiceHelper.Get().Logger.Log("Connected to Google Awareness API.", LoggingLevel.Normal, GetType()); }, status => { SensusServiceHelper.Get().Logger.Log("Connection to Google Awareness API suspended. Status: " + status, LoggingLevel.Normal, GetType()); }) .Build(); _awarenessApiClient.BlockingConnect(); if (_awarenessApiClient.IsConnected) { // we need location permission in order to snapshot / fence the user's location. if (SensusServiceHelper.Get().ObtainPermission(Permission.Location) != PermissionStatus.Granted) { string error = "Geolocation is not permitted on this device. Cannot start location fences."; SensusServiceHelper.Get().FlashNotificationAsync(error); } } else { throw new Exception("Failed to connect with Google Awareness API."); } }
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 static void LogOut() { new Thread(() => { ConnectionResult result = mGoogleApiClient?.BlockingConnect((long)1.5, Java.Util.Concurrent.TimeUnit.Seconds); if (mGoogleApiClient.IsConnected) { Auth.GoogleSignInApi.RevokeAccess(mGoogleApiClient).SetResultCallback(new SignOutResultCallback()); } }).Start(); }
protected override void OnHandleIntent(Intent intent) { google_api_client.BlockingConnect(CONNECTION_TIME_OUT_MS, TimeUnit.Milliseconds); if (Log.IsLoggable(TAG, LogPriority.Verbose)) { Log.Verbose(TAG, "FindPhoneService.OnHandleEvent"); } if (google_api_client.IsConnected) { bool alarmOn = false; if (intent.Action == ACTION_TOGGLE_ALARM) { var result = WearableClass.DataApi.GetDataItems(google_api_client).Await().JavaCast <DataItemBuffer>(); if (result.Status.IsSuccess) { if (result.Count == 1) { alarmOn = DataMap.FromByteArray((result.Get(0).JavaCast <IDataItem>()).GetData()).GetBoolean(FIELD_ALARM_ON, false); } else { Log.Error(TAG, "Unexpected number of DataItems found.\n" + "\tExpected: 1\n" + "\tActual: " + result.Count); } } else if (Log.IsLoggable(TAG, LogPriority.Debug)) { Log.Debug(TAG, "OnHandleIntent: failed to get current alarm state"); } result.Close(); alarmOn = !alarmOn; string notificationText = alarmOn ? GetString(Resource.String.turn_alarm_on) : GetString(Resource.String.turn_alarm_off); MainActivity.UpdateNotification(this, notificationText); } var putDataMapRequest = PutDataMapRequest.Create(PATH_SOUND_ALARM); putDataMapRequest.DataMap.PutBoolean(FIELD_ALARM_ON, alarmOn); WearableClass.DataApi.PutDataItem(google_api_client, putDataMapRequest.AsPutDataRequest()).Await(); } else { Log.Error(TAG, "Failed to toggle alarm on phone - Client disconnected from Google Play Services"); } google_api_client.Disconnect(); }
public void connectme() { try { google_api_client = new GoogleApiClient.Builder(this) .AddApi(WearableClass.API) .AddConnectionCallbacks(this) .AddOnConnectionFailedListener(this) .Build(); google_api_client.Connect(); google_api_client.BlockingConnect(CONNECTION_TIME_OUT_MS, TimeUnit.Milliseconds); } catch (Exception ex) { throw; } }
protected override void OnHandleIntent(Android.Content.Intent intent) { mGoogleApiClient.BlockingConnect(TIME_OUT, TimeUnit.Milliseconds); Android.Net.Uri dataItemUri = intent.Data; if (Log.IsLoggable(Constants.TAG, LogPriority.Verbose)) { Log.Verbose(Constants.TAG, "DeleteService.OnHandleIntent = " + dataItemUri); } if (mGoogleApiClient.IsConnected) { IDataApiDeleteDataItemsResult result = WearableClass.DataApi .DeleteDataItems(mGoogleApiClient, dataItemUri).Await().JavaCast <IDataApiDeleteDataItemsResult>(); if (result.Status.IsSuccess && !intent.GetBooleanExtra(Constants.EXTRA_SILENT, false)) { // Show the success animaton on the watch unless Silent extra is true. StartConfirmationActivity(ConfirmationActivity.SuccessAnimation, GetString(Resource.String.delete_successful)); } else { if (Log.IsLoggable(Constants.TAG, LogPriority.Verbose)) { Log.Verbose(Constants.TAG, "DeleteService.OnHandleIntent: Failed to delete dataITem:" + dataItemUri); } // Show the failure animation on the watch unless Silent extra is true. if (!intent.GetBooleanExtra(Constants.EXTRA_SILENT, false)) { StartConfirmationActivity(ConfirmationActivity.FailureAnimation, GetString(Resource.String.delete_unsuccessful)); } } } else { Log.Error(Constants.TAG, "Failed to delete data item: " + dataItemUri + " - Client disconnected from Google Play Services"); // Show the failure animation on the watch unless Silent extra is true. if (!intent.GetBooleanExtra(Constants.EXTRA_SILENT, false)) { StartConfirmationActivity(ConfirmationActivity.FailureAnimation, GetString(Resource.String.delete_unsuccessful)); } } mGoogleApiClient.Disconnect(); }
protected override void OnHandleIntent(Android.Content.Intent intent) { if (Constants.ACTION_CHECK_IN.Equals(intent.Action)) { // In a real app, code for checking in would go here. For this sample, we will simply disaply a success animation StartConfirmationActivity(ConfirmationActivity.SuccessAnimation, GetString(Resource.String.check_in_success)); // Dismiss the check-in notification GetSystemService(NotificationService).JavaCast <NotificationManager> ().Cancel(Constants.NOTIFICATION_ID); } else if (!Constants.ACTION_DELETE_DATA_ITEM.Equals(intent.Action)) { // The only possible actions should be checking in or dismissing the notification // (which causes an intent with ACTION_DELETE_DATA_ITEM) Log.Error(Constants.TAG, "Unrecognized Action: " + intent.Action); return; } // Regardless of the action, delete the DataItem (we are only handling intents if the notification is dismissed or if the user // has chosen to check in, either of which would be completed at this point mGoogleApiClient.BlockingConnect(Constants.CONNECTION_TIME_OUT_MS, TimeUnit.Milliseconds); Android.Net.Uri dataItemUri = intent.Data; if (mGoogleApiClient.IsConnected) { var result = WearableClass.DataApi.DeleteDataItems(mGoogleApiClient, dataItemUri).Await().JavaCast <IDataApiDeleteDataItemsResult> (); if (!result.Status.IsSuccess) { Log.Error(Constants.TAG, "CheckInAndDeleteDataItemsService.OnHandleIntent: " + "Failed to delete dataItem: " + dataItemUri); } else if (Log.IsLoggable(Constants.TAG, LogPriority.Debug)) { Log.Debug(Constants.TAG, "Successfully deleted data item: " + dataItemUri); } } else { Log.Error(Constants.TAG, "Failed to delete data item: " + dataItemUri + " - Client disconnected from Google Play Services"); } mGoogleApiClient.Disconnect(); }
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(); }
private async void LoadIssues() { var sharedPreferences = GetSharedPreferences("IssueApp", FileCreationMode.Private); var key = sharedPreferences.GetString("Key", null); if (key == null) { var editText = new EditText(this); var alertDialog = new AlertDialog.Builder(this); alertDialog.SetIcon(Android.Resource.Drawable.IcDialogInfo); alertDialog.SetTitle("Redmine認証キー").SetView(editText).SetPositiveButton("OK", async(sender, args) => { var service = new RedmineService(editText.Text); var check = await service.CheckAsync(); if (check) { var preferencesEditor = sharedPreferences.Edit(); preferencesEditor.PutString("Key", editText.Text); preferencesEditor.Apply(); LoadIssues(); } else { LoadIssues(); } }).SetNegativeButton(Properties.Resources.Host + "を開く", (sender, args) => { var uri = Uri.Parse(Properties.Resources.Url); var intent = new Intent(Intent.ActionView, uri); StartActivity(intent); LoadIssues(); }).Show(); return; } var progressDialog = new ProgressDialog(this); progressDialog.SetMessage("Redmineから読み込み中"); progressDialog.SetProgressStyle(ProgressDialogStyle.Spinner); progressDialog.SetButton("この表示を消す", (sender, args) => progressDialog.Hide()); progressDialog.Show(); var redmineService = new RedmineService(key); var response = await redmineService.GetIssues(); _issues = response.issues; foreach (var issue in _issues) { if (double.IsNaN(issue.lat)) { continue; } var markerOptions = new MarkerOptions(); markerOptions.SetPosition(new LatLng(issue.lat, issue.lng)); markerOptions.SetTitle(issue.subject); _googleMap.AddMarker(markerOptions); } UpdateList(); progressDialog.Hide(); if (ContextCompat.CheckSelfPermission(this, Manifest.Permission.AccessFineLocation) == Permission.Granted) { _googleMap.MyLocationEnabled = true; } else { RequestPermissions(new[] { Manifest.Permission.AccessFineLocation, Manifest.Permission.AccessCoarseLocation }, 0x01); } _googleApiClient = new GoogleApiClient.Builder(this) .AddApi(LocationServices.API) .AddConnectionCallbacks(this) .Build(); await Task.Run(() => { _googleApiClient.BlockingConnect(); }); }