+ * Should be used whenever there Google Play Services is present. In general, use + * {@link LocationClientProvider} to retrieve a configured {@link LocationClient}. + */ +@SuppressLint("MissingPermission") // Permission checks for location services handled in components that use this class +public class GoogleFusedLocationClient + extends BaseLocationClient + implements ConnectionCallbacks, OnConnectionFailedListener, LocationListener { + + /** + * The default requested time between location updates, in milliseconds. + */ + private static final long DEFAULT_UPDATE_INTERVAL = 5000; + + /** + * The default maximum rate at which location updates can arrive (other updates will be throttled), + * in milliseconds. + */ + private static final long DEFAULT_FASTEST_UPDATE_INTERVAL = 2500; + + /** + * Although FusedLocationProviderApi is deprecated, FusedLocationProviderClient which is + * supposed to replace it doesn't work until Google Play Services 11.6.0, released Nov 2017. + * Some of our users have really slow connections and old versions of Play Services so we should + * wait to switch APIs. + */ + @NonNull + private final FusedLocationProviderApi fusedLocationProviderApi; + + @NonNull + private final GoogleApiClient googleApiClient; + + @Nullable + private LocationListener locationListener; + + private long updateInterval = DEFAULT_UPDATE_INTERVAL; + private long fastestUpdateInterval = DEFAULT_FASTEST_UPDATE_INTERVAL; + private boolean retainMockAccuracy; + + /** + * Constructs a new GoogleFusedLocationClient with the provided Context. + *
+ * This Constructor should be used normally. + * + * @param application The application. Used as the Context for building the GoogleApiClient because + * it doesn't release context. + */ + public GoogleFusedLocationClient(@NonNull Application application) { + this(locationServicesClientForContext(application), LocationServices.FusedLocationApi, + (LocationManager) application.getSystemService(Context.LOCATION_SERVICE)); + } + + /** + * Constructs a new AndroidLocationClient with the provided GoogleApiClient + * and FusedLocationProviderApi. + *
+ * This Constructor should only be used for testing. + * + * @param googleApiClient The GoogleApiClient for managing the LocationClient's connection + * to Play Services. + * @param fusedLocationProviderApi The FusedLocationProviderApi for fetching the User's + * location. + */ + public GoogleFusedLocationClient(@NonNull GoogleApiClient googleApiClient, + @NonNull FusedLocationProviderApi fusedLocationProviderApi, + @NonNull LocationManager locationManager) { + super(locationManager); + + this.googleApiClient = googleApiClient; + this.fusedLocationProviderApi = fusedLocationProviderApi; + } + + // LocationClient: + + public void start(LocationClientListener listener) { + setListener(listener); + googleApiClient.registerConnectionCallbacks(this); + googleApiClient.registerConnectionFailedListener(this); + + googleApiClient.connect(); + } + + public void stop() { + stopLocationUpdates(); + + googleApiClient.unregisterConnectionCallbacks(this); + googleApiClient.unregisterConnectionFailedListener(this); + + if (googleApiClient.isConnected()) { + googleApiClient.disconnect(); + } + + if (getListener() != null) { + getListener().onClientStop(); + } + setListener(null); + } + + public void requestLocationUpdates(@NonNull LocationListener locationListener) { + if (!isMonitoringLocation() && googleApiClient.isConnected()) { + fusedLocationProviderApi.requestLocationUpdates(googleApiClient, createLocationRequest(), this); + } + + this.locationListener = locationListener; + } + + public void stopLocationUpdates() { + if (!isMonitoringLocation()) { + return; + } + + if (googleApiClient.isConnected()) { + fusedLocationProviderApi.removeLocationUpdates(googleApiClient, locationListener); + } + locationListener = null; + } + + @Override + public void setRetainMockAccuracy(boolean retainMockAccuracy) { + this.retainMockAccuracy = retainMockAccuracy; + } + + @Override + public Location getLastLocation() { + // We need to block if the Client isn't already connected: + if (!googleApiClient.isConnected()) { + googleApiClient.blockingConnect(); + } + + return LocationUtils.sanitizeAccuracy(fusedLocationProviderApi.getLastLocation(googleApiClient), retainMockAccuracy); + } + + @Override + public boolean isMonitoringLocation() { + return locationListener != null; + } + + @Override + public void setUpdateIntervals(long updateInterval, long fastestUpdateInterval) { + Timber.i("GoogleFusedLocationClient setting update intervals: %d, %d", updateInterval, fastestUpdateInterval); + + this.updateInterval = updateInterval; + this.fastestUpdateInterval = fastestUpdateInterval; + } + + // GoogleFusedLocationClient: + + private LocationRequest createLocationRequest() { + LocationRequest locationRequest = new LocationRequest(); + locationRequest.setPriority(getPriority().getValue()); + + locationRequest.setInterval(updateInterval); + locationRequest.setFastestInterval(fastestUpdateInterval); + + return locationRequest; + } + + // ConnectionCallbacks: + + @Override + public void onConnected(@Nullable Bundle bundle) { + if (getListener() != null) { + getListener().onClientStart(); + } + } + + @Override + public void onConnectionSuspended(int cause) { + } + + // OnConnectionFailedListener: + + @Override + public void onConnectionFailed(@NonNull ConnectionResult connectionResult) { + Analytics.log("GoogleFusedLocationClientConnectionFailed"); + if (getListener() != null) { + getListener().onClientStartFailure(); + } + } + + // LocationListener: + + @Override + public void onLocationChanged(Location location) { + Timber.i("Location changed: %s", location.toString()); + + if (locationListener != null) { + locationListener.onLocationChanged(LocationUtils.sanitizeAccuracy(location, retainMockAccuracy)); + } + } + + /** + * Helper method for building a GoogleApiClient with the LocationServices API. + * + * @param context The Context for building the GoogleApiClient. + * @return A GoogleApiClient with the LocationServices API. + */ + private static GoogleApiClient locationServicesClientForContext(@NonNull Context context) { + return new GoogleApiClient.Builder(context) + .addApi(LocationServices.API) + .build(); + } +} diff --git a/location/src/main/java/org/odk/collect/location/GoogleFusedLocationClient.kt b/location/src/main/java/org/odk/collect/location/GoogleFusedLocationClient.kt deleted file mode 100644 index 42b185f8ab3..00000000000 --- a/location/src/main/java/org/odk/collect/location/GoogleFusedLocationClient.kt +++ /dev/null @@ -1,131 +0,0 @@ -package org.odk.collect.location - -import android.annotation.SuppressLint -import android.app.Application -import android.content.Context -import android.location.Location -import android.location.LocationManager -import android.os.Looper -import com.google.android.gms.location.FusedLocationProviderClient -import com.google.android.gms.location.LocationCallback -import com.google.android.gms.location.LocationListener -import com.google.android.gms.location.LocationRequest -import com.google.android.gms.location.LocationResult -import com.google.android.gms.location.LocationServices -import org.odk.collect.location.LocationClient.LocationClientListener -import org.odk.collect.location.LocationUtils.sanitizeAccuracy - -/** - * An implementation of [LocationClient] that uses Google Play Services to retrieve the User's location. - * - * Should be used whenever Google Play Services is present. In general, use - * [LocationClientProvider] to retrieve a configured [LocationClient]. - */ -class GoogleFusedLocationClient( - private val fusedLocationProviderClientWrapper: FusedLocationProviderClientWrapper, - locationManager: LocationManager -) : BaseLocationClient(locationManager), LocationListener { - - constructor(application: Application) : this( - FusedLocationProviderClientWrapper(LocationServices.getFusedLocationProviderClient(application)), - (application.getSystemService(Context.LOCATION_SERVICE) as LocationManager) - ) - - private var lastKnownLocation: Location? = null - set(value) { - field = sanitizeAccuracy(value, retainMockAccuracy) - } - - private var locationListener: LocationListener? = null - private var updateInterval: Long = 5000 - private var fastestUpdateInterval: Long = 2500 - private var retainMockAccuracy = false - - override fun start(listener: LocationClientListener) { - fusedLocationProviderClientWrapper.start(this) - setListener(listener) - listener.onClientStart() - } - - override fun stop() { - stopLocationUpdates() - getListener()?.onClientStop() - setListener(null) - } - - override fun requestLocationUpdates(locationListener: LocationListener) { - if (!isMonitoringLocation) { - fusedLocationProviderClientWrapper.requestLocationUpdates(createLocationRequest()) - } - this.locationListener = locationListener - } - - override fun stopLocationUpdates() { - if (isMonitoringLocation) { - fusedLocationProviderClientWrapper.removeLocationUpdates() - locationListener = null - } - } - - override fun setRetainMockAccuracy(retainMockAccuracy: Boolean) { - this.retainMockAccuracy = retainMockAccuracy - } - - override fun getLastLocation(): Location? { - return lastKnownLocation - } - - override fun isMonitoringLocation(): Boolean { - return locationListener != null - } - - override fun setUpdateIntervals(updateInterval: Long, fastestUpdateInterval: Long) { - this.updateInterval = updateInterval - this.fastestUpdateInterval = fastestUpdateInterval - } - - override fun onLocationChanged(location: Location) { - lastKnownLocation = location - lastKnownLocation?.let { - locationListener?.onLocationChanged(it) - } - } - - private fun createLocationRequest(): LocationRequest { - return LocationRequest.create().apply { - priority = this@GoogleFusedLocationClient.getPriority().value - interval = updateInterval - fastestInterval = fastestUpdateInterval - } - } -} - -@SuppressLint("MissingPermission") // Permission checks for location services handled in components that use this class -class FusedLocationProviderClientWrapper(private val fusedLocationProviderClient: FusedLocationProviderClient) { - private lateinit var listener: LocationListener - - private var locationCallback: LocationCallback = object : LocationCallback() { - override fun onLocationResult(locationResult: LocationResult) { - for (location in locationResult.locations) { - listener.onLocationChanged(location) - } - } - } - - fun start(listener: LocationListener) { - this.listener = listener - fusedLocationProviderClient.lastLocation.addOnSuccessListener { location: Location? -> - location?.let { - listener.onLocationChanged(it) - } - } - } - - fun requestLocationUpdates(locationRequest: LocationRequest) { - fusedLocationProviderClient.requestLocationUpdates(locationRequest, locationCallback, Looper.getMainLooper()) - } - - fun removeLocationUpdates() { - fusedLocationProviderClient.removeLocationUpdates(locationCallback) - } -} diff --git a/location/src/test/java/org/odk/collect/location/GoogleFusedLocationClientTest.java b/location/src/test/java/org/odk/collect/location/GoogleFusedLocationClientTest.java new file mode 100644 index 00000000000..4b219db45ae --- /dev/null +++ b/location/src/test/java/org/odk/collect/location/GoogleFusedLocationClientTest.java @@ -0,0 +1,282 @@ +package org.odk.collect.location; + +import static android.location.LocationManager.GPS_PROVIDER; +import static org.hamcrest.MatcherAssert.assertThat; +import static org.hamcrest.Matchers.is; +import static org.hamcrest.Matchers.notNullValue; +import static org.hamcrest.Matchers.nullValue; +import static org.junit.Assert.assertSame; +import static org.mockito.ArgumentMatchers.any; +import static org.mockito.Mockito.doAnswer; +import static org.mockito.Mockito.mock; +import static org.mockito.Mockito.never; +import static org.mockito.Mockito.reset; +import static org.mockito.Mockito.verify; +import static org.mockito.Mockito.when; + +import android.location.Location; +import android.location.LocationManager; + +import androidx.test.ext.junit.runners.AndroidJUnit4; + +import com.google.android.gms.common.ConnectionResult; +import com.google.android.gms.common.api.GoogleApiClient; +import com.google.android.gms.location.FusedLocationProviderApi; +import com.google.android.gms.location.LocationListener; + +import org.junit.Before; +import org.junit.Test; +import org.junit.runner.RunWith; +import org.mockito.invocation.InvocationOnMock; +import org.mockito.stubbing.Answer; +import org.odk.collect.testshared.LocationTestUtils; + +@RunWith(AndroidJUnit4.class) +public class GoogleFusedLocationClientTest { + + private GoogleApiClient googleApiClient; + private GoogleFusedLocationClient client; + private FusedLocationProviderApi fusedLocationProviderApi; + + @Before + public void setUp() { + fusedLocationProviderApi = mock(FusedLocationProviderApi.class); + googleApiClient = mock(GoogleApiClient.class); + LocationManager locationManager = mock(LocationManager.class); + client = new GoogleFusedLocationClient(googleApiClient, fusedLocationProviderApi, locationManager); + } + + @Test + public void startShouldSetListenerAndStopShouldRemoveIt() { + LocationClient.LocationClientListener listener = mock(LocationClient.LocationClientListener.class); + client.start(listener); + assertThat(client.getListener(), is(notNullValue())); + + client.stop(); + assertThat(client.getListener(), is(nullValue())); + } + + @Test + public void startShouldCallLocationClientOnConnected() { + doAnswer(new OnConnectedAnswer()).when(googleApiClient).connect(); + + LocationClient.LocationClientListener listener = mock(LocationClient.LocationClientListener.class); + + client.start(listener); + verify(listener).onClientStart(); + verify(listener, never()).onClientStartFailure(); + verify(listener, never()).onClientStop(); + + client.stop(); + + reset(listener); + doAnswer(new OnConnectionFailedAnswer()).when(googleApiClient).connect(); + + client.start(listener); + verify(listener, never()).onClientStart(); + verify(listener).onClientStartFailure(); + verify(listener, never()).onClientStop(); + + client.stop(); + verify(listener, never()).onClientStart(); + verify(listener).onClientStartFailure(); + verify(listener).onClientStop(); + } + + @Test + public void stopShouldDisconnectFromGoogleApiIfConnected_andAlwaysCallOnClientStopIfListenerSet() { + LocationClient.LocationClientListener listener = mock(LocationClient.LocationClientListener.class); + client.start(listener); + + // Previously connected, disconnection succeeds + when(googleApiClient.isConnected()).thenReturn(true); + client.stop(); + verify(googleApiClient).disconnect(); + verify(listener).onClientStop(); + + reset(listener); + + client.start(listener); + // Previously connected, disconnection calls onConnectionSuspended + doAnswer(new OnDisconnectedAnswer()).when(googleApiClient).disconnect(); + client.stop(); + verify(listener).onClientStop(); + + reset(listener); + + client.start(listener); + // Not previously connected + when(googleApiClient.isConnected()).thenReturn(false); + client.stop(); + verify(listener).onClientStop(); + } + + @Test + public void whenGoogleApiClientNotConnected_shouldNotRemoveLocationUpdatesBeCalled() { + when(googleApiClient.isConnected()).thenReturn(false); + + client.start(null); + + TestLocationListener listener = new TestLocationListener(); + client.requestLocationUpdates(listener); + + client.stop(); + verify(fusedLocationProviderApi, never()).removeLocationUpdates(googleApiClient, listener); + } + + @Test + public void whenGoogleApiClientNotConnected_shouldNotRequestLocationUpdatesBeCalled() { + when(googleApiClient.isConnected()).thenReturn(false); + + client.start(null); + client.requestLocationUpdates(new TestLocationListener()); + + verify(fusedLocationProviderApi, never()).requestLocationUpdates(any(), any(), (LocationListener) any()); + } + + @Test + public void requestingLocationUpdatesShouldUpdateCorrectListener() { + client.start(null); + + TestLocationListener firstListener = new TestLocationListener(); + client.requestLocationUpdates(firstListener); + + Location firstLocation = newMockLocation(); + client.onLocationChanged(firstLocation); + + assertSame(firstLocation, firstListener.getLastLocation()); + + Location secondLocation = newMockLocation(); + client.onLocationChanged(secondLocation); + + assertSame(secondLocation, firstListener.getLastLocation()); + + // Now stop updates: + client.stopLocationUpdates(); + + Location thirdLocation = newMockLocation(); + client.onLocationChanged(thirdLocation); + + // Should still be second: + assertSame(secondLocation, firstListener.getLastLocation()); + + // Call requestLocationUpdates again with new listener: + TestLocationListener secondListener = new TestLocationListener(); + client.requestLocationUpdates(secondListener); + + Location fourthLocation = newMockLocation(); + client.onLocationChanged(fourthLocation); + + // First listener should still have second location: + assertSame(secondLocation, firstListener.getLastLocation()); + assertSame(fourthLocation, secondListener.getLastLocation()); + + // Call stop() and make sure it called stopLocationUpdates(): + client.stop(); + + Location fifthLocation = newMockLocation(); + client.onLocationChanged(fifthLocation); + + // Listener should still have fourth location: + assertSame(fourthLocation, secondListener.getLastLocation()); + } + + @Test + public void getLastLocationShouldCallBlockingConnectIfNotConnected() { + client.getLastLocation(); + verify(googleApiClient).blockingConnect(); + + when(googleApiClient.isConnected()).thenReturn(true); + client.start(null); + + client.getLastLocation(); + verify(googleApiClient).blockingConnect(); // 'verify' checks if called *once*. + } + + @Test + public void whenNewlyReceivedLocationAccuracyIsNegative_shouldBeSetToZero() { + TestLocationListener listener = new TestLocationListener(); + client.requestLocationUpdates(listener); + + Location location = LocationTestUtils.createLocation("GPS", 7, 2, 3, -1); + client.onLocationChanged(location); + + assertThat(listener.getLastLocation().getAccuracy(), is(0.0f)); + } + + @Test + public void whenNewlyReceivedLocationIsMocked_shouldAccuracyBeSetToZero() { + TestLocationListener listener = new TestLocationListener(); + client.requestLocationUpdates(listener); + + Location location = LocationTestUtils.createLocation("GPS", 7, 2, 3, 5.0f, true); + client.onLocationChanged(location); + + assertThat(listener.getLastLocation().getAccuracy(), is(0.0f)); + } + + @Test + public void whenNewlyReceivedLocationIsMocked_andRetainMockAccuracyIsTrue_doesNotChangeAccuracy() { + TestLocationListener listener = new TestLocationListener(); + client.setRetainMockAccuracy(true); + client.requestLocationUpdates(listener); + + Location location = LocationTestUtils.createLocation("GPS", 7, 2, 3, 5.0f, true); + client.onLocationChanged(location); + + assertThat(listener.getLastLocation().getAccuracy(), is(5.0f)); + } + + @Test + public void whenLastKnownLocationAccuracyIsNegative_shouldBeSetToZero() { + Location location = LocationTestUtils.createLocation(GPS_PROVIDER, 7, 2, 3, -1.0f); + when(fusedLocationProviderApi.getLastLocation(googleApiClient)).thenReturn(location); + + assertThat(client.getLastLocation().getAccuracy(), is(0.0f)); + } + + @Test + public void whenLastKnownLocationIsMocked_shouldAccuracyBeSetToZero() { + Location location = LocationTestUtils.createLocation(GPS_PROVIDER, 7, 2, 3, 5.0f, true); + when(fusedLocationProviderApi.getLastLocation(googleApiClient)).thenReturn(location); + + assertThat(client.getLastLocation().getAccuracy(), is(0.0f)); + } + + @Test + public void whenLastKnownLocationIsMocked_andRetainMockAccuracyIsTrue_doesNotChangeAccuracy() { + Location location = LocationTestUtils.createLocation(GPS_PROVIDER, 7, 2, 3, 5.0f, true); + client.setRetainMockAccuracy(true); + when(fusedLocationProviderApi.getLastLocation(googleApiClient)).thenReturn(location); + + assertThat(client.getLastLocation().getAccuracy(), is(5.0f)); + } + + private static Location newMockLocation() { + return mock(Location.class); + } + + private class OnConnectedAnswer implements Answer