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
This commit is contained in:
Sailesh Nepal
@@ -289,9 +289,8 @@ LOCAL_SRC_FILES += \
|
||||
telecomm/java/com/android/internal/telecomm/ICallServiceAdapter.aidl \
|
||||
telecomm/java/com/android/internal/telecomm/ICallServiceLookupResponse.aidl \
|
||||
telecomm/java/com/android/internal/telecomm/ICallServiceProvider.aidl \
|
||||
telecomm/java/com/android/internal/telecomm/ICallServiceSelectionResponse.aidl \
|
||||
telecomm/java/com/android/internal/telecomm/ICallServiceSelector.aidl \
|
||||
telecomm/java/com/android/internal/telecomm/ICallSwitchabilityResponse.aidl \
|
||||
telecomm/java/com/android/internal/telecomm/ICallServiceSelectorAdapter.aidl \
|
||||
telecomm/java/com/android/internal/telecomm/IInCallAdapter.aidl \
|
||||
telecomm/java/com/android/internal/telecomm/IInCallService.aidl \
|
||||
telephony/java/com/android/internal/telephony/IPhoneStateListener.aidl \
|
||||
|
||||
@@ -24945,17 +24945,14 @@ package android.telecomm {
|
||||
|
||||
public abstract class CallServiceSelector extends android.app.Service {
|
||||
ctor protected CallServiceSelector();
|
||||
method protected abstract void isSwitchable(android.telecomm.CallInfo, android.telecomm.CallServiceSelector.CallSwitchabilityResponse);
|
||||
method public final android.os.IBinder onBind(android.content.Intent);
|
||||
method protected abstract void select(android.telecomm.CallInfo, java.util.List<android.telecomm.CallServiceDescriptor>, android.telecomm.CallServiceSelector.CallServiceSelectionResponse);
|
||||
method protected abstract void select(android.telecomm.CallInfo, java.util.List<android.telecomm.CallServiceDescriptor>);
|
||||
method protected abstract void setCallServiceSelectorAdapter(android.telecomm.CallServiceSelectorAdapter);
|
||||
}
|
||||
|
||||
public static abstract interface CallServiceSelector.CallServiceSelectionResponse {
|
||||
method public abstract void setSelectedCallServices(java.util.List<android.telecomm.CallServiceDescriptor>);
|
||||
}
|
||||
|
||||
public static abstract interface CallServiceSelector.CallSwitchabilityResponse {
|
||||
method public abstract void setSwitchable(boolean);
|
||||
public final class CallServiceSelectorAdapter {
|
||||
method public void setHandoffInfo(java.lang.String, android.net.Uri, android.os.Bundle);
|
||||
method public void setSelectedCallServices(java.lang.String, java.util.List<android.telecomm.CallServiceDescriptor>);
|
||||
}
|
||||
|
||||
public final class CallState extends java.lang.Enum {
|
||||
|
||||
@@ -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);
|
||||
}
|
||||
|
||||
@@ -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) {
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -21,16 +21,12 @@ import android.telecomm.CallServiceDescriptor;
|
||||
import java.util.List;
|
||||
|
||||
/**
|
||||
* Used by {@link ICallServiceProvider} to return a list of {@link CallServiceDescriptor}s.
|
||||
* {@hide}
|
||||
* Internal remote interface for call service lookup response.
|
||||
*
|
||||
* @see android.telecomm.CallServiceLookupResponse
|
||||
*
|
||||
* @hide
|
||||
*/
|
||||
oneway interface ICallServiceLookupResponse {
|
||||
/**
|
||||
* Passes the sorted list of preferred {@link CallServiceDescriptor}s back to Telecomm. Used
|
||||
* in the context of attempting to place a pending outgoing call.
|
||||
*
|
||||
* @param callServiceDescriptors The set of call-service descriptors from
|
||||
* {@link ICallServiceProvider}.
|
||||
*/
|
||||
void setCallServiceDescriptors(in List<CallServiceDescriptor> callServiceDescriptors);
|
||||
}
|
||||
|
||||
@@ -21,28 +21,12 @@ import android.telecomm.CallServiceDescriptor;
|
||||
import com.android.internal.telecomm.ICallServiceLookupResponse;
|
||||
|
||||
/**
|
||||
* Interface for applications interested in providing call-service implementations. Only used in
|
||||
* outgoing-call scenarios where the best-candidate service to issue the call over may need to be
|
||||
* decided dynamically (unlike incoming call scenario where the call-service is known).
|
||||
* Internal remote interface for call service providers.
|
||||
*
|
||||
* Intended usage at time of writing is: Call intent received by the CallsManager, which in turn
|
||||
* gathers and binds all ICallServiceProvider implementations (using the framework). Once bound, the
|
||||
* CallsManager invokes the lookupCallServices API of each bound provider and waits until
|
||||
* either all providers reply (asynchronously) or some timeout is met. The resulted list is then
|
||||
* processed by the CallsManager and its helpers (potentially requesting input from the user) to
|
||||
* identify the best CallService. The user should obviously be notified upon zero candidates as
|
||||
* well as all (one or more) candidates failing to issue the call.
|
||||
* {@hide}
|
||||
* @see android.telecomm.CallServiceProvider
|
||||
*
|
||||
* @hide
|
||||
*/
|
||||
oneway interface ICallServiceProvider {
|
||||
|
||||
/**
|
||||
* Initiates the process to retrieve the list of {@link CallServiceDescriptor}s implemented by
|
||||
* this provider.
|
||||
* TODO(santoscordon): Needs comments on how to populate the list within
|
||||
* ICallServiceLookupResponse and how to handle error conditions.
|
||||
*
|
||||
* @param response The response object through which the list of call services is sent.
|
||||
*/
|
||||
void lookupCallServices(in ICallServiceLookupResponse response);
|
||||
}
|
||||
|
||||
@@ -20,72 +20,19 @@ import android.telecomm.CallInfo;
|
||||
import android.telecomm.CallServiceDescriptor;
|
||||
|
||||
import com.android.internal.telecomm.ICallService;
|
||||
import com.android.internal.telecomm.ICallServiceSelectionResponse;
|
||||
import com.android.internal.telecomm.ICallSwitchabilityResponse;
|
||||
import com.android.internal.telecomm.ICallServiceSelectorAdapter;
|
||||
|
||||
import java.util.List;
|
||||
|
||||
/**
|
||||
* Interface for call-service selector implementations.
|
||||
* Internal remote interface for call service selectors.
|
||||
*
|
||||
* Call-service selectors are ultimately responsible for deciding which of the available call
|
||||
* service implementations should be used to place an outgoing call, as well as which service
|
||||
* to switch the call to upon system-provided opportunities to switch call services.
|
||||
* @see android.telecomm.CallServiceSelector
|
||||
*
|
||||
* Outgoing call scenario:
|
||||
*
|
||||
* Telecomm maintains a prioritized list of call-service selectors. Upon attempting to issue
|
||||
* outgoing calls, the switchboard iterates through these (starting with the highest-priority
|
||||
* selector). It then invokes the "select" API below passing -- among other parameters -- the
|
||||
* list of available call services, excluding fully-utilized services that temporarily aren't
|
||||
* capable of accommodating additional calls. Once invoked, selectors return a sorted subset
|
||||
* from the specified list, containing the preferred services through which to place the call.
|
||||
* Upon empty selection the switchboard continues to the next selector. Otherwise, upon non-
|
||||
* empty selection, the returned call services are attempted in the specified order. The flow
|
||||
* is concluded either when the call is placed by one of the specified services (e.g. ringing)
|
||||
* or upon failure to connect by the time the set of selectors is exhausted. Failed calls are
|
||||
* essentially abandoned by this flow and then picked up by the switchboard's monitor.
|
||||
*
|
||||
* Note that attempted-yet-failed call services within one outgoing-call cycle may be omitted
|
||||
* from the set passed to the next selector. As for selector priority, at the time of writing
|
||||
* this is intended to be a blend of built-in priorities (e.g. to handle emergency calls) and
|
||||
* user-specified preferences (via settings, e.g. electing to use a particular selector prior
|
||||
* to attempting the system-default call-service selector).
|
||||
*
|
||||
* Call-services switching scenario (applying to both incoming and outgoing calls):
|
||||
*
|
||||
* The switchboard may invoke any active selector (a selector associated with one or more on-
|
||||
* going calls) up to once per ongoing call at its discretion (e.g. periodically), once again
|
||||
* passing the available call services to the "select" API. As in the outgoing-call scenario
|
||||
* above, returning the empty list means "pass" -- basically indicating that the current call
|
||||
* service for this call need not be switched at this time. In cases where switching isn't at
|
||||
* all supported (either for a given call or globally across a given selector) , isSwitchable
|
||||
* below can return false blindly to suppress all "select" calls beyond the initial one (that
|
||||
* is used to establish outgoing calls).
|
||||
* {@hide}
|
||||
* @hide
|
||||
*/
|
||||
oneway interface ICallServiceSelector {
|
||||
void setCallServiceSelectorAdapter(in ICallServiceSelectorAdapter adapter);
|
||||
|
||||
/**
|
||||
* Initiates the process to retrieve the sorted set of call services that are preferred by
|
||||
* this call-service selector.
|
||||
*
|
||||
* @param callInfo The details of the relevant call.
|
||||
* @param callServiceDescriptors The list of call-service descriptors to select from.
|
||||
* @param response The response object through which the selected service IDs are passed back
|
||||
* to Telecomm.
|
||||
*/
|
||||
void select(
|
||||
in CallInfo callInfo,
|
||||
in List<CallServiceDescriptor> callServiceDescriptors,
|
||||
in ICallServiceSelectionResponse response);
|
||||
|
||||
/**
|
||||
* Determines if the specified ongoing call can/should be switched from the currently-used
|
||||
* call service to another.
|
||||
*
|
||||
* @param callInfo The details of the relevant call.
|
||||
* @param response The response object to be populated and returned to switchboard.
|
||||
*/
|
||||
void isSwitchable(in CallInfo callInfo, in ICallSwitchabilityResponse response);
|
||||
void select(in CallInfo callInfo, in List<CallServiceDescriptor> callServiceDescriptors);
|
||||
}
|
||||
|
||||
@@ -16,23 +16,24 @@
|
||||
|
||||
package com.android.internal.telecomm;
|
||||
|
||||
import android.os.IBinder;
|
||||
import android.net.Uri;
|
||||
import android.os.Bundle;
|
||||
import android.telecomm.CallInfo;
|
||||
import android.telecomm.CallServiceDescriptor;
|
||||
|
||||
import java.util.List;
|
||||
|
||||
/**
|
||||
* Used by {@link ICallServiceSelector} to return the preferred list of {@link ICallService}
|
||||
* implementations with which to connect the corresponding outgoing call.
|
||||
* {@hide}
|
||||
* Internal remote interface for call service selector adapter.
|
||||
*
|
||||
* @see android.telecomm.CallServiceSelectorAdapter
|
||||
*
|
||||
* @hide
|
||||
*/
|
||||
oneway interface ICallServiceSelectionResponse {
|
||||
/**
|
||||
* Records the sorted set of call services that are preferred by the corresponding
|
||||
* call-service selector.
|
||||
*
|
||||
* @param selectedCallServiceDescriptors The prioritized list of preferred call-service
|
||||
* descriptors to use for completing the call.
|
||||
*/
|
||||
void setSelectedCallServiceDescriptors(
|
||||
oneway interface ICallServiceSelectorAdapter {
|
||||
void setSelectedCallServices(
|
||||
String callId,
|
||||
in List<CallServiceDescriptor> selectedCallServiceDescriptors);
|
||||
|
||||
void setHandoffInfo(String callId, in Uri handle, in Bundle extras);
|
||||
}
|
||||
@@ -1,36 +0,0 @@
|
||||
/*
|
||||
* 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 com.android.internal.telecomm;
|
||||
|
||||
/**
|
||||
* Used by {@link ICallServiceSelector}s to return whether or not the relevant
|
||||
* call is switchable.
|
||||
* {@hide}
|
||||
*/
|
||||
oneway interface ICallSwitchabilityResponse {
|
||||
/**
|
||||
* Records whether or not the corresponding call can potentially be switched to another
|
||||
* call service.
|
||||
*
|
||||
* @param isSwitchable True if the associated call-service selector may be interested
|
||||
* in switching call services. Setting isSwitchable to true should generally
|
||||
* guarantee the "select" API of the associated selector to be invoked, hence
|
||||
* allowing the selector to return either the empty list (meaning pass, don't
|
||||
* switch) or the prioritized list of call-services to attempt switching to.
|
||||
*/
|
||||
void setIsSwitchable(boolean isSwitchable);
|
||||
}
|
||||
Reference in New Issue
Block a user