| /* |
| * 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.NonNull; |
| import android.annotation.Nullable; |
| import android.content.Context; |
| import android.net.Uri; |
| import android.os.IBinder; |
| import android.os.PersistableBundle; |
| import android.os.RemoteException; |
| import android.os.ServiceSpecificException; |
| import android.telephony.BinderCacheManager; |
| import android.telephony.CarrierConfigManager; |
| import android.telephony.SubscriptionManager; |
| import android.telephony.TelephonyFrameworkInitializer; |
| import android.telephony.ims.ImsException; |
| import android.telephony.ims.ImsService; |
| import android.telephony.ims.RcsUceAdapter.StackPublishTriggerType; |
| import android.telephony.ims.RegistrationManager; |
| import android.telephony.ims.SipDetails; |
| import android.telephony.ims.aidl.ICapabilityExchangeEventListener; |
| import android.telephony.ims.aidl.IImsCapabilityCallback; |
| import android.telephony.ims.aidl.IImsConfig; |
| import android.telephony.ims.aidl.IImsRcsController; |
| import android.telephony.ims.aidl.IImsRcsFeature; |
| import android.telephony.ims.aidl.IImsRegistration; |
| import android.telephony.ims.aidl.IImsRegistrationCallback; |
| import android.telephony.ims.aidl.IOptionsRequestCallback; |
| import android.telephony.ims.aidl.IOptionsResponseCallback; |
| import android.telephony.ims.aidl.IPublishResponseCallback; |
| import android.telephony.ims.aidl.ISipTransport; |
| import android.telephony.ims.aidl.ISubscribeResponseCallback; |
| import android.telephony.ims.feature.CapabilityChangeRequest; |
| import android.telephony.ims.feature.ImsFeature; |
| import android.telephony.ims.feature.RcsFeature.RcsImsCapabilities; |
| import android.telephony.ims.stub.ImsRegistrationImplBase; |
| import android.util.Log; |
| |
| import com.android.ims.internal.IImsServiceFeatureCallback; |
| import com.android.internal.annotations.VisibleForTesting; |
| import com.android.telephony.Rlog; |
| |
| import java.util.ArrayList; |
| import java.util.List; |
| import java.util.Set; |
| import java.util.concurrent.CopyOnWriteArraySet; |
| import java.util.concurrent.CountDownLatch; |
| import java.util.concurrent.Executor; |
| import java.util.concurrent.atomic.AtomicReference; |
| import java.util.function.Consumer; |
| |
| /** |
| * Encapsulates all logic related to the RcsFeature: |
| * - Updating RcsFeature capabilities. |
| * - Registering/Unregistering availability/registration callbacks. |
| * - Querying Registration and Capability information. |
| */ |
| public class RcsFeatureManager implements FeatureUpdates { |
| private static final String TAG = "RcsFeatureManager"; |
| private static boolean DBG = true; |
| |
| private static final int CAPABILITY_OPTIONS = RcsImsCapabilities.CAPABILITY_TYPE_OPTIONS_UCE; |
| private static final int CAPABILITY_PRESENCE = RcsImsCapabilities.CAPABILITY_TYPE_PRESENCE_UCE; |
| |
| /** |
| * The capability exchange event callbacks from the RcsFeature. |
| */ |
| public interface CapabilityExchangeEventCallback { |
| /** |
| * Triggered by RcsFeature to publish the device's capabilities to the network. |
| */ |
| void onRequestPublishCapabilities(@StackPublishTriggerType int publishTriggerType); |
| |
| /** |
| * Notify that the devices is unpublished. |
| */ |
| void onUnpublish(); |
| |
| /** |
| * Notify the framework that the ImsService has refreshed the PUBLISH |
| * internally, which has resulted in a new PUBLISH result. |
| * <p> |
| * This method must be called to notify the framework of SUCCESS (200 OK) and FAILURE (300+) |
| * codes in order to keep the AOSP stack up to date. |
| */ |
| void onPublishUpdated(SipDetails details); |
| |
| /** |
| * Receive a capabilities request from the remote client. |
| */ |
| void onRemoteCapabilityRequest(Uri contactUri, |
| List<String> remoteCapabilities, IOptionsRequestCallback cb); |
| } |
| |
| /* |
| * Setup the listener to listen to the requests and updates from ImsService. |
| */ |
| private ICapabilityExchangeEventListener mCapabilityEventListener = |
| new ICapabilityExchangeEventListener.Stub() { |
| @Override |
| public void onRequestPublishCapabilities(@StackPublishTriggerType int type) { |
| mCapabilityEventCallback.forEach( |
| callback -> callback.onRequestPublishCapabilities(type)); |
| } |
| |
| @Override |
| public void onUnpublish() { |
| mCapabilityEventCallback.forEach(callback -> callback.onUnpublish()); |
| } |
| |
| @Override |
| public void onPublishUpdated(@NonNull SipDetails details) { |
| mCapabilityEventCallback.forEach( |
| callback ->callback.onPublishUpdated(details)); |
| } |
| |
| @Override |
| public void onRemoteCapabilityRequest(Uri contactUri, |
| List<String> remoteCapabilities, IOptionsRequestCallback cb) { |
| mCapabilityEventCallback.forEach( |
| callback -> callback.onRemoteCapabilityRequest( |
| contactUri, remoteCapabilities, cb)); |
| } |
| }; |
| |
| private final int mSlotId; |
| private final Context mContext; |
| private final Set<CapabilityExchangeEventCallback> mCapabilityEventCallback |
| = new CopyOnWriteArraySet<>(); |
| private final BinderCacheManager<IImsRcsController> mBinderCache |
| = new BinderCacheManager<>(RcsFeatureManager::getIImsRcsControllerInterface); |
| |
| @VisibleForTesting |
| public RcsFeatureConnection mRcsFeatureConnection; |
| |
| /** |
| * Use to obtain a FeatureConnector, which will maintain a consistent listener to the |
| * RcsFeature attached to the specified slotId. If the RcsFeature changes (due to things like |
| * SIM swap), a new RcsFeatureManager will be delivered to this Listener. |
| * @param context The Context this connector should use. |
| * @param slotId The slotId associated with the Listener and requested RcsFeature |
| * @param listener The listener, which will be used to generate RcsFeatureManager instances. |
| * @param executor The executor that the Listener callbacks will be called on. |
| * @param logPrefix The prefix used in logging of the FeatureConnector for notable events. |
| * @return A FeatureConnector, which will start delivering RcsFeatureManagers as the underlying |
| * RcsFeature instances become available to the platform. |
| * @see {@link FeatureConnector#connect()}. |
| */ |
| public static FeatureConnector<RcsFeatureManager> getConnector(Context context, int slotId, |
| FeatureConnector.Listener<RcsFeatureManager> listener, Executor executor, |
| String logPrefix) { |
| ArrayList<Integer> filter = new ArrayList<>(); |
| filter.add(ImsFeature.STATE_READY); |
| return new FeatureConnector<>(context, slotId, RcsFeatureManager::new, logPrefix, filter, |
| listener, executor); |
| } |
| |
| /** |
| * Use {@link #getConnector} to get an instance of this class. |
| */ |
| private RcsFeatureManager(Context context, int slotId) { |
| mContext = context; |
| mSlotId = slotId; |
| } |
| |
| /** |
| * Opens a persistent connection to the RcsFeature. This must be called before the RcsFeature |
| * can be used to communicate. |
| */ |
| public void openConnection() throws android.telephony.ims.ImsException { |
| try { |
| mRcsFeatureConnection.setCapabilityExchangeEventListener(mCapabilityEventListener); |
| } catch (RemoteException e){ |
| throw new android.telephony.ims.ImsException("Service is not available.", |
| android.telephony.ims.ImsException.CODE_ERROR_SERVICE_UNAVAILABLE); |
| } |
| } |
| |
| /** |
| * Closes the persistent connection to the RcsFeature. This must be called when this manager |
| * wishes to no longer be used to communicate with the RcsFeature. |
| */ |
| public void releaseConnection() { |
| try { |
| mRcsFeatureConnection.setCapabilityExchangeEventListener(null); |
| } catch (RemoteException e){ |
| // Connection may not be available at this point. |
| } |
| mRcsFeatureConnection.close(); |
| mCapabilityEventCallback.clear(); |
| } |
| |
| /** |
| * Adds a callback for {@link CapabilityExchangeEventCallback}. |
| * Note: These callbacks will be sent on the binder thread used to notify the callback. |
| */ |
| public void addCapabilityEventCallback(CapabilityExchangeEventCallback listener) { |
| mCapabilityEventCallback.add(listener); |
| } |
| |
| /** |
| * Removes an existing {@link CapabilityExchangeEventCallback}. |
| */ |
| public void removeCapabilityEventCallback(CapabilityExchangeEventCallback listener) { |
| mCapabilityEventCallback.remove(listener); |
| } |
| |
| /** |
| * Update the capabilities for this RcsFeature. |
| */ |
| public void updateCapabilities(int newSubId) throws android.telephony.ims.ImsException { |
| boolean optionsSupport = isOptionsSupported(newSubId); |
| boolean presenceSupported = isPresenceSupported(newSubId); |
| |
| logi("Update capabilities for slot " + mSlotId + " and sub " + newSubId + ": options=" |
| + optionsSupport+ ", presence=" + presenceSupported); |
| |
| if (optionsSupport || presenceSupported) { |
| CapabilityChangeRequest request = new CapabilityChangeRequest(); |
| if (optionsSupport) { |
| addRcsUceCapability(request, CAPABILITY_OPTIONS); |
| } |
| if (presenceSupported) { |
| addRcsUceCapability(request, CAPABILITY_PRESENCE); |
| } |
| sendCapabilityChangeRequest(request); |
| } else { |
| disableAllRcsUceCapabilities(); |
| } |
| } |
| |
| /** |
| * Add a {@link RegistrationManager.RegistrationCallback} callback that gets called when IMS |
| * registration has changed for a specific subscription. |
| */ |
| public void registerImsRegistrationCallback(int subId, IImsRegistrationCallback callback) |
| throws android.telephony.ims.ImsException { |
| try { |
| mRcsFeatureConnection.addCallbackForSubscription(subId, callback); |
| } catch (IllegalStateException e) { |
| loge("registerImsRegistrationCallback error: ", e); |
| throw new android.telephony.ims.ImsException("Can not register callback", |
| android.telephony.ims.ImsException.CODE_ERROR_SERVICE_UNAVAILABLE); |
| } |
| } |
| |
| /** |
| * Add a {@link RegistrationManager.RegistrationCallback} callback that gets called when IMS |
| * registration has changed, independent of the subscription it is currently on. |
| */ |
| public void registerImsRegistrationCallback(IImsRegistrationCallback callback) |
| throws android.telephony.ims.ImsException { |
| try { |
| mRcsFeatureConnection.addCallback(callback); |
| } catch (IllegalStateException e) { |
| loge("registerImsRegistrationCallback error: ", e); |
| throw new android.telephony.ims.ImsException("Can not register callback", |
| android.telephony.ims.ImsException.CODE_ERROR_SERVICE_UNAVAILABLE); |
| } |
| } |
| |
| /** |
| * Removes a previously registered {@link RegistrationManager.RegistrationCallback} callback |
| * that is associated with a specific subscription. |
| */ |
| public void unregisterImsRegistrationCallback(int subId, IImsRegistrationCallback callback) { |
| mRcsFeatureConnection.removeCallbackForSubscription(subId, callback); |
| } |
| |
| /** |
| * Removes a previously registered {@link RegistrationManager.RegistrationCallback} callback |
| * that was not associated with a subscription. |
| */ |
| public void unregisterImsRegistrationCallback(IImsRegistrationCallback callback) { |
| mRcsFeatureConnection.removeCallback(callback); |
| } |
| |
| /** |
| * Get the IMS RCS registration technology for this Phone, |
| * defined in {@link ImsRegistrationImplBase}. |
| */ |
| public void getImsRegistrationTech(Consumer<Integer> callback) { |
| try { |
| int tech = mRcsFeatureConnection.getRegistrationTech(); |
| callback.accept(tech); |
| } catch (RemoteException e) { |
| loge("getImsRegistrationTech error: ", e); |
| callback.accept(ImsRegistrationImplBase.REGISTRATION_TECH_NONE); |
| } |
| } |
| |
| /** |
| * Register an ImsCapabilityCallback with RCS service, which will provide RCS availability |
| * updates. |
| */ |
| public void registerRcsAvailabilityCallback(int subId, IImsCapabilityCallback callback) |
| throws android.telephony.ims.ImsException { |
| try { |
| mRcsFeatureConnection.addCallbackForSubscription(subId, callback); |
| } catch (IllegalStateException e) { |
| loge("registerRcsAvailabilityCallback: ", e); |
| throw new android.telephony.ims.ImsException("Can not register callback", |
| android.telephony.ims.ImsException.CODE_ERROR_SERVICE_UNAVAILABLE); |
| } |
| } |
| |
| /** |
| * Remove an registered ImsCapabilityCallback from RCS service. |
| */ |
| public void unregisterRcsAvailabilityCallback(int subId, IImsCapabilityCallback callback) { |
| mRcsFeatureConnection.removeCallbackForSubscription(subId, callback); |
| } |
| |
| public boolean isImsServiceCapable(@ImsService.ImsServiceCapability long capabilities) |
| throws ImsException { |
| try { |
| return mRcsFeatureConnection.isCapable(capabilities); |
| } catch (RemoteException e) { |
| throw new ImsException(e.getMessage(), ImsException.CODE_ERROR_SERVICE_UNAVAILABLE); |
| } |
| } |
| |
| /** |
| * @return The SipTransport interface if it exists or {@code null} if it does not exist due to |
| * the ImsService not supporting it. |
| */ |
| public ISipTransport getSipTransport() throws ImsException { |
| if (!isImsServiceCapable(ImsService.CAPABILITY_SIP_DELEGATE_CREATION)) { |
| return null; |
| } |
| return mRcsFeatureConnection.getSipTransport(); |
| } |
| |
| public IImsRegistration getImsRegistration() { |
| return mRcsFeatureConnection.getRegistration(); |
| } |
| |
| /** |
| * Query for the specific capability. |
| */ |
| public boolean isCapable( |
| @RcsImsCapabilities.RcsImsCapabilityFlag int capability, |
| @ImsRegistrationImplBase.ImsRegistrationTech int radioTech) |
| throws android.telephony.ims.ImsException { |
| CountDownLatch latch = new CountDownLatch(1); |
| AtomicReference<Boolean> capableRef = new AtomicReference<>(); |
| |
| IImsCapabilityCallback callback = new IImsCapabilityCallback.Stub() { |
| @Override |
| public void onQueryCapabilityConfiguration( |
| int resultCapability, int resultRadioTech, boolean enabled) { |
| if ((capability != resultCapability) || (radioTech != resultRadioTech)) { |
| return; |
| } |
| if (DBG) log("capable result:capability=" + capability + ", enabled=" + enabled); |
| capableRef.set(enabled); |
| latch.countDown(); |
| } |
| |
| @Override |
| public void onCapabilitiesStatusChanged(int config) { |
| // Don't handle it |
| } |
| |
| @Override |
| public void onChangeCapabilityConfigurationError(int capability, int radioTech, |
| int reason) { |
| // Don't handle it |
| } |
| }; |
| |
| try { |
| if (DBG) log("Query capability: " + capability + ", radioTech=" + radioTech); |
| mRcsFeatureConnection.queryCapabilityConfiguration(capability, radioTech, callback); |
| return awaitResult(latch, capableRef); |
| } catch (RemoteException e) { |
| loge("isCapable error: ", e); |
| throw new android.telephony.ims.ImsException("Can not determine capabilities", |
| android.telephony.ims.ImsException.CODE_ERROR_SERVICE_UNAVAILABLE); |
| } |
| } |
| |
| private static <T> T awaitResult(CountDownLatch latch, AtomicReference<T> resultRef) { |
| try { |
| latch.await(); |
| } catch (InterruptedException e) { |
| Thread.currentThread().interrupt(); |
| } |
| return resultRef.get(); |
| } |
| |
| /** |
| * Query the availability of an IMS RCS capability. |
| */ |
| public boolean isAvailable(@RcsImsCapabilities.RcsImsCapabilityFlag int capability, |
| @ImsRegistrationImplBase.ImsRegistrationTech int radioTech) |
| throws android.telephony.ims.ImsException { |
| try { |
| if (mRcsFeatureConnection.getRegistrationTech() != radioTech) { |
| return false; |
| } |
| int currentStatus = mRcsFeatureConnection.queryCapabilityStatus(); |
| return new RcsImsCapabilities(currentStatus).isCapable(capability); |
| } catch (RemoteException e) { |
| loge("isAvailable error: ", e); |
| throw new android.telephony.ims.ImsException("Can not determine availability", |
| android.telephony.ims.ImsException.CODE_ERROR_SERVICE_UNAVAILABLE); |
| } |
| } |
| |
| /** |
| * Add UCE capabilities with given type. |
| * @param capability the specific RCS UCE capability wants to enable |
| */ |
| public void addRcsUceCapability(CapabilityChangeRequest request, |
| @RcsImsCapabilities.RcsImsCapabilityFlag int capability) { |
| request.addCapabilitiesToEnableForTech(capability, |
| ImsRegistrationImplBase.REGISTRATION_TECH_NR); |
| request.addCapabilitiesToEnableForTech(capability, |
| ImsRegistrationImplBase.REGISTRATION_TECH_LTE); |
| request.addCapabilitiesToEnableForTech(capability, |
| ImsRegistrationImplBase.REGISTRATION_TECH_IWLAN); |
| } |
| |
| public void requestPublication(String pidfXml, IPublishResponseCallback responseCallback) |
| throws RemoteException { |
| mRcsFeatureConnection.requestPublication(pidfXml, responseCallback); |
| } |
| |
| public void requestCapabilities(List<Uri> uris, ISubscribeResponseCallback c) |
| throws RemoteException { |
| mRcsFeatureConnection.requestCapabilities(uris, c); |
| } |
| |
| public void sendOptionsCapabilityRequest(Uri contactUri, List<String> myCapabilities, |
| IOptionsResponseCallback callback) throws RemoteException { |
| mRcsFeatureConnection.sendOptionsCapabilityRequest(contactUri, myCapabilities, callback); |
| } |
| |
| /** |
| * Disable all of the UCE capabilities. |
| */ |
| private void disableAllRcsUceCapabilities() throws android.telephony.ims.ImsException { |
| final int techNr = ImsRegistrationImplBase.REGISTRATION_TECH_NR; |
| final int techLte = ImsRegistrationImplBase.REGISTRATION_TECH_LTE; |
| final int techIWlan = ImsRegistrationImplBase.REGISTRATION_TECH_IWLAN; |
| CapabilityChangeRequest request = new CapabilityChangeRequest(); |
| request.addCapabilitiesToDisableForTech(CAPABILITY_OPTIONS, techNr); |
| request.addCapabilitiesToDisableForTech(CAPABILITY_OPTIONS, techLte); |
| request.addCapabilitiesToDisableForTech(CAPABILITY_OPTIONS, techIWlan); |
| request.addCapabilitiesToDisableForTech(CAPABILITY_PRESENCE, techNr); |
| request.addCapabilitiesToDisableForTech(CAPABILITY_PRESENCE, techLte); |
| request.addCapabilitiesToDisableForTech(CAPABILITY_PRESENCE, techIWlan); |
| sendCapabilityChangeRequest(request); |
| } |
| |
| private void sendCapabilityChangeRequest(CapabilityChangeRequest request) |
| throws android.telephony.ims.ImsException { |
| try { |
| if (DBG) log("sendCapabilityChangeRequest: " + request); |
| mRcsFeatureConnection.changeEnabledCapabilities(request, null); |
| } catch (RemoteException e) { |
| throw new android.telephony.ims.ImsException("Can not connect to service", |
| android.telephony.ims.ImsException.CODE_ERROR_SERVICE_UNAVAILABLE); |
| } |
| } |
| |
| private boolean isOptionsSupported(int subId) { |
| return isCapabilityTypeSupported(mContext, subId, CAPABILITY_OPTIONS); |
| } |
| |
| private boolean isPresenceSupported(int subId) { |
| return isCapabilityTypeSupported(mContext, subId, CAPABILITY_PRESENCE); |
| } |
| |
| /* |
| * Check if the given type of capability is supported. |
| */ |
| private static boolean isCapabilityTypeSupported( |
| Context context, int subId, int capabilityType) { |
| |
| if (subId == SubscriptionManager.INVALID_SUBSCRIPTION_ID) { |
| Log.e(TAG, "isCapabilityTypeSupported: Invalid subId=" + subId); |
| return false; |
| } |
| |
| CarrierConfigManager configManager = |
| (CarrierConfigManager) context.getSystemService(Context.CARRIER_CONFIG_SERVICE); |
| if (configManager == null) { |
| Log.e(TAG, "isCapabilityTypeSupported: CarrierConfigManager is null, " + subId); |
| return false; |
| } |
| |
| PersistableBundle b = configManager.getConfigForSubId(subId); |
| if (b == null) { |
| Log.e(TAG, "isCapabilityTypeSupported: PersistableBundle is null, " + subId); |
| return false; |
| } |
| |
| if (capabilityType == CAPABILITY_OPTIONS) { |
| return b.getBoolean(CarrierConfigManager.KEY_USE_RCS_SIP_OPTIONS_BOOL, false); |
| } else if (capabilityType == CAPABILITY_PRESENCE) { |
| return b.getBoolean(CarrierConfigManager.Ims.KEY_ENABLE_PRESENCE_PUBLISH_BOOL, false); |
| } |
| return false; |
| } |
| |
| @Override |
| public void registerFeatureCallback(int slotId, IImsServiceFeatureCallback cb) { |
| IImsRcsController controller = mBinderCache.listenOnBinder(cb, () -> { |
| try { |
| cb.imsFeatureRemoved( |
| FeatureConnector.UNAVAILABLE_REASON_SERVER_UNAVAILABLE); |
| } catch (RemoteException ignore) {} // This is local. |
| }); |
| |
| try { |
| if (controller == null) { |
| Log.e(TAG, "registerRcsFeatureListener: IImsRcsController is null"); |
| cb.imsFeatureRemoved(FeatureConnector.UNAVAILABLE_REASON_SERVER_UNAVAILABLE); |
| return; |
| } |
| controller.registerRcsFeatureCallback(slotId, cb); |
| } catch (ServiceSpecificException e) { |
| try { |
| switch (e.errorCode) { |
| case ImsException.CODE_ERROR_UNSUPPORTED_OPERATION: |
| cb.imsFeatureRemoved(FeatureConnector.UNAVAILABLE_REASON_IMS_UNSUPPORTED); |
| break; |
| default: { |
| cb.imsFeatureRemoved( |
| FeatureConnector.UNAVAILABLE_REASON_SERVER_UNAVAILABLE); |
| } |
| } |
| } catch (RemoteException ignore) {} // Already dead anyway if this happens. |
| } catch (RemoteException e) { |
| try { |
| cb.imsFeatureRemoved(FeatureConnector.UNAVAILABLE_REASON_SERVER_UNAVAILABLE); |
| } catch (RemoteException ignore) {} // Already dead if this happens. |
| } |
| } |
| |
| @Override |
| public void unregisterFeatureCallback(IImsServiceFeatureCallback cb) { |
| try { |
| IImsRcsController imsRcsController = mBinderCache.removeRunnable(cb); |
| if (imsRcsController != null) { |
| imsRcsController.unregisterImsFeatureCallback(cb); |
| } |
| } catch (RemoteException e) { |
| // This means that telephony died, so do not worry about it. |
| Rlog.e(TAG, "unregisterImsFeatureCallback (RCS), RemoteException: " |
| + e.getMessage()); |
| } |
| } |
| |
| private IImsRcsController getIImsRcsController() { |
| return mBinderCache.getBinder(); |
| } |
| |
| private static IImsRcsController getIImsRcsControllerInterface() { |
| IBinder binder = TelephonyFrameworkInitializer |
| .getTelephonyServiceManager() |
| .getTelephonyImsServiceRegisterer() |
| .get(); |
| IImsRcsController c = IImsRcsController.Stub.asInterface(binder); |
| return c; |
| } |
| |
| @Override |
| public void associate(ImsFeatureContainer c, int subId) { |
| IImsRcsFeature f = IImsRcsFeature.Stub.asInterface(c.imsFeature); |
| mRcsFeatureConnection = new RcsFeatureConnection(mContext, mSlotId, subId, f, c.imsConfig, |
| c.imsRegistration, c.sipTransport); |
| } |
| |
| @Override |
| public void invalidate() { |
| mRcsFeatureConnection.onRemovedOrDied(); |
| } |
| |
| @Override |
| public void updateFeatureState(int state) { |
| mRcsFeatureConnection.updateFeatureState(state); |
| } |
| |
| @Override |
| public void updateFeatureCapabilities(long capabilities) { |
| mRcsFeatureConnection.updateFeatureCapabilities(capabilities); |
| } |
| |
| public IImsConfig getConfig() { |
| return mRcsFeatureConnection.getConfig(); |
| } |
| |
| /** |
| * @return the subscription ID associated with this ImsService connection. |
| */ |
| public int getSubId() { |
| return mRcsFeatureConnection.getSubId(); |
| } |
| |
| private void log(String s) { |
| Rlog.d(TAG + " [" + mSlotId + "]", s); |
| } |
| |
| private void logi(String s) { |
| Rlog.i(TAG + " [" + mSlotId + "]", s); |
| } |
| |
| private void loge(String s) { |
| Rlog.e(TAG + " [" + mSlotId + "]", s); |
| } |
| |
| private void loge(String s, Throwable t) { |
| Rlog.e(TAG + " [" + mSlotId + "]", s, t); |
| } |
| } |
