title: Step Counter Google FIT API
body: <p>I am currently trying to work with Google Fit API.This is my first App using the API, and I have been mainly by following Google's documentation.</p>
  
  <p>Below is the code that I have which seems to have a problem </p>
  
  <p>The problem I have is that it doesn't seem to be updating the step counter.</p>
  
  <pre><code>public class MainActivity extends Activity
          implements GoogleApiClient.ConnectionCallbacks, GoogleApiClient.OnConnectionFailedListener {
  
          private static final String TAG = "FitActivity";
      //[START Auth_Variable_References]
          private static final int REQUEST_OAUTH = 1;
      // [END auth_variable_references]
          private GoogleApiClient mClient = null;
  
          int mInitialNumberOfSteps = 0;
          private TextView mStepsTextView;
          private boolean mFirstCount = true;
  
      // Create Builder View
          @Override
          protected void onCreate(Bundle savedInstanceState) {
              super.onCreate(savedInstanceState);
              setContentView(R.layout.activity_main);
              mStepsTextView = (TextView) findViewById(R.id.textview_number_of_steps);
          }
  
  
          private void connectFitness() {
              Log.i(TAG, "Connecting...");
  
              // Create the Google API Client
              mClient = new GoogleApiClient.Builder(this)
                      // select the Fitness API
                      .addApi(Fitness.API)
                              // specify the scopes of access
                      .addScope(new Scope(Scopes.FITNESS_ACTIVITY_READ))
                       .addScope(new Scope(Scopes.FITNESS_LOCATION_READ))
                      .addScope(new Scope(Scopes.FITNESS_BODY_READ_WRITE))
                                      // provide callbacks
                              .addConnectionCallbacks(this)
                              .addOnConnectionFailedListener(this)
                              .build();
  
              // Connect the Google API client
              mClient.connect();
          }
  
          // Manage OAuth authentication
          @Override
          public void onConnectionFailed(ConnectionResult result) {
  
              // Error while connecting. Try to resolve using the pending intent returned.
              if (result.getErrorCode() == ConnectionResult.SIGN_IN_REQUIRED ||
                      result.getErrorCode() == FitnessStatusCodes.NEEDS_OAUTH_PERMISSIONS) {
                  try {
                      // Request authentication
                      result.startResolutionForResult(this, REQUEST_OAUTH);
                  } catch (IntentSender.SendIntentException e) {
                      Log.e(TAG, "Exception connecting to the fitness service", e);
                  }
              } else {
                  Log.e(TAG, "Unknown connection issue. Code = " + result.getErrorCode());
              }
          }
  
          @Override
          public void onActivityResult(int requestCode, int resultCode, Intent data) {
              if (requestCode == REQUEST_OAUTH) {
                  if (resultCode == RESULT_OK) {
                      // If the user authenticated, try to connect again
                      mClient.connect();
                  }
              }
          }
  
          @Override
          public void onConnectionSuspended(int i) {
              // If your connection gets lost at some point,
              // you'll be able to determine the reason and react to it here.
              if (i == GoogleApiClient.ConnectionCallbacks.CAUSE_NETWORK_LOST) {
                  Log.i(TAG, "Connection lost.  Cause: Network Lost.");
              } else if (i == GoogleApiClient.ConnectionCallbacks.CAUSE_SERVICE_DISCONNECTED) {
                  Log.i(TAG, "Connection lost.  Reason: Service Disconnected");
              }
          }
  
          @Override
          public void onConnected(Bundle bundle) {
  
              Log.i(TAG, "Connected!");
  
              // Now you can make calls to the Fitness APIs.
              invokeFitnessAPIs();
  
          }
  
          private void invokeFitnessAPIs() {
  
              // Create a listener object to be called when new data is available
              OnDataPointListener listener = new OnDataPointListener() {
                  @Override
                  public void onDataPoint(DataPoint dataPoint) {
  
                      for (Field field : dataPoint.getDataType().getFields()) {
                          Value val = dataPoint.getValue(field);
                          updateTextViewWithStepCounter(val.asInt());
                      }
                  }
              };
  
              //Specify what data sources to return
              DataSourcesRequest req = new DataSourcesRequest.Builder()
                      .setDataSourceTypes(DataSource.TYPE_DERIVED)
                      .setDataTypes(DataType.TYPE_STEP_COUNT_DELTA)
                      .build();
  
              //  Invoke the Sensors API with:
              // - The Google API client object
              // - The data sources request object
              PendingResult&lt;DataSourcesResult&gt; pendingResult =
                      Fitness.SensorsApi.findDataSources(mClient, req);
  
              //  Build a sensor registration request object
              SensorRequest sensorRequest = new SensorRequest.Builder()
                      .setDataType(DataType.TYPE_STEP_COUNT_CUMULATIVE)
                      .setSamplingRate(1, TimeUnit.SECONDS)
                      .build();
  
              //  Invoke the Sensors API with:
              // - The Google API client object
              // - The sensor registration request object
              // - The listener object
              PendingResult&lt;Status&gt; regResult =
                Fitness.SensorsApi.add(mClient,
                        new SensorRequest.Builder()
                        .setDataType(DataType.TYPE_STEP_COUNT_DELTA)
                        .build(),
                        listener);
  
  
              // 4. Check the result asynchronously
              regResult.setResultCallback(new ResultCallback&lt;Status&gt;()
              {
                  @Override
                  public void onResult(Status status) {
                      if (status.isSuccess()) {
                          Log.d(TAG, "listener registered");
                          // listener registered
                      } else {
                          Log.d(TAG, "listener not registered");
                          // listener not registered
                      }
                  }
              });
          }
  
          // Update the Text Viewer with Counter of Steps..
          private void updateTextViewWithStepCounter(final int numberOfSteps) {
              runOnUiThread(new Runnable() {
                  @Override
                  public void run() {
                      Toast.makeText(getBaseContext(), "On Datapoint!", Toast.LENGTH_SHORT);
  
                      if(mFirstCount &amp;&amp; (numberOfSteps != 0)) {
                          mInitialNumberOfSteps = numberOfSteps;
                          mFirstCount = false;
                      }
                      if(mStepsTextView != null){
                          mStepsTextView.setText(String.valueOf(numberOfSteps - mInitialNumberOfSteps));
                      }
                  }
              });
          }
  
      //Start
      @Override
      protected void onStart() {
          super.onStart();
          mFirstCount = true;
          mInitialNumberOfSteps = 0;
          if (mClient == null || !mClient.isConnected()) {
              connectFitness();
          }
      }
      //Stop
          @Override
          protected void onStop() {
              super.onStop();
              if(mClient.isConnected() || mClient.isConnecting()) mClient.disconnect();
              mInitialNumberOfSteps = 0;
              mFirstCount = true;
          }
  
      }
  </code></pre>