Delete Third Party Call APIs (f86a9221) · Commits · e / os / android_frameworks_base

Android.mk

+0 −3

Original line number	Diff line number	Diff line
		@@ -275,9 +275,6 @@ LOCAL_SRC_FILES += \
		telephony/java/com/android/internal/telephony/IPhoneStateListener.aidl \
		telephony/java/com/android/internal/telephony/IPhoneSubInfo.aidl \
		telephony/java/com/android/internal/telephony/ITelephony.aidl \
		telephony/java/com/android/internal/telephony/IThirdPartyCallListener.aidl \
		telephony/java/com/android/internal/telephony/IThirdPartyCallProvider.aidl \
		telephony/java/com/android/internal/telephony/IThirdPartyCallService.aidl \
		telephony/java/com/android/internal/telephony/ISms.aidl \
		telephony/java/com/android/internal/telephony/ITelephonyRegistry.aidl \
		telephony/java/com/android/internal/telephony/IWapPushManager.aidl \

api/current.txt

+0 −44

Original line number	Diff line number	Diff line
		@@ -24570,32 +24570,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);
		}

		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 {
		@@ -34079,24 +34053,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) throws android.os.RemoteException;
		}

		}

		package com.android.internal.util {

		public abstract interface Predicate {

telephony/java/android/telephony/ThirdPartyCallListener.java

deleted100644 → 0

+0 −82

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.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. TODO: rename this to DisconnectCause once they are public.
		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;
		}

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

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

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

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

telephony/java/android/telephony/ThirdPartyCallProvider.java

deleted100644 → 0

+0 −107

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;

		/**
		* 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) {
		// default implementation empty
		}

		IThirdPartyCallProvider getCallback() {
		return mCallback;
		}

		private final IThirdPartyCallProvider mCallback = 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) {
		Message.obtain(mHandler, MSG_SEND_DTMF, (int) c, 0).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:
		sendDtmf((char) msg.arg1);
		break;
		}
		}
		};
		}

telephony/java/android/telephony/ThirdPartyCallService.java

deleted100644 → 0

+0 −94

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.IBinder;
		import android.os.Message;
		import android.util.Pair;

		import com.android.internal.telephony.IThirdPartyCallListener;
		import com.android.internal.telephony.IThirdPartyCallService;

		/**
		* Interface provided by a service to start outgoing calls and attach to incoming calls.
		*/
		public class ThirdPartyCallService {
		private static final int MSG_OUTGOING_CALL_INITIATE = 1;
		private static final int MSG_INCOMING_CALL_ATTACH = 2;

		/**
		* Call to start a new outgoing call.
		*/
		public void outgoingCallInitiate(ThirdPartyCallListener listener, String number) {
		// default implementation empty
		}

		/**
		* Call to attach to an incoming call.
		*/
		public void incomingCallAttach(ThirdPartyCallListener listener, String callId) {
		// default implementation empty
		}

		/**
		* Returns an IBinder instance that can returned from the service's onBind function.
		*/
		public IBinder getBinder() {
		return mCallback;
		}

		private final IThirdPartyCallService.Stub mCallback = new IThirdPartyCallService.Stub() {
		@Override
		public void outgoingCallInitiate(IThirdPartyCallListener listener, String number) {
		Rlog.w("ThirdPartyPhone", "ThirdPartyCallService.IThirdPartyCallService.out");
		Message.obtain(mHandler, MSG_OUTGOING_CALL_INITIATE,
		Pair.create(listener, number)).sendToTarget();
		}

		@Override
		public void incomingCallAttach(IThirdPartyCallListener listener, String callId) {
		Rlog.w("ThirdPartyPhone", "ThirdPartyCallService.IThirdPartyCallService.in");
		Message.obtain(mHandler, MSG_INCOMING_CALL_ATTACH,
		Pair.create(listener, callId)).sendToTarget();
		}
		};

		private final Handler mHandler = new Handler() {
		public void handleMessage(Message msg) {
		Rlog.w("ThirdPartyPhone", "ThirdPartyCallService.handleMessage: " + msg.what);
		switch (msg.what) {
		case MSG_OUTGOING_CALL_INITIATE: {
		Rlog.w("ThirdPartyPhone", "ThirdPartyCallService.handleMessage out");
		Pair<IThirdPartyCallListener, String> pair =
		(Pair<IThirdPartyCallListener, String>) msg.obj;
		ThirdPartyCallListener listener = new ThirdPartyCallListener(pair.first);
		outgoingCallInitiate(listener, pair.second);
		break;
		}
		case MSG_INCOMING_CALL_ATTACH: {
		Rlog.w("ThirdPartyPhone", "ThirdPartyCallService.handleMessage in");
		Pair<IThirdPartyCallListener, String> pair =
		(Pair<IThirdPartyCallListener, String>) msg.obj;
		ThirdPartyCallListener listener = new ThirdPartyCallListener(pair.first);
		incomingCallAttach(listener, pair.second);
		break;
		}
		}
		}
		};
		}