Move ImsServiceProxy to opt/net/ims (8f291b18) · Commits · e / os / android_frameworks_base

config/compiled-classes-phone

+0 −2

Original line number	Diff line number	Diff line
		@@ -3948,8 +3948,6 @@ android.telephony.VisualVoicemailSmsFilterSettings
		android.telephony.VoLteServiceState
		android.telephony.VoLteServiceState$1
		android.telephony.gsm.GsmCellLocation
		android.telephony.ims.ImsServiceProxy$INotifyStatusChanged
		android.telephony.ims.ImsServiceProxyCompat
		android.telephony.ims.feature.IMMTelFeature
		android.telephony.ims.stub.ImsConfigImplBase
		android.telephony.ims.stub.ImsEcbmImplBase

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

deleted100644 → 0

+0 −349

Original line number	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.IRcsFeature;
		import android.telephony.ims.feature.ImsFeature;
		import android.util.Log;

		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.IImsServiceController;
		import com.android.ims.internal.IImsServiceFeatureListener;
		import com.android.ims.internal.IImsUt;

		/**
		* A container of the IImsServiceController binder, which implements all of the ImsFeatures that
		* the platform currently supports: MMTel and RCS.
		* @hide
		*/

		public class ImsServiceProxy implements IMMTelFeature, IRcsFeature {

		protected String LOG_TAG = "ImsServiceProxy";
		protected final int mSlotId;
		protected IBinder mBinder;
		private final int mSupportedFeature;

		// Start by assuming the proxy is available for usage.
		private boolean mIsAvailable = true;
		// ImsFeature Status from the ImsService. Cached.
		private Integer mFeatureStatusCached = null;
		private ImsServiceProxy.INotifyStatusChanged mStatusCallback;
		private final Object mLock = new Object();

		public interface INotifyStatusChanged {
		void notifyStatusChanged();
		}

		private final IImsServiceFeatureListener mListenerBinder =
		new IImsServiceFeatureListener.Stub() {

		@Override
		public void imsFeatureCreated(int slotId, int feature) throws RemoteException {
		// The feature has been re-enabled. This may happen when the service crashes.
		synchronized (mLock) {
		if (!mIsAvailable && mSlotId == slotId && feature == mSupportedFeature) {
		Log.i(LOG_TAG, "Feature enabled on slotId: " + slotId + " for feature: " +
		feature);
		mIsAvailable = true;
		}
		}
		}

		@Override
		public void imsFeatureRemoved(int slotId, int feature) throws RemoteException {
		synchronized (mLock) {
		if (mIsAvailable && mSlotId == slotId && feature == mSupportedFeature) {
		Log.i(LOG_TAG, "Feature disabled on slotId: " + slotId + " for feature: " +
		feature);
		mIsAvailable = false;
		}
		}
		}

		@Override
		public void imsStatusChanged(int slotId, int feature, int status) throws RemoteException {
		synchronized (mLock) {
		Log.i(LOG_TAG, "imsStatusChanged: slot: " + slotId + " feature: " + feature +
		" status: " + status);
		if (mSlotId == slotId && feature == mSupportedFeature) {
		mFeatureStatusCached = status;
		if (mStatusCallback != null) {
		mStatusCallback.notifyStatusChanged();
		}
		}
		}
		}
		};

		public ImsServiceProxy(int slotId, IBinder binder, int featureType) {
		mSlotId = slotId;
		mBinder = binder;
		mSupportedFeature = featureType;
		}

		public ImsServiceProxy(int slotId, int featureType) {
		this(slotId, null, featureType);
		}

		public IImsServiceFeatureListener getListener() {
		return mListenerBinder;
		}

		public void setBinder(IBinder binder) {
		mBinder = binder;
		}

		@Override
		public int startSession(PendingIntent incomingCallIntent, IImsRegistrationListener listener)
		throws RemoteException {
		synchronized (mLock) {
		checkServiceIsReady();
		return getServiceInterface(mBinder).startSession(mSlotId, mSupportedFeature,
		incomingCallIntent, listener);
		}
		}

		@Override
		public void endSession(int sessionId) throws RemoteException {
		synchronized (mLock) {
		// Only check to make sure the binder connection still exists. This method should
		// still be able to be called when the state is STATE_NOT_AVAILABLE.
		checkBinderConnection();
		getServiceInterface(mBinder).endSession(mSlotId, mSupportedFeature, sessionId);
		}
		}

		@Override
		public boolean isConnected(int callServiceType, int callType)
		throws RemoteException {
		synchronized (mLock) {
		checkServiceIsReady();
		return getServiceInterface(mBinder).isConnected(mSlotId, mSupportedFeature,
		callServiceType, callType);
		}
		}

		@Override
		public boolean isOpened() throws RemoteException {
		synchronized (mLock) {
		checkServiceIsReady();
		return getServiceInterface(mBinder).isOpened(mSlotId, mSupportedFeature);
		}
		}

		@Override
		public void addRegistrationListener(IImsRegistrationListener listener)
		throws RemoteException {
		synchronized (mLock) {
		checkServiceIsReady();
		getServiceInterface(mBinder).addRegistrationListener(mSlotId, mSupportedFeature,
		listener);
		}
		}

		@Override
		public void removeRegistrationListener(IImsRegistrationListener listener)
		throws RemoteException {
		synchronized (mLock) {
		checkServiceIsReady();
		getServiceInterface(mBinder).removeRegistrationListener(mSlotId, mSupportedFeature,
		listener);
		}
		}

		@Override
		public ImsCallProfile createCallProfile(int sessionId, int callServiceType, int callType)
		throws RemoteException {
		synchronized (mLock) {
		checkServiceIsReady();
		return getServiceInterface(mBinder).createCallProfile(mSlotId, mSupportedFeature,
		sessionId, callServiceType, callType);
		}
		}

		@Override
		public IImsCallSession createCallSession(int sessionId, ImsCallProfile profile,
		IImsCallSessionListener listener) throws RemoteException {
		synchronized (mLock) {
		checkServiceIsReady();
		return getServiceInterface(mBinder).createCallSession(mSlotId, mSupportedFeature,
		sessionId, profile, listener);
		}
		}

		@Override
		public IImsCallSession getPendingCallSession(int sessionId, String callId)
		throws RemoteException {
		synchronized (mLock) {
		checkServiceIsReady();
		return getServiceInterface(mBinder).getPendingCallSession(mSlotId, mSupportedFeature,
		sessionId, callId);
		}
		}

		@Override
		public IImsUt getUtInterface() throws RemoteException {
		synchronized (mLock) {
		checkServiceIsReady();
		return getServiceInterface(mBinder).getUtInterface(mSlotId, mSupportedFeature);
		}
		}

		@Override
		public IImsConfig getConfigInterface() throws RemoteException {
		synchronized (mLock) {
		checkServiceIsReady();
		return getServiceInterface(mBinder).getConfigInterface(mSlotId, mSupportedFeature);
		}
		}

		@Override
		public void turnOnIms() throws RemoteException {
		synchronized (mLock) {
		checkServiceIsReady();
		getServiceInterface(mBinder).turnOnIms(mSlotId, mSupportedFeature);
		}
		}

		@Override
		public void turnOffIms() throws RemoteException {
		synchronized (mLock) {
		checkServiceIsReady();
		getServiceInterface(mBinder).turnOffIms(mSlotId, mSupportedFeature);
		}
		}

		@Override
		public IImsEcbm getEcbmInterface() throws RemoteException {
		synchronized (mLock) {
		checkServiceIsReady();
		return getServiceInterface(mBinder).getEcbmInterface(mSlotId, mSupportedFeature);
		}
		}

		@Override
		public void setUiTTYMode(int uiTtyMode, Message onComplete)
		throws RemoteException {
		synchronized (mLock) {
		checkServiceIsReady();
		getServiceInterface(mBinder).setUiTTYMode(mSlotId, mSupportedFeature, uiTtyMode,
		onComplete);
		}
		}

		@Override
		public IImsMultiEndpoint getMultiEndpointInterface() throws RemoteException {
		synchronized (mLock) {
		checkServiceIsReady();
		return getServiceInterface(mBinder).getMultiEndpointInterface(mSlotId,
		mSupportedFeature);
		}
		}

		/**
		* @return an integer describing the current Feature Status, defined in
		* {@link ImsFeature.ImsState}.
		*/
		public int getFeatureStatus() {
		synchronized (mLock) {
		if (isBinderAlive() && mFeatureStatusCached != null) {
		Log.i(LOG_TAG, "getFeatureStatus - returning cached: " + mFeatureStatusCached);
		return mFeatureStatusCached;
		}
		}
		// Don't synchronize on Binder call.
		Integer status = retrieveFeatureStatus();
		synchronized (mLock) {
		if (status == null) {
		return ImsFeature.STATE_NOT_AVAILABLE;
		}
		// Cache only non-null value for feature status.
		mFeatureStatusCached = status;
		}
		Log.i(LOG_TAG, "getFeatureStatus - returning " + status);
		return status;
		}

		/**
		* Internal method used to retrieve the feature status from the corresponding ImsService.
		*/
		private Integer retrieveFeatureStatus() {
		if (mBinder != null) {
		try {
		return getServiceInterface(mBinder).getFeatureStatus(mSlotId, mSupportedFeature);
		} catch (RemoteException e) {
		// Status check failed, don't update cache
		}
		}
		return null;
		}

		/**
		* @param c Callback that will fire when the feature status has changed.
		*/
		public void setStatusCallback(INotifyStatusChanged c) {
		mStatusCallback = c;
		}

		/**
		* @return Returns true if the ImsService is ready to take commands, false otherwise. If this
		* method returns false, it doesn't mean that the Binder connection is not available (use
		* {@link #isBinderReady()} to check that), but that the ImsService is not accepting commands
		* at this time.
		*
		* For example, for DSDS devices, only one slot can be {@link ImsFeature#STATE_READY} to take
		* commands at a time, so the other slot must stay at {@link ImsFeature#STATE_NOT_AVAILABLE}.
		*/
		public boolean isBinderReady() {
		return isBinderAlive() && getFeatureStatus() == ImsFeature.STATE_READY;
		}

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

		protected void checkServiceIsReady() throws RemoteException {
		if (!isBinderReady()) {
		throw new RemoteException("ImsServiceProxy is not ready to accept commands.");
		}
		}

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

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

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

deleted100644 → 0

+0 −168

Original line number	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 extends ImsServiceProxy {

		private static final int SERVICE_ID = ImsFeature.MMTEL;

		public ImsServiceProxyCompat(int slotId, IBinder binder) {
		super(slotId, binder, SERVICE_ID);
		}

		@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 callServiceType, int callType)
		throws RemoteException {
		checkBinderConnection();
		return getServiceInterface(mBinder).isConnected(SERVICE_ID, callServiceType, callType);
		}

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

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

		@Override
		public void removeRegistrationListener(IImsRegistrationListener listener)
		throws RemoteException {
		// 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() throws RemoteException {
		checkBinderConnection();
		return getServiceInterface(mBinder).getUtInterface(SERVICE_ID);
		}

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

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

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

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

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

		@Override
		public IImsMultiEndpoint getMultiEndpointInterface() throws RemoteException {
		checkBinderConnection();
		return getServiceInterface(mBinder).getMultiEndpointInterface(SERVICE_ID);
		}
		@Override
		public int getFeatureStatus() {
		return ImsFeature.STATE_READY;
		}

		@Override
		public boolean isBinderAlive() {
		return mBinder != null && mBinder.isBinderAlive();
		}

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