diff --git a/src/com/android/phone/ImsStateCallbackController.java b/src/com/android/phone/ImsStateCallbackController.java
index d29a080..109c524 100644
--- a/src/com/android/phone/ImsStateCallbackController.java
+++ b/src/com/android/phone/ImsStateCallbackController.java
@@ -105,6 +105,9 @@
                 Executor executor, String logPrefix);
     }
 
+    /** Indicates that the state is not valid, used in ExternalRcsFeatureState only */
+    private static final int STATE_UNKNOWN = -1;
+
     /** The unavailable reason of ImsFeature is not initialized */
     private static final int NOT_INITIALIZED = -1;
     /** The ImsFeature is available. */
@@ -114,6 +117,7 @@
     private static final int EVENT_REGISTER_CALLBACK = 2;
     private static final int EVENT_UNREGISTER_CALLBACK = 3;
     private static final int EVENT_CARRIER_CONFIG_CHANGED = 4;
+    private static final int EVENT_EXTERNAL_RCS_STATE_CHANGED = 5;
 
     private static ImsStateCallbackController sInstance;
 
@@ -208,6 +212,11 @@
                     onCarrierConfigChanged(msg.arg1);
                     break;
 
+                case EVENT_EXTERNAL_RCS_STATE_CHANGED:
+                    if (msg.obj == null) break;
+                    onExternalRcsStateChanged((ExternalRcsFeatureState) msg.obj);
+                    break;
+
                 default:
                     loge("Unhandled event " + msg.what);
             }
@@ -219,9 +228,18 @@
         private int mSubId = SubscriptionManager.INVALID_SUBSCRIPTION_ID;
         private int mState = STATE_UNAVAILABLE;
         private int mReason = REASON_IMS_SERVICE_DISCONNECTED;
-        /**
+
+        /*
          * Remember the last return of verifyImsMmTelConfigured().
          * true means ImsResolver found an IMS package for FEATURE_MMTEL.
+         *
+         * mReason is updated through connectionUnavailable triggered by ImsResolver.
+         * mHasConfig is update through notifyConfigChanged triggered by mReceiver.
+         * mHasConfig can be a redundancy of (mReason == REASON_NO_IMS_SERVICE_CONFIGURED).
+         * However, when a carrier config changes, we are not sure the order
+         * of execution of connectionUnavailable and notifyConfigChanged.
+         * So, it's safe to use a separated state to retain it.
+         * We assume mHasConfig is true, until it's determined explicitly.
          */
         private boolean mHasConfig = true;
 
@@ -267,11 +285,16 @@
             reason = convertReasonType(reason);
             if (mReason == reason) return;
 
+            connectionUnavailableInternal(reason);
+        }
+
+        private void connectionUnavailableInternal(int reason) {
             mState = STATE_UNAVAILABLE;
+            mReason = reason;
+
             /* If having no IMS package for MMTEL,
              * dicard the reason except REASON_NO_IMS_SERVICE_CONFIGURED. */
             if (!mHasConfig && reason != REASON_NO_IMS_SERVICE_CONFIGURED) return;
-            mReason = reason;
 
             onFeatureStateChange(mSubId, FEATURE_MMTEL, mState, mReason);
         }
@@ -286,11 +309,19 @@
                 // REASON_NO_IMS_SERVICE_CONFIGURED is already reported to the clients,
                 // since there is no configuration of IMS package for MMTEL.
                 // Now, a carrier configuration change is notified and
-                // mHasConfig is changed from false to true.
-                // In this case, notify clients the reason, REASON_DISCONNCTED,
-                // to update the state.
-                if (mState != STATE_READY && mReason == REASON_NO_IMS_SERVICE_CONFIGURED) {
-                    connectionUnavailable(UNAVAILABLE_REASON_DISCONNECTED);
+                // the response from ImsResolver is changed from false to true.
+                if (mState != STATE_READY) {
+                    if (mReason == REASON_NO_IMS_SERVICE_CONFIGURED) {
+                        // In this case, notify clients the reason, REASON_DISCONNCTED,
+                        // to update the state.
+                        connectionUnavailable(UNAVAILABLE_REASON_DISCONNECTED);
+                    } else {
+                        // ImsResolver and ImsStateCallbackController run with different Looper.
+                        // In this case, FeatureConnectorListener is updated ahead of this.
+                        // But, connectionUnavailable didn't notify clients since mHasConfig is
+                        // false. So, notify clients here.
+                        connectionUnavailableInternal(mReason);
+                    }
                 }
             } else {
                 // FeatureConnector doesn't report UNAVAILABLE_REASON_IMS_UNSUPPORTED,
@@ -312,12 +343,36 @@
         private int mSubId = SubscriptionManager.INVALID_SUBSCRIPTION_ID;
         private int mState = STATE_UNAVAILABLE;
         private int mReason = REASON_IMS_SERVICE_DISCONNECTED;
-        /**
-         * Remember the last return of verifyImsRcsConfigured().
+
+        /*
+         * Remember the last return of verifyImsMmTelConfigured().
          * true means ImsResolver found an IMS package for FEATURE_RCS.
+         *
+         * mReason is updated through connectionUnavailable triggered by ImsResolver.
+         * mHasConfig is update through notifyConfigChanged triggered by mReceiver,
+         * and notifyExternalRcsState which triggered by TelephonyRcsService refers it.
+         * mHasConfig can be a redundancy of (mReason == REASON_NO_IMS_SERVICE_CONFIGURED).
+         * However, when a carrier config changes, we are not sure the order
+         * of execution of connectionUnavailable, notifyConfigChanged and notifyExternalRcsState.
+         * So, it's safe to use a separated state to retain it.
+         * We assume mHasConfig is true, until it's determined explicitly.
          */
         private boolean mHasConfig = true;
 
+        /*
+         * TelephonyRcsService doesn’t try to connect to RcsFeature if there is no active feature
+         * for a given subscription. The active features are declared by carrier configs and
+         * configuration resources. The APIs of ImsRcsManager and SipDelegateManager are available
+         * only when the RcsFeatureController has a STATE_READY state connection.
+         * This configuration is different from the configuration of IMS package for RCS.
+         * ImsStateCallbackController's FeatureConnectorListener can be STATE_READY state,
+         * even in case there is no active RCS feature. But Manager's APIs throws exception.
+         *
+         * For RCS, in addition to mHasConfig, the sate of TelephonyRcsService and
+         * RcsFeatureConnector will be traced to determine the state to be notified to clients.
+         */
+        private ExternalRcsFeatureState mExternalState = null;
+
         private int mSlotId = -1;
         private String mLogPrefix = "";
 
@@ -352,7 +407,10 @@
             mState = STATE_READY;
             mReason = AVAILABLE;
             mHasConfig = true;
-            onFeatureStateChange(mSubId, FEATURE_RCS, mState, mReason);
+
+            if (mExternalState != null && mExternalState.isReady()) {
+                onFeatureStateChange(mSubId, FEATURE_RCS, mState, mReason);
+            }
         }
 
         @Override
@@ -362,13 +420,32 @@
             reason = convertReasonType(reason);
             if (mReason == reason) return;
 
+            connectionUnavailableInternal(reason);
+        }
+
+        private void connectionUnavailableInternal(int reason) {
             mState = STATE_UNAVAILABLE;
+            mReason = reason;
+
             /* If having no IMS package for RCS,
              * dicard the reason except REASON_NO_IMS_SERVICE_CONFIGURED. */
             if (!mHasConfig && reason != REASON_NO_IMS_SERVICE_CONFIGURED) return;
-            mReason = reason;
 
-            onFeatureStateChange(mSubId, FEATURE_RCS, mState, mReason);
+            if (mExternalState == null && reason != REASON_NO_IMS_SERVICE_CONFIGURED) {
+                // Wait until TelephonyRcsService notifies its state.
+                return;
+            }
+
+            if (mExternalState != null && !mExternalState.hasActiveFeatures()) {
+                // notifyExternalState has notified REASON_NO_IMS_SERVICE_CONFIGURED already
+                // ignore it
+                return;
+            }
+
+            if ((mExternalState != null && mExternalState.hasActiveFeatures())
+                    || mReason == REASON_NO_IMS_SERVICE_CONFIGURED) {
+                onFeatureStateChange(mSubId, FEATURE_RCS, mState, mReason);
+            }
         }
 
         void notifyConfigChanged(boolean hasConfig) {
@@ -381,11 +458,19 @@
                 // REASON_NO_IMS_SERVICE_CONFIGURED is already reported to the clients,
                 // since there is no configuration of IMS package for RCS.
                 // Now, a carrier configuration change is notified and
-                // mHasConfig is changed from false to true.
-                // In this case, notify clients the reason, REASON_DISCONNCTED,
-                // to update the state.
-                if (mState != STATE_READY && mReason == REASON_NO_IMS_SERVICE_CONFIGURED) {
-                    connectionUnavailable(UNAVAILABLE_REASON_DISCONNECTED);
+                // the response from ImsResolver is changed from false to true.
+                if (mState != STATE_READY) {
+                    if (mReason == REASON_NO_IMS_SERVICE_CONFIGURED) {
+                        // In this case, notify clients the reason, REASON_DISCONNCTED,
+                        // to update the state.
+                        connectionUnavailable(UNAVAILABLE_REASON_DISCONNECTED);
+                    } else {
+                        // ImsResolver and ImsStateCallbackController run with different Looper.
+                        // In this case, FeatureConnectorListener is updated ahead of this.
+                        // But, connectionUnavailable didn't notify clients since mHasConfig is
+                        // false. So, notify clients here.
+                        connectionUnavailableInternal(mReason);
+                    }
                 }
             } else {
                 // FeatureConnector doesn't report UNAVAILABLE_REASON_IMS_UNSUPPORTED,
@@ -394,10 +479,66 @@
             }
         }
 
+        void notifyExternalRcsState(ExternalRcsFeatureState fs) {
+            logv(mLogPrefix + "notifyExternalRcsState"
+                    + " state=" + (fs.mState == STATE_UNKNOWN
+                            ? "" : ImsFeature.STATE_LOG_MAP.get(fs.mState))
+                    + ", reason=" + imsStateReasonToString(fs.mReason));
+
+            ExternalRcsFeatureState oldFs = mExternalState;
+            // External state is from TelephonyRcsService while a feature is added or removed.
+            if (fs.mState == STATE_UNKNOWN) {
+                if (oldFs != null) fs.mState = oldFs.mState;
+                else fs.mState = STATE_UNAVAILABLE;
+            }
+
+            mExternalState = fs;
+
+            // No IMS package found.
+            // REASON_NO_IMS_SERVICE_CONFIGURED is notified to clients already.
+            if (!mHasConfig) return;
+
+            if (fs.hasActiveFeatures()) {
+                if (mState == STATE_READY) {
+                    if ((oldFs == null || !oldFs.isReady()) && fs.isReady()) {
+                        // it is waiting RcsFeatureConnector's notification.
+                        // notify clients here.
+                        onFeatureStateChange(mSubId, FEATURE_RCS, mState, mReason);
+                    } else if (!fs.isReady()) {
+                        // Wait RcsFeatureConnector's notification
+                    } else {
+                        // ignore duplicated notification
+                    }
+                }
+            } else {
+                // notify only once
+                if (oldFs == null || oldFs.hasActiveFeatures()) {
+                    if (mReason != REASON_NO_IMS_SERVICE_CONFIGURED) {
+                        onFeatureStateChange(
+                                mSubId, FEATURE_RCS, STATE_UNAVAILABLE,
+                                REASON_NO_IMS_SERVICE_CONFIGURED);
+                    }
+                } else {
+                    // ignore duplicated notification
+                }
+            }
+        }
+
         // called from onRegisterCallback
         boolean notifyState(CallbackWrapper wrapper) {
             logv(mLogPrefix + "notifyState subId=" + wrapper.mSubId);
 
+            if (mHasConfig) {
+                if (mExternalState == null) {
+                    // Wait until TelephonyRcsService notifies its state.
+                    return wrapper.notifyState(mSubId, FEATURE_RCS, STATE_UNAVAILABLE,
+                            REASON_IMS_SERVICE_DISCONNECTED);
+                } else if (!mExternalState.hasActiveFeatures()) {
+                    return wrapper.notifyState(mSubId, FEATURE_RCS, STATE_UNAVAILABLE,
+                            REASON_NO_IMS_SERVICE_CONFIGURED);
+                }
+            }
+
             return wrapper.notifyState(mSubId, FEATURE_RCS, mState, mReason);
         }
     }
@@ -455,6 +596,26 @@
         }
     }
 
+    private static class ExternalRcsFeatureState {
+        private int mSlotId;
+        private int mState = STATE_UNAVAILABLE;
+        private int mReason = NOT_INITIALIZED;
+
+        ExternalRcsFeatureState(int slotId, int state, int reason) {
+            mSlotId = slotId;
+            mState = state;
+            mReason = reason;
+        }
+
+        boolean hasActiveFeatures() {
+            return mReason != REASON_NO_IMS_SERVICE_CONFIGURED;
+        }
+
+        boolean isReady() {
+            return mState == STATE_READY;
+        }
+    }
+
     /**
      * create an instance
      */
@@ -654,6 +815,54 @@
         }
     }
 
+    private void onExternalRcsStateChanged(ExternalRcsFeatureState fs) {
+        logv("onExternalRcsStateChanged slotId=" + fs.mSlotId
+                + ", state=" + (fs.mState == STATE_UNKNOWN
+                        ? "" : ImsFeature.STATE_LOG_MAP.get(fs.mState))
+                + ", reason=" + imsStateReasonToString(fs.mReason));
+
+        RcsFeatureListener listener = mRcsFeatureListeners.get(fs.mSlotId);
+        if (listener != null) {
+            listener.notifyExternalRcsState(fs);
+        } else {
+            // unexpected state
+            loge("onExternalRcsStateChanged slotId=" + fs.mSlotId + ", no listener.");
+        }
+    }
+
+    /**
+     * Interface to be notified from TelephonyRcsSerice and RcsFeatureController
+     *
+     * @param ready true if feature's state is STATE_READY. Valid only when it is true.
+     * @param hasActiveFeatures true if the RcsFeatureController has active features.
+     */
+    public void notifyExternalRcsStateChanged(
+            int slotId, boolean ready, boolean hasActiveFeatures) {
+        int state = STATE_UNKNOWN;
+        int reason = REASON_IMS_SERVICE_DISCONNECTED;
+
+        if (ready) {
+            // From RcsFeatureController
+            state = STATE_READY;
+            reason = AVAILABLE;
+        } else if (!hasActiveFeatures) {
+            // From TelephonyRcsService
+            reason = REASON_NO_IMS_SERVICE_CONFIGURED;
+            state = STATE_UNAVAILABLE;
+        } else {
+            // From TelephonyRcsService
+            // TelephonyRcsService doesn't know the exact state of FeatureConnection.
+            // Only when there is no feature, we can assume the state.
+        }
+
+        logv("notifyExternalRcsStateChanged slotId=" + slotId
+                + ", ready=" + ready
+                + ", hasActiveFeatures=" + hasActiveFeatures);
+
+        ExternalRcsFeatureState fs = new ExternalRcsFeatureState(slotId, state, reason);
+        mHandler.sendMessage(mHandler.obtainMessage(EVENT_EXTERNAL_RCS_STATE_CHANGED, fs));
+    }
+
     /**
      * Notifies carrier configuration has changed.
      */
diff --git a/src/com/android/services/telephony/rcs/RcsFeatureController.java b/src/com/android/services/telephony/rcs/RcsFeatureController.java
index 7834903..cc1a2cc 100644
--- a/src/com/android/services/telephony/rcs/RcsFeatureController.java
+++ b/src/com/android/services/telephony/rcs/RcsFeatureController.java
@@ -33,6 +33,7 @@
 import com.android.internal.annotations.VisibleForTesting;
 import com.android.internal.telephony.imsphone.ImsRegistrationCallbackHelper;
 import com.android.internal.util.IndentingPrintWriter;
+import com.android.phone.ImsStateCallbackController;
 
 import java.io.FileDescriptor;
 import java.io.PrintWriter;
@@ -139,6 +140,8 @@
                         // ImsService is gone.
                         updateConnectionStatus(manager);
                         setupConnectionToService(manager);
+                        ImsStateCallbackController.getInstance()
+                                .notifyExternalRcsStateChanged(mSlotId, true, true);
                     } catch (ImsException e) {
                         updateConnectionStatus(null /*manager*/);
                         // Use deprecated Exception for compatibility.
diff --git a/src/com/android/services/telephony/rcs/TelephonyRcsService.java b/src/com/android/services/telephony/rcs/TelephonyRcsService.java
index 034382c..e72b0ab 100644
--- a/src/com/android/services/telephony/rcs/TelephonyRcsService.java
+++ b/src/com/android/services/telephony/rcs/TelephonyRcsService.java
@@ -33,6 +33,7 @@
 import com.android.internal.annotations.VisibleForTesting;
 import com.android.internal.telephony.PhoneConfigurationManager;
 import com.android.internal.util.IndentingPrintWriter;
+import com.android.phone.ImsStateCallbackController;
 import com.android.phone.R;
 
 import java.io.FileDescriptor;
@@ -310,6 +311,9 @@
         }
         // Only start the connection procedure if we have active features.
         if (c.hasActiveFeatures()) c.connect();
+
+        ImsStateCallbackController.getInstance()
+                .notifyExternalRcsStateChanged(slotId, false, c.hasActiveFeatures());
     }
 
     /**
diff --git a/tests/src/com/android/phone/ImsStateCallbackControllerTest.java b/tests/src/com/android/phone/ImsStateCallbackControllerTest.java
index c476d40..431b7e6 100644
--- a/tests/src/com/android/phone/ImsStateCallbackControllerTest.java
+++ b/tests/src/com/android/phone/ImsStateCallbackControllerTest.java
@@ -217,15 +217,15 @@
         verify(mCallback0, times(1)).onUnavailable(REASON_IMS_SERVICE_DISCONNECTED);
 
         mMmTelConnectorListenerSlot0.getValue()
-                .connectionUnavailable(UNAVAILABLE_REASON_IMS_UNSUPPORTED);
-        processAllMessages();
-        verify(mCallback0, times(1)).onUnavailable(REASON_NO_IMS_SERVICE_CONFIGURED);
-
-        mMmTelConnectorListenerSlot0.getValue()
                 .connectionUnavailable(UNAVAILABLE_REASON_NOT_READY);
         processAllMessages();
         verify(mCallback0, times(1)).onUnavailable(REASON_IMS_SERVICE_NOT_READY);
 
+        mMmTelConnectorListenerSlot0.getValue()
+                .connectionUnavailable(UNAVAILABLE_REASON_IMS_UNSUPPORTED);
+        processAllMessages();
+        verify(mCallback0, times(1)).onUnavailable(REASON_NO_IMS_SERVICE_CONFIGURED);
+
         mImsStateCallbackController.unregisterImsStateCallback(mCallback0);
         processAllMessages();
         assertFalse(mImsStateCallbackController.isRegistered(mCallback0));
@@ -305,6 +305,10 @@
         assertTrue(mImsStateCallbackController.isRegistered(mCallback0));
         verify(mCallback0, times(1)).onUnavailable(REASON_IMS_SERVICE_DISCONNECTED);
 
+        // TelephonyRcsService notifying active features
+        mImsStateCallbackController.notifyExternalRcsStateChanged(SLOT_0, false, true);
+        processAllMessages();
+
         mRcsConnectorListenerSlot0.getValue()
                 .connectionUnavailable(UNAVAILABLE_REASON_NOT_READY);
         processAllMessages();
@@ -331,6 +335,10 @@
         assertTrue(mImsStateCallbackController.isRegistered(mCallback0));
         verify(mCallback0, times(1)).onUnavailable(REASON_IMS_SERVICE_DISCONNECTED);
 
+        // TelephonyRcsService notifying active features
+        mImsStateCallbackController.notifyExternalRcsStateChanged(SLOT_0, false, true);
+        processAllMessages();
+
         mRcsConnectorListenerSlot0.getValue()
                 .connectionUnavailable(UNAVAILABLE_REASON_NOT_READY);
         processAllMessages();
@@ -338,6 +346,11 @@
 
         mRcsConnectorListenerSlot0.getValue().connectionReady(null);
         processAllMessages();
+        verify(mCallback0, times(0)).onAvailable();
+
+        // RcsFeatureController notifying STATE_READY
+        mImsStateCallbackController.notifyExternalRcsStateChanged(SLOT_0, true, true);
+        processAllMessages();
         verify(mCallback0, times(1)).onAvailable();
 
         mRcsConnectorListenerSlot0.getValue()
@@ -350,6 +363,11 @@
         processAllMessages();
         verify(mCallback0, times(2)).onUnavailable(REASON_IMS_SERVICE_NOT_READY);
 
+        // RcsFeatureController notifying STATE_READY
+        mImsStateCallbackController.notifyExternalRcsStateChanged(SLOT_0, true, true);
+        processAllMessages();
+        verify(mCallback0, times(1)).onAvailable();
+
         mRcsConnectorListenerSlot0.getValue().connectionReady(null);
         processAllMessages();
         verify(mCallback0, times(2)).onAvailable();
@@ -361,6 +379,36 @@
 
     @Test
     @SmallTest
+    public void testRcsHasNoActiveFeature() throws Exception {
+        createController(1);
+
+        mImsStateCallbackController
+                .registerImsStateCallback(SLOT_0_SUB_ID, FEATURE_RCS, mCallback0);
+        processAllMessages();
+        assertTrue(mImsStateCallbackController.isRegistered(mCallback0));
+        verify(mCallback0, times(1)).onUnavailable(REASON_IMS_SERVICE_DISCONNECTED);
+
+        // TelephonyRcsService notifying NO active feature
+        mImsStateCallbackController.notifyExternalRcsStateChanged(SLOT_0, false, false);
+        processAllMessages();
+        verify(mCallback0, times(1)).onUnavailable(REASON_NO_IMS_SERVICE_CONFIGURED);
+
+        mRcsConnectorListenerSlot0.getValue()
+                .connectionUnavailable(UNAVAILABLE_REASON_NOT_READY);
+        processAllMessages();
+        verify(mCallback0, times(0)).onUnavailable(REASON_IMS_SERVICE_NOT_READY);
+
+        mRcsConnectorListenerSlot0.getValue().connectionReady(null);
+        processAllMessages();
+        verify(mCallback0, times(0)).onAvailable();
+
+        mImsStateCallbackController.unregisterImsStateCallback(mCallback0);
+        processAllMessages();
+        assertFalse(mImsStateCallbackController.isRegistered(mCallback0));
+    }
+
+    @Test
+    @SmallTest
     public void testRcsIgnoreDuplicatedConsecutiveReason() throws Exception {
         createController(1);
 
@@ -370,6 +418,10 @@
         assertTrue(mImsStateCallbackController.isRegistered(mCallback0));
         verify(mCallback0, times(1)).onUnavailable(REASON_IMS_SERVICE_DISCONNECTED);
 
+        // TelephonyRcsService notifying active features
+        mImsStateCallbackController.notifyExternalRcsStateChanged(SLOT_0, false, true);
+        processAllMessages();
+
         mRcsConnectorListenerSlot0.getValue()
                 .connectionUnavailable(UNAVAILABLE_REASON_NOT_READY);
         processAllMessages();
@@ -494,6 +546,48 @@
         verify(mCallback1, times(3)).onUnavailable(anyInt());
         verify(mCallback2, times(1)).onUnavailable(anyInt());
 
+        // carrier config changed, no MMTEL package for slot 1
+        when(mImsResolver.isImsServiceConfiguredForFeature(eq(1), eq(FEATURE_MMTEL)))
+                .thenReturn(false);
+        mImsStateCallbackController.notifyCarrierConfigChanged(SLOT_1);
+        mImsStateCallbackController.notifyCarrierConfigChanged(SLOT_1);
+        processAllMessages();
+        // only the callback for MMTEL of slot 1 received the reason
+        verify(mCallback0, times(0)).onUnavailable(REASON_NO_IMS_SERVICE_CONFIGURED);
+        verify(mCallback1, times(2)).onUnavailable(REASON_NO_IMS_SERVICE_CONFIGURED);
+        verify(mCallback2, times(0)).onUnavailable(REASON_NO_IMS_SERVICE_CONFIGURED);
+
+        // ensure no other reason repored
+        verify(mCallback0, times(1)).onUnavailable(anyInt());
+        verify(mCallback1, times(4)).onUnavailable(anyInt());
+        verify(mCallback2, times(1)).onUnavailable(anyInt());
+
+        mMmTelConnectorListenerSlot1.getValue()
+                .connectionUnavailable(UNAVAILABLE_REASON_NOT_READY);
+
+        // resons except REASON_NO_IMS_SERVICE_CONFIGURED are discared
+        verify(mCallback0, times(1)).onUnavailable(anyInt());
+        verify(mCallback1, times(4)).onUnavailable(anyInt());
+        verify(mCallback2, times(1)).onUnavailable(anyInt());
+
+        // IMS package for MMTEL of slot 1 is added
+        when(mImsResolver.isImsServiceConfiguredForFeature(eq(1), eq(FEATURE_MMTEL)))
+                .thenReturn(true);
+        mImsStateCallbackController.notifyCarrierConfigChanged(SLOT_1);
+        processAllMessages();
+
+        // ensure the callback to MMTEL of slot 1
+        // there is a pending reason UNAVAILABLE_REASON_NOT_READY
+        verify(mCallback0, times(1)).onUnavailable(REASON_IMS_SERVICE_DISCONNECTED);
+        verify(mCallback1, times(2)).onUnavailable(REASON_IMS_SERVICE_DISCONNECTED);
+        verify(mCallback1, times(1)).onUnavailable(REASON_IMS_SERVICE_NOT_READY);
+        verify(mCallback2, times(1)).onUnavailable(REASON_IMS_SERVICE_DISCONNECTED);
+
+        // ensure no other reason repored
+        verify(mCallback0, times(1)).onUnavailable(anyInt());
+        verify(mCallback1, times(5)).onUnavailable(anyInt());
+        verify(mCallback2, times(1)).onUnavailable(anyInt());
+
         assertTrue(mImsStateCallbackController.isRegistered(mCallback0));
         assertTrue(mImsStateCallbackController.isRegistered(mCallback1));
         assertTrue(mImsStateCallbackController.isRegistered(mCallback2));
@@ -532,6 +626,13 @@
         verify(mCallback2, times(1)).onUnavailable(REASON_IMS_SERVICE_DISCONNECTED);
         verify(mCallback3, times(1)).onUnavailable(REASON_IMS_SERVICE_DISCONNECTED);
 
+        // TelephonyRcsService notifying active features
+        // slot 0
+        mImsStateCallbackController.notifyExternalRcsStateChanged(SLOT_0, false, true);
+        // slot 1
+        mImsStateCallbackController.notifyExternalRcsStateChanged(SLOT_1, false, true);
+        processAllMessages();
+
         verify(mCallback0, times(1)).onUnavailable(anyInt());
         verify(mCallback1, times(1)).onUnavailable(anyInt());
         verify(mCallback2, times(1)).onUnavailable(anyInt());
@@ -606,6 +707,17 @@
         mRcsConnectorListenerSlot0.getValue().connectionReady(null);
         processAllMessages();
         verify(mCallback0, times(1)).onAvailable();
+        verify(mCallback1, times(0)).onAvailable();
+        verify(mCallback2, times(0)).onAvailable();
+        verify(mCallback3, times(0)).onAvailable();
+        verify(mCallback0, times(2)).onUnavailable(anyInt());
+        verify(mCallback1, times(2)).onUnavailable(anyInt());
+        verify(mCallback2, times(2)).onUnavailable(anyInt());
+        verify(mCallback3, times(2)).onUnavailable(anyInt());
+
+        mImsStateCallbackController.notifyExternalRcsStateChanged(SLOT_0, true, true);
+        processAllMessages();
+        verify(mCallback0, times(1)).onAvailable();
         verify(mCallback1, times(1)).onAvailable();
         verify(mCallback2, times(0)).onAvailable();
         verify(mCallback3, times(0)).onAvailable();
@@ -630,6 +742,17 @@
         verify(mCallback0, times(1)).onAvailable();
         verify(mCallback1, times(1)).onAvailable();
         verify(mCallback2, times(1)).onAvailable();
+        verify(mCallback3, times(0)).onAvailable();
+        verify(mCallback0, times(2)).onUnavailable(anyInt());
+        verify(mCallback1, times(2)).onUnavailable(anyInt());
+        verify(mCallback2, times(2)).onUnavailable(anyInt());
+        verify(mCallback3, times(2)).onUnavailable(anyInt());
+
+        mImsStateCallbackController.notifyExternalRcsStateChanged(SLOT_1, true, true);
+        processAllMessages();
+        verify(mCallback0, times(1)).onAvailable();
+        verify(mCallback1, times(1)).onAvailable();
+        verify(mCallback2, times(1)).onAvailable();
         verify(mCallback3, times(1)).onAvailable();
         verify(mCallback0, times(2)).onUnavailable(anyInt());
         verify(mCallback1, times(2)).onUnavailable(anyInt());