diff options
Diffstat (limited to 'java/com/android/dialer/shortcuts/DynamicShortcuts.java')
-rw-r--r-- | java/com/android/dialer/shortcuts/DynamicShortcuts.java | 243 |
1 files changed, 243 insertions, 0 deletions
diff --git a/java/com/android/dialer/shortcuts/DynamicShortcuts.java b/java/com/android/dialer/shortcuts/DynamicShortcuts.java new file mode 100644 index 000000000..be9e088e1 --- /dev/null +++ b/java/com/android/dialer/shortcuts/DynamicShortcuts.java @@ -0,0 +1,243 @@ +/* + * Copyright (C) 2016 The Android Open Source Project + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package com.android.dialer.shortcuts; + +import android.Manifest; +import android.annotation.TargetApi; +import android.content.Context; +import android.content.pm.PackageManager; +import android.content.pm.ShortcutInfo; +import android.content.pm.ShortcutManager; +import android.os.Build.VERSION_CODES; +import android.support.annotation.NonNull; +import android.support.annotation.WorkerThread; +import android.support.v4.content.ContextCompat; +import android.util.ArrayMap; +import com.android.contacts.common.list.ContactEntry; +import com.android.dialer.common.Assert; +import com.android.dialer.common.LogUtil; +import java.util.ArrayList; +import java.util.List; +import java.util.Map; +import java.util.Map.Entry; + +/** + * Handles refreshing of dialer dynamic shortcuts. + * + * <p>Dynamic shortcuts are the list of shortcuts which is accessible by tapping and holding the + * dialer launcher icon from the app drawer or a home screen. + * + * <p>Dynamic shortcuts are refreshed whenever the dialtacts activity detects changes to favorites + * tiles. This class compares the newly updated favorites tiles to the existing list of (previously + * published) dynamic shortcuts to compute a delta, which consists of lists of shortcuts which need + * to be updated, added, or deleted. + * + * <p>Dynamic shortcuts should mirror (in order) the contacts displayed in the "tiled favorites" tab + * of the dialer application. When selecting a dynamic shortcut, the behavior should be the same as + * if the user had tapped on the contact from the tiled favorites tab. Specifically, if the user has + * more than one phone number, a number picker should be displayed, and otherwise the contact should + * be called directly. + * + * <p>Note that an icon change by itself does not trigger a shortcut update, because it is not + * possible to detect an icon update and we don't want to constantly force update icons, because + * that is an expensive operation which requires storage I/O. + * + * <p>However, the job scheduler uses {@link #updateIcons()} to makes sure icons are forcefully + * updated periodically (about once a day). + * + */ +@TargetApi(VERSION_CODES.N_MR1) // Shortcuts introduced in N MR1 +final class DynamicShortcuts { + + private static final int MAX_DYNAMIC_SHORTCUTS = 3; + + private static class Delta { + + final Map<String, DialerShortcut> shortcutsToUpdateById = new ArrayMap<>(); + final List<String> shortcutIdsToRemove = new ArrayList<>(); + final Map<String, DialerShortcut> shortcutsToAddById = new ArrayMap<>(); + } + + private final Context context; + private final ShortcutInfoFactory shortcutInfoFactory; + + DynamicShortcuts(@NonNull Context context, IconFactory iconFactory) { + this.context = context; + this.shortcutInfoFactory = new ShortcutInfoFactory(context, iconFactory); + } + + /** + * Performs a "complete refresh" of dynamic shortcuts. This is done by comparing the provided + * contact information with the existing dynamic shortcuts in order to compute a delta which + * contains shortcuts which should be added, updated, or removed. + * + * <p>If the delta is non-empty, it is applied by making appropriate calls to the {@link + * ShortcutManager} system service. + * + * <p>This is a slow blocking call which performs file I/O and should not be performed on the main + * thread. + */ + @WorkerThread + public void refresh(List<ContactEntry> contacts) { + Assert.isWorkerThread(); + LogUtil.enterBlock("DynamicShortcuts.refresh"); + + ShortcutManager shortcutManager = getShortcutManager(context); + + if (ContextCompat.checkSelfPermission(context, Manifest.permission.READ_CONTACTS) + != PackageManager.PERMISSION_GRANTED) { + LogUtil.i("DynamicShortcuts.refresh", "no contact permissions"); + shortcutManager.removeAllDynamicShortcuts(); + return; + } + + // Fill the available shortcuts with dynamic shortcuts up to a maximum of 3 dynamic shortcuts. + int numDynamicShortcutsToCreate = + Math.min( + MAX_DYNAMIC_SHORTCUTS, + shortcutManager.getMaxShortcutCountPerActivity() + - shortcutManager.getManifestShortcuts().size()); + + Map<String, DialerShortcut> newDynamicShortcutsById = + new ArrayMap<>(numDynamicShortcutsToCreate); + int rank = 0; + for (ContactEntry entry : contacts) { + if (newDynamicShortcutsById.size() >= numDynamicShortcutsToCreate) { + break; + } + + DialerShortcut shortcut = + DialerShortcut.builder() + .setContactId(entry.id) + .setLookupKey(entry.lookupKey) + .setDisplayName(entry.getPreferredDisplayName()) + .setRank(rank++) + .build(); + newDynamicShortcutsById.put(shortcut.getShortcutId(), shortcut); + } + + List<ShortcutInfo> oldDynamicShortcuts = new ArrayList<>(shortcutManager.getDynamicShortcuts()); + Delta delta = computeDelta(oldDynamicShortcuts, newDynamicShortcutsById); + applyDelta(delta); + } + + /** + * Forces an update of all dynamic shortcut icons. This should only be done from job scheduler as + * updating icons requires storage I/O. + */ + @WorkerThread + void updateIcons() { + Assert.isWorkerThread(); + LogUtil.enterBlock("DynamicShortcuts.updateIcons"); + + if (ContextCompat.checkSelfPermission(context, Manifest.permission.READ_CONTACTS) + != PackageManager.PERMISSION_GRANTED) { + LogUtil.i("DynamicShortcuts.updateIcons", "no contact permissions"); + return; + } + + ShortcutManager shortcutManager = getShortcutManager(context); + + int maxDynamicShortcutsToCreate = + shortcutManager.getMaxShortcutCountPerActivity() + - shortcutManager.getManifestShortcuts().size(); + int count = 0; + + List<ShortcutInfo> newShortcuts = new ArrayList<>(); + for (ShortcutInfo oldInfo : shortcutManager.getDynamicShortcuts()) { + newShortcuts.add(shortcutInfoFactory.withUpdatedIcon(oldInfo)); + if (++count >= maxDynamicShortcutsToCreate) { + break; + } + } + LogUtil.i("DynamicShortcuts.updateIcons", "updating %d shortcut icons", newShortcuts.size()); + shortcutManager.setDynamicShortcuts(newShortcuts); + } + + @NonNull + private Delta computeDelta( + @NonNull List<ShortcutInfo> oldDynamicShortcuts, + @NonNull Map<String, DialerShortcut> newDynamicShortcutsById) { + Delta delta = new Delta(); + if (oldDynamicShortcuts.isEmpty()) { + delta.shortcutsToAddById.putAll(newDynamicShortcutsById); + return delta; + } + + for (ShortcutInfo oldInfo : oldDynamicShortcuts) { + // Check to see if the new shortcut list contains the existing shortcut. + DialerShortcut newShortcut = newDynamicShortcutsById.get(oldInfo.getId()); + if (newShortcut != null) { + if (newShortcut.needsUpdate(oldInfo)) { + LogUtil.i("DynamicShortcuts.computeDelta", "contact updated"); + delta.shortcutsToUpdateById.put(oldInfo.getId(), newShortcut); + } // else the shortcut hasn't changed, nothing to do to it + } else { + // The old shortcut is not in the new shortcut list, remove it. + LogUtil.i("DynamicShortcuts.computeDelta", "contact removed"); + delta.shortcutIdsToRemove.add(oldInfo.getId()); + } + } + + // Add any new shortcuts that were not in the old shortcuts. + for (Entry<String, DialerShortcut> entry : newDynamicShortcutsById.entrySet()) { + String newId = entry.getKey(); + DialerShortcut newShortcut = entry.getValue(); + if (!containsShortcut(oldDynamicShortcuts, newId)) { + // The new shortcut was not found in the old shortcut list, so add it. + LogUtil.i("DynamicShortcuts.computeDelta", "contact added"); + delta.shortcutsToAddById.put(newId, newShortcut); + } + } + return delta; + } + + private void applyDelta(@NonNull Delta delta) { + ShortcutManager shortcutManager = getShortcutManager(context); + // Must perform remove before performing add to avoid adding more than supported by system. + if (!delta.shortcutIdsToRemove.isEmpty()) { + shortcutManager.removeDynamicShortcuts(delta.shortcutIdsToRemove); + } + if (!delta.shortcutsToUpdateById.isEmpty()) { + // Note: This may update pinned shortcuts as well. Pinned shortcuts which are also dynamic + // are not updated by the pinned shortcut logic. The reason that they are updated here + // instead of in the pinned shortcut logic is because setRank is required and only available + // here. + shortcutManager.updateShortcuts( + shortcutInfoFactory.buildShortcutInfos(delta.shortcutsToUpdateById)); + } + if (!delta.shortcutsToAddById.isEmpty()) { + shortcutManager.addDynamicShortcuts( + shortcutInfoFactory.buildShortcutInfos(delta.shortcutsToAddById)); + } + } + + private boolean containsShortcut( + @NonNull List<ShortcutInfo> shortcutInfos, @NonNull String shortcutId) { + for (ShortcutInfo oldInfo : shortcutInfos) { + if (oldInfo.getId().equals(shortcutId)) { + return true; + } + } + return false; + } + + private static ShortcutManager getShortcutManager(Context context) { + //noinspection WrongConstant + return (ShortcutManager) context.getSystemService(Context.SHORTCUT_SERVICE); + } +} |