src/java/com/android/ims/FeatureConnector.java - platform/frameworks/opt/net/ims - Git at Google

 /*
  * Copyright (c) 2019 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.ims;

 import android.annotation.IntDef;
 import android.content.Context;
 import android.content.pm.PackageManager;
 import android.os.RemoteException;
 import android.telephony.ims.ImsReasonInfo;
 import android.telephony.ims.ImsService;
 import android.telephony.ims.feature.ImsFeature;

 import com.android.ims.internal.IImsServiceFeatureCallback;
 import com.android.internal.annotations.VisibleForTesting;
 import com.android.telephony.Rlog;

 import java.lang.annotation.Retention;
 import java.lang.annotation.RetentionPolicy;
 import java.util.ArrayList;
 import java.util.List;
 import java.util.concurrent.Executor;

 /**
  * Helper class for managing a connection to the ImsFeature manager.
  */
 public class FeatureConnector<U extends FeatureUpdates> {
     private static final String TAG = "FeatureConnector";
     private static final boolean DBG = false;

     /**
      * This Connection has become unavailable due to the ImsService being disconnected due to
      * an event such as SIM Swap, carrier configuration change, etc...
      *
      * {@link Listener#connectionReady}  will be called when a new Manager is available.
      */
     public static final int UNAVAILABLE_REASON_DISCONNECTED = 0;

     /**
      * This Connection has become unavailable due to the ImsService moving to the NOT_READY state.
      *
      * {@link Listener#connectionReady}  will be called when the manager moves back to ready.
      */
     public static final int UNAVAILABLE_REASON_NOT_READY = 1;

     /**
      * IMS is not supported on this device. This should be considered a permanent error and
      * a Manager will never become available.
      */
     public static final int UNAVAILABLE_REASON_IMS_UNSUPPORTED = 2;

     /**
      * The server of this information has crashed or otherwise generated an error that will require
      * a retry to connect. This is rare, however in this case, {@link #disconnect()} and
      * {@link #connect()} will need to be called again to recreate the connection with the server.
      * <p>
      * Only applicable if this is used outside of the server's own process.
      */
     public static final int UNAVAILABLE_REASON_SERVER_UNAVAILABLE = 3;

     /**
      * @hide
      */
     @Retention(RetentionPolicy.SOURCE)
     @IntDef(prefix = "UNAVAILABLE_REASON_", value = {
             UNAVAILABLE_REASON_DISCONNECTED,
             UNAVAILABLE_REASON_NOT_READY,
             UNAVAILABLE_REASON_IMS_UNSUPPORTED,
             UNAVAILABLE_REASON_SERVER_UNAVAILABLE
     })
     public @interface UnavailableReason {}

     /**
      * Factory used to create a new instance of the manager that this FeatureConnector is waiting
      * to connect the FeatureConnection to.
      * @param <U> The Manager that this FeatureConnector has been created for.
      */
     public interface ManagerFactory<U extends FeatureUpdates> {
         /**
          * Create a manager instance, which will connect to the FeatureConnection.
          */
         U createManager(Context context, int phoneId);
     }

     /**
      * Listener interface used by Listeners of FeatureConnector that are waiting for a Manager
      * interface for a specific ImsFeature.
      * @param <U> The Manager that the listener is listening for.
      */
     public interface Listener<U extends FeatureUpdates> {
         /**
          * ImsFeature manager is connected to the underlying IMS implementation.
          */
         void connectionReady(U manager, int subId) throws ImsException;

         /**
          * The underlying IMS implementation is unavailable and can not be used to communicate.
          */
         void connectionUnavailable(@UnavailableReason int reason);
     }

     private final IImsServiceFeatureCallback mCallback = new IImsServiceFeatureCallback.Stub() {

         @Override
         public void imsFeatureCreated(ImsFeatureContainer c, int subId) {
             log("imsFeatureCreated: " + c + ", subId: " + subId);
             synchronized (mLock) {
                 mManager.associate(c, subId);
                 mManager.updateFeatureCapabilities(c.getCapabilities());
                 mDisconnectedReason = null;
             }
             // Notifies executor, so notify outside of lock
             imsStatusChanged(c.getState(), subId);
         }

         @Override
         public void imsFeatureRemoved(@UnavailableReason int reason) {
             log("imsFeatureRemoved: reason=" + reason);
             synchronized (mLock) {
                 // only generate new events if the disconnect event isn't the same as before, except
                 // for UNAVAILABLE_REASON_SERVER_UNAVAILABLE, which indicates a local issue and
                 // each event is actionable.
                 if (mDisconnectedReason != null
                         && (mDisconnectedReason == reason
                         && mDisconnectedReason != UNAVAILABLE_REASON_SERVER_UNAVAILABLE)) {
                     log("imsFeatureRemoved: ignore");
                     return;
                 }
                 mDisconnectedReason = reason;
                 // Ensure that we set ready state back to false so that we do not miss setting ready
                 // later if the initial state when recreated is READY.
                 mLastReadyState = false;
             }
             // Allow the listener to do cleanup while the connection still potentially valid (unless
             // the process crashed).
             mExecutor.execute(() -> mListener.connectionUnavailable(reason));
             mManager.invalidate();
         }

         @Override
         public void imsStatusChanged(int status, int subId) {
             log("imsStatusChanged: status=" + ImsFeature.STATE_LOG_MAP.get(status));
             final U manager;
             final boolean isReady;
             synchronized (mLock) {
                 if (mDisconnectedReason != null) {
                     log("imsStatusChanged: ignore");
                     return;
                 }
                 mManager.updateFeatureState(status);
                 manager = mManager;
                 isReady = mReadyFilter.contains(status);
                 boolean didReadyChange = isReady ^ mLastReadyState;
                 mLastReadyState = isReady;
                 if (!didReadyChange) {
                     log("imsStatusChanged: ready didn't change, ignore");
                     return;
                 }
             }
             mExecutor.execute(() -> {
                 try {
                     if (isReady) {
                         notifyReady(manager, subId);
                     } else {
                         notifyNotReady();
                     }
                 } catch (ImsException e) {
                     if (e.getCode()
                             == ImsReasonInfo.CODE_LOCAL_IMS_NOT_SUPPORTED_ON_DEVICE) {
                         mListener.connectionUnavailable(UNAVAILABLE_REASON_IMS_UNSUPPORTED);
                     } else {
                         notifyNotReady();
                     }
                 }
             });
         }

         @Override
         public void updateCapabilities(long caps) {
             log("updateCapabilities: capabilities=" + ImsService.getCapabilitiesString(caps));
             synchronized (mLock) {
                 if (mDisconnectedReason != null) {
                     log("updateCapabilities: ignore");
                     return;
                 }
                 mManager.updateFeatureCapabilities(caps);
             }
         }
     };

     private final int mPhoneId;
     private final Context mContext;
     private final ManagerFactory<U> mFactory;
     private final Listener<U> mListener;
     private final Executor mExecutor;
     private final Object mLock = new Object();
     private final String mLogPrefix;
     // A List of integers, each corresponding to an ImsFeature.ImsState, that the FeatureConnector
     // will use to call Listener#connectionReady when the ImsFeature that this connector is waiting
     // for changes into one of the states in this list.
     private final List<Integer> mReadyFilter = new ArrayList<>();

     private U mManager;
     // Start in disconnected state;
     private Integer mDisconnectedReason = UNAVAILABLE_REASON_DISCONNECTED;
     // Stop redundant connectionAvailable if the ready filter contains multiple states.
     // Also, do not send the first unavailable until after we have moved to available once.
     private boolean mLastReadyState = false;


     @VisibleForTesting
     public FeatureConnector(Context context, int phoneId, ManagerFactory<U> factory,
             String logPrefix, List<Integer> readyFilter, Listener<U> listener, Executor executor) {
         mContext = context;
         mPhoneId = phoneId;
         mFactory = factory;
         mLogPrefix = logPrefix;
         mReadyFilter.addAll(readyFilter);
         mListener = listener;
         mExecutor = executor;
     }

     /**
      * Start the creation of a connection to the underlying ImsService implementation. When the
      * service is connected, {@link FeatureConnector.Listener#connectionReady} will be
      * called with an active instance.
      *
      * If this device does not support an ImsStack (i.e. doesn't support
      * {@link PackageManager#FEATURE_TELEPHONY_IMS} feature), this method will do nothing.
      */
     public void connect() {
         if (DBG) log("connect");
         if (!isSupported()) {
             mExecutor.execute(() -> mListener.connectionUnavailable(
                     UNAVAILABLE_REASON_IMS_UNSUPPORTED));
             logw("connect: not supported.");
             return;
         }
         synchronized (mLock) {
             if (mManager == null) {
                 mManager = mFactory.createManager(mContext, mPhoneId);
             }
         }
         mManager.registerFeatureCallback(mPhoneId, mCallback);
     }

     // Check if this ImsFeature is supported or not.
     private boolean isSupported() {
         return mContext.getPackageManager().hasSystemFeature(PackageManager.FEATURE_TELEPHONY_IMS);
     }

     /**
      * Disconnect from the ImsService Implementation and clean up. When this is complete,
      * {@link FeatureConnector.Listener#connectionUnavailable(int)} will be called one last time.
      */
     public void disconnect() {
         if (DBG) log("disconnect");
         final U manager;
         synchronized (mLock) {
             manager = mManager;
         }
         if (manager == null) return;

         manager.unregisterFeatureCallback(mCallback);
         try {
             mCallback.imsFeatureRemoved(UNAVAILABLE_REASON_DISCONNECTED);
         } catch (RemoteException ignore) {} // local call
     }

     // Should be called on executor
     private void notifyReady(U manager, int subId) throws ImsException {
         try {
             if (DBG) log("notifyReady");
             mListener.connectionReady(manager, subId);
         }
         catch (ImsException e) {
             if(DBG) log("notifyReady exception: " + e.getMessage());
             throw e;
         }
     }

     // Should be called on executor.
     private void notifyNotReady() {
         if (DBG) log("notifyNotReady");
         mListener.connectionUnavailable(UNAVAILABLE_REASON_NOT_READY);
     }

     private void log(String message) {
         Rlog.d(TAG, "[" + mLogPrefix + ", " + mPhoneId + "] " + message);
     }

     private void logw(String message) {
         Rlog.w(TAG, "[" + mLogPrefix + ", " + mPhoneId + "] " + message);
     }
 }
	/*
	* Copyright (c) 2019 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.ims;

	import android.annotation.IntDef;
	import android.content.Context;
	import android.content.pm.PackageManager;
	import android.os.RemoteException;
	import android.telephony.ims.ImsReasonInfo;
	import android.telephony.ims.ImsService;
	import android.telephony.ims.feature.ImsFeature;

	import com.android.ims.internal.IImsServiceFeatureCallback;
	import com.android.internal.annotations.VisibleForTesting;
	import com.android.telephony.Rlog;

	import java.lang.annotation.Retention;
	import java.lang.annotation.RetentionPolicy;
	import java.util.ArrayList;
	import java.util.List;
	import java.util.concurrent.Executor;

	/**
	* Helper class for managing a connection to the ImsFeature manager.
	*/
	public class FeatureConnector<U extends FeatureUpdates> {
	private static final String TAG = "FeatureConnector";
	private static final boolean DBG = false;

	/**
	* This Connection has become unavailable due to the ImsService being disconnected due to
	* an event such as SIM Swap, carrier configuration change, etc...
	*
	* {@link Listener#connectionReady} will be called when a new Manager is available.
	*/
	public static final int UNAVAILABLE_REASON_DISCONNECTED = 0;

	/**
	* This Connection has become unavailable due to the ImsService moving to the NOT_READY state.
	*
	* {@link Listener#connectionReady} will be called when the manager moves back to ready.
	*/
	public static final int UNAVAILABLE_REASON_NOT_READY = 1;

	/**
	* IMS is not supported on this device. This should be considered a permanent error and
	* a Manager will never become available.
	*/
	public static final int UNAVAILABLE_REASON_IMS_UNSUPPORTED = 2;

	/**
	* The server of this information has crashed or otherwise generated an error that will require
	* a retry to connect. This is rare, however in this case, {@link #disconnect()} and
	* {@link #connect()} will need to be called again to recreate the connection with the server.
	* <p>
	* Only applicable if this is used outside of the server's own process.
	*/
	public static final int UNAVAILABLE_REASON_SERVER_UNAVAILABLE = 3;

	/**
	* @hide
	*/
	@Retention(RetentionPolicy.SOURCE)
	@IntDef(prefix = "UNAVAILABLE_REASON_", value = {
	UNAVAILABLE_REASON_DISCONNECTED,
	UNAVAILABLE_REASON_NOT_READY,
	UNAVAILABLE_REASON_IMS_UNSUPPORTED,
	UNAVAILABLE_REASON_SERVER_UNAVAILABLE
	})
	public @interface UnavailableReason {}

	/**
	* Factory used to create a new instance of the manager that this FeatureConnector is waiting
	* to connect the FeatureConnection to.
	* @param <U> The Manager that this FeatureConnector has been created for.
	*/
	public interface ManagerFactory<U extends FeatureUpdates> {
	/**
	* Create a manager instance, which will connect to the FeatureConnection.
	*/
	U createManager(Context context, int phoneId);
	}

	/**
	* Listener interface used by Listeners of FeatureConnector that are waiting for a Manager
	* interface for a specific ImsFeature.
	* @param <U> The Manager that the listener is listening for.
	*/
	public interface Listener<U extends FeatureUpdates> {
	/**
	* ImsFeature manager is connected to the underlying IMS implementation.
	*/
	void connectionReady(U manager, int subId) throws ImsException;

	/**
	* The underlying IMS implementation is unavailable and can not be used to communicate.
	*/
	void connectionUnavailable(@UnavailableReason int reason);
	}

	private final IImsServiceFeatureCallback mCallback = new IImsServiceFeatureCallback.Stub() {

	@Override
	public void imsFeatureCreated(ImsFeatureContainer c, int subId) {
	log("imsFeatureCreated: " + c + ", subId: " + subId);
	synchronized (mLock) {
	mManager.associate(c, subId);
	mManager.updateFeatureCapabilities(c.getCapabilities());
	mDisconnectedReason = null;
	}
	// Notifies executor, so notify outside of lock
	imsStatusChanged(c.getState(), subId);
	}

	@Override
	public void imsFeatureRemoved(@UnavailableReason int reason) {
	log("imsFeatureRemoved: reason=" + reason);
	synchronized (mLock) {
	// only generate new events if the disconnect event isn't the same as before, except
	// for UNAVAILABLE_REASON_SERVER_UNAVAILABLE, which indicates a local issue and
	// each event is actionable.
	if (mDisconnectedReason != null
	&& (mDisconnectedReason == reason
	&& mDisconnectedReason != UNAVAILABLE_REASON_SERVER_UNAVAILABLE)) {
	log("imsFeatureRemoved: ignore");
	return;
	}
	mDisconnectedReason = reason;
	// Ensure that we set ready state back to false so that we do not miss setting ready
	// later if the initial state when recreated is READY.
	mLastReadyState = false;
	}
	// Allow the listener to do cleanup while the connection still potentially valid (unless
	// the process crashed).
	mExecutor.execute(() -> mListener.connectionUnavailable(reason));
	mManager.invalidate();
	}

	@Override
	public void imsStatusChanged(int status, int subId) {
	log("imsStatusChanged: status=" + ImsFeature.STATE_LOG_MAP.get(status));
	final U manager;
	final boolean isReady;
	synchronized (mLock) {
	if (mDisconnectedReason != null) {
	log("imsStatusChanged: ignore");
	return;
	}
	mManager.updateFeatureState(status);
	manager = mManager;
	isReady = mReadyFilter.contains(status);
	boolean didReadyChange = isReady ^ mLastReadyState;
	mLastReadyState = isReady;
	if (!didReadyChange) {
	log("imsStatusChanged: ready didn't change, ignore");
	return;
	}
	}
	mExecutor.execute(() -> {
	try {
	if (isReady) {
	notifyReady(manager, subId);
	} else {
	notifyNotReady();
	}
	} catch (ImsException e) {
	if (e.getCode()
	== ImsReasonInfo.CODE_LOCAL_IMS_NOT_SUPPORTED_ON_DEVICE) {
	mListener.connectionUnavailable(UNAVAILABLE_REASON_IMS_UNSUPPORTED);
	} else {
	notifyNotReady();
	}
	}
	});
	}

	@Override
	public void updateCapabilities(long caps) {
	log("updateCapabilities: capabilities=" + ImsService.getCapabilitiesString(caps));
	synchronized (mLock) {
	if (mDisconnectedReason != null) {
	log("updateCapabilities: ignore");
	return;
	}
	mManager.updateFeatureCapabilities(caps);
	}
	}
	};

	private final int mPhoneId;
	private final Context mContext;
	private final ManagerFactory<U> mFactory;
	private final Listener<U> mListener;
	private final Executor mExecutor;
	private final Object mLock = new Object();
	private final String mLogPrefix;
	// A List of integers, each corresponding to an ImsFeature.ImsState, that the FeatureConnector
	// will use to call Listener#connectionReady when the ImsFeature that this connector is waiting
	// for changes into one of the states in this list.
	private final List<Integer> mReadyFilter = new ArrayList<>();

	private U mManager;
	// Start in disconnected state;
	private Integer mDisconnectedReason = UNAVAILABLE_REASON_DISCONNECTED;
	// Stop redundant connectionAvailable if the ready filter contains multiple states.
	// Also, do not send the first unavailable until after we have moved to available once.
	private boolean mLastReadyState = false;



	@VisibleForTesting
	public FeatureConnector(Context context, int phoneId, ManagerFactory<U> factory,
	String logPrefix, List<Integer> readyFilter, Listener<U> listener, Executor executor) {
	mContext = context;
	mPhoneId = phoneId;
	mFactory = factory;
	mLogPrefix = logPrefix;
	mReadyFilter.addAll(readyFilter);
	mListener = listener;
	mExecutor = executor;
	}

	/**
	* Start the creation of a connection to the underlying ImsService implementation. When the
	* service is connected, {@link FeatureConnector.Listener#connectionReady} will be
	* called with an active instance.
	*
	* If this device does not support an ImsStack (i.e. doesn't support
	* {@link PackageManager#FEATURE_TELEPHONY_IMS} feature), this method will do nothing.
	*/
	public void connect() {
	if (DBG) log("connect");
	if (!isSupported()) {
	mExecutor.execute(() -> mListener.connectionUnavailable(
	UNAVAILABLE_REASON_IMS_UNSUPPORTED));
	logw("connect: not supported.");
	return;
	}
	synchronized (mLock) {
	if (mManager == null) {
	mManager = mFactory.createManager(mContext, mPhoneId);
	}
	}
	mManager.registerFeatureCallback(mPhoneId, mCallback);
	}

	// Check if this ImsFeature is supported or not.
	private boolean isSupported() {
	return mContext.getPackageManager().hasSystemFeature(PackageManager.FEATURE_TELEPHONY_IMS);
	}

	/**
	* Disconnect from the ImsService Implementation and clean up. When this is complete,
	* {@link FeatureConnector.Listener#connectionUnavailable(int)} will be called one last time.
	*/
	public void disconnect() {
	if (DBG) log("disconnect");
	final U manager;
	synchronized (mLock) {
	manager = mManager;
	}
	if (manager == null) return;

	manager.unregisterFeatureCallback(mCallback);
	try {
	mCallback.imsFeatureRemoved(UNAVAILABLE_REASON_DISCONNECTED);
	} catch (RemoteException ignore) {} // local call
	}

	// Should be called on executor
	private void notifyReady(U manager, int subId) throws ImsException {
	try {
	if (DBG) log("notifyReady");
	mListener.connectionReady(manager, subId);
	}
	catch (ImsException e) {
	if(DBG) log("notifyReady exception: " + e.getMessage());
	throw e;
	}
	}

	// Should be called on executor.
	private void notifyNotReady() {
	if (DBG) log("notifyNotReady");
	mListener.connectionUnavailable(UNAVAILABLE_REASON_NOT_READY);
	}

	private void log(String message) {
	Rlog.d(TAG, "[" + mLogPrefix + ", " + mPhoneId + "] " + message);
	}

	private void logw(String message) {
	Rlog.w(TAG, "[" + mLogPrefix + ", " + mPhoneId + "] " + message);
	}
	}