android: Improve ActivityStatus and add ChromiumActivity.

content/public/android/java/src/org/chromium/content/browser/LocationProvider.java

 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 package org.chromium.content.browser;
 
 import android.content.Context;
 import android.location.Criteria;
 import android.location.Location;
 import android.location.LocationListener;
@@ skipping 19 matching lines @@
 
     // Log tag
     private static final String TAG = "LocationProvider";
 
     /**
      * This is the core of android location provider. It is a separate class for clarity
      * so that it can manage all processing completely in the UI thread. The container class
      * ensures that the start/stop calls into this class are done in the UI thread.
      */
     private static class LocationProviderImpl
-            implements LocationListener, ActivityStatus.Listener {
+            implements LocationListener, ActivityStatus.StateListener {
 
         private Context mContext;
         private LocationManager mLocationManager;
         private boolean mIsRunning;
         private boolean mShouldRunAfterActivityResume;
         private boolean mIsGpsEnabled;
 
         LocationProviderImpl(Context context) {
             mContext = context;
         }
 
-        public void onActivityStatusChanged(boolean isPaused) {
-            if (isPaused) {
+        public void onActivityStateChange(int state) {
+            if (state == ActivityStatus.PAUSED) {

[digit1, 2012/12/04 15:41:55]

I suspect this should really be STOPPED / STARTED instead. The PAUSED state
means the activity is still visible, e.g. there is a dialog on top of it.

The feature I'm working on (SSL client certificate support) does exactly this,
i.e. it prompts the user through a system UI dialog to select a certificate.
This will definitely put the activity in the paused state. However, I don't see
why we should stop the LocationListener in this case.

The STOPPED state corresponds to the case where the activity is not visible
anymore (and even there, do we want to stop the listener if, say, we display the
settings activity instead of the main one).

I didn't want to address this in this patch, but I'm curious about your opinions
on this topic.

[Philippe, 2012/12/04 16:12:42]

This seems too aggressive indeed. Let's see what the others think.

[joth, 2012/12/04 22:42:09]

+1 ISTM that STOPPED makes more sense here. copying in bulach & jknotten for
opinions.

[John Knottenbelt, 2012/12/05 11:19:52]

This sounds reasonable to me, too.

                 mShouldRunAfterActivityResume = mIsRunning;
                 unregisterFromLocationUpdates();
-            } else {
+            } else if (state == ActivityStatus.RESUMED) {
                 assert !mIsRunning;
                 if (mShouldRunAfterActivityResume) {
                     registerForLocationUpdates();
                 }
             }
         }
 
         /**
          * Start listening for location updates.
          * @param gpsEnabled Whether or not we're interested in high accuracy GPS.
          */
         private void start(boolean gpsEnabled) {
             if (!mIsRunning && !mShouldRunAfterActivityResume) {
                 // Currently idle so start listening to activity status changes.
-                ActivityStatus.getInstance().registerListener(this);
+                ActivityStatus.registerStateListener(this);
             }
             mIsGpsEnabled = gpsEnabled;
             if (ActivityStatus.getInstance().isPaused()) {
                 mShouldRunAfterActivityResume = true;
             } else {
                 unregisterFromLocationUpdates();
                 registerForLocationUpdates();
             }
         }
 
         /**
          * Stop listening for location updates.
          */
         private void stop() {
             unregisterFromLocationUpdates();
-            ActivityStatus.getInstance().unregisterListener(this);
+            ActivityStatus.unregisterStateListener(this);
             mShouldRunAfterActivityResume = false;
         }
 
         /**
          * Returns true if we are currently listening for location updates, false if not.
          */
         private boolean isRunning() {
             return mIsRunning;
         }
 
@@ skipping 126 matching lines @@
 
     // Native functions
     public static native void nativeNewLocationAvailable(
             double latitude, double longitude, double timeStamp,
             boolean hasAltitude, double altitude,
             boolean hasAccuracy, double accuracy,
             boolean hasHeading, double heading,
             boolean hasSpeed, double speed);
     public static native void nativeNewErrorAvailable(String message);
 }