Merge "Adds @hide ImsService APIs" (2b879016) · Commits · e / os / android_frameworks_base

Android.mk

+1 −0

Original line number	Original line	Diff line number	Diff line
	@@ -435,6 +435,7 @@ LOCAL_SRC_FILES += \
	telephony/java/com/android/ims/internal/IImsEcbm.aidl \		telephony/java/com/android/ims/internal/IImsEcbm.aidl \
	telephony/java/com/android/ims/internal/IImsEcbmListener.aidl \		telephony/java/com/android/ims/internal/IImsEcbmListener.aidl \
	telephony/java/com/android/ims/internal/IImsExternalCallStateListener.aidl \		telephony/java/com/android/ims/internal/IImsExternalCallStateListener.aidl \
			telephony/java/com/android/ims/internal/IImsFeatureStatusCallback.aidl \
	telephony/java/com/android/ims/internal/IImsMultiEndpoint.aidl \		telephony/java/com/android/ims/internal/IImsMultiEndpoint.aidl \
	telephony/java/com/android/ims/internal/IImsService.aidl \		telephony/java/com/android/ims/internal/IImsService.aidl \
	telephony/java/com/android/ims/internal/IImsServiceController.aidl \		telephony/java/com/android/ims/internal/IImsServiceController.aidl \

telephony/java/android/telephony/ims/ImsService.java

0 → 100644

+430 −0

Original line number	Original line	Diff line number	Diff line
			/*
			* Copyright (C) 2017 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.ims;

			import android.app.PendingIntent;
			import android.content.Intent;
			import android.os.IBinder;
			import android.os.Message;
			import android.os.RemoteException;
			import android.telephony.CarrierConfigManager;
			import android.telephony.ims.feature.ImsFeature;
			import android.telephony.ims.feature.MMTelFeature;
			import android.telephony.ims.feature.RcsFeature;
			import android.util.Log;
			import android.util.SparseArray;

			import com.android.ims.ImsCallProfile;
			import com.android.ims.internal.IImsCallSession;
			import com.android.ims.internal.IImsCallSessionListener;
			import com.android.ims.internal.IImsConfig;
			import com.android.ims.internal.IImsEcbm;
			import com.android.ims.internal.IImsFeatureStatusCallback;
			import com.android.ims.internal.IImsMultiEndpoint;
			import com.android.ims.internal.IImsRegistrationListener;
			import com.android.ims.internal.IImsServiceController;
			import com.android.ims.internal.IImsServiceFeatureListener;
			import com.android.ims.internal.IImsUt;
			import com.android.internal.annotations.VisibleForTesting;

			/**
			* Main ImsService implementation, which binds via the Telephony ImsResolver. Services that extend
			* ImsService must register the service in their AndroidManifest to be detected by the framework.
			* First, the application must declare that they use the "android.permission.BIND_IMS_SERVICE"
			* permission. Then, the ImsService definition in the manifest must follow the following format:
			*
			* ...
			* <service android:name=".EgImsService"
			* android:permission="android.permission.BIND_IMS_SERVICE" >
			* <!-- Apps must declare which features they support as metadata. The different categories are
			* defined below. In this example, the RCS_FEATURE feature is supported. -->
			* <meta-data android:name="android.telephony.ims.RCS_FEATURE" android:value="true" />
			* <intent-filter>
			* <action android:name="android.telephony.ims.ImsService" />
			* </intent-filter>
			* </service>
			* ...
			*
			* The telephony framework will then bind to the ImsService you have defined in your manifest
			* if you are either:
			* 1) Defined as the default ImsService for the device in the device overlay using
			* "config_ims_package".
			* 2) Defined as a Carrier Provided ImsService in the Carrier Configuration using
			* {@link CarrierConfigManager#KEY_CONFIG_IMS_PACKAGE_OVERRIDE_STRING}.
			*
			* The features that are currently supported in an ImsService are:
			* - RCS_FEATURE: This ImsService implements the {@link RcsFeature} class.
			* - MMTEL_FEATURE: This ImsService implements the {@link MMTelFeature} class.
			* - EMERGENCY_MMTEL_FEATURE: This ImsService implements the {@link MMTelFeature} class and will be
			* available to place emergency calls at all times. This MUST be implemented by the default
			* ImsService provided in the device overlay.
			*
			* @hide
			*/
			public abstract class ImsService extends ImsServiceBase {

			private static final String LOG_TAG = "ImsService";

			/**
			* The intent that must be defined as an intent-filter in the AndroidManifest of the ImsService.
			*/
			public static final String SERVICE_INTERFACE = "android.telephony.ims.ImsService";

			// A map of slot Id -> Set of features corresponding to that slot.
			private final SparseArray<SparseArray<ImsFeature>> mFeatures = new SparseArray<>();

			// Implements all supported features as a flat interface.
			protected final IBinder mImsServiceController = new IImsServiceController.Stub() {

			@Override
			public void createImsFeature(int slotId, int feature, IImsFeatureStatusCallback c)
			throws RemoteException {
			synchronized (mFeatures) {
			onCreateImsFeatureInternal(slotId, feature, c);
			}
			}

			@Override
			public void removeImsFeature(int slotId, int feature) throws RemoteException {
			synchronized (mFeatures) {
			onRemoveImsFeatureInternal(slotId, feature);
			}
			}

			@Override
			public int startSession(int slotId, int featureType, PendingIntent incomingCallIntent,
			IImsRegistrationListener listener) throws RemoteException {
			synchronized (mFeatures) {
			MMTelFeature feature = resolveMMTelFeature(slotId, featureType);
			if (feature != null) {
			return feature.startSession(incomingCallIntent, listener);
			}
			}
			return 0;
			}

			@Override
			public void endSession(int slotId, int featureType, int sessionId) throws RemoteException {
			synchronized (mFeatures) {
			MMTelFeature feature = resolveMMTelFeature(slotId, featureType);
			if (feature != null) {
			feature.endSession(sessionId);
			}
			}
			}

			@Override
			public boolean isConnected(int slotId, int featureType, int sessionId, int callSessionType,
			int callType) throws RemoteException {
			synchronized (mFeatures) {
			MMTelFeature feature = resolveMMTelFeature(slotId, featureType);
			if (feature != null) {
			return feature.isConnected(sessionId, callSessionType, callType);
			}
			}
			return false;
			}

			@Override
			public boolean isOpened(int slotId, int featureType, int sessionId) throws RemoteException {
			synchronized (mFeatures) {
			MMTelFeature feature = resolveMMTelFeature(slotId, featureType);
			if (feature != null) {
			return feature.isOpened(sessionId);
			}
			}
			return false;
			}

			@Override
			public int getFeatureStatus(int slotId, int featureType) throws RemoteException {
			int status = ImsFeature.STATE_NOT_AVAILABLE;
			synchronized (mFeatures) {
			SparseArray<ImsFeature> featureMap = mFeatures.get(slotId);
			if (featureMap != null) {
			ImsFeature feature = getImsFeatureFromType(featureMap, featureType);
			if (feature != null) {
			status = feature.getFeatureState();
			}
			}
			}
			return status;
			}

			@Override
			public void addRegistrationListener(int slotId, int featureType, int sessionId,
			IImsRegistrationListener listener) throws RemoteException {
			synchronized (mFeatures) {
			MMTelFeature feature = resolveMMTelFeature(slotId, featureType);
			if (feature != null) {
			feature.addRegistrationListener(sessionId, listener);
			}
			}
			}

			@Override
			public void removeRegistrationListener(int slotId, int featureType, int sessionId,
			IImsRegistrationListener listener) throws RemoteException {
			synchronized (mFeatures) {
			MMTelFeature feature = resolveMMTelFeature(slotId, featureType);
			if (feature != null) {
			feature.removeRegistrationListener(sessionId, listener);
			}
			}
			}

			@Override
			public ImsCallProfile createCallProfile(int slotId, int featureType, int sessionId,
			int callSessionType, int callType) throws RemoteException {
			synchronized (mFeatures) {
			MMTelFeature feature = resolveMMTelFeature(slotId, featureType);
			if (feature != null) {
			return feature.createCallProfile(sessionId, callSessionType, callType);
			}
			}
			return null;
			}

			@Override
			public IImsCallSession createCallSession(int slotId, int featureType, int sessionId,
			ImsCallProfile profile, IImsCallSessionListener listener) throws RemoteException {
			synchronized (mFeatures) {
			MMTelFeature feature = resolveMMTelFeature(slotId, featureType);
			if (feature != null) {
			return feature.createCallSession(sessionId, profile, listener);
			}
			}
			return null;
			}

			@Override
			public IImsCallSession getPendingCallSession(int slotId, int featureType, int sessionId,
			String callId) throws RemoteException {
			synchronized (mFeatures) {
			MMTelFeature feature = resolveMMTelFeature(slotId, featureType);
			if (feature != null) {
			return feature.getPendingCallSession(sessionId, callId);
			}
			}
			return null;
			}

			@Override
			public IImsUt getUtInterface(int slotId, int featureType, int sessionId)
			throws RemoteException {
			synchronized (mFeatures) {
			MMTelFeature feature = resolveMMTelFeature(slotId, featureType);
			if (feature != null) {
			return feature.getUtInterface(sessionId);
			}
			}
			return null;
			}

			@Override
			public IImsConfig getConfigInterface(int slotId, int featureType, int sessionId)
			throws RemoteException {
			synchronized (mFeatures) {
			MMTelFeature feature = resolveMMTelFeature(slotId, featureType);
			if (feature != null) {
			return feature.getConfigInterface(sessionId);
			}
			}
			return null;
			}

			@Override
			public void turnOnIms(int slotId, int featureType, int sessionId) throws RemoteException {
			synchronized (mFeatures) {
			MMTelFeature feature = resolveMMTelFeature(slotId, featureType);
			if (feature != null) {
			feature.turnOnIms(sessionId);
			}
			}
			}

			@Override
			public void turnOffIms(int slotId, int featureType, int sessionId) throws RemoteException {
			synchronized (mFeatures) {
			MMTelFeature feature = resolveMMTelFeature(slotId, featureType);
			if (feature != null) {
			feature.turnOffIms(sessionId);
			}
			}
			}

			@Override
			public IImsEcbm getEcbmInterface(int slotId, int featureType, int sessionId)
			throws RemoteException {
			synchronized (mFeatures) {
			MMTelFeature feature = resolveMMTelFeature(slotId, featureType);
			if (feature != null) {
			return feature.getEcbmInterface(sessionId);
			}
			}
			return null;
			}

			@Override
			public void setUiTTYMode(int slotId, int featureType, int sessionId, int uiTtyMode,
			Message onComplete) throws RemoteException {
			synchronized (mFeatures) {
			MMTelFeature feature = resolveMMTelFeature(slotId, featureType);
			if (feature != null) {
			feature.setUiTTYMode(sessionId, uiTtyMode, onComplete);
			}
			}
			}

			@Override
			public IImsMultiEndpoint getMultiEndpointInterface(int slotId, int featureType,
			int sessionId) throws RemoteException {
			synchronized (mFeatures) {
			MMTelFeature feature = resolveMMTelFeature(slotId, featureType);
			if (feature != null) {
			return feature.getMultiEndpointInterface(sessionId);
			}
			}
			return null;
			}

			};

			@Override
			public IBinder onBind(Intent intent) {
			if(SERVICE_INTERFACE.equals(intent.getAction())) {
			return mImsServiceController;
			}
			return null;
			}

			/**
			* Called from the ImsResolver to create the requested ImsFeature, as defined by the slot and
			* featureType
			* @param slotId An integer representing which SIM slot the ImsFeature is assigned to.
			* @param featureType An integer representing the type of ImsFeature being created. This is
			* defined in {@link ImsFeature}.
			*/
			// Be sure to lock on mFeatures before accessing this method
			private void onCreateImsFeatureInternal(int slotId, int featureType,
			IImsFeatureStatusCallback c) {
			SparseArray<ImsFeature> featureMap = mFeatures.get(slotId);
			if (featureMap == null) {
			featureMap = new SparseArray<>();
			mFeatures.put(slotId, featureMap);
			}
			ImsFeature f = makeImsFeature(slotId, featureType);
			if (f != null) {
			f.setImsFeatureStatusCallback(c);
			featureMap.put(featureType, f);
			}

			}
			/**
			* Called from the ImsResolver to remove an existing ImsFeature, as defined by the slot and
			* featureType.
			* @param slotId An integer representing which SIM slot the ImsFeature is assigned to.
			* @param featureType An integer representing the type of ImsFeature being removed. This is
			* defined in {@link ImsFeature}.
			*/
			// Be sure to lock on mFeatures before accessing this method
			private void onRemoveImsFeatureInternal(int slotId, int featureType) {
			SparseArray<ImsFeature> featureMap = mFeatures.get(slotId);
			if (featureMap == null) {
			return;
			}

			ImsFeature featureToRemove = getImsFeatureFromType(featureMap, featureType);
			if (featureToRemove != null) {
			featureMap.remove(featureType);
			featureToRemove.notifyFeatureRemoved(slotId);
			// Remove reference to Binder
			featureToRemove.setImsFeatureStatusCallback(null);
			}
			}

			// Be sure to lock on mFeatures before accessing this method
			private MMTelFeature resolveMMTelFeature(int slotId, int featureType) {
			SparseArray<ImsFeature> features = getImsFeatureMap(slotId);
			MMTelFeature feature = null;
			if (features != null) {
			feature = resolveImsFeature(features, featureType, MMTelFeature.class);
			}
			return feature;
			}

			// Be sure to lock on mFeatures before accessing this method
			private <T extends ImsFeature> T resolveImsFeature(SparseArray<ImsFeature> set, int featureType,
			Class<T> className) {
			ImsFeature feature = getImsFeatureFromType(set, featureType);
			if (feature == null) {
			return null;
			}
			try {
			return className.cast(feature);
			} catch (ClassCastException e)
			{
			Log.e(LOG_TAG, "Can not cast ImsFeature! Exception: " + e.getMessage());
			}
			return null;
			}

			@VisibleForTesting
			// Be sure to lock on mFeatures before accessing this method
			public SparseArray<ImsFeature> getImsFeatureMap(int slotId) {
			return mFeatures.get(slotId);
			}

			@VisibleForTesting
			// Be sure to lock on mFeatures before accessing this method
			public ImsFeature getImsFeatureFromType(SparseArray<ImsFeature> set, int featureType) {
			return set.get(featureType);
			}

			private ImsFeature makeImsFeature(int slotId, int feature) {
			switch (feature) {
			case ImsFeature.EMERGENCY_MMTEL: {
			return onCreateEmergencyMMTelImsFeature(slotId);
			}
			case ImsFeature.MMTEL: {
			return onCreateMMTelImsFeature(slotId);
			}
			case ImsFeature.RCS: {
			return onCreateRcsFeature(slotId);
			}
			}
			// Tried to create feature that is not defined.
			return null;
			}

			/**
			* @return An implementation of MMTelFeature that will be used by the system for MMTel
			* functionality. Must be able to handle emergency calls at any time as well.
			*/
			public abstract MMTelFeature onCreateEmergencyMMTelImsFeature(int slotId);

			/**
			* @return An implementation of MMTelFeature that will be used by the system for MMTel
			* functionality.
			*/
			public abstract MMTelFeature onCreateMMTelImsFeature(int slotId);

			/**
			* @return An implementation of RcsFeature that will be used by the system for RCS.
			*/
			public abstract RcsFeature onCreateRcsFeature(int slotId);
			}

telephony/java/android/telephony/ims/ImsServiceBase.java

+3 −1

Original line number	Original line	Diff line number	Diff line
	@@ -22,7 +22,9 @@ import android.content.Intent;
	import android.os.IBinder;		import android.os.IBinder;

	/**		/**
	* Base ImsService Implementation, which is used by the ImsResolver to bind.		* Base ImsService Implementation, which is used by the ImsResolver to bind. ImsServices that do not
			* need to provide an ImsService implementation but still wish to be managed by the ImsResolver
			* lifecycle may implement this class directly.
	* @hide		* @hide
	*/		*/
	@SystemApi		@SystemApi

telephony/java/android/telephony/ims/ImsServiceProxy.java

0 → 100644

+316 −0

File added.

Preview size limit exceeded, changes collapsed.

telephony/java/android/telephony/ims/ImsServiceProxyCompat.java

0 → 100644

+182 −0

Original line number	Original line	Diff line number	Diff line
			/*
			* Copyright (C) 2017 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.ims;

			import android.app.PendingIntent;
			import android.os.IBinder;
			import android.os.Message;
			import android.os.RemoteException;
			import android.telephony.ims.feature.IMMTelFeature;
			import android.telephony.ims.feature.ImsFeature;

			import com.android.ims.ImsCallProfile;
			import com.android.ims.internal.IImsCallSession;
			import com.android.ims.internal.IImsCallSessionListener;
			import com.android.ims.internal.IImsConfig;
			import com.android.ims.internal.IImsEcbm;
			import com.android.ims.internal.IImsMultiEndpoint;
			import com.android.ims.internal.IImsRegistrationListener;
			import com.android.ims.internal.IImsService;
			import com.android.ims.internal.IImsUt;

			/**
			* Compatibility class that implements the new ImsService IMMTelFeature interface, but
			* uses the old IImsService interface to support older devices that implement the deprecated
			* opt/net/ims interface.
			* @hide
			*/

			public class ImsServiceProxyCompat implements IMMTelFeature {

			protected final int mSlotId;
			protected IBinder mBinder;

			public ImsServiceProxyCompat(int slotId, IBinder binder) {
			mSlotId = slotId;
			mBinder = binder;
			}

			@Override
			public int startSession(PendingIntent incomingCallIntent, IImsRegistrationListener listener)
			throws RemoteException {
			checkBinderConnection();
			return getServiceInterface(mBinder).open(mSlotId, ImsFeature.MMTEL, incomingCallIntent,
			listener);
			}

			@Override
			public void endSession(int sessionId) throws RemoteException {
			checkBinderConnection();
			getServiceInterface(mBinder).close(sessionId);
			}

			@Override
			public boolean isConnected(int sessionId, int callServiceType, int callType)
			throws RemoteException {
			checkBinderConnection();
			return getServiceInterface(mBinder).isConnected(sessionId, callServiceType, callType);
			}

			@Override
			public boolean isOpened(int sessionId) throws RemoteException {
			checkBinderConnection();
			return getServiceInterface(mBinder).isOpened(sessionId);
			}

			@Override
			public void addRegistrationListener(int sessionId, IImsRegistrationListener listener)
			throws RemoteException {
			checkBinderConnection();
			getServiceInterface(mBinder).addRegistrationListener(mSlotId, ImsFeature.MMTEL, listener);
			}

			@Override
			public void removeRegistrationListener(int sessionId, IImsRegistrationListener listener)
			throws RemoteException {
			checkBinderConnection();
			// Not Implemented in old ImsService. If the registration listener becomes invalid, the
			// ImsService will remove.
			}

			@Override
			public ImsCallProfile createCallProfile(int sessionId, int callServiceType, int callType)
			throws RemoteException {
			checkBinderConnection();
			return getServiceInterface(mBinder).createCallProfile(sessionId, callServiceType, callType);
			}

			@Override
			public IImsCallSession createCallSession(int sessionId, ImsCallProfile profile,
			IImsCallSessionListener listener) throws RemoteException {
			checkBinderConnection();
			return getServiceInterface(mBinder).createCallSession(sessionId, profile, listener);
			}

			@Override
			public IImsCallSession getPendingCallSession(int sessionId, String callId)
			throws RemoteException {
			checkBinderConnection();
			return getServiceInterface(mBinder).getPendingCallSession(sessionId, callId);
			}

			@Override
			public IImsUt getUtInterface(int sessionId) throws RemoteException {
			checkBinderConnection();
			return getServiceInterface(mBinder).getUtInterface(sessionId);
			}

			@Override
			public IImsConfig getConfigInterface(int sessionId) throws RemoteException {
			checkBinderConnection();
			return getServiceInterface(mBinder).getConfigInterface(mSlotId);
			}

			@Override
			public void turnOnIms(int sessionId) throws RemoteException {
			checkBinderConnection();
			getServiceInterface(mBinder).turnOnIms(mSlotId);
			}

			@Override
			public void turnOffIms(int sessionId) throws RemoteException {
			checkBinderConnection();
			getServiceInterface(mBinder).turnOffIms(mSlotId);
			}

			@Override
			public IImsEcbm getEcbmInterface(int sessionId) throws RemoteException {
			checkBinderConnection();
			return getServiceInterface(mBinder).getEcbmInterface(sessionId);
			}

			@Override
			public void setUiTTYMode(int sessionId, int uiTtyMode, Message onComplete)
			throws RemoteException {
			checkBinderConnection();
			getServiceInterface(mBinder).setUiTTYMode(sessionId, uiTtyMode, onComplete);
			}

			@Override
			public IImsMultiEndpoint getMultiEndpointInterface(int sessionId) throws RemoteException {
			checkBinderConnection();
			return getServiceInterface(mBinder).getMultiEndpointInterface(sessionId);
			}

			/**
			* Base implementation, always returns READY for compatibility with old ImsService.
			*/
			public int getFeatureStatus() {
			return ImsFeature.STATE_READY;
			}

			/**
			* @return false if the binder connection is no longer alive.
			*/
			public boolean isBinderAlive() {
			return mBinder != null && mBinder.isBinderAlive();
			}

			private IImsService getServiceInterface(IBinder b) {
			return IImsService.Stub.asInterface(b);
			}

			protected void checkBinderConnection() throws RemoteException {
			if (!isBinderAlive()) {
			throw new RemoteException("ImsServiceProxy is not available for that feature.");
			}
			}
			}