| /* |
| * 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.RcsContactPresenceTuple; |
| import android.telephony.ims.RcsContactPresenceTuple.ServiceCapabilities; |
| import android.telephony.ims.RcsContactUceCapability; |
| import android.telephony.ims.RcsContactUceCapability.PresenceBuilder; |
| 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; |
| |
| private static final String SIP_SCHEME = "sip"; |
| private static final String TEL_SCHEME = "tel"; |
| private static final String DOMAIN_SEPARATOR = "@"; |
| |
| 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 myUri = getUriForPublication(); |
| if (myUri == null) { |
| logger.error("doPublish, myUri is null"); |
| return; |
| } |
| |
| boolean isVolteCapble = publishRequest.getVolteCapable(); |
| boolean isVtCapable = publishRequest.getVtCapable(); |
| RcsContactUceCapability presenceInfo = |
| getRcsContactUceCapability(myUri, isVolteCapble, isVtCapable); |
| |
| synchronized(mSyncObj) { |
| mPublishingRequest = publishRequest; |
| mPublishingRequest.setTimestamp(System.currentTimeMillis()); |
| } |
| |
| String myNumber = getNumberFromUri(myUri); |
| int taskId = TaskManager.getDefault().addPublishTask(myNumber); |
| logger.print("doPublish, uri=" + myUri + ", myNumber=" + myNumber + ", taskId=" + taskId); |
| int ret = presencePublisher.requestPublication(presenceInfo, myUri.toString(), 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 RcsContactUceCapability getRcsContactUceCapability(Uri contact, boolean isVolteCapable, |
| boolean isVtCapable) { |
| |
| ServiceCapabilities.Builder servCapsBuilder = new ServiceCapabilities.Builder( |
| isVolteCapable, isVtCapable); |
| servCapsBuilder.addSupportedDuplexMode(ServiceCapabilities.DUPLEX_MODE_FULL); |
| |
| RcsContactPresenceTuple.Builder tupleBuilder = new RcsContactPresenceTuple.Builder( |
| RcsContactPresenceTuple.TUPLE_BASIC_STATUS_OPEN, |
| RcsContactPresenceTuple.SERVICE_ID_MMTEL, "1.0"); |
| tupleBuilder.setContactUri(contact) |
| .setServiceCapabilities(servCapsBuilder.build()); |
| |
| PresenceBuilder presenceBuilder = new PresenceBuilder(contact, |
| RcsContactUceCapability.SOURCE_TYPE_CACHED, |
| RcsContactUceCapability.REQUEST_RESULT_FOUND); |
| presenceBuilder.addCapabilityTuple(tupleBuilder.build()); |
| |
| return presenceBuilder.build(); |
| } |
| |
| private String getNumberFromUri(Uri uri) { |
| if (uri == null) return null; |
| String number = uri.getSchemeSpecificPart(); |
| String[] numberParts = number.split("[@;:]"); |
| |
| if (numberParts.length == 0) { |
| logger.error("getNumberFromUri: invalid uri=" + uri); |
| return null; |
| } |
| return numberParts[0]; |
| } |
| |
| private Uri getUriForPublication() { |
| TelephonyManager teleMgr = (TelephonyManager) mContext.getSystemService( |
| Context.TELEPHONY_SERVICE); |
| if (teleMgr == null) { |
| logger.error("getUriForPublication, teleMgr = null"); |
| return null; |
| } |
| teleMgr = teleMgr.createForSubscriptionId(mAssociatedSubscription); |
| |
| Uri myNumUri = null; |
| String myDomain = teleMgr.getIsimDomain(); |
| logger.debug("myDomain=" + myDomain); |
| if (!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 (!TextUtils.isEmpty(impu[i])) { |
| Uri impuUri = Uri.parse(impu[i]); |
| if (SIP_SCHEME.equals(impuUri.getScheme()) && |
| impuUri.getSchemeSpecificPart().endsWith(myDomain)) { |
| myNumUri = impuUri; |
| logger.debug("impu[" + i + "] -> uri:" + myNumUri); |
| } |
| break; |
| } |
| } |
| } |
| } |
| |
| // Try to parse URI, if it works, we are good! |
| String myNumber = myNumUri == null ? null : myNumUri.getSchemeSpecificPart(); |
| if (!TextUtils.isEmpty(myNumber)) { |
| return myNumUri; |
| } |
| |
| // Fall back to trying to use the line 1 number to construct URI |
| myNumber = ContactNumberUtils.getDefault().format(teleMgr.getLine1Number()); |
| if (myNumber == null) return null; |
| if (!TextUtils.isEmpty(myDomain)) { |
| return Uri.fromParts(SIP_SCHEME, myNumber + DOMAIN_SEPARATOR + myDomain, null); |
| } else { |
| return Uri.fromParts(TEL_SCHEME, myNumber, null); |
| } |
| } |
| |
| 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|PendingIntent.FLAG_IMMUTABLE); |
| |
| 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); |
| } |
| } |
