Googleapiclient Not Connecting While Using Google Fit

I am trying to get the data for number of steps walked using google fit. I am implementing the code from this tutorial. I am being asked for the account from which I want to connec

Solution 1:

This answer helped me figure out how it was to be solved. Add these dependencies to the gradle file. Google has updated ApiClient Libraries and they require google sign in authentication to access the apis

compile'com.google.android.gms:play-services-fitness:9.0.1'compile'com.google.android.gms:play-services-auth:9.0.1'

I am adding the entire code as different errors can give RESULT_CANCELED as the output.

publicclassMainActivityextendsActivityimplementsGoogleApiClient.OnConnectionFailedListener,
GoogleApiClient.ConnectionCallbacks, OnDataPointListener {
privatestaticfinalStringTAG="CCC";
privatestaticfinalStringAUTH_PENDING="isAuthPending";
GoogleApiClient googleApiClient;
privatebooleanauthInProgress=false;

protectedvoidonCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    setContentView(R.layout.activity_main);

    //authInProgress code is useful because the onStop may be called while authentication is not complete.//In such case this tells it to complete itif (savedInstanceState != null) {
        authInProgress = savedInstanceState.getBoolean(AUTH_PENDING);
    }
}

@OverrideprotectedvoidonStart() {
    super.onStart();
    //very important that the following lines are called in onStart//when they are called in onCreate, when the permission fragment opens up, onStop gets called which disconnects the api client.//after which it needs to be reConnected which does not happen as the apiClient is built in onCreate//Hence these should be called in onStart or probably onResume.
    googleApiClient = googleFitBuild(this, this, this);
    googleFitConnect(this, googleApiClient);
}

publicstatic GoogleApiClient googleFitBuild(Activity activity, GoogleApiClient.ConnectionCallbacks connectionCallbacks, GoogleApiClient.OnConnectionFailedListener failedListener){
    GoogleSignInOptionsgso=newGoogleSignInOptions.Builder(GoogleSignInOptions.DEFAULT_SIGN_IN)
            .requestEmail()
            .requestScopes(newScope(Scopes.FITNESS_ACTIVITY_READ_WRITE))
            .build();

    returnnewGoogleApiClient.Builder(activity)
//without GOOGLE_SIGN_IN_API, RESULT_CANCELED is always the output//The new version of google Fit requires that the user authenticates with gmail account
            .addApi(Auth.GOOGLE_SIGN_IN_API, gso)
            .addConnectionCallbacks(connectionCallbacks)
            .addOnConnectionFailedListener(failedListener)
            .addApi(Fitness.HISTORY_API)
            .addApi(Fitness.SESSIONS_API)
            .addApi(Fitness.RECORDING_API)
            .addApi(Fitness.SENSORS_API)
            .build();
}

//runs an automated Google Fit connect sequencepublicstaticvoidgoogleFitConnect(final Activity activity, final GoogleApiClient mGoogleApiClient){
    Log.d(TAG, "google fit connect called");
    if(!mGoogleApiClient.isConnected() && !mGoogleApiClient.isConnecting()) {
        mGoogleApiClient.registerConnectionCallbacks(newGoogleApiClient.ConnectionCallbacks() {
            @OverridepublicvoidonConnected(Bundle bundle) {
                Log.d(TAG, "Google API connected");
                IntentsignInIntent= Auth.GoogleSignInApi.getSignInIntent(mGoogleApiClient);
                activity.startActivityForResult(signInIntent, 1);
            }
            @OverridepublicvoidonConnectionSuspended(int i) {

            }
        });
        mGoogleApiClient.connect(GoogleApiClient.SIGN_IN_MODE_OPTIONAL);
    }
}

@OverridepublicvoidonConnected(@Nullable Bundle bundle) {
    Log.d(TAG, "onConnected called");
    DataSourcesRequestdataSourceRequest=newDataSourcesRequest.Builder()
            .setDataTypes(DataType.TYPE_STEP_COUNT_CUMULATIVE)
            .setDataSourceTypes(DataSource.TYPE_RAW)
            .build();
    Log.d(TAG, "DataSourcetype: " + dataSourceRequest.getDataTypes().toString());

    ResultCallback<DataSourcesResult> dataSourcesResultCallback = newResultCallback<DataSourcesResult>() {
        @OverridepublicvoidonResult(DataSourcesResult dataSourcesResult) {
            Log.d(TAG, "onResult in Result Callback called");
            for( DataSource dataSource : dataSourcesResult.getDataSources() ) {
                if(DataType.TYPE_STEP_COUNT_CUMULATIVE.equals(dataSource.getDataType())) {
                    Log.d(TAG, "type step");
                    registerStepsDataListener(dataSource, DataType.TYPE_STEP_COUNT_CUMULATIVE);
                }
            }
        }
    };

    Fitness.SensorsApi.findDataSources(googleApiClient, dataSourceRequest)
            .setResultCallback(dataSourcesResultCallback);
}

@OverridepublicvoidonConnectionSuspended(int i) {
    Log.d(TAG, "Connection suspended i= " + i);
}

@OverridepublicvoidonConnectionFailed(@NonNull ConnectionResult connectionResult) {
    if( !authInProgress ) {
        Log.d(TAG, "!AUTHINPROG");
        try {
            authInProgress = true;
            connectionResult.startResolutionForResult(this, 1);
        } catch(IntentSender.SendIntentException e ) {
            Log.d(TAG, "SendIntentExc: " + e.toString());
        }
    } else {
        Log.d(TAG, "authInProgress" );
    }
}

privatevoidregisterStepsDataListener(DataSource dataSource, DataType dataType) {

    SensorRequestrequest=newSensorRequest.Builder()
            .setDataSource(dataSource)
            .setDataType(dataType)
            .setSamplingRate(3, TimeUnit.SECONDS )
            .build();

    Fitness.SensorsApi.add(googleApiClient, request, this)
            .setResultCallback(newResultCallback<Status>() {
                @OverridepublicvoidonResult(Status status) {
                    if (status.isSuccess()) {
                        Log.d(TAG, "SensorApi successfully added" );
                    }
                }
            });
}

@OverridepublicvoidonDataPoint(DataPoint dataPoint) {
    for( final Field field : dataPoint.getDataType().getFields() ) {
        finalValuevalue= dataPoint.getValue( field );
        Log.d(TAG, "Field Name: " + field.getName() + " Value: " + value.toString());
        runOnUiThread(newRunnable() {
            @Overridepublicvoidrun() {
                Toast.makeText(MainActivity.this, "Field: " + field.getName() + " Value: " + value, Toast.LENGTH_SHORT).show();
            }
        });
    }
}

@OverrideprotectedvoidonActivityResult(int requestCode, int resultCode, Intent data) {
    Log.d(TAG, "OnActivityResult called");
    if( requestCode == 1) {
        authInProgress = false;
        if( resultCode == RESULT_OK ) {
            Log.d(TAG, "Result_OK");
            if( !googleApiClient.isConnecting() && !googleApiClient.isConnected() ) {
                Log.d(TAG, "Calling googleApiClient.connect again");
                googleApiClient.connect(GoogleApiClient.SIGN_IN_MODE_OPTIONAL);
            } else {
                onConnected(null);
            }
        } elseif( resultCode == RESULT_CANCELED ) {
            Log.d( TAG, "RESULT_CANCELED" );
        }
    } else {
        Log.d(TAG, "requestCode NOT request_oauth");
    }
}

@OverrideprotectedvoidonStop() {
    Log.d(TAG, "Onstop called");
    super.onStop();

    Fitness.SensorsApi.remove( googleApiClient, this )
            .setResultCallback(newResultCallback<Status>() {
                @OverridepublicvoidonResult(Status status) {
                    if (status.isSuccess()) {
                        googleApiClient.disconnect();
                    }
                }
            });
}

@OverrideprotectedvoidonSaveInstanceState(Bundle outState) {
    super.onSaveInstanceState(outState);
    Log.d(TAG, "Onsaveinstance called");
    outState.putBoolean(AUTH_PENDING, authInProgress);
}
}