Update CallServiceSelector API

Move the consumer methods to the main thread and use response objects
to return the results back to the caller.

Change-Id: Ifc062cf49421079686d925406c823000232fa728

2 files changed, 135 insertions, 34 deletions

diff --git a/telecomm/java/android/telecomm/CallService.java b/telecomm/java/android/telecomm/CallService.java
index 7d1e32a..7144653 100644
--- a/telecomm/java/android/telecomm/CallService.java
+++ b/telecomm/java/android/telecomm/CallService.java
@@ -21,8 +21,6 @@ import android.content.Intent;
 import android.os.Handler;
 import android.os.IBinder;
 import android.os.Message;
-import android.telecomm.ICallService;
-import android.telecomm.ICallServiceAdapter;
 
 import com.android.internal.os.SomeArgs;
 
@@ -135,14 +133,14 @@ public abstract class CallService extends Service {
 
     /** {@inheritDoc} */
     @Override
-    public IBinder onBind(Intent intent) {
+    public final IBinder onBind(Intent intent) {
         return getBinder();
     }
 
     /**
      * Returns binder object which can be used across IPC methods.
      */
-    public IBinder getBinder() {
+    public final IBinder getBinder() {
         return mBinder;
     }
 
diff --git a/telecomm/java/android/telecomm/CallServiceSelector.java b/telecomm/java/android/telecomm/CallServiceSelector.java
index cef9987..6937bdf 100644
--- a/telecomm/java/android/telecomm/CallServiceSelector.java
+++ b/telecomm/java/android/telecomm/CallServiceSelector.java
@@ -18,47 +18,146 @@ package android.telecomm;
 
 import android.app.Service;
 import android.content.Intent;
-import android.os.Binder;
+import android.os.Handler;
 import android.os.IBinder;
+import android.os.Looper;
+import android.os.Message;
 import android.os.RemoteException;
+import android.util.Log;
+
+import com.android.internal.os.SomeArgs;
 
 import java.util.List;
 
 /**
  * Allows for the organization of {@link CallService}s for outbound calls. Given a call and list of
  * {@link CallService} IDs, order the list in terms of priority and return it using
- * {@link #select(CallInfo, List)}. <br />
+ * {@link #select(CallInfo, List, CallServiceSelectionResponse)}. <br />
  * <br />
  * Also determine whether a call is switchable (can be moved between {@link CallService}s) or not
- * using {@link #isSwitchable(CallInfo)}.
+ * using {@link #isSwitchable(CallInfo, CallSwitchabilityResponse)}.
  */
 public abstract class CallServiceSelector extends Service {
+    private static final String TAG = CallServiceSelector.class.getSimpleName();
 
-    /** Manages the binder calls so that the implementor does not need to deal it. */
-    private final class CallServiceSelectorBinder extends ICallServiceSelector.Stub {
+    /**
+     * Used to tell {@link #mHandler} to move the call to
+     * {@link CallServiceSelector#isSwitchable(CallInfo, CallSwitchabilityResponse)} to the main
+     * thread.
+     */
+    private static final int MSG_IS_SWITCHABLE = 1;
+
+    /**
+     * Used to tell {@link #mHandler} to move the call to
+     * {@link #select(CallInfo, List, CallServiceSelectionResponse)} to the main thread.
+     */
+    private static final int MSG_SELECT_CALL_SERVICES = 2;
+
+    /**
+     * Listens for responses from the {@link CallServiceSelector} and passes them back through the
+     * Binder interface. This must be called from
+     * {@link CallServiceSelector#isSwitchable(CallInfo, CallSwitchabilityResponse)}.
+     */
+    public interface CallSwitchabilityResponse {
+        /**
+         * Mark a call as switchable (or not). This must be called by
+         * {@link CallServiceSelector#isSwitchable(CallInfo, CallSwitchabilityResponse)}.
+         *
+         * @param isSwitchable Whether the call was switchable or not.
+         */
+        void setSwitchable(boolean isSwitchable);
+    }
+
+    /**
+     * Listens for responses from the {@link CallServiceSelector} and passes them back through the
+     * Binder interface. This must be called from
+     * {@link CallServiceSelector#select(CallInfo, List, CallServiceSelectionResponse)}.
+     */
+    public interface CallServiceSelectionResponse {
+        /**
+         * Sets the prioritized {@link CallServiceDescriptor}s for the given {@link CallInfo}. This
+         * must be called by
+         * {@link CallServiceSelector#select(CallInfo, List, CallServiceSelectionResponse)}.
+         *
+         * @param callServices The prioritized {@link CallServiceDescriptor}s.
+         */
+        void setSelectedCallServices(List<CallServiceDescriptor> callServices);
+    }
+
+    /** Handler to move client-bound method calls to the main thread. */
+    private final Handler mHandler = new Handler(Looper.getMainLooper()) {
+        @SuppressWarnings("unchecked")
         @Override
-        public void isSwitchable(CallInfo callInfo, ICallSwitchabilityResponse response)
-                throws RemoteException {
-            // Ensure that we're running with the app's normal permission level
-            long ident = Binder.clearCallingIdentity();
+        public void handleMessage(Message msg) {
+            final SomeArgs args = (SomeArgs) msg.obj;
             try {
-                response.setIsSwitchable(CallServiceSelector.this.isSwitchable(callInfo));
+                switch (msg.what) {
+                    case MSG_IS_SWITCHABLE:
+                        isSwitchable((CallInfo) args.arg1, (CallSwitchabilityResponse) args.arg2);
+                        break;
+                    case MSG_SELECT_CALL_SERVICES:
+                        select((CallInfo) args.arg1, (List<CallServiceDescriptor>) args.arg2,
+                                (CallServiceSelectionResponse) args.arg3);
+                        break;
+                }
             } finally {
-                Binder.restoreCallingIdentity(ident);
+                if (args != null) {
+                    args.recycle();
+                }
             }
         }
+    };
+
+    /** Manages the binder calls so that the implementor does not need to deal it. */
+    private final class CallServiceSelectorBinder extends ICallServiceSelector.Stub
+            implements CallSwitchabilityResponse, CallServiceSelectionResponse {
+        private ICallSwitchabilityResponse mSwitchabilityResponse;
+        private ICallServiceSelectionResponse mSelectionResponse;
+
+        @Override
+        public void isSwitchable(CallInfo callInfo, ICallSwitchabilityResponse response)
+                throws RemoteException {
+            mSwitchabilityResponse = response;
+            SomeArgs args = SomeArgs.obtain();
+            args.arg1 = callInfo;
+            args.arg2 = this;
+            mHandler.obtainMessage(MSG_IS_SWITCHABLE, args).sendToTarget();
+        }
 
         @Override
         public void select(CallInfo callInfo, List<CallServiceDescriptor> descriptors,
                 ICallServiceSelectionResponse response) throws RemoteException {
+            mSelectionResponse = response;
+            SomeArgs args = SomeArgs.obtain();
+            args.arg1 = callInfo;
+            args.arg2 = descriptors;
+            args.arg3 = this;
+            mHandler.obtainMessage(MSG_SELECT_CALL_SERVICES, args).sendToTarget();
+        }
 
-            // Ensure that we're running with the app's normal permission level
-            long ident = Binder.clearCallingIdentity();
-            try {
-                response.setSelectedCallServiceDescriptors(
-                        CallServiceSelector.this.select(callInfo, descriptors));
-            } finally {
-                Binder.restoreCallingIdentity(ident);
+        @Override
+        public void setSwitchable(boolean isSwitchable) {
+            if (mSwitchabilityResponse != null) {
+                try {
+                    mSwitchabilityResponse.setIsSwitchable(isSwitchable);
+                } catch (RemoteException e) {
+                    Log.d(TAG, "Failed to set switchability", e);
+                }
+            } else {
+                Log.wtf(TAG, "Switchability response object not set");
+            }
+        }
+
+        @Override
+        public void setSelectedCallServices(List<CallServiceDescriptor> callServices) {
+            if (mSelectionResponse != null) {
+                try {
+                    mSelectionResponse.setSelectedCallServiceDescriptors(callServices);
+                } catch (RemoteException e) {
+                    Log.d(TAG, "Failed to set call services", e);
+                }
+            } else {
+                Log.wtf(TAG, "Selector response object not set");
             }
         }
     }
@@ -75,27 +174,31 @@ public abstract class CallServiceSelector extends Service {
     }
 
     /**
-     * Determines (and returns) whether the given call is switchable. That is, whether the call can
-     * be moved to another {@link CallService} seamlessly.<br />
+     * Determines whether the given call is switchable. That is, whether the call can be moved to
+     * another {@link CallService} seamlessly. Once this is determined, the result is passed to the
+     * given {@link CallSwitchabilityResponse} listener.<br />
      * <br />
-     * This method is not called on the UI thread and is safe to block.
+     * This method is called on the main thread and is not safe to block.
      *
      * @param callInfo The call being potentially switched between {@link CallService}s.
-     * @return Whether the given call is switchable or not.
+     * @param response The {@link CallSwitchabilityResponse} listener to call back with the result.
      */
-    protected abstract boolean isSwitchable(CallInfo callInfo);
+    protected abstract void isSwitchable(CallInfo callInfo, CallSwitchabilityResponse response);
 
     /**
-     * Return a list of prioritized {@link CallService}s which should be used to complete the given
-     * call.<br />
+     * Given a list of {@link CallServiceDescriptor}s, order them into a prioritized list and return
+     * them through the given {@link CallServiceSelectionResponse} listener.<br />
      * <br />
-     * This method is not called on the UI thread and is safe to block.
+     * This method is called on the UI thread and is not safe to block.
      *
      * @param callInfo The call being placed using the {@link CallService}s.
      * @param descriptors The descriptors of the available {@link CallService}s with which to place
-     *         the call.
-     * @return A list of prioritized call-service descriptors to use to complete the given call.
+     *            the call.
+     * @param response The {@link CallServiceSelectionResponse} listener to call back with the
+     *            result.
      */
-    protected abstract List<CallServiceDescriptor> select(
-            CallInfo callInfo, List<CallServiceDescriptor> descriptors);
+    protected abstract void select(
+            CallInfo callInfo,
+            List<CallServiceDescriptor> descriptors,
+            CallServiceSelectionResponse response);
 }