Add a mechanism to pause and resume geolocation requests.

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

-// Copyright 2012 The Chromium Authors. All rights reserved.
+// Copyright 2013 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;
 import android.location.LocationManager;
 import android.os.Bundle;
 import android.util.Log;
 
-import org.chromium.base.ActivityStatus;
-import org.chromium.base.CalledByNative;
+import com.google.common.annotations.VisibleForTesting;
+
 import org.chromium.base.ThreadUtils;
 
 import java.util.List;
-import java.util.concurrent.FutureTask;
 
 /**
- * Implements the Java side of LocationProviderAndroid.
- * Delegates all real functionality to the inner class.
- * See detailed documentation on
- * content/browser/geolocation/android_location_api_adapter.h.
- * Based on android.webkit.GeolocationService.java
+ * Factory to create a LocationProvider to allow us to inject
+ * a mock for tests.
  */
-class LocationProvider {
+public class LocationProviderFactory {
+    private static LocationProviderFactory.LocationProvider sProviderImpl;
 
-    // Log tag
-    private static final String TAG = "LocationProvider";
+    /**
+     * LocationProviderFactory.get() returns an instance of this interface.
+     */
+    public interface LocationProvider {
+        public void start(boolean gpsEnabled);
+        public void stop();
+        public boolean isRunning();
+    }
+
+    private LocationProviderFactory() {
+    }
+
+    @VisibleForTesting
+    public static void setLocationProviderImpl(LocationProviderFactory.LocationProvider provider) {
+        assert sProviderImpl == null;
+        sProviderImpl = provider;
+    }
+
+    public static LocationProvider get(Context context) {
+        if (sProviderImpl == null) {
+            sProviderImpl = new LocationProviderImpl(context);
+        }
+        return sProviderImpl;
+    }
 
     /**
      * 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.StateListener {
+            implements LocationListener, LocationProviderFactory.LocationProvider {
+
+        // Log tag
+        private static final String TAG = "LocationProvider";
 
         private Context mContext;
         private LocationManager mLocationManager;
         private boolean mIsRunning;
-        private boolean mShouldRunAfterActivityResume;
-        private boolean mIsGpsEnabled;
 
         LocationProviderImpl(Context context) {
             mContext = context;
         }
 
-        @Override
-        public void onActivityStateChange(int state) {
-            if (state == ActivityStatus.PAUSED) {
-                mShouldRunAfterActivityResume |= mIsRunning;
-                unregisterFromLocationUpdates();
-            } 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.registerStateListener(this);
-            }
-            mIsGpsEnabled = gpsEnabled;
-
-            if (ActivityStatus.getState() != ActivityStatus.RESUMED) {
-                mShouldRunAfterActivityResume = true;
-            } else {
-                unregisterFromLocationUpdates();
-                registerForLocationUpdates();
-            }
+        @Override
+        public void start(boolean gpsEnabled) {
+            unregisterFromLocationUpdates();
+            registerForLocationUpdates(gpsEnabled);
         }
 
         /**
          * Stop listening for location updates.
          */
-        private void stop() {
+        @Override
+        public void stop() {
             unregisterFromLocationUpdates();
-            ActivityStatus.unregisterStateListener(this);
-            mShouldRunAfterActivityResume = false;
         }
 
         /**
          * Returns true if we are currently listening for location updates, false if not.
          */
-        private boolean isRunning() {
+        @Override
+        public boolean isRunning() {
             return mIsRunning;
         }
 
         @Override
         public void onLocationChanged(Location location) {
             // Callbacks from the system location sevice are queued to this thread, so it's
             // possible that we receive callbacks after unregistering. At this point, the
             // native object will no longer exist.
             if (mIsRunning) {
                 updateNewLocation(location);
             }
         }
 
         private void updateNewLocation(Location location) {
-            nativeNewLocationAvailable(location.getLatitude(), location.getLongitude(),
+            LocationProviderAdapter.newLocationAvailable(
+                    location.getLatitude(), location.getLongitude(),
                     location.getTime() / 1000.0,
                     location.hasAltitude(), location.getAltitude(),
                     location.hasAccuracy(), location.getAccuracy(),
                     location.hasBearing(), location.getBearing(),
                     location.hasSpeed(), location.getSpeed());
         }
 
         @Override
         public void onStatusChanged(String provider, int status, Bundle extras) {
         }
@@ skipping 11 matching lines @@
             mLocationManager = (LocationManager) mContext.getSystemService(
                     Context.LOCATION_SERVICE);
             if (mLocationManager == null) {
                 Log.e(TAG, "Could not get location manager.");
             }
         }
 
         /**
          * Registers this object with the location service.
          */
-        private void registerForLocationUpdates() {
+        private void registerForLocationUpdates(boolean isGpsEnabled) {
             ensureLocationManagerCreated();
             if (usePassiveOneShotLocation()) return;
 
             assert !mIsRunning;
             mIsRunning = true;
 
             // We're running on the main thread. The C++ side is responsible to
             // bounce notifications to the Geolocation thread as they arrive in the mainLooper.
             try {
                 Criteria criteria = new Criteria();
                 mLocationManager.requestLocationUpdates(0, 0, criteria, this,
                         ThreadUtils.getUiThreadLooper());
-                if (mIsGpsEnabled) {
+                if (isGpsEnabled) {
                     criteria.setAccuracy(Criteria.ACCURACY_FINE);
                     mLocationManager.requestLocationUpdates(0, 0, criteria, this,
                             ThreadUtils.getUiThreadLooper());
                 }
             } catch (SecurityException e) {
                 Log.e(TAG, "Caught security exception registering for location updates from " +
                     "system. This should only happen in DumpRenderTree.");
             } catch (IllegalArgumentException e) {
                 Log.e(TAG, "Caught IllegalArgumentException registering for location updates.");
             }
@@ skipping 31 matching lines @@
         /*
          * Checks if the passive location provider is the only provider available
          * in the system.
          */
         private boolean isOnlyPassiveLocationProviderEnabled() {
             List<String> providers = mLocationManager.getProviders(true);
             return providers != null && providers.size() == 1
                     && providers.get(0).equals(LocationManager.PASSIVE_PROVIDER);
         }
     }
+}
 
-    // Delegate handling the real work in the main thread.
-    private LocationProviderImpl mImpl;
 
-    private LocationProvider(Context context) {
-        mImpl = new LocationProviderImpl(context);
-    }
-
-    @CalledByNative
-    static LocationProvider create(Context context) {
-        return new LocationProvider(context);
-    }
-
-    /**
-     * Start listening for location updates until we're told to quit. May be
-     * called in any thread.
-     * @param gpsEnabled Whether or not we're interested in high accuracy GPS.
-     */
-    @CalledByNative
-    public boolean start(final boolean gpsEnabled) {
-        FutureTask<Void> task = new FutureTask<Void>(new Runnable() {
-            @Override
-            public void run() {
-                mImpl.start(gpsEnabled);
-            }
-        }, null);
-        ThreadUtils.runOnUiThread(task);
-        return true;
-    }
-
-    /**
-     * Stop listening for location updates. May be called in any thread.
-     */
-    @CalledByNative
-    public void stop() {
-        FutureTask<Void> task = new FutureTask<Void>(new Runnable() {
-            @Override
-            public void run() {
-                mImpl.stop();
-            }
-        }, null);
-        ThreadUtils.runOnUiThread(task);
-    }
-
-    /**
-     * Returns true if we are currently listening for location updates, false if not.
-     * Must be called only in the UI thread.
-     */
-    public boolean isRunning() {
-        assert ThreadUtils.runningOnUiThread();
-        return mImpl.isRunning();
-    }
-
-    // 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);
-}