OLD | NEW |
| (Empty) |
1 // Copyright 2012 The Chromium Authors. All rights reserved. | |
2 // Use of this source code is governed by a BSD-style license that can be | |
3 // found in the LICENSE file. | |
4 | |
5 package org.chromium.content.browser; | |
6 | |
7 import android.content.Context; | |
8 import android.location.Criteria; | |
9 import android.location.Location; | |
10 import android.location.LocationListener; | |
11 import android.location.LocationManager; | |
12 import android.os.Bundle; | |
13 import android.util.Log; | |
14 | |
15 import org.chromium.base.ActivityStatus; | |
16 import org.chromium.base.CalledByNative; | |
17 import org.chromium.base.ThreadUtils; | |
18 | |
19 import java.util.List; | |
20 import java.util.concurrent.FutureTask; | |
21 | |
22 /** | |
23 * Implements the Java side of LocationProviderAndroid. | |
24 * Delegates all real functionality to the inner class. | |
25 * See detailed documentation on | |
26 * content/browser/geolocation/android_location_api_adapter.h. | |
27 * Based on android.webkit.GeolocationService.java | |
28 */ | |
29 class LocationProvider { | |
30 | |
31 // Log tag | |
32 private static final String TAG = "LocationProvider"; | |
33 | |
34 /** | |
35 * This is the core of android location provider. It is a separate class for
clarity | |
36 * so that it can manage all processing completely in the UI thread. The con
tainer class | |
37 * ensures that the start/stop calls into this class are done in the UI thre
ad. | |
38 */ | |
39 private static class LocationProviderImpl | |
40 implements LocationListener, ActivityStatus.StateListener { | |
41 | |
42 private Context mContext; | |
43 private LocationManager mLocationManager; | |
44 private boolean mIsRunning; | |
45 private boolean mShouldRunAfterActivityResume; | |
46 private boolean mIsGpsEnabled; | |
47 | |
48 LocationProviderImpl(Context context) { | |
49 mContext = context; | |
50 } | |
51 | |
52 @Override | |
53 public void onActivityStateChange(int state) { | |
54 if (state == ActivityStatus.PAUSED) { | |
55 mShouldRunAfterActivityResume |= mIsRunning; | |
56 unregisterFromLocationUpdates(); | |
57 } else if (state == ActivityStatus.RESUMED) { | |
58 assert !mIsRunning; | |
59 if (mShouldRunAfterActivityResume) { | |
60 registerForLocationUpdates(); | |
61 } | |
62 } | |
63 } | |
64 | |
65 /** | |
66 * Start listening for location updates. | |
67 * @param gpsEnabled Whether or not we're interested in high accuracy GP
S. | |
68 */ | |
69 private void start(boolean gpsEnabled) { | |
70 if (!mIsRunning && !mShouldRunAfterActivityResume) { | |
71 // Currently idle so start listening to activity status changes. | |
72 ActivityStatus.registerStateListener(this); | |
73 } | |
74 mIsGpsEnabled = gpsEnabled; | |
75 | |
76 if (ActivityStatus.getState() != ActivityStatus.RESUMED) { | |
77 mShouldRunAfterActivityResume = true; | |
78 } else { | |
79 unregisterFromLocationUpdates(); | |
80 registerForLocationUpdates(); | |
81 } | |
82 } | |
83 | |
84 /** | |
85 * Stop listening for location updates. | |
86 */ | |
87 private void stop() { | |
88 unregisterFromLocationUpdates(); | |
89 ActivityStatus.unregisterStateListener(this); | |
90 mShouldRunAfterActivityResume = false; | |
91 } | |
92 | |
93 /** | |
94 * Returns true if we are currently listening for location updates, fals
e if not. | |
95 */ | |
96 private boolean isRunning() { | |
97 return mIsRunning; | |
98 } | |
99 | |
100 @Override | |
101 public void onLocationChanged(Location location) { | |
102 // Callbacks from the system location sevice are queued to this thre
ad, so it's | |
103 // possible that we receive callbacks after unregistering. At this p
oint, the | |
104 // native object will no longer exist. | |
105 if (mIsRunning) { | |
106 updateNewLocation(location); | |
107 } | |
108 } | |
109 | |
110 private void updateNewLocation(Location location) { | |
111 nativeNewLocationAvailable(location.getLatitude(), location.getLongi
tude(), | |
112 location.getTime() / 1000.0, | |
113 location.hasAltitude(), location.getAltitude(), | |
114 location.hasAccuracy(), location.getAccuracy(), | |
115 location.hasBearing(), location.getBearing(), | |
116 location.hasSpeed(), location.getSpeed()); | |
117 } | |
118 | |
119 @Override | |
120 public void onStatusChanged(String provider, int status, Bundle extras)
{ | |
121 } | |
122 | |
123 @Override | |
124 public void onProviderEnabled(String provider) { | |
125 } | |
126 | |
127 @Override | |
128 public void onProviderDisabled(String provider) { | |
129 } | |
130 | |
131 private void ensureLocationManagerCreated() { | |
132 if (mLocationManager != null) return; | |
133 mLocationManager = (LocationManager) mContext.getSystemService( | |
134 Context.LOCATION_SERVICE); | |
135 if (mLocationManager == null) { | |
136 Log.e(TAG, "Could not get location manager."); | |
137 } | |
138 } | |
139 | |
140 /** | |
141 * Registers this object with the location service. | |
142 */ | |
143 private void registerForLocationUpdates() { | |
144 ensureLocationManagerCreated(); | |
145 if (usePassiveOneShotLocation()) return; | |
146 | |
147 assert !mIsRunning; | |
148 mIsRunning = true; | |
149 | |
150 // We're running on the main thread. The C++ side is responsible to | |
151 // bounce notifications to the Geolocation thread as they arrive in
the mainLooper. | |
152 try { | |
153 Criteria criteria = new Criteria(); | |
154 mLocationManager.requestLocationUpdates(0, 0, criteria, this, | |
155 ThreadUtils.getUiThreadLooper()); | |
156 if (mIsGpsEnabled) { | |
157 criteria.setAccuracy(Criteria.ACCURACY_FINE); | |
158 mLocationManager.requestLocationUpdates(0, 0, criteria, this
, | |
159 ThreadUtils.getUiThreadLooper()); | |
160 } | |
161 } catch (SecurityException e) { | |
162 Log.e(TAG, "Caught security exception registering for location u
pdates from " + | |
163 "system. This should only happen in DumpRenderTree."); | |
164 } catch (IllegalArgumentException e) { | |
165 Log.e(TAG, "Caught IllegalArgumentException registering for loca
tion updates."); | |
166 } | |
167 } | |
168 | |
169 /** | |
170 * Unregisters this object from the location service. | |
171 */ | |
172 private void unregisterFromLocationUpdates() { | |
173 if (mIsRunning) { | |
174 mIsRunning = false; | |
175 mLocationManager.removeUpdates(this); | |
176 } | |
177 } | |
178 | |
179 private boolean usePassiveOneShotLocation() { | |
180 if (!isOnlyPassiveLocationProviderEnabled()) return false; | |
181 | |
182 // Do not request a location update if the only available location p
rovider is | |
183 // the passive one. Make use of the last known location and call | |
184 // onLocationChanged directly. | |
185 final Location location = mLocationManager.getLastKnownLocation( | |
186 LocationManager.PASSIVE_PROVIDER); | |
187 if (location != null) { | |
188 ThreadUtils.runOnUiThread(new Runnable() { | |
189 @Override | |
190 public void run() { | |
191 updateNewLocation(location); | |
192 } | |
193 }); | |
194 } | |
195 return true; | |
196 } | |
197 | |
198 /* | |
199 * Checks if the passive location provider is the only provider availabl
e | |
200 * in the system. | |
201 */ | |
202 private boolean isOnlyPassiveLocationProviderEnabled() { | |
203 List<String> providers = mLocationManager.getProviders(true); | |
204 return providers != null && providers.size() == 1 | |
205 && providers.get(0).equals(LocationManager.PASSIVE_PROVIDER)
; | |
206 } | |
207 } | |
208 | |
209 // Delegate handling the real work in the main thread. | |
210 private LocationProviderImpl mImpl; | |
211 | |
212 private LocationProvider(Context context) { | |
213 mImpl = new LocationProviderImpl(context); | |
214 } | |
215 | |
216 @CalledByNative | |
217 static LocationProvider create(Context context) { | |
218 return new LocationProvider(context); | |
219 } | |
220 | |
221 /** | |
222 * Start listening for location updates until we're told to quit. May be | |
223 * called in any thread. | |
224 * @param gpsEnabled Whether or not we're interested in high accuracy GPS. | |
225 */ | |
226 @CalledByNative | |
227 public boolean start(final boolean gpsEnabled) { | |
228 FutureTask<Void> task = new FutureTask<Void>(new Runnable() { | |
229 @Override | |
230 public void run() { | |
231 mImpl.start(gpsEnabled); | |
232 } | |
233 }, null); | |
234 ThreadUtils.runOnUiThread(task); | |
235 return true; | |
236 } | |
237 | |
238 /** | |
239 * Stop listening for location updates. May be called in any thread. | |
240 */ | |
241 @CalledByNative | |
242 public void stop() { | |
243 FutureTask<Void> task = new FutureTask<Void>(new Runnable() { | |
244 @Override | |
245 public void run() { | |
246 mImpl.stop(); | |
247 } | |
248 }, null); | |
249 ThreadUtils.runOnUiThread(task); | |
250 } | |
251 | |
252 /** | |
253 * Returns true if we are currently listening for location updates, false if
not. | |
254 * Must be called only in the UI thread. | |
255 */ | |
256 public boolean isRunning() { | |
257 assert ThreadUtils.runningOnUiThread(); | |
258 return mImpl.isRunning(); | |
259 } | |
260 | |
261 // Native functions | |
262 public static native void nativeNewLocationAvailable( | |
263 double latitude, double longitude, double timeStamp, | |
264 boolean hasAltitude, double altitude, | |
265 boolean hasAccuracy, double accuracy, | |
266 boolean hasHeading, double heading, | |
267 boolean hasSpeed, double speed); | |
268 public static native void nativeNewErrorAvailable(String message); | |
269 } | |
OLD | NEW |