Narayan Kamath | c034fe9 | 2019-01-23 10:48:17 +0000 | [diff] [blame] | 1 | /* |
| 2 | * Copyright (C) 2019 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 | |
| 17 | package com.android.server.rollback; |
| 18 | |
| 19 | import android.content.rollback.PackageRollbackInfo; |
| 20 | import android.content.rollback.PackageRollbackInfo.RestoreInfo; |
Narayan Kamath | c034fe9 | 2019-01-23 10:48:17 +0000 | [diff] [blame] | 21 | import android.os.storage.StorageManager; |
| 22 | import android.util.IntArray; |
| 23 | import android.util.Log; |
Nikita Ioffe | 952aa7b | 2019-01-28 19:49:56 +0000 | [diff] [blame] | 24 | import android.util.SparseLongArray; |
Narayan Kamath | c034fe9 | 2019-01-23 10:48:17 +0000 | [diff] [blame] | 25 | |
| 26 | import com.android.internal.annotations.VisibleForTesting; |
| 27 | import com.android.server.pm.Installer; |
| 28 | import com.android.server.pm.Installer.InstallerException; |
| 29 | |
| 30 | import java.util.ArrayList; |
Nikita Ioffe | 5dcd1797 | 2019-02-04 11:08:13 +0000 | [diff] [blame] | 31 | import java.util.HashMap; |
Richard Uhler | e9aaf63 | 2019-03-01 16:03:01 +0000 | [diff] [blame] | 32 | import java.util.HashSet; |
Nikita Ioffe | 5dcd1797 | 2019-02-04 11:08:13 +0000 | [diff] [blame] | 33 | import java.util.Iterator; |
Narayan Kamath | c034fe9 | 2019-01-23 10:48:17 +0000 | [diff] [blame] | 34 | import java.util.List; |
| 35 | import java.util.Map; |
Richard Uhler | e9aaf63 | 2019-03-01 16:03:01 +0000 | [diff] [blame] | 36 | import java.util.Set; |
Narayan Kamath | c034fe9 | 2019-01-23 10:48:17 +0000 | [diff] [blame] | 37 | |
| 38 | /** |
| 39 | * Encapsulates the logic for initiating userdata snapshots and rollbacks via installd. |
| 40 | */ |
| 41 | @VisibleForTesting |
| 42 | // TODO(narayan): Reason about the failure scenarios that involve one or more IPCs to installd |
| 43 | // failing. We need to decide what course of action to take if calls to snapshotAppData or |
| 44 | // restoreAppDataSnapshot fail. |
| 45 | public class AppDataRollbackHelper { |
| 46 | private static final String TAG = "RollbackManager"; |
| 47 | |
| 48 | private final Installer mInstaller; |
| 49 | |
| 50 | public AppDataRollbackHelper(Installer installer) { |
| 51 | mInstaller = installer; |
| 52 | } |
| 53 | |
| 54 | /** |
Nikita Ioffe | 5dcd1797 | 2019-02-04 11:08:13 +0000 | [diff] [blame] | 55 | * Creates an app data snapshot for a specified {@code packageRollbackInfo}. Updates said {@code |
| 56 | * packageRollbackInfo} with the inodes of the CE user data snapshot folders. |
Narayan Kamath | c034fe9 | 2019-01-23 10:48:17 +0000 | [diff] [blame] | 57 | */ |
Nikita Ioffe | 5dcd1797 | 2019-02-04 11:08:13 +0000 | [diff] [blame] | 58 | public void snapshotAppData(int snapshotId, PackageRollbackInfo packageRollbackInfo) { |
| 59 | final int[] installedUsers = packageRollbackInfo.getInstalledUsers().toArray(); |
Narayan Kamath | c034fe9 | 2019-01-23 10:48:17 +0000 | [diff] [blame] | 60 | for (int user : installedUsers) { |
| 61 | final int storageFlags; |
| 62 | if (isUserCredentialLocked(user)) { |
| 63 | // We've encountered a user that hasn't unlocked on a FBE device, so we can't copy |
| 64 | // across app user data until the user unlocks their device. |
| 65 | Log.v(TAG, "User: " + user + " isn't unlocked, skipping CE userdata backup."); |
| 66 | storageFlags = Installer.FLAG_STORAGE_DE; |
Nikita Ioffe | 5dcd1797 | 2019-02-04 11:08:13 +0000 | [diff] [blame] | 67 | packageRollbackInfo.addPendingBackup(user); |
Narayan Kamath | c034fe9 | 2019-01-23 10:48:17 +0000 | [diff] [blame] | 68 | } else { |
| 69 | storageFlags = Installer.FLAG_STORAGE_CE | Installer.FLAG_STORAGE_DE; |
| 70 | } |
| 71 | |
| 72 | try { |
Nikita Ioffe | 5dcd1797 | 2019-02-04 11:08:13 +0000 | [diff] [blame] | 73 | long ceSnapshotInode = mInstaller.snapshotAppData( |
| 74 | packageRollbackInfo.getPackageName(), user, snapshotId, storageFlags); |
Nikita Ioffe | 952aa7b | 2019-01-28 19:49:56 +0000 | [diff] [blame] | 75 | if ((storageFlags & Installer.FLAG_STORAGE_CE) != 0) { |
Nikita Ioffe | 5dcd1797 | 2019-02-04 11:08:13 +0000 | [diff] [blame] | 76 | packageRollbackInfo.putCeSnapshotInode(user, ceSnapshotInode); |
Nikita Ioffe | 952aa7b | 2019-01-28 19:49:56 +0000 | [diff] [blame] | 77 | } |
Narayan Kamath | c034fe9 | 2019-01-23 10:48:17 +0000 | [diff] [blame] | 78 | } catch (InstallerException ie) { |
Nikita Ioffe | 5dcd1797 | 2019-02-04 11:08:13 +0000 | [diff] [blame] | 79 | Log.e(TAG, "Unable to create app data snapshot for: " |
| 80 | + packageRollbackInfo.getPackageName() + ", userId: " + user, ie); |
Narayan Kamath | c034fe9 | 2019-01-23 10:48:17 +0000 | [diff] [blame] | 81 | } |
| 82 | } |
Narayan Kamath | c034fe9 | 2019-01-23 10:48:17 +0000 | [diff] [blame] | 83 | } |
| 84 | |
| 85 | /** |
Nikita Ioffe | 5dcd1797 | 2019-02-04 11:08:13 +0000 | [diff] [blame] | 86 | * Restores an app data snapshot for a specified {@code packageRollbackInfo}, for a specified |
| 87 | * {@code userId}. |
Narayan Kamath | c034fe9 | 2019-01-23 10:48:17 +0000 | [diff] [blame] | 88 | * |
Nikita Ioffe | 5dcd1797 | 2019-02-04 11:08:13 +0000 | [diff] [blame] | 89 | * @return {@code true} iff. a change to the {@code packageRollbackInfo} has been made. Changes |
| 90 | * to {@code packageRollbackInfo} are restricted to the removal or addition of {@code |
| 91 | * userId} to the list of pending backups or restores. |
Narayan Kamath | c034fe9 | 2019-01-23 10:48:17 +0000 | [diff] [blame] | 92 | */ |
Nikita Ioffe | 5dcd1797 | 2019-02-04 11:08:13 +0000 | [diff] [blame] | 93 | public boolean restoreAppData(int rollbackId, PackageRollbackInfo packageRollbackInfo, |
| 94 | int userId, int appId, String seInfo) { |
Narayan Kamath | c034fe9 | 2019-01-23 10:48:17 +0000 | [diff] [blame] | 95 | int storageFlags = Installer.FLAG_STORAGE_DE; |
| 96 | |
Nikita Ioffe | 5dcd1797 | 2019-02-04 11:08:13 +0000 | [diff] [blame] | 97 | final IntArray pendingBackups = packageRollbackInfo.getPendingBackups(); |
| 98 | final List<RestoreInfo> pendingRestores = packageRollbackInfo.getPendingRestores(); |
Narayan Kamath | c034fe9 | 2019-01-23 10:48:17 +0000 | [diff] [blame] | 99 | boolean changedRollbackData = false; |
| 100 | |
| 101 | // If we still have a userdata backup pending for this user, it implies that the user |
| 102 | // hasn't unlocked their device between the point of backup and the point of restore, |
| 103 | // so the data cannot have changed. We simply skip restoring CE data in this case. |
| 104 | if (pendingBackups != null && pendingBackups.indexOf(userId) != -1) { |
| 105 | pendingBackups.remove(pendingBackups.indexOf(userId)); |
| 106 | changedRollbackData = true; |
| 107 | } else { |
| 108 | // There's no pending CE backup for this user, which means that we successfully |
| 109 | // managed to backup data for the user, which means we seek to restore it |
| 110 | if (isUserCredentialLocked(userId)) { |
| 111 | // We've encountered a user that hasn't unlocked on a FBE device, so we can't |
| 112 | // copy across app user data until the user unlocks their device. |
| 113 | pendingRestores.add(new RestoreInfo(userId, appId, seInfo)); |
| 114 | changedRollbackData = true; |
| 115 | } else { |
| 116 | // This user has unlocked, we can proceed to restore both CE and DE data. |
| 117 | storageFlags = storageFlags | Installer.FLAG_STORAGE_CE; |
| 118 | } |
| 119 | } |
| 120 | |
| 121 | try { |
Nikita Ioffe | 5dcd1797 | 2019-02-04 11:08:13 +0000 | [diff] [blame] | 122 | mInstaller.restoreAppDataSnapshot(packageRollbackInfo.getPackageName(), appId, seInfo, |
| 123 | userId, rollbackId, storageFlags); |
Narayan Kamath | c034fe9 | 2019-01-23 10:48:17 +0000 | [diff] [blame] | 124 | } catch (InstallerException ie) { |
Nikita Ioffe | 5dcd1797 | 2019-02-04 11:08:13 +0000 | [diff] [blame] | 125 | Log.e(TAG, "Unable to restore app data snapshot: " |
| 126 | + packageRollbackInfo.getPackageName(), ie); |
Narayan Kamath | c034fe9 | 2019-01-23 10:48:17 +0000 | [diff] [blame] | 127 | } |
| 128 | |
| 129 | return changedRollbackData; |
| 130 | } |
| 131 | |
| 132 | /** |
Nikita Ioffe | 5dcd1797 | 2019-02-04 11:08:13 +0000 | [diff] [blame] | 133 | * Deletes an app data snapshot with a given {@code rollbackId} for a specified package |
| 134 | * {@code packageName} for a given {@code user}. |
Nikita Ioffe | 952aa7b | 2019-01-28 19:49:56 +0000 | [diff] [blame] | 135 | */ |
Nikita Ioffe | 5dcd1797 | 2019-02-04 11:08:13 +0000 | [diff] [blame] | 136 | public void destroyAppDataSnapshot(int rollbackId, PackageRollbackInfo packageRollbackInfo, |
| 137 | int user) { |
Nikita Ioffe | 952aa7b | 2019-01-28 19:49:56 +0000 | [diff] [blame] | 138 | int storageFlags = Installer.FLAG_STORAGE_DE; |
Nikita Ioffe | 5dcd1797 | 2019-02-04 11:08:13 +0000 | [diff] [blame] | 139 | final SparseLongArray ceSnapshotInodes = packageRollbackInfo.getCeSnapshotInodes(); |
| 140 | long ceSnapshotInode = ceSnapshotInodes.get(user); |
Nikita Ioffe | 952aa7b | 2019-01-28 19:49:56 +0000 | [diff] [blame] | 141 | if (ceSnapshotInode > 0) { |
| 142 | storageFlags |= Installer.FLAG_STORAGE_CE; |
| 143 | } |
| 144 | try { |
Nikita Ioffe | 5dcd1797 | 2019-02-04 11:08:13 +0000 | [diff] [blame] | 145 | mInstaller.destroyAppDataSnapshot(packageRollbackInfo.getPackageName(), user, |
| 146 | ceSnapshotInode, rollbackId, storageFlags); |
| 147 | if ((storageFlags & Installer.FLAG_STORAGE_CE) != 0) { |
| 148 | ceSnapshotInodes.delete(user); |
| 149 | } |
Nikita Ioffe | 952aa7b | 2019-01-28 19:49:56 +0000 | [diff] [blame] | 150 | } catch (InstallerException ie) { |
Nikita Ioffe | 5dcd1797 | 2019-02-04 11:08:13 +0000 | [diff] [blame] | 151 | Log.e(TAG, "Unable to delete app data snapshot for " |
| 152 | + packageRollbackInfo.getPackageName(), ie); |
Nikita Ioffe | 952aa7b | 2019-01-28 19:49:56 +0000 | [diff] [blame] | 153 | } |
| 154 | } |
| 155 | |
| 156 | /** |
Richard Uhler | 6f8a33b | 2019-02-26 10:40:36 +0000 | [diff] [blame] | 157 | * Computes the list of pending backups for {@code userId} given lists of rollbacks. |
Nikita Ioffe | 5dcd1797 | 2019-02-04 11:08:13 +0000 | [diff] [blame] | 158 | * Packages pending backup for the given user are added to {@code pendingBackupPackages} along |
| 159 | * with their corresponding {@code PackageRollbackInfo}. |
Narayan Kamath | c034fe9 | 2019-01-23 10:48:17 +0000 | [diff] [blame] | 160 | * |
Nikita Ioffe | 5dcd1797 | 2019-02-04 11:08:13 +0000 | [diff] [blame] | 161 | * @return the list of {@code RollbackData} that has pending backups. Note that some of the |
| 162 | * backups won't be performed, because they might be counteracted by pending restores. |
Narayan Kamath | c034fe9 | 2019-01-23 10:48:17 +0000 | [diff] [blame] | 163 | */ |
Nikita Ioffe | 5dcd1797 | 2019-02-04 11:08:13 +0000 | [diff] [blame] | 164 | private static List<RollbackData> computePendingBackups(int userId, |
| 165 | Map<String, PackageRollbackInfo> pendingBackupPackages, |
Richard Uhler | 6f8a33b | 2019-02-26 10:40:36 +0000 | [diff] [blame] | 166 | List<RollbackData> rollbacks) { |
Narayan Kamath | c034fe9 | 2019-01-23 10:48:17 +0000 | [diff] [blame] | 167 | List<RollbackData> rd = new ArrayList<>(); |
Nikita Ioffe | 5dcd1797 | 2019-02-04 11:08:13 +0000 | [diff] [blame] | 168 | |
Richard Uhler | 6f8a33b | 2019-02-26 10:40:36 +0000 | [diff] [blame] | 169 | for (RollbackData data : rollbacks) { |
Richard Uhler | cca637a | 2019-02-27 11:50:48 +0000 | [diff] [blame] | 170 | for (PackageRollbackInfo info : data.info.getPackages()) { |
Narayan Kamath | c034fe9 | 2019-01-23 10:48:17 +0000 | [diff] [blame] | 171 | final IntArray pendingBackupUsers = info.getPendingBackups(); |
| 172 | if (pendingBackupUsers != null) { |
| 173 | final int idx = pendingBackupUsers.indexOf(userId); |
| 174 | if (idx != -1) { |
Nikita Ioffe | 5dcd1797 | 2019-02-04 11:08:13 +0000 | [diff] [blame] | 175 | pendingBackupPackages.put(info.getPackageName(), info); |
Narayan Kamath | c034fe9 | 2019-01-23 10:48:17 +0000 | [diff] [blame] | 176 | if (rd.indexOf(data) == -1) { |
| 177 | rd.add(data); |
| 178 | } |
| 179 | } |
| 180 | } |
| 181 | } |
| 182 | } |
Nikita Ioffe | 5dcd1797 | 2019-02-04 11:08:13 +0000 | [diff] [blame] | 183 | return rd; |
| 184 | } |
Narayan Kamath | c034fe9 | 2019-01-23 10:48:17 +0000 | [diff] [blame] | 185 | |
Nikita Ioffe | 5dcd1797 | 2019-02-04 11:08:13 +0000 | [diff] [blame] | 186 | /** |
Richard Uhler | 6f8a33b | 2019-02-26 10:40:36 +0000 | [diff] [blame] | 187 | * Computes the list of pending restores for {@code userId} given lists of rollbacks. |
Nikita Ioffe | 5dcd1797 | 2019-02-04 11:08:13 +0000 | [diff] [blame] | 188 | * Packages pending restore are added to {@code pendingRestores} along with their corresponding |
| 189 | * {@code PackageRollbackInfo}. |
| 190 | * |
Richard Uhler | 6f8a33b | 2019-02-26 10:40:36 +0000 | [diff] [blame] | 191 | * @return the list of {@code RollbackData} that has pending restores. Note that some of the |
Nikita Ioffe | 5dcd1797 | 2019-02-04 11:08:13 +0000 | [diff] [blame] | 192 | * restores won't be performed, because they might be counteracted by pending backups. |
| 193 | */ |
Richard Uhler | 6f8a33b | 2019-02-26 10:40:36 +0000 | [diff] [blame] | 194 | private static List<RollbackData> computePendingRestores(int userId, |
Nikita Ioffe | 5dcd1797 | 2019-02-04 11:08:13 +0000 | [diff] [blame] | 195 | Map<String, PackageRollbackInfo> pendingRestorePackages, |
Richard Uhler | 6f8a33b | 2019-02-26 10:40:36 +0000 | [diff] [blame] | 196 | List<RollbackData> rollbacks) { |
| 197 | List<RollbackData> rd = new ArrayList<>(); |
Nikita Ioffe | 5dcd1797 | 2019-02-04 11:08:13 +0000 | [diff] [blame] | 198 | |
Richard Uhler | 6f8a33b | 2019-02-26 10:40:36 +0000 | [diff] [blame] | 199 | for (RollbackData data : rollbacks) { |
| 200 | for (PackageRollbackInfo info : data.info.getPackages()) { |
Narayan Kamath | c034fe9 | 2019-01-23 10:48:17 +0000 | [diff] [blame] | 201 | final RestoreInfo ri = info.getRestoreInfo(userId); |
| 202 | if (ri != null) { |
Nikita Ioffe | 5dcd1797 | 2019-02-04 11:08:13 +0000 | [diff] [blame] | 203 | pendingRestorePackages.put(info.getPackageName(), info); |
| 204 | if (rd.indexOf(data) == -1) { |
| 205 | rd.add(data); |
Narayan Kamath | c034fe9 | 2019-01-23 10:48:17 +0000 | [diff] [blame] | 206 | } |
Narayan Kamath | c034fe9 | 2019-01-23 10:48:17 +0000 | [diff] [blame] | 207 | } |
| 208 | } |
| 209 | } |
| 210 | |
| 211 | return rd; |
| 212 | } |
| 213 | |
| 214 | /** |
Nikita Ioffe | 952aa7b | 2019-01-28 19:49:56 +0000 | [diff] [blame] | 215 | * Commits the list of pending backups and restores for a given {@code userId}. For the pending |
| 216 | * backups updates corresponding {@code changedRollbackData} with a mapping from {@code userId} |
| 217 | * to a inode of theirs CE user data snapshot. |
Nikita Ioffe | 5dcd1797 | 2019-02-04 11:08:13 +0000 | [diff] [blame] | 218 | * |
Richard Uhler | e9aaf63 | 2019-03-01 16:03:01 +0000 | [diff] [blame] | 219 | * @return the set of {@code RollbackData} that have been changed and should be stored on disk. |
Narayan Kamath | c034fe9 | 2019-01-23 10:48:17 +0000 | [diff] [blame] | 220 | */ |
Richard Uhler | e9aaf63 | 2019-03-01 16:03:01 +0000 | [diff] [blame] | 221 | public Set<RollbackData> commitPendingBackupAndRestoreForUser(int userId, |
Richard Uhler | 6f8a33b | 2019-02-26 10:40:36 +0000 | [diff] [blame] | 222 | List<RollbackData> rollbacks) { |
Nikita Ioffe | 5dcd1797 | 2019-02-04 11:08:13 +0000 | [diff] [blame] | 223 | |
| 224 | final Map<String, PackageRollbackInfo> pendingBackupPackages = new HashMap<>(); |
| 225 | final List<RollbackData> pendingBackups = computePendingBackups(userId, |
Richard Uhler | 6f8a33b | 2019-02-26 10:40:36 +0000 | [diff] [blame] | 226 | pendingBackupPackages, rollbacks); |
Nikita Ioffe | 5dcd1797 | 2019-02-04 11:08:13 +0000 | [diff] [blame] | 227 | |
| 228 | final Map<String, PackageRollbackInfo> pendingRestorePackages = new HashMap<>(); |
Richard Uhler | 6f8a33b | 2019-02-26 10:40:36 +0000 | [diff] [blame] | 229 | final List<RollbackData> pendingRestores = computePendingRestores(userId, |
| 230 | pendingRestorePackages, rollbacks); |
Nikita Ioffe | 5dcd1797 | 2019-02-04 11:08:13 +0000 | [diff] [blame] | 231 | |
| 232 | // First remove unnecessary backups, i.e. when user did not unlock their phone between the |
| 233 | // request to backup data and the request to restore it. |
| 234 | Iterator<Map.Entry<String, PackageRollbackInfo>> iter = |
| 235 | pendingBackupPackages.entrySet().iterator(); |
| 236 | while (iter.hasNext()) { |
| 237 | PackageRollbackInfo backupPackage = iter.next().getValue(); |
| 238 | PackageRollbackInfo restorePackage = |
| 239 | pendingRestorePackages.get(backupPackage.getPackageName()); |
| 240 | if (restorePackage != null) { |
| 241 | backupPackage.removePendingBackup(userId); |
| 242 | backupPackage.removePendingRestoreInfo(userId); |
| 243 | iter.remove(); |
| 244 | pendingRestorePackages.remove(backupPackage.getPackageName()); |
| 245 | } |
| 246 | } |
| 247 | |
| 248 | if (!pendingBackupPackages.isEmpty()) { |
| 249 | for (RollbackData data : pendingBackups) { |
Richard Uhler | cca637a | 2019-02-27 11:50:48 +0000 | [diff] [blame] | 250 | for (PackageRollbackInfo info : data.info.getPackages()) { |
Nikita Ioffe | 5dcd1797 | 2019-02-04 11:08:13 +0000 | [diff] [blame] | 251 | final IntArray pendingBackupUsers = info.getPendingBackups(); |
| 252 | final int idx = pendingBackupUsers.indexOf(userId); |
| 253 | if (idx != -1) { |
| 254 | try { |
| 255 | long ceSnapshotInode = mInstaller.snapshotAppData(info.getPackageName(), |
Richard Uhler | cca637a | 2019-02-27 11:50:48 +0000 | [diff] [blame] | 256 | userId, data.info.getRollbackId(), Installer.FLAG_STORAGE_CE); |
Nikita Ioffe | 5dcd1797 | 2019-02-04 11:08:13 +0000 | [diff] [blame] | 257 | info.putCeSnapshotInode(userId, ceSnapshotInode); |
| 258 | pendingBackupUsers.remove(idx); |
| 259 | } catch (InstallerException ie) { |
| 260 | Log.e(TAG, |
| 261 | "Unable to create app data snapshot for: " |
| 262 | + info.getPackageName() + ", userId: " + userId, ie); |
Nikita Ioffe | 952aa7b | 2019-01-28 19:49:56 +0000 | [diff] [blame] | 263 | } |
| 264 | } |
Narayan Kamath | c034fe9 | 2019-01-23 10:48:17 +0000 | [diff] [blame] | 265 | } |
| 266 | } |
| 267 | } |
| 268 | |
Nikita Ioffe | 5dcd1797 | 2019-02-04 11:08:13 +0000 | [diff] [blame] | 269 | if (!pendingRestorePackages.isEmpty()) { |
Richard Uhler | 6f8a33b | 2019-02-26 10:40:36 +0000 | [diff] [blame] | 270 | for (RollbackData data : pendingRestores) { |
| 271 | for (PackageRollbackInfo info : data.info.getPackages()) { |
Nikita Ioffe | 5dcd1797 | 2019-02-04 11:08:13 +0000 | [diff] [blame] | 272 | final RestoreInfo ri = info.getRestoreInfo(userId); |
| 273 | if (ri != null) { |
| 274 | try { |
| 275 | mInstaller.restoreAppDataSnapshot(info.getPackageName(), ri.appId, |
Richard Uhler | 6f8a33b | 2019-02-26 10:40:36 +0000 | [diff] [blame] | 276 | ri.seInfo, userId, data.info.getRollbackId(), |
Nikita Ioffe | 5dcd1797 | 2019-02-04 11:08:13 +0000 | [diff] [blame] | 277 | Installer.FLAG_STORAGE_CE); |
| 278 | info.removeRestoreInfo(ri); |
| 279 | } catch (InstallerException ie) { |
| 280 | Log.e(TAG, "Unable to restore app data snapshot for: " |
| 281 | + info.getPackageName(), ie); |
| 282 | } |
| 283 | } |
Narayan Kamath | c034fe9 | 2019-01-23 10:48:17 +0000 | [diff] [blame] | 284 | } |
| 285 | } |
| 286 | } |
Nikita Ioffe | 5dcd1797 | 2019-02-04 11:08:13 +0000 | [diff] [blame] | 287 | |
Richard Uhler | e9aaf63 | 2019-03-01 16:03:01 +0000 | [diff] [blame] | 288 | final Set<RollbackData> changed = new HashSet<>(pendingBackups); |
Richard Uhler | 6f8a33b | 2019-02-26 10:40:36 +0000 | [diff] [blame] | 289 | changed.addAll(pendingRestores); |
| 290 | return changed; |
Narayan Kamath | c034fe9 | 2019-01-23 10:48:17 +0000 | [diff] [blame] | 291 | } |
| 292 | |
| 293 | /** |
| 294 | * @return {@code true} iff. {@code userId} is locked on an FBE device. |
| 295 | */ |
| 296 | @VisibleForTesting |
| 297 | public boolean isUserCredentialLocked(int userId) { |
| 298 | return StorageManager.isFileEncryptedNativeOrEmulated() |
| 299 | && !StorageManager.isUserKeyUnlocked(userId); |
| 300 | } |
Narayan Kamath | c034fe9 | 2019-01-23 10:48:17 +0000 | [diff] [blame] | 301 | } |