Makoto Onuki | 3145924 | 2016-03-22 11:12:18 -0700 | [diff] [blame] | 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 | */ |
| 16 | package com.android.server.pm; |
| 17 | |
| 18 | import android.annotation.NonNull; |
Makoto Onuki | c51b287 | 2016-05-04 15:24:50 -0700 | [diff] [blame] | 19 | import android.annotation.Nullable; |
Makoto Onuki | 3145924 | 2016-03-22 11:12:18 -0700 | [diff] [blame] | 20 | import android.annotation.UserIdInt; |
| 21 | import android.content.ComponentName; |
Makoto Onuki | 4e6cef4 | 2016-07-13 16:14:01 -0700 | [diff] [blame] | 22 | import android.content.pm.ShortcutManager; |
| 23 | import android.text.TextUtils; |
Makoto Onuki | 0033b2a | 2016-04-14 17:19:16 -0700 | [diff] [blame] | 24 | import android.text.format.Formatter; |
Makoto Onuki | 3145924 | 2016-03-22 11:12:18 -0700 | [diff] [blame] | 25 | import android.util.ArrayMap; |
Makoto Onuki | fc4cf2d | 2016-08-24 11:10:26 -0700 | [diff] [blame] | 26 | import android.util.Log; |
Makoto Onuki | 0acbb14 | 2016-03-22 17:02:57 -0700 | [diff] [blame] | 27 | import android.util.Slog; |
Makoto Onuki | 3145924 | 2016-03-22 11:12:18 -0700 | [diff] [blame] | 28 | |
Makoto Onuki | 4d36b3a | 2016-04-27 12:00:17 -0700 | [diff] [blame] | 29 | import com.android.internal.annotations.VisibleForTesting; |
Makoto Onuki | d99c6f0 | 2016-03-28 11:02:54 -0700 | [diff] [blame] | 30 | import com.android.internal.util.Preconditions; |
Makoto Onuki | 20b8221 | 2017-10-04 15:03:50 -0700 | [diff] [blame] | 31 | import com.android.server.pm.ShortcutService.DumpFilter; |
Makoto Onuki | fc4cf2d | 2016-08-24 11:10:26 -0700 | [diff] [blame] | 32 | import com.android.server.pm.ShortcutService.InvalidFileFormatException; |
Makoto Onuki | d99c6f0 | 2016-03-28 11:02:54 -0700 | [diff] [blame] | 33 | |
Makoto Onuki | 7626992 | 2016-07-15 14:58:54 -0700 | [diff] [blame] | 34 | import org.json.JSONArray; |
| 35 | import org.json.JSONException; |
| 36 | import org.json.JSONObject; |
Makoto Onuki | 3145924 | 2016-03-22 11:12:18 -0700 | [diff] [blame] | 37 | import org.xmlpull.v1.XmlPullParser; |
| 38 | import org.xmlpull.v1.XmlPullParserException; |
| 39 | import org.xmlpull.v1.XmlSerializer; |
| 40 | |
Makoto Onuki | 0033b2a | 2016-04-14 17:19:16 -0700 | [diff] [blame] | 41 | import java.io.File; |
Makoto Onuki | 3145924 | 2016-03-22 11:12:18 -0700 | [diff] [blame] | 42 | import java.io.IOException; |
| 43 | import java.io.PrintWriter; |
Narayan Kamath | 607223f | 2018-02-19 14:09:02 +0000 | [diff] [blame] | 44 | import java.util.Objects; |
Makoto Onuki | 9da23fc | 2016-03-29 11:14:42 -0700 | [diff] [blame] | 45 | import java.util.function.Consumer; |
Makoto Onuki | 3145924 | 2016-03-22 11:12:18 -0700 | [diff] [blame] | 46 | |
| 47 | /** |
| 48 | * User information used by {@link ShortcutService}. |
Makoto Onuki | 22fcc68 | 2016-05-17 14:52:19 -0700 | [diff] [blame] | 49 | * |
| 50 | * All methods should be guarded by {@code #mService.mLock}. |
Makoto Onuki | 3145924 | 2016-03-22 11:12:18 -0700 | [diff] [blame] | 51 | */ |
| 52 | class ShortcutUser { |
| 53 | private static final String TAG = ShortcutService.TAG; |
| 54 | |
| 55 | static final String TAG_ROOT = "user"; |
| 56 | private static final String TAG_LAUNCHER = "launcher"; |
| 57 | |
| 58 | private static final String ATTR_VALUE = "value"; |
Makoto Onuki | 4e6cef4 | 2016-07-13 16:14:01 -0700 | [diff] [blame] | 59 | private static final String ATTR_KNOWN_LOCALES = "locales"; |
Makoto Onuki | 4dd032d | 2016-08-02 11:39:19 -0700 | [diff] [blame] | 60 | |
| 61 | // Suffix "2" was added to force rescan all packages after the next OTA. |
| 62 | private static final String ATTR_LAST_APP_SCAN_TIME = "last-app-scan-time2"; |
Makoto Onuki | 3366328 | 2016-08-22 16:19:04 -0700 | [diff] [blame] | 63 | private static final String ATTR_LAST_APP_SCAN_OS_FINGERPRINT = "last-app-scan-fp"; |
Makoto Onuki | e3fffa9 | 2018-02-28 16:25:40 -0800 | [diff] [blame] | 64 | private static final String ATTR_RESTORE_SOURCE_FINGERPRINT = "restore-from-fp"; |
Makoto Onuki | 7626992 | 2016-07-15 14:58:54 -0700 | [diff] [blame] | 65 | private static final String KEY_USER_ID = "userId"; |
| 66 | private static final String KEY_LAUNCHERS = "launchers"; |
| 67 | private static final String KEY_PACKAGES = "packages"; |
Makoto Onuki | 3145924 | 2016-03-22 11:12:18 -0700 | [diff] [blame] | 68 | |
Makoto Onuki | d99c6f0 | 2016-03-28 11:02:54 -0700 | [diff] [blame] | 69 | static final class PackageWithUser { |
| 70 | final int userId; |
| 71 | final String packageName; |
| 72 | |
| 73 | private PackageWithUser(int userId, String packageName) { |
| 74 | this.userId = userId; |
| 75 | this.packageName = Preconditions.checkNotNull(packageName); |
| 76 | } |
| 77 | |
Makoto Onuki | 2e210c4 | 2016-03-30 08:30:36 -0700 | [diff] [blame] | 78 | public static PackageWithUser of(int userId, String packageName) { |
| 79 | return new PackageWithUser(userId, packageName); |
Makoto Onuki | d99c6f0 | 2016-03-28 11:02:54 -0700 | [diff] [blame] | 80 | } |
| 81 | |
Makoto Onuki | 9da23fc | 2016-03-29 11:14:42 -0700 | [diff] [blame] | 82 | public static PackageWithUser of(ShortcutPackageItem spi) { |
| 83 | return new PackageWithUser(spi.getPackageUserId(), spi.getPackageName()); |
| 84 | } |
| 85 | |
Makoto Onuki | d99c6f0 | 2016-03-28 11:02:54 -0700 | [diff] [blame] | 86 | @Override |
| 87 | public int hashCode() { |
| 88 | return packageName.hashCode() ^ userId; |
| 89 | } |
| 90 | |
| 91 | @Override |
| 92 | public boolean equals(Object obj) { |
| 93 | if (!(obj instanceof PackageWithUser)) { |
| 94 | return false; |
| 95 | } |
| 96 | final PackageWithUser that = (PackageWithUser) obj; |
| 97 | |
| 98 | return userId == that.userId && packageName.equals(that.packageName); |
| 99 | } |
| 100 | |
| 101 | @Override |
| 102 | public String toString() { |
Makoto Onuki | b08790c | 2016-06-23 14:05:46 -0700 | [diff] [blame] | 103 | return String.format("[Package: %d, %s]", userId, packageName); |
Makoto Onuki | d99c6f0 | 2016-03-28 11:02:54 -0700 | [diff] [blame] | 104 | } |
| 105 | } |
| 106 | |
Makoto Onuki | c51b287 | 2016-05-04 15:24:50 -0700 | [diff] [blame] | 107 | final ShortcutService mService; |
| 108 | |
Makoto Onuki | 3145924 | 2016-03-22 11:12:18 -0700 | [diff] [blame] | 109 | @UserIdInt |
Makoto Onuki | 2e210c4 | 2016-03-30 08:30:36 -0700 | [diff] [blame] | 110 | private final int mUserId; |
Makoto Onuki | 3145924 | 2016-03-22 11:12:18 -0700 | [diff] [blame] | 111 | |
| 112 | private final ArrayMap<String, ShortcutPackage> mPackages = new ArrayMap<>(); |
| 113 | |
Makoto Onuki | d99c6f0 | 2016-03-28 11:02:54 -0700 | [diff] [blame] | 114 | private final ArrayMap<PackageWithUser, ShortcutLauncher> mLaunchers = new ArrayMap<>(); |
Makoto Onuki | 3145924 | 2016-03-22 11:12:18 -0700 | [diff] [blame] | 115 | |
Makoto Onuki | 1030520 | 2016-07-14 18:14:08 -0700 | [diff] [blame] | 116 | /** |
| 117 | * Last known launcher. It's used when the default launcher isn't set in PM -- i.e. |
| 118 | * when getHomeActivitiesAsUser() return null. We need it so that in this situation the |
| 119 | * previously default launcher can still access shortcuts. |
| 120 | */ |
| 121 | private ComponentName mLastKnownLauncher; |
| 122 | |
| 123 | /** In-memory-cached default launcher. */ |
| 124 | private ComponentName mCachedLauncher; |
Makoto Onuki | 3145924 | 2016-03-22 11:12:18 -0700 | [diff] [blame] | 125 | |
Makoto Onuki | 4e6cef4 | 2016-07-13 16:14:01 -0700 | [diff] [blame] | 126 | private String mKnownLocales; |
Makoto Onuki | 4d36b3a | 2016-04-27 12:00:17 -0700 | [diff] [blame] | 127 | |
Makoto Onuki | 6dd9fb7 | 2016-06-01 13:55:54 -0700 | [diff] [blame] | 128 | private long mLastAppScanTime; |
| 129 | |
Makoto Onuki | 3366328 | 2016-08-22 16:19:04 -0700 | [diff] [blame] | 130 | private String mLastAppScanOsFingerprint; |
Makoto Onuki | e3fffa9 | 2018-02-28 16:25:40 -0800 | [diff] [blame] | 131 | private String mRestoreFromOsFingerprint; |
Makoto Onuki | 3366328 | 2016-08-22 16:19:04 -0700 | [diff] [blame] | 132 | |
Makoto Onuki | c51b287 | 2016-05-04 15:24:50 -0700 | [diff] [blame] | 133 | public ShortcutUser(ShortcutService service, int userId) { |
| 134 | mService = service; |
Makoto Onuki | 3145924 | 2016-03-22 11:12:18 -0700 | [diff] [blame] | 135 | mUserId = userId; |
| 136 | } |
| 137 | |
Makoto Onuki | 2e210c4 | 2016-03-30 08:30:36 -0700 | [diff] [blame] | 138 | public int getUserId() { |
| 139 | return mUserId; |
| 140 | } |
| 141 | |
Makoto Onuki | 6dd9fb7 | 2016-06-01 13:55:54 -0700 | [diff] [blame] | 142 | public long getLastAppScanTime() { |
| 143 | return mLastAppScanTime; |
| 144 | } |
| 145 | |
| 146 | public void setLastAppScanTime(long lastAppScanTime) { |
| 147 | mLastAppScanTime = lastAppScanTime; |
| 148 | } |
| 149 | |
Makoto Onuki | 3366328 | 2016-08-22 16:19:04 -0700 | [diff] [blame] | 150 | public String getLastAppScanOsFingerprint() { |
| 151 | return mLastAppScanOsFingerprint; |
| 152 | } |
| 153 | |
| 154 | public void setLastAppScanOsFingerprint(String lastAppScanOsFingerprint) { |
| 155 | mLastAppScanOsFingerprint = lastAppScanOsFingerprint; |
| 156 | } |
| 157 | |
Makoto Onuki | 4d36b3a | 2016-04-27 12:00:17 -0700 | [diff] [blame] | 158 | // We don't expose this directly to non-test code because only ShortcutUser should add to/ |
| 159 | // remove from it. |
| 160 | @VisibleForTesting |
| 161 | ArrayMap<String, ShortcutPackage> getAllPackagesForTest() { |
Makoto Onuki | 3145924 | 2016-03-22 11:12:18 -0700 | [diff] [blame] | 162 | return mPackages; |
| 163 | } |
| 164 | |
Makoto Onuki | 6c1dbd5 | 2016-05-02 15:19:32 -0700 | [diff] [blame] | 165 | public boolean hasPackage(@NonNull String packageName) { |
| 166 | return mPackages.containsKey(packageName); |
| 167 | } |
| 168 | |
Makoto Onuki | fc4cf2d | 2016-08-24 11:10:26 -0700 | [diff] [blame] | 169 | private void addPackage(@NonNull ShortcutPackage p) { |
| 170 | p.replaceUser(this); |
| 171 | mPackages.put(p.getPackageName(), p); |
| 172 | } |
| 173 | |
Makoto Onuki | c51b287 | 2016-05-04 15:24:50 -0700 | [diff] [blame] | 174 | public ShortcutPackage removePackage(@NonNull String packageName) { |
Makoto Onuki | 0033b2a | 2016-04-14 17:19:16 -0700 | [diff] [blame] | 175 | final ShortcutPackage removed = mPackages.remove(packageName); |
| 176 | |
Makoto Onuki | c51b287 | 2016-05-04 15:24:50 -0700 | [diff] [blame] | 177 | mService.cleanupBitmapsForPackage(mUserId, packageName); |
Makoto Onuki | 0033b2a | 2016-04-14 17:19:16 -0700 | [diff] [blame] | 178 | |
| 179 | return removed; |
Makoto Onuki | 2e210c4 | 2016-03-30 08:30:36 -0700 | [diff] [blame] | 180 | } |
| 181 | |
Makoto Onuki | 4d36b3a | 2016-04-27 12:00:17 -0700 | [diff] [blame] | 182 | // We don't expose this directly to non-test code because only ShortcutUser should add to/ |
| 183 | // remove from it. |
| 184 | @VisibleForTesting |
| 185 | ArrayMap<PackageWithUser, ShortcutLauncher> getAllLaunchersForTest() { |
Makoto Onuki | 3145924 | 2016-03-22 11:12:18 -0700 | [diff] [blame] | 186 | return mLaunchers; |
| 187 | } |
| 188 | |
Makoto Onuki | fc4cf2d | 2016-08-24 11:10:26 -0700 | [diff] [blame] | 189 | private void addLauncher(ShortcutLauncher launcher) { |
| 190 | launcher.replaceUser(this); |
Makoto Onuki | 9da23fc | 2016-03-29 11:14:42 -0700 | [diff] [blame] | 191 | mLaunchers.put(PackageWithUser.of(launcher.getPackageUserId(), |
| 192 | launcher.getPackageName()), launcher); |
Makoto Onuki | d99c6f0 | 2016-03-28 11:02:54 -0700 | [diff] [blame] | 193 | } |
| 194 | |
Makoto Onuki | c51b287 | 2016-05-04 15:24:50 -0700 | [diff] [blame] | 195 | @Nullable |
Makoto Onuki | d99c6f0 | 2016-03-28 11:02:54 -0700 | [diff] [blame] | 196 | public ShortcutLauncher removeLauncher( |
Makoto Onuki | 9da23fc | 2016-03-29 11:14:42 -0700 | [diff] [blame] | 197 | @UserIdInt int packageUserId, @NonNull String packageName) { |
| 198 | return mLaunchers.remove(PackageWithUser.of(packageUserId, packageName)); |
Makoto Onuki | d99c6f0 | 2016-03-28 11:02:54 -0700 | [diff] [blame] | 199 | } |
| 200 | |
Makoto Onuki | c51b287 | 2016-05-04 15:24:50 -0700 | [diff] [blame] | 201 | @Nullable |
| 202 | public ShortcutPackage getPackageShortcutsIfExists(@NonNull String packageName) { |
| 203 | final ShortcutPackage ret = mPackages.get(packageName); |
| 204 | if (ret != null) { |
| 205 | ret.attemptToRestoreIfNeededAndSave(); |
Makoto Onuki | 3145924 | 2016-03-22 11:12:18 -0700 | [diff] [blame] | 206 | } |
| 207 | return ret; |
| 208 | } |
| 209 | |
Makoto Onuki | c51b287 | 2016-05-04 15:24:50 -0700 | [diff] [blame] | 210 | @NonNull |
| 211 | public ShortcutPackage getPackageShortcuts(@NonNull String packageName) { |
| 212 | ShortcutPackage ret = getPackageShortcutsIfExists(packageName); |
| 213 | if (ret == null) { |
| 214 | ret = new ShortcutPackage(this, mUserId, packageName); |
| 215 | mPackages.put(packageName, ret); |
| 216 | } |
| 217 | return ret; |
| 218 | } |
| 219 | |
| 220 | @NonNull |
| 221 | public ShortcutLauncher getLauncherShortcuts(@NonNull String packageName, |
Makoto Onuki | d99c6f0 | 2016-03-28 11:02:54 -0700 | [diff] [blame] | 222 | @UserIdInt int launcherUserId) { |
| 223 | final PackageWithUser key = PackageWithUser.of(launcherUserId, packageName); |
| 224 | ShortcutLauncher ret = mLaunchers.get(key); |
Makoto Onuki | 3145924 | 2016-03-22 11:12:18 -0700 | [diff] [blame] | 225 | if (ret == null) { |
Makoto Onuki | 4d36b3a | 2016-04-27 12:00:17 -0700 | [diff] [blame] | 226 | ret = new ShortcutLauncher(this, mUserId, packageName, launcherUserId); |
Makoto Onuki | d99c6f0 | 2016-03-28 11:02:54 -0700 | [diff] [blame] | 227 | mLaunchers.put(key, ret); |
Makoto Onuki | 2e210c4 | 2016-03-30 08:30:36 -0700 | [diff] [blame] | 228 | } else { |
Makoto Onuki | c51b287 | 2016-05-04 15:24:50 -0700 | [diff] [blame] | 229 | ret.attemptToRestoreIfNeededAndSave(); |
Makoto Onuki | 3145924 | 2016-03-22 11:12:18 -0700 | [diff] [blame] | 230 | } |
| 231 | return ret; |
| 232 | } |
| 233 | |
Makoto Onuki | 4d36b3a | 2016-04-27 12:00:17 -0700 | [diff] [blame] | 234 | public void forAllPackages(Consumer<? super ShortcutPackage> callback) { |
| 235 | final int size = mPackages.size(); |
| 236 | for (int i = 0; i < size; i++) { |
| 237 | callback.accept(mPackages.valueAt(i)); |
Makoto Onuki | 9da23fc | 2016-03-29 11:14:42 -0700 | [diff] [blame] | 238 | } |
Makoto Onuki | 4d36b3a | 2016-04-27 12:00:17 -0700 | [diff] [blame] | 239 | } |
| 240 | |
| 241 | public void forAllLaunchers(Consumer<? super ShortcutLauncher> callback) { |
| 242 | final int size = mLaunchers.size(); |
| 243 | for (int i = 0; i < size; i++) { |
| 244 | callback.accept(mLaunchers.valueAt(i)); |
Makoto Onuki | 9da23fc | 2016-03-29 11:14:42 -0700 | [diff] [blame] | 245 | } |
| 246 | } |
Makoto Onuki | 0acbb14 | 2016-03-22 17:02:57 -0700 | [diff] [blame] | 247 | |
Makoto Onuki | 4d36b3a | 2016-04-27 12:00:17 -0700 | [diff] [blame] | 248 | public void forAllPackageItems(Consumer<? super ShortcutPackageItem> callback) { |
| 249 | forAllLaunchers(callback); |
| 250 | forAllPackages(callback); |
| 251 | } |
| 252 | |
Makoto Onuki | 9da23fc | 2016-03-29 11:14:42 -0700 | [diff] [blame] | 253 | public void forPackageItem(@NonNull String packageName, @UserIdInt int packageUserId, |
| 254 | Consumer<ShortcutPackageItem> callback) { |
| 255 | forAllPackageItems(spi -> { |
| 256 | if ((spi.getPackageUserId() == packageUserId) |
| 257 | && spi.getPackageName().equals(packageName)) { |
| 258 | callback.accept(spi); |
| 259 | } |
| 260 | }); |
Makoto Onuki | 0acbb14 | 2016-03-22 17:02:57 -0700 | [diff] [blame] | 261 | } |
| 262 | |
Makoto Onuki | 39686e8 | 2016-04-13 18:03:00 -0700 | [diff] [blame] | 263 | /** |
Makoto Onuki | 4e6cef4 | 2016-07-13 16:14:01 -0700 | [diff] [blame] | 264 | * Must be called at any entry points on {@link ShortcutManager} APIs to make sure the |
| 265 | * information on the package is up-to-date. |
| 266 | * |
| 267 | * We use broadcasts to handle locale changes and package changes, but because broadcasts |
| 268 | * are asynchronous, there's a chance a publisher calls getXxxShortcuts() after a certain event |
| 269 | * (e.g. system locale change) but shortcut manager hasn't finished processing the broadcast. |
| 270 | * |
| 271 | * So we call this method at all entry points from publishers to make sure we update all |
| 272 | * relevant information. |
| 273 | * |
| 274 | * Similar inconsistencies can happen when the launcher fetches shortcut information, but |
| 275 | * that's a less of an issue because for the launcher we report shortcut changes with |
| 276 | * callbacks. |
Makoto Onuki | 4d36b3a | 2016-04-27 12:00:17 -0700 | [diff] [blame] | 277 | */ |
Makoto Onuki | 4e6cef4 | 2016-07-13 16:14:01 -0700 | [diff] [blame] | 278 | public void onCalledByPublisher(@NonNull String packageName) { |
| 279 | detectLocaleChange(); |
| 280 | rescanPackageIfNeeded(packageName, /*forceRescan=*/ false); |
Makoto Onuki | 4d36b3a | 2016-04-27 12:00:17 -0700 | [diff] [blame] | 281 | } |
| 282 | |
Makoto Onuki | 4e6cef4 | 2016-07-13 16:14:01 -0700 | [diff] [blame] | 283 | private String getKnownLocales() { |
| 284 | if (TextUtils.isEmpty(mKnownLocales)) { |
| 285 | mKnownLocales = mService.injectGetLocaleTagsForUser(mUserId); |
| 286 | mService.scheduleSaveUser(mUserId); |
| 287 | } |
| 288 | return mKnownLocales; |
| 289 | } |
| 290 | |
| 291 | /** |
| 292 | * Check to see if the system locale has changed, and if so, reset throttling |
| 293 | * and update resource strings. |
| 294 | */ |
| 295 | public void detectLocaleChange() { |
| 296 | final String currentLocales = mService.injectGetLocaleTagsForUser(mUserId); |
| 297 | if (getKnownLocales().equals(currentLocales)) { |
| 298 | return; |
| 299 | } |
| 300 | if (ShortcutService.DEBUG) { |
| 301 | Slog.d(TAG, "Locale changed from " + currentLocales + " to " + mKnownLocales |
| 302 | + " for user " + mUserId); |
| 303 | } |
| 304 | mKnownLocales = currentLocales; |
| 305 | |
| 306 | forAllPackages(pkg -> { |
| 307 | pkg.resetRateLimiting(); |
| 308 | pkg.resolveResourceStrings(); |
| 309 | }); |
| 310 | |
| 311 | mService.scheduleSaveUser(mUserId); |
| 312 | } |
| 313 | |
| 314 | public void rescanPackageIfNeeded(@NonNull String packageName, boolean forceRescan) { |
Makoto Onuki | 22fcc68 | 2016-05-17 14:52:19 -0700 | [diff] [blame] | 315 | final boolean isNewApp = !mPackages.containsKey(packageName); |
| 316 | |
| 317 | final ShortcutPackage shortcutPackage = getPackageShortcuts(packageName); |
| 318 | |
Makoto Onuki | 4e6cef4 | 2016-07-13 16:14:01 -0700 | [diff] [blame] | 319 | if (!shortcutPackage.rescanPackageIfNeeded(isNewApp, forceRescan)) { |
Makoto Onuki | 22fcc68 | 2016-05-17 14:52:19 -0700 | [diff] [blame] | 320 | if (isNewApp) { |
| 321 | mPackages.remove(packageName); |
| 322 | } |
Makoto Onuki | 39686e8 | 2016-04-13 18:03:00 -0700 | [diff] [blame] | 323 | } |
Makoto Onuki | 39686e8 | 2016-04-13 18:03:00 -0700 | [diff] [blame] | 324 | } |
| 325 | |
Makoto Onuki | 2e210c4 | 2016-03-30 08:30:36 -0700 | [diff] [blame] | 326 | public void attemptToRestoreIfNeededAndSave(ShortcutService s, @NonNull String packageName, |
| 327 | @UserIdInt int packageUserId) { |
| 328 | forPackageItem(packageName, packageUserId, spi -> { |
Makoto Onuki | c51b287 | 2016-05-04 15:24:50 -0700 | [diff] [blame] | 329 | spi.attemptToRestoreIfNeededAndSave(); |
Makoto Onuki | 2e210c4 | 2016-03-30 08:30:36 -0700 | [diff] [blame] | 330 | }); |
| 331 | } |
| 332 | |
Makoto Onuki | c51b287 | 2016-05-04 15:24:50 -0700 | [diff] [blame] | 333 | public void saveToXml(XmlSerializer out, boolean forBackup) |
Makoto Onuki | 0acbb14 | 2016-03-22 17:02:57 -0700 | [diff] [blame] | 334 | throws IOException, XmlPullParserException { |
Makoto Onuki | 3145924 | 2016-03-22 11:12:18 -0700 | [diff] [blame] | 335 | out.startTag(null, TAG_ROOT); |
| 336 | |
Makoto Onuki | fc4cf2d | 2016-08-24 11:10:26 -0700 | [diff] [blame] | 337 | if (!forBackup) { |
| 338 | // Don't have to back them up. |
| 339 | ShortcutService.writeAttr(out, ATTR_KNOWN_LOCALES, mKnownLocales); |
| 340 | ShortcutService.writeAttr(out, ATTR_LAST_APP_SCAN_TIME, |
| 341 | mLastAppScanTime); |
| 342 | ShortcutService.writeAttr(out, ATTR_LAST_APP_SCAN_OS_FINGERPRINT, |
| 343 | mLastAppScanOsFingerprint); |
Makoto Onuki | e3fffa9 | 2018-02-28 16:25:40 -0800 | [diff] [blame] | 344 | ShortcutService.writeAttr(out, ATTR_RESTORE_SOURCE_FINGERPRINT, |
| 345 | mRestoreFromOsFingerprint); |
Makoto Onuki | 4d36b3a | 2016-04-27 12:00:17 -0700 | [diff] [blame] | 346 | |
Makoto Onuki | fc4cf2d | 2016-08-24 11:10:26 -0700 | [diff] [blame] | 347 | ShortcutService.writeTagValue(out, TAG_LAUNCHER, mLastKnownLauncher); |
Makoto Onuki | e3fffa9 | 2018-02-28 16:25:40 -0800 | [diff] [blame] | 348 | } else { |
| 349 | ShortcutService.writeAttr(out, ATTR_RESTORE_SOURCE_FINGERPRINT, |
| 350 | mService.injectBuildFingerprint()); |
Makoto Onuki | fc4cf2d | 2016-08-24 11:10:26 -0700 | [diff] [blame] | 351 | } |
Makoto Onuki | 3145924 | 2016-03-22 11:12:18 -0700 | [diff] [blame] | 352 | |
Makoto Onuki | 9da23fc | 2016-03-29 11:14:42 -0700 | [diff] [blame] | 353 | // Can't use forEachPackageItem due to the checked exceptions. |
Makoto Onuki | 0acbb14 | 2016-03-22 17:02:57 -0700 | [diff] [blame] | 354 | { |
| 355 | final int size = mLaunchers.size(); |
| 356 | for (int i = 0; i < size; i++) { |
Makoto Onuki | c51b287 | 2016-05-04 15:24:50 -0700 | [diff] [blame] | 357 | saveShortcutPackageItem(out, mLaunchers.valueAt(i), forBackup); |
Makoto Onuki | 0acbb14 | 2016-03-22 17:02:57 -0700 | [diff] [blame] | 358 | } |
| 359 | } |
| 360 | { |
| 361 | final int size = mPackages.size(); |
| 362 | for (int i = 0; i < size; i++) { |
Makoto Onuki | c51b287 | 2016-05-04 15:24:50 -0700 | [diff] [blame] | 363 | saveShortcutPackageItem(out, mPackages.valueAt(i), forBackup); |
Makoto Onuki | 0acbb14 | 2016-03-22 17:02:57 -0700 | [diff] [blame] | 364 | } |
Makoto Onuki | 3145924 | 2016-03-22 11:12:18 -0700 | [diff] [blame] | 365 | } |
| 366 | |
| 367 | out.endTag(null, TAG_ROOT); |
| 368 | } |
| 369 | |
Makoto Onuki | c51b287 | 2016-05-04 15:24:50 -0700 | [diff] [blame] | 370 | private void saveShortcutPackageItem(XmlSerializer out, |
Makoto Onuki | 0acbb14 | 2016-03-22 17:02:57 -0700 | [diff] [blame] | 371 | ShortcutPackageItem spi, boolean forBackup) throws IOException, XmlPullParserException { |
Makoto Onuki | 9da23fc | 2016-03-29 11:14:42 -0700 | [diff] [blame] | 372 | if (forBackup) { |
Makoto Onuki | 9da23fc | 2016-03-29 11:14:42 -0700 | [diff] [blame] | 373 | if (spi.getPackageUserId() != spi.getOwnerUserId()) { |
| 374 | return; // Don't save cross-user information. |
| 375 | } |
Makoto Onuki | 0acbb14 | 2016-03-22 17:02:57 -0700 | [diff] [blame] | 376 | } |
| 377 | spi.saveToXml(out, forBackup); |
| 378 | } |
| 379 | |
Makoto Onuki | 9da23fc | 2016-03-29 11:14:42 -0700 | [diff] [blame] | 380 | public static ShortcutUser loadFromXml(ShortcutService s, XmlPullParser parser, int userId, |
Makoto Onuki | fc4cf2d | 2016-08-24 11:10:26 -0700 | [diff] [blame] | 381 | boolean fromBackup) throws IOException, XmlPullParserException, InvalidFileFormatException { |
Makoto Onuki | c51b287 | 2016-05-04 15:24:50 -0700 | [diff] [blame] | 382 | final ShortcutUser ret = new ShortcutUser(s, userId); |
Makoto Onuki | 3145924 | 2016-03-22 11:12:18 -0700 | [diff] [blame] | 383 | |
Makoto Onuki | fc4cf2d | 2016-08-24 11:10:26 -0700 | [diff] [blame] | 384 | try { |
| 385 | ret.mKnownLocales = ShortcutService.parseStringAttribute(parser, |
| 386 | ATTR_KNOWN_LOCALES); |
Makoto Onuki | 4d36b3a | 2016-04-27 12:00:17 -0700 | [diff] [blame] | 387 | |
Makoto Onuki | fc4cf2d | 2016-08-24 11:10:26 -0700 | [diff] [blame] | 388 | // If lastAppScanTime is in the future, that means the clock went backwards. |
| 389 | // Just scan all apps again. |
| 390 | final long lastAppScanTime = ShortcutService.parseLongAttribute(parser, |
| 391 | ATTR_LAST_APP_SCAN_TIME); |
| 392 | final long currentTime = s.injectCurrentTimeMillis(); |
| 393 | ret.mLastAppScanTime = lastAppScanTime < currentTime ? lastAppScanTime : 0; |
| 394 | ret.mLastAppScanOsFingerprint = ShortcutService.parseStringAttribute(parser, |
| 395 | ATTR_LAST_APP_SCAN_OS_FINGERPRINT); |
Makoto Onuki | e3fffa9 | 2018-02-28 16:25:40 -0800 | [diff] [blame] | 396 | ret.mRestoreFromOsFingerprint = ShortcutService.parseStringAttribute(parser, |
| 397 | ATTR_RESTORE_SOURCE_FINGERPRINT); |
Makoto Onuki | fc4cf2d | 2016-08-24 11:10:26 -0700 | [diff] [blame] | 398 | final int outerDepth = parser.getDepth(); |
| 399 | int type; |
| 400 | while ((type = parser.next()) != XmlPullParser.END_DOCUMENT |
| 401 | && (type != XmlPullParser.END_TAG || parser.getDepth() > outerDepth)) { |
| 402 | if (type != XmlPullParser.START_TAG) { |
| 403 | continue; |
| 404 | } |
| 405 | final int depth = parser.getDepth(); |
| 406 | final String tag = parser.getName(); |
Makoto Onuki | 3145924 | 2016-03-22 11:12:18 -0700 | [diff] [blame] | 407 | |
Makoto Onuki | fc4cf2d | 2016-08-24 11:10:26 -0700 | [diff] [blame] | 408 | if (depth == outerDepth + 1) { |
| 409 | switch (tag) { |
| 410 | case TAG_LAUNCHER: { |
| 411 | ret.mLastKnownLauncher = ShortcutService.parseComponentNameAttribute( |
| 412 | parser, ATTR_VALUE); |
| 413 | continue; |
| 414 | } |
| 415 | case ShortcutPackage.TAG_ROOT: { |
| 416 | final ShortcutPackage shortcuts = ShortcutPackage.loadFromXml( |
| 417 | s, ret, parser, fromBackup); |
Makoto Onuki | 3145924 | 2016-03-22 11:12:18 -0700 | [diff] [blame] | 418 | |
Makoto Onuki | fc4cf2d | 2016-08-24 11:10:26 -0700 | [diff] [blame] | 419 | // Don't use addShortcut(), we don't need to save the icon. |
| 420 | ret.mPackages.put(shortcuts.getPackageName(), shortcuts); |
| 421 | continue; |
| 422 | } |
Makoto Onuki | 0acbb14 | 2016-03-22 17:02:57 -0700 | [diff] [blame] | 423 | |
Makoto Onuki | fc4cf2d | 2016-08-24 11:10:26 -0700 | [diff] [blame] | 424 | case ShortcutLauncher.TAG_ROOT: { |
| 425 | ret.addLauncher( |
| 426 | ShortcutLauncher.loadFromXml(parser, ret, userId, fromBackup)); |
| 427 | continue; |
| 428 | } |
Makoto Onuki | 9da23fc | 2016-03-29 11:14:42 -0700 | [diff] [blame] | 429 | } |
Makoto Onuki | 3145924 | 2016-03-22 11:12:18 -0700 | [diff] [blame] | 430 | } |
Makoto Onuki | fc4cf2d | 2016-08-24 11:10:26 -0700 | [diff] [blame] | 431 | ShortcutService.warnForInvalidTag(depth, tag); |
Makoto Onuki | 3145924 | 2016-03-22 11:12:18 -0700 | [diff] [blame] | 432 | } |
Makoto Onuki | fc4cf2d | 2016-08-24 11:10:26 -0700 | [diff] [blame] | 433 | } catch (RuntimeException e) { |
| 434 | throw new ShortcutService.InvalidFileFormatException( |
| 435 | "Unable to parse file", e); |
Makoto Onuki | 3145924 | 2016-03-22 11:12:18 -0700 | [diff] [blame] | 436 | } |
| 437 | return ret; |
| 438 | } |
| 439 | |
Makoto Onuki | 1030520 | 2016-07-14 18:14:08 -0700 | [diff] [blame] | 440 | public ComponentName getLastKnownLauncher() { |
| 441 | return mLastKnownLauncher; |
Makoto Onuki | 3145924 | 2016-03-22 11:12:18 -0700 | [diff] [blame] | 442 | } |
| 443 | |
Makoto Onuki | 1030520 | 2016-07-14 18:14:08 -0700 | [diff] [blame] | 444 | public void setLauncher(ComponentName launcherComponent) { |
| 445 | setLauncher(launcherComponent, /* allowPurgeLastKnown */ false); |
| 446 | } |
| 447 | |
| 448 | /** Clears the launcher information without clearing the last known one */ |
| 449 | public void clearLauncher() { |
| 450 | setLauncher(null); |
| 451 | } |
| 452 | |
| 453 | /** |
| 454 | * Clears the launcher information *with(* clearing the last known one; we do this witl |
| 455 | * "cmd shortcut clear-default-launcher". |
| 456 | */ |
| 457 | public void forceClearLauncher() { |
| 458 | setLauncher(null, /* allowPurgeLastKnown */ true); |
| 459 | } |
| 460 | |
| 461 | private void setLauncher(ComponentName launcherComponent, boolean allowPurgeLastKnown) { |
| 462 | mCachedLauncher = launcherComponent; // Always update the in-memory cache. |
| 463 | |
Narayan Kamath | 607223f | 2018-02-19 14:09:02 +0000 | [diff] [blame] | 464 | if (Objects.equals(mLastKnownLauncher, launcherComponent)) { |
Makoto Onuki | 3145924 | 2016-03-22 11:12:18 -0700 | [diff] [blame] | 465 | return; |
| 466 | } |
Makoto Onuki | 1030520 | 2016-07-14 18:14:08 -0700 | [diff] [blame] | 467 | if (!allowPurgeLastKnown && launcherComponent == null) { |
| 468 | return; |
| 469 | } |
| 470 | mLastKnownLauncher = launcherComponent; |
Makoto Onuki | c51b287 | 2016-05-04 15:24:50 -0700 | [diff] [blame] | 471 | mService.scheduleSaveUser(mUserId); |
Makoto Onuki | 3145924 | 2016-03-22 11:12:18 -0700 | [diff] [blame] | 472 | } |
| 473 | |
Makoto Onuki | 1030520 | 2016-07-14 18:14:08 -0700 | [diff] [blame] | 474 | public ComponentName getCachedLauncher() { |
| 475 | return mCachedLauncher; |
| 476 | } |
| 477 | |
Makoto Onuki | 3145924 | 2016-03-22 11:12:18 -0700 | [diff] [blame] | 478 | public void resetThrottling() { |
| 479 | for (int i = mPackages.size() - 1; i >= 0; i--) { |
| 480 | mPackages.valueAt(i).resetThrottling(); |
| 481 | } |
| 482 | } |
| 483 | |
Makoto Onuki | fc4cf2d | 2016-08-24 11:10:26 -0700 | [diff] [blame] | 484 | public void mergeRestoredFile(ShortcutUser restored) { |
| 485 | final ShortcutService s = mService; |
| 486 | // Note, a restore happens only at the end of setup wizard. At this point, no apps are |
| 487 | // installed from Play Store yet, but it's still possible that system apps have already |
| 488 | // published dynamic shortcuts, since some apps do so on BOOT_COMPLETED. |
| 489 | // When such a system app has allowbackup=true, then we go ahead and replace all existing |
| 490 | // shortcuts with the restored shortcuts. (Then we'll re-publish manifest shortcuts later |
| 491 | // in the call site.) |
| 492 | // When such a system app has allowbackup=false, then we'll keep the shortcuts that have |
| 493 | // already been published. So we selectively add restored ShortcutPackages here. |
| 494 | // |
| 495 | // The same logic applies to launchers, but since launchers shouldn't pin shortcuts |
| 496 | // without users interaction it's really not a big deal, so we just clear existing |
| 497 | // ShortcutLauncher instances in mLaunchers and add all the restored ones here. |
| 498 | |
Makoto Onuki | 50a320e | 2017-05-31 14:38:42 -0700 | [diff] [blame] | 499 | int[] restoredLaunchers = new int[1]; |
| 500 | int[] restoredPackages = new int[1]; |
| 501 | int[] restoredShortcuts = new int[1]; |
| 502 | |
Makoto Onuki | fc4cf2d | 2016-08-24 11:10:26 -0700 | [diff] [blame] | 503 | mLaunchers.clear(); |
| 504 | restored.forAllLaunchers(sl -> { |
| 505 | // If the app is already installed and allowbackup = false, then ignore the restored |
| 506 | // data. |
| 507 | if (s.isPackageInstalled(sl.getPackageName(), getUserId()) |
| 508 | && !s.shouldBackupApp(sl.getPackageName(), getUserId())) { |
| 509 | return; |
| 510 | } |
| 511 | addLauncher(sl); |
Makoto Onuki | 50a320e | 2017-05-31 14:38:42 -0700 | [diff] [blame] | 512 | restoredLaunchers[0]++; |
Makoto Onuki | fc4cf2d | 2016-08-24 11:10:26 -0700 | [diff] [blame] | 513 | }); |
| 514 | restored.forAllPackages(sp -> { |
| 515 | // If the app is already installed and allowbackup = false, then ignore the restored |
| 516 | // data. |
| 517 | if (s.isPackageInstalled(sp.getPackageName(), getUserId()) |
| 518 | && !s.shouldBackupApp(sp.getPackageName(), getUserId())) { |
| 519 | return; |
| 520 | } |
| 521 | |
| 522 | final ShortcutPackage previous = getPackageShortcutsIfExists(sp.getPackageName()); |
| 523 | if (previous != null && previous.hasNonManifestShortcuts()) { |
| 524 | Log.w(TAG, "Shortcuts for package " + sp.getPackageName() + " are being restored." |
| 525 | + " Existing non-manifeset shortcuts will be overwritten."); |
| 526 | } |
| 527 | addPackage(sp); |
Makoto Onuki | 50a320e | 2017-05-31 14:38:42 -0700 | [diff] [blame] | 528 | restoredPackages[0]++; |
| 529 | restoredShortcuts[0] += sp.getShortcutCount(); |
Makoto Onuki | fc4cf2d | 2016-08-24 11:10:26 -0700 | [diff] [blame] | 530 | }); |
| 531 | // Empty the launchers and packages in restored to avoid accidentally using them. |
| 532 | restored.mLaunchers.clear(); |
| 533 | restored.mPackages.clear(); |
Makoto Onuki | 50a320e | 2017-05-31 14:38:42 -0700 | [diff] [blame] | 534 | |
Makoto Onuki | e3fffa9 | 2018-02-28 16:25:40 -0800 | [diff] [blame] | 535 | mRestoreFromOsFingerprint = restored.mRestoreFromOsFingerprint; |
| 536 | |
Makoto Onuki | 50a320e | 2017-05-31 14:38:42 -0700 | [diff] [blame] | 537 | Slog.i(TAG, "Restored: L=" + restoredLaunchers[0] |
| 538 | + " P=" + restoredPackages[0] |
| 539 | + " S=" + restoredShortcuts[0]); |
Makoto Onuki | fc4cf2d | 2016-08-24 11:10:26 -0700 | [diff] [blame] | 540 | } |
| 541 | |
Makoto Onuki | 20b8221 | 2017-10-04 15:03:50 -0700 | [diff] [blame] | 542 | public void dump(@NonNull PrintWriter pw, @NonNull String prefix, DumpFilter filter) { |
| 543 | if (filter.shouldDumpDetails()) { |
| 544 | pw.print(prefix); |
| 545 | pw.print("User: "); |
| 546 | pw.print(mUserId); |
| 547 | pw.print(" Known locales: "); |
| 548 | pw.print(mKnownLocales); |
| 549 | pw.print(" Last app scan: ["); |
| 550 | pw.print(mLastAppScanTime); |
| 551 | pw.print("] "); |
Makoto Onuki | e3fffa9 | 2018-02-28 16:25:40 -0800 | [diff] [blame] | 552 | pw.println(ShortcutService.formatTime(mLastAppScanTime)); |
Makoto Onuki | 3145924 | 2016-03-22 11:12:18 -0700 | [diff] [blame] | 553 | |
Makoto Onuki | 20b8221 | 2017-10-04 15:03:50 -0700 | [diff] [blame] | 554 | prefix += prefix + " "; |
Makoto Onuki | 0033b2a | 2016-04-14 17:19:16 -0700 | [diff] [blame] | 555 | |
Makoto Onuki | 20b8221 | 2017-10-04 15:03:50 -0700 | [diff] [blame] | 556 | pw.print(prefix); |
Makoto Onuki | e3fffa9 | 2018-02-28 16:25:40 -0800 | [diff] [blame] | 557 | pw.print("Last app scan FP: "); |
| 558 | pw.println(mLastAppScanOsFingerprint); |
| 559 | |
| 560 | pw.print(prefix); |
| 561 | pw.print("Restore from FP: "); |
| 562 | pw.print(mRestoreFromOsFingerprint); |
| 563 | pw.println(); |
| 564 | |
| 565 | |
| 566 | pw.print(prefix); |
Makoto Onuki | 20b8221 | 2017-10-04 15:03:50 -0700 | [diff] [blame] | 567 | pw.print("Cached launcher: "); |
| 568 | pw.print(mCachedLauncher); |
| 569 | pw.println(); |
Makoto Onuki | 1030520 | 2016-07-14 18:14:08 -0700 | [diff] [blame] | 570 | |
Makoto Onuki | 20b8221 | 2017-10-04 15:03:50 -0700 | [diff] [blame] | 571 | pw.print(prefix); |
| 572 | pw.print("Last known launcher: "); |
| 573 | pw.print(mLastKnownLauncher); |
| 574 | pw.println(); |
| 575 | } |
Makoto Onuki | 3145924 | 2016-03-22 11:12:18 -0700 | [diff] [blame] | 576 | |
| 577 | for (int i = 0; i < mLaunchers.size(); i++) { |
Makoto Onuki | 20b8221 | 2017-10-04 15:03:50 -0700 | [diff] [blame] | 578 | ShortcutLauncher launcher = mLaunchers.valueAt(i); |
| 579 | if (filter.isPackageMatch(launcher.getPackageName())) { |
| 580 | launcher.dump(pw, prefix, filter); |
| 581 | } |
Makoto Onuki | 3145924 | 2016-03-22 11:12:18 -0700 | [diff] [blame] | 582 | } |
| 583 | |
| 584 | for (int i = 0; i < mPackages.size(); i++) { |
Makoto Onuki | 20b8221 | 2017-10-04 15:03:50 -0700 | [diff] [blame] | 585 | ShortcutPackage pkg = mPackages.valueAt(i); |
| 586 | if (filter.isPackageMatch(pkg.getPackageName())) { |
| 587 | pkg.dump(pw, prefix, filter); |
| 588 | } |
Makoto Onuki | 3145924 | 2016-03-22 11:12:18 -0700 | [diff] [blame] | 589 | } |
Makoto Onuki | 0033b2a | 2016-04-14 17:19:16 -0700 | [diff] [blame] | 590 | |
Makoto Onuki | 20b8221 | 2017-10-04 15:03:50 -0700 | [diff] [blame] | 591 | if (filter.shouldDumpDetails()) { |
| 592 | pw.println(); |
| 593 | pw.print(prefix); |
| 594 | pw.println("Bitmap directories: "); |
| 595 | dumpDirectorySize(pw, prefix + " ", mService.getUserBitmapFilePath(mUserId)); |
| 596 | } |
Makoto Onuki | 0033b2a | 2016-04-14 17:19:16 -0700 | [diff] [blame] | 597 | } |
| 598 | |
Makoto Onuki | c51b287 | 2016-05-04 15:24:50 -0700 | [diff] [blame] | 599 | private void dumpDirectorySize(@NonNull PrintWriter pw, |
Makoto Onuki | 0033b2a | 2016-04-14 17:19:16 -0700 | [diff] [blame] | 600 | @NonNull String prefix, File path) { |
| 601 | int numFiles = 0; |
| 602 | long size = 0; |
| 603 | final File[] children = path.listFiles(); |
| 604 | if (children != null) { |
| 605 | for (File child : path.listFiles()) { |
| 606 | if (child.isFile()) { |
| 607 | numFiles++; |
| 608 | size += child.length(); |
| 609 | } else if (child.isDirectory()) { |
Makoto Onuki | c51b287 | 2016-05-04 15:24:50 -0700 | [diff] [blame] | 610 | dumpDirectorySize(pw, prefix + " ", child); |
Makoto Onuki | 0033b2a | 2016-04-14 17:19:16 -0700 | [diff] [blame] | 611 | } |
| 612 | } |
| 613 | } |
| 614 | pw.print(prefix); |
| 615 | pw.print("Path: "); |
| 616 | pw.print(path.getName()); |
| 617 | pw.print("/ has "); |
| 618 | pw.print(numFiles); |
| 619 | pw.print(" files, size="); |
| 620 | pw.print(size); |
| 621 | pw.print(" ("); |
Makoto Onuki | c51b287 | 2016-05-04 15:24:50 -0700 | [diff] [blame] | 622 | pw.print(Formatter.formatFileSize(mService.mContext, size)); |
Makoto Onuki | 0033b2a | 2016-04-14 17:19:16 -0700 | [diff] [blame] | 623 | pw.println(")"); |
Makoto Onuki | 3145924 | 2016-03-22 11:12:18 -0700 | [diff] [blame] | 624 | } |
Makoto Onuki | 7626992 | 2016-07-15 14:58:54 -0700 | [diff] [blame] | 625 | |
| 626 | public JSONObject dumpCheckin(boolean clear) throws JSONException { |
| 627 | final JSONObject result = new JSONObject(); |
| 628 | |
| 629 | result.put(KEY_USER_ID, mUserId); |
| 630 | |
| 631 | { |
| 632 | final JSONArray launchers = new JSONArray(); |
| 633 | for (int i = 0; i < mLaunchers.size(); i++) { |
| 634 | launchers.put(mLaunchers.valueAt(i).dumpCheckin(clear)); |
| 635 | } |
| 636 | result.put(KEY_LAUNCHERS, launchers); |
| 637 | } |
| 638 | |
| 639 | { |
| 640 | final JSONArray packages = new JSONArray(); |
| 641 | for (int i = 0; i < mPackages.size(); i++) { |
| 642 | packages.put(mPackages.valueAt(i).dumpCheckin(clear)); |
| 643 | } |
| 644 | result.put(KEY_PACKAGES, packages); |
| 645 | } |
| 646 | |
| 647 | return result; |
| 648 | } |
Makoto Onuki | 3145924 | 2016-03-22 11:12:18 -0700 | [diff] [blame] | 649 | } |