Add support for sources in Geofencing APIs.

Support setting the source when adding geofences.
b/14117199

Surface the source when FLP geofence changes state.
b/14119200

Change-Id: I50dc40a9caee400594e1778c98e284e0db0d5e66

10 files changed, 321 insertions, 67 deletions

diff --git a/core/java/android/hardware/location/GeofenceHardware.java b/core/java/android/hardware/location/GeofenceHardware.java
index 2d7b7e1..2d82cba 100644
--- a/core/java/android/hardware/location/GeofenceHardware.java
+++ b/core/java/android/hardware/location/GeofenceHardware.java
@@ -16,6 +16,7 @@
 package android.hardware.location;
 
 import android.location.Location;
+import android.os.Build;
 import android.os.RemoteException;
 
 import java.lang.ref.WeakReference;
@@ -60,19 +61,19 @@ public final class GeofenceHardware {
     public static final int MONITORING_TYPE_FUSED_HARDWARE = 1;
 
     /**
-     * Constant to indiciate that the monitoring system is currently
+     * Constant to indicate that the monitoring system is currently
      * available for monitoring geofences.
      */
     public static final int MONITOR_CURRENTLY_AVAILABLE = 0;
 
     /**
-     * Constant to indiciate that the monitoring system is currently
+     * Constant to indicate that the monitoring system is currently
      * unavailable for monitoring geofences.
      */
     public static final int MONITOR_CURRENTLY_UNAVAILABLE = 1;
 
     /**
-     * Constant to indiciate that the monitoring system is unsupported
+     * Constant to indicate that the monitoring system is unsupported
      * for hardware geofence monitoring.
      */
     public static final int MONITOR_UNSUPPORTED = 2;
@@ -129,6 +130,33 @@ public final class GeofenceHardware {
      */
     public static final int GEOFENCE_ERROR_INSUFFICIENT_MEMORY = 6;
 
+    // the following values must match the definitions in fused_location.h
+
+    /**
+     * The constant used to indicate that the monitoring system supports GNSS.
+     */
+    public static final int SOURCE_TECHNOLOGY_GNSS = (1<<0);
+
+    /**
+     * The constant used to indicate that the monitoring system supports WiFi.
+     */
+    public static final int SOURCE_TECHNOLOGY_WIFI = (1<<1);
+
+    /**
+     * The constant used to indicate that the monitoring system supports Sensors.
+     */
+    public static final int SOURCE_TECHNOLOGY_SENSORS = (1<<2);
+
+    /**
+     * The constant used to indicate that the monitoring system supports Cell.
+     */
+    public static final int SOURCE_TECHNOLOGY_CELL = (1<<3);
+
+    /**
+     * The constant used to indicate that the monitoring system supports Bluetooth.
+     */
+    public static final int SOURCE_TECHNOLOGY_BLUETOOTH = (1<<4);
+
     private HashMap<GeofenceHardwareCallback, GeofenceHardwareCallbackWrapper>
             mCallbacks = new HashMap<GeofenceHardwareCallback, GeofenceHardwareCallbackWrapper>();
     private HashMap<GeofenceHardwareMonitorCallback, GeofenceHardwareMonitorCallbackWrapper>
@@ -238,13 +266,9 @@ public final class GeofenceHardware {
             geofenceRequest, GeofenceHardwareCallback callback) {
         try {
             if (geofenceRequest.getType() == GeofenceHardwareRequest.GEOFENCE_TYPE_CIRCLE) {
-                return mService.addCircularFence(geofenceId, monitoringType,
-                        geofenceRequest.getLatitude(),
-                        geofenceRequest.getLongitude(), geofenceRequest.getRadius(),
-                        geofenceRequest.getLastTransition(),
-                        geofenceRequest.getMonitorTransitions(),
-                        geofenceRequest.getNotificationResponsiveness(),
-                        geofenceRequest.getUnknownTimer(),
+                return mService.addCircularFence(
+                        monitoringType,
+                        new GeofenceHardwareRequestParcelable(geofenceId, geofenceRequest),
                         getCallbackWrapper(callback));
             } else {
                 throw new IllegalArgumentException("Geofence Request type not supported");
@@ -452,10 +476,21 @@ public final class GeofenceHardware {
             mCallback = new WeakReference<GeofenceHardwareMonitorCallback>(c);
         }
 
-        public void onMonitoringSystemChange(int monitoringType, boolean available,
-                Location location) {
+        public void onMonitoringSystemChange(GeofenceHardwareMonitorEvent event) {
             GeofenceHardwareMonitorCallback c = mCallback.get();
-            if (c != null) c.onMonitoringSystemChange(monitoringType, available, location);
+            if (c == null) return;
+
+            // report the legacy event first, so older clients are not broken
+            c.onMonitoringSystemChange(
+                    event.getMonitoringType(),
+                    event.getMonitoringStatus() == GeofenceHardware.MONITOR_CURRENTLY_AVAILABLE,
+                    event.getLocation());
+
+            // and only call the updated callback on on L and above, this complies with the
+            // documentation of GeofenceHardwareMonitorCallback
+            if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.L) {
+                c.onMonitoringSystemChange(event);
+            }
         }
     }
 
diff --git a/core/java/android/hardware/location/GeofenceHardwareImpl.java b/core/java/android/hardware/location/GeofenceHardwareImpl.java
index 6b61690..6734878 100644
--- a/core/java/android/hardware/location/GeofenceHardwareImpl.java
+++ b/core/java/android/hardware/location/GeofenceHardwareImpl.java
@@ -210,18 +210,20 @@ public final class GeofenceHardwareImpl {
         }
     }
 
-    public boolean addCircularFence(int geofenceId,  int monitoringType, double latitude,
-            double longitude, double radius, int lastTransition,int monitorTransitions,
-            int notificationResponsivenes, int unknownTimer, IGeofenceHardwareCallback callback) {
+    public boolean addCircularFence(
+            int monitoringType,
+            GeofenceHardwareRequestParcelable request,
+            IGeofenceHardwareCallback callback) {
+        int geofenceId = request.getId();
+
         // This API is not thread safe. Operations on the same geofence need to be serialized
         // by upper layers
         if (DEBUG) {
-            Log.d(TAG, "addCircularFence: GeofenceId: " + geofenceId + " Latitude: " + latitude +
-                    " Longitude: " + longitude + " Radius: " + radius + " LastTransition: "
-                    + lastTransition + " MonitorTransition: " + monitorTransitions +
-                    " NotificationResponsiveness: " + notificationResponsivenes +
-                    " UnKnown Timer: " + unknownTimer + " MonitoringType: " + monitoringType);
-
+            String message = String.format(
+                    "addCircularFence: monitoringType=%d, %s",
+                    monitoringType,
+                    request);
+            Log.d(TAG, message);
         }
         boolean result;
 
@@ -237,9 +239,15 @@ public final class GeofenceHardwareImpl {
             case GeofenceHardware.MONITORING_TYPE_GPS_HARDWARE:
                 if (mGpsService == null) return false;
                 try {
-                    result = mGpsService.addCircularHardwareGeofence(geofenceId, latitude,
-                            longitude, radius, lastTransition, monitorTransitions,
-                            notificationResponsivenes, unknownTimer);
+                    result = mGpsService.addCircularHardwareGeofence(
+                            request.getId(),
+                            request.getLatitude(),
+                            request.getLongitude(),
+                            request.getRadius(),
+                            request.getLastTransition(),
+                            request.getMonitorTransitions(),
+                            request.getNotificationResponsiveness(),
+                            request.getUnknownTimer());
                 } catch (RemoteException e) {
                     Log.e(TAG, "AddGeofence: Remote Exception calling LocationManagerService");
                     result = false;
@@ -249,20 +257,9 @@ public final class GeofenceHardwareImpl {
                 if(mFusedService == null) {
                     return false;
                 }
-                GeofenceHardwareRequest request = GeofenceHardwareRequest.createCircularGeofence(
-                        latitude,
-                        longitude,
-                        radius);
-                request.setUnknownTimer(unknownTimer);
-                request.setNotificationResponsiveness(notificationResponsivenes);
-                request.setMonitorTransitions(monitorTransitions);
-                request.setLastTransition(lastTransition);
-
-                GeofenceHardwareRequestParcelable parcelableRequest =
-                        new GeofenceHardwareRequestParcelable(geofenceId, request);
                 try {
                     mFusedService.addGeofences(
-                            new GeofenceHardwareRequestParcelable[] { parcelableRequest });
+                            new GeofenceHardwareRequestParcelable[] { request });
                     result = true;
                 } catch(RemoteException e) {
                     Log.e(TAG, "AddGeofence: RemoteException calling LocationManagerService");
@@ -471,12 +468,14 @@ public final class GeofenceHardwareImpl {
             int monitoringStatus,
             Location location,
             int source) {
-        // TODO: use the source if needed in the future
         setMonitorAvailability(monitoringType, monitoringStatus);
         acquireWakeLock();
-        Message message = mCallbacksHandler.obtainMessage(GEOFENCE_STATUS, location);
-        message.arg1 = monitoringStatus;
-        message.arg2 = monitoringType;
+        GeofenceHardwareMonitorEvent event = new GeofenceHardwareMonitorEvent(
+                monitoringType,
+                monitoringStatus,
+                source,
+                location);
+        Message message = mCallbacksHandler.obtainMessage(GEOFENCE_STATUS, event);
         message.sendToTarget();
     }
 
@@ -644,20 +643,17 @@ public final class GeofenceHardwareImpl {
 
             switch (msg.what) {
                 case GEOFENCE_STATUS:
-                    Location location = (Location) msg.obj;
-                    int val = msg.arg1;
-                    monitoringType = msg.arg2;
-                    boolean available;
-                    available = (val == GeofenceHardware.MONITOR_CURRENTLY_AVAILABLE ?
-                            true : false);
-                    callbackList = mCallbacks[monitoringType];
+                    GeofenceHardwareMonitorEvent event = (GeofenceHardwareMonitorEvent) msg.obj;
+                    callbackList = mCallbacks[event.getMonitoringType()];
                     if (callbackList != null) {
-                        if (DEBUG) Log.d(TAG, "MonitoringSystemChangeCallback: GPS : " + available);
+                        if (DEBUG) Log.d(TAG, "MonitoringSystemChangeCallback: " + event);
 
-                        for (IGeofenceHardwareMonitorCallback c: callbackList) {
+                        for (IGeofenceHardwareMonitorCallback c : callbackList) {
                             try {
-                                c.onMonitoringSystemChange(monitoringType, available, location);
-                            } catch (RemoteException e) {}
+                                c.onMonitoringSystemChange(event);
+                            } catch (RemoteException e) {
+                                Log.d(TAG, "Error reporting onMonitoringSystemChange.", e);
+                            }
                         }
                     }
                     releaseWakeLock();
diff --git a/core/java/android/hardware/location/GeofenceHardwareMonitorCallback.java b/core/java/android/hardware/location/GeofenceHardwareMonitorCallback.java
index b8e927e..f927027 100644
--- a/core/java/android/hardware/location/GeofenceHardwareMonitorCallback.java
+++ b/core/java/android/hardware/location/GeofenceHardwareMonitorCallback.java
@@ -19,19 +19,39 @@ package android.hardware.location;
 import android.location.Location;
 
 /**
- * The callback class associated with the status change of hardware montiors
+ * The callback class associated with the status change of hardware monitors
  * in {@link GeofenceHardware}
  */
 public abstract class GeofenceHardwareMonitorCallback {
     /**
      * The callback called when the state of a monitoring system changes.
      * {@link GeofenceHardware#MONITORING_TYPE_GPS_HARDWARE} is an example of a
-     * monitoring system
+     * monitoring system.
+     *
+     * @deprecated use {@link #onMonitoringSystemChange(GeofenceHardwareMonitorEvent)} instead.
+     * NOTE: this API is will remain to be called on Android API 21 and above for backwards
+     * compatibility. But clients must stop implementing it when updating their code.
      *
      * @param monitoringType The type of the monitoring system.
-     * @param available Indicates whether the system is currenty available or not.
+     * @param available Indicates whether the system is currently available or not.
      * @param location The last known location according to the monitoring system.
      */
+    @Deprecated
     public void onMonitoringSystemChange(int monitoringType, boolean available, Location location) {
     }
+
+    /**
+     * The callback called when the sate of a monitoring system changes.
+     * {@link GeofenceHardware#MONITORING_TYPE_GPS_HARDWARE} is an example of a monitoring system.
+     * {@link GeofenceHardware#MONITOR_CURRENTLY_AVAILABLE} is an example of a monitoring status.
+     * {@link GeofenceHardware#SOURCE_TECHNOLOGY_GNSS} is an example of a source.
+     *
+     * This callback must be used instead of
+     * {@link #onMonitoringSystemChange(int, boolean, android.location.Location)}.
+     *
+     * NOTE: this API is only called on Android API 21 and above.
+     *
+     * @param event An object representing the monitoring system change event.
+     */
+    public void onMonitoringSystemChange(GeofenceHardwareMonitorEvent event) {}
 }
diff --git a/core/java/android/hardware/location/GeofenceHardwareMonitorEvent.aidl b/core/java/android/hardware/location/GeofenceHardwareMonitorEvent.aidl
new file mode 100644
index 0000000..008953e
--- /dev/null
+++ b/core/java/android/hardware/location/GeofenceHardwareMonitorEvent.aidl
@@ -0,0 +1,19 @@
+/*
+ * Copyright (C) 2014 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License
+ */
+
+package android.hardware.location;
+
+parcelable GeofenceHardwareMonitorEvent;
\ No newline at end of file
diff --git a/core/java/android/hardware/location/GeofenceHardwareMonitorEvent.java b/core/java/android/hardware/location/GeofenceHardwareMonitorEvent.java
new file mode 100644
index 0000000..9c460d2
--- /dev/null
+++ b/core/java/android/hardware/location/GeofenceHardwareMonitorEvent.java
@@ -0,0 +1,116 @@
+/*
+ * Copyright (C) 2014 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.hardware.location;
+
+import android.location.Location;
+import android.os.Parcel;
+import android.os.Parcelable;
+
+/**
+ * A class that represents an event for each change in the state of a monitoring system.
+ */
+public class GeofenceHardwareMonitorEvent implements Parcelable {
+    private final int mMonitoringType;
+    private final int mMonitoringStatus;
+    private final int mSourceTechnologies;
+    private final Location mLocation;
+
+    public GeofenceHardwareMonitorEvent(
+            int monitoringType,
+            int monitoringStatus,
+            int sourceTechnologies,
+            Location location) {
+        mMonitoringType = monitoringType;
+        mMonitoringStatus = monitoringStatus;
+        mSourceTechnologies = sourceTechnologies;
+        mLocation = location;
+    }
+
+    /**
+     * Returns the type of the monitoring system that has a change on its state.
+     */
+    public int getMonitoringType() {
+        return mMonitoringType;
+    }
+
+    /**
+     * Returns the new status associated with the monitoring system.
+     */
+    public int getMonitoringStatus() {
+        return mMonitoringStatus;
+    }
+
+    /**
+     * Returns the source technologies that the status is associated to.
+     */
+    public int getSourceTechnologies() {
+        return mSourceTechnologies;
+    }
+
+    /**
+     * Returns the last known location according to the monitoring system.
+     */
+    public Location getLocation() {
+        return mLocation;
+    }
+
+    public static final Creator<GeofenceHardwareMonitorEvent> CREATOR =
+            new Creator<GeofenceHardwareMonitorEvent>() {
+                @Override
+                public GeofenceHardwareMonitorEvent createFromParcel(Parcel source) {
+                    ClassLoader classLoader = GeofenceHardwareMonitorEvent.class.getClassLoader();
+                    int monitoringType = source.readInt();
+                    int monitoringStatus = source.readInt();
+                    int sourceTechnologies = source.readInt();
+                    Location location = source.readParcelable(classLoader);
+
+                    return new GeofenceHardwareMonitorEvent(
+                            monitoringType,
+                            monitoringStatus,
+                            sourceTechnologies,
+                            location);
+                }
+
+                @Override
+                public GeofenceHardwareMonitorEvent[] newArray(int size) {
+                    return new GeofenceHardwareMonitorEvent[size];
+                }
+            };
+
+    @Override
+    public int describeContents() {
+        return 0;
+    }
+
+    @Override
+    public void writeToParcel(Parcel parcel, int flags) {
+        parcel.writeInt(mMonitoringType);
+        parcel.writeInt(mMonitoringStatus);
+        parcel.writeInt(mSourceTechnologies);
+        parcel.writeParcelable(mLocation, flags);
+    }
+
+    @Override
+    public String toString() {
+        return String.format(
+                "GeofenceHardwareMonitorEvent: type=%d, status=%d, sources=%d, location=%s",
+                mMonitoringType,
+                mMonitoringStatus,
+                mSourceTechnologies,
+                mLocation);
+    }
+}
diff --git a/core/java/android/hardware/location/GeofenceHardwareRequest.java b/core/java/android/hardware/location/GeofenceHardwareRequest.java
index 796d7f8..887c4ad 100644
--- a/core/java/android/hardware/location/GeofenceHardwareRequest.java
+++ b/core/java/android/hardware/location/GeofenceHardwareRequest.java
@@ -33,6 +33,7 @@ public final class GeofenceHardwareRequest {
     private int mMonitorTransitions = GeofenceHardware.GEOFENCE_UNCERTAIN |
         GeofenceHardware.GEOFENCE_ENTERED | GeofenceHardware.GEOFENCE_EXITED;
     private int mNotificationResponsiveness = 5000; // 5 secs
+    private int mSourceTechnologies = GeofenceHardware.SOURCE_TECHNOLOGY_GNSS;
 
     private void setCircularGeofence(double latitude, double longitude, double radius) {
         mLatitude = latitude;
@@ -102,6 +103,28 @@ public final class GeofenceHardwareRequest {
     }
 
     /**
+     * Set the source technologies to use while tracking the geofence.
+     * The value is the bit-wise of one or several source fields defined in
+     * {@link GeofenceHardware}.
+     *
+     * @param sourceTechnologies The set of source technologies to use.
+     */
+    public void setSourceTechnologies(int sourceTechnologies) {
+        int sourceTechnologiesAll = GeofenceHardware.SOURCE_TECHNOLOGY_GNSS
+                | GeofenceHardware.SOURCE_TECHNOLOGY_WIFI
+                | GeofenceHardware.SOURCE_TECHNOLOGY_SENSORS
+                | GeofenceHardware.SOURCE_TECHNOLOGY_CELL
+                | GeofenceHardware.SOURCE_TECHNOLOGY_BLUETOOTH;
+
+        int sanitizedSourceTechnologies = (sourceTechnologies & sourceTechnologiesAll);
+        if (sanitizedSourceTechnologies == 0) {
+            throw new IllegalArgumentException("At least one valid source technology must be set.");
+        }
+
+        mSourceTechnologies = sanitizedSourceTechnologies;
+    }
+
+    /**
      * Returns the latitude of this geofence.
      */
     public double getLatitude() {
@@ -150,6 +173,13 @@ public final class GeofenceHardwareRequest {
         return mLastTransition;
     }
 
+    /**
+     * Returns the source technologies to track this geofence.
+     */
+    public int getSourceTechnologies() {
+        return mSourceTechnologies;
+    }
+
     int getType() {
         return mType;
     }
diff --git a/core/java/android/hardware/location/GeofenceHardwareRequestParcelable.java b/core/java/android/hardware/location/GeofenceHardwareRequestParcelable.java
index 40e7fc4..d3311f5 100644
--- a/core/java/android/hardware/location/GeofenceHardwareRequestParcelable.java
+++ b/core/java/android/hardware/location/GeofenceHardwareRequestParcelable.java
@@ -98,9 +98,43 @@ public final class GeofenceHardwareRequestParcelable implements Parcelable {
     }
 
     /**
+     * Returns the source technologies to track this geofence.
+     */
+    int getSourceTechnologies() {
+        return mRequest.getSourceTechnologies();
+    }
+
+
+    @Override
+    public String toString() {
+        StringBuilder builder = new StringBuilder();
+        builder.append("id=");
+        builder.append(mId);
+        builder.append(", type=");
+        builder.append(mRequest.getType());
+        builder.append(", latitude=");
+        builder.append(mRequest.getLatitude());
+        builder.append(", longitude=");
+        builder.append(mRequest.getLongitude());
+        builder.append(", radius=");
+        builder.append(mRequest.getRadius());
+        builder.append(", lastTransition=");
+        builder.append(mRequest.getLastTransition());
+        builder.append(", unknownTimer=");
+        builder.append(mRequest.getUnknownTimer());
+        builder.append(", monitorTransitions=");
+        builder.append(mRequest.getMonitorTransitions());
+        builder.append(", notificationResponsiveness=");
+        builder.append(mRequest.getNotificationResponsiveness());
+        builder.append(", sourceTechnologies=");
+        builder.append(mRequest.getSourceTechnologies());
+        return builder.toString();
+    }
+
+    /**
      * Method definitions to support Parcelable operations.
      */
-    public static final Parcelable.Creator<GeofenceHardwareRequestParcelable> CREATOR = 
+    public static final Parcelable.Creator<GeofenceHardwareRequestParcelable> CREATOR =
             new Parcelable.Creator<GeofenceHardwareRequestParcelable>() {
         @Override
         public GeofenceHardwareRequestParcelable createFromParcel(Parcel parcel) {
@@ -120,7 +154,8 @@ public final class GeofenceHardwareRequestParcelable implements Parcelable {
             request.setMonitorTransitions(parcel.readInt());
             request.setUnknownTimer(parcel.readInt());
             request.setNotificationResponsiveness(parcel.readInt());
-            
+            request.setSourceTechnologies(parcel.readInt());
+
             int id = parcel.readInt();
             return new GeofenceHardwareRequestParcelable(id, request);
         }
@@ -146,6 +181,7 @@ public final class GeofenceHardwareRequestParcelable implements Parcelable {
         parcel.writeInt(getMonitorTransitions());
         parcel.writeInt(getUnknownTimer());
         parcel.writeInt(getNotificationResponsiveness());
+        parcel.writeInt(getSourceTechnologies());
         parcel.writeInt(getId());
     }
 }
diff --git a/core/java/android/hardware/location/GeofenceHardwareService.java b/core/java/android/hardware/location/GeofenceHardwareService.java
index fb238bd..4816c5f 100644
--- a/core/java/android/hardware/location/GeofenceHardwareService.java
+++ b/core/java/android/hardware/location/GeofenceHardwareService.java
@@ -86,15 +86,14 @@ public class GeofenceHardwareService extends Service {
 
             return mGeofenceHardwareImpl.getStatusOfMonitoringType(monitoringType);
         }
-        public boolean addCircularFence(int id, int monitoringType, double lat, double longitude,
-                double radius, int lastTransition, int monitorTransitions, int
-                notificationResponsiveness, int unknownTimer, IGeofenceHardwareCallback callback) {
+        public boolean addCircularFence(
+                int monitoringType,
+                GeofenceHardwareRequestParcelable request,
+                IGeofenceHardwareCallback callback) {
             mContext.enforceCallingPermission(Manifest.permission.LOCATION_HARDWARE,
                     "Location Hardware permission not granted to access hardware geofence");
             checkPermission(Binder.getCallingPid(), Binder.getCallingUid(), monitoringType);
-            return mGeofenceHardwareImpl.addCircularFence(id, monitoringType, lat, longitude,
-                    radius, lastTransition, monitorTransitions, notificationResponsiveness,
-                    unknownTimer, callback);
+            return mGeofenceHardwareImpl.addCircularFence(monitoringType, request, callback);
         }
 
         public boolean removeGeofence(int id, int monitoringType) {
diff --git a/core/java/android/hardware/location/IGeofenceHardware.aidl b/core/java/android/hardware/location/IGeofenceHardware.aidl
index 8900166..0e840c4 100644
--- a/core/java/android/hardware/location/IGeofenceHardware.aidl
+++ b/core/java/android/hardware/location/IGeofenceHardware.aidl
@@ -18,6 +18,7 @@ package android.hardware.location;
 
 import android.location.IFusedGeofenceHardware;
 import android.location.IGpsGeofenceHardware;
+import android.hardware.location.GeofenceHardwareRequestParcelable;
 import android.hardware.location.IGeofenceHardwareCallback;
 import android.hardware.location.IGeofenceHardwareMonitorCallback;
 
@@ -27,9 +28,10 @@ interface IGeofenceHardware {
     void setFusedGeofenceHardware(in IFusedGeofenceHardware service);
     int[] getMonitoringTypes();
     int getStatusOfMonitoringType(int monitoringType);
-    boolean addCircularFence(int id,  int monitoringType, double lat, double longitude,
-            double radius, int lastTransition, int monitorTransitions,
-            int notificationResponsiveness, int unknownTimer,in IGeofenceHardwareCallback callback);
+    boolean addCircularFence(
+            int monitoringType,
+            in GeofenceHardwareRequestParcelable request,
+            in IGeofenceHardwareCallback callback);
     boolean removeGeofence(int id, int monitoringType);
     boolean pauseGeofence(int id, int monitoringType);
     boolean resumeGeofence(int id, int monitoringType, int monitorTransitions);
diff --git a/core/java/android/hardware/location/IGeofenceHardwareMonitorCallback.aidl b/core/java/android/hardware/location/IGeofenceHardwareMonitorCallback.aidl
index 0b6e04b..811ecd0 100644
--- a/core/java/android/hardware/location/IGeofenceHardwareMonitorCallback.aidl
+++ b/core/java/android/hardware/location/IGeofenceHardwareMonitorCallback.aidl
@@ -16,9 +16,10 @@
 
 package android.hardware.location;
 
+import android.hardware.location.GeofenceHardwareMonitorEvent;
 import android.location.Location;
 
 /** @hide */
 oneway interface IGeofenceHardwareMonitorCallback {
-   void onMonitoringSystemChange(int monitoringType, boolean available, in Location location);
+    void onMonitoringSystemChange(in GeofenceHardwareMonitorEvent event);
 }