Add CallServiceSelectorAdapter

Previously the selector would communicate with Telecomm using
callbacks.

For handoff, it's easier to communicate using an adapter.

Bug: 13643568
Change-Id: Ida5859a3b5b15c9fa1c533f27a3e14fd0d7c36af

2 files changed, 101 insertions, 128 deletions

diff --git a/telecomm/java/android/telecomm/CallServiceSelector.java b/telecomm/java/android/telecomm/CallServiceSelector.java
index 44181d1..8eec142 100644
--- a/telecomm/java/android/telecomm/CallServiceSelector.java
+++ b/telecomm/java/android/telecomm/CallServiceSelector.java
@@ -23,145 +23,58 @@ 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 com.android.internal.telecomm.ICallServiceSelector;
-import com.android.internal.telecomm.ICallServiceSelectionResponse;
-import com.android.internal.telecomm.ICallSwitchabilityResponse;
+import com.android.internal.telecomm.ICallServiceSelectorAdapter;
 
 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, CallServiceSelectionResponse)}. <br />
- * <br />
- * Also determine whether a call is switchable (can be moved between {@link CallService}s) or not
- * using {@link #isSwitchable(CallInfo, CallSwitchabilityResponse)}.
+ * {@link #select(CallInfo, List)}.
  */
 public abstract class CallServiceSelector extends Service {
-    private static final String TAG = CallServiceSelector.class.getSimpleName();
-
-    /**
-     * 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);
-    }
+    private static final int MSG_SET_CALL_SERVICE_SELECTOR_ADAPTER = 0;
+    private static final int MSG_SELECT = 1;
 
     /** Handler to move client-bound method calls to the main thread. */
     private final Handler mHandler = new Handler(Looper.getMainLooper()) {
-        @SuppressWarnings("unchecked")
         @Override
         public void handleMessage(Message msg) {
-            final SomeArgs args = (SomeArgs) msg.obj;
-            try {
-                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 {
-                if (args != null) {
-                    args.recycle();
-                }
+            switch (msg.what) {
+                case MSG_SET_CALL_SERVICE_SELECTOR_ADAPTER:
+                    CallServiceSelectorAdapter adapter = new CallServiceSelectorAdapter(
+                            (ICallServiceSelectorAdapter) msg.obj);
+                    setCallServiceSelectorAdapter(adapter);
+                    break;
+                case MSG_SELECT:
+                    SomeArgs args = (SomeArgs) msg.obj;
+                    try {
+                        select((CallInfo) args.arg1, (List<CallServiceDescriptor>) args.arg2);
+                    } finally {
+                        args.recycle();
+                    }
+                    break;
             }
         }
     };
 
     /** Manages the binder calls so that the implementor does not need to deal with it. */
-    private final class CallServiceSelectorBinder extends ICallServiceSelector.Stub
-            implements CallSwitchabilityResponse, CallServiceSelectionResponse {
-        private ICallSwitchabilityResponse mSwitchabilityResponse;
-        private ICallServiceSelectionResponse mSelectionResponse;
-
+    private final class CallServiceSelectorBinder extends ICallServiceSelector.Stub {
         @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();
+        public void setCallServiceSelectorAdapter(ICallServiceSelectorAdapter adapter) {
+            mHandler.obtainMessage(MSG_SET_CALL_SERVICE_SELECTOR_ADAPTER, adapter)
+                    .sendToTarget();
         }
 
         @Override
-        public void select(CallInfo callInfo, List<CallServiceDescriptor> descriptors,
-                ICallServiceSelectionResponse response) throws RemoteException {
-            mSelectionResponse = response;
+        public void select(CallInfo callInfo, List<CallServiceDescriptor> descriptors) {
             SomeArgs args = SomeArgs.obtain();
             args.arg1 = callInfo;
             args.arg2 = descriptors;
-            args.arg3 = this;
-            mHandler.obtainMessage(MSG_SELECT_CALL_SERVICES, args).sendToTarget();
-        }
-
-        @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");
-            }
+            mHandler.obtainMessage(MSG_SELECT, args).sendToTarget();
         }
     }
 
@@ -177,31 +90,19 @@ public abstract class CallServiceSelector extends Service {
     }
 
     /**
-     * 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 called on the main thread and is not safe to block.
+     * Sets an adapter that allows the selector to communicate with Telecomm.
      *
-     * @param callInfo The call being potentially switched between {@link CallService}s.
-     * @param response The {@link CallSwitchabilityResponse} listener to call back with the result.
+     * @param adapter Adapter object for communicating with Telecomm.
      */
-    protected abstract void isSwitchable(CallInfo callInfo, CallSwitchabilityResponse response);
+    protected abstract void setCallServiceSelectorAdapter(CallServiceSelectorAdapter adapter);
 
     /**
      * 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 called on the UI thread and is not safe to block.
+     * them through {@link CallServiceSelectorAdapter#select}.
      *
      * @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.
-     * @param response The {@link CallServiceSelectionResponse} listener to call back with the
-     *            result.
      */
-    protected abstract void select(
-            CallInfo callInfo,
-            List<CallServiceDescriptor> descriptors,
-            CallServiceSelectionResponse response);
+    protected abstract void select(CallInfo callInfo, List<CallServiceDescriptor> descriptors);
 }
diff --git a/telecomm/java/android/telecomm/CallServiceSelectorAdapter.java b/telecomm/java/android/telecomm/CallServiceSelectorAdapter.java
new file mode 100644
index 0000000..8635f1a
--- /dev/null
+++ b/telecomm/java/android/telecomm/CallServiceSelectorAdapter.java
@@ -0,0 +1,72 @@
+/*
+ * 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.telecomm;
+
+import android.net.Uri;
+import android.os.Bundle;
+import android.os.RemoteException;
+import android.telecomm.CallServiceDescriptor;
+
+import com.android.internal.telecomm.ICallServiceSelectorAdapter;
+
+import java.util.List;
+
+/**
+ * Provides methods for ICallServiceSelector implementations to interact with Telecomm.
+ */
+public final class CallServiceSelectorAdapter {
+    private final ICallServiceSelectorAdapter mAdapter;
+
+    /**
+     * {@hide}
+     */
+    public CallServiceSelectorAdapter(ICallServiceSelectorAdapter adapter) {
+        mAdapter = adapter;
+    }
+
+    /**
+     * Records the sorted set of call services that are preferred by the corresponding
+     * call-service selector.
+     *
+     * @param callId The ID of the call to complete.
+     * @param selectedCallServiceDescriptors The prioritized list of preferred call-service
+     *        descriptors to use for completing the call.
+     */
+    public void setSelectedCallServices(
+            String callId,
+            List<CallServiceDescriptor> selectedCallServiceDescriptors) {
+        try {
+            mAdapter.setSelectedCallServices(callId, selectedCallServiceDescriptors);
+        } catch (RemoteException e) {
+        }
+    }
+
+    /**
+     * Associates handoff information with an ongoing call. Calls can switch from one call service
+     * to another. Setting handle to a non-null value marks the call as switchable.
+     *
+     * @param callId The ID of the call to set handoff information for.
+     * @param handle The handle used to place the call when switching.
+     * @param extras Optional extra that's attached to the call.
+     */
+    public void setHandoffInfo(String callId, Uri handle, Bundle extras) {
+        try {
+            mAdapter.setHandoffInfo(callId, handle, extras);
+        } catch (RemoteException e) {
+        }
+    }
+}