diff options
Diffstat (limited to 'telephony')
16 files changed, 623 insertions, 27 deletions
diff --git a/telephony/java/android/telephony/CallService.java b/telephony/java/android/telephony/CallService.java new file mode 100644 index 0000000..0ea55b2 --- /dev/null +++ b/telephony/java/android/telephony/CallService.java @@ -0,0 +1,165 @@ +/* + * Copyright (C) 2013 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.telephony; + +import android.app.Service; +import android.content.Intent; +import android.os.Handler; +import android.os.IBinder; +import android.os.Message; + +import com.android.internal.telephony.ICallService; +import com.android.internal.telephony.ICallServiceAdapter; + +/** + * Base implementation of CallService which can be used to provide calls for the system + * in-call UI. CallService is a one-way service from the framework's CallsManager to any app + * that would like to provide calls managed by the default system in-call user interface. + * When the service is bound by the framework, CallsManager will call setCallServiceAdapter + * which will provide CallService with an instance of {@link CallServiceAdapter} to be used + * for communicating back to CallsManager. Subsequently, more specific methods of the service + * will be called to perform various call actions including making an outgoing call and + * disconnected existing calls. + * TODO(santoscordon): Needs more about AndroidManifest.xml service registrations before + * we can unhide this API. + * + * Most public methods of this function are backed by a one-way AIDL interface which precludes + * syncronous responses. As a result, most responses are handled by (or have TODOs to handle) + * response objects instead of return values. + * TODO(santoscordon): Improve paragraph above once the final design is in place. + * @hide + */ +public abstract class CallService extends Service { + + /** + * Default Handler used to consolidate binder method calls onto a single thread. + */ + private final class CallServiceMessageHandler extends Handler { + @Override + public void handleMessage(Message msg) { + switch (msg.what) { + case MSG_SET_CALL_SERVICE_ADAPTER: + setCallServiceAdapter((ICallServiceAdapter) msg.obj); + break; + case MSG_IS_COMPATIBLE_WITH: + isCompatibleWith((String) msg.obj); + break; + case MSG_CALL: + call((String) msg.obj); + break; + case MSG_DISCONNECT: + disconnect((String) msg.obj); + break; + default: + break; + } + } + } + + /** + * Default ICallService implementation provided to CallsManager via {@link #onBind}. + */ + private final class CallServiceWrapper extends ICallService.Stub { + @Override + public void setCallServiceAdapter(ICallServiceAdapter callServiceAdapter) { + mMessageHandler.obtainMessage(MSG_SET_CALL_SERVICE_ADAPTER, callServiceAdapter) + .sendToTarget(); + } + + @Override + public void isCompatibleWith(String handle) { + mMessageHandler.obtainMessage(MSG_IS_COMPATIBLE_WITH, handle).sendToTarget(); + } + + @Override + public void call(String handle) { + mMessageHandler.obtainMessage(MSG_CALL, handle).sendToTarget(); + } + + @Override + public void disconnect(String callId) { + mMessageHandler.obtainMessage(MSG_DISCONNECT, callId).sendToTarget(); + } + } + + // Only used internally by this class. + // Binder method calls on this service can occur on multiple threads. These messages are used + // in conjunction with {@link #mMessageHandler} to ensure that all callbacks are handled on a + // single thread. Keeping it on a single thread allows CallService implementations to avoid + // needing multi-threaded code in their own callback routines. + private static final int + MSG_SET_CALL_SERVICE_ADAPTER = 1, + MSG_IS_COMPATIBLE_WITH = 2, + MSG_CALL = 3, + MSG_DISCONNECT = 4; + + /** + * Message handler for consolidating binder callbacks onto a single thread. + * See {@link #CallServiceMessageHandler}. + */ + private final CallServiceMessageHandler mMessageHandler; + + /** + * Default binder implementation of {@link ICallService} interface. + */ + private final CallServiceWrapper mBinder; + + /** + * Protected constructor called only by subclasses creates the binder interface and + * single-threaded message handler. + */ + protected CallService() { + mMessageHandler = new CallServiceMessageHandler(); + mBinder = new CallServiceWrapper(); + } + + /** {@inheritDoc} */ + public IBinder onBind(Intent intent) { + return mBinder; + } + + /** + * Sets an implementation of ICallServiceAdapter for adding new calls and communicating state + * changes of existing calls. + * @param callServiceAdapter Adapter object for communicating call to CallsManager + * TODO(santoscordon): Should we not reference ICallServiceAdapter directly from here? Should we + * wrap that in a wrapper like we do for CallService/ICallService? + * TODO(santoscordon): Consider rename of CallServiceAdapter to CallsManager. + */ + public abstract void setCallServiceAdapter(ICallServiceAdapter callServiceAdapter); + + /** + * Determines if the CallService can make calls to the handle. + * @param handle The handle to test for compatibility. + * TODO(santoscordon): Need response parameter. + */ + public abstract void isCompatibleWith(String handle); + + /** + * Calls the specified handle. Handle type is dynamically extensible and can be a phone number, + * a SIP address, or other types. Only called if {@link #isCompatibleWith} returns true for the + * same handle and this service is selected by the switchboard to handle the call. + * @param handle The handle to call. + */ + public abstract void call(String handle); + + /** + * Disconnects the specified call. + * @param callId The ID of the call to disconnect. + */ + public abstract void disconnect(String callId); +} diff --git a/telephony/java/android/telephony/TelephonyManager.java b/telephony/java/android/telephony/TelephonyManager.java index 23e4d77..108310e 100644 --- a/telephony/java/android/telephony/TelephonyManager.java +++ b/telephony/java/android/telephony/TelephonyManager.java @@ -18,6 +18,7 @@ package android.telephony; import android.annotation.SdkConstant; import android.annotation.SdkConstant.SdkConstantType; +import android.content.ComponentName; import android.content.Context; import android.os.Bundle; import android.os.RemoteException; @@ -61,6 +62,20 @@ public class TelephonyManager { private static ITelephonyRegistry sRegistry; private final Context mContext; + /** + * The allowed states of Wi-Fi calling. + * + * @hide + */ + public interface WifiCallingChoices { + /** Always use Wi-Fi calling */ + static final int ALWAYS_USE = 0; + /** Ask the user whether to use Wi-Fi on every call */ + static final int ASK_EVERY_TIME = 1; + /** Never use Wi-Fi calling */ + static final int NEVER_USE = 2; + } + /** @hide */ public TelephonyManager(Context context) { Context appContext = context.getApplicationContext(); @@ -1683,6 +1698,24 @@ public class TelephonyManager { } /** + * Inform the phone about a new incoming third party call. The phone will bind to the service + * identified by component to handle the call. + * @param component the component that should handle the intent. + * @param callId the unique id of the call. This id is passed to the service via {@link + * ThirdPartyCallService#incomingCallAttach incomingCallAttach}. + * @param callerDisplayName the name shown to the user. Normally this will be the caller's phone + * number. + */ + public void newIncomingThirdPartyCall(ComponentName component, String callId, + String callerDisplayName) { + try { + getITelephony().newIncomingThirdPartyCall(component, callId, callerDisplayName); + } catch (RemoteException ex) { + } catch (NullPointerException ex) { + } + } + + /** * Returns the MMS user agent. */ public String getMmsUserAgent() { @@ -1705,12 +1738,15 @@ public class TelephonyManager { * * Input parameters equivalent to TS 27.007 AT+CCHO command. * + * <p>Requires Permission: + * {@link android.Manifest.permission#SIM_COMMUNICATION SIM_COMMUNICATION} + * * @param AID Application id. See ETSI 102.221 and 101.220. * @return The logical channel id which is negative on error. */ public int iccOpenLogicalChannel(String AID) { try { - return getITelephony().iccOpenLogicalChannel(AID); + return getITelephony().iccOpenLogicalChannel(AID); } catch (RemoteException ex) { } catch (NullPointerException ex) { } @@ -1722,13 +1758,16 @@ public class TelephonyManager { * * Input parameters equivalent to TS 27.007 AT+CCHC command. * + * <p>Requires Permission: + * {@link android.Manifest.permission#SIM_COMMUNICATION SIM_COMMUNICATION} + * * @param channel is the channel id to be closed as retruned by a successful * iccOpenLogicalChannel. * @return true if the channel was closed successfully. */ public boolean iccCloseLogicalChannel(int channel) { try { - return getITelephony().iccCloseLogicalChannel(channel); + return getITelephony().iccCloseLogicalChannel(channel); } catch (RemoteException ex) { } catch (NullPointerException ex) { } @@ -1740,6 +1779,9 @@ public class TelephonyManager { * * Input parameters equivalent to TS 27.007 AT+CGLA command. * + * <p>Requires Permission: + * {@link android.Manifest.permission#SIM_COMMUNICATION SIM_COMMUNICATION} + * * @param channel is the channel id to be closed as returned by a successful * iccOpenLogicalChannel. * @param cla Class of the APDU command. @@ -1755,8 +1797,29 @@ public class TelephonyManager { public String iccTransmitApduLogicalChannel(int channel, int cla, int instruction, int p1, int p2, int p3, String data) { try { - return getITelephony().iccTransmitApduLogicalChannel(channel, cla, - instruction, p1, p2, p3, data); + return getITelephony().iccTransmitApduLogicalChannel(channel, cla, + instruction, p1, p2, p3, data); + } catch (RemoteException ex) { + } catch (NullPointerException ex) { + } + return ""; + } + + /** + * Send ENVELOPE to the SIM, after processing a proactive command sent by + * the SIM. + * + * <p>Requires Permission: + * {@link android.Manifest.permission#SIM_COMMUNICATION SIM_COMMUNICATION} + * + * @param content String containing SAT/USAT response in hexadecimal + * format starting with command tag. See TS 102 223 for + * details. + * @return The APDU response from the ICC card. + */ + public String sendEnvelope(String content) { + try { + return getITelephony().sendEnvelope(content); } catch (RemoteException ex) { } catch (NullPointerException ex) { } @@ -1860,4 +1923,31 @@ public class TelephonyManager { } return false; } + + /* + * Obtain the current state of Wi-Fi calling. + * + * @hide + * @see android.telephony.TelephonyManager.WifiCallingChoices + */ + public int getWhenToMakeWifiCalls() { + try { + return getITelephony().getWhenToMakeWifiCalls(); + } catch (RemoteException ex) { + return WifiCallingChoices.NEVER_USE; + } + } + + /** + * Set the current state of Wi-Fi calling. + * + * @hide + * @see android.telephony.TelephonyManager.WifiCallingChoices + */ + public void setWhenToMakeWifiCalls(int state) { + try { + getITelephony().setWhenToMakeWifiCalls(state); + } catch (RemoteException ex) { + } + } } diff --git a/telephony/java/android/telephony/ThirdPartyCallListener.java b/telephony/java/android/telephony/ThirdPartyCallListener.java index 00265f8..08f8d3a 100644 --- a/telephony/java/android/telephony/ThirdPartyCallListener.java +++ b/telephony/java/android/telephony/ThirdPartyCallListener.java @@ -16,6 +16,8 @@ package android.telephony; +import android.os.Handler; +import android.os.Message; import android.os.RemoteException; import com.android.internal.telephony.IThirdPartyCallListener; @@ -27,15 +29,12 @@ import com.android.internal.telephony.IThirdPartyCallListener; public class ThirdPartyCallListener { private final IThirdPartyCallListener mListener; - // Call end reason. TODO: rename this to DisconnectCause once they are public. + // Call end reason. public static final int CALL_END_NORMAL = 1; public static final int CALL_END_INCOMING_MISSED = 2; public static final int CALL_END_OTHER = 3; public ThirdPartyCallListener(IThirdPartyCallListener listener) { - if (listener == null) { - throw new IllegalArgumentException("Invalid listener"); - } mListener = listener; } @@ -45,7 +44,9 @@ public class ThirdPartyCallListener { */ public void onCallProviderAttached(ThirdPartyCallProvider callProvider) { try { - mListener.onCallProviderAttached(callProvider.getCallback()); + if (mListener != null) { + mListener.onCallProviderAttached(callProvider.callback); + } } catch (RemoteException e) { } } @@ -55,7 +56,9 @@ public class ThirdPartyCallListener { */ public void onRingingStarted() { try { - mListener.onRingingStarted(); + if (mListener != null) { + mListener.onRingingStarted(); + } } catch (RemoteException e) { } } @@ -65,7 +68,9 @@ public class ThirdPartyCallListener { */ public void onCallEstablished() { try { - mListener.onCallEstablished(); + if (mListener != null) { + mListener.onCallEstablished(); + } } catch (RemoteException e) { } } @@ -75,7 +80,9 @@ public class ThirdPartyCallListener { */ public void onCallEnded(int reason) { try { - mListener.onCallEnded(reason); + if (mListener != null) { + mListener.onCallEnded(reason); + } } catch (RemoteException e) { } } diff --git a/telephony/java/android/telephony/ThirdPartyCallProvider.java b/telephony/java/android/telephony/ThirdPartyCallProvider.java index bd8a1ea..5054380 100644 --- a/telephony/java/android/telephony/ThirdPartyCallProvider.java +++ b/telephony/java/android/telephony/ThirdPartyCallProvider.java @@ -20,6 +20,7 @@ import android.os.Handler; import android.os.Message; import com.android.internal.telephony.IThirdPartyCallProvider; +import com.android.internal.telephony.IThirdPartyCallSendDtmfCallback; /** * Interface sent to {@link android.telephony.ThirdPartyCallListener#onCallProviderAttached @@ -55,15 +56,11 @@ public class ThirdPartyCallProvider { /** * Sends the given DTMF code. The code can be '0'-'9', 'A'-'D', '#', or '*'. */ - public void sendDtmf(char c) { + public void sendDtmf(char c, ThirdPartyCallSendDtmfCallback callback) { // default implementation empty } - IThirdPartyCallProvider getCallback() { - return mCallback; - } - - private final IThirdPartyCallProvider mCallback = new IThirdPartyCallProvider.Stub() { + final IThirdPartyCallProvider callback = new IThirdPartyCallProvider.Stub() { @Override public void mute(boolean shouldMute) { Message.obtain(mHandler, MSG_MUTE, shouldMute ? 1 : 0, 0).sendToTarget(); @@ -80,8 +77,8 @@ public class ThirdPartyCallProvider { } @Override - public void sendDtmf(char c) { - Message.obtain(mHandler, MSG_SEND_DTMF, (int) c, 0).sendToTarget(); + public void sendDtmf(char c, IThirdPartyCallSendDtmfCallback callback) { + Message.obtain(mHandler, MSG_SEND_DTMF, (int) c, 0, callback).sendToTarget(); } }; @@ -99,7 +96,9 @@ public class ThirdPartyCallProvider { incomingCallAccept(); break; case MSG_SEND_DTMF: - sendDtmf((char) msg.arg1); + ThirdPartyCallSendDtmfCallback callback = new ThirdPartyCallSendDtmfCallback( + (IThirdPartyCallSendDtmfCallback) msg.obj); + sendDtmf((char) msg.arg1, callback); break; } } diff --git a/telephony/java/android/telephony/ThirdPartyCallSendDtmfCallback.java b/telephony/java/android/telephony/ThirdPartyCallSendDtmfCallback.java new file mode 100644 index 0000000..5a67cf7 --- /dev/null +++ b/telephony/java/android/telephony/ThirdPartyCallSendDtmfCallback.java @@ -0,0 +1,46 @@ +/* + * Copyright (C) 2013 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.telephony; + +import android.os.RemoteException; + +import com.android.internal.telephony.IThirdPartyCallSendDtmfCallback; + +/** + * Callback interface for when DTMF has been sent. + */ +public class ThirdPartyCallSendDtmfCallback { + private final IThirdPartyCallSendDtmfCallback mCallback; + + public ThirdPartyCallSendDtmfCallback(IThirdPartyCallSendDtmfCallback callback) { + if (callback == null) { + throw new IllegalArgumentException("Invalid callback"); + } + mCallback = callback; + } + + /** + * Called by the service when a call provider is available to perform the outgoing or incoming + * call. + */ + public void onSendDtmfCompleted() { + try { + mCallback.onSendDtmfCompleted(); + } catch (RemoteException e) { + } + } +} diff --git a/telephony/java/android/telephony/ThirdPartyCallService.java b/telephony/java/android/telephony/ThirdPartyCallService.java index 6eddb43..de6c290 100644 --- a/telephony/java/android/telephony/ThirdPartyCallService.java +++ b/telephony/java/android/telephony/ThirdPartyCallService.java @@ -19,6 +19,7 @@ package android.telephony; import android.os.Handler; import android.os.IBinder; import android.os.Message; +import android.os.RemoteException; import android.util.Pair; import com.android.internal.telephony.IThirdPartyCallListener; @@ -39,7 +40,8 @@ public class ThirdPartyCallService { } /** - * Call to attach to an incoming call. + * Call to attach to an incoming call. This is in response to a call to {@link + * android.telephony.TelephonyManager#newIncomingThirdPartyCall newIncomingThirdPartyCall}. */ public void incomingCallAttach(ThirdPartyCallListener listener, String callId) { // default implementation empty @@ -49,10 +51,10 @@ public class ThirdPartyCallService { * Returns an IBinder instance that can returned from the service's onBind function. */ public IBinder getBinder() { - return mCallback; + return callback; } - private final IThirdPartyCallService.Stub mCallback = new IThirdPartyCallService.Stub() { + private final IThirdPartyCallService.Stub callback = new IThirdPartyCallService.Stub() { @Override public void outgoingCallInitiate(IThirdPartyCallListener listener, String number) { Rlog.w("ThirdPartyPhone", "ThirdPartyCallService.IThirdPartyCallService.out"); diff --git a/telephony/java/com/android/internal/telephony/CallInfo.aidl b/telephony/java/com/android/internal/telephony/CallInfo.aidl new file mode 100644 index 0000000..9140388 --- /dev/null +++ b/telephony/java/com/android/internal/telephony/CallInfo.aidl @@ -0,0 +1,19 @@ +/* +** Copyright 2013, 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.telephony; + +parcelable CallInfo; diff --git a/telephony/java/com/android/internal/telephony/CallInfo.java b/telephony/java/com/android/internal/telephony/CallInfo.java new file mode 100644 index 0000000..6bfc9d7 --- /dev/null +++ b/telephony/java/com/android/internal/telephony/CallInfo.java @@ -0,0 +1,77 @@ +/* +** Copyright 2013, 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.telephony; + +import android.os.Parcel; +import android.os.Parcelable; + +/** + * A parcelable holder class of Call information data. + */ +public class CallInfo implements Parcelable { + + /** + * Endpoint to which the call is connected. + * This could be the dialed value for outgoing calls or the caller id of incoming calls. + */ + private String handle; + + public CallInfo(String handle) { + this.handle = handle; + } + + public String getHandle() { + return handle; + } + + // + // Parcelling related code below here. + // + + /** + * Responsible for creating CallInfo objects for deserialized Parcels. + */ + public static final Parcelable.Creator<CallInfo> CREATOR + = new Parcelable.Creator<CallInfo> () { + + @Override + public CallInfo createFromParcel(Parcel source) { + return new CallInfo(source.readString()); + } + + @Override + public CallInfo[] newArray(int size) { + return new CallInfo[size]; + } + }; + + /** + * {@inheritDoc} + */ + @Override + public int describeContents() { + return 0; + } + + /** + * Writes CallInfo object into a serializeable Parcel. + */ + @Override + public void writeToParcel(Parcel destination, int flags) { + destination.writeString(handle); + } +} diff --git a/telephony/java/com/android/internal/telephony/ICallService.aidl b/telephony/java/com/android/internal/telephony/ICallService.aidl new file mode 100644 index 0000000..cb9b2e8 --- /dev/null +++ b/telephony/java/com/android/internal/telephony/ICallService.aidl @@ -0,0 +1,61 @@ +/* + * Copyright (C) 2013 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.telephony; + +import com.android.internal.telephony.ICallServiceAdapter; + +/** + * Service interface for services which would like to provide calls to be + * managed by the system in-call UI. + * + * This interface provides methods that the android framework can use to deliver commands + * for calls provided by this call service including making new calls and disconnecting + * existing ones. A binding to ICallService implementations exists for two conditions: + * 1) There exists one or more live calls for that call service, + * 2) Prior to an outbound call to test if this call service is compatible with the outgoing call. + */ +oneway interface ICallService { + + /** + * Determines if the CallService can make calls to the handle. + * TODO(santoscordon): Move this method into its own service interface long term. + * TODO(santoscordon): Add response callback parameter. + */ + void isCompatibleWith(String handle); + + /** + * Attempts to call the relevant party using the specified handle, be it a phone number, + * SIP address, or some other kind of user ID. Note that the set of handle types is + * dynamically extensible since call providers should be able to implement arbitrary + * handle-calling systems. See {@link #isCompatibleWith}. + * TODO(santoscordon): Should this have a response attached to it to ensure that the call + * service actually plans to make the call? + */ + void call(String handle); + + /** + * Disconnects the call identified by callId. + */ + void disconnect(String callId); + + /** + * Sets an implementation of ICallServiceAdapter which the call service can use to add new calls + * and communicate state changes of existing calls. This is the first method that is called + * after a the framework binds to the call service. + */ + void setCallServiceAdapter(ICallServiceAdapter callServiceAdapter); +} diff --git a/telephony/java/com/android/internal/telephony/ICallServiceAdapter.aidl b/telephony/java/com/android/internal/telephony/ICallServiceAdapter.aidl new file mode 100644 index 0000000..bc900f0 --- /dev/null +++ b/telephony/java/com/android/internal/telephony/ICallServiceAdapter.aidl @@ -0,0 +1,61 @@ +/* + * Copyright (C) 2013 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.telephony; + +import com.android.internal.telephony.CallInfo; + +/** + * Provides methods for ICallService implementations to interact with the system phone app. + */ +oneway interface ICallServiceAdapter { + + /** + * Retrieves a new unique call id for use with newOutgoingCall and newIncomingCall. + */ + void getNextCallId(/* TODO(santoscordon): Needs response object */); + + /** + * Tells CallsManager of a new incoming call. + */ + void newIncomingCall(String callId, in CallInfo info); + + /** + * Tells CallsManager of a new outgoing call. + */ + void newOutgoingCall(String callId, in CallInfo info); + + /** + * Sets a call's state to active (e.g., an ongoing call where two parties can actively + * communicate). + */ + void setActive(String callId); + + /** + * Sets a call's state to ringing (e.g., an inbound ringing call). + */ + void setRinging(String callId); + + /** + * Sets a call's state to dialing (e.g., dialing an outbound call). + */ + void setDialing(String callId); + + /** + * Sets a call's state to disconnected. + */ + void setDisconnected(String callId); +} diff --git a/telephony/java/com/android/internal/telephony/ITelephony.aidl b/telephony/java/com/android/internal/telephony/ITelephony.aidl index 370e27a..5f490af 100644 --- a/telephony/java/com/android/internal/telephony/ITelephony.aidl +++ b/telephony/java/com/android/internal/telephony/ITelephony.aidl @@ -17,10 +17,12 @@ package com.android.internal.telephony; import android.os.Bundle; -import java.util.List; +import android.content.ComponentName; import android.telephony.NeighboringCellInfo; import android.telephony.CellInfo; +import java.util.List; + /** * Interface used to interact with the phone. Mostly this is used by the * TelephonyManager class. A few places are still using this directly. @@ -367,6 +369,17 @@ interface ITelephony { int p1, int p2, int p3, String data); /** + * Send ENVELOPE to the SIM, after processing a proactive command sent by + * the SIM. + * + * @param contents String containing SAT/USAT response in hexadecimal + * format starting with command tag. See TS 102 223 for + * details. + * @return The APDU response from the ICC card. + */ + String sendEnvelope(String content); + + /** * Read one of the NV items defined in {@link RadioNVItems} / {@code ril_nv_items.h}. * Used for device configuration by some CDMA operators. * @@ -412,4 +425,29 @@ interface ITelephony { * @return true on success; false on any failure. */ boolean setRadioMode(int radioMode); + + /** + * Inform the phone about a new incoming third party call. The phone will bind to the service + * identified by component to handle the call. + * @param component the component that should handle the intent. + * @param callId the unique id of the call. + * @param callerDisplayName the name shown to the user. Normally this will be the caller's phone + * number. + */ + void newIncomingThirdPartyCall(in ComponentName component, String callId, + String callerDisplayName); + + /** + * Obtain the current state of Wi-Fi calling. + * + * @see android.telephony.TelephonyManager.WifiCallingChoices + */ + int getWhenToMakeWifiCalls(); + + /** + * Set the current state of Wi-Fi calling. + * + * @see android.telephony.TelephonyManager.WifiCallingChoices + */ + void setWhenToMakeWifiCalls(int state); } diff --git a/telephony/java/com/android/internal/telephony/IThirdPartyCallProvider.aidl b/telephony/java/com/android/internal/telephony/IThirdPartyCallProvider.aidl index a9d67a4..9d595b0 100644 --- a/telephony/java/com/android/internal/telephony/IThirdPartyCallProvider.aidl +++ b/telephony/java/com/android/internal/telephony/IThirdPartyCallProvider.aidl @@ -17,6 +17,7 @@ package com.android.internal.telephony; import com.android.internal.telephony.IThirdPartyCallListener; +import com.android.internal.telephony.IThirdPartyCallSendDtmfCallback; /** * Interface sent to ThirdPartyCallListener.onCallProviderAttached. This is used to control an @@ -42,5 +43,5 @@ oneway interface IThirdPartyCallProvider { /** * Sends the given DTMF code. The code can be '0'-'9', 'A'-'D', '#', or '*'. */ - void sendDtmf(char c); + void sendDtmf(char c, IThirdPartyCallSendDtmfCallback callback); } diff --git a/telephony/java/com/android/internal/telephony/IThirdPartyCallSendDtmfCallback.aidl b/telephony/java/com/android/internal/telephony/IThirdPartyCallSendDtmfCallback.aidl new file mode 100644 index 0000000..3a02b06 --- /dev/null +++ b/telephony/java/com/android/internal/telephony/IThirdPartyCallSendDtmfCallback.aidl @@ -0,0 +1,27 @@ +/* + * Copyright (C) 2013 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.telephony; + +/** + * Callback interface for when DTMF has been sent. + */ +oneway interface IThirdPartyCallSendDtmfCallback { + /** + * Called when the DTMF code has been sent. + */ + void onSendDtmfCompleted(); +} diff --git a/telephony/java/com/android/internal/telephony/IThirdPartyCallService.aidl b/telephony/java/com/android/internal/telephony/IThirdPartyCallService.aidl index c9ee4ed..597567a 100644 --- a/telephony/java/com/android/internal/telephony/IThirdPartyCallService.aidl +++ b/telephony/java/com/android/internal/telephony/IThirdPartyCallService.aidl @@ -28,7 +28,8 @@ oneway interface IThirdPartyCallService { void outgoingCallInitiate(IThirdPartyCallListener listener, String number); /** - * Call to attach to an incoming call. + * Call to attach to an incoming call. This is in response to a call to + * TelephonyManager.newIncomingThirdPartyCall. */ void incomingCallAttach(IThirdPartyCallListener listener, String callId); } diff --git a/telephony/java/com/android/internal/telephony/PhoneConstants.java b/telephony/java/com/android/internal/telephony/PhoneConstants.java index 8c42d25..2dc48c5 100644 --- a/telephony/java/com/android/internal/telephony/PhoneConstants.java +++ b/telephony/java/com/android/internal/telephony/PhoneConstants.java @@ -57,6 +57,7 @@ public class PhoneConstants { public static final int PHONE_TYPE_GSM = RILConstants.GSM_PHONE; public static final int PHONE_TYPE_CDMA = RILConstants.CDMA_PHONE; public static final int PHONE_TYPE_SIP = RILConstants.SIP_PHONE; + public static final int PHONE_TYPE_THIRD_PARTY = RILConstants.THIRD_PARTY_PHONE; // Modes for LTE_ON_CDMA public static final int LTE_ON_CDMA_UNKNOWN = RILConstants.LTE_ON_CDMA_UNKNOWN; diff --git a/telephony/java/com/android/internal/telephony/RILConstants.java b/telephony/java/com/android/internal/telephony/RILConstants.java index 6015df0..b8b90ee 100644 --- a/telephony/java/com/android/internal/telephony/RILConstants.java +++ b/telephony/java/com/android/internal/telephony/RILConstants.java @@ -84,6 +84,7 @@ public interface RILConstants { int GSM_PHONE = 1; int CDMA_PHONE = 2; int SIP_PHONE = 3; + int THIRD_PARTY_PHONE = 4; int LTE_ON_CDMA_UNKNOWN = -1; int LTE_ON_CDMA_FALSE = 0; |