drgreen/android_frameworks_base
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Merge "Refactor GnssGeofenceProvider" into pi-dev

Browse Source 
am: 728cb519a5

Change-Id: I165ae0783ce26c28ddb19ec68666a810855535b0
This commit is contained in:
Yu-Han Yang
2018-04-24 21:07:52 -07:00
committed by android-build-merger
parent ac4f6a9bc0 728cb519a5
commit 87bbfe0529
4 changed files with 340 additions and 58 deletions
Download Patch File Download Diff File Expand all files Collapse all files

188
services/core/java/com/android/server/location/GnssGeofenceProvider.java Normal file
View File

@ -0,0 +1,188 @@
package com.android.server.location;
import android.location.IGpsGeofenceHardware;
import android.os.Handler;
import android.os.IBinder;
import android.os.Looper;
import android.util.Log;
import android.util.SparseArray;
import com.android.internal.annotations.VisibleForTesting;
import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.FutureTask;
/**
* Manages GNSS Geofence operations.
*/
class GnssGeofenceProvider extends IGpsGeofenceHardware.Stub {
private static final String TAG = "GnssGeofenceProvider";
private static final boolean DEBUG = Log.isLoggable(TAG, Log.DEBUG);
/** Holds the parameters of a geofence. */
private static class GeofenceEntry {
public int geofenceId;
public double latitude;
public double longitude;
public double radius;
public int lastTransition;
public int monitorTransitions;
public int notificationResponsiveness;
public int unknownTimer;
public boolean paused;
}
private final GnssGeofenceProviderNative mNative;
private final SparseArray<GeofenceEntry> mGeofenceEntries = new SparseArray<>();
private final Handler mHandler;
GnssGeofenceProvider(Looper looper) {
this(looper, new GnssGeofenceProviderNative());
}
@VisibleForTesting
GnssGeofenceProvider(Looper looper, GnssGeofenceProviderNative gnssGeofenceProviderNative) {
mHandler = new Handler(looper);
mNative = gnssGeofenceProviderNative;
}
// TODO(b/37460011): use this method in HAL death recovery.
void resumeIfStarted() {
if (DEBUG) {
Log.d(TAG, "resumeIfStarted");
}
mHandler.post(() -> {
for (int i = 0; i < mGeofenceEntries.size(); i++) {
GeofenceEntry entry = mGeofenceEntries.valueAt(i);
boolean added = mNative.addGeofence(entry.geofenceId, entry.latitude,
entry.longitude,
entry.radius,
entry.lastTransition, entry.monitorTransitions,
entry.notificationResponsiveness, entry.unknownTimer);
if (added && entry.paused) {
mNative.pauseGeofence(entry.geofenceId);
}
}
});
}
private boolean runOnHandlerThread(Callable<Boolean> callable) {
FutureTask<Boolean> futureTask = new FutureTask<>(callable);
mHandler.post(futureTask);
try {
return futureTask.get();
} catch (InterruptedException | ExecutionException e) {
Log.e(TAG, "Failed running callable.", e);
}
return false;
}
@Override
public boolean isHardwareGeofenceSupported() {
return runOnHandlerThread(mNative::isGeofenceSupported);
}
@Override
public boolean addCircularHardwareGeofence(int geofenceId, double latitude,
double longitude, double radius, int lastTransition, int monitorTransitions,
int notificationResponsiveness, int unknownTimer) {
return runOnHandlerThread(() -> {
boolean added = mNative.addGeofence(geofenceId, latitude, longitude, radius,
lastTransition, monitorTransitions, notificationResponsiveness,
unknownTimer);
if (added) {
GeofenceEntry entry = new GeofenceEntry();
entry.geofenceId = geofenceId;
entry.latitude = latitude;
entry.longitude = longitude;
entry.radius = radius;
entry.lastTransition = lastTransition;
entry.monitorTransitions = monitorTransitions;
entry.notificationResponsiveness = notificationResponsiveness;
entry.unknownTimer = unknownTimer;
mGeofenceEntries.put(geofenceId, entry);
}
return added;
});
}
@Override
public boolean removeHardwareGeofence(int geofenceId) {
return runOnHandlerThread(() -> {
boolean removed = mNative.removeGeofence(geofenceId);
if (removed) {
mGeofenceEntries.remove(geofenceId);
}
return removed;
});
}
@Override
public boolean pauseHardwareGeofence(int geofenceId) {
return runOnHandlerThread(() -> {
boolean paused = mNative.pauseGeofence(geofenceId);
if (paused) {
GeofenceEntry entry = mGeofenceEntries.get(geofenceId);
if (entry != null) {
entry.paused = true;
}
}
return paused;
});
}
@Override
public boolean resumeHardwareGeofence(int geofenceId, int monitorTransitions) {
return runOnHandlerThread(() -> {
boolean resumed = mNative.resumeGeofence(geofenceId, monitorTransitions);
if (resumed) {
GeofenceEntry entry = mGeofenceEntries.get(geofenceId);
if (entry != null) {
entry.paused = false;
entry.monitorTransitions = monitorTransitions;
}
}
return resumed;
});
}
@VisibleForTesting
static class GnssGeofenceProviderNative {
public boolean isGeofenceSupported() {
return native_is_geofence_supported();
}
public boolean addGeofence(int geofenceId, double latitude, double longitude, double radius,
int lastTransition, int monitorTransitions, int notificationResponsiveness,
int unknownTimer) {
return native_add_geofence(geofenceId, latitude, longitude, radius, lastTransition,
monitorTransitions, notificationResponsiveness, unknownTimer);
}
public boolean removeGeofence(int geofenceId) {
return native_remove_geofence(geofenceId);
}
public boolean resumeGeofence(int geofenceId, int transitions) {
return native_resume_geofence(geofenceId, transitions);
}
public boolean pauseGeofence(int geofenceId) {
return native_pause_geofence(geofenceId);
}
}
private static native boolean native_is_geofence_supported();
private static native boolean native_add_geofence(int geofenceId, double latitude,
double longitude, double radius, int lastTransition, int monitorTransitions,
int notificationResponsivenes, int unknownTimer);
private static native boolean native_remove_geofence(int geofenceId);
private static native boolean native_resume_geofence(int geofenceId, int transitions);
private static native boolean native_pause_geofence(int geofenceId);
}

42
services/core/java/com/android/server/location/GnssLocationProvider.java
View File

@ -419,6 +419,7 @@ public class GnssLocationProvider implements LocationProviderInterface, InjectNt
private final LocationChangeListener mFusedLocationListener = new FusedLocationListener();
private final NtpTimeHelper mNtpTimeHelper;
private final GnssBatchingProvider mGnssBatchingProvider;
private final GnssGeofenceProvider mGnssGeofenceProvider;
// Handler for processing events
private Handler mHandler;
@ -493,7 +494,7 @@ public class GnssLocationProvider implements LocationProviderInterface, InjectNt
}
public IGpsGeofenceHardware getGpsGeofenceProxy() {
return mGpsGeofenceBinder;
return mGnssGeofenceProvider;
}
public GnssMeasurementsProvider getGnssMeasurementsProvider() {
@ -887,6 +888,7 @@ public class GnssLocationProvider implements LocationProviderInterface, InjectNt
looper, this);
mHandler.post(mGnssSatelliteBlacklistHelper::updateSatelliteBlacklist);
mGnssBatchingProvider = new GnssBatchingProvider();
mGnssGeofenceProvider = new GnssGeofenceProvider(looper);
}
/**
@ -1501,31 +1503,6 @@ public class GnssLocationProvider implements LocationProviderInterface, InjectNt
}
}
private IGpsGeofenceHardware mGpsGeofenceBinder = new IGpsGeofenceHardware.Stub() {
public boolean isHardwareGeofenceSupported() {
return native_is_geofence_supported();
}
public boolean addCircularHardwareGeofence(int geofenceId, double latitude,
double longitude, double radius, int lastTransition, int monitorTransitions,
int notificationResponsiveness, int unknownTimer) {
return native_add_geofence(geofenceId, latitude, longitude, radius,
lastTransition, monitorTransitions, notificationResponsiveness, unknownTimer);
}
public boolean removeHardwareGeofence(int geofenceId) {
return native_remove_geofence(geofenceId);
}
public boolean pauseHardwareGeofence(int geofenceId) {
return native_pause_geofence(geofenceId);
}
public boolean resumeHardwareGeofence(int geofenceId, int monitorTransition) {
return native_resume_geofence(geofenceId, monitorTransition);
}
};
private boolean deleteAidingData(Bundle extras) {
int flags;
@ -2813,19 +2790,6 @@ public class GnssLocationProvider implements LocationProviderInterface, InjectNt
private native void native_update_network_state(boolean connected, int type,
boolean roaming, boolean available, String extraInfo, String defaultAPN);
// Hardware Geofence support.
private static native boolean native_is_geofence_supported();
private static native boolean native_add_geofence(int geofenceId, double latitude,
double longitude, double radius, int lastTransition, int monitorTransitions,
int notificationResponsivenes, int unknownTimer);
private static native boolean native_remove_geofence(int geofenceId);
private static native boolean native_resume_geofence(int geofenceId, int transitions);
private static native boolean native_pause_geofence(int geofenceId);
// Gps Hal measurements support.
private static native boolean native_is_measurement_supported();

47
services/core/jni/com_android_server_location_GnssLocationProvider.cpp
View File

@ -1745,12 +1745,12 @@ static void android_location_GnssLocationProvider_update_network_state(JNIEnv* e
}
}
static jboolean android_location_GnssLocationProvider_is_geofence_supported(
static jboolean android_location_GnssGeofenceProvider_is_geofence_supported(
JNIEnv* /* env */, jobject /* obj */) {
return (gnssGeofencingIface != nullptr) ? JNI_TRUE : JNI_FALSE;
}
static jboolean android_location_GnssLocationProvider_add_geofence(JNIEnv* /* env */,
static jboolean android_location_GnssGeofenceProvider_add_geofence(JNIEnv* /* env */,
jobject /* obj */, jint geofenceId, jdouble latitude, jdouble longitude, jdouble radius,
jint last_transition, jint monitor_transition, jint notification_responsiveness,
jint unknown_timer) {
@ -1766,7 +1766,7 @@ static jboolean android_location_GnssLocationProvider_add_geofence(JNIEnv* /* en
return JNI_FALSE;
}
static jboolean android_location_GnssLocationProvider_remove_geofence(JNIEnv* /* env */,
static jboolean android_location_GnssGeofenceProvider_remove_geofence(JNIEnv* /* env */,
jobject /* obj */, jint geofenceId) {
if (gnssGeofencingIface != nullptr) {
auto result = gnssGeofencingIface->removeGeofence(geofenceId);
@ -1777,7 +1777,7 @@ static jboolean android_location_GnssLocationProvider_remove_geofence(JNIEnv* /*
return JNI_FALSE;
}
static jboolean android_location_GnssLocationProvider_pause_geofence(JNIEnv* /* env */,
static jboolean android_location_GnssGeofenceProvider_pause_geofence(JNIEnv* /* env */,
jobject /* obj */, jint geofenceId) {
if (gnssGeofencingIface != nullptr) {
auto result = gnssGeofencingIface->pauseGeofence(geofenceId);
@ -1788,7 +1788,7 @@ static jboolean android_location_GnssLocationProvider_pause_geofence(JNIEnv* /*
return JNI_FALSE;
}
static jboolean android_location_GnssLocationProvider_resume_geofence(JNIEnv* /* env */,
static jboolean android_location_GnssGeofenceProvider_resume_geofence(JNIEnv* /* env */,
jobject /* obj */, jint geofenceId, jint monitor_transition) {
if (gnssGeofencingIface != nullptr) {
auto result = gnssGeofencingIface->resumeGeofence(geofenceId, monitor_transition);
@ -2178,20 +2178,6 @@ static const JNINativeMethod sMethods[] = {
{"native_update_network_state",
"(ZIZZLjava/lang/String;Ljava/lang/String;)V",
reinterpret_cast<void *>(android_location_GnssLocationProvider_update_network_state)},
{"native_is_geofence_supported",
"()Z",
reinterpret_cast<void *>(android_location_GnssLocationProvider_is_geofence_supported)},
{"native_add_geofence",
"(IDDDIIII)Z",
reinterpret_cast<void *>(android_location_GnssLocationProvider_add_geofence)},
{"native_remove_geofence",
"(I)Z",
reinterpret_cast<void *>(android_location_GnssLocationProvider_remove_geofence)},
{"native_pause_geofence", "(I)Z", reinterpret_cast<void *>(
android_location_GnssLocationProvider_pause_geofence)},
{"native_resume_geofence",
"(II)Z",
reinterpret_cast<void *>(android_location_GnssLocationProvider_resume_geofence)},
{"native_is_measurement_supported",
"()Z",
reinterpret_cast<void *>(
@ -2265,12 +2251,35 @@ static const JNINativeMethod sMethodsBatching[] = {
reinterpret_cast<void *>(android_location_GnssBatchingProvider_cleanup_batching)},
};
static const JNINativeMethod sGeofenceMethods[] = {
/* name, signature, funcPtr */
{"native_is_geofence_supported",
"()Z",
reinterpret_cast<void *>(android_location_GnssGeofenceProvider_is_geofence_supported)},
{"native_add_geofence",
"(IDDDIIII)Z",
reinterpret_cast<void *>(android_location_GnssGeofenceProvider_add_geofence)},
{"native_remove_geofence",
"(I)Z",
reinterpret_cast<void *>(android_location_GnssGeofenceProvider_remove_geofence)},
{"native_pause_geofence", "(I)Z", reinterpret_cast<void *>(
android_location_GnssGeofenceProvider_pause_geofence)},
{"native_resume_geofence",
"(II)Z",
reinterpret_cast<void *>(android_location_GnssGeofenceProvider_resume_geofence)},
};
int register_android_server_location_GnssLocationProvider(JNIEnv* env) {
jniRegisterNativeMethods(
env,
"com/android/server/location/GnssBatchingProvider",
sMethodsBatching,
NELEM(sMethodsBatching));
jniRegisterNativeMethods(
env,
"com/android/server/location/GnssGeofenceProvider",
sGeofenceMethods,
NELEM(sGeofenceMethods));
return jniRegisterNativeMethods(
env,
"com/android/server/location/GnssLocationProvider",

121
services/robotests/src/com/android/server/location/GnssGeofenceProviderTest.java Normal file
View File

@ -0,0 +1,121 @@
package com.android.server.location;
import static org.mockito.Matchers.anyDouble;
import static org.mockito.Matchers.anyInt;
import static org.mockito.Matchers.eq;
import static org.mockito.Mockito.times;
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.when;
import android.os.Looper;
import android.os.RemoteException;
import android.platform.test.annotations.Presubmit;
import com.android.server.testing.FrameworkRobolectricTestRunner;
import com.android.server.testing.SystemLoaderPackages;
import org.junit.Before;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.mockito.Mock;
import org.mockito.MockitoAnnotations;
import org.robolectric.annotation.Config;
/**
* Unit tests for {@link GnssGeofenceProvider}.
*/
@RunWith(FrameworkRobolectricTestRunner.class)
@Config(
manifest = Config.NONE,
sdk = 27
)
@SystemLoaderPackages({"com.android.server.location"})
@Presubmit
public class GnssGeofenceProviderTest {
private static final int GEOFENCE_ID = 12345;
private static final double LATITUDE = 10.0;
private static final double LONGITUDE = 20.0;
private static final double RADIUS = 5.0;
private static final int LAST_TRANSITION = 0;
private static final int MONITOR_TRANSITIONS = 0;
private static final int NOTIFICATION_RESPONSIVENESS = 0;
private static final int UNKNOWN_TIMER = 0;
@Mock
private GnssGeofenceProvider.GnssGeofenceProviderNative mMockNative;
private GnssGeofenceProvider mTestProvider;
@Before
public void setUp() {
MockitoAnnotations.initMocks(this);
when(mMockNative.addGeofence(anyInt(), anyDouble(), anyDouble(), anyDouble(), anyInt(),
anyInt(), anyInt(), anyInt())).thenReturn(true);
when(mMockNative.pauseGeofence(anyInt())).thenReturn(true);
when(mMockNative.removeGeofence(anyInt())).thenReturn(true);
when(mMockNative.resumeGeofence(anyInt(), anyInt())).thenReturn(true);
mTestProvider = new GnssGeofenceProvider(Looper.myLooper(), mMockNative);
mTestProvider.addCircularHardwareGeofence(GEOFENCE_ID, LATITUDE,
LONGITUDE, RADIUS, LAST_TRANSITION, MONITOR_TRANSITIONS,
NOTIFICATION_RESPONSIVENESS,
UNKNOWN_TIMER);
}
@Test
public void addGeofence_nativeAdded() {
verify(mMockNative).addGeofence(eq(GEOFENCE_ID), eq(LATITUDE), eq(LONGITUDE),
eq(RADIUS), eq(LAST_TRANSITION), eq(MONITOR_TRANSITIONS),
eq(NOTIFICATION_RESPONSIVENESS),
eq(UNKNOWN_TIMER));
}
@Test
public void pauseGeofence_nativePaused() {
mTestProvider.pauseHardwareGeofence(GEOFENCE_ID);
verify(mMockNative).pauseGeofence(eq(GEOFENCE_ID));
}
@Test
public void removeGeofence_nativeRemoved() {
mTestProvider.removeHardwareGeofence(GEOFENCE_ID);
verify(mMockNative).removeGeofence(eq(GEOFENCE_ID));
}
@Test
public void resumeGeofence_nativeResumed() {
mTestProvider.pauseHardwareGeofence(GEOFENCE_ID);
mTestProvider.resumeHardwareGeofence(GEOFENCE_ID, MONITOR_TRANSITIONS);
verify(mMockNative).resumeGeofence(eq(GEOFENCE_ID), eq(MONITOR_TRANSITIONS));
}
@Test
public void addGeofence_restart_added() throws RemoteException {
mTestProvider.resumeIfStarted();
verify(mMockNative, times(2)).addGeofence(eq(GEOFENCE_ID), eq(LATITUDE), eq(LONGITUDE),
eq(RADIUS), eq(LAST_TRANSITION), eq(MONITOR_TRANSITIONS),
eq(NOTIFICATION_RESPONSIVENESS),
eq(UNKNOWN_TIMER));
}
@Test
public void removeGeofence_restart_notAdded() throws RemoteException {
mTestProvider.removeHardwareGeofence(GEOFENCE_ID);
mTestProvider.resumeIfStarted();
verify(mMockNative, times(1)).addGeofence(eq(GEOFENCE_ID), eq(LATITUDE), eq(LONGITUDE),
eq(RADIUS), eq(LAST_TRANSITION), eq(MONITOR_TRANSITIONS),
eq(NOTIFICATION_RESPONSIVENESS),
eq(UNKNOWN_TIMER));
}
@Test
public void pauseGeofence_restart_paused() throws RemoteException {
mTestProvider.pauseHardwareGeofence(GEOFENCE_ID);
mTestProvider.resumeIfStarted();
verify(mMockNative, times(2)).addGeofence(eq(GEOFENCE_ID), eq(LATITUDE), eq(LONGITUDE),
eq(RADIUS), eq(LAST_TRANSITION), eq(MONITOR_TRANSITIONS),
eq(NOTIFICATION_RESPONSIVENESS),
eq(UNKNOWN_TIMER));
verify(mMockNative, times(2)).pauseGeofence(eq(GEOFENCE_ID));
}
}