Merge "Remove obsolete ThirdPartyCall APIs" (4a644e39) · Commits · e / os / android_frameworks_base

api/current.txt

+0 −56

Original line number	Diff line number	Diff line
		@@ -27075,15 +27075,12 @@ package android.telephony {
		method public java.lang.String getSubscriberId();
		method public java.lang.String getVoiceMailAlphaTag();
		method public java.lang.String getVoiceMailNumber();
		method public int getWhenToMakeWifiCalls();
		method public boolean hasIccCard();
		method public boolean iccCloseLogicalChannel(int);
		method public int iccOpenLogicalChannel(java.lang.String);
		method public java.lang.String iccTransmitApduLogicalChannel(int, int, int, int, int, int, java.lang.String);
		method public boolean isNetworkRoaming();
		method public void listen(android.telephony.PhoneStateListener, int);
		method public void newIncomingThirdPartyCall(android.content.ComponentName, java.lang.String, java.lang.String);
		method public java.lang.String sendEnvelope(java.lang.String);
		field public static final java.lang.String ACTION_PHONE_STATE_CHANGED = "android.intent.action.PHONE_STATE";
		field public static final java.lang.String ACTION_RESPOND_VIA_MESSAGE = "android.intent.action.RESPOND_VIA_MESSAGE";
		field public static final int CALL_STATE_IDLE = 0; // 0x0
		@@ -27131,37 +27128,6 @@ package android.telephony {
		field public static final int SIM_STATE_UNKNOWN = 0; // 0x0
		}

		public class ThirdPartyCallListener {
		ctor public ThirdPartyCallListener(com.android.internal.telephony.IThirdPartyCallListener);
		method public void onCallEnded(int);
		method public void onCallEstablished();
		method public void onCallProviderAttached(android.telephony.ThirdPartyCallProvider);
		method public void onRingingStarted();
		field public static final int CALL_END_INCOMING_MISSED = 2; // 0x2
		field public static final int CALL_END_NORMAL = 1; // 0x1
		field public static final int CALL_END_OTHER = 3; // 0x3
		}

		public class ThirdPartyCallProvider {
		ctor public ThirdPartyCallProvider();
		method public void hangup();
		method public void incomingCallAccept();
		method public void mute(boolean);
		method public void sendDtmf(char, android.telephony.ThirdPartyCallSendDtmfCallback);
		}

		public class ThirdPartyCallSendDtmfCallback {
		ctor public ThirdPartyCallSendDtmfCallback(com.android.internal.telephony.IThirdPartyCallSendDtmfCallback);
		method public void onSendDtmfCompleted();
		}

		public class ThirdPartyCallService {
		ctor public ThirdPartyCallService();
		method public android.os.IBinder getBinder();
		method public void incomingCallAttach(android.telephony.ThirdPartyCallListener, java.lang.String);
		method public void outgoingCallInitiate(android.telephony.ThirdPartyCallListener, java.lang.String);
		}

		}

		package android.telephony.cdma {
		@@ -37090,28 +37056,6 @@ package android.widget {

		}

		package com.android.internal.telephony {

		public abstract interface IThirdPartyCallListener implements android.os.IInterface {
		method public abstract void onCallEnded(int) throws android.os.RemoteException;
		method public abstract void onCallEstablished() throws android.os.RemoteException;
		method public abstract void onCallProviderAttached(com.android.internal.telephony.IThirdPartyCallProvider) throws android.os.RemoteException;
		method public abstract void onRingingStarted() throws android.os.RemoteException;
		}

		public abstract interface IThirdPartyCallProvider implements android.os.IInterface {
		method public abstract void hangup() throws android.os.RemoteException;
		method public abstract void incomingCallAccept() throws android.os.RemoteException;
		method public abstract void mute(boolean) throws android.os.RemoteException;
		method public abstract void sendDtmf(char, com.android.internal.telephony.IThirdPartyCallSendDtmfCallback) throws android.os.RemoteException;
		}

		public abstract interface IThirdPartyCallSendDtmfCallback implements android.os.IInterface {
		method public abstract void onSendDtmfCompleted() throws android.os.RemoteException;
		}

		}

		package com.android.internal.util {

		public abstract interface Predicate {

telephony/java/android/telephony/TelephonyManager.java

+0 −45

Original line number	Diff line number	Diff line
		@@ -1750,24 +1750,6 @@ 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.
		*/
		@@ -1928,33 +1910,6 @@ 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) {
		}
		}

		/**
		* Get the preferred network type.
		* Used for device configuration by some CDMA operators.

telephony/java/android/telephony/ThirdPartyCallListener.java

deleted100644 → 0

+0 −89

Original line number	Diff line number	Diff line
		/*
		* 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.Handler;
		import android.os.Message;
		import android.os.RemoteException;

		import com.android.internal.telephony.IThirdPartyCallListener;

		/**
		* Interface provided to {@link android.telephony.ThirdPartyCallService}. The service can use this
		* to notify the listener of changes to the call state.
		*/
		public class ThirdPartyCallListener {
		private final IThirdPartyCallListener mListener;

		// 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) {
		mListener = listener;
		}

		/**
		* Called by the service when a call provider is available to perform the outgoing or incoming
		* call.
		*/
		public void onCallProviderAttached(ThirdPartyCallProvider callProvider) {
		try {
		if (mListener != null) {
		mListener.onCallProviderAttached(callProvider.callback);
		}
		} catch (RemoteException e) {
		}
		}

		/**
		* Notifies the listener that ringing has started for this call.
		*/
		public void onRingingStarted() {
		try {
		if (mListener != null) {
		mListener.onRingingStarted();
		}
		} catch (RemoteException e) {
		}
		}

		/**
		* Notifies the listener that the call has been successfully established.
		*/
		public void onCallEstablished() {
		try {
		if (mListener != null) {
		mListener.onCallEstablished();
		}
		} catch (RemoteException e) {
		}
		}

		/**
		* Notifies the listener that the call has ended.
		*/
		public void onCallEnded(int reason) {
		try {
		if (mListener != null) {
		mListener.onCallEnded(reason);
		}
		} catch (RemoteException e) {
		}
		}
		}

telephony/java/android/telephony/ThirdPartyCallProvider.java

deleted100644 → 0

+0 −106

Original line number	Diff line number	Diff line
		/*
		* 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.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
		* onCallProviderAttached}. This is used to control an outgoing or an incoming call.
		*/
		public class ThirdPartyCallProvider {
		private static final int MSG_MUTE = 1;
		private static final int MSG_HANGUP = 2;
		private static final int MSG_INCOMING_CALL_ACCEPT = 3;
		private static final int MSG_SEND_DTMF = 4;

		/**
		* Mutes or unmutes the call.
		*/
		public void mute(boolean shouldMute) {
		// default implementation empty
		}

		/**
		* Ends the current call. If this is an unanswered incoming call then the call is rejected.
		*/
		public void hangup() {
		// default implementation empty
		}

		/**
		* Accepts the incoming call.
		*/
		public void incomingCallAccept() {
		// default implementation empty
		}

		/**
		* Sends the given DTMF code. The code can be '0'-'9', 'A'-'D', '#', or '*'.
		*/
		public void sendDtmf(char c, ThirdPartyCallSendDtmfCallback callback) {
		// default implementation empty
		}

		final IThirdPartyCallProvider callback = new IThirdPartyCallProvider.Stub() {
		@Override
		public void mute(boolean shouldMute) {
		Message.obtain(mHandler, MSG_MUTE, shouldMute ? 1 : 0, 0).sendToTarget();
		}

		@Override
		public void hangup() {
		Message.obtain(mHandler, MSG_HANGUP).sendToTarget();
		}

		@Override
		public void incomingCallAccept() {
		Message.obtain(mHandler, MSG_INCOMING_CALL_ACCEPT).sendToTarget();
		}

		@Override
		public void sendDtmf(char c, IThirdPartyCallSendDtmfCallback callback) {
		Message.obtain(mHandler, MSG_SEND_DTMF, (int) c, 0, callback).sendToTarget();
		}
		};

		private final Handler mHandler = new Handler() {
		@Override
		public void handleMessage(Message msg) {
		switch (msg.what) {
		case MSG_MUTE:
		mute(msg.arg1 != 0);
		break;
		case MSG_HANGUP:
		hangup();
		break;
		case MSG_INCOMING_CALL_ACCEPT:
		incomingCallAccept();
		break;
		case MSG_SEND_DTMF:
		ThirdPartyCallSendDtmfCallback callback = new ThirdPartyCallSendDtmfCallback(
		(IThirdPartyCallSendDtmfCallback) msg.obj);
		sendDtmf((char) msg.arg1, callback);
		break;
		}
		}
		};
		}

telephony/java/android/telephony/ThirdPartyCallSendDtmfCallback.java

deleted100644 → 0

+0 −46

Original line number	Diff line number	Diff line
		/*
		* 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) {
		}
		}
		}