Java tutorial
/** * Copyright 2014 Google Inc. All Rights Reserved. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ package com.android.fpuna.activityrecognition; import android.app.PendingIntent; import android.content.BroadcastReceiver; import android.content.Context; import android.content.Intent; import android.content.IntentFilter; import android.content.SharedPreferences; import android.os.Bundle; import android.support.v4.content.LocalBroadcastManager; import android.support.v7.app.ActionBarActivity; import android.util.Log; import android.view.View; import android.widget.Button; import android.widget.ListView; import android.widget.Toast; import org.harservice.android.client.ActivityRecognitionClient; import org.harservice.android.common.HumanActivity; import java.util.ArrayList; /** * This sample demonstrates use of the * {@link org.harservice.android.api.ActivityRecognitionApi} to recognize a user's current * activity, such as walking, driving, or standing still. It uses an * {@link android.app.IntentService} to broadcast detected activities through a * {@link BroadcastReceiver}. See the {@link HumanActivity} class for a list of DetectedActivity * types. * <p/> */ public class MainActivity extends ActionBarActivity { protected static final String TAG = "activity-recognition"; /** * A receiver for DetectedActivity objects broadcast by the * {@code ActivityDetectionIntentService}. */ protected ActivityDetectionBroadcastReceiver mBroadcastReceiver; /** * Provides the entry point to Google Play services. */ protected ActivityRecognitionClient mApiClient; /** * Used when requesting or removing activity detection updates. */ private PendingIntent mActivityDetectionPendingIntent; // UI elements. private Button mRequestActivityUpdatesButton; private Button mRemoveActivityUpdatesButton; private ListView mDetectedActivitiesListView; /** * Adapter backed by a list of DetectedActivity objects. */ private DetectedActivitiesAdapter mAdapter; /** * The DetectedActivities that we track in this sample. We use this for initializing the * {@code DetectedActivitiesAdapter}. We also use this for persisting state in * {@code onSaveInstanceState()} and restoring it in {@code onCreate()}. This ensures that each * activity is displayed with the correct confidence level upon orientation changes. */ private ArrayList<HumanActivity> mDetectedActivities; @Override public void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); setContentView(R.layout.main_activity); // Get the UI widgets. mRequestActivityUpdatesButton = (Button) findViewById(R.id.request_activity_updates_button); mRemoveActivityUpdatesButton = (Button) findViewById(R.id.remove_activity_updates_button); mDetectedActivitiesListView = (ListView) findViewById(R.id.detected_activities_listview); // Get a receiver for broadcasts from ActivityDetectionIntentService. mBroadcastReceiver = new ActivityDetectionBroadcastReceiver(); // Enable either the Request Updates button or the Remove Updates button depending on // whether activity updates have been requested. setButtonsEnabledState(); // Reuse the value of mDetectedActivities from the bundle if possible. This maintains state // across device orientation changes. If mDetectedActivities is not stored in the bundle, // populate it with DetectedActivity objects whose confidence is set to 0. Doing this // ensures that the bar graphs for only only the most recently detected activities are // filled in. if (savedInstanceState != null && savedInstanceState.containsKey(Constants.DETECTED_ACTIVITIES)) { mDetectedActivities = (ArrayList<HumanActivity>) savedInstanceState .getSerializable(Constants.DETECTED_ACTIVITIES); } else { mDetectedActivities = new ArrayList<HumanActivity>(); // Set the confidence level of each monitored activity to zero. for (int i = 0; i < Constants.MONITORED_ACTIVITIES.length; i++) { mDetectedActivities.add(new HumanActivity(Constants.MONITORED_ACTIVITIES[i], 0)); } } // Bind the adapter to the ListView responsible for display data for detected activities. mAdapter = new DetectedActivitiesAdapter(this, mDetectedActivities); mDetectedActivitiesListView.setAdapter(mAdapter); // Kick off the request to build GoogleApiClient. buildApiClient(); } /** * Builds a ActivityRecognitionClient. Uses the {@code #addApi} method to request the * ActivityRecognition API. */ protected synchronized void buildApiClient() { mApiClient = new ActivityRecognitionClient(this); } @Override protected void onStart() { super.onStart(); mApiClient.connect(); } @Override protected void onStop() { super.onStop(); mApiClient.disconnect(); } @Override protected void onResume() { super.onResume(); // Register the broadcast receiver that informs this activity of the DetectedActivity // object broadcast sent by the intent service. LocalBroadcastManager.getInstance(this).registerReceiver(mBroadcastReceiver, new IntentFilter(Constants.BROADCAST_ACTION)); } @Override protected void onPause() { // Unregister the broadcast receiver that was registered during onResume(). LocalBroadcastManager.getInstance(this).unregisterReceiver(mBroadcastReceiver); super.onPause(); } /** * Registers for activity recognition updates using * {@link org.harservice.android.api.ActivityRecognitionApi#requestActivityUpdates} */ public void requestActivityUpdatesButtonHandler(View view) { if (!mApiClient.isConnected()) { Toast.makeText(this, getString(R.string.not_connected), Toast.LENGTH_SHORT).show(); return; } mApiClient.getService().requestActivityUpdates(Constants.DETECTION_INTERVAL_IN_MILLISECONDS, getActivityDetectionPendingIntent()); setUpdatesRequestedState(true); setButtonsEnabledState(); } /** * Removes activity recognition updates using * {@link org.harservice.android.api.ActivityRecognitionApi#removeActivityUpdates} */ public void removeActivityUpdatesButtonHandler(View view) { if (!mApiClient.isConnected()) { Toast.makeText(this, getString(R.string.not_connected), Toast.LENGTH_SHORT).show(); return; } // Remove all activity updates for the PendingIntent that was used to request activity // updates. mApiClient.getService().removeActivityUpdates(getActivityDetectionPendingIntent()); setUpdatesRequestedState(false); setButtonsEnabledState(); } /** * Gets a PendingIntent to be sent for each activity detection. */ private PendingIntent getActivityDetectionPendingIntent() { // Reuse the PendingIntent if we already have it. if (mActivityDetectionPendingIntent != null) { return mActivityDetectionPendingIntent; } Intent intent = new Intent(this, DetectedActivitiesIntentService.class); // We use FLAG_UPDATE_CURRENT so that we get the same pending intent back when calling // requestActivityUpdates() and removeActivityUpdates(). return PendingIntent.getService(this, 0, intent, PendingIntent.FLAG_UPDATE_CURRENT); } /** * Ensures that only one button is enabled at any time. The Request Activity Updates button is * enabled if the user hasn't yet requested activity updates. The Remove Activity Updates button * is enabled if the user has requested activity updates. */ private void setButtonsEnabledState() { if (getUpdatesRequestedState()) { mRequestActivityUpdatesButton.setEnabled(false); mRemoveActivityUpdatesButton.setEnabled(true); } else { mRequestActivityUpdatesButton.setEnabled(true); mRemoveActivityUpdatesButton.setEnabled(false); } } /** * Retrieves a SharedPreference object used to store or read values in this app. If a * preferences file passed as the first argument to {@link #getSharedPreferences} * does not exist, it is created when {@link SharedPreferences.Editor} is used to commit * data. */ private SharedPreferences getSharedPreferencesInstance() { return getSharedPreferences(Constants.SHARED_PREFERENCES_NAME, MODE_PRIVATE); } /** * Retrieves the boolean from SharedPreferences that tracks whether we are requesting activity * updates. */ private boolean getUpdatesRequestedState() { return getSharedPreferencesInstance().getBoolean(Constants.ACTIVITY_UPDATES_REQUESTED_KEY, false); } /** * Sets the boolean in SharedPreferences that tracks whether we are requesting activity * updates. */ private void setUpdatesRequestedState(boolean requestingUpdates) { getSharedPreferencesInstance().edit() .putBoolean(Constants.ACTIVITY_UPDATES_REQUESTED_KEY, requestingUpdates).commit(); } /** * Stores the list of detected activities in the Bundle. */ public void onSaveInstanceState(Bundle savedInstanceState) { savedInstanceState.putSerializable(Constants.DETECTED_ACTIVITIES, mDetectedActivities); super.onSaveInstanceState(savedInstanceState); } /** * Processes the list of freshly detected activities. Asks the adapter to update its list of * DetectedActivities with new {@code DetectedActivity} objects reflecting the latest detected * activities. */ protected void updateDetectedActivitiesList(ArrayList<HumanActivity> detectedActivities) { mAdapter.updateActivities(detectedActivities); } /** * Receiver for intents sent by DetectedActivitiesIntentService via a sendBroadcast(). * Receives a list of one or more DetectedActivity objects associated with the current state of * the device. */ public class ActivityDetectionBroadcastReceiver extends BroadcastReceiver { protected static final String TAG = "activity-detection-response-receiver"; @Override public void onReceive(Context context, Intent intent) { ArrayList<HumanActivity> updatedActivities = intent .getParcelableArrayListExtra(Constants.ACTIVITY_EXTRA); updateDetectedActivitiesList(updatedActivities); } } }