| /* |
| * 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.app.AlarmManager; |
| import android.app.PendingIntent; |
| import android.content.BroadcastReceiver; |
| import android.content.Context; |
| import android.content.Intent; |
| import android.content.IntentFilter; |
| import android.database.Cursor; |
| import android.net.Uri; |
| import android.os.Handler; |
| import android.os.HandlerThread; |
| import android.os.Message; |
| import android.os.Process; |
| import android.os.SystemClock; |
| import android.telephony.PhoneNumberUtils; |
| import android.telephony.SubscriptionManager; |
| import android.telephony.TelephonyManager; |
| import android.text.format.TimeMigrationUtils; |
| import android.text.TextUtils; |
| import android.content.ComponentName; |
| |
| import com.android.ims.ImsConfig; |
| import com.android.ims.ImsException; |
| import com.android.ims.ImsManager; |
| import com.android.internal.telephony.IccCardConstants; |
| import com.android.internal.telephony.TelephonyIntents; |
| |
| import com.android.ims.RcsException; |
| import com.android.ims.RcsManager; |
| import com.android.ims.RcsManager.ResultCode; |
| import com.android.ims.RcsPresence; |
| import com.android.ims.RcsPresence.PublishState; |
| import com.android.ims.RcsPresenceInfo; |
| import com.android.ims.internal.ContactNumberUtils; |
| import com.android.ims.internal.Logger; |
| |
| import java.util.ArrayList; |
| import java.util.List; |
| |
| public class CapabilityPolling { |
| private Logger logger = Logger.getLogger(this.getClass().getName()); |
| private final Context mContext; |
| |
| public static final String ACTION_PERIODICAL_DISCOVERY_ALARM = |
| "com.android.service.ims.presence.periodical_capability_discovery"; |
| private PendingIntent mDiscoveryAlarmIntent = null; |
| |
| public static final int ACTION_POLLING_NORMAL = 0; |
| public static final int ACTION_POLLING_NEW_CONTACTS = 1; |
| |
| private long mCapabilityPollInterval = 604800000L; |
| private long mMinCapabilityPollInterval = 60480000L; |
| private long mCapabilityCacheExpiration = 7776000000L; |
| private long mNextPollingTimeStamp = 0L; |
| private final Object mScheduleSyncObj = new Object(); |
| |
| private boolean mInitialized = false; |
| private AlarmManager mAlarmManager = null; |
| private EABContactManager mEABContactManager = null; |
| private boolean mStackAvailable = false; |
| private int mPublished = -1; |
| private int mProvisioned = -1; |
| |
| private HandlerThread mDiscoveryThread; |
| private Handler mDiscoveryHandler; |
| |
| private final BroadcastReceiver mReceiver = new BroadcastReceiver() { |
| @Override |
| public void onReceive(Context context, Intent intent) { |
| logger.info("onReceive(), intent: " + intent + |
| ", context: " + context); |
| |
| String action = intent.getAction(); |
| if (RcsManager.ACTION_RCS_SERVICE_AVAILABLE.equals(action)) { |
| enqueueServiceStatusChanged(true); |
| } else if (RcsManager.ACTION_RCS_SERVICE_UNAVAILABLE.equals(action)) { |
| enqueueServiceStatusChanged(false); |
| } else if (RcsManager.ACTION_RCS_SERVICE_DIED.equals(action)) { |
| logger.warn("No handler for this intent: " + action); |
| } else if (RcsPresence.ACTION_PUBLISH_STATE_CHANGED.equals(action)) { |
| int state = intent.getIntExtra( |
| RcsPresence.EXTRA_PUBLISH_STATE, |
| RcsPresence.PublishState.PUBLISH_STATE_NOT_PUBLISHED); |
| enqueuePublishStateChanged(state); |
| } else if (ImsConfig.ACTION_IMS_CONFIG_CHANGED.equals(action)) { |
| int item = intent.getIntExtra(ImsConfig.EXTRA_CHANGED_ITEM, -1); |
| if ((ImsConfig.ConfigConstants.CAPABILITIES_POLL_INTERVAL == item) || |
| (ImsConfig.ConfigConstants.CAPABILITIES_CACHE_EXPIRATION == item)) { |
| enqueueSettingsChanged(); |
| } else if ((ImsConfig.ConfigConstants.VLT_SETTING_ENABLED == item) || |
| (ImsConfig.ConfigConstants.LVC_SETTING_ENABLED == item) || |
| (ImsConfig.ConfigConstants.EAB_SETTING_ENABLED == item)) { |
| enqueueProvisionStateChanged(); |
| } |
| } else if(TelephonyIntents.ACTION_SIM_STATE_CHANGED.equalsIgnoreCase(action)) { |
| String stateExtra = intent.getStringExtra( |
| IccCardConstants.INTENT_KEY_ICC_STATE); |
| logger.print("SIM_STATE_CHANGED: " + stateExtra); |
| if (IccCardConstants.INTENT_VALUE_ICC_LOADED.equalsIgnoreCase(stateExtra)) { |
| enqueueSimLoaded(); |
| } |
| } else { |
| logger.debug("No interest in this intent: " + action); |
| } |
| } |
| }; |
| |
| private static CapabilityPolling sInstance = null; |
| public static synchronized CapabilityPolling getInstance(Context context) { |
| if ((sInstance == null) && (context != null)) { |
| sInstance = new CapabilityPolling(context); |
| } |
| |
| return sInstance; |
| } |
| |
| private CapabilityPolling(Context context) { |
| mContext = context; |
| |
| ContactNumberUtils.getDefault().setContext(mContext); |
| PresencePreferences.getInstance().setContext(mContext); |
| |
| mAlarmManager = (AlarmManager) mContext.getSystemService(Context.ALARM_SERVICE); |
| mEABContactManager = new EABContactManager(mContext.getContentResolver(), |
| mContext.getPackageName()); |
| |
| setRcsTestMode(PresencePreferences.getInstance().getRcsTestMode()); |
| logger.debug("CapabilityPolling is created."); |
| } |
| |
| public void setRcsTestMode(boolean test) { |
| logger.setRcsTestMode(test); |
| |
| PresencePreferences pref = PresencePreferences.getInstance(); |
| if (pref != null) { |
| if (pref.getRcsTestMode() != test) { |
| pref.setRcsTestMode(test); |
| } |
| } |
| } |
| |
| private void initialise() { |
| if (mInitialized) { |
| return; |
| } |
| |
| PresenceSetting.init(mContext); |
| long capabilityPollInterval = PresenceSetting.getCapabilityPollInterval(); |
| logger.print("getCapabilityPollInterval: " + capabilityPollInterval); |
| if (capabilityPollInterval == -1) { |
| capabilityPollInterval = mContext.getResources().getInteger( |
| R.integer.capability_poll_interval); |
| } |
| if (capabilityPollInterval < 10) { |
| capabilityPollInterval = 10; |
| } |
| |
| long capabilityCacheExpiration = PresenceSetting.getCapabilityCacheExpiration(); |
| logger.print("getCapabilityCacheExpiration: " + capabilityCacheExpiration); |
| if (capabilityCacheExpiration == -1) { |
| capabilityCacheExpiration = mContext.getResources().getInteger( |
| R.integer.capability_cache_expiration); |
| } |
| if (capabilityCacheExpiration < 10) { |
| capabilityCacheExpiration = 10; |
| } |
| |
| int publishTimer = PresenceSetting.getPublishTimer(); |
| logger.print("getPublishTimer: " + publishTimer); |
| int publishTimerExtended = PresenceSetting.getPublishTimerExtended(); |
| logger.print("getPublishTimerExtended: " + publishTimerExtended); |
| int maxEntriesInRequest = PresenceSetting.getMaxNumberOfEntriesInRequestContainedList(); |
| logger.print("getMaxNumberOfEntriesInRequestContainedList: " + maxEntriesInRequest); |
| if ((capabilityPollInterval <= 30 * 60) || // default: 7 days |
| (capabilityCacheExpiration <= 60 * 60) || // default: 90 days |
| (maxEntriesInRequest <= 20) || // default: 100 |
| (publishTimer <= 10 * 60) || // default: 20 minutes |
| (publishTimerExtended <= 20 * 60)) { // default: 1 day |
| setRcsTestMode(true); |
| } |
| |
| if (capabilityCacheExpiration < capabilityPollInterval) { |
| capabilityPollInterval = capabilityCacheExpiration; |
| } |
| |
| mCapabilityPollInterval = capabilityPollInterval * 1000; |
| mMinCapabilityPollInterval = mCapabilityPollInterval / 10; |
| logger.info("mCapabilityPollInterval: " + mCapabilityPollInterval + |
| ", mMinCapabilityPollInterval: " + mMinCapabilityPollInterval); |
| |
| mCapabilityCacheExpiration = capabilityCacheExpiration * 1000; |
| logger.info("mCapabilityCacheExpiration: " + mCapabilityCacheExpiration); |
| |
| mInitialized = true; |
| } |
| |
| public void start() { |
| mDiscoveryThread = new HandlerThread("Presence-DiscoveryThread"); |
| mDiscoveryThread.start(); |
| mDiscoveryHandler = new Handler(mDiscoveryThread.getLooper(), mDiscoveryCallback); |
| |
| registerForBroadcasts(); |
| |
| if (isPollingReady()) { |
| schedulePolling(5 * 1000, ACTION_POLLING_NORMAL); |
| } |
| } |
| |
| public void stop() { |
| cancelDiscoveryAlarm(); |
| clearPollingTasks(); |
| mContext.unregisterReceiver(mReceiver); |
| mDiscoveryThread.quit(); |
| } |
| |
| private void registerForBroadcasts() { |
| IntentFilter intentFilter = new IntentFilter(); |
| intentFilter.addAction(RcsManager.ACTION_RCS_SERVICE_AVAILABLE); |
| intentFilter.addAction(RcsManager.ACTION_RCS_SERVICE_UNAVAILABLE); |
| intentFilter.addAction(RcsManager.ACTION_RCS_SERVICE_DIED); |
| intentFilter.addAction(RcsPresence.ACTION_PUBLISH_STATE_CHANGED); |
| intentFilter.addAction(ImsConfig.ACTION_IMS_CONFIG_CHANGED); |
| intentFilter.addAction(TelephonyIntents.ACTION_SIM_STATE_CHANGED); |
| mContext.registerReceiver(mReceiver, intentFilter); |
| } |
| |
| private boolean isPollingReady() { |
| if (mPublished == -1) { |
| RcsManager rcsManager = RcsManager.getInstance(mContext, 0); |
| if (rcsManager != null) { |
| mStackAvailable = rcsManager.isRcsServiceAvailable(); |
| logger.print("isPollingReady, mStackAvailable: " + mStackAvailable); |
| try { |
| RcsPresence rcsPresence = rcsManager.getRcsPresenceInterface(); |
| if (rcsPresence != null) { |
| int state = rcsPresence.getPublishState(); |
| mPublished = (PublishState.PUBLISH_STATE_200_OK == state) ? 1 : 0; |
| logger.print("isPollingReady, mPublished: " + mPublished); |
| } |
| } catch (RcsException ex) { |
| logger.warn("RcsPresence.getPublishState failed, exception: " + ex); |
| mPublished = -1; |
| } |
| } |
| } |
| |
| if (mProvisioned == -1) { |
| ImsManager imsManager = ImsManager.getInstance(mContext, |
| SubscriptionManager.getDefaultVoicePhoneId()); |
| if (imsManager != null) { |
| try { |
| ImsConfig imsConfig = imsManager.getConfigInterface(); |
| if (imsConfig != null) { |
| mProvisioned = imsConfig.getProvisionedValue( |
| ImsConfig.ConfigConstants.EAB_SETTING_ENABLED); |
| logger.print("isPollingReady, mProvisioned: " + mProvisioned); |
| } |
| } catch (ImsException ex) { |
| logger.warn("ImsConfig.getEabProvisioned failed, exception: " + ex); |
| mProvisioned = -1; |
| } |
| } |
| } |
| logger.print("isPollingReady, mProvisioned: " + mProvisioned + |
| ", mStackAvailable: " + mStackAvailable + ", mPublished: " + mPublished); |
| return mStackAvailable && (mPublished == 1) && (mProvisioned == 1); |
| } |
| |
| private void serviceStatusChanged(boolean enabled) { |
| logger.print("Enter serviceStatusChanged: " + enabled); |
| mStackAvailable = enabled; |
| |
| if (isPollingReady()) { |
| schedulePolling(0, ACTION_POLLING_NORMAL); |
| } else { |
| cancelDiscoveryAlarm(); |
| clearPollingTasks(); |
| } |
| } |
| |
| private void publishStateChanged(int state) { |
| logger.print("Enter publishStateChanged: " + state); |
| mPublished = (PublishState.PUBLISH_STATE_200_OK == state) ? 1 : 0; |
| if (mPublished == 1) { |
| PresencePreferences pref = PresencePreferences.getInstance(); |
| if (pref != null) { |
| String mdn_old = pref.getLine1Number(); |
| String subscriberId_old = pref.getSubscriberId(); |
| if (TextUtils.isEmpty(mdn_old) && TextUtils.isEmpty(subscriberId_old)) { |
| String mdn = getLine1Number(); |
| pref.setLine1Number(mdn); |
| String subscriberId = getSubscriberId(); |
| pref.setSubscriberId(subscriberId); |
| } |
| } |
| } |
| |
| if (isPollingReady()) { |
| schedulePolling(0, ACTION_POLLING_NORMAL); |
| } else { |
| cancelDiscoveryAlarm(); |
| clearPollingTasks(); |
| } |
| } |
| |
| private void provisionStateChanged() { |
| ImsManager imsManager = ImsManager.getInstance(mContext, |
| SubscriptionManager.getDefaultVoicePhoneId()); |
| if (imsManager == null) { |
| return; |
| } |
| |
| try { |
| ImsConfig imsConfig = imsManager.getConfigInterface(); |
| if (imsConfig == null) { |
| return; |
| } |
| boolean volteProvision = imsConfig.getProvisionedValue( |
| ImsConfig.ConfigConstants.VLT_SETTING_ENABLED) |
| == ImsConfig.FeatureValueConstants.ON; |
| boolean vtProvision = imsConfig.getProvisionedValue( |
| ImsConfig.ConfigConstants.LVC_SETTING_ENABLED) |
| == ImsConfig.FeatureValueConstants.ON; |
| boolean eabProvision = imsConfig.getProvisionedValue( |
| ImsConfig.ConfigConstants.EAB_SETTING_ENABLED) |
| == ImsConfig.FeatureValueConstants.ON; |
| logger.print("Provision state changed, VolteProvision: " |
| + volteProvision + ", vtProvision: " + vtProvision |
| + ", eabProvision: " + eabProvision); |
| |
| if ((mProvisioned == 1) && !eabProvision) { |
| logger.print("EAB Provision is disabled, clear all capabilities!"); |
| if (mEABContactManager != null) { |
| mEABContactManager.updateAllCapabilityToUnknown(); |
| } |
| } |
| mProvisioned = eabProvision ? 1 : 0; |
| } catch (ImsException ex) { |
| logger.warn("ImsConfig.getEabProvisioned failed, exception: " + ex); |
| mProvisioned = -1; |
| return; |
| } |
| |
| if (isPollingReady()) { |
| schedulePolling(0, ACTION_POLLING_NORMAL); |
| } else { |
| cancelDiscoveryAlarm(); |
| clearPollingTasks(); |
| } |
| } |
| |
| private void settingsChanged() { |
| logger.print("Enter settingsChanged."); |
| cancelDiscoveryAlarm(); |
| clearPollingTasks(); |
| mInitialized = false; |
| |
| if (isPollingReady()) { |
| schedulePolling(0, ACTION_POLLING_NORMAL); |
| } |
| } |
| |
| private void newContactAdded(String number) { |
| if (TextUtils.isEmpty(number)) { |
| return; |
| } |
| |
| EABContactManager.Request request = new EABContactManager.Request(number) |
| .setLastUpdatedTimeStamp(0); |
| int result = mEABContactManager.update(request); |
| if (result <= 0) { |
| return; |
| } |
| |
| if (isPollingReady()) { |
| schedulePolling(5 * 1000, ACTION_POLLING_NEW_CONTACTS); |
| } |
| } |
| |
| private void verifyPollingResult(int counts) { |
| if (isPollingReady()) { |
| PresencePreferences pref = PresencePreferences.getInstance(); |
| if ((pref != null) && pref.getRcsTestMode()) { |
| counts = 1; |
| } |
| long lm = (long)(1 << (counts - 1)); |
| schedulePolling(30 * 1000 * lm, ACTION_POLLING_NORMAL); |
| } |
| } |
| |
| public synchronized void schedulePolling(long msec, int type) { |
| logger.print("schedulePolling msec=" + msec + " type=" + type); |
| if (!isPollingReady()) { |
| logger.debug("Cancel the polling since the network is not ready"); |
| return; |
| } |
| |
| if (type == ACTION_POLLING_NEW_CONTACTS) { |
| cancelDiscoveryAlarm(); |
| } |
| |
| if (mNextPollingTimeStamp != 0L) { |
| long scheduled = mNextPollingTimeStamp - System.currentTimeMillis(); |
| if ((scheduled > 0) && (scheduled < msec)) { |
| logger.print("There has been a discovery scheduled at " |
| + getTimeString(mNextPollingTimeStamp)); |
| return; |
| } |
| } |
| |
| long nextTime = System.currentTimeMillis() + msec; |
| logger.print("A new discovery needs to be started in " + |
| (msec / 1000) + " seconds at " |
| + getTimeString(nextTime)); |
| |
| cancelDiscoveryAlarm(); |
| |
| if (msec <= 0) { |
| enqueueDiscovery(type); |
| return; |
| } |
| |
| Intent intent = new Intent(ACTION_PERIODICAL_DISCOVERY_ALARM); |
| intent.setClass(mContext, AlarmBroadcastReceiver.class); |
| intent.putExtra("pollingType", type); |
| |
| mDiscoveryAlarmIntent = PendingIntent.getBroadcast(mContext, 0, intent, |
| PendingIntent.FLAG_UPDATE_CURRENT); |
| mAlarmManager.setExact(AlarmManager.ELAPSED_REALTIME_WAKEUP, |
| SystemClock.elapsedRealtime() + msec, mDiscoveryAlarmIntent); |
| |
| mNextPollingTimeStamp = nextTime; |
| } |
| |
| private synchronized void doCapabilityDiscovery(int type) { |
| logger.print("doCapabilityDiscovery type=" + type); |
| if (!isPollingReady()) { |
| logger.debug("doCapabilityDiscovery isPollingReady=false"); |
| return; |
| } |
| |
| long delay = 0; |
| List<Contacts.Item> list = null; |
| |
| initialise(); |
| |
| mNextPollingTimeStamp = 0L; |
| Cursor cursor = null; |
| EABContactManager.Query baseQuery = new EABContactManager.Query() |
| .orderBy(EABContactManager.COLUMN_LAST_UPDATED_TIMESTAMP, |
| EABContactManager.Query.ORDER_ASCENDING); |
| try { |
| logger.debug("doCapabilityDiscovery.query:\n" + baseQuery); |
| cursor = mEABContactManager.query(baseQuery); |
| if (cursor == null) { |
| logger.print("Cursor is null, there is no database found."); |
| return; |
| } |
| int count = cursor.getCount(); |
| if (count == 0) { |
| logger.print("Cursor.getCount() is 0, there is no items found in db."); |
| return; |
| } |
| |
| list = new ArrayList<Contacts.Item>(); |
| list.clear(); |
| |
| long current = System.currentTimeMillis(); |
| for (cursor.moveToFirst(); !cursor.isAfterLast(); cursor.moveToNext()) { |
| long id = cursor.getLong(cursor.getColumnIndex(Contacts.Impl._ID)); |
| long last = cursor.getLong(cursor.getColumnIndex( |
| Contacts.Impl.CONTACT_LAST_UPDATED_TIMESTAMP)); |
| |
| Contacts.Item item = new Contacts.Item(id); |
| item.setLastUpdateTime(last); |
| item.setNumber(cursor.getString( |
| cursor.getColumnIndex(Contacts.Impl.CONTACT_NUMBER))); |
| item.setName(cursor.getString( |
| cursor.getColumnIndex(Contacts.Impl.CONTACT_NAME))); |
| item.setVolteTimestamp(cursor.getLong( |
| cursor.getColumnIndex(Contacts.Impl.VOLTE_CALL_CAPABILITY_TIMESTAMP))); |
| item.setVideoTimestamp(cursor.getLong( |
| cursor.getColumnIndex(Contacts.Impl.VIDEO_CALL_CAPABILITY_TIMESTAMP))); |
| |
| if ((current - last < 0) || |
| (current - last >= mCapabilityPollInterval - mMinCapabilityPollInterval)) { |
| logger.print("This item will be updated:\n" |
| + item); |
| if (item.isValid()) { |
| list.add(item); |
| } |
| } else { |
| logger.print("The first item which will be updated next time:\n" + item); |
| delay = randomCapabilityPollInterval() - (current - last); |
| if (delay > 0) { |
| break; |
| } |
| } |
| } |
| } catch (Exception ex) { |
| logger.warn("Exception in doCapabilityDiscovery: " + ex); |
| if (delay <= 0) { |
| delay = 5 * 60 * 1000; |
| } |
| } finally { |
| if (cursor != null) { |
| cursor.close(); |
| } |
| } |
| |
| if (delay <= 0) { |
| delay = randomCapabilityPollInterval(); |
| } |
| logger.print("Polling delay: " + delay); |
| schedulePolling(delay, ACTION_POLLING_NORMAL); |
| |
| updateObsoleteItems(); |
| |
| if ((list != null) && (list.size() > 0)) { |
| PollingsQueue queue = PollingsQueue.getInstance(mContext); |
| if (queue != null) { |
| queue.setCapabilityPolling(this); |
| queue.add(type, list); |
| } |
| } |
| } |
| |
| private long randomCapabilityPollInterval() { |
| double random = Math.random() * 0.2 + 0.9; |
| logger.print("The random for this time polling is: " + random); |
| random = random * mCapabilityPollInterval; |
| return (long)random; |
| } |
| |
| private void updateObsoleteItems() { |
| long current = System.currentTimeMillis(); |
| long last = current - mCapabilityCacheExpiration; |
| long last3year = current - 3 * 365 * 24 * 3600000L; |
| StringBuilder sb = new StringBuilder(); |
| sb.append("(("); |
| sb.append(Contacts.Impl.VOLTE_CALL_CAPABILITY_TIMESTAMP + "<='" + last + "'"); |
| sb.append(" OR "); |
| sb.append(Contacts.Impl.VIDEO_CALL_CAPABILITY_TIMESTAMP + "<='" + last + "'"); |
| sb.append(") AND "); |
| sb.append(Contacts.Impl.CONTACT_LAST_UPDATED_TIMESTAMP + ">='" + last3year + "'"); |
| sb.append(")"); |
| EABContactManager.Query baseQuery = new EABContactManager.Query() |
| .setFilterByTime(sb.toString()) |
| .orderBy(EABContactManager.COLUMN_ID, |
| EABContactManager.Query.ORDER_ASCENDING); |
| |
| Cursor cursor = null; |
| List<Contacts.Item> list = null; |
| try { |
| logger.debug("updateObsoleteItems.query:\n" + baseQuery); |
| cursor = mEABContactManager.query(baseQuery); |
| if (cursor == null) { |
| logger.print("Cursor is null, there is no database found."); |
| return; |
| } |
| int count = cursor.getCount(); |
| if (count == 0) { |
| logger.print("Cursor.getCount() is 0, there is no obsolete items found."); |
| return; |
| } |
| |
| list = new ArrayList<Contacts.Item>(); |
| list.clear(); |
| |
| for (cursor.moveToFirst(); !cursor.isAfterLast(); cursor.moveToNext()) { |
| long id = cursor.getLong(cursor.getColumnIndex(Contacts.Impl._ID)); |
| |
| Contacts.Item item = new Contacts.Item(id); |
| item.setLastUpdateTime(cursor.getLong( |
| cursor.getColumnIndex(Contacts.Impl.CONTACT_LAST_UPDATED_TIMESTAMP))); |
| item.setNumber(cursor.getString( |
| cursor.getColumnIndex(Contacts.Impl.CONTACT_NUMBER))); |
| item.setName(cursor.getString( |
| cursor.getColumnIndex(Contacts.Impl.CONTACT_NAME))); |
| item.setVolteTimestamp(cursor.getLong( |
| cursor.getColumnIndex(Contacts.Impl.VOLTE_CALL_CAPABILITY_TIMESTAMP))); |
| item.setVideoTimestamp(cursor.getLong( |
| cursor.getColumnIndex(Contacts.Impl.VIDEO_CALL_CAPABILITY_TIMESTAMP))); |
| logger.print("updateObsoleteItems, the obsolete item:\n" + item); |
| |
| if ((item.lastUpdateTime() > 0) && item.isValid()) { |
| list.add(item); |
| } |
| } |
| } catch (Exception ex) { |
| logger.warn("Exception in updateObsoleteItems: " + ex); |
| } finally { |
| if (cursor != null) { |
| cursor.close(); |
| } |
| } |
| |
| if ((list == null) || (list.size() <= 0)) { |
| return; |
| } |
| |
| for (Contacts.Item item : list) { |
| EABContactManager.Request request = new EABContactManager.Request(item.id()); |
| if (item.volteTimestamp() <= last) { |
| request.setVolteCallCapability(false); |
| request.setVolteCallCapabilityTimeStamp(current); |
| } |
| if (item.videoTimestamp() <= last) { |
| request.setVideoCallCapability(false); |
| request.setVideoCallCapabilityTimeStamp(current); |
| } |
| int result = mEABContactManager.update(request); |
| if (result <= 0) { |
| logger.print("Failed to update this request: " + request); |
| } |
| } |
| } |
| |
| private void cancelDiscoveryAlarm() { |
| if (mDiscoveryAlarmIntent != null) { |
| mAlarmManager.cancel(mDiscoveryAlarmIntent); |
| mDiscoveryAlarmIntent = null; |
| mNextPollingTimeStamp = 0L; |
| } |
| } |
| |
| private void clearPollingTasks() { |
| PollingsQueue queue = PollingsQueue.getInstance(null); |
| if (queue != null) { |
| queue.clear(); |
| } |
| } |
| |
| private String getTimeString(long time) { |
| if (time <= 0) { |
| time = System.currentTimeMillis(); |
| } |
| |
| String timeString = TimeMigrationUtils.formatMillisWithFixedFormat(time); |
| return String.format("%s.%s", timeString, time % 1000); |
| } |
| |
| private static final int MSG_CHECK_DISCOVERY = 1; |
| private static final int MSG_NEW_CONTACT_ADDED = 2; |
| private static final int MSG_SERVICE_STATUS_CHANGED = 3; |
| private static final int MSG_SETTINGS_CHANGED = 4; |
| private static final int MSG_PUBLISH_STATE_CHANGED = 5; |
| private static final int MSG_SIM_LOADED = 6; |
| private static final int MSG_PROVISION_STATE_CHANGED = 7; |
| private static final int MSG_VERIFY_POLLING_RESULT = 8; |
| |
| public void enqueueDiscovery(int type) { |
| mDiscoveryHandler.removeMessages(MSG_CHECK_DISCOVERY); |
| mDiscoveryHandler.obtainMessage(MSG_CHECK_DISCOVERY, type, -1).sendToTarget(); |
| } |
| |
| public void enqueueNewContact(String number) { |
| mDiscoveryHandler.obtainMessage(MSG_NEW_CONTACT_ADDED, number).sendToTarget(); |
| } |
| |
| private void enqueueServiceStatusChanged(boolean enabled) { |
| mDiscoveryHandler.removeMessages(MSG_SERVICE_STATUS_CHANGED); |
| mDiscoveryHandler.obtainMessage(MSG_SERVICE_STATUS_CHANGED, |
| enabled ? 1 : 0, -1).sendToTarget(); |
| } |
| |
| private void enqueuePublishStateChanged(int state) { |
| mDiscoveryHandler.removeMessages(MSG_PUBLISH_STATE_CHANGED); |
| mDiscoveryHandler.obtainMessage(MSG_PUBLISH_STATE_CHANGED, |
| state, -1).sendToTarget(); |
| } |
| |
| public void enqueueSettingsChanged() { |
| mDiscoveryHandler.removeMessages(MSG_SETTINGS_CHANGED); |
| mDiscoveryHandler.obtainMessage(MSG_SETTINGS_CHANGED).sendToTarget(); |
| } |
| |
| private void enqueueSimLoaded() { |
| mDiscoveryHandler.removeMessages(MSG_SIM_LOADED); |
| mDiscoveryHandler.obtainMessage(MSG_SIM_LOADED).sendToTarget(); |
| } |
| |
| private void enqueueProvisionStateChanged() { |
| mDiscoveryHandler.removeMessages(MSG_PROVISION_STATE_CHANGED); |
| mDiscoveryHandler.obtainMessage(MSG_PROVISION_STATE_CHANGED).sendToTarget(); |
| } |
| |
| public void enqueueVerifyPollingResult(int counts) { |
| mDiscoveryHandler.removeMessages(MSG_VERIFY_POLLING_RESULT); |
| mDiscoveryHandler.obtainMessage(MSG_VERIFY_POLLING_RESULT, counts, -1).sendToTarget(); |
| } |
| |
| private Handler.Callback mDiscoveryCallback = new Handler.Callback() { |
| @Override |
| public boolean handleMessage(Message msg) { |
| Process.setThreadPriority(Process.THREAD_PRIORITY_BACKGROUND); |
| |
| if (msg.what == MSG_CHECK_DISCOVERY) { |
| doCapabilityDiscovery(msg.arg1); |
| } else if (msg.what == MSG_NEW_CONTACT_ADDED) { |
| newContactAdded((String)msg.obj); |
| } else if (msg.what == MSG_SERVICE_STATUS_CHANGED) { |
| serviceStatusChanged(msg.arg1 == 1); |
| } else if (msg.what == MSG_PUBLISH_STATE_CHANGED) { |
| publishStateChanged(msg.arg1); |
| } else if (msg.what == MSG_SETTINGS_CHANGED) { |
| settingsChanged(); |
| } else if(msg.what == MSG_SIM_LOADED) { |
| onSimLoaded(); |
| } else if(msg.what == MSG_PROVISION_STATE_CHANGED) { |
| provisionStateChanged(); |
| } else if(msg.what == MSG_VERIFY_POLLING_RESULT) { |
| verifyPollingResult(msg.arg1); |
| } else { |
| } |
| |
| return true; |
| } |
| }; |
| |
| private void onSimLoaded() { |
| PresencePreferences pref = PresencePreferences.getInstance(); |
| if (pref == null) { |
| return; |
| } |
| |
| String mdn_old = pref.getLine1Number(); |
| if (TextUtils.isEmpty(mdn_old)) { |
| return; |
| } |
| String subscriberId_old = pref.getSubscriberId(); |
| if (TextUtils.isEmpty(subscriberId_old)) { |
| return; |
| } |
| |
| String mdn = getLine1Number(); |
| String subscriberId = getSubscriberId(); |
| if (TextUtils.isEmpty(mdn) && TextUtils.isEmpty(subscriberId)) { |
| return; |
| } |
| |
| boolean mdnMatched = false; |
| if (TextUtils.isEmpty(mdn) || PhoneNumberUtils.compare(mdn_old, mdn)) { |
| mdnMatched = true; |
| } |
| boolean subscriberIdMatched = false; |
| if (TextUtils.isEmpty(subscriberId) || subscriberId.equals(subscriberId_old)) { |
| subscriberIdMatched = true; |
| } |
| if (mdnMatched && subscriberIdMatched) { |
| return; |
| } |
| |
| logger.print("Remove presence cache for Sim card changed!"); |
| pref.setLine1Number(""); |
| pref.setSubscriberId(""); |
| |
| if (mEABContactManager != null) { |
| mEABContactManager.updateAllCapabilityToUnknown(); |
| } |
| } |
| |
| private static final int DEFAULT_SUBSCRIPTION = 1; |
| private String getLine1Number() { |
| if (mContext == null) { |
| return null; |
| } |
| |
| TelephonyManager telephony = (TelephonyManager) |
| mContext.getSystemService(Context.TELEPHONY_SERVICE); |
| if (telephony == null) { |
| return null; |
| } |
| |
| String mdn = null; |
| if (TelephonyManager.getDefault().isMultiSimEnabled()) { |
| int subId = SubscriptionManager.getDefaultDataSubscriptionId(); |
| if (!SubscriptionManager.isValidSubscriptionId(subId)) { |
| subId = DEFAULT_SUBSCRIPTION; |
| } |
| mdn = telephony.getLine1Number(subId); |
| } else { |
| mdn = telephony.getLine1Number(); |
| } |
| |
| if ((mdn == null) || (mdn.length() == 0) || mdn.startsWith("00000")) { |
| return null; |
| } |
| |
| logger.print("getLine1Number: " + mdn); |
| return mdn; |
| } |
| |
| private String getSubscriberId() { |
| if (mContext == null) { |
| return null; |
| } |
| |
| TelephonyManager telephony = (TelephonyManager) |
| mContext.getSystemService(Context.TELEPHONY_SERVICE); |
| if (telephony == null) { |
| return null; |
| } |
| |
| String subscriberId = null; |
| if (TelephonyManager.getDefault().isMultiSimEnabled()) { |
| int subId = SubscriptionManager.getDefaultDataSubscriptionId(); |
| if (!SubscriptionManager.isValidSubscriptionId(subId)) { |
| subId = DEFAULT_SUBSCRIPTION; |
| } |
| subscriberId = telephony.getSubscriberId(subId); |
| } else { |
| subscriberId = telephony.getSubscriberId(); |
| } |
| |
| logger.print("getSubscriberId: " + subscriberId); |
| return subscriberId; |
| } |
| } |
