path: root/rcs/rcsservice/src/com/android/service/ims/presence/PresencePublication.java

/*
 * Copyright (c) 2015, Motorola Mobility LLC
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions are met:
 *     - Redistributions of source code must retain the above copyright
 *       notice, this list of conditions and the following disclaimer.
 *     - Redistributions in binary form must reproduce the above copyright
 *       notice, this list of conditions and the following disclaimer in the
 *       documentation and/or other materials provided with the distribution.
 *     - Neither the name of Motorola Mobility nor the
 *       names of its contributors may be used to endorse or promote products
 *       derived from this software without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
 * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL MOTOROLA MOBILITY LLC BE LIABLE
 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH
 * DAMAGE.
 */

package com.android.service.ims.presence;

import android.annotation.IntDef;
import android.app.AlarmManager;
import android.app.PendingIntent;
import android.content.Context;
import android.content.Intent;
import android.net.Uri;
import android.os.Handler;
import android.os.Looper;
import android.os.Message;
import android.os.SystemClock;
import android.provider.Settings;
import android.telecom.PhoneAccount;
import android.telecom.TelecomManager;
import android.telephony.AccessNetworkConstants;
import android.telephony.SubscriptionManager;
import android.telephony.TelephonyManager;
import android.telephony.ims.RcsContactUceCapability;
import android.telephony.ims.feature.MmTelFeature;
import android.text.TextUtils;

import com.android.ims.ResultCode;
import com.android.ims.internal.ContactNumberUtils;
import com.android.ims.internal.Logger;
import com.android.service.ims.RcsSettingUtils;
import com.android.service.ims.Task;
import com.android.service.ims.TaskManager;

import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;

public class PresencePublication extends PresenceBase {
    private Logger logger = Logger.getLogger(this.getClass().getName());

    private final Object mSyncObj = new Object();

    private static final int TIMEOUT_CHECK_SUBSCRIPTION_READY_MS = 5000;

    boolean mMovedToIWLAN = false;
    boolean mMovedToLTE = false;
    boolean mVoPSEnabled = false;

    boolean mIsVolteAvailable = false;
    boolean mIsVtAvailable = false;
    boolean mIsVoWifiAvailable = false;
    boolean mIsViWifiAvailable = false;

    // Queue for the pending PUBLISH request. Just need cache the last one.
    volatile PublishRequest mPendingRequest = null;
    volatile PublishRequest mPublishingRequest = null;
    volatile PublishRequest mPublishedRequest = null;

    /*
     * Message sent to mMsgHandler when there is a new request to Publish capabilities.
     */
    private static final int MESSAGE_RCS_PUBLISH_REQUEST = 1;
    /*
     * Message sent when the default subscription has changed or become active for the first time.
     */
    private static final int MESSAGE_DEFAULT_SUBSCRIPTION_CHANGED = 2;

    private Handler mMsgHandler = new Handler(Looper.getMainLooper()) {
        @Override
        public void handleMessage(Message msg) {
            super.handleMessage(msg);

            logger.debug( "Thread=" + Thread.currentThread().getName() + " received "
                    + msg);
            if(msg == null){
                logger.error("msg=null");
                return;
            }

            switch (msg.what) {
                case MESSAGE_RCS_PUBLISH_REQUEST: {
                    logger.debug("handleMessage  msg=RCS_PUBLISH_REQUEST:");

                    PublishRequest publishRequest = (PublishRequest) msg.obj;
                    synchronized (mSyncObj) {
                        mPendingRequest = null;
                    }
                    doPublish(publishRequest);
                    break;
                }
                case MESSAGE_DEFAULT_SUBSCRIPTION_CHANGED: {
                    requestPublishIfSubscriptionReady();
                    break;
                }
                default:
                    logger.debug("handleMessage unknown msg=" + msg.what);
            }
        }
    };

    private PresencePublisher mPresencePublisher;
    private PresenceSubscriber mSubscriber = null;
    static private PresencePublication sPresencePublication = null;

    private boolean mHasCachedTrigger = false;
    private boolean mGotTriggerFromStack = false;
    private boolean mDonotRetryUntilPowerCycle = false;
    private boolean mSimLoaded = false;
    private int mPreferredTtyMode = TelecomManager.TTY_MODE_OFF;

    private boolean mImsRegistered = false;
    private boolean mVtEnabled = false;
    private boolean mDataEnabled = false;
    private final String[] mConfigVolteProvisionErrorOnPublishResponse;
    private final String[] mConfigRcsProvisionErrorOnPublishResponse;
    private int mAssociatedSubscription = SubscriptionManager.INVALID_SUBSCRIPTION_ID;

    /** ETag expired. */
    public static final int UCE_PRES_PUBLISH_TRIGGER_ETAG_EXPIRED = 0;
    /** Move to LTE with VoPS disabled. */
    public static final int UCE_PRES_PUBLISH_TRIGGER_MOVE_TO_LTE_VOPS_DISABLED = 1;
    /** Move to LTE with VoPS enabled. */
    public static final int UCE_PRES_PUBLISH_TRIGGER_MOVE_TO_LTE_VOPS_ENABLED = 2;
    /** Move to eHRPD. */
    public static final int UCE_PRES_PUBLISH_TRIGGER_MOVE_TO_EHRPD = 3;
    /** Move to HSPA+. */
    public static final int UCE_PRES_PUBLISH_TRIGGER_MOVE_TO_HSPAPLUS = 4;
    /** Move to 3G. */
    public static final int UCE_PRES_PUBLISH_TRIGGER_MOVE_TO_3G = 5;
    /** Move to 2G. */
    public static final int UCE_PRES_PUBLISH_TRIGGER_MOVE_TO_2G = 6;
    /** Move to WLAN */
    public static final int UCE_PRES_PUBLISH_TRIGGER_MOVE_TO_WLAN = 7;
    /** Move to IWLAN */
    public static final int UCE_PRES_PUBLISH_TRIGGER_MOVE_TO_IWLAN = 8;
    /** Trigger is unknown. */
    public static final int UCE_PRES_PUBLISH_TRIGGER_UNKNOWN = 9;

    @IntDef(value = {
            UCE_PRES_PUBLISH_TRIGGER_ETAG_EXPIRED,
            UCE_PRES_PUBLISH_TRIGGER_MOVE_TO_LTE_VOPS_DISABLED,
            UCE_PRES_PUBLISH_TRIGGER_MOVE_TO_LTE_VOPS_ENABLED,
            UCE_PRES_PUBLISH_TRIGGER_MOVE_TO_EHRPD,
            UCE_PRES_PUBLISH_TRIGGER_MOVE_TO_HSPAPLUS,
            UCE_PRES_PUBLISH_TRIGGER_MOVE_TO_3G,
            UCE_PRES_PUBLISH_TRIGGER_MOVE_TO_2G,
            UCE_PRES_PUBLISH_TRIGGER_MOVE_TO_WLAN,
            UCE_PRES_PUBLISH_TRIGGER_MOVE_TO_IWLAN,
            UCE_PRES_PUBLISH_TRIGGER_UNKNOWN
    }, prefix="UCE_PRES_PUBLISH_TRIGGER_")
    @Retention(RetentionPolicy.SOURCE)
    public @interface StackPublishTriggerType {}

    public class PublishType {
        public static final int PRES_PUBLISH_TRIGGER_DATA_CHANGED = 0;
        // the lower layer should send trigger when enable volte
        // the lower layer should unpublish when disable volte
        // so only handle VT here.
        public static final int PRES_PUBLISH_TRIGGER_VTCALL_CHANGED = 1;
        public static final int PRES_PUBLISH_TRIGGER_CACHED_TRIGGER = 2;
        public static final int PRES_PUBLISH_TRIGGER_TTY_ENABLE_STATUS = 3;
        public static final int PRES_PUBLISH_TRIGGER_RETRY = 4;
        public static final int PRES_PUBLISH_TRIGGER_FEATURE_AVAILABILITY_CHANGED = 5;
        public static final int PRES_PUBLISH_TRIGGER_DEFAULT_SUB_CHANGED = 6;
    };

    public PresencePublication(PresencePublisher presencePublisher, Context context,
            String[] configVolteProvisionErrorOnPublishResponse,
            String[] configRcsProvisionErrorOnPublishResponse) {
        super(context);
        logger.debug("PresencePublication constrcuct");
        synchronized(mSyncObj) {
            this.mPresencePublisher = presencePublisher;
        }
        mConfigVolteProvisionErrorOnPublishResponse = configVolteProvisionErrorOnPublishResponse;
        mConfigRcsProvisionErrorOnPublishResponse = configRcsProvisionErrorOnPublishResponse;

        mVtEnabled = RcsSettingUtils.isVtEnabledByUser(mAssociatedSubscription);

        mDataEnabled = Settings.Global.getInt(mContext.getContentResolver(),
                    Settings.Global.MOBILE_DATA, 1) == 1;
        logger.debug("The current mobile data is: " + (mDataEnabled ? "enabled" : "disabled"));

        TelecomManager tm = mContext.getSystemService(TelecomManager.class);
        mPreferredTtyMode = tm.getCurrentTtyMode();
        logger.debug("The current TTY mode is: " + mPreferredTtyMode);

        sPresencePublication = this;
    }

    public void updatePresencePublisher(PresencePublisher presencePublisher) {
        synchronized(mSyncObj) {
            logger.debug("Update PresencePublisher");
            this.mPresencePublisher = presencePublisher;
        }
    }

    public void removePresencePublisher() {
        synchronized(mSyncObj) {
            logger.debug("Remove PresencePublisher");
            this.mPresencePublisher = null;
        }
    }

    private void requestPublishIfSubscriptionReady() {
        if (!SubscriptionManager.isValidSubscriptionId(mAssociatedSubscription)) {
            // pulled out the SIM, set it as the same as power on status:
            logger.print("subscription changed to invalid, setting to not published");

            // only reset when the SIM gets absent.
            reset();
            mSimLoaded = false;
            setPublishState(PUBLISH_STATE_NOT_PUBLISHED);
            return;
        }
        if (isSimLoaded()) {
            logger.print("subscription ready, requesting publish");
            mSimLoaded = true;
            // treat hot SIM hot swap as power on.
            mDonotRetryUntilPowerCycle = false;
            requestLocalPublish(PublishType.PRES_PUBLISH_TRIGGER_DEFAULT_SUB_CHANGED);
        } else {
            mMsgHandler.removeMessages(MESSAGE_DEFAULT_SUBSCRIPTION_CHANGED);
            mMsgHandler.sendMessageDelayed(
                    mMsgHandler.obtainMessage(MESSAGE_DEFAULT_SUBSCRIPTION_CHANGED),
                    TIMEOUT_CHECK_SUBSCRIPTION_READY_MS);
        }
    }

    private boolean isSimLoaded() {
        TelephonyManager teleMgr = (TelephonyManager) mContext.getSystemService(
                Context.TELEPHONY_SERVICE);
        if (teleMgr == null) return false;
        teleMgr = teleMgr.createForSubscriptionId(mAssociatedSubscription);
        String[] myImpu = teleMgr.getIsimImpu();
        String myDomain = teleMgr.getIsimDomain();
        String line1Number = teleMgr.getLine1Number();
        return !TextUtils.isEmpty(line1Number) || (!TextUtils.isEmpty(myDomain) && myImpu != null
                && myImpu.length != 0);
    }

    private boolean isIPVoiceSupported(boolean volteAvailable, boolean voWifiAvailable) {
        // volte and vowifi can be enabled separately
        if(!RcsSettingUtils.isVoLteSupported(mAssociatedSubscription) &&
                !RcsSettingUtils.isVoWiFiSupported(mAssociatedSubscription)) {
            logger.print("Disabled by platform, voiceSupported=false");
            return false;
        }

        if(!RcsSettingUtils.isVoLteProvisioned(mAssociatedSubscription) &&
                !RcsSettingUtils.isVowifiProvisioned(mAssociatedSubscription)) {
            logger.print("Wasn't provisioned, voiceSupported=false");
            return false;
        }

        if(!RcsSettingUtils.isAdvancedCallingEnabledByUser(mAssociatedSubscription) &&
                !RcsSettingUtils.isWfcEnabledByUser(mAssociatedSubscription)){
            logger.print("User didn't enable volte or wfc, voiceSupported=false");
            return false;
        }

        // for IWLAN. All WFC settings and provision should be fine if voWifiAvailable is true.
        if(isOnIWLAN()) {
            boolean voiceSupported=volteAvailable || voWifiAvailable;
            logger.print("on IWLAN, voiceSupported=" + voiceSupported);
            return voiceSupported;
        }

        // for none-IWLAN
        if(!isOnLTE()) {
            logger.print("isOnLTE=false, voiceSupported=false");
            return false;
        }

        if(!mVoPSEnabled) {
            logger.print("mVoPSEnabled=false, voiceSupported=false");
            return false;
        }

        logger.print("voiceSupported=true");
        return true;
    }

    private boolean isIPVideoSupported(boolean vtAvailable, boolean viWifiAvailable) {
        // if volte or vt was disabled then the viwifi will be disabled as well.
        if(!RcsSettingUtils.isVoLteSupported(mAssociatedSubscription) ||
                !RcsSettingUtils.isVtSupported(mAssociatedSubscription)) {
            logger.print("Disabled by platform, videoSupported=false");
            return false;
        }

        if(!RcsSettingUtils.isVoLteProvisioned(mAssociatedSubscription) ||
                !RcsSettingUtils.isLvcProvisioned(mAssociatedSubscription)) {
            logger.print("Not provisioned. videoSupported=false");
            return false;
        }

        if(!RcsSettingUtils.isAdvancedCallingEnabledByUser(mAssociatedSubscription) || !mVtEnabled){
            logger.print("User disabled volte or vt, videoSupported=false");
            return false;
        }

        if(isTtyOn()){
            logger.print("isTtyOn=true, videoSupported=false");
            return false;
        }

        // for IWLAN, all WFC settings and provision should be fine if viWifiAvailable is true.
        if(isOnIWLAN()) {
            boolean videoSupported = vtAvailable || viWifiAvailable;
            logger.print("on IWLAN, videoSupported=" + videoSupported);
            return videoSupported;
        }

        if(!isDataEnabled()) {
            logger.print("isDataEnabled()=false, videoSupported=false");
            return false;
        }

        if(!isOnLTE()) {
            logger.print("isOnLTE=false, videoSupported=false");
            return false;
        }

        if(!mVoPSEnabled) {
            logger.print("mVoPSEnabled=false, videoSupported=false");
            return false;
        }

        return true;
    }

    public void onTtyPreferredModeChanged(int newTtyPreferredMode) {
        logger.debug("Tty mode changed from " + mPreferredTtyMode
                + " to " + newTtyPreferredMode);

        boolean mIsTtyEnabled = isTtyEnabled(mPreferredTtyMode);
        boolean isTtyEnabled = isTtyEnabled(newTtyPreferredMode);
        mPreferredTtyMode = newTtyPreferredMode;
        if (mIsTtyEnabled != isTtyEnabled) {
            logger.print("ttyEnabled status changed from " + mIsTtyEnabled
                    + " to " + isTtyEnabled);
            requestLocalPublish(PresencePublication.PublishType.
                    PRES_PUBLISH_TRIGGER_TTY_ENABLE_STATUS );
        }
    }

    public void onAirplaneModeChanged(boolean isAirplaneModeEnabled) {
        if(isAirplaneModeEnabled){
            logger.print("Airplane mode, set to PUBLISH_STATE_NOT_PUBLISHED");
            reset();
            setPublishState(PUBLISH_STATE_NOT_PUBLISHED);
        }
    }

    public boolean isTtyOn() {
        logger.debug("isTtyOn settingsTtyMode=" + mPreferredTtyMode);
        return isTtyEnabled(mPreferredTtyMode);
    }

    public void onImsConnected() {
        mImsRegistered = true;
    }

    public void onImsDisconnected() {
        logger.debug("reset PUBLISH status for IMS had been disconnected");
        mImsRegistered = false;
        reset();
    }

    private void reset() {
        mIsVolteAvailable = false;
        mIsVtAvailable = false;
        mIsVoWifiAvailable = false;
        mIsViWifiAvailable = false;

        synchronized(mSyncObj) {
            mPendingRequest = null; //ignore the previous request
            mPublishingRequest = null;
            mPublishedRequest = null;
        }
    }

    public void handleAssociatedSubscriptionChanged(int newSubId) {
        if (mAssociatedSubscription == newSubId) {
            return;
        }
        reset();
        mAssociatedSubscription = newSubId;
        mMsgHandler.removeMessages(MESSAGE_DEFAULT_SUBSCRIPTION_CHANGED);
        mMsgHandler.sendMessage(mMsgHandler.obtainMessage(MESSAGE_DEFAULT_SUBSCRIPTION_CHANGED));
    }

    public void handleProvisioningChanged() {
        if(RcsSettingUtils.isEabProvisioned(mContext, mAssociatedSubscription)) {
            logger.debug("provisioned, set mDonotRetryUntilPowerCycle to false");
            mDonotRetryUntilPowerCycle = false;
            if(mHasCachedTrigger) {
                requestLocalPublish(PublishType.PRES_PUBLISH_TRIGGER_CACHED_TRIGGER);
            }
        }
    }

    static public PresencePublication getPresencePublication() {
        return sPresencePublication;
    }

    public void setSubscriber(PresenceSubscriber subscriber) {
        mSubscriber = subscriber;
    }

    public boolean isDataEnabled() {
        return  Settings.Global.getInt(mContext.getContentResolver(),
                Settings.Global.MOBILE_DATA, 1) == 1;
    }

    public void onMobileDataChanged(boolean value){
        logger.print("onMobileDataChanged, mDataEnabled=" + mDataEnabled + " value=" + value);
        if(mDataEnabled != value) {
            mDataEnabled = value;

            requestLocalPublish(PublishType.PRES_PUBLISH_TRIGGER_DATA_CHANGED);
        }
    }

    public void onVtEnabled(boolean enabled) {
        logger.debug("onVtEnabled mVtEnabled=" + mVtEnabled + " enabled=" + enabled);

        if(mVtEnabled != enabled) {
            mVtEnabled = enabled;
            requestLocalPublish(PublishType.PRES_PUBLISH_TRIGGER_VTCALL_CHANGED);
        }
    }

    @Override
    public void onCommandStatusUpdated(int taskId, int requestId, int resultCode) {
        logger.info("onCommandStatusUpdated: resultCode= " + resultCode);
        super.onCommandStatusUpdated(taskId, requestId, resultCode);
    }

    /**
     * @return return true if it had been PUBLISHED.
     */
    private boolean isPublishedOrPublishing() {
        long publishThreshold = RcsSettingUtils.getPublishThrottle(mAssociatedSubscription);

        boolean publishing = false;
        publishing = (mPublishingRequest != null) &&
                (System.currentTimeMillis() - mPublishingRequest.getTimestamp()
                <= publishThreshold);

        return (getPublishState() == PUBLISH_STATE_200_OK || publishing);
    }

    /**
     * @return The result of the last Publish request.
     */
    public @PresenceBase.PresencePublishState int getPublishState() {
        PresencePublisher presencePublisher = null;
        synchronized(mSyncObj) {
            presencePublisher = mPresencePublisher;
        }

        if (presencePublisher != null) {
            return presencePublisher.getPublisherState();
        }
        return PUBLISH_STATE_NOT_PUBLISHED;
    }

    /**
     * @param publishState The result of the last publish request.
     */
    public void setPublishState(int publishState) {
        PresencePublisher presencePublisher = null;
        synchronized(mSyncObj) {
            presencePublisher = mPresencePublisher;
        }

        if (presencePublisher != null) {
            presencePublisher.updatePublisherState(publishState);
        }
    }

    // Trigger a local publish based off of state changes in the framework.
    private void requestLocalPublish(int trigger) {

        // if the value is true then it will call stack to send the PUBLISH
        // though the previous publish had the same capability
        // for example: for retry PUBLISH.
        boolean bForceToNetwork = true;
        switch(trigger)
        {
            case PublishType.PRES_PUBLISH_TRIGGER_DATA_CHANGED:
            {
                logger.print("PRES_PUBLISH_TRIGGER_DATA_CHANGED");
                bForceToNetwork = false;
                break;
            }
            case PublishType.PRES_PUBLISH_TRIGGER_VTCALL_CHANGED:
            {
                logger.print("PRES_PUBLISH_TRIGGER_VTCALL_CHANGED");
                // Didn't get featureCapabilityChanged sometimes.
                bForceToNetwork = true;
                break;
            }
            case PublishType.PRES_PUBLISH_TRIGGER_CACHED_TRIGGER:
            {
                logger.print("PRES_PUBLISH_TRIGGER_CACHED_TRIGGER");
                break;
            }
            case PublishType.PRES_PUBLISH_TRIGGER_TTY_ENABLE_STATUS:
            {
                logger.print("PRES_PUBLISH_TRIGGER_TTY_ENABLE_STATUS");
                bForceToNetwork = true;

                break;
            }
            case PublishType.PRES_PUBLISH_TRIGGER_FEATURE_AVAILABILITY_CHANGED:
            {
                bForceToNetwork = false;
                logger.print("PRES_PUBLISH_TRIGGER_FEATURE_AVAILABILITY_CHANGED");
                break;
            }
            case PublishType.PRES_PUBLISH_TRIGGER_RETRY:
            {
                logger.print("PRES_PUBLISH_TRIGGER_RETRY");
                break;
            }
            case PublishType.PRES_PUBLISH_TRIGGER_DEFAULT_SUB_CHANGED:
            {
                logger.print("PRES_PUBLISH_TRIGGER_DEFAULT_SUB_CHANGED");
                bForceToNetwork = true;
                break;
            }
            default:
            {
                logger.print("Unknown publish trigger from AP");
            }
        }

        if(mGotTriggerFromStack == false){
            // Waiting for RCS stack get ready.
            logger.print("Didn't get trigger from stack yet, discard framework trigger.");
            return;
        }

        if (mDonotRetryUntilPowerCycle) {
            logger.print("Don't publish until next power cycle");
            return;
        }

        if(!mSimLoaded){
            //need to read some information from SIM to publish
            logger.print("invokePublish cache the trigger since the SIM is not ready");
            mHasCachedTrigger = true;
            return;
        }

        //the provision status didn't be read from modem yet
        if(!RcsSettingUtils.isEabProvisioned(mContext, mAssociatedSubscription)) {
            logger.print("invokePublish cache the trigger, not provision yet");
            mHasCachedTrigger = true;
            return;
        }

        PublishRequest publishRequest = new PublishRequest(
                bForceToNetwork, System.currentTimeMillis());

        requestPublication(publishRequest);

        return;
    }

    public void onStackPublishRequested(@StackPublishTriggerType int publishTriggerType) {
        mGotTriggerFromStack = true;

        switch (publishTriggerType)
        {
            case UCE_PRES_PUBLISH_TRIGGER_ETAG_EXPIRED:
            {
                logger.print("PUBLISH_TRIGGER_ETAG_EXPIRED");
                break;
            }
            case UCE_PRES_PUBLISH_TRIGGER_MOVE_TO_LTE_VOPS_DISABLED:
            {
                logger.print("PUBLISH_TRIGGER_MOVE_TO_LTE_VOPS_DISABLED");
                mMovedToLTE = true;
                mVoPSEnabled = false;
                mMovedToIWLAN = false;

                // onImsConnected could came later than this trigger.
                mImsRegistered = true;
                break;
            }
            case UCE_PRES_PUBLISH_TRIGGER_MOVE_TO_LTE_VOPS_ENABLED:
            {
                logger.print("PUBLISH_TRIGGER_MOVE_TO_LTE_VOPS_ENABLED");
                mMovedToLTE = true;
                mVoPSEnabled = true;
                mMovedToIWLAN = false;

                // onImsConnected could came later than this trigger.
                mImsRegistered = true;
                break;
            }
            case UCE_PRES_PUBLISH_TRIGGER_MOVE_TO_IWLAN:
            {
                logger.print("QRCS_PRES_PUBLISH_TRIGGER_MOVE_TO_IWLAN");
                mMovedToLTE = false;
                mVoPSEnabled = false;
                mMovedToIWLAN = true;

                // onImsConnected could came later than this trigger.
                mImsRegistered = true;
                break;
            }
            case UCE_PRES_PUBLISH_TRIGGER_MOVE_TO_EHRPD:
            {
                logger.print("PUBLISH_TRIGGER_MOVE_TO_EHRPD");
                mMovedToLTE = false;
                mVoPSEnabled = false;
                mMovedToIWLAN = false;

                // onImsConnected could came later than this trigger.
                mImsRegistered = true;
                break;
            }
            case UCE_PRES_PUBLISH_TRIGGER_MOVE_TO_HSPAPLUS:
            {
                logger.print("PUBLISH_TRIGGER_MOVE_TO_HSPAPLUS");
                mMovedToLTE = false;
                mVoPSEnabled = false;
                mMovedToIWLAN = false;
                break;
            }
            case UCE_PRES_PUBLISH_TRIGGER_MOVE_TO_2G:
            {
                logger.print("PUBLISH_TRIGGER_MOVE_TO_2G");
                mMovedToLTE = false;
                mVoPSEnabled = false;
                mMovedToIWLAN = false;
                break;
            }
            case UCE_PRES_PUBLISH_TRIGGER_MOVE_TO_3G:
            {
                logger.print("PUBLISH_TRIGGER_MOVE_TO_3G");
                mMovedToLTE = false;
                mVoPSEnabled = false;
                mMovedToIWLAN = false;
                break;
            }
            default:
                logger.print("Unknow Publish Trigger Type");
        }

        if (mDonotRetryUntilPowerCycle) {
            logger.print("Don't publish until next power cycle");
            return;
        }

        if(!mSimLoaded){
            //need to read some information from SIM to publish
            logger.print("invokePublish cache the trigger since the SIM is not ready");
            mHasCachedTrigger = true;
            return;
        }

        //the provision status didn't be read from modem yet
        if(!RcsSettingUtils.isEabProvisioned(mContext, mAssociatedSubscription)) {
            logger.print("invokePublish cache the trigger, not provision yet");
            mHasCachedTrigger = true;
            return;
        }

        // Always send the PUBLISH when we got the trigger from stack.
        // This can avoid any issue when switch the phone between IWLAN and LTE.
        PublishRequest publishRequest = new PublishRequest(
                true /*forceToNetwork*/, System.currentTimeMillis());

        requestPublication(publishRequest);
    }

    /**
     * Trigger a publish when the stack becomes available and we have a cached trigger waiting.
     */
    public void onStackAvailable() {
        if (mHasCachedTrigger) {
            requestLocalPublish(PublishType.PRES_PUBLISH_TRIGGER_CACHED_TRIGGER);
        }
    }

    public class PublishRequest {
        private boolean mForceToNetwork;
        private long mCurrentTime;
        private boolean mVolteCapable = false;
        private boolean mVtCapable = false;

        PublishRequest(boolean bForceToNetwork, long currentTime) {
            refreshPublishContent();
            mForceToNetwork = bForceToNetwork;
            mCurrentTime = currentTime;
        }

        public void refreshPublishContent() {
            setVolteCapable(isIPVoiceSupported(mIsVolteAvailable, mIsVoWifiAvailable));
            setVtCapable(isIPVideoSupported(mIsVtAvailable, mIsViWifiAvailable));
        }

        public boolean getForceToNetwork() {
            return mForceToNetwork;
        }

        public void setForceToNetwork(boolean bForceToNetwork) {
            mForceToNetwork = bForceToNetwork;
        }

        public long getTimestamp() {
            return mCurrentTime;
        }

        public void setTimestamp(long currentTime) {
            mCurrentTime = currentTime;
        }

        public void setVolteCapable(boolean capable) {
            mVolteCapable = capable;
        }

        public void setVtCapable(boolean capable) {
            mVtCapable = capable;
        }

        public boolean getVolteCapable() {
            return mVolteCapable;
        }

        public boolean getVtCapable() {
            return mVtCapable;
        }

        public boolean hasSamePublishContent(PublishRequest request) {
            if(request == null) {
                logger.error("request == null");
                return false;
            }

            return (mVolteCapable == request.getVolteCapable() &&
                    mVtCapable == request.getVtCapable());
        }

        public String toString(){
            return "mForceToNetwork=" + mForceToNetwork +
                    " mCurrentTime=" + mCurrentTime +
                    " mVolteCapable=" + mVolteCapable +
                    " mVtCapable=" + mVtCapable;
        }
    }

    private void requestPublication(PublishRequest publishRequest) {
        // this is used to avoid the temp false feature change when switched between network.
        if(publishRequest == null) {
            logger.error("Invalid parameter publishRequest == null");
            return;
        }

        long requestThrottle = 2000;
        long currentTime = System.currentTimeMillis();
        synchronized(mSyncObj){
            // There is a PUBLISH will be done soon. Discard it
            if((mPendingRequest != null) && currentTime - mPendingRequest.getTimestamp()
                    <= requestThrottle) {
                logger.print("A publish is pending, update the pending request and discard this one");
                if(publishRequest.getForceToNetwork() && !mPendingRequest.getForceToNetwork()) {
                    mPendingRequest.setForceToNetwork(true);
                }
                mPendingRequest.setTimestamp(publishRequest.getTimestamp());
                return;
            }

            mPendingRequest = publishRequest;
        }

        Message publishMessage = mMsgHandler.obtainMessage(
                MESSAGE_RCS_PUBLISH_REQUEST, mPendingRequest);
        mMsgHandler.sendMessageDelayed(publishMessage, requestThrottle);
    }

    private void doPublish(PublishRequest publishRequest) {

        if(publishRequest == null) {
            logger.error("publishRequest == null");
            return;
        }

        PresencePublisher presencePublisher = null;
        synchronized(mSyncObj) {
            presencePublisher = mPresencePublisher;
        }

        if (presencePublisher == null) {
            logger.error("mPresencePublisher == null");
            return;
        }

        if(!mImsRegistered) {
            logger.error("IMS wasn't registered");
            return;
        }

        // Since we are doing a publish, don't need the retry any more.
        if(mPendingRetry) {
            mPendingRetry = false;
            mAlarmManager.cancel(mRetryAlarmIntent);
        }

        // always publish the latest status.
        synchronized(mSyncObj) {
            publishRequest.refreshPublishContent();
        }

        logger.print("publishRequest=" + publishRequest);
        if(!publishRequest.getForceToNetwork() && isPublishedOrPublishing() &&
                (publishRequest.hasSamePublishContent(mPublishingRequest) ||
                        (mPublishingRequest == null) &&
                        publishRequest.hasSamePublishContent(mPublishedRequest)) &&
                (getPublishState() != PUBLISH_STATE_NOT_PUBLISHED)) {
            logger.print("Don't need publish since the capability didn't change publishRequest "
                    + publishRequest + " getPublishState()=" + getPublishState());
            return;
        }

        // Don't publish too frequently. Checking the throttle timer.
        if(isPublishedOrPublishing()) {
            if(mPendingRetry) {
                logger.print("Pending a retry");
                return;
            }

            long publishThreshold = RcsSettingUtils.getPublishThrottle(mAssociatedSubscription);
            long passed = publishThreshold;
            if(mPublishingRequest != null) {
                passed = System.currentTimeMillis() - mPublishingRequest.getTimestamp();
            } else if(mPublishedRequest != null) {
                passed = System.currentTimeMillis() - mPublishedRequest.getTimestamp();
            }
            passed = passed>=0?passed:publishThreshold;

            long left = publishThreshold - passed;
            left = left>120000?120000:left; // Don't throttle more then 2 mintues.
            if(left > 0) {
                // A publish is ongoing or published in 1 minute.
                // Since the new publish has new status. So schedule
                // the publish after the throttle timer.
                scheduleRetryPublish(left);
                return;
            }
        }

        // we need send PUBLISH once even the volte is off when power on the phone.
        // That will tell other phone that it has no volte/vt capability.
        if(!RcsSettingUtils.isAdvancedCallingEnabledByUser(mAssociatedSubscription) &&
                getPublishState() != PUBLISH_STATE_NOT_PUBLISHED) {
            // volte was not enabled.
            // or it is turnning off volte. lower layer should unpublish
            reset();
            return;
        }

        TelephonyManager teleMgr = (TelephonyManager) mContext.getSystemService(
                Context.TELEPHONY_SERVICE);
        teleMgr = teleMgr.createForSubscriptionId(mAssociatedSubscription);
        if (teleMgr == null) {
            logger.error("TelephonyManager not available.");
            return;
        }
        Uri contactUri = Uri.fromParts(PhoneAccount.SCHEME_TEL, teleMgr.getLine1Number(), null);

        RcsContactUceCapability.Builder presenceInfoBuilder =
                new RcsContactUceCapability.Builder(contactUri);
        if (publishRequest.getVolteCapable()) {
            presenceInfoBuilder.add(RcsContactUceCapability.CAPABILITY_IP_VOICE_CALL);
        }
        if (publishRequest.getVtCapable()) {
            presenceInfoBuilder.add(RcsContactUceCapability.CAPABILITY_IP_VIDEO_CALL);
        }

        synchronized(mSyncObj) {
            mPublishingRequest = publishRequest;
            mPublishingRequest.setTimestamp(System.currentTimeMillis());
        }

        String myUri = getUriForPublication();
        if (myUri == null) {
            logger.error("doPublish, myUri is null");
        }
        String myNumber = getNumberFromUri(myUri);
        int taskId = TaskManager.getDefault().addPublishTask(myNumber);
        logger.print("doPublish, uri=" + myUri + ", myNumber=" + myNumber + ", taskId=" + taskId);

        int ret = presencePublisher.requestPublication(presenceInfoBuilder.build(), myUri, taskId);
        if (ret != ResultCode.SUCCESS) {
            logger.print("doPublish, task=" + taskId + " failed with code=" + ret);
            TaskManager.getDefault().removeTask(taskId);
        }
        // cache the latest publication request if temporarily not available.
        mHasCachedTrigger = (ret == ResultCode.ERROR_SERVICE_NOT_AVAILABLE);
    }

    private String getNumberFromUri(String uriString) {
        String number = Uri.parse(uriString).getSchemeSpecificPart();
        String[] numberParts = number.split("[@;:]");

        if (numberParts.length == 0) {
            logger.error("getNumberFromUri: invalid uri=" + uriString);
            return null;
        }
        return numberParts[0];
    }

    private String getUriForPublication() {
        TelephonyManager teleMgr = (TelephonyManager) mContext.getSystemService(
                Context.TELEPHONY_SERVICE);
        if (teleMgr == null) {
            logger.error("getUriForPublication, teleMgr = null");
            return null;
        }
        teleMgr = teleMgr.createForSubscriptionId(mAssociatedSubscription);

        String myNumUri = null;
        String myDomain = teleMgr.getIsimDomain();
        logger.debug("myDomain=" + myDomain);
        if (myDomain != null && !TextUtils.isEmpty(myDomain)) {
            String[] impu = teleMgr.getIsimImpu();

            if(impu !=null){
                for(int i=0; i<impu.length; i++){
                    logger.debug("impu[" + i + "]=" + impu[i]);
                    if(impu[i] != null && impu[i].startsWith("sip:") &&
                            impu[i].endsWith(myDomain)){
                        myNumUri = impu[i];
                        break;
                    }
                }
            }
        }
        String myNumber = null;
        if (myNumUri != null) {
            myNumber = Uri.parse(myNumUri).getSchemeSpecificPart();
        }

        if (myNumber == null) {
            myNumber = ContactNumberUtils.getDefault().format(teleMgr.getLine1Number());
            if (myDomain != null && !TextUtils.isEmpty(myDomain)) {
                myNumUri = "sip:" + myNumber + "@" + myDomain;
            } else {
                myNumUri = "tel:" + myNumber;
            }
        }
        return myNumUri;
    }

    private PendingIntent mRetryAlarmIntent = null;
    public static final String ACTION_RETRY_PUBLISH_ALARM =
            "com.android.service.ims.presence.retry.publish";
    private AlarmManager mAlarmManager = null;
    boolean mCancelRetry = true;
    boolean mPendingRetry = false;

    private void scheduleRetryPublish(long timeSpan) {
        logger.print("timeSpan=" + timeSpan +
                " mPendingRetry=" + mPendingRetry +
                " mCancelRetry=" + mCancelRetry);

        // avoid duplicated retry.
        if(mPendingRetry) {
            logger.debug("There was a retry already");
            return;
        }
        mPendingRetry = true;
        mCancelRetry = false;

        Intent intent = new Intent(ACTION_RETRY_PUBLISH_ALARM);
        intent.setPackage(mContext.getPackageName());
        mRetryAlarmIntent = PendingIntent.getBroadcast(mContext, 0, intent,
                PendingIntent.FLAG_UPDATE_CURRENT);

        if(mAlarmManager == null) {
            mAlarmManager = (AlarmManager) mContext.getSystemService(Context.ALARM_SERVICE);
        }

        mAlarmManager.setExact(AlarmManager.ELAPSED_REALTIME_WAKEUP,
                SystemClock.elapsedRealtime() + timeSpan, mRetryAlarmIntent);
    }

    public void retryPublish() {
        logger.print("mCancelRetry=" + mCancelRetry);
        mPendingRetry = false;

        // Need some time to cancel it (1 minute for longest)
        // Don't do it if it was canceled already.
        if(mCancelRetry) {
            return;
        }

        requestLocalPublish(PublishType.PRES_PUBLISH_TRIGGER_RETRY);
    }

    public void onSipResponse(int requestId, int responseCode, String reasonPhrase) {
        logger.print( "Publish response code = " + responseCode
                +"Publish response reason phrase = " + reasonPhrase);

        synchronized(mSyncObj) {
            mPublishedRequest = mPublishingRequest;
            mPublishingRequest = null;
        }

        if (isInConfigList(responseCode, reasonPhrase,
                mConfigVolteProvisionErrorOnPublishResponse)) {
            logger.print("volte provision error. sipCode=" + responseCode + " phrase=" +
                    reasonPhrase);
            setPublishState(PUBLISH_STATE_VOLTE_PROVISION_ERROR);
            mDonotRetryUntilPowerCycle = true;

            notifyDm();

            return;
        }

        if (isInConfigList(responseCode, reasonPhrase, mConfigRcsProvisionErrorOnPublishResponse)) {
            logger.print("rcs provision error.sipCode=" + responseCode + " phrase=" + reasonPhrase);
            setPublishState(PUBLISH_STATE_RCS_PROVISION_ERROR);
            mDonotRetryUntilPowerCycle = true;

            return;
        }

        switch (responseCode) {
            case 999:
                logger.debug("Publish ignored - No capability change");
                break;
            case 200:
                setPublishState(PUBLISH_STATE_200_OK);
                if(mSubscriber != null) {
                    mSubscriber.retryToGetAvailability();
                }
                break;

            case 408:
                setPublishState(PUBLISH_STATE_REQUEST_TIMEOUT);
                break;

            default: // Generic Failure
                if ((responseCode < 100) || (responseCode > 699)) {
                    logger.debug("Ignore internal response code, sipCode=" + responseCode);
                    // internal error
                    //  0- PERMANENT ERROR: UI should not retry immediately
                    //  888- TEMP ERROR:  UI Can retry immediately
                    //  999- NO CHANGE: No Publish needs to be sent
                    if(responseCode == 888) {
                        // retry per 2 minutes
                        scheduleRetryPublish(120000);
                    } else {
                        logger.debug("Ignore internal response code, sipCode=" + responseCode);
                    }
                } else {
                    logger.debug( "Generic Failure");
                    setPublishState(PUBLISH_STATE_OTHER_ERROR);

                    if ((responseCode>=400) && (responseCode <= 699)) {
                        // 4xx/5xx/6xx, No retry, no impact on subsequent publish
                        logger.debug( "No Retry in OEM");
                    }
                }
                break;
        }

        // Suppose the request ID had been set when IQPresListener_CMDStatus
        Task task = TaskManager.getDefault().getTaskByRequestId(requestId);
        if(task != null){
            task.mSipResponseCode = responseCode;
            task.mSipReasonPhrase = reasonPhrase;
        }

        handleCallback(task, getPublishState(), false);
    }

    private static boolean isTtyEnabled(int mode) {
        return TelecomManager.TTY_MODE_OFF != mode;
    }

    public void onFeatureCapabilityChanged(int networkType,
            MmTelFeature.MmTelCapabilities capabilities) {
        logger.debug("onFeatureCapabilityChanged networkType=" + networkType
                +", capabilities=" + capabilities);

        Thread thread = new Thread(() -> onFeatureCapabilityChangedInternal(networkType,
                capabilities), "onFeatureCapabilityChangedInternal thread");

        thread.start();
    }

    synchronized private void onFeatureCapabilityChangedInternal(int networkType,
            MmTelFeature.MmTelCapabilities capabilities) {
        boolean oldIsVolteAvailable = mIsVolteAvailable;
        boolean oldIsVtAvailable = mIsVtAvailable;
        boolean oldIsVoWifiAvailable = mIsVoWifiAvailable;
        boolean oldIsViWifiAvailable = mIsViWifiAvailable;

        mIsVolteAvailable = (networkType == AccessNetworkConstants.TRANSPORT_TYPE_WWAN) &&
                capabilities.isCapable(MmTelFeature.MmTelCapabilities.CAPABILITY_TYPE_VOICE);

        mIsVoWifiAvailable = (networkType == AccessNetworkConstants.TRANSPORT_TYPE_WLAN) &&
                capabilities.isCapable(MmTelFeature.MmTelCapabilities.CAPABILITY_TYPE_VOICE);

        mIsVtAvailable = (networkType == AccessNetworkConstants.TRANSPORT_TYPE_WWAN) &&
                capabilities.isCapable(MmTelFeature.MmTelCapabilities.CAPABILITY_TYPE_VIDEO);

        mIsViWifiAvailable = (networkType == AccessNetworkConstants.TRANSPORT_TYPE_WLAN) &&
                capabilities.isCapable(MmTelFeature.MmTelCapabilities.CAPABILITY_TYPE_VIDEO);

        logger.print("mIsVolteAvailable=" + mIsVolteAvailable +
                " mIsVoWifiAvailable=" + mIsVoWifiAvailable +
                " mIsVtAvailable=" + mIsVtAvailable +
                " mIsViWifiAvailable=" + mIsViWifiAvailable +
                " oldIsVolteAvailable=" + oldIsVolteAvailable +
                " oldIsVoWifiAvailable=" + oldIsVoWifiAvailable +
                " oldIsVtAvailable=" + oldIsVtAvailable +
                " oldIsViWifiAvailable=" + oldIsViWifiAvailable);

        if(oldIsVolteAvailable != mIsVolteAvailable ||
                oldIsVtAvailable != mIsVtAvailable ||
                oldIsVoWifiAvailable != mIsVoWifiAvailable ||
                oldIsViWifiAvailable != mIsViWifiAvailable) {
            if(mGotTriggerFromStack) {
                if((Settings.Global.getInt(mContext.getContentResolver(),
                        Settings.Global.AIRPLANE_MODE_ON, 0) != 0) && !mIsVoWifiAvailable &&
                        !mIsViWifiAvailable) {
                    logger.print("Airplane mode was on and no vowifi and viwifi." +
                        " Don't need publish. Stack will unpublish");
                    return;
                }

                if(isOnIWLAN()) {
                    // will check duplicated PUBLISH in requestPublication by invokePublish
                    requestLocalPublish(PublishType.
                            PRES_PUBLISH_TRIGGER_FEATURE_AVAILABILITY_CHANGED);
                }
            } else {
                mHasCachedTrigger = true;
            }
        }
    }

    private boolean isOnLTE() {
        TelephonyManager teleMgr = (TelephonyManager) mContext.getSystemService(
                Context.TELEPHONY_SERVICE);
            int networkType = teleMgr.getDataNetworkType();
            logger.debug("mMovedToLTE=" + mMovedToLTE + " networkType=" + networkType);

            // Had reported LTE by trigger and still have DATA.
            return mMovedToLTE && (networkType != TelephonyManager.NETWORK_TYPE_UNKNOWN);
    }

    private boolean isOnIWLAN() {
        TelephonyManager teleMgr = (TelephonyManager) mContext.getSystemService(
                Context.TELEPHONY_SERVICE);
            int networkType = teleMgr.getDataNetworkType();
            logger.debug("mMovedToIWLAN=" + mMovedToIWLAN + " networkType=" + networkType);

            // Had reported IWLAN by trigger and still have DATA.
            return mMovedToIWLAN && (networkType != TelephonyManager.NETWORK_TYPE_UNKNOWN);
    }
}