ShortcutService.java revision 2e210c4d0f766e52ea4c087a1d54213c36a4e0ea 
1/*
2 * Copyright (C) 2016 The Android Open Source Project
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 *      http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
16package com.android.server.pm;
17
18import android.annotation.NonNull;
19import android.annotation.Nullable;
20import android.annotation.UserIdInt;
21import android.app.ActivityManager;
22import android.app.AppGlobals;
23import android.content.ComponentName;
24import android.content.ContentProvider;
25import android.content.Context;
26import android.content.Intent;
27import android.content.pm.ApplicationInfo;
28import android.content.pm.IPackageManager;
29import android.content.pm.IShortcutService;
30import android.content.pm.LauncherApps;
31import android.content.pm.LauncherApps.ShortcutQuery;
32import android.content.pm.PackageInfo;
33import android.content.pm.PackageManager;
34import android.content.pm.PackageManagerInternal;
35import android.content.pm.ParceledListSlice;
36import android.content.pm.ResolveInfo;
37import android.content.pm.ShortcutInfo;
38import android.content.pm.ShortcutServiceInternal;
39import android.content.pm.ShortcutServiceInternal.ShortcutChangeListener;
40import android.graphics.Bitmap;
41import android.graphics.Bitmap.CompressFormat;
42import android.graphics.BitmapFactory;
43import android.graphics.Canvas;
44import android.graphics.RectF;
45import android.graphics.drawable.Icon;
46import android.net.Uri;
47import android.os.Binder;
48import android.os.Environment;
49import android.os.FileUtils;
50import android.os.Handler;
51import android.os.Looper;
52import android.os.ParcelFileDescriptor;
53import android.os.PersistableBundle;
54import android.os.Process;
55import android.os.RemoteException;
56import android.os.ResultReceiver;
57import android.os.SELinux;
58import android.os.ShellCommand;
59import android.os.UserHandle;
60import android.os.UserManager;
61import android.text.TextUtils;
62import android.text.format.Time;
63import android.util.ArrayMap;
64import android.util.ArraySet;
65import android.util.AtomicFile;
66import android.util.KeyValueListParser;
67import android.util.Slog;
68import android.util.SparseArray;
69import android.util.TypedValue;
70import android.util.Xml;
71
72import com.android.internal.annotations.GuardedBy;
73import com.android.internal.annotations.VisibleForTesting;
74import com.android.internal.content.PackageMonitor;
75import com.android.internal.os.BackgroundThread;
76import com.android.internal.util.FastXmlSerializer;
77import com.android.internal.util.Preconditions;
78import com.android.server.LocalServices;
79import com.android.server.SystemService;
80import com.android.server.pm.ShortcutUser.PackageWithUser;
81
82import libcore.io.IoUtils;
83
84import org.xmlpull.v1.XmlPullParser;
85import org.xmlpull.v1.XmlPullParserException;
86import org.xmlpull.v1.XmlSerializer;
87
88import java.io.BufferedInputStream;
89import java.io.BufferedOutputStream;
90import java.io.ByteArrayInputStream;
91import java.io.ByteArrayOutputStream;
92import java.io.File;
93import java.io.FileDescriptor;
94import java.io.FileInputStream;
95import java.io.FileNotFoundException;
96import java.io.FileOutputStream;
97import java.io.IOException;
98import java.io.InputStream;
99import java.io.OutputStream;
100import java.io.PrintWriter;
101import java.net.URISyntaxException;
102import java.nio.charset.StandardCharsets;
103import java.util.ArrayList;
104import java.util.List;
105import java.util.function.Consumer;
106import java.util.function.Predicate;
107
108/**
109 * TODO:
110 *
111 * - Default launcher check does take a few ms.  Worth caching.
112 *
113 * - Clear data -> remove all dynamic?  but not the pinned?
114 *
115 * - Scan and remove orphan bitmaps (just in case).
116 *
117 * - Detect when already registered instances are passed to APIs again, which might break
118 *   internal bitmap handling.
119 *
120 * - Add more call stats.
121 */
122public class ShortcutService extends IShortcutService.Stub {
123    static final String TAG = "ShortcutService";
124
125    static final boolean DEBUG = false; // STOPSHIP if true
126    static final boolean DEBUG_LOAD = false; // STOPSHIP if true
127
128    @VisibleForTesting
129    static final long DEFAULT_RESET_INTERVAL_SEC = 24 * 60 * 60; // 1 day
130
131    @VisibleForTesting
132    static final int DEFAULT_MAX_DAILY_UPDATES = 10;
133
134    @VisibleForTesting
135    static final int DEFAULT_MAX_SHORTCUTS_PER_APP = 5;
136
137    @VisibleForTesting
138    static final int DEFAULT_MAX_ICON_DIMENSION_DP = 96;
139
140    @VisibleForTesting
141    static final int DEFAULT_MAX_ICON_DIMENSION_LOWRAM_DP = 48;
142
143    @VisibleForTesting
144    static final String DEFAULT_ICON_PERSIST_FORMAT = CompressFormat.PNG.name();
145
146    @VisibleForTesting
147    static final int DEFAULT_ICON_PERSIST_QUALITY = 100;
148
149    @VisibleForTesting
150    static final int DEFAULT_SAVE_DELAY_MS = 3000;
151
152    @VisibleForTesting
153    static final String FILENAME_BASE_STATE = "shortcut_service.xml";
154
155    @VisibleForTesting
156    static final String DIRECTORY_PER_USER = "shortcut_service";
157
158    @VisibleForTesting
159    static final String FILENAME_USER_PACKAGES = "shortcuts.xml";
160
161    static final String DIRECTORY_BITMAPS = "bitmaps";
162
163    private static final String TAG_ROOT = "root";
164    private static final String TAG_LAST_RESET_TIME = "last_reset_time";
165
166    private static final String ATTR_VALUE = "value";
167
168    @VisibleForTesting
169    interface ConfigConstants {
170        /**
171         * Key name for the save delay, in milliseconds. (int)
172         */
173        String KEY_SAVE_DELAY_MILLIS = "save_delay_ms";
174
175        /**
176         * Key name for the throttling reset interval, in seconds. (long)
177         */
178        String KEY_RESET_INTERVAL_SEC = "reset_interval_sec";
179
180        /**
181         * Key name for the max number of modifying API calls per app for every interval. (int)
182         */
183        String KEY_MAX_DAILY_UPDATES = "max_daily_updates";
184
185        /**
186         * Key name for the max icon dimensions in DP, for non-low-memory devices.
187         */
188        String KEY_MAX_ICON_DIMENSION_DP = "max_icon_dimension_dp";
189
190        /**
191         * Key name for the max icon dimensions in DP, for low-memory devices.
192         */
193        String KEY_MAX_ICON_DIMENSION_DP_LOWRAM = "max_icon_dimension_dp_lowram";
194
195        /**
196         * Key name for the max dynamic shortcuts per app. (int)
197         */
198        String KEY_MAX_SHORTCUTS = "max_shortcuts";
199
200        /**
201         * Key name for icon compression quality, 0-100.
202         */
203        String KEY_ICON_QUALITY = "icon_quality";
204
205        /**
206         * Key name for icon compression format: "PNG", "JPEG" or "WEBP"
207         */
208        String KEY_ICON_FORMAT = "icon_format";
209    }
210
211    final Context mContext;
212
213    private final Object mLock = new Object();
214
215    private final Handler mHandler;
216
217    @GuardedBy("mLock")
218    private final ArrayList<ShortcutChangeListener> mListeners = new ArrayList<>(1);
219
220    @GuardedBy("mLock")
221    private long mRawLastResetTime;
222
223    /**
224     * User ID -> UserShortcuts
225     */
226    @GuardedBy("mLock")
227    private final SparseArray<ShortcutUser> mUsers = new SparseArray<>();
228
229    /**
230     * Max number of dynamic shortcuts that each application can have at a time.
231     */
232    private int mMaxDynamicShortcuts;
233
234    /**
235     * Max number of updating API calls that each application can make a day.
236     */
237    int mMaxDailyUpdates;
238
239    /**
240     * Actual throttling-reset interval.  By default it's a day.
241     */
242    private long mResetInterval;
243
244    /**
245     * Icon max width/height in pixels.
246     */
247    private int mMaxIconDimension;
248
249    private CompressFormat mIconPersistFormat;
250    private int mIconPersistQuality;
251
252    private int mSaveDelayMillis;
253
254    private final IPackageManager mIPackageManager;
255    private final PackageManagerInternal mPackageManagerInternal;
256    private final UserManager mUserManager;
257
258    @GuardedBy("mLock")
259    private List<Integer> mDirtyUserIds = new ArrayList<>();
260
261    private static final int PACKAGE_MATCH_FLAGS =
262            PackageManager.MATCH_DIRECT_BOOT_AWARE
263            | PackageManager.MATCH_DIRECT_BOOT_UNAWARE
264            | PackageManager.MATCH_UNINSTALLED_PACKAGES;
265
266    // Stats
267    @VisibleForTesting
268    interface Stats {
269        int GET_DEFAULT_HOME = 0;
270        int GET_PACKAGE_INFO = 1;
271        int GET_PACKAGE_INFO_WITH_SIG = 2;
272        int GET_APPLICATION_INFO = 3;
273        int LAUNCHER_PERMISSION_CHECK = 4;
274
275        int COUNT = LAUNCHER_PERMISSION_CHECK + 1;
276    }
277
278    final Object mStatLock = new Object();
279
280    @GuardedBy("mStatLock")
281    private final int[] mCountStats = new int[Stats.COUNT];
282
283    @GuardedBy("mStatLock")
284    private final long[] mDurationStats = new long[Stats.COUNT];
285
286    public ShortcutService(Context context) {
287        this(context, BackgroundThread.get().getLooper());
288    }
289
290    @VisibleForTesting
291    ShortcutService(Context context, Looper looper) {
292        mContext = Preconditions.checkNotNull(context);
293        LocalServices.addService(ShortcutServiceInternal.class, new LocalService());
294        mHandler = new Handler(looper);
295        mIPackageManager = AppGlobals.getPackageManager();
296        mPackageManagerInternal = LocalServices.getService(PackageManagerInternal.class);
297        mUserManager = context.getSystemService(UserManager.class);
298
299        mPackageMonitor.register(context, looper, UserHandle.ALL, /* externalStorage= */ false);
300    }
301
302    void logDurationStat(int statId, long start) {
303        synchronized (mStatLock) {
304            mCountStats[statId]++;
305            mDurationStats[statId] += (System.currentTimeMillis() - start);
306        }
307    }
308
309    /**
310     * System service lifecycle.
311     */
312    public static final class Lifecycle extends SystemService {
313        final ShortcutService mService;
314
315        public Lifecycle(Context context) {
316            super(context);
317            mService = new ShortcutService(context);
318        }
319
320        @Override
321        public void onStart() {
322            publishBinderService(Context.SHORTCUT_SERVICE, mService);
323        }
324
325        @Override
326        public void onBootPhase(int phase) {
327            mService.onBootPhase(phase);
328        }
329
330        @Override
331        public void onCleanupUser(int userHandle) {
332            mService.handleCleanupUser(userHandle);
333        }
334
335        @Override
336        public void onUnlockUser(int userId) {
337            mService.handleUnlockUser(userId);
338        }
339    }
340
341    /** lifecycle event */
342    void onBootPhase(int phase) {
343        if (DEBUG) {
344            Slog.d(TAG, "onBootPhase: " + phase);
345        }
346        switch (phase) {
347            case SystemService.PHASE_LOCK_SETTINGS_READY:
348                initialize();
349                break;
350        }
351    }
352
353    /** lifecycle event */
354    void handleUnlockUser(int userId) {
355        synchronized (mLock) {
356            // Preload
357            getUserShortcutsLocked(userId);
358
359            cleanupGonePackages(userId);
360        }
361    }
362
363    /** lifecycle event */
364    void handleCleanupUser(int userId) {
365        synchronized (mLock) {
366            unloadUserLocked(userId);
367        }
368    }
369
370    private void unloadUserLocked(int userId) {
371        if (DEBUG) {
372            Slog.d(TAG, "unloadUserLocked: user=" + userId);
373        }
374        // Save all dirty information.
375        saveDirtyInfo();
376
377        // Unload
378        mUsers.delete(userId);
379    }
380
381    /** Return the base state file name */
382    private AtomicFile getBaseStateFile() {
383        final File path = new File(injectSystemDataPath(), FILENAME_BASE_STATE);
384        path.mkdirs();
385        return new AtomicFile(path);
386    }
387
388    /**
389     * Init the instance. (load the state file, etc)
390     */
391    private void initialize() {
392        synchronized (mLock) {
393            loadConfigurationLocked();
394            loadBaseStateLocked();
395        }
396    }
397
398    /**
399     * Load the configuration from Settings.
400     */
401    private void loadConfigurationLocked() {
402        updateConfigurationLocked(injectShortcutManagerConstants());
403    }
404
405    /**
406     * Load the configuration from Settings.
407     */
408    @VisibleForTesting
409    boolean updateConfigurationLocked(String config) {
410        boolean result = true;
411
412        final KeyValueListParser parser = new KeyValueListParser(',');
413        try {
414            parser.setString(config);
415        } catch (IllegalArgumentException e) {
416            // Failed to parse the settings string, log this and move on
417            // with defaults.
418            Slog.e(TAG, "Bad shortcut manager settings", e);
419            result = false;
420        }
421
422        mSaveDelayMillis = (int) parser.getLong(ConfigConstants.KEY_SAVE_DELAY_MILLIS,
423                DEFAULT_SAVE_DELAY_MS);
424
425        mResetInterval = parser.getLong(
426                ConfigConstants.KEY_RESET_INTERVAL_SEC, DEFAULT_RESET_INTERVAL_SEC)
427                * 1000L;
428
429        mMaxDailyUpdates = (int) parser.getLong(
430                ConfigConstants.KEY_MAX_DAILY_UPDATES, DEFAULT_MAX_DAILY_UPDATES);
431
432        mMaxDynamicShortcuts = (int) parser.getLong(
433                ConfigConstants.KEY_MAX_SHORTCUTS, DEFAULT_MAX_SHORTCUTS_PER_APP);
434
435        final int iconDimensionDp = injectIsLowRamDevice()
436                ? (int) parser.getLong(
437                    ConfigConstants.KEY_MAX_ICON_DIMENSION_DP_LOWRAM,
438                    DEFAULT_MAX_ICON_DIMENSION_LOWRAM_DP)
439                : (int) parser.getLong(
440                    ConfigConstants.KEY_MAX_ICON_DIMENSION_DP,
441                    DEFAULT_MAX_ICON_DIMENSION_DP);
442
443        mMaxIconDimension = injectDipToPixel(iconDimensionDp);
444
445        mIconPersistFormat = CompressFormat.valueOf(
446                parser.getString(ConfigConstants.KEY_ICON_FORMAT, DEFAULT_ICON_PERSIST_FORMAT));
447
448        mIconPersistQuality = (int) parser.getLong(
449                ConfigConstants.KEY_ICON_QUALITY,
450                DEFAULT_ICON_PERSIST_QUALITY);
451
452        return result;
453    }
454
455    @VisibleForTesting
456    String injectShortcutManagerConstants() {
457        return android.provider.Settings.Global.getString(
458                mContext.getContentResolver(),
459                android.provider.Settings.Global.SHORTCUT_MANAGER_CONSTANTS);
460    }
461
462    @VisibleForTesting
463    int injectDipToPixel(int dip) {
464        return (int) TypedValue.applyDimension(TypedValue.COMPLEX_UNIT_DIP, dip,
465                mContext.getResources().getDisplayMetrics());
466    }
467
468    // === Persisting ===
469
470    @Nullable
471    static String parseStringAttribute(XmlPullParser parser, String attribute) {
472        return parser.getAttributeValue(null, attribute);
473    }
474
475    static boolean parseBooleanAttribute(XmlPullParser parser, String attribute) {
476        return parseLongAttribute(parser, attribute) == 1;
477    }
478
479    static int parseIntAttribute(XmlPullParser parser, String attribute) {
480        return (int) parseLongAttribute(parser, attribute);
481    }
482
483    static int parseIntAttribute(XmlPullParser parser, String attribute, int def) {
484        return (int) parseLongAttribute(parser, attribute, def);
485    }
486
487    static long parseLongAttribute(XmlPullParser parser, String attribute) {
488        return parseLongAttribute(parser, attribute, 0);
489    }
490
491    static long parseLongAttribute(XmlPullParser parser, String attribute, long def) {
492        final String value = parseStringAttribute(parser, attribute);
493        if (TextUtils.isEmpty(value)) {
494            return def;
495        }
496        try {
497            return Long.parseLong(value);
498        } catch (NumberFormatException e) {
499            Slog.e(TAG, "Error parsing long " + value);
500            return def;
501        }
502    }
503
504    @Nullable
505    static ComponentName parseComponentNameAttribute(XmlPullParser parser, String attribute) {
506        final String value = parseStringAttribute(parser, attribute);
507        if (TextUtils.isEmpty(value)) {
508            return null;
509        }
510        return ComponentName.unflattenFromString(value);
511    }
512
513    @Nullable
514    static Intent parseIntentAttribute(XmlPullParser parser, String attribute) {
515        final String value = parseStringAttribute(parser, attribute);
516        if (TextUtils.isEmpty(value)) {
517            return null;
518        }
519        try {
520            return Intent.parseUri(value, /* flags =*/ 0);
521        } catch (URISyntaxException e) {
522            Slog.e(TAG, "Error parsing intent", e);
523            return null;
524        }
525    }
526
527    static void writeTagValue(XmlSerializer out, String tag, String value) throws IOException {
528        if (TextUtils.isEmpty(value)) return;
529
530        out.startTag(null, tag);
531        out.attribute(null, ATTR_VALUE, value);
532        out.endTag(null, tag);
533    }
534
535    static void writeTagValue(XmlSerializer out, String tag, long value) throws IOException {
536        writeTagValue(out, tag, Long.toString(value));
537    }
538
539    static void writeTagValue(XmlSerializer out, String tag, ComponentName name) throws IOException {
540        if (name == null) return;
541        writeTagValue(out, tag, name.flattenToString());
542    }
543
544    static void writeTagExtra(XmlSerializer out, String tag, PersistableBundle bundle)
545            throws IOException, XmlPullParserException {
546        if (bundle == null) return;
547
548        out.startTag(null, tag);
549        bundle.saveToXml(out);
550        out.endTag(null, tag);
551    }
552
553    static void writeAttr(XmlSerializer out, String name, String value) throws IOException {
554        if (TextUtils.isEmpty(value)) return;
555
556        out.attribute(null, name, value);
557    }
558
559    static void writeAttr(XmlSerializer out, String name, long value) throws IOException {
560        writeAttr(out, name, String.valueOf(value));
561    }
562
563    static void writeAttr(XmlSerializer out, String name, boolean value) throws IOException {
564        if (value) {
565            writeAttr(out, name, "1");
566        }
567    }
568
569    static void writeAttr(XmlSerializer out, String name, ComponentName comp) throws IOException {
570        if (comp == null) return;
571        writeAttr(out, name, comp.flattenToString());
572    }
573
574    static void writeAttr(XmlSerializer out, String name, Intent intent) throws IOException {
575        if (intent == null) return;
576
577        writeAttr(out, name, intent.toUri(/* flags =*/ 0));
578    }
579
580    @VisibleForTesting
581    void saveBaseStateLocked() {
582        final AtomicFile file = getBaseStateFile();
583        if (DEBUG) {
584            Slog.d(TAG, "Saving to " + file.getBaseFile());
585        }
586
587        FileOutputStream outs = null;
588        try {
589            outs = file.startWrite();
590
591            // Write to XML
592            XmlSerializer out = new FastXmlSerializer();
593            out.setOutput(outs, StandardCharsets.UTF_8.name());
594            out.startDocument(null, true);
595            out.startTag(null, TAG_ROOT);
596
597            // Body.
598            writeTagValue(out, TAG_LAST_RESET_TIME, mRawLastResetTime);
599
600            // Epilogue.
601            out.endTag(null, TAG_ROOT);
602            out.endDocument();
603
604            // Close.
605            file.finishWrite(outs);
606        } catch (IOException e) {
607            Slog.e(TAG, "Failed to write to file " + file.getBaseFile(), e);
608            file.failWrite(outs);
609        }
610    }
611
612    private void loadBaseStateLocked() {
613        mRawLastResetTime = 0;
614
615        final AtomicFile file = getBaseStateFile();
616        if (DEBUG) {
617            Slog.d(TAG, "Loading from " + file.getBaseFile());
618        }
619        try (FileInputStream in = file.openRead()) {
620            XmlPullParser parser = Xml.newPullParser();
621            parser.setInput(in, StandardCharsets.UTF_8.name());
622
623            int type;
624            while ((type = parser.next()) != XmlPullParser.END_DOCUMENT) {
625                if (type != XmlPullParser.START_TAG) {
626                    continue;
627                }
628                final int depth = parser.getDepth();
629                // Check the root tag
630                final String tag = parser.getName();
631                if (depth == 1) {
632                    if (!TAG_ROOT.equals(tag)) {
633                        Slog.e(TAG, "Invalid root tag: " + tag);
634                        return;
635                    }
636                    continue;
637                }
638                // Assume depth == 2
639                switch (tag) {
640                    case TAG_LAST_RESET_TIME:
641                        mRawLastResetTime = parseLongAttribute(parser, ATTR_VALUE);
642                        break;
643                    default:
644                        Slog.e(TAG, "Invalid tag: " + tag);
645                        break;
646                }
647            }
648        } catch (FileNotFoundException e) {
649            // Use the default
650        } catch (IOException|XmlPullParserException e) {
651            Slog.e(TAG, "Failed to read file " + file.getBaseFile(), e);
652
653            mRawLastResetTime = 0;
654        }
655        // Adjust the last reset time.
656        getLastResetTimeLocked();
657    }
658
659    private void saveUserLocked(@UserIdInt int userId) {
660        final File path = new File(injectUserDataPath(userId), FILENAME_USER_PACKAGES);
661        if (DEBUG) {
662            Slog.d(TAG, "Saving to " + path);
663        }
664        path.mkdirs();
665        final AtomicFile file = new AtomicFile(path);
666        FileOutputStream os = null;
667        try {
668            os = file.startWrite();
669
670            saveUserInternalLocked(userId, os, /* forBackup= */ false);
671
672            file.finishWrite(os);
673        } catch (XmlPullParserException|IOException e) {
674            Slog.e(TAG, "Failed to write to file " + file.getBaseFile(), e);
675            file.failWrite(os);
676        }
677    }
678
679    private void saveUserInternalLocked(@UserIdInt int userId, OutputStream os,
680            boolean forBackup) throws IOException, XmlPullParserException {
681
682        final BufferedOutputStream bos = new BufferedOutputStream(os);
683
684        // Write to XML
685        XmlSerializer out = new FastXmlSerializer();
686        out.setOutput(bos, StandardCharsets.UTF_8.name());
687        out.startDocument(null, true);
688
689        getUserShortcutsLocked(userId).saveToXml(this, out, forBackup);
690
691        out.endDocument();
692
693        bos.flush();
694        os.flush();
695    }
696
697    static IOException throwForInvalidTag(int depth, String tag) throws IOException {
698        throw new IOException(String.format("Invalid tag '%s' found at depth %d", tag, depth));
699    }
700
701    static void warnForInvalidTag(int depth, String tag) throws IOException {
702        Slog.w(TAG, String.format("Invalid tag '%s' found at depth %d", tag, depth));
703    }
704
705    @Nullable
706    private ShortcutUser loadUserLocked(@UserIdInt int userId) {
707        final File path = new File(injectUserDataPath(userId), FILENAME_USER_PACKAGES);
708        if (DEBUG) {
709            Slog.d(TAG, "Loading from " + path);
710        }
711        final AtomicFile file = new AtomicFile(path);
712
713        final FileInputStream in;
714        try {
715            in = file.openRead();
716        } catch (FileNotFoundException e) {
717            if (DEBUG) {
718                Slog.d(TAG, "Not found " + path);
719            }
720            return null;
721        }
722        try {
723            return loadUserInternal(userId, in, /* forBackup= */ false);
724        } catch (IOException|XmlPullParserException e) {
725            Slog.e(TAG, "Failed to read file " + file.getBaseFile(), e);
726            return null;
727        } finally {
728            IoUtils.closeQuietly(in);
729        }
730    }
731
732    private ShortcutUser loadUserInternal(@UserIdInt int userId, InputStream is,
733            boolean fromBackup) throws XmlPullParserException, IOException {
734
735        final BufferedInputStream bis = new BufferedInputStream(is);
736
737        ShortcutUser ret = null;
738        XmlPullParser parser = Xml.newPullParser();
739        parser.setInput(bis, StandardCharsets.UTF_8.name());
740
741        int type;
742        while ((type = parser.next()) != XmlPullParser.END_DOCUMENT) {
743            if (type != XmlPullParser.START_TAG) {
744                continue;
745            }
746            final int depth = parser.getDepth();
747
748            final String tag = parser.getName();
749            if (DEBUG_LOAD) {
750                Slog.d(TAG, String.format("depth=%d type=%d name=%s",
751                        depth, type, tag));
752            }
753            if ((depth == 1) && ShortcutUser.TAG_ROOT.equals(tag)) {
754                ret = ShortcutUser.loadFromXml(this, parser, userId, fromBackup);
755                continue;
756            }
757            throwForInvalidTag(depth, tag);
758        }
759        return ret;
760    }
761
762    private void scheduleSaveBaseState() {
763        scheduleSaveInner(UserHandle.USER_NULL); // Special case -- use USER_NULL for base state.
764    }
765
766    void scheduleSaveUser(@UserIdInt int userId) {
767        scheduleSaveInner(userId);
768    }
769
770    // In order to re-schedule, we need to reuse the same instance, so keep it in final.
771    private final Runnable mSaveDirtyInfoRunner = this::saveDirtyInfo;
772
773    private void scheduleSaveInner(@UserIdInt int userId) {
774        if (DEBUG) {
775            Slog.d(TAG, "Scheduling to save for " + userId);
776        }
777        synchronized (mLock) {
778            if (!mDirtyUserIds.contains(userId)) {
779                mDirtyUserIds.add(userId);
780            }
781        }
782        // If already scheduled, remove that and re-schedule in N seconds.
783        mHandler.removeCallbacks(mSaveDirtyInfoRunner);
784        mHandler.postDelayed(mSaveDirtyInfoRunner, mSaveDelayMillis);
785    }
786
787    @VisibleForTesting
788    void saveDirtyInfo() {
789        if (DEBUG) {
790            Slog.d(TAG, "saveDirtyInfo");
791        }
792        synchronized (mLock) {
793            for (int i = mDirtyUserIds.size() - 1; i >= 0; i--) {
794                final int userId = mDirtyUserIds.get(i);
795                if (userId == UserHandle.USER_NULL) { // USER_NULL for base state.
796                    saveBaseStateLocked();
797                } else {
798                    saveUserLocked(userId);
799                }
800            }
801            mDirtyUserIds.clear();
802        }
803    }
804
805    /** Return the last reset time. */
806    long getLastResetTimeLocked() {
807        updateTimesLocked();
808        return mRawLastResetTime;
809    }
810
811    /** Return the next reset time. */
812    long getNextResetTimeLocked() {
813        updateTimesLocked();
814        return mRawLastResetTime + mResetInterval;
815    }
816
817    static boolean isClockValid(long time) {
818        return time >= 1420070400; // Thu, 01 Jan 2015 00:00:00 GMT
819    }
820
821    /**
822     * Update the last reset time.
823     */
824    private void updateTimesLocked() {
825
826        final long now = injectCurrentTimeMillis();
827
828        final long prevLastResetTime = mRawLastResetTime;
829
830        if (mRawLastResetTime == 0) { // first launch.
831            // TODO Randomize??
832            mRawLastResetTime = now;
833        } else if (now < mRawLastResetTime) {
834            // Clock rewound.
835            if (isClockValid(now)) {
836                Slog.w(TAG, "Clock rewound");
837                // TODO Randomize??
838                mRawLastResetTime = now;
839            }
840        } else {
841            if ((mRawLastResetTime + mResetInterval) <= now) {
842                final long offset = mRawLastResetTime % mResetInterval;
843                mRawLastResetTime = ((now / mResetInterval) * mResetInterval) + offset;
844            }
845        }
846        if (prevLastResetTime != mRawLastResetTime) {
847            scheduleSaveBaseState();
848        }
849    }
850
851    @GuardedBy("mLock")
852    @NonNull
853    private boolean isUserLoadedLocked(@UserIdInt int userId) {
854        return mUsers.get(userId) != null;
855    }
856
857    /** Return the per-user state. */
858    @GuardedBy("mLock")
859    @NonNull
860    ShortcutUser getUserShortcutsLocked(@UserIdInt int userId) {
861        ShortcutUser userPackages = mUsers.get(userId);
862        if (userPackages == null) {
863            userPackages = loadUserLocked(userId);
864            if (userPackages == null) {
865                userPackages = new ShortcutUser(userId);
866            }
867            mUsers.put(userId, userPackages);
868        }
869        return userPackages;
870    }
871
872    void forEachLoadedUserLocked(@NonNull Consumer<ShortcutUser> c) {
873        for (int i = mUsers.size() - 1; i >= 0; i--) {
874            c.accept(mUsers.valueAt(i));
875        }
876    }
877
878    /** Return the per-user per-package state. */
879    @GuardedBy("mLock")
880    @NonNull
881    ShortcutPackage getPackageShortcutsLocked(
882            @NonNull String packageName, @UserIdInt int userId) {
883        return getUserShortcutsLocked(userId).getPackageShortcuts(this, packageName);
884    }
885
886    @GuardedBy("mLock")
887    @NonNull
888    ShortcutLauncher getLauncherShortcutsLocked(
889            @NonNull String packageName, @UserIdInt int ownerUserId,
890            @UserIdInt int launcherUserId) {
891        return getUserShortcutsLocked(ownerUserId)
892                .getLauncherShortcuts(this, packageName, launcherUserId);
893    }
894
895    // === Caller validation ===
896
897    void removeIcon(@UserIdInt int userId, ShortcutInfo shortcut) {
898        if (shortcut.getBitmapPath() != null) {
899            if (DEBUG) {
900                Slog.d(TAG, "Removing " + shortcut.getBitmapPath());
901            }
902            new File(shortcut.getBitmapPath()).delete();
903
904            shortcut.setBitmapPath(null);
905            shortcut.setIconResourceId(0);
906            shortcut.clearFlags(ShortcutInfo.FLAG_HAS_ICON_FILE | ShortcutInfo.FLAG_HAS_ICON_RES);
907        }
908    }
909
910    @VisibleForTesting
911    static class FileOutputStreamWithPath extends FileOutputStream {
912        private final File mFile;
913
914        public FileOutputStreamWithPath(File file) throws FileNotFoundException {
915            super(file);
916            mFile = file;
917        }
918
919        public File getFile() {
920            return mFile;
921        }
922    }
923
924    /**
925     * Build the cached bitmap filename for a shortcut icon.
926     *
927     * The filename will be based on the ID, except certain characters will be escaped.
928     */
929    @VisibleForTesting
930    FileOutputStreamWithPath openIconFileForWrite(@UserIdInt int userId, ShortcutInfo shortcut)
931            throws IOException {
932        final File packagePath = new File(getUserBitmapFilePath(userId),
933                shortcut.getPackageName());
934        if (!packagePath.isDirectory()) {
935            packagePath.mkdirs();
936            if (!packagePath.isDirectory()) {
937                throw new IOException("Unable to create directory " + packagePath);
938            }
939            SELinux.restorecon(packagePath);
940        }
941
942        final String baseName = String.valueOf(injectCurrentTimeMillis());
943        for (int suffix = 0;; suffix++) {
944            final String filename = (suffix == 0 ? baseName : baseName + "_" + suffix) + ".png";
945            final File file = new File(packagePath, filename);
946            if (!file.exists()) {
947                if (DEBUG) {
948                    Slog.d(TAG, "Saving icon to " + file.getAbsolutePath());
949                }
950                return new FileOutputStreamWithPath(file);
951            }
952        }
953    }
954
955    void saveIconAndFixUpShortcut(@UserIdInt int userId, ShortcutInfo shortcut) {
956        if (shortcut.hasIconFile() || shortcut.hasIconResource()) {
957            return;
958        }
959
960        final long token = injectClearCallingIdentity();
961        try {
962            // Clear icon info on the shortcut.
963            shortcut.setIconResourceId(0);
964            shortcut.setBitmapPath(null);
965
966            final Icon icon = shortcut.getIcon();
967            if (icon == null) {
968                return; // has no icon
969            }
970
971            Bitmap bitmap = null;
972            try {
973                switch (icon.getType()) {
974                    case Icon.TYPE_RESOURCE: {
975                        injectValidateIconResPackage(shortcut, icon);
976
977                        shortcut.setIconResourceId(icon.getResId());
978                        shortcut.addFlags(ShortcutInfo.FLAG_HAS_ICON_RES);
979                        return;
980                    }
981                    case Icon.TYPE_BITMAP: {
982                        bitmap = icon.getBitmap();
983                        break;
984                    }
985                    case Icon.TYPE_URI: {
986                        final Uri uri = ContentProvider.maybeAddUserId(icon.getUri(), userId);
987
988                        try (InputStream is = mContext.getContentResolver().openInputStream(uri)) {
989
990                            bitmap = BitmapFactory.decodeStream(is);
991
992                        } catch (IOException e) {
993                            Slog.e(TAG, "Unable to load icon from " + uri);
994                            return;
995                        }
996                        break;
997                    }
998                    default:
999                        // This shouldn't happen because we've already validated the icon, but
1000                        // just in case.
1001                        throw ShortcutInfo.getInvalidIconException();
1002                }
1003                if (bitmap == null) {
1004                    Slog.e(TAG, "Null bitmap detected");
1005                    return;
1006                }
1007                // Shrink and write to the file.
1008                File path = null;
1009                try {
1010                    final FileOutputStreamWithPath out = openIconFileForWrite(userId, shortcut);
1011                    try {
1012                        path = out.getFile();
1013
1014                        shrinkBitmap(bitmap, mMaxIconDimension)
1015                                .compress(mIconPersistFormat, mIconPersistQuality, out);
1016
1017                        shortcut.setBitmapPath(out.getFile().getAbsolutePath());
1018                        shortcut.addFlags(ShortcutInfo.FLAG_HAS_ICON_FILE);
1019                    } finally {
1020                        IoUtils.closeQuietly(out);
1021                    }
1022                } catch (IOException|RuntimeException e) {
1023                    // STOPSHIP Change wtf to e
1024                    Slog.wtf(ShortcutService.TAG, "Unable to write bitmap to file", e);
1025                    if (path != null && path.exists()) {
1026                        path.delete();
1027                    }
1028                }
1029            } finally {
1030                if (bitmap != null) {
1031                    bitmap.recycle();
1032                }
1033                // Once saved, we won't use the original icon information, so null it out.
1034                shortcut.clearIcon();
1035            }
1036        } finally {
1037            injectRestoreCallingIdentity(token);
1038        }
1039    }
1040
1041    // Unfortunately we can't do this check in unit tests because we fake creator package names,
1042    // so override in unit tests.
1043    // TODO CTS this case.
1044    void injectValidateIconResPackage(ShortcutInfo shortcut, Icon icon) {
1045        if (!shortcut.getPackageName().equals(icon.getResPackage())) {
1046            throw new IllegalArgumentException(
1047                    "Icon resource must reside in shortcut owner package");
1048        }
1049    }
1050
1051    @VisibleForTesting
1052    static Bitmap shrinkBitmap(Bitmap in, int maxSize) {
1053        // Original width/height.
1054        final int ow = in.getWidth();
1055        final int oh = in.getHeight();
1056        if ((ow <= maxSize) && (oh <= maxSize)) {
1057            if (DEBUG) {
1058                Slog.d(TAG, String.format("Icon size %dx%d, no need to shrink", ow, oh));
1059            }
1060            return in;
1061        }
1062        final int longerDimension = Math.max(ow, oh);
1063
1064        // New width and height.
1065        final int nw = ow * maxSize / longerDimension;
1066        final int nh = oh * maxSize / longerDimension;
1067        if (DEBUG) {
1068            Slog.d(TAG, String.format("Icon size %dx%d, shrinking to %dx%d",
1069                    ow, oh, nw, nh));
1070        }
1071
1072        final Bitmap scaledBitmap = Bitmap.createBitmap(nw, nh, Bitmap.Config.ARGB_8888);
1073        final Canvas c = new Canvas(scaledBitmap);
1074
1075        final RectF dst = new RectF(0, 0, nw, nh);
1076
1077        c.drawBitmap(in, /*src=*/ null, dst, /* paint =*/ null);
1078
1079        in.recycle();
1080
1081        return scaledBitmap;
1082    }
1083
1084    // === Caller validation ===
1085
1086    private boolean isCallerSystem() {
1087        final int callingUid = injectBinderCallingUid();
1088         return UserHandle.isSameApp(callingUid, Process.SYSTEM_UID);
1089    }
1090
1091    private boolean isCallerShell() {
1092        final int callingUid = injectBinderCallingUid();
1093        return callingUid == Process.SHELL_UID || callingUid == Process.ROOT_UID;
1094    }
1095
1096    private void enforceSystemOrShell() {
1097        Preconditions.checkState(isCallerSystem() || isCallerShell(),
1098                "Caller must be system or shell");
1099    }
1100
1101    private void enforceShell() {
1102        Preconditions.checkState(isCallerShell(), "Caller must be shell");
1103    }
1104
1105    private void enforceSystem() {
1106        Preconditions.checkState(isCallerSystem(), "Caller must be system");
1107    }
1108
1109    private void verifyCaller(@NonNull String packageName, @UserIdInt int userId) {
1110        Preconditions.checkStringNotEmpty(packageName, "packageName");
1111
1112        if (isCallerSystem()) {
1113            return; // no check
1114        }
1115
1116        final int callingUid = injectBinderCallingUid();
1117
1118        // Otherwise, make sure the arguments are valid.
1119        if (UserHandle.getUserId(callingUid) != userId) {
1120            throw new SecurityException("Invalid user-ID");
1121        }
1122        if (injectGetPackageUid(packageName, userId) == injectBinderCallingUid()) {
1123            return; // Caller is valid.
1124        }
1125        throw new SecurityException("Caller UID= doesn't own " + packageName);
1126    }
1127
1128    void postToHandler(Runnable r) {
1129        mHandler.post(r);
1130    }
1131
1132    /**
1133     * Throw if {@code numShortcuts} is bigger than {@link #mMaxDynamicShortcuts}.
1134     */
1135    void enforceMaxDynamicShortcuts(int numShortcuts) {
1136        if (numShortcuts > mMaxDynamicShortcuts) {
1137            throw new IllegalArgumentException("Max number of dynamic shortcuts exceeded");
1138        }
1139    }
1140
1141    /**
1142     * - Sends a notification to LauncherApps
1143     * - Write to file
1144     */
1145    private void userPackageChanged(@NonNull String packageName, @UserIdInt int userId) {
1146        notifyListeners(packageName, userId);
1147        scheduleSaveUser(userId);
1148    }
1149
1150    private void notifyListeners(@NonNull String packageName, @UserIdInt int userId) {
1151        if (!mUserManager.isUserRunning(userId)) {
1152            return;
1153        }
1154        postToHandler(() -> {
1155            final ArrayList<ShortcutChangeListener> copy;
1156            synchronized (mLock) {
1157                copy = new ArrayList<>(mListeners);
1158            }
1159            // Note onShortcutChanged() needs to be called with the system service permissions.
1160            for (int i = copy.size() - 1; i >= 0; i--) {
1161                copy.get(i).onShortcutChanged(packageName, userId);
1162            }
1163        });
1164    }
1165
1166    /**
1167     * Clean up / validate an incoming shortcut.
1168     * - Make sure all mandatory fields are set.
1169     * - Make sure the intent's extras are persistable, and them to set
1170     *  {@link ShortcutInfo#mIntentPersistableExtras}.  Also clear its extras.
1171     * - Clear flags.
1172     *
1173     * TODO Detailed unit tests
1174     */
1175    private void fixUpIncomingShortcutInfo(@NonNull ShortcutInfo shortcut, boolean forUpdate) {
1176        Preconditions.checkNotNull(shortcut, "Null shortcut detected");
1177        if (shortcut.getActivityComponent() != null) {
1178            Preconditions.checkState(
1179                    shortcut.getPackageName().equals(
1180                            shortcut.getActivityComponent().getPackageName()),
1181                    "Activity package name mismatch");
1182        }
1183
1184        if (!forUpdate) {
1185            shortcut.enforceMandatoryFields();
1186        }
1187        if (shortcut.getIcon() != null) {
1188            ShortcutInfo.validateIcon(shortcut.getIcon());
1189        }
1190
1191        validateForXml(shortcut.getId());
1192        validateForXml(shortcut.getTitle());
1193        validatePersistableBundleForXml(shortcut.getIntentPersistableExtras());
1194        validatePersistableBundleForXml(shortcut.getExtras());
1195
1196        shortcut.replaceFlags(0);
1197    }
1198
1199    // KXmlSerializer is strict and doesn't allow certain characters, so we disallow those
1200    // characters.
1201
1202    private static void validatePersistableBundleForXml(PersistableBundle b) {
1203        if (b == null || b.size() == 0) {
1204            return;
1205        }
1206        for (String key : b.keySet()) {
1207            validateForXml(key);
1208            final Object value = b.get(key);
1209            if (value == null) {
1210                continue;
1211            } else if (value instanceof String) {
1212                validateForXml((String) value);
1213            } else if (value instanceof String[]) {
1214                for (String v : (String[]) value) {
1215                    validateForXml(v);
1216                }
1217            } else if (value instanceof PersistableBundle) {
1218                validatePersistableBundleForXml((PersistableBundle) value);
1219            }
1220        }
1221    }
1222
1223    private static void validateForXml(String s) {
1224        if (TextUtils.isEmpty(s)) {
1225            return;
1226        }
1227        for (int i = s.length() - 1; i >= 0; i--) {
1228            if (!isAllowedInXml(s.charAt(i))) {
1229                throw new IllegalArgumentException("Unsupported character detected in: " + s);
1230            }
1231        }
1232    }
1233
1234    private static boolean isAllowedInXml(char c) {
1235        return (c >= 0x20 && c <= 0xd7ff) || (c >= 0xe000 && c <= 0xfffd);
1236    }
1237
1238    // === APIs ===
1239
1240    @Override
1241    public boolean setDynamicShortcuts(String packageName, ParceledListSlice shortcutInfoList,
1242            @UserIdInt int userId) {
1243        verifyCaller(packageName, userId);
1244
1245        final List<ShortcutInfo> newShortcuts = (List<ShortcutInfo>) shortcutInfoList.getList();
1246        final int size = newShortcuts.size();
1247
1248        synchronized (mLock) {
1249            final ShortcutPackage ps = getPackageShortcutsLocked(packageName, userId);
1250
1251            // Throttling.
1252            if (!ps.tryApiCall(this)) {
1253                return false;
1254            }
1255            enforceMaxDynamicShortcuts(size);
1256
1257            // Validate the shortcuts.
1258            for (int i = 0; i < size; i++) {
1259                fixUpIncomingShortcutInfo(newShortcuts.get(i), /* forUpdate= */ false);
1260            }
1261
1262            // First, remove all un-pinned; dynamic shortcuts
1263            ps.deleteAllDynamicShortcuts(this);
1264
1265            // Then, add/update all.  We need to make sure to take over "pinned" flag.
1266            for (int i = 0; i < size; i++) {
1267                final ShortcutInfo newShortcut = newShortcuts.get(i);
1268                ps.addDynamicShortcut(this, newShortcut);
1269            }
1270        }
1271        userPackageChanged(packageName, userId);
1272        return true;
1273    }
1274
1275    @Override
1276    public boolean updateShortcuts(String packageName, ParceledListSlice shortcutInfoList,
1277            @UserIdInt int userId) {
1278        verifyCaller(packageName, userId);
1279
1280        final List<ShortcutInfo> newShortcuts = (List<ShortcutInfo>) shortcutInfoList.getList();
1281        final int size = newShortcuts.size();
1282
1283        synchronized (mLock) {
1284            final ShortcutPackage ps = getPackageShortcutsLocked(packageName, userId);
1285
1286            // Throttling.
1287            if (!ps.tryApiCall(this)) {
1288                return false;
1289            }
1290
1291            for (int i = 0; i < size; i++) {
1292                final ShortcutInfo source = newShortcuts.get(i);
1293                fixUpIncomingShortcutInfo(source, /* forUpdate= */ true);
1294
1295                final ShortcutInfo target = ps.findShortcutById(source.getId());
1296                if (target != null) {
1297                    final boolean replacingIcon = (source.getIcon() != null);
1298                    if (replacingIcon) {
1299                        removeIcon(userId, target);
1300                    }
1301
1302                    target.copyNonNullFieldsFrom(source);
1303
1304                    if (replacingIcon) {
1305                        saveIconAndFixUpShortcut(userId, target);
1306                    }
1307                }
1308            }
1309        }
1310        userPackageChanged(packageName, userId);
1311
1312        return true;
1313    }
1314
1315    @Override
1316    public boolean addDynamicShortcut(String packageName, ShortcutInfo newShortcut,
1317            @UserIdInt int userId) {
1318        verifyCaller(packageName, userId);
1319
1320        synchronized (mLock) {
1321            final ShortcutPackage ps = getPackageShortcutsLocked(packageName, userId);
1322
1323            // Throttling.
1324            if (!ps.tryApiCall(this)) {
1325                return false;
1326            }
1327
1328            // Validate the shortcut.
1329            fixUpIncomingShortcutInfo(newShortcut, /* forUpdate= */ false);
1330
1331            // Add it.
1332            ps.addDynamicShortcut(this, newShortcut);
1333        }
1334        userPackageChanged(packageName, userId);
1335
1336        return true;
1337    }
1338
1339    @Override
1340    public void deleteDynamicShortcut(String packageName, String shortcutId,
1341            @UserIdInt int userId) {
1342        verifyCaller(packageName, userId);
1343        Preconditions.checkStringNotEmpty(shortcutId, "shortcutId must be provided");
1344
1345        synchronized (mLock) {
1346            getPackageShortcutsLocked(packageName, userId).deleteDynamicWithId(this, shortcutId);
1347        }
1348        userPackageChanged(packageName, userId);
1349    }
1350
1351    @Override
1352    public void deleteAllDynamicShortcuts(String packageName, @UserIdInt int userId) {
1353        verifyCaller(packageName, userId);
1354
1355        synchronized (mLock) {
1356            getPackageShortcutsLocked(packageName, userId).deleteAllDynamicShortcuts(this);
1357        }
1358        userPackageChanged(packageName, userId);
1359    }
1360
1361    @Override
1362    public ParceledListSlice<ShortcutInfo> getDynamicShortcuts(String packageName,
1363            @UserIdInt int userId) {
1364        verifyCaller(packageName, userId);
1365        synchronized (mLock) {
1366            return getShortcutsWithQueryLocked(
1367                    packageName, userId, ShortcutInfo.CLONE_REMOVE_FOR_CREATOR,
1368                    ShortcutInfo::isDynamic);
1369        }
1370    }
1371
1372    @Override
1373    public ParceledListSlice<ShortcutInfo> getPinnedShortcuts(String packageName,
1374            @UserIdInt int userId) {
1375        verifyCaller(packageName, userId);
1376        synchronized (mLock) {
1377            return getShortcutsWithQueryLocked(
1378                    packageName, userId, ShortcutInfo.CLONE_REMOVE_FOR_CREATOR,
1379                    ShortcutInfo::isPinned);
1380        }
1381    }
1382
1383    private ParceledListSlice<ShortcutInfo> getShortcutsWithQueryLocked(@NonNull String packageName,
1384            @UserIdInt int userId, int cloneFlags, @NonNull Predicate<ShortcutInfo> query) {
1385
1386        final ArrayList<ShortcutInfo> ret = new ArrayList<>();
1387
1388        getPackageShortcutsLocked(packageName, userId).findAll(this, ret, query, cloneFlags);
1389
1390        return new ParceledListSlice<>(ret);
1391    }
1392
1393    @Override
1394    public int getMaxDynamicShortcutCount(String packageName, @UserIdInt int userId)
1395            throws RemoteException {
1396        verifyCaller(packageName, userId);
1397
1398        return mMaxDynamicShortcuts;
1399    }
1400
1401    @Override
1402    public int getRemainingCallCount(String packageName, @UserIdInt int userId) {
1403        verifyCaller(packageName, userId);
1404
1405        synchronized (mLock) {
1406            return mMaxDailyUpdates
1407                    - getPackageShortcutsLocked(packageName, userId).getApiCallCount(this);
1408        }
1409    }
1410
1411    @Override
1412    public long getRateLimitResetTime(String packageName, @UserIdInt int userId) {
1413        verifyCaller(packageName, userId);
1414
1415        synchronized (mLock) {
1416            return getNextResetTimeLocked();
1417        }
1418    }
1419
1420    @Override
1421    public int getIconMaxDimensions(String packageName, int userId) throws RemoteException {
1422        synchronized (mLock) {
1423            return mMaxIconDimension;
1424        }
1425    }
1426
1427    /**
1428     * Reset all throttling, for developer options and command line.  Only system/shell can call it.
1429     */
1430    @Override
1431    public void resetThrottling() {
1432        enforceSystemOrShell();
1433
1434        resetThrottlingInner(getCallingUserId());
1435    }
1436
1437    void resetThrottlingInner(@UserIdInt int userId) {
1438        synchronized (mLock) {
1439            getUserShortcutsLocked(userId).resetThrottling();
1440        }
1441        scheduleSaveUser(userId);
1442        Slog.i(TAG, "ShortcutManager: throttling counter reset");
1443    }
1444
1445    // We override this method in unit tests to do a simpler check.
1446    boolean hasShortcutHostPermission(@NonNull String callingPackage, int userId) {
1447        return hasShortcutHostPermissionInner(callingPackage, userId);
1448    }
1449
1450    // This method is extracted so we can directly call this method from unit tests,
1451    // even when hasShortcutPermission() is overridden.
1452    @VisibleForTesting
1453    boolean hasShortcutHostPermissionInner(@NonNull String callingPackage, int userId) {
1454        synchronized (mLock) {
1455            final long start = System.currentTimeMillis();
1456
1457            final ShortcutUser user = getUserShortcutsLocked(userId);
1458
1459            final List<ResolveInfo> allHomeCandidates = new ArrayList<>();
1460
1461            // Default launcher from package manager.
1462            final long startGetHomeActivitiesAsUser = System.currentTimeMillis();
1463            final ComponentName defaultLauncher = injectPackageManagerInternal()
1464                    .getHomeActivitiesAsUser(allHomeCandidates, userId);
1465            logDurationStat(Stats.GET_DEFAULT_HOME, startGetHomeActivitiesAsUser);
1466
1467            ComponentName detected;
1468            if (defaultLauncher != null) {
1469                detected = defaultLauncher;
1470                if (DEBUG) {
1471                    Slog.v(TAG, "Default launcher from PM: " + detected);
1472                }
1473            } else {
1474                detected = user.getLauncherComponent();
1475
1476                // TODO: Make sure it's still enabled.
1477                if (DEBUG) {
1478                    Slog.v(TAG, "Cached launcher: " + detected);
1479                }
1480            }
1481
1482            if (detected == null) {
1483                // If we reach here, that means it's the first check since the user was created,
1484                // and there's already multiple launchers and there's no default set.
1485                // Find the system one with the highest priority.
1486                // (We need to check the priority too because of FallbackHome in Settings.)
1487                // If there's no system launcher yet, then no one can access shortcuts, until
1488                // the user explicitly
1489                final int size = allHomeCandidates.size();
1490
1491                int lastPriority = Integer.MIN_VALUE;
1492                for (int i = 0; i < size; i++) {
1493                    final ResolveInfo ri = allHomeCandidates.get(i);
1494                    if (!ri.activityInfo.applicationInfo.isSystemApp()) {
1495                        continue;
1496                    }
1497                    if (DEBUG) {
1498                        Slog.d(TAG, String.format("hasShortcutPermissionInner: pkg=%s prio=%d",
1499                                ri.activityInfo.getComponentName(), ri.priority));
1500                    }
1501                    if (ri.priority < lastPriority) {
1502                        continue;
1503                    }
1504                    detected = ri.activityInfo.getComponentName();
1505                    lastPriority = ri.priority;
1506                }
1507            }
1508            logDurationStat(Stats.LAUNCHER_PERMISSION_CHECK, start);
1509
1510            if (detected != null) {
1511                if (DEBUG) {
1512                    Slog.v(TAG, "Detected launcher: " + detected);
1513                }
1514                user.setLauncherComponent(this, detected);
1515                return detected.getPackageName().equals(callingPackage);
1516            } else {
1517                // Default launcher not found.
1518                return false;
1519            }
1520        }
1521    }
1522
1523    // === House keeping ===
1524
1525    /**
1526     * Remove all the information associated with a package.  This will really remove all the
1527     * information, including the restore information (i.e. it'll remove packages even if they're
1528     * shadow).
1529     */
1530    @VisibleForTesting
1531    void cleanUpPackageLocked(String packageName, int owningUserId, int packageUserId) {
1532        if (isPackageInstalled(packageName, packageUserId)) {
1533            wtf("Package " + packageName + " is still installed for user " + packageUserId);
1534            return;
1535        }
1536
1537        final boolean wasUserLoaded = isUserLoadedLocked(owningUserId);
1538
1539        final ShortcutUser mUser = getUserShortcutsLocked(owningUserId);
1540        boolean doNotify = false;
1541
1542        // First, remove the package from the package list (if the package is a publisher).
1543        if (packageUserId == owningUserId) {
1544            if (mUser.removePackage(packageName) != null) {
1545                doNotify = true;
1546            }
1547        }
1548
1549        // Also remove from the launcher list (if the package is a launcher).
1550        mUser.removeLauncher(packageUserId, packageName);
1551
1552        // Then remove pinned shortcuts from all launchers.
1553        final ArrayMap<PackageWithUser, ShortcutLauncher> launchers = mUser.getAllLaunchers();
1554        for (int i = launchers.size() - 1; i >= 0; i--) {
1555            launchers.valueAt(i).cleanUpPackage(packageName, packageUserId);
1556        }
1557        // Now there may be orphan shortcuts because we removed pinned shortucts at the previous
1558        // step.  Remove them too.
1559        for (int i = mUser.getAllPackages().size() - 1; i >= 0; i--) {
1560            mUser.getAllPackages().valueAt(i).refreshPinnedFlags(this);
1561        }
1562
1563        scheduleSaveUser(owningUserId);
1564
1565        if (doNotify) {
1566            notifyListeners(packageName, owningUserId);
1567        }
1568
1569        if (!wasUserLoaded) {
1570            // Note this will execute the scheduled save.
1571            unloadUserLocked(owningUserId);
1572        }
1573    }
1574
1575    /**
1576     * Entry point from {@link LauncherApps}.
1577     */
1578    private class LocalService extends ShortcutServiceInternal {
1579
1580        @Override
1581        public List<ShortcutInfo> getShortcuts(int launcherUserId,
1582                @NonNull String callingPackage, long changedSince,
1583                @Nullable String packageName, @Nullable ComponentName componentName,
1584                int queryFlags, int userId) {
1585            final ArrayList<ShortcutInfo> ret = new ArrayList<>();
1586            final int cloneFlag =
1587                    ((queryFlags & ShortcutQuery.FLAG_GET_KEY_FIELDS_ONLY) == 0)
1588                            ? ShortcutInfo.CLONE_REMOVE_FOR_LAUNCHER
1589                            : ShortcutInfo.CLONE_REMOVE_NON_KEY_INFO;
1590
1591            synchronized (mLock) {
1592                getLauncherShortcutsLocked(callingPackage, userId, launcherUserId)
1593                        .attemptToRestoreIfNeededAndSave(ShortcutService.this);
1594
1595                if (packageName != null) {
1596                    getShortcutsInnerLocked(launcherUserId,
1597                            callingPackage, packageName, changedSince,
1598                            componentName, queryFlags, userId, ret, cloneFlag);
1599                } else {
1600                    final ArrayMap<String, ShortcutPackage> packages =
1601                            getUserShortcutsLocked(userId).getAllPackages();
1602                    for (int i = packages.size() - 1; i >= 0; i--) {
1603                        getShortcutsInnerLocked(launcherUserId,
1604                                callingPackage, packages.keyAt(i), changedSince,
1605                                componentName, queryFlags, userId, ret, cloneFlag);
1606                    }
1607                }
1608            }
1609            return ret;
1610        }
1611
1612        private void getShortcutsInnerLocked(int launcherUserId, @NonNull String callingPackage,
1613                @Nullable String packageName,long changedSince,
1614                @Nullable ComponentName componentName, int queryFlags,
1615                int userId, ArrayList<ShortcutInfo> ret, int cloneFlag) {
1616            getPackageShortcutsLocked(packageName, userId).findAll(ShortcutService.this, ret,
1617                    (ShortcutInfo si) -> {
1618                        if (si.getLastChangedTimestamp() < changedSince) {
1619                            return false;
1620                        }
1621                        if (componentName != null
1622                                && !componentName.equals(si.getActivityComponent())) {
1623                            return false;
1624                        }
1625                        final boolean matchDynamic =
1626                                ((queryFlags & ShortcutQuery.FLAG_GET_DYNAMIC) != 0)
1627                                        && si.isDynamic();
1628                        final boolean matchPinned =
1629                                ((queryFlags & ShortcutQuery.FLAG_GET_PINNED) != 0)
1630                                        && si.isPinned();
1631                        return matchDynamic || matchPinned;
1632                    }, cloneFlag, callingPackage, launcherUserId);
1633        }
1634
1635        @Override
1636        public List<ShortcutInfo> getShortcutInfo(int launcherUserId,
1637                @NonNull String callingPackage,
1638                @NonNull String packageName, @Nullable List<String> ids, int userId) {
1639            // Calling permission must be checked by LauncherAppsImpl.
1640            Preconditions.checkStringNotEmpty(packageName, "packageName");
1641
1642            final ArrayList<ShortcutInfo> ret = new ArrayList<>(ids.size());
1643            final ArraySet<String> idSet = new ArraySet<>(ids);
1644            synchronized (mLock) {
1645                getLauncherShortcutsLocked(callingPackage, userId, launcherUserId)
1646                        .attemptToRestoreIfNeededAndSave(ShortcutService.this);
1647
1648                getPackageShortcutsLocked(packageName, userId).findAll(
1649                        ShortcutService.this, ret,
1650                        (ShortcutInfo si) -> idSet.contains(si.getId()),
1651                        ShortcutInfo.CLONE_REMOVE_FOR_LAUNCHER, callingPackage, launcherUserId);
1652            }
1653            return ret;
1654        }
1655
1656        @Override
1657        public boolean isPinnedByCaller(int launcherUserId, @NonNull String callingPackage,
1658                @NonNull String packageName, @NonNull String shortcutId, int userId) {
1659            Preconditions.checkStringNotEmpty(packageName, "packageName");
1660            Preconditions.checkStringNotEmpty(shortcutId, "shortcutId");
1661
1662            synchronized (mLock) {
1663                getLauncherShortcutsLocked(callingPackage, userId, launcherUserId)
1664                        .attemptToRestoreIfNeededAndSave(ShortcutService.this);
1665
1666                final ShortcutInfo si = getShortcutInfoLocked(
1667                        launcherUserId, callingPackage, packageName, shortcutId, userId);
1668                return si != null && si.isPinned();
1669            }
1670        }
1671
1672        private ShortcutInfo getShortcutInfoLocked(
1673                int launcherUserId, @NonNull String callingPackage,
1674                @NonNull String packageName, @NonNull String shortcutId, int userId) {
1675            Preconditions.checkStringNotEmpty(packageName, "packageName");
1676            Preconditions.checkStringNotEmpty(shortcutId, "shortcutId");
1677
1678            final ArrayList<ShortcutInfo> list = new ArrayList<>(1);
1679            getPackageShortcutsLocked(packageName, userId).findAll(
1680                    ShortcutService.this, list,
1681                    (ShortcutInfo si) -> shortcutId.equals(si.getId()),
1682                    /* clone flags=*/ 0, callingPackage, launcherUserId);
1683            return list.size() == 0 ? null : list.get(0);
1684        }
1685
1686        @Override
1687        public void pinShortcuts(int launcherUserId,
1688                @NonNull String callingPackage, @NonNull String packageName,
1689                @NonNull List<String> shortcutIds, int userId) {
1690            // Calling permission must be checked by LauncherAppsImpl.
1691            Preconditions.checkStringNotEmpty(packageName, "packageName");
1692            Preconditions.checkNotNull(shortcutIds, "shortcutIds");
1693
1694            synchronized (mLock) {
1695                final ShortcutLauncher launcher =
1696                        getLauncherShortcutsLocked(callingPackage, userId, launcherUserId);
1697                launcher.attemptToRestoreIfNeededAndSave(ShortcutService.this);
1698
1699                launcher.pinShortcuts(
1700                        ShortcutService.this, userId, packageName, shortcutIds);
1701            }
1702            userPackageChanged(packageName, userId);
1703        }
1704
1705        @Override
1706        public Intent createShortcutIntent(int launcherUserId,
1707                @NonNull String callingPackage,
1708                @NonNull String packageName, @NonNull String shortcutId, int userId) {
1709            // Calling permission must be checked by LauncherAppsImpl.
1710            Preconditions.checkStringNotEmpty(packageName, "packageName can't be empty");
1711            Preconditions.checkStringNotEmpty(shortcutId, "shortcutId can't be empty");
1712
1713            synchronized (mLock) {
1714                getLauncherShortcutsLocked(callingPackage, userId, launcherUserId)
1715                        .attemptToRestoreIfNeededAndSave(ShortcutService.this);
1716
1717                // Make sure the shortcut is actually visible to the launcher.
1718                final ShortcutInfo si = getShortcutInfoLocked(
1719                        launcherUserId, callingPackage, packageName, shortcutId, userId);
1720                // "si == null" should suffice here, but check the flags too just to make sure.
1721                if (si == null || !(si.isDynamic() || si.isPinned())) {
1722                    return null;
1723                }
1724                return si.getIntent();
1725            }
1726        }
1727
1728        @Override
1729        public void addListener(@NonNull ShortcutChangeListener listener) {
1730            synchronized (mLock) {
1731                mListeners.add(Preconditions.checkNotNull(listener));
1732            }
1733        }
1734
1735        @Override
1736        public int getShortcutIconResId(int launcherUserId,
1737                @NonNull String callingPackage,
1738                @NonNull ShortcutInfo shortcut, int userId) {
1739            Preconditions.checkNotNull(shortcut, "shortcut");
1740
1741            synchronized (mLock) {
1742                getLauncherShortcutsLocked(callingPackage, userId, launcherUserId)
1743                        .attemptToRestoreIfNeededAndSave(ShortcutService.this);
1744
1745                final ShortcutInfo shortcutInfo = getPackageShortcutsLocked(
1746                        shortcut.getPackageName(), userId).findShortcutById(shortcut.getId());
1747                return (shortcutInfo != null && shortcutInfo.hasIconResource())
1748                        ? shortcutInfo.getIconResourceId() : 0;
1749            }
1750        }
1751
1752        @Override
1753        public ParcelFileDescriptor getShortcutIconFd(int launcherUserId,
1754                @NonNull String callingPackage,
1755                @NonNull ShortcutInfo shortcutIn, int userId) {
1756            Preconditions.checkNotNull(shortcutIn, "shortcut");
1757
1758            synchronized (mLock) {
1759                getLauncherShortcutsLocked(callingPackage, userId, launcherUserId)
1760                        .attemptToRestoreIfNeededAndSave(ShortcutService.this);
1761
1762                final ShortcutInfo shortcutInfo = getPackageShortcutsLocked(
1763                        shortcutIn.getPackageName(), userId).findShortcutById(shortcutIn.getId());
1764                if (shortcutInfo == null || !shortcutInfo.hasIconFile()) {
1765                    return null;
1766                }
1767                try {
1768                    if (shortcutInfo.getBitmapPath() == null) {
1769                        Slog.w(TAG, "null bitmap detected in getShortcutIconFd()");
1770                        return null;
1771                    }
1772                    return ParcelFileDescriptor.open(
1773                            new File(shortcutInfo.getBitmapPath()),
1774                            ParcelFileDescriptor.MODE_READ_ONLY);
1775                } catch (FileNotFoundException e) {
1776                    Slog.e(TAG, "Icon file not found: " + shortcutInfo.getBitmapPath());
1777                    return null;
1778                }
1779            }
1780        }
1781
1782        @Override
1783        public boolean hasShortcutHostPermission(int launcherUserId,
1784                @NonNull String callingPackage) {
1785            return ShortcutService.this.hasShortcutHostPermission(callingPackage, launcherUserId);
1786        }
1787    }
1788
1789    /**
1790     * Package event callbacks.
1791     */
1792    @VisibleForTesting
1793    final PackageMonitor mPackageMonitor = new PackageMonitor() {
1794        @Override
1795        public void onPackageAdded(String packageName, int uid) {
1796            handlePackageAdded(packageName, getChangingUserId());
1797        }
1798
1799        @Override
1800        public void onPackageUpdateFinished(String packageName, int uid) {
1801            handlePackageUpdateFinished(packageName, getChangingUserId());
1802        }
1803
1804        @Override
1805        public void onPackageRemoved(String packageName, int uid) {
1806            handlePackageRemoved(packageName, getChangingUserId());
1807        }
1808    };
1809
1810    /**
1811     * Called when a user is unlocked.  Check all known packages still exist, and otherwise
1812     * perform cleanup.
1813     */
1814    @VisibleForTesting
1815    void cleanupGonePackages(@UserIdInt int ownerUserId) {
1816        if (DEBUG) {
1817            Slog.d(TAG, "cleanupGonePackages() ownerUserId=" + ownerUserId);
1818        }
1819        final ArrayList<PackageWithUser> gonePackages = new ArrayList<>();
1820
1821        synchronized (mLock) {
1822            final ShortcutUser user = getUserShortcutsLocked(ownerUserId);
1823
1824            user.forAllPackageItems(spi -> {
1825                if (spi.getPackageInfo().isShadow()) {
1826                    return; // Don't delete shadow information.
1827                }
1828                if (isPackageInstalled(spi.getPackageName(), spi.getPackageUserId())) {
1829                    return; // Package not gone.
1830                }
1831                gonePackages.add(PackageWithUser.of(spi));
1832            });
1833            if (gonePackages.size() > 0) {
1834                for (int i = gonePackages.size() - 1; i >= 0; i--) {
1835                    final PackageWithUser pu = gonePackages.get(i);
1836                    cleanUpPackageLocked(pu.packageName, ownerUserId, pu.userId);
1837                }
1838            }
1839        }
1840    }
1841
1842    private void handlePackageAdded(String packageName, @UserIdInt int userId) {
1843        if (DEBUG) {
1844            Slog.d(TAG, String.format("handlePackageAdded: %s user=%d", packageName, userId));
1845        }
1846        synchronized (mLock) {
1847            forEachLoadedUserLocked(user ->
1848                    user.attemptToRestoreIfNeededAndSave(this, packageName, userId));
1849        }
1850    }
1851
1852    private void handlePackageUpdateFinished(String packageName, @UserIdInt int userId) {
1853        if (DEBUG) {
1854            Slog.d(TAG, String.format("handlePackageUpdateFinished: %s user=%d",
1855                    packageName, userId));
1856        }
1857        synchronized (mLock) {
1858            forEachLoadedUserLocked(user ->
1859                    user.attemptToRestoreIfNeededAndSave(this, packageName, userId));
1860        }
1861    }
1862
1863    private void handlePackageRemoved(String packageName, @UserIdInt int packageUserId) {
1864        if (DEBUG) {
1865            Slog.d(TAG, String.format("handlePackageRemoved: %s user=%d", packageName,
1866                    packageUserId));
1867        }
1868        synchronized (mLock) {
1869            forEachLoadedUserLocked(user ->
1870                cleanUpPackageLocked(packageName, user.getUserId(), packageUserId));
1871        }
1872    }
1873
1874    // === PackageManager interaction ===
1875
1876    PackageInfo getPackageInfoWithSignatures(String packageName, @UserIdInt int userId) {
1877        return injectPackageInfo(packageName, userId, true);
1878    }
1879
1880    int injectGetPackageUid(@NonNull String packageName, @UserIdInt int userId) {
1881        final long token = injectClearCallingIdentity();
1882        try {
1883            return mIPackageManager.getPackageUid(packageName, PACKAGE_MATCH_FLAGS
1884                    , userId);
1885        } catch (RemoteException e) {
1886            // Shouldn't happen.
1887            Slog.wtf(TAG, "RemoteException", e);
1888            return -1;
1889        } finally {
1890            injectRestoreCallingIdentity(token);
1891        }
1892    }
1893
1894    @VisibleForTesting
1895    PackageInfo injectPackageInfo(String packageName, @UserIdInt int userId,
1896            boolean getSignatures) {
1897        final long start = System.currentTimeMillis();
1898        final long token = injectClearCallingIdentity();
1899        try {
1900            return mIPackageManager.getPackageInfo(packageName, PACKAGE_MATCH_FLAGS
1901                    | (getSignatures ? PackageManager.GET_SIGNATURES : 0)
1902                    , userId);
1903        } catch (RemoteException e) {
1904            // Shouldn't happen.
1905            Slog.wtf(TAG, "RemoteException", e);
1906            return null;
1907        } finally {
1908            injectRestoreCallingIdentity(token);
1909
1910            logDurationStat(
1911                    (getSignatures ? Stats.GET_PACKAGE_INFO_WITH_SIG : Stats.GET_PACKAGE_INFO),
1912                    start);
1913        }
1914    }
1915
1916    @VisibleForTesting
1917    ApplicationInfo injectApplicationInfo(String packageName, @UserIdInt int userId) {
1918        final long start = System.currentTimeMillis();
1919        final long token = injectClearCallingIdentity();
1920        try {
1921            return mIPackageManager.getApplicationInfo(packageName, PACKAGE_MATCH_FLAGS, userId);
1922        } catch (RemoteException e) {
1923            // Shouldn't happen.
1924            Slog.wtf(TAG, "RemoteException", e);
1925            return null;
1926        } finally {
1927            injectRestoreCallingIdentity(token);
1928
1929            logDurationStat(Stats.GET_APPLICATION_INFO, start);
1930        }
1931    }
1932
1933    private boolean isApplicationFlagSet(String packageName, int userId, int flags) {
1934        final ApplicationInfo ai = injectApplicationInfo(packageName, userId);
1935        return (ai != null) && ((ai.flags & flags) == flags);
1936    }
1937
1938    boolean isPackageInstalled(String packageName, int userId) {
1939        return isApplicationFlagSet(packageName, userId, ApplicationInfo.FLAG_INSTALLED);
1940    }
1941
1942    // === Backup & restore ===
1943
1944    boolean shouldBackupApp(String packageName, int userId) {
1945        return isApplicationFlagSet(packageName, userId, ApplicationInfo.FLAG_ALLOW_BACKUP);
1946    }
1947
1948    boolean shouldBackupApp(PackageInfo pi) {
1949        return (pi.applicationInfo.flags & ApplicationInfo.FLAG_ALLOW_BACKUP) != 0;
1950    }
1951
1952    @Override
1953    public byte[] getBackupPayload(@UserIdInt int userId) {
1954        enforceSystem();
1955        if (DEBUG) {
1956            Slog.d(TAG, "Backing up user " + userId);
1957        }
1958        synchronized (mLock) {
1959            final ShortcutUser user = getUserShortcutsLocked(userId);
1960            if (user == null) {
1961                Slog.w(TAG, "Can't backup: user not found: id=" + userId);
1962                return null;
1963            }
1964
1965            user.forAllPackageItems(spi -> spi.refreshPackageInfoAndSave(this));
1966
1967            // Then save.
1968            final ByteArrayOutputStream os = new ByteArrayOutputStream(32 * 1024);
1969            try {
1970                saveUserInternalLocked(userId, os, /* forBackup */ true);
1971            } catch (XmlPullParserException|IOException e) {
1972                // Shouldn't happen.
1973                Slog.w(TAG, "Backup failed.", e);
1974                return null;
1975            }
1976            return os.toByteArray();
1977        }
1978    }
1979
1980    @Override
1981    public void applyRestore(byte[] payload, @UserIdInt int userId) {
1982        enforceSystem();
1983        if (DEBUG) {
1984            Slog.d(TAG, "Restoring user " + userId);
1985        }
1986        final ShortcutUser user;
1987        final ByteArrayInputStream is = new ByteArrayInputStream(payload);
1988        try {
1989            user = loadUserInternal(userId, is, /* fromBackup */ true);
1990        } catch (XmlPullParserException|IOException e) {
1991            Slog.w(TAG, "Restoration failed.", e);
1992            return;
1993        }
1994        synchronized (mLock) {
1995            mUsers.put(userId, user);
1996
1997            // Then purge all the save images.
1998            final File bitmapPath = getUserBitmapFilePath(userId);
1999            final boolean success = FileUtils.deleteContents(bitmapPath);
2000            if (!success) {
2001                Slog.w(TAG, "Failed to delete " + bitmapPath);
2002            }
2003
2004            saveUserLocked(userId);
2005        }
2006    }
2007
2008    // === Dump ===
2009
2010    @Override
2011    public void dump(FileDescriptor fd, PrintWriter pw, String[] args) {
2012        if (mContext.checkCallingOrSelfPermission(android.Manifest.permission.DUMP)
2013                != PackageManager.PERMISSION_GRANTED) {
2014            pw.println("Permission Denial: can't dump UserManager from from pid="
2015                    + Binder.getCallingPid()
2016                    + ", uid=" + Binder.getCallingUid()
2017                    + " without permission "
2018                    + android.Manifest.permission.DUMP);
2019            return;
2020        }
2021        dumpInner(pw);
2022    }
2023
2024    @VisibleForTesting
2025    void dumpInner(PrintWriter pw) {
2026        synchronized (mLock) {
2027            final long now = injectCurrentTimeMillis();
2028            pw.print("Now: [");
2029            pw.print(now);
2030            pw.print("] ");
2031            pw.print(formatTime(now));
2032
2033            pw.print("  Raw last reset: [");
2034            pw.print(mRawLastResetTime);
2035            pw.print("] ");
2036            pw.print(formatTime(mRawLastResetTime));
2037
2038            final long last = getLastResetTimeLocked();
2039            pw.print("  Last reset: [");
2040            pw.print(last);
2041            pw.print("] ");
2042            pw.print(formatTime(last));
2043
2044            final long next = getNextResetTimeLocked();
2045            pw.print("  Next reset: [");
2046            pw.print(next);
2047            pw.print("] ");
2048            pw.print(formatTime(next));
2049            pw.println();
2050
2051            pw.print("  Max icon dim: ");
2052            pw.print(mMaxIconDimension);
2053            pw.print("  Icon format: ");
2054            pw.print(mIconPersistFormat);
2055            pw.print("  Icon quality: ");
2056            pw.println(mIconPersistQuality);
2057            pw.println();
2058
2059            pw.println("  Stats:");
2060            synchronized (mStatLock) {
2061                final String p = "     ";
2062                dumpStatLS(pw, p, Stats.GET_DEFAULT_HOME, "getHomeActivities()");
2063                dumpStatLS(pw, p, Stats.LAUNCHER_PERMISSION_CHECK, "Launcher permission check");
2064
2065                dumpStatLS(pw, p, Stats.GET_PACKAGE_INFO, "getPackageInfo()");
2066                dumpStatLS(pw, p, Stats.GET_PACKAGE_INFO_WITH_SIG, "getPackageInfo(SIG)");
2067                dumpStatLS(pw, p, Stats.GET_APPLICATION_INFO, "getApplicationInfo");
2068            }
2069
2070            for (int i = 0; i < mUsers.size(); i++) {
2071                pw.println();
2072                mUsers.valueAt(i).dump(this, pw, "  ");
2073            }
2074        }
2075    }
2076
2077    static String formatTime(long time) {
2078        Time tobj = new Time();
2079        tobj.set(time);
2080        return tobj.format("%Y-%m-%d %H:%M:%S");
2081    }
2082
2083    private void dumpStatLS(PrintWriter pw, String prefix, int statId, String label) {
2084        pw.print(prefix);
2085        final int count = mCountStats[statId];
2086        final long dur = mDurationStats[statId];
2087        pw.println(String.format("%s: count=%d, total=%dms, avg=%.1fms",
2088                label, count, dur,
2089                (count == 0 ? 0 : ((double) dur) / count)));
2090    }
2091
2092    // === Shell support ===
2093
2094    @Override
2095    public void onShellCommand(FileDescriptor in, FileDescriptor out, FileDescriptor err,
2096            String[] args, ResultReceiver resultReceiver) throws RemoteException {
2097
2098        enforceShell();
2099
2100        (new MyShellCommand()).exec(this, in, out, err, args, resultReceiver);
2101    }
2102
2103    static class CommandException extends Exception {
2104        public CommandException(String message) {
2105            super(message);
2106        }
2107    }
2108
2109    /**
2110     * Handle "adb shell cmd".
2111     */
2112    private class MyShellCommand extends ShellCommand {
2113
2114        private int mUserId = UserHandle.USER_SYSTEM;
2115
2116        private void parseOptions(boolean takeUser)
2117                throws CommandException {
2118            String opt;
2119            while ((opt = getNextOption()) != null) {
2120                switch (opt) {
2121                    case "--user":
2122                        if (takeUser) {
2123                            mUserId = UserHandle.parseUserArg(getNextArgRequired());
2124                            break;
2125                        }
2126                        // fallthrough
2127                    default:
2128                        throw new CommandException("Unknown option: " + opt);
2129                }
2130            }
2131        }
2132
2133        @Override
2134        public int onCommand(String cmd) {
2135            if (cmd == null) {
2136                return handleDefaultCommands(cmd);
2137            }
2138            final PrintWriter pw = getOutPrintWriter();
2139            try {
2140                switch (cmd) {
2141                    case "reset-package-throttling":
2142                        handleResetPackageThrottling();
2143                        break;
2144                    case "reset-throttling":
2145                        handleResetThrottling();
2146                        break;
2147                    case "override-config":
2148                        handleOverrideConfig();
2149                        break;
2150                    case "reset-config":
2151                        handleResetConfig();
2152                        break;
2153                    case "clear-default-launcher":
2154                        handleClearDefaultLauncher();
2155                        break;
2156                    case "get-default-launcher":
2157                        handleGetDefaultLauncher();
2158                        break;
2159                    case "refresh-default-launcher":
2160                        handleRefreshDefaultLauncher();
2161                        break;
2162                    default:
2163                        return handleDefaultCommands(cmd);
2164                }
2165            } catch (CommandException e) {
2166                pw.println("Error: " + e.getMessage());
2167                return 1;
2168            }
2169            pw.println("Success");
2170            return 0;
2171        }
2172
2173        @Override
2174        public void onHelp() {
2175            final PrintWriter pw = getOutPrintWriter();
2176            pw.println("Usage: cmd shortcut COMMAND [options ...]");
2177            pw.println();
2178            pw.println("cmd shortcut reset-package-throttling [--user USER_ID] PACKAGE");
2179            pw.println("    Reset throttling for a package");
2180            pw.println();
2181            pw.println("cmd shortcut reset-throttling");
2182            pw.println("    Reset throttling for all packages and users");
2183            pw.println();
2184            pw.println("cmd shortcut override-config CONFIG");
2185            pw.println("    Override the configuration for testing (will last until reboot)");
2186            pw.println();
2187            pw.println("cmd shortcut reset-config");
2188            pw.println("    Reset the configuration set with \"update-config\"");
2189            pw.println();
2190            pw.println("cmd shortcut clear-default-launcher [--user USER_ID]");
2191            pw.println("    Clear the cached default launcher");
2192            pw.println();
2193            pw.println("cmd shortcut get-default-launcher [--user USER_ID]");
2194            pw.println("    Show the cached default launcher");
2195            pw.println();
2196            pw.println("cmd shortcut refresh-default-launcher [--user USER_ID]");
2197            pw.println("    Refresh the cached default launcher");
2198            pw.println();
2199        }
2200
2201        private int handleResetThrottling() throws CommandException {
2202            parseOptions(/* takeUser =*/ true);
2203
2204            resetThrottlingInner(mUserId);
2205            return 0;
2206        }
2207
2208        private void handleResetPackageThrottling() throws CommandException {
2209            parseOptions(/* takeUser =*/ true);
2210
2211            final String packageName = getNextArgRequired();
2212
2213            synchronized (mLock) {
2214                getPackageShortcutsLocked(packageName, mUserId).resetRateLimitingForCommandLine();
2215                saveUserLocked(mUserId);
2216            }
2217        }
2218
2219        private void handleOverrideConfig() throws CommandException {
2220            final String config = getNextArgRequired();
2221
2222            synchronized (mLock) {
2223                if (!updateConfigurationLocked(config)) {
2224                    throw new CommandException("override-config failed.  See logcat for details.");
2225                }
2226            }
2227        }
2228
2229        private void handleResetConfig() {
2230            synchronized (mLock) {
2231                loadConfigurationLocked();
2232            }
2233        }
2234
2235        private void clearLauncher() {
2236            synchronized (mLock) {
2237                getUserShortcutsLocked(mUserId).setLauncherComponent(
2238                        ShortcutService.this, null);
2239            }
2240        }
2241
2242        private void showLauncher() {
2243            synchronized (mLock) {
2244                // This ensures to set the cached launcher.  Package name doesn't matter.
2245                hasShortcutHostPermissionInner("-", mUserId);
2246
2247                getOutPrintWriter().println("Launcher: "
2248                        + getUserShortcutsLocked(mUserId).getLauncherComponent());
2249            }
2250        }
2251
2252        private void handleClearDefaultLauncher() throws CommandException {
2253            parseOptions(/* takeUser =*/ true);
2254
2255            clearLauncher();
2256        }
2257
2258        private void handleGetDefaultLauncher() throws CommandException {
2259            parseOptions(/* takeUser =*/ true);
2260
2261            showLauncher();
2262        }
2263
2264        private void handleRefreshDefaultLauncher() throws CommandException {
2265            parseOptions(/* takeUser =*/ true);
2266
2267            clearLauncher();
2268            showLauncher();
2269        }
2270    }
2271
2272    // === Unit test support ===
2273
2274    // Injection point.
2275    @VisibleForTesting
2276    long injectCurrentTimeMillis() {
2277        return System.currentTimeMillis();
2278    }
2279
2280    // Injection point.
2281    @VisibleForTesting
2282    int injectBinderCallingUid() {
2283        return getCallingUid();
2284    }
2285
2286    private int getCallingUserId() {
2287        return UserHandle.getUserId(injectBinderCallingUid());
2288    }
2289
2290    // Injection point.
2291    @VisibleForTesting
2292    long injectClearCallingIdentity() {
2293        return Binder.clearCallingIdentity();
2294    }
2295
2296    // Injection point.
2297    @VisibleForTesting
2298    void injectRestoreCallingIdentity(long token) {
2299        Binder.restoreCallingIdentity(token);
2300    }
2301
2302    final void wtf(String message) {
2303        wtf( message, /* exception= */ null);
2304    }
2305
2306    // Injection point.
2307    void wtf(String message, Exception e) {
2308        Slog.wtf(TAG, message, e);
2309    }
2310
2311    @VisibleForTesting
2312    File injectSystemDataPath() {
2313        return Environment.getDataSystemDirectory();
2314    }
2315
2316    @VisibleForTesting
2317    File injectUserDataPath(@UserIdInt int userId) {
2318        return new File(Environment.getDataSystemCeDirectory(userId), DIRECTORY_PER_USER);
2319    }
2320
2321    @VisibleForTesting
2322    boolean injectIsLowRamDevice() {
2323        return ActivityManager.isLowRamDeviceStatic();
2324    }
2325
2326    @VisibleForTesting
2327    PackageManagerInternal injectPackageManagerInternal() {
2328        return mPackageManagerInternal;
2329    }
2330
2331    @VisibleForTesting
2332    File getUserBitmapFilePath(@UserIdInt int userId) {
2333        return new File(injectUserDataPath(userId), DIRECTORY_BITMAPS);
2334    }
2335
2336    @VisibleForTesting
2337    SparseArray<ShortcutUser> getShortcutsForTest() {
2338        return mUsers;
2339    }
2340
2341    @VisibleForTesting
2342    int getMaxDynamicShortcutsForTest() {
2343        return mMaxDynamicShortcuts;
2344    }
2345
2346    @VisibleForTesting
2347    int getMaxDailyUpdatesForTest() {
2348        return mMaxDailyUpdates;
2349    }
2350
2351    @VisibleForTesting
2352    long getResetIntervalForTest() {
2353        return mResetInterval;
2354    }
2355
2356    @VisibleForTesting
2357    int getMaxIconDimensionForTest() {
2358        return mMaxIconDimension;
2359    }
2360
2361    @VisibleForTesting
2362    CompressFormat getIconPersistFormatForTest() {
2363        return mIconPersistFormat;
2364    }
2365
2366    @VisibleForTesting
2367    int getIconPersistQualityForTest() {
2368        return mIconPersistQuality;
2369    }
2370
2371    @VisibleForTesting
2372    ShortcutInfo getPackageShortcutForTest(String packageName, String shortcutId, int userId) {
2373        synchronized (mLock) {
2374            final ShortcutUser user = mUsers.get(userId);
2375            if (user == null) return null;
2376
2377            final ShortcutPackage pkg = user.getAllPackages().get(packageName);
2378            if (pkg == null) return null;
2379
2380            return pkg.findShortcutById(shortcutId);
2381        }
2382    }
2383}
2384