com.google.android.gms.fitness.FitnessActivities Java Examples

/**
 * Starts a new session for Fit data. This will take care of registering all the sensors,
 * recording the sensor data, and registering the data set as a session to Google Fit.
 * @param dataTypeSettings Types of data to listen to, in an array.
 * @param sessionDescription The description of the session.
 * @param listener The OnDataPointListener to receive sensor events.
 */
public void startFitDataSession(FitDataTypeSetting[] dataTypeSettings,
                                String sessionDescription, OnDataPointListener listener) {
    for (FitDataTypeSetting dataTypeSetting : dataTypeSettings) {
        registerFitDataListener(dataTypeSetting, listener);
        startRecordingFitData(dataTypeSetting);
    }

    Session session = new Session.Builder()
            .setName(SESSION_NAME)
            .setDescription(sessionDescription)
            .setActivity(FitnessActivities.RUNNING_JOGGING)
            .setStartTime(System.currentTimeMillis(), TimeUnit.MILLISECONDS)
            .build();

    PendingResult<Status> pendingResult =
            Fitness.SessionsApi.startSession(mGoogleApiClient, session);
    pendingResult.setResultCallback(new FitResultCallback<Status>(
            this, FitResultCallback.RegisterType.SESSION, null /* dataType */,
            true /* subscribe */));
}
 

/**
 * Sessions can include multiple data set types.
 *
 * @param startTime Start time for the activity in milliseconds
 * @param endTime End time for the activity in milliseconds
 * @param stepCountDelta Number of steps during the activity
 * @param activityName Name of the activity, must match FitnessActivities types
 * @param packageName Package name for the app
 * @return Resulting insert request
 */
public static SessionInsertRequest createSession(long startTime, long endTime, int stepCountDelta, String activityName, String packageName, Device device) {
    // Create a session with metadata about the activity.
    Session session = new Session.Builder()
            .setName(TAG)
            //.setDescription("Long run around Shoreline Park")
            .setIdentifier(packageName + ":" + startTime)
            .setActivity(FitnessActivities.WALKING)
            .setStartTime(startTime, TimeUnit.MILLISECONDS)
            .setEndTime(endTime, TimeUnit.MILLISECONDS)
            .build();

    // Build a session insert request

    return new SessionInsertRequest.Builder()
            .setSession(session)
            .addDataSet(createStepDeltaDataSet(startTime, endTime, stepCountDelta, packageName, device))
            .addDataSet(createActivityDataSet(startTime, endTime, activityName, packageName, device))
            .build();
}
 

@OnClick(R.id.btn_start_session)
public void startSession() {
    mSession = new Session.Builder()
            .setName(SESSION_NAME)
            .setIdentifier(getString(R.string.app_name) + " " + System.currentTimeMillis())
            .setDescription("Yoga Session Description")
            .setStartTime(Calendar.getInstance().getTimeInMillis(), TimeUnit.MILLISECONDS)
            .setActivity(FitnessActivities.YOGA)
            .build();

    PendingResult<Status> pendingResult =
            Fitness.SessionsApi.startSession(mGoogleApiClient, mSession);

    pendingResult.setResultCallback(
            new ResultCallback<Status>() {
                @Override
                public void onResult(Status status) {
                    if (status.isSuccess()) {
                        Log.i("Tuts+", "Successfully started session");
                    } else {
                        Log.i("Tuts+", "Failed to start session: " + status.getStatusMessage());
                    }
                }
            }
    );
}
 

public DetectedToFitnessActivityAdapater(int activity) {
    switch (activity) {
        case DetectedActivity.ON_BICYCLE:
            _activity = FitnessActivities.BIKING;
            break;
        case DetectedActivity.STILL:
            _activity = FitnessActivities.STILL;
            break;
        case DetectedActivity.WALKING:
            _activity = FitnessActivities.WALKING;
            break;
        case DetectedActivity.RUNNING:
            _activity = FitnessActivities.RUNNING;
            break;
        case DetectedActivity.ON_FOOT:
            _activity = FitnessActivities.ON_FOOT;
    }
}
 

@SmallTest
public void testSaveActiveSessionCallBackWithNoRecognisedActivityCreates1DataPoints() {

    // setup the mock to return the same start time as set
    startSession(1000);

    when(_mockSession.getStartTime(TimeUnit.MILLISECONDS)).thenReturn((long)1000);

    _sessionManager.saveActiveSession(2000);
    DataSet dataSet = getDataSet();

    assertEquals(1,dataSet.getDataPoints().size());
    assertEquals("Start time should equal session start time",1000,dataSet.getDataPoints().get(0).getStartTime(TimeUnit.MILLISECONDS));
    assertEquals("End time should equal session end time", 2000,dataSet.getDataPoints().get(0).getEndTime(TimeUnit.MILLISECONDS));
    assertEquals("Activity should equal unknown", FitnessActivities.UNKNOWN, dataSet.getDataPoints().get(0).getValue(Field.FIELD_ACTIVITY).asActivity());
}
 

@SmallTest
public void test2DuplicateActivityEventsCreates1DataPoints() {
    startSession(1000);

    _sessionManager.addDataPoint(2000, DetectedActivity.RUNNING);
    _sessionManager.addDataPoint(3000, DetectedActivity.RUNNING);

    _sessionManager.saveActiveSession(4000);

    DataSet dataSet = getDataSet();

    assertEquals(1,dataSet.getDataPoints().size());
    assertEquals("Start time should equal data start time",2000,dataSet.getDataPoints().get(0).getStartTime(TimeUnit.MILLISECONDS));
    assertEquals("End time should equal session end time", 4000,dataSet.getDataPoints().get(0).getEndTime(TimeUnit.MILLISECONDS));
    assertEquals("Activity should equal unknown", FitnessActivities.RUNNING, dataSet.getDataPoints().get(0).getValue(Field.FIELD_ACTIVITY).asActivity());
}
 

@SmallTest
public void test2UniqueActivityEventsCreates2DataPoints() {
    startSession(1000);

    _sessionManager.addDataPoint(2000, DetectedActivity.RUNNING);
    _sessionManager.addDataPoint(3000, DetectedActivity.WALKING);

    _sessionManager.saveActiveSession(4000);

    DataSet dataSet = getDataSet();

    assertEquals(2,dataSet.getDataPoints().size());

    assertEquals("Start time should equal data start time",2000,dataSet.getDataPoints().get(0).getStartTime(TimeUnit.MILLISECONDS));
    assertEquals("End time should equal session end time", 3000,dataSet.getDataPoints().get(0).getEndTime(TimeUnit.MILLISECONDS));
    assertEquals("Activity should equal unknown", FitnessActivities.RUNNING, dataSet.getDataPoints().get(0).getValue(Field.FIELD_ACTIVITY).asActivity());

    assertEquals("Start time should equal data start time",3000,dataSet.getDataPoints().get(1).getStartTime(TimeUnit.MILLISECONDS));
    assertEquals("End time should equal session end time", 4000,dataSet.getDataPoints().get(1).getEndTime(TimeUnit.MILLISECONDS));
    assertEquals("Activity should equal unknown", FitnessActivities.WALKING, dataSet.getDataPoints().get(1).getValue(Field.FIELD_ACTIVITY).asActivity());
}
 

@SmallTest
public void testNewWALKINGActivityEventCreates1DataPoints() {
    startSession(1000);

    _sessionManager.addDataPoint(2000, DetectedActivity.WALKING);

    _sessionManager.saveActiveSession(3000);

    DataSet dataSet = getDataSet();

    assertEquals(1,dataSet.getDataPoints().size());
    assertEquals("Start time should equal data start time",2000,dataSet.getDataPoints().get(0).getStartTime(TimeUnit.MILLISECONDS));
    assertEquals("End time should equal session end time", 3000,dataSet.getDataPoints().get(0).getEndTime(TimeUnit.MILLISECONDS));
    assertEquals("Activity should equal unknown", FitnessActivities.WALKING, dataSet.getDataPoints().get(0).getValue(Field.FIELD_ACTIVITY).asActivity());
}
 

@SmallTest
public void testNewON_BICYCLEActivityEventCreates1DataPoints() {
    startSession(1000);

    _sessionManager.addDataPoint(2000, DetectedActivity.ON_BICYCLE);

    _sessionManager.saveActiveSession(3000);

    DataSet dataSet = getDataSet();

    assertEquals(1,dataSet.getDataPoints().size());
    assertEquals("Start time should equal data start time",2000,dataSet.getDataPoints().get(0).getStartTime(TimeUnit.MILLISECONDS));
    assertEquals("End time should equal session end time", 3000,dataSet.getDataPoints().get(0).getEndTime(TimeUnit.MILLISECONDS));
    assertEquals("Activity should equal unknown", FitnessActivities.BIKING, dataSet.getDataPoints().get(0).getValue(Field.FIELD_ACTIVITY).asActivity());
}
 

@SmallTest
public void testNewRUNNINGActivityEventCreates1DataPoints() {
    startSession(1000);

    _sessionManager.addDataPoint(2000, DetectedActivity.RUNNING);

    _sessionManager.saveActiveSession(3000);

    DataSet dataSet = getDataSet();

    assertEquals(1,dataSet.getDataPoints().size());
    assertEquals("Start time should equal data start time",2000,dataSet.getDataPoints().get(0).getStartTime(TimeUnit.MILLISECONDS));
    assertEquals("End time should equal session end time", 3000,dataSet.getDataPoints().get(0).getEndTime(TimeUnit.MILLISECONDS));
    assertEquals("Activity should equal unknown", FitnessActivities.RUNNING, dataSet.getDataPoints().get(0).getValue(Field.FIELD_ACTIVITY).asActivity());
}
 

@RequiresApi(api = Build.VERSION_CODES.N)
public void getSleepData(double startDate, double endDate, final Callback errorCallback, final Callback successCallback) {
    SessionReadRequest request = new SessionReadRequest.Builder()
            .readSessionsFromAllApps()
            .read(DataType.TYPE_ACTIVITY_SEGMENT)
            .setTimeInterval((long) startDate, (long) endDate, TimeUnit.MILLISECONDS)
            .build();

    GoogleSignInAccount gsa = GoogleSignIn.getAccountForScopes(this.mReactContext, new Scope(Scopes.FITNESS_ACTIVITY_READ));
    Fitness.getSessionsClient(this.mReactContext, gsa)
            .readSession(request)
            .addOnSuccessListener(new OnSuccessListener<SessionReadResponse>() {
                @Override
                public void onSuccess(SessionReadResponse response) {
                    List<Object> sleepSessions = response.getSessions()
                        .stream()
                        .filter(new Predicate<Session>() {
                            @Override
                            public boolean test(Session s) {
                                Log.i(TAG, "Activity found: " + s.getActivity());
                                return s.getActivity().equals(FitnessActivities.SLEEP);
                            }
                        })
                        .collect(Collectors.toList());

                    WritableArray sleep = Arguments.createArray();

                    for (Object session : sleepSessions) {
                        List<DataSet> dataSets = response.getDataSet((Session) session);

                        for (DataSet dataSet : dataSets) {
                            processDataSet(dataSet, (Session) session, sleep);
                        }
                    }

                    successCallback.invoke(sleep);
                }
            })
            .addOnFailureListener(new OnFailureListener() {
                @Override
                public void onFailure(@NonNull Exception e) {
                    Log.i(TAG, "Failure: " + e.getMessage());
                    errorCallback.invoke(e.getMessage());
                }
            });
}
 

protected Void doInBackground(Void... params) {
    Log.d(LOG_TAG, "readDataTask");
    Calendar cal = Calendar.getInstance();
    Date now = new Date();
    cal.setTime(now);
    long endTime = cal.getTimeInMillis();
    cal.add(Calendar.DAY_OF_MONTH, -3);
    long startTime = cal.getTimeInMillis();
    lastPedometerSteps = 0;
    lastPedometerCals = 0;
    lastPedometerDist = 0;

    SessionReadRequest readRequest = new SessionReadRequest.Builder()
    .setTimeInterval(startTime, endTime, TimeUnit.MILLISECONDS)
    .read(DataType.TYPE_ACTIVITY_SEGMENT)
    .build();

    SessionReadResult sessionReadResult = Fitness.SessionsApi.readSession(mClient, readRequest).await(1, TimeUnit.MINUTES);

    Log.d(LOG_TAG, "Session read was successful. Number of returned sessions is: " + sessionReadResult.getSessions().size());
    for(Session session : sessionReadResult.getSessions()) {
        Date start = new Date(session.getStartTime(TimeUnit.MILLISECONDS));
        Date end = new Date(session.getEndTime(TimeUnit.MILLISECONDS));
        Log.d(LOG_TAG, "Description: " + session.getDescription());
        Log.d(LOG_TAG, "start: " + start + ", end: " + end);
        Log.d(LOG_TAG, "Activity" + session.getActivity());

        List<DataSet> dataSets = sessionReadResult.getDataSet(session);
        for(DataSet dataSet : dataSets) {
            for(DataPoint dp : dataSet.getDataPoints()) {
                if(session.getActivity() == FitnessActivities.WALKING) {
                    long sTime = dp.getStartTime(TimeUnit.MILLISECONDS);
                    if(sTime % 600000 == 0) {
                        lastPedometerStartTime = new Date(sTime);
                    }
                    lastPedometerSession = new Date(dp.getEndTime(TimeUnit.MILLISECONDS));
                }
                else if(session.getActivity() == FitnessActivities.WALKING_FITNESS) {
                    lastWalkingSession = new Date(dp.getEndTime(TimeUnit.MILLISECONDS));
                }
                else if(session.getActivity() == FitnessActivities.RUNNING) {
                    lastRunningSession = new Date(dp.getEndTime(TimeUnit.MILLISECONDS));
                }
                else if(session.getActivity() == FitnessActivities.SLEEP) {
                    lastSleepSession = new Date(dp.getStartTime(TimeUnit.MILLISECONDS));
                }
                else if(session.getActivity() == FitnessActivities.BIKING) {
                    lastCyclingSession = new Date(dp.getEndTime(TimeUnit.MILLISECONDS));
                }
                else if(session.getActivity() == FitnessActivities.HIKING) {
                    lastHikingSession = new Date(dp.getEndTime(TimeUnit.MILLISECONDS));
                }
            }
        }
    }

    if(lastPedometerSession != null) {
        if(lastWalkingSession != null && lastPedometerSession.getTime() < lastWalkingSession.getTime()) {
            lastPedometerSession = lastWalkingSession;
        }
        if(lastRunningSession != null && lastPedometerSession.getTime() < lastRunningSession.getTime()) {
            lastPedometerSession = lastRunningSession;
        }
        if(lastCyclingSession != null && lastPedometerSession.getTime() < lastCyclingSession.getTime()) {
            lastPedometerSession = lastCyclingSession;
        }
        if(lastHikingSession != null && lastPedometerSession.getTime() < lastHikingSession.getTime()) {
            lastPedometerSession = lastHikingSession;
        }
        Calendar calendar = Calendar.getInstance();
        calendar.setTime(lastPedometerSession);
        int minute = ((int) (calendar.get(Calendar.MINUTE) / 10.0) * 10);
        calendar.set(Calendar.MINUTE, minute);
        calendar.set(Calendar.SECOND, 0);
        calendar.set(Calendar.MILLISECOND, 0);
        lastPedometerStartTime = calendar.getTime();
        if(lastPedometerStartTime.getTime() == lastPedometerSession.getTime()) {
            calendar.add(Calendar.MINUTE, -10);
            lastPedometerStartTime = calendar.getTime();
        }
    }

    Log.d(LOG_TAG, "Last session updated start: " + lastPedometerStartTime + ", end: " + lastPedometerSession);

    lastPedometerSteps = prefs.getInt(prefsSteps, 0);
    lastPedometerCals = prefs.getFloat(prefsCals, 0);
    lastPedometerDist = prefs.getFloat(prefsDist, 0);

    Log.d(LOG_TAG, "Last pedometer session from: " + lastPedometerStartTime + " to: " + lastPedometerSession + " steps: " + lastPedometerSteps + " cals: " + lastPedometerCals + " dist: " + lastPedometerDist);
    Log.d(LOG_TAG, "Last walking session: " + lastWalkingSession);
    Log.d(LOG_TAG, "Last running session: " + lastRunningSession);
    Log.d(LOG_TAG, "Last cycling session: " + lastCyclingSession);
    Log.d(LOG_TAG, "Last hiking session: " + lastHikingSession);
    writeData();
    return null;
}
 

private void createUnknownDataPoint(Session session, long endTime) {
    DataPoint firstRunningDp = _activitySegments.createDataPoint()
            .setTimeInterval(session.getStartTime(TimeUnit.MILLISECONDS), endTime, TimeUnit.MILLISECONDS);
    firstRunningDp.getValue(Field.FIELD_ACTIVITY).setActivity(FitnessActivities.UNKNOWN);
    _activitySegments.add(firstRunningDp);
}