@Override
 public void onConnectionFailed(ConnectionResult connectionResult) {
   if (statusesToHandle.contains(connectionResult.getErrorCode())) {
     GooglePlayServicesUtil.getErrorDialog(connectionResult.getErrorCode(), this, 0).show();
   }
   if (!gPlusSignInInProgress) {
     if (gPlusSignInClicked && connectionResult.hasResolution()) {
       try {
         gPlusSignInInProgress = true;
         startIntentSenderForResult(
             connectionResult.getResolution().getIntentSender(), 0, null, 0, 0, 0);
       } catch (IntentSender.SendIntentException e) {
         e.printStackTrace();
         gPlusSignInInProgress = false;
         googleApiClient.connect();
       }
     } else {
       googleApiClient.disconnect();
       if (progressDialog != null) {
         progressDialog.dismiss();
       }
     }
   } else {
     googleApiClient.disconnect();
     if (progressDialog != null) {
       progressDialog.dismiss();
     }
   }
 }
 @Override
 protected void onPause() {
   super.onPause();
   if (mGoogleApiClient != null && mGoogleApiClient.isConnected()) {
     mGoogleApiClient.disconnect();
   }
 }
 @Override
 protected void onDestroy() {
   if (client.isConnected()) {
     client.disconnect();
   }
   super.onDestroy();
 }
 @Override
 public void onPause() {
   super.onPause();
   if (mGoogleApiClient.isConnected()) {
     mGoogleApiClient.disconnect();
   }
 }
  /**
   * Handle activity result. Call this method from your Activity's onActivityResult callback. If the
   * activity result pertains to the sign-in process, processes it appropriately.
   */
  public void onActivityResult(int requestCode, int responseCode, Intent intent) {
    debugLog(
        "onActivityResult: req="
            + (requestCode == RC_RESOLVE ? "RC_RESOLVE" : String.valueOf(requestCode))
            + ", resp="
            + GooglePlayServicesGameHelperUtils.activityResponseCodeToString(responseCode));
    if (requestCode != RC_RESOLVE) {
      debugLog("onActivityResult: request code not meant for us. Ignoring.");
      return;
    }

    // no longer expecting a resolution
    mExpectingResolution = false;

    if (!mConnecting) {
      debugLog("onActivityResult: ignoring because we are not connecting.");
      return;
    }

    // We're coming back from an activity that was launched to resolve a
    // connection problem. For example, the sign-in UI.
    if (responseCode == Activity.RESULT_OK) {
      // Ready to try to connect again.
      debugLog("onAR: Resolution was RESULT_OK, so connecting current client again.");
      connect();
    } else if (responseCode == GamesActivityResultCodes.RESULT_RECONNECT_REQUIRED) {
      debugLog("onAR: Resolution was RECONNECT_REQUIRED, so reconnecting.");
      connect();
    } else if (responseCode == Activity.RESULT_CANCELED) {
      // User cancelled.
      debugLog("onAR: Got a cancellation result, so disconnecting.");
      mSignInCancelled = true;
      mConnectOnStart = false;
      mUserInitiatedSignIn = false;
      mSignInFailureReason = null; // cancelling is not a failure!
      mConnecting = false;
      mGoogleApiClient.disconnect();

      // increment # of cancellations
      int prevCancellations = getSignInCancellations();
      int newCancellations = incrementSignInCancellations();
      debugLog(
          "onAR: # of cancellations "
              + prevCancellations
              + " --> "
              + newCancellations
              + ", max "
              + mMaxAutoSignInAttempts);

      notifyListener(false);
    } else {
      // Whatever the problem we were trying to solve, it was not
      // solved. So give up and show an error message.
      debugLog(
          "onAR: responseCode="
              + GooglePlayServicesGameHelperUtils.activityResponseCodeToString(responseCode)
              + ", so giving up.");
      giveUp(new SignInFailureReason(mConnectionResult.getErrorCode(), responseCode));
    }
  }
  @Override
  public void onConnected(Bundle bundle) {
    gPlusEmail = Plus.AccountApi.getAccountName(googleApiClient);
    Person person = Plus.PeopleApi.getCurrentPerson(googleApiClient);
    if (person != null) {
      if (person.hasName()) {
        gPlusFullName = "";
        if (person.getName().hasGivenName()) {
          gPlusFullName += person.getName().getGivenName() + " ";
        }
        if (person.getName().hasMiddleName()) {
          gPlusFullName += person.getName().getMiddleName() + " ";
        }
        if (person.getName().hasFamilyName()) {
          gPlusFullName += person.getName().getFamilyName();
        }
      }
      if (person.hasId()) {
        gPlusId = person.getId();
      }
    }
    if (gPlusSignInClicked) {
      Log.d("LOGIN", "Starting Authentication Service...");

    } else {
      Plus.AccountApi.clearDefaultAccount(googleApiClient);
      Plus.AccountApi.clearDefaultAccount(googleApiClient);
      googleApiClient.disconnect();
    }
    gPlusSignInClicked = false;
  }
 @Override
 protected void onPause() {
   super.onPause();
   if (googleApiClient != null) {
     googleApiClient.disconnect();
   }
 }
 @Override
 protected void onStop() {
   if (googleApiClient != null && googleApiClient.isConnected()) {
     googleApiClient.disconnect();
   }
   super.onStop();
 }
 protected void onStop() {
   super.onStop();
   if (mGoogleApiClient.isConnected()) {
     Log.i(TAG, "disconnected");
     mGoogleApiClient.disconnect();
   }
 }
Exemple #10
0
 @Override
 public void onDetach() {
   super.onDetach();
   mSelectedAccount = null;
   mGoogleApiClient.disconnect();
   mGoogleApiClient = null;
 }
 private void googlePlusLogout() {
   if (mGoogleApiClient.isConnected()) {
     Plus.AccountApi.clearDefaultAccount(mGoogleApiClient);
     mGoogleApiClient.disconnect();
     mGoogleApiClient.connect();
   }
 }
 @Override
 public void onResult(DataApi.DeleteDataItemsResult deleteDataItemsResult) {
   if (!deleteDataItemsResult.getStatus().isSuccess()) {
     Log.e(TAG, "dismissWearableNotification(): failed to delete DataItem");
   }
   mGoogleApiClient.disconnect();
 }
 public void desconectar() {
   if (mGoogleApiClient.isConnected()) {
     enviarMensagemSair();
     apagarDados();
     mGoogleApiClient.disconnect();
   }
 }
Exemple #14
0
 @Override
 protected void onHandleIntent(Intent intent) {
   GoogleApiClient googleApiClient =
       new GoogleApiClient.Builder(this).addApi(Wearable.API).build();
   ConnectionResult connectionResult = googleApiClient.blockingConnect(30, TimeUnit.SECONDS);
   if (!connectionResult.isSuccess()) {
     Log.e(TAG, "Failed to connect to GoogleApiClient: " + connectionResult.getErrorCode());
     return;
   }
   // Read all DataItems
   DataItemBuffer dataItemBuffer = Wearable.DataApi.getDataItems(googleApiClient).await();
   if (!dataItemBuffer.getStatus().isSuccess()) {
     Log.e(TAG, "Error getting all data items: " + dataItemBuffer.getStatus().getStatusMessage());
   }
   Iterator<DataItem> dataItemIterator = dataItemBuffer.singleRefIterator();
   boolean foundArtwork = false;
   while (dataItemIterator.hasNext()) {
     DataItem dataItem = dataItemIterator.next();
     foundArtwork = foundArtwork || processDataItem(googleApiClient, dataItem);
   }
   dataItemBuffer.release();
   if (!foundArtwork
       && intent != null
       && intent.getBooleanExtra(SHOW_ACTIVATE_NOTIFICATION_EXTRA, false)) {
     ActivateMuzeiIntentService.maybeShowActivateMuzeiNotification(this);
   }
   googleApiClient.disconnect();
 }
  @Override
  protected void onStop() {
    super.onStop();

    mGoogleApiClient.disconnect();
    unregisterReceiver(mConnectionReceiver);
  }
Exemple #16
0
 @Override
 public void onClick(View v) {
   if (!mGoogleApiClient.isConnecting()) {
     // We only process button clicks when GoogleApiClient is not
     // transitioning between connected and not connected.
     switch (v.getId()) {
       case R.id.sign_in_button:
         mStatus.setText(R.string.status_signing_in);
         resolveSignInError();
         break;
       case R.id.sign_out_button:
         // We clear the default account on sign out so that Google
         // Play services will not return an onConnected callback
         // without user interaction.
         Plus.AccountApi.clearDefaultAccount(mGoogleApiClient);
         mGoogleApiClient.disconnect();
         mGoogleApiClient.connect();
         break;
       case R.id.revoke_access_button:
         // After we revoke permissions for the user with a
         // GoogleApiClient instance, we must discard it and create a
         // new one.
         Plus.AccountApi.clearDefaultAccount(mGoogleApiClient);
         // Our sample has caches no user data from Google+, however
         // we would normally register a callback on
         // revokeAccessAndDisconnect to delete user data so that we
         // comply with Google developer policies.
         Plus.AccountApi.revokeAccessAndDisconnect(mGoogleApiClient);
         mGoogleApiClient = buildGoogleApiClient();
         mGoogleApiClient.connect();
         break;
     }
   }
 }
 @Override
 public void onCancel() {
   mGoogleApiClient.disconnect();
   String title = getString(R.string.app_name);
   // initialize the notification
   NotificationCompat.Builder mBuilder =
       new NotificationCompat.Builder(getApplicationContext())
           .setSmallIcon(R.mipmap.ic_launcher_logo)
           .setContentTitle(title)
           .setContentText(getString(R.string.alarm_cancelled))
           .setSound(RingtoneManager.getDefaultUri(RingtoneManager.TYPE_NOTIFICATION))
           .setAutoCancel(true);
   Intent resultIntent = new Intent(getApplicationContext(), MainActivity.class);
   PendingIntent resultPendingIntent =
       PendingIntent.getActivity(
           getApplicationContext(), 0, resultIntent, PendingIntent.FLAG_UPDATE_CURRENT);
   mBuilder.setContentIntent(resultPendingIntent);
   NotificationManager mNotificationManager =
       (NotificationManager) getSystemService(Context.NOTIFICATION_SERVICE);
   //  allows you to update the notification later on.
   if (!declined) {
     mNotificationManager.notify(AlarmNotifier.notificationID, mBuilder.build());
     String text = getString(R.string.alarm_cancelled);
     Toast toast = Toast.makeText(getApplicationContext(), text, Toast.LENGTH_LONG);
     toast.show();
   }
   finish();
 }
  @Override
  public void onResult(LoadPeopleResult peopleData) {
    switch (peopleData.getStatus().getStatusCode()) {
      case CommonStatusCodes.SUCCESS:
        mListItems.clear();
        PersonBuffer personBuffer = peopleData.getPersonBuffer();
        try {
          int count = personBuffer.getCount();
          for (int i = 0; i < count; i++) {
            mListItems.add(personBuffer.get(i).getDisplayName());
          }
        } finally {
          personBuffer.close();
        }

        mListAdapter.notifyDataSetChanged();
        break;

      case CommonStatusCodes.SIGN_IN_REQUIRED:
        mGoogleApiClient.disconnect();
        mGoogleApiClient.connect();
        break;

      default:
        Log.e(TAG, "Error when listing people: " + peopleData.getStatus());
        break;
    }
  }
 public void disconnect() {
   if (isGooglePlayServicesAvailable()) {
     apiClient.disconnect();
   } else {
     listener.onDisconnected();
   }
 }
  /** Sign out and disconnect from the APIs. */
  public void signOut() {
    if (!mGoogleApiClient.isConnected()) {
      // nothing to do
      debugLog("signOut: was already disconnected, ignoring.");
      return;
    }

    // for Plus, "signing out" means clearing the default account and
    // then disconnecting
    if (0 != (mRequestedClients & CLIENT_PLUS)) {
      debugLog("Clearing default account on PlusClient.");
      Plus.AccountApi.clearDefaultAccount(mGoogleApiClient);
    }

    // For the games client, signing out means calling signOut and
    // disconnecting
    if (0 != (mRequestedClients & CLIENT_GAMES)) {
      debugLog("Signing out from the Google API Client.");
      Games.signOut(mGoogleApiClient);
    }

    // Ready to disconnect
    debugLog("Disconnecting client.");
    mConnectOnStart = false;
    mConnecting = false;
    mGoogleApiClient.disconnect();
  }
    @Override
    public void onVisibilityChanged(boolean visible) {
      Log.d(TAG, "onVisibilityChanged: " + visible);

      super.onVisibilityChanged(visible);

      if (visible) {
        mGoogleApiClient.connect();

        registerReceiver();

        // Update time zone and date formats, in case they changed while we weren't visible.
        mCalendar.setTimeZone(TimeZone.getDefault());
      } else {
        unregisterReceiver();

        if (mGoogleApiClient != null && mGoogleApiClient.isConnected()) {
          mGoogleApiClient.disconnect();
        }
      }

      // Whether the timer should be running depends on whether we're visible (as well as
      // whether we're in ambient mode), so we may need to start or stop the timer.
      updateTimer();
    }
 @Override
 public void onDestroy() {
   super.onDestroy();
   if (mGoogleApiClient != null && mGoogleApiClient.isConnected()) {
     mGoogleApiClient.disconnect();
   }
 }
  /**
   * Kills a session and it's underlying media player
   *
   * @param callback
   */
  public void kill(final ChromecastSessionCallback callback) {
    //		this.mRemoteMediaPlayer.stop(mApiClient).setResultCallback(new
    // ResultCallback<RemoteMediaPlayer.MediaChannelResult>() {
    //			@Override
    //			public void onResult(MediaChannelResult result) {
    //				try {
    //					Cast.CastApi.stopApplication(mApiClient);
    //					mApiClient.disconnect();
    //				} catch(Exception e) {
    //
    //				}
    //
    //				callback.onSuccess();
    //			}
    //		});
    try {
      Cast.CastApi.stopApplication(mApiClient);
      mApiClient.disconnect();
    } catch (Exception e) {

    }

    callback.onSuccess();
    //		Cast.CastApi.stopApplication(mApiClient);
  }
 @Override
 protected void onStop() {
   super.onStop();
   if (mGoogleApiClient.isConnected()) {
     mGoogleApiClient.disconnect();
   }
 }
 @Override
 public void onStop() {
   super.onStop();
   Log.d("TAG", "onStop LocationActivity");
   mGoogleApiClient.disconnect();
   Log.d("TAG", "isConnected ...............: " + mGoogleApiClient.isConnected());
 }
 public void signOutFromGplus() {
   if (mGoogleApiClient.isConnected()) {
     Plus.AccountApi.clearDefaultAccount(mGoogleApiClient);
     mGoogleApiClient.disconnect();
     mGoogleApiClient.connect();
     updateUI(false);
   }
 }
 @Override
 public void onStop() {
   // Tear down GoogleApiClient
   if (mGoogleApiClient != null && mGoogleApiClient.isConnected()) {
     mGoogleApiClient.disconnect();
   }
   super.onStop();
 }
Exemple #28
0
 @Override
 protected void onPause() {
   super.onPause();
   if (mGoogleApiClient != null) Wearable.DataApi.removeListener(mGoogleApiClient, this);
   if (mSensorManager != null) mSensorManager.unregisterListener(this);
   if (mGoogleApiClient != null && mGoogleApiClient.isConnected()) mGoogleApiClient.disconnect();
   if (mHeadTracker != null) mHeadTracker.stopTracking();
 }
 @Override
 protected void onPause() {
   super.onPause();
   if (mGoogleApiClient.isConnected()) {
     LocationServices.FusedLocationApi.removeLocationUpdates(mGoogleApiClient, this);
     mGoogleApiClient.disconnect();
   }
 }
  @Override
  public void onStop() {
    super.onStop();

    if (mGoogleApiClient != null) {
      mGoogleApiClient.disconnect();
    }
  }