Ejemplo n.º 1
0
 @Override
 protected void onStop() {
   super.onStop();
   if (mGoogleApiClient.isConnected()) {
     mGoogleApiClient.disconnect();
   }
 }
  /** 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 onResume() {
    super.onResume();

    if (getActivity() instanceof BraintreeListener) {
      addListener((BraintreeListener) getActivity());
    }

    flushCallbacks();

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

    if (mIsBrowserSwitching) {
      onActivityResult(
          PayPal.PAYPAL_REQUEST_CODE,
          Activity.RESULT_FIRST_USER,
          BraintreeBrowserSwitchActivity.sLastBrowserSwitchResponse);

      BraintreeBrowserSwitchActivity.sLastBrowserSwitchResponse = null;
      mIsBrowserSwitching = false;
    }
  }
Ejemplo n.º 4
0
 @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 onStart() {
   super.onStart();
   if (mGoogleApiClient != null && !mGoogleApiClient.isConnected()) {
     mGoogleApiClient.connect();
   }
 }
  @Override
  protected void onActivityResult(int requestCode, int resultCode, Intent data) {

    super.onActivityResult(requestCode, resultCode, data);

    switch (requestCode) {
      case REQUEST_ACCOUNT_PICKER:
        if (resultCode == RESULT_OK) {
          String accountName = data.getStringExtra(AccountManager.KEY_ACCOUNT_NAME);
          PrefsManager.setLoggedInAccountEmail(getApplication(), accountName);

          connectionProgress.show();
          if (!Constants.LOCAL_RUN) {
            initializeApiClient(accountName);
            apiClient.connect();
          }
        }
        break;

      case REQUEST_CODE_RESOLVE_ERR:
        if (resultCode == RESULT_OK) {
          connectionResult = null;
          if (!Constants.LOCAL_RUN) apiClient.connect();
        }

        break;

      case REQUEST_RECOVER_AUTH:
        Log.d("TAG", "Recover Auth");
        break;
    }
  }
Ejemplo n.º 7
0
 protected void onStop() {
   super.onStop();
   if (mGoogleApiClient.isConnected()) {
     Log.i(TAG, "disconnected");
     mGoogleApiClient.disconnect();
   }
 }
 @Override
 protected void onDestroy() {
   if (client.isConnected()) {
     client.disconnect();
   }
   super.onDestroy();
 }
Ejemplo n.º 9
0
 private void googlePlusLogout() {
   if (mGoogleApiClient.isConnected()) {
     Plus.AccountApi.clearDefaultAccount(mGoogleApiClient);
     mGoogleApiClient.disconnect();
     mGoogleApiClient.connect();
   }
 }
Ejemplo n.º 10
0
 @Override
 protected void onStop() {
   if (googleApiClient != null && googleApiClient.isConnected()) {
     googleApiClient.disconnect();
   }
   super.onStop();
 }
  @AutoFactory
  public LocationProvider(
      @Provided GoogleApiAvailability googleApiAvailability,
      @Provided GoogleApiClient googleApiClient,
      @Provided FusedLocationProviderApi fusedLocationProviderApi,
      @Provided LocationManager locationManager,
      @Provided SensorManager sensorManager,
      @Provided Display displayManager,
      Context context,
      LocationCallback locationCallback) {
    this.mGoogleApiAvailability = googleApiAvailability;
    this.mGoogleApiClient = googleApiClient;
    this.mFusedLocationProviderApi = fusedLocationProviderApi;
    this.mLocationManager = locationManager;
    this.mContext = context;
    this.mLocationCallback = locationCallback;
    this.mSensorManager = sensorManager;
    this.mDisplay = displayManager;
    mLocationRequest =
        LocationRequest.create()
            .setPriority(LocationRequest.PRIORITY_HIGH_ACCURACY)
            .setInterval(INTERVAL_IN_MS)
            .setFastestInterval(FASTEST_INTERVAL_IN_MS);
    mNetworkLocationListener = createLocationListener();
    mGpsLocationListener = createLocationListener();

    determineIfUsingGms();
    if (isUsingGms()) {
      mGoogleApiClient.registerConnectionCallbacks(this);
      mGoogleApiClient.registerConnectionFailedListener(this);
    }
  }
Ejemplo n.º 12
0
 public void desconectar() {
   if (mGoogleApiClient.isConnected()) {
     enviarMensagemSair();
     apagarDados();
     mGoogleApiClient.disconnect();
   }
 }
  @Override
  public void onMessageReceived(MessageEvent messageEvent) {

    if (!messageEvent.getPath().equalsIgnoreCase(AppConstants.PATH_REQUEST_WEATHER)) return;

    if (mGoogleApiClient == null) {
      mGoogleApiClient =
          new GoogleApiClient.Builder(this)
              .addConnectionCallbacks(this)
              .addOnConnectionFailedListener(this)
              .addApi(Wearable.API)
              .build();
    }

    if (!mGoogleApiClient.isConnected()) {
      ConnectionResult connectionResult = mGoogleApiClient.blockingConnect(30, TimeUnit.SECONDS);

      if (!connectionResult.isSuccess()) {
        Log.e(LOG_TAG, "Failed to connect to GoogleApiClient.");
        return;
      }
    }

    Context context = getApplicationContext();
    Cursor weatherData = getWearableWeatherData(context);
    if (weatherData != null && weatherData.moveToFirst()) {
      // Send Data Item with weather data
      sendWeatherData(weatherData, context);
    } else {
      Log.d(LOG_TAG, "No weather data");
    }
  }
Ejemplo n.º 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();
 }
Ejemplo n.º 15
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;
     }
   }
 }
Ejemplo n.º 16
0
 @Override
 public void onPause() {
   super.onPause();
   if (mGoogleApiClient.isConnected()) {
     mGoogleApiClient.disconnect();
   }
 }
Ejemplo n.º 17
0
  @Override
  protected void onActivityResult(int requestCode, int resultCode, Intent data) {
    switch (requestCode) {
      case RC_SIGN_IN:
        if (resultCode == RESULT_OK) {
          // If the error resolution was successful we should continue
          // processing errors.
          mSignInProgress = STATE_SIGN_IN;
        } else {
          // If the error resolution was not successful or the user
          // canceled,
          // we should stop processing errors.
          mSignInProgress = STATE_DEFAULT;
        }

        if (!mGoogleApiClient.isConnecting()) {
          // If Google Play services resolved the issue with a dialog
          // then
          // onStart is not called so we need to re-attempt connection
          // here.
          mGoogleApiClient.connect();
        }
        break;
    }
  }
 @Override
 public void onDestroy() {
   super.onDestroy();
   if (mGoogleApiClient != null && mGoogleApiClient.isConnected()) {
     mGoogleApiClient.disconnect();
   }
 }
 private void attachRecorder() {
   if (locationClientAPI == null) {
     connectToPlayAPI();
   } else if (locationClientAPI.isConnected()) {
     Integer priority = translateDesiredAccuracy(config.getDesiredAccuracy());
     LocationRequest locationRequest =
         LocationRequest.create()
             .setPriority(priority) // this.accuracy
             .setFastestInterval(config.getFastestInterval())
             .setInterval(config.getInterval());
     // .setSmallestDisplacement(config.getStationaryRadius());
     LocationServices.FusedLocationApi.requestLocationUpdates(
         locationClientAPI, locationRequest, this);
     Log.d(
         TAG,
         "- locationUpdateReceiver NOW RECORDING!!!!!!!!!! with priority: "
             + priority
             + ", fastestInterval: "
             + config.getFastestInterval()
             + ", interval: "
             + config.getInterval()
             + ", smallestDisplacement: "
             + config.getStationaryRadius());
   } else {
     locationClientAPI.connect();
   }
 }
Ejemplo n.º 20
0
  // [START on_connection_failed]
  @Override
  public void onConnectionFailed(ConnectionResult connectionResult) {
    // Could not connect to Google Play Services.  The user needs to select an account,
    // grant permissions or resolve an error in order to sign in. Refer to the javadoc for
    // ConnectionResult to see possible error codes.
    Log.d(TAG, "onConnectionFailed:" + connectionResult);

    if (!mIsResolving && mShouldResolve) {
      // Log.e(TAG, "Could not resolve ConnectionResult.");
      if (connectionResult.hasResolution()) {
        Log.d(TAG, "La conexion tiene solucion.");
        try {
          connectionResult.startResolutionForResult(mActivity, RC_SIGN_IN);
          mIsResolving = false;
          Log.d(TAG, "Se resuelve:" + RC_SIGN_IN);
          mShouldResolve = true;
          mGoogleApiClient.connect();

        } catch (IntentSender.SendIntentException e) {
          Log.e(TAG, "Could not resolve ConnectionResult.", e);
          mIsResolving = false;
          mGoogleApiClient.connect();
        }
      } else {
        Log.e(TAG, "No connectionResult.hasResolution.");
        // Could not resolve the connection result, show the user an
        // error dialog.
        showErrorDialog(connectionResult);
      }
    } else {
      // Show the signed-out UI
      showSignedOutUI();
    }
  }
Ejemplo n.º 21
0
  private void resolveSignInError() {

    Log.e(tag, "Has a error. Resolving !");

    if (mConnectionResult != null && mConnectionResult.hasResolution()) {
      Log.e(tag, "ERROR CODE: " + mConnectionResult.getErrorCode());
      try {
        mIntentInProgress = true;
        ((Activity) mContext)
            .startIntentSenderForResult(
                mConnectionResult.getResolution().getIntentSender(),
                RC_GOOGLE_SIGN_IN,
                null,
                0,
                0,
                0);
      } catch (SendIntentException e) {
        mIntentInProgress = false;
        mGoogleApiClient.connect();
      }
    } else {
      Log.d(tag, "mConnectionResult is null:" + (mConnectionResult == null));
      mGoogleApiClient.connect();
    }
  }
Ejemplo n.º 22
0
 public void showAchievements() {
   if (mGoogleApiClient != null && mGoogleApiClient.isConnected()) {
     startActivityForResult(Games.Achievements.getAchievementsIntent(mGoogleApiClient), 2);
   } else if (mGoogleApiClient != null) {
     mGoogleApiClient.connect();
   }
 }
  @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;
    }
  }
    @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();
    }
  /** Call this method from your Activity's onStart(). */
  public void onStart(Activity act) {
    mActivity = act;
    mAppContext = act.getApplicationContext();

    debugLog("onStart");
    assertConfigured("onStart");

    if (mConnectOnStart) {
      if (mGoogleApiClient.isConnected()) {
        Log.w(TAG, "GameHelper: client was already connected on onStart()");
      } else {
        debugLog("Connecting client.");
        mConnecting = true;
        mGoogleApiClient.connect();
      }
    } else {
      debugLog("Not attempting to connect becase mConnectOnStart=false");
      debugLog("Instead, reporting a sign-in failure.");
      mHandler.postDelayed(
          new Runnable() {
            @Override
            public void run() {
              notifyListener(false);
            }
          },
          1000);
    }
  }
Ejemplo n.º 26
0
 @Override
 public void onStop() {
   super.onStop();
   Log.d("TAG", "onStop LocationActivity");
   mGoogleApiClient.disconnect();
   Log.d("TAG", "isConnected ...............: " + mGoogleApiClient.isConnected());
 }
Ejemplo n.º 27
0
  @Test
  @Feature({"GCore"})
  public void willUseConnectionBackgroundTest() {
    int disconnectionTimeout = 5000;
    int arbitraryNumberOfSeconds = 42;
    GoogleApiClientHelper helper = new GoogleApiClientHelper(mMockClient);
    ShadowLooper.runUiThreadTasksIncludingDelayedTasks();
    Activity mockActivity = mock(Activity.class);
    ApplicationStatus.onStateChangeForTesting(mockActivity, ActivityState.CREATED);
    helper.setDisconnectionDelay(disconnectionTimeout);

    // We have a connected client
    when(mMockClient.isConnected()).thenReturn(true);

    // We go in the background and extend the delay
    ApplicationStatus.onStateChangeForTesting(mockActivity, ActivityState.STOPPED);
    ShadowLooper.idleMainLooper(disconnectionTimeout - arbitraryNumberOfSeconds);
    helper.willUseConnection();

    // The client should not have been disconnected.
    ShadowLooper.idleMainLooper(disconnectionTimeout - arbitraryNumberOfSeconds);
    verify(mMockClient, never()).disconnect();

    // After the full timeout it should still disconnect though
    ShadowLooper.idleMainLooper(arbitraryNumberOfSeconds);
    verify(mMockClient).disconnect();

    // The client is now disconnected then
    when(mMockClient.isConnected()).thenReturn(false);

    // The call should reconnect a disconnected client
    helper.willUseConnection();
    verify(mMockClient).connect();
  }
Ejemplo n.º 28
0
    @Override
    public void run() {
      // check for STORAGE permission
      if (!canWriteToStorage()) return;

      SharedPreferences SP = PreferenceManager.getDefaultSharedPreferences(mActivity);
      String driveAccount =
          SP.getString(
              mActivity.getResources().getString(R.string.PROPERTY_googledrive_account),
              "<Not Set>");

      if (driveAccount.equals("<Not Set>")) return;
      GoogleApiClient googleApiClient =
          new GoogleApiClient.Builder(mActivity)
              .addApi(Drive.API)
              .addScope(Drive.SCOPE_FILE)
              .setAccountName(driveAccount)
              .addConnectionCallbacks(m_me)
              .addOnConnectionFailedListener(m_me)
              .build();

      googleApiClient.blockingConnect();
      if (!googleApiClient.isConnected()) return;

      if (mTeamNumber >= 0) {
        syncPhotosForTeam(googleApiClient, mTeamNumber);
      } else {
        mRequester = null;

        // TODO: loop over all folders in the photos dir
      }
    }
 @Override
 protected void onPause() {
   super.onPause();
   if (mGoogleApiClient != null && mGoogleApiClient.isConnected()) {
     mGoogleApiClient.disconnect();
   }
 }
Ejemplo n.º 30
0
 public void signOutFromGplus() {
   if (mGoogleApiClient.isConnected()) {
     Plus.AccountApi.clearDefaultAccount(mGoogleApiClient);
     mGoogleApiClient.disconnect();
     mGoogleApiClient.connect();
     updateUI(false);
   }
 }