• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
1 /*
2  * Copyright (C) 2011 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.pm;
18 
19 import static android.app.admin.flags.Flags.crossUserSuspensionEnabledRo;
20 import static android.content.pm.ApplicationInfo.PRIVATE_FLAG_DEFAULT_TO_DEVICE_PROTECTED_STORAGE;
21 import static android.content.pm.PackageManager.COMPONENT_ENABLED_STATE_DEFAULT;
22 import static android.content.pm.PackageManager.COMPONENT_ENABLED_STATE_DISABLED;
23 import static android.content.pm.PackageManager.COMPONENT_ENABLED_STATE_ENABLED;
24 
25 import android.annotation.IntDef;
26 import android.annotation.NonNull;
27 import android.annotation.Nullable;
28 import android.annotation.UserIdInt;
29 import android.content.ComponentName;
30 import android.content.Context;
31 import android.content.pm.ApplicationInfo;
32 import android.content.pm.PackageManager;
33 import android.content.pm.SharedLibraryInfo;
34 import android.content.pm.SigningDetails;
35 import android.content.pm.SigningInfo;
36 import android.content.pm.UserInfo;
37 import android.content.pm.UserPackage;
38 import android.content.pm.overlay.OverlayPaths;
39 import android.os.UserHandle;
40 import android.os.incremental.IncrementalManager;
41 import android.service.pm.PackageProto;
42 import android.service.pm.PackageProto.UserInfoProto.ArchiveState.ArchiveActivityInfo;
43 import android.text.TextUtils;
44 import android.util.ArrayMap;
45 import android.util.ArraySet;
46 import android.util.IntArray;
47 import android.util.SparseArray;
48 import android.util.proto.ProtoOutputStream;
49 
50 import com.android.internal.annotations.VisibleForTesting;
51 import com.android.internal.pm.parsing.pkg.AndroidPackageInternal;
52 import com.android.internal.util.CollectionUtils;
53 import com.android.internal.util.DataClass;
54 import com.android.server.pm.parsing.pkg.AndroidPackageUtils;
55 import com.android.server.pm.permission.LegacyPermissionDataProvider;
56 import com.android.server.pm.permission.LegacyPermissionState;
57 import com.android.server.pm.pkg.AndroidPackage;
58 import com.android.server.pm.pkg.ArchiveState;
59 import com.android.server.pm.pkg.PackageState;
60 import com.android.server.pm.pkg.PackageStateInternal;
61 import com.android.server.pm.pkg.PackageStateUnserialized;
62 import com.android.server.pm.pkg.PackageUserState;
63 import com.android.server.pm.pkg.PackageUserStateImpl;
64 import com.android.server.pm.pkg.PackageUserStateInternal;
65 import com.android.server.pm.pkg.SharedLibrary;
66 import com.android.server.pm.pkg.SharedLibraryWrapper;
67 import com.android.server.pm.pkg.SuspendParams;
68 import com.android.server.utils.SnapshotCache;
69 import com.android.server.utils.WatchedArraySet;
70 
71 import libcore.util.EmptyArray;
72 
73 import java.io.File;
74 import java.util.ArrayList;
75 import java.util.Arrays;
76 import java.util.Collection;
77 import java.util.Collections;
78 import java.util.LinkedHashSet;
79 import java.util.List;
80 import java.util.Map;
81 import java.util.Objects;
82 import java.util.Set;
83 import java.util.UUID;
84 
85 /**
86  * Settings data for a particular package we know about.
87  *
88  * @hide
89  */
90 @DataClass(genGetters = true, genConstructor = false, genSetters = false, genBuilder = false)
91 @DataClass.Suppress({"getSnapshot", "getBooleans"})
92 public class PackageSetting extends SettingBase implements PackageStateInternal {
93 
94     // Use a bitset to store boolean data to save memory
95     private static class Booleans {
96         @IntDef({
97                 INSTALL_PERMISSION_FIXED,
98                 UPDATE_AVAILABLE,
99                 FORCE_QUERYABLE_OVERRIDE,
100                 SCANNED_AS_STOPPED_SYSTEM_APP,
101                 PENDING_RESTORE,
102                 DEBUGGABLE,
103                 IS_LEAVING_SHARED_USER,
104         })
105         public @interface Flags {
106         }
107         private static final int INSTALL_PERMISSION_FIXED = 1;
108         private static final int UPDATE_AVAILABLE = 1 << 1;
109         private static final int FORCE_QUERYABLE_OVERRIDE = 1 << 2;
110         private static final int SCANNED_AS_STOPPED_SYSTEM_APP = 1 << 3;
111         private static final int PENDING_RESTORE = 1 << 4;
112         private static final int DEBUGGABLE = 1 << 5;
113         private static final int IS_LEAVING_SHARED_USER = 1 << 6;
114     }
115     private int mBooleans;
116 
setBoolean(@ooleans.Flags int flag, boolean value)117     private void setBoolean(@Booleans.Flags int flag, boolean value) {
118         if (value) {
119             mBooleans |= flag;
120         } else {
121             mBooleans &= ~flag;
122         }
123     }
124 
getBoolean(@ooleans.Flags int flag)125     private boolean getBoolean(@Booleans.Flags int flag) {
126         return (mBooleans & flag) != 0;
127     }
128 
129     /**
130      * The shared user ID lets us link this object to {@link SharedUserSetting}.
131      */
132     private int mSharedUserAppId;
133 
134     @Nullable
135     private Map<String, Set<String>> mimeGroups;
136 
137     // TODO(b/314036181): encapsulate all these fields for usesSdk, instead of having three
138     //  separate arrays.
139     @Nullable
140     private String[] usesSdkLibraries;
141 
142     @Nullable
143     private long[] usesSdkLibrariesVersionsMajor;
144     @Nullable
145     private boolean[] usesSdkLibrariesOptional;
146 
147     @Nullable
148     private String[] usesStaticLibraries;
149 
150     @Nullable
151     private long[] usesStaticLibrariesVersions;
152 
153     /**
154      * The path under which native libraries have been unpacked. This path is
155      * always derived at runtime, and is only stored here for cleanup when a
156      * package is uninstalled.
157      */
158     @Nullable
159     @Deprecated
160     private String legacyNativeLibraryPath;
161 
162     @NonNull
163     private String mName;
164 
165     @Nullable
166     private String mRealName;
167 
168     private int mAppId;
169 
170     /**
171      * It is expected that all code that uses a {@link PackageSetting} understands this inner field
172      * may be null. Note that this relationship only works one way. It should not be possible to
173      * have an entry inside {@link PackageManagerService#mPackages} without a corresponding
174      * {@link PackageSetting} inside {@link Settings#mPackages}.
175      *
176      * @see PackageState#getAndroidPackage()
177      */
178     @Nullable
179     private AndroidPackageInternal pkg;
180 
181     /** @see AndroidPackage#getPath() */
182     @NonNull
183     private File mPath;
184     @NonNull
185     private String mPathString;
186     @Nullable
187     private LinkedHashSet<File> mOldPaths;
188 
189     private float mLoadingProgress;
190     private long mLoadingCompletedTime;
191 
192     @Nullable
193     private String mPrimaryCpuAbi;
194 
195     @Nullable
196     private String mSecondaryCpuAbi;
197 
198     @Nullable
199     private String mCpuAbiOverride;
200 
201     private long mLastModifiedTime;
202     private long lastUpdateTime;
203     private long versionCode;
204 
205     @NonNull
206     private PackageSignatures signatures;
207 
208     @NonNull
209     private PackageKeySetData keySetData = new PackageKeySetData();
210 
211     // TODO: Access is not locked.
212     @NonNull
213     private final SparseArray<PackageUserStateImpl> mUserStates = new SparseArray<>();
214 
215     @NonNull
216     private InstallSource installSource;
217 
218     /** @see PackageState#getVolumeUuid() */
219     @Nullable
220     private String volumeUuid;
221 
222     /** @see PackageState#getCategoryOverride() */
223     private int categoryOverride = ApplicationInfo.CATEGORY_UNDEFINED;
224 
225     private int mPageSizeAppCompatFlags = ApplicationInfo.PAGE_SIZE_APP_COMPAT_FLAG_UNDEFINED;
226 
227     @NonNull
228     private final PackageStateUnserialized pkgState = new PackageStateUnserialized(this);
229 
230     @NonNull
231     private UUID mDomainSetId;
232 
233     @Nullable
234     private String mAppMetadataFilePath;
235 
236     private int mAppMetadataSource = PackageManager.APP_METADATA_SOURCE_UNKNOWN;
237 
238     private int mTargetSdkVersion;
239 
240     @Nullable
241     private byte[] mRestrictUpdateHash;
242 
243     // This is the copy of the same data stored in AndroidPackage. It is not null if the
244     // AndroidPackage is deleted in cases of DELETE_KEEP_DATA. When AndroidPackage is not null,
245     // the field will be null, and the getter method will return the data from AndroidPackage
246     // instead.
247     @Nullable
248     private String[] mSplitNames;
249 
250     // This is the copy of the same data stored in AndroidPackage. It is not null if the
251     // AndroidPackage is deleted in cases of DELETE_KEEP_DATA. When AndroidPackage is not null,
252     // the field will be null, and the getter method will return the data from AndroidPackage
253     // instead.
254     @Nullable
255     private int[] mSplitRevisionCodes;
256 
257     private int mBaseRevisionCode;
258 
259     /**
260      * Snapshot support.
261      */
262     @NonNull
263     private final SnapshotCache<PackageSetting> mSnapshot;
264 
makeCache()265     private SnapshotCache<PackageSetting> makeCache() {
266         return new SnapshotCache<PackageSetting>(this, this) {
267             @Override
268             public PackageSetting createSnapshot() {
269                 return new PackageSetting(mSource, true);
270             }};
271     }
272 
273     @VisibleForTesting(visibility = VisibleForTesting.Visibility.PACKAGE)
274     public PackageSetting(@NonNull String name, @Nullable String realName, @NonNull File path,
275                           int pkgFlags, int pkgPrivateFlags, @NonNull UUID domainSetId) {
276         super(pkgFlags, pkgPrivateFlags);
277         this.mName = name;
278         this.mRealName = realName;
279         this.mPath = path;
280         this.mPathString = path.toString();
281         this.signatures = new PackageSignatures();
282         this.installSource = InstallSource.EMPTY;
283         this.mDomainSetId = domainSetId;
284         mSnapshot = makeCache();
285     }
286 
287     /**
288      * New instance of PackageSetting replicating the original settings.
289      * Note that it keeps the same PackageParser.Package instance.
290      */
291     PackageSetting(PackageSetting orig) {
292         this(orig, false);
293     }
294 
295     /**
296      * New instance of PackageSetting with one-level-deep cloning.
297      * <p>
298      * IMPORTANT: With a shallow copy, we do NOT create new contained objects.
299      * This means, for example, changes to the user state of the original PackageSetting
300      * will also change the user state in its copy.
301      */
302     PackageSetting(PackageSetting base, String realPkgName) {
303         this(base, false);
304         this.mRealName = realPkgName;
305     }
306 
307     @VisibleForTesting(visibility = VisibleForTesting.Visibility.PACKAGE)
308     public PackageSetting(@NonNull PackageSetting original, boolean sealedSnapshot)  {
309         super(original);
310         copyPackageSetting(original, sealedSnapshot);
311         if (sealedSnapshot) {
312             mSnapshot = new SnapshotCache.Sealed();
313         } else {
314             mSnapshot = makeCache();
315         }
316     }
317 
318     /**
319      * Return the package snapshot.
320      */
321     public PackageSetting snapshot() {
322         return mSnapshot.snapshot();
323     }
324 
325     public void dumpDebug(ProtoOutputStream proto, long fieldId, List<UserInfo> users,
326             LegacyPermissionDataProvider dataProvider) {
327         final long packageToken = proto.start(fieldId);
328         proto.write(PackageProto.NAME, (mRealName != null ? mRealName : mName));
329         proto.write(PackageProto.UID, mAppId);
330         proto.write(PackageProto.VERSION_CODE, versionCode);
331         proto.write(PackageProto.UPDATE_TIME_MS, lastUpdateTime);
332         proto.write(PackageProto.INSTALLER_NAME, installSource.mInstallerPackageName);
333 
334         if (pkg != null) {
335             proto.write(PackageProto.VERSION_STRING, pkg.getVersionName());
336 
337             long splitToken = proto.start(PackageProto.SPLITS);
338             proto.write(PackageProto.SplitProto.NAME, "base");
339             proto.write(PackageProto.SplitProto.REVISION_CODE, pkg.getBaseRevisionCode());
340             proto.end(splitToken);
341 
342             for (int i = 0; i < pkg.getSplitNames().length; i++) {
343                 splitToken = proto.start(PackageProto.SPLITS);
344                 proto.write(PackageProto.SplitProto.NAME, pkg.getSplitNames()[i]);
345                 proto.write(PackageProto.SplitProto.REVISION_CODE,
346                         pkg.getSplitRevisionCodes()[i]);
347                 proto.end(splitToken);
348             }
349 
350             long sourceToken = proto.start(PackageProto.INSTALL_SOURCE);
351             proto.write(PackageProto.InstallSourceProto.INITIATING_PACKAGE_NAME,
352                     installSource.mInitiatingPackageName);
353             proto.write(PackageProto.InstallSourceProto.ORIGINATING_PACKAGE_NAME,
354                     installSource.mOriginatingPackageName);
355             proto.write(PackageProto.InstallSourceProto.UPDATE_OWNER_PACKAGE_NAME,
356                     installSource.mUpdateOwnerPackageName);
357             proto.end(sourceToken);
358         }
359         proto.write(PackageProto.StatesProto.IS_LOADING, isLoading());
360         writeUsersInfoToProto(proto, PackageProto.USERS);
361         writePackageUserPermissionsProto(proto, PackageProto.USER_PERMISSIONS, users, dataProvider);
362         proto.end(packageToken);
363     }
364 
365     public PackageSetting setAppId(int appId) {
366         this.mAppId = appId;
367         onChanged();
368         return this;
369     }
370 
371     public PackageSetting setCpuAbiOverride(String cpuAbiOverrideString) {
372         this.mCpuAbiOverride = cpuAbiOverrideString;
373         onChanged();
374         return this;
375     }
376 
377     /**
378      * In case of replacing an old package, restore the first install timestamps if it was installed
379      * for the same users
380      */
381     public PackageSetting setFirstInstallTimeFromReplaced(PackageStateInternal replacedPkgSetting,
382             int[] userIds) {
383         for (int userId = 0; userId < userIds.length; userId++) {
384             final long previousFirstInstallTime =
385                     replacedPkgSetting.getUserStateOrDefault(userId).getFirstInstallTimeMillis();
386             if (previousFirstInstallTime != 0) {
387                 modifyUserState(userId).setFirstInstallTimeMillis(previousFirstInstallTime);
388             }
389         }
390         onChanged();
391         return this;
392     }
393 
394     /**
395      * Set the time for the first time when an app is installed for a user. If userId specifies all
396      * users, set the same timestamp for all the users.
397      */
398     public PackageSetting setFirstInstallTime(long firstInstallTime, int userId) {
399         if (userId == UserHandle.USER_ALL) {
400             int userStateCount = mUserStates.size();
401             for (int i = 0; i < userStateCount; i++) {
402                 mUserStates.valueAt(i).setFirstInstallTimeMillis(firstInstallTime);
403             }
404         } else {
405             modifyUserState(userId).setFirstInstallTimeMillis(firstInstallTime);
406         }
407         onChanged();
408         return this;
409     }
410 
411     public PackageSetting setForceQueryableOverride(boolean forceQueryableOverride) {
412         setBoolean(Booleans.FORCE_QUERYABLE_OVERRIDE, forceQueryableOverride);
413         onChanged();
414         return this;
415     }
416 
417     public PackageSetting setInstallerPackage(@Nullable String installerPackageName,
418             int installerPackageUid) {
419         installSource = installSource.setInstallerPackage(installerPackageName,
420                 installerPackageUid);
421         onChanged();
422         return this;
423     }
424 
425     public PackageSetting setUpdateOwnerPackage(@Nullable String updateOwnerPackageName) {
426         installSource = installSource.setUpdateOwnerPackageName(updateOwnerPackageName);
427         onChanged();
428         return this;
429     }
430 
431     public PackageSetting setInstallSource(InstallSource installSource) {
432         this.installSource = Objects.requireNonNull(installSource);
433         onChanged();
434         return this;
435     }
436 
437     PackageSetting removeInstallerPackage(@Nullable String packageName) {
438         installSource = installSource.removeInstallerPackage(packageName);
439         onChanged();
440         return this;
441     }
442 
443     public PackageSetting setIsOrphaned(boolean isOrphaned) {
444         installSource = installSource.setIsOrphaned(isOrphaned);
445         onChanged();
446         return this;
447     }
448 
449     public PackageSetting setKeySetData(PackageKeySetData keySetData) {
450         this.keySetData = keySetData;
451         onChanged();
452         return this;
453     }
454 
455     public PackageSetting setLastModifiedTime(long timeStamp) {
456         this.mLastModifiedTime = timeStamp;
457         onChanged();
458         return this;
459     }
460 
461     public PackageSetting setLastUpdateTime(long lastUpdateTime) {
462         this.lastUpdateTime = lastUpdateTime;
463         onChanged();
464         return this;
465     }
466 
467     public PackageSetting setLongVersionCode(long versionCode) {
468         this.versionCode = versionCode;
469         onChanged();
470         return this;
471     }
472 
473     public boolean setMimeGroup(String mimeGroup, ArraySet<String> newMimeTypes) {
474         Set<String> oldMimeTypes = mimeGroups == null ? null : mimeGroups.get(mimeGroup);
475         if (oldMimeTypes == null) {
476             throw new IllegalArgumentException("Unknown MIME group " + mimeGroup
477                     + " for package " + mName);
478         }
479 
480         boolean hasChanges = !newMimeTypes.equals(oldMimeTypes);
481         mimeGroups.put(mimeGroup, newMimeTypes);
482         if (hasChanges) {
483             onChanged();
484         }
485         return hasChanges;
486     }
487 
488     // TODO: Remove, only commit package when it's actually finalized
489     public PackageSetting setPkg(AndroidPackage pkg) {
490         this.pkg = (AndroidPackageInternal) pkg;
491         onChanged();
492         return this;
493     }
494 
495     /**
496      * Notify {@link #onChanged()}  if the parameter {@code usesLibraryFiles} is different from
497      * {@link #getUsesLibraryFiles()}.
498      *
499      * @param usesLibraryFiles the new uses library files
500      * @return {@code this}
501      */
502     public PackageSetting setPkgStateLibraryFiles(@NonNull Collection<String> usesLibraryFiles) {
503         final Collection<String> oldUsesLibraryFiles = getUsesLibraryFiles();
504         if (oldUsesLibraryFiles.size() != usesLibraryFiles.size()
505                 || !oldUsesLibraryFiles.containsAll(usesLibraryFiles)) {
506             pkgState.setUsesLibraryFiles(new ArrayList<>(usesLibraryFiles));
507             onChanged();
508         }
509         return this;
510     }
511 
512     public PackageSetting setPrimaryCpuAbi(String primaryCpuAbiString) {
513         this.mPrimaryCpuAbi = primaryCpuAbiString;
514         onChanged();
515         return this;
516     }
517 
518     public PackageSetting setSecondaryCpuAbi(String secondaryCpuAbiString) {
519         this.mSecondaryCpuAbi = secondaryCpuAbiString;
520         onChanged();
521         return this;
522     }
523 
524     public PackageSetting setSignatures(PackageSignatures signatures) {
525         this.signatures = signatures;
526         onChanged();
527         return this;
528     }
529 
530     public PackageSetting setVolumeUuid(String volumeUuid) {
531         this.volumeUuid = volumeUuid;
532         onChanged();
533         return this;
534     }
535 
536     @Override
537     public boolean isExternalStorage() {
538         return (getFlags() & ApplicationInfo.FLAG_EXTERNAL_STORAGE) != 0;
539     }
540 
541     public PackageSetting setUpdateAvailable(boolean updateAvailable) {
542         setBoolean(Booleans.UPDATE_AVAILABLE, updateAvailable);
543         onChanged();
544         return this;
545     }
546 
547     public PackageSetting setSharedUserAppId(int sharedUserAppId) {
548         mSharedUserAppId = sharedUserAppId;
549         onChanged();
550         return this;
551     }
552 
553     public PackageSetting setTargetSdkVersion(int targetSdkVersion) {
554         mTargetSdkVersion = targetSdkVersion;
555         onChanged();
556         return this;
557     }
558 
559     public PackageSetting setRestrictUpdateHash(byte[] restrictUpdateHash) {
560         mRestrictUpdateHash = restrictUpdateHash;
561         onChanged();
562         return this;
563     }
564 
565     @Override
566     public int getSharedUserAppId() {
567         return mSharedUserAppId;
568     }
569 
570     @Override
571     public boolean hasSharedUser() {
572         return mSharedUserAppId > 0;
573     }
574 
575     /**
576      * @see PackageState#isPendingRestore()
577      */
578     public PackageSetting setPendingRestore(boolean value) {
579         setBoolean(Booleans.PENDING_RESTORE, value);
580         onChanged();
581         return this;
582     }
583 
584     @Override
585     public boolean isPendingRestore() {
586         return getBoolean(Booleans.PENDING_RESTORE);
587     }
588 
589     /**
590      * @see PackageState#isDebuggable
591      */
592     public PackageSetting setDebuggable(boolean value) {
593         setBoolean(Booleans.DEBUGGABLE, value);
594         onChanged();
595         return this;
596     }
597 
598     @Override
599     public boolean isDebuggable() {
600         return getBoolean(Booleans.DEBUGGABLE);
601     }
602 
603     /**
604      * @see PackageState#isLeavingSharedUser
605      */
606     public PackageSetting setLeavingSharedUser(boolean value) {
607         setBoolean(Booleans.IS_LEAVING_SHARED_USER, value);
608         onChanged();
609         return this;
610     }
611 
612     @Override
613     public boolean isLeavingSharedUser() {
614         return getBoolean(Booleans.IS_LEAVING_SHARED_USER);
615     }
616 
617     /**
618      * @see AndroidPackage#getBaseRevisionCode
619      */
620     public PackageSetting setBaseRevisionCode(int value) {
621         mBaseRevisionCode = value;
622         onChanged();
623         return this;
624     }
625 
626     /**
627      * @see AndroidPackage#getBaseRevisionCode
628      */
629     public int getBaseRevisionCode() {
630         return mBaseRevisionCode;
631     }
632 
633     /**
634      * @see AndroidPackage#getSplitNames
635      */
636     public PackageSetting setSplitNames(String[] value) {
637         mSplitNames = value;
638         onChanged();
639         return this;
640     }
641 
642     /**
643      * @see AndroidPackage#getSplitNames
644      */
645     @NonNull
646     public String[] getSplitNames() {
647         if (pkg != null) {
648             return pkg.getSplitNames();
649         }
650         return mSplitNames == null ? EmptyArray.STRING : mSplitNames;
651     }
652 
653     /**
654      * @see AndroidPackage#getSplitRevisionCodes
655      */
656     public PackageSetting setSplitRevisionCodes(int[] value) {
657         mSplitRevisionCodes = value;
658         onChanged();
659         return this;
660     }
661 
662     /**
663      * @see AndroidPackage#getSplitRevisionCodes
664      */
665     @NonNull
666     public int[] getSplitRevisionCodes() {
667         if (pkg != null) {
668             return pkg.getSplitRevisionCodes();
669         }
670         return mSplitRevisionCodes == null ? EmptyArray.INT : mSplitRevisionCodes;
671     }
672 
673     @Override
674     public String toString() {
675         return "PackageSetting{"
676                 + Integer.toHexString(System.identityHashCode(this))
677                 + " " + mName + "/" + mAppId + "}";
678     }
679 
680     private void copyMimeGroups(@Nullable Map<String, Set<String>> newMimeGroups) {
681         if (newMimeGroups == null) {
682             mimeGroups = null;
683             return;
684         }
685 
686         mimeGroups = new ArrayMap<>(newMimeGroups.size());
687         for (String mimeGroup : newMimeGroups.keySet()) {
688             Set<String> mimeTypes = newMimeGroups.get(mimeGroup);
689 
690             if (mimeTypes != null) {
691                 mimeGroups.put(mimeGroup, new ArraySet<>(mimeTypes));
692             } else {
693                 mimeGroups.put(mimeGroup, new ArraySet<>());
694             }
695         }
696     }
697 
698     /** Updates all fields in the current setting from another. */
699     public void updateFrom(PackageSetting other) {
700         copyPackageSetting(other, false /* sealedSnapshot */);
701 
702         Set<String> mimeGroupNames = other.mimeGroups != null ? other.mimeGroups.keySet() : null;
703         updateMimeGroups(mimeGroupNames);
704 
705         onChanged();
706     }
707 
708     /**
709      * Updates declared MIME groups, removing no longer declared groups
710      * and keeping previous state of MIME groups
711      */
712     PackageSetting updateMimeGroups(@Nullable Set<String> newMimeGroupNames) {
713         if (newMimeGroupNames == null) {
714             mimeGroups = null;
715             return this;
716         }
717 
718         if (mimeGroups == null) {
719             // set mimeGroups to empty map to avoid repeated null-checks in the next loop
720             mimeGroups = Collections.emptyMap();
721         }
722 
723         ArrayMap<String, Set<String>> updatedMimeGroups =
724                 new ArrayMap<>(newMimeGroupNames.size());
725 
726         for (String mimeGroup : newMimeGroupNames) {
727             if (mimeGroups.containsKey(mimeGroup)) {
728                 updatedMimeGroups.put(mimeGroup, mimeGroups.get(mimeGroup));
729             } else {
730                 updatedMimeGroups.put(mimeGroup, new ArraySet<>());
731             }
732         }
733         onChanged();
734         mimeGroups = updatedMimeGroups;
735         return this;
736     }
737 
738     @Deprecated
739     @Override
740     public LegacyPermissionState getLegacyPermissionState() {
741         return super.getLegacyPermissionState();
742     }
743 
744     public PackageSetting setInstallPermissionsFixed(boolean installPermissionsFixed) {
745         setBoolean(Booleans.INSTALL_PERMISSION_FIXED, installPermissionsFixed);
746         return this;
747     }
748 
749     public boolean isPrivileged() {
750         return (getPrivateFlags() & ApplicationInfo.PRIVATE_FLAG_PRIVILEGED) != 0;
751     }
752 
753     public boolean isOem() {
754         return (getPrivateFlags() & ApplicationInfo.PRIVATE_FLAG_OEM) != 0;
755     }
756 
757     public boolean isVendor() {
758         return (getPrivateFlags() & ApplicationInfo.PRIVATE_FLAG_VENDOR) != 0;
759     }
760 
761     public boolean isProduct() {
762         return (getPrivateFlags() & ApplicationInfo.PRIVATE_FLAG_PRODUCT) != 0;
763     }
764 
765     @Override
766     public boolean isRequiredForSystemUser() {
767         return (getPrivateFlags() & ApplicationInfo.PRIVATE_FLAG_REQUIRED_FOR_SYSTEM_USER) != 0;
768     }
769 
770     public boolean isSystemExt() {
771         return (getPrivateFlags() & ApplicationInfo.PRIVATE_FLAG_SYSTEM_EXT) != 0;
772     }
773 
774     public boolean isOdm() {
775         return (getPrivateFlags() & ApplicationInfo.PRIVATE_FLAG_ODM) != 0;
776     }
777 
778     public boolean isSystem() {
779         return (getFlags() & ApplicationInfo.FLAG_SYSTEM) != 0;
780     }
781 
782     public boolean isRequestLegacyExternalStorage() {
783         return (getPrivateFlags() & ApplicationInfo.PRIVATE_FLAG_REQUEST_LEGACY_EXTERNAL_STORAGE)
784                 != 0;
785     }
786 
787     public boolean isUserDataFragile() {
788         return (getPrivateFlags() & ApplicationInfo.PRIVATE_FLAG_HAS_FRAGILE_USER_DATA)
789                 != 0;
790     }
791 
792     public SigningDetails getSigningDetails() {
793         return signatures.mSigningDetails;
794     }
795 
796     public PackageSetting setSigningDetails(SigningDetails signingDetails) {
797         // TODO: Immutability
798         signatures.mSigningDetails = signingDetails;
799         onChanged();
800         return this;
801     }
802 
803     public void copyPackageSetting(PackageSetting other, boolean sealedSnapshot) {
804         super.copySettingBase(other);
805         mBooleans = other.mBooleans;
806         mSharedUserAppId = other.mSharedUserAppId;
807         mLoadingProgress = other.mLoadingProgress;
808         mLoadingCompletedTime = other.mLoadingCompletedTime;
809         legacyNativeLibraryPath = other.legacyNativeLibraryPath;
810         mName = other.mName;
811         mRealName = other.mRealName;
812         mAppId = other.mAppId;
813         pkg = other.pkg;
814         mPath = other.mPath;
815         mPathString = other.mPathString;
816         mOldPaths = other.mOldPaths == null ? null : new LinkedHashSet<>(other.mOldPaths);
817         mPrimaryCpuAbi = other.mPrimaryCpuAbi;
818         mSecondaryCpuAbi = other.mSecondaryCpuAbi;
819         mCpuAbiOverride = other.mCpuAbiOverride;
820         mLastModifiedTime = other.mLastModifiedTime;
821         lastUpdateTime = other.lastUpdateTime;
822         versionCode = other.versionCode;
823         signatures = other.signatures;
824         keySetData = new PackageKeySetData(other.keySetData);
825         installSource = other.installSource;
826         volumeUuid = other.volumeUuid;
827         categoryOverride = other.categoryOverride;
828         mDomainSetId = other.mDomainSetId;
829         mAppMetadataFilePath = other.mAppMetadataFilePath;
830         mAppMetadataSource = other.mAppMetadataSource;
831         mTargetSdkVersion = other.mTargetSdkVersion;
832         mRestrictUpdateHash = other.mRestrictUpdateHash == null
833                 ? null : other.mRestrictUpdateHash.clone();
834         mBaseRevisionCode = other.mBaseRevisionCode;
835         mSplitNames = other.mSplitNames != null
836                 ? Arrays.copyOf(other.mSplitNames, other.mSplitNames.length) : null;
837         mSplitRevisionCodes = other.mSplitRevisionCodes != null
838                 ? Arrays.copyOf(other.mSplitRevisionCodes, other.mSplitRevisionCodes.length) : null;
839 
840         usesSdkLibraries = other.usesSdkLibraries != null
841                 ? Arrays.copyOf(other.usesSdkLibraries,
842                 other.usesSdkLibraries.length) : null;
843         usesSdkLibrariesVersionsMajor = other.usesSdkLibrariesVersionsMajor != null
844                 ? Arrays.copyOf(other.usesSdkLibrariesVersionsMajor,
845                 other.usesSdkLibrariesVersionsMajor.length) : null;
846         usesSdkLibrariesOptional = other.usesSdkLibrariesOptional != null
847                 ? Arrays.copyOf(other.usesSdkLibrariesOptional,
848                 other.usesSdkLibrariesOptional.length) : null;
849 
850         usesStaticLibraries = other.usesStaticLibraries != null
851                 ? Arrays.copyOf(other.usesStaticLibraries,
852                 other.usesStaticLibraries.length) : null;
853         usesStaticLibrariesVersions = other.usesStaticLibrariesVersions != null
854                 ? Arrays.copyOf(other.usesStaticLibrariesVersions,
855                 other.usesStaticLibrariesVersions.length) : null;
856         mUserStates.clear();
857         for (int i = 0; i < other.mUserStates.size(); i++) {
858             if (sealedSnapshot) {
859                 mUserStates.put(other.mUserStates.keyAt(i),
860                         other.mUserStates.valueAt(i).snapshot());
861             } else {
862                 var userState = other.mUserStates.valueAt(i);
863                 userState.setWatchable(this);
864                 mUserStates.put(other.mUserStates.keyAt(i), userState);
865             }
866         }
867 
868         copyMimeGroups(other.mimeGroups);
869         mPageSizeAppCompatFlags = other.mPageSizeAppCompatFlags;
870 
871         pkgState.updateFrom(other.pkgState);
872         onChanged();
873     }
874 
875     @VisibleForTesting
876     PackageUserStateImpl modifyUserState(int userId) {
877         PackageUserStateImpl state = mUserStates.get(userId);
878         if (state == null) {
879             state = new PackageUserStateImpl(this);
880             mUserStates.put(userId, state);
881             onChanged();
882         }
883         return state;
884     }
885 
886     public PackageUserStateImpl getOrCreateUserState(@UserIdInt int userId) {
887         PackageUserStateImpl state = mUserStates.get(userId);
888         if (state == null) {
889             state = new PackageUserStateImpl(this);
890             mUserStates.put(userId, state);
891         }
892         return state;
893     }
894 
895     @NonNull
896     public PackageUserStateInternal readUserState(int userId) {
897         PackageUserStateInternal state = mUserStates.get(userId);
898         if (state == null) {
899             return PackageUserStateInternal.DEFAULT;
900         }
901         return state;
902     }
903 
904     void setEnabled(int state, int userId, String callingPackage) {
905         modifyUserState(userId)
906                 .setEnabledState(state)
907                 .setLastDisableAppCaller(callingPackage);
908         onChanged();
909     }
910 
911     int getEnabled(int userId) {
912         return readUserState(userId).getEnabledState();
913     }
914 
915     void setInstalled(boolean inst, int userId) {
916         modifyUserState(userId).setInstalled(inst);
917         onChanged();
918     }
919 
920     void setArchiveState(ArchiveState archiveState, int userId) {
921         modifyUserState(userId).setArchiveState(archiveState);
922         onChanged();
923     }
924 
925     boolean getInstalled(int userId) {
926         return readUserState(userId).isInstalled();
927     }
928 
929     boolean isArchived(int userId) {
930         return PackageArchiver.isArchived(readUserState(userId));
931     }
932 
933     /**
934      * @return if the package is archived in any of the users
935      */
936     boolean isArchivedOnAnyUser(int[] userIds) {
937         for (int user : userIds) {
938             if (isArchived(user)) {
939                 return true;
940             }
941         }
942         return false;
943     }
944 
945     int getInstallReason(int userId) {
946         return readUserState(userId).getInstallReason();
947     }
948 
949     void setInstallReason(int installReason, int userId) {
950         modifyUserState(userId).setInstallReason(installReason);
951         onChanged();
952     }
953 
954     int getUninstallReason(int userId) {
955         return readUserState(userId).getUninstallReason();
956     }
957 
958     void setUninstallReason(@PackageManager.UninstallReason int uninstallReason, int userId) {
959         modifyUserState(userId).setUninstallReason(uninstallReason);
960         onChanged();
961     }
962 
963     @NonNull
964     OverlayPaths getOverlayPaths(int userId) {
965         return readUserState(userId).getOverlayPaths();
966     }
967 
968     boolean setOverlayPathsForLibrary(String libName, OverlayPaths overlayPaths, int userId) {
969         boolean changed = modifyUserState(userId)
970                 .setSharedLibraryOverlayPaths(libName, overlayPaths);
971         onChanged();
972         return changed;
973     }
974 
975     boolean isInstalledOnAnyOtherUser(int[] allUsers, int currentUser) {
976         for (int user: allUsers) {
977             if (user == currentUser) {
978                 continue;
979             }
980             final PackageUserStateInternal userState = readUserState(user);
981             if (userState.isInstalled()) {
982                 return true;
983             }
984         }
985         return false;
986     }
987 
988     boolean hasDataOnAnyOtherUser(int[] allUsers, int currentUser) {
989         for (int user: allUsers) {
990             if (user == currentUser) {
991                 continue;
992             }
993             final PackageUserStateInternal userState = readUserState(user);
994             if (userState.dataExists()) {
995                 return true;
996             }
997         }
998         return false;
999     }
1000 
1001     int[] queryInstalledUsers(int[] users, boolean installed) {
1002         IntArray installedUsers = new IntArray(users.length);
1003         for (int user : users) {
1004             if (getInstalled(user) == installed) {
1005                 installedUsers.add(user);
1006             }
1007         }
1008         return installedUsers.toArray();
1009     }
1010 
1011     int[] queryUsersInstalledOrHasData(int[] users) {
1012         IntArray usersInstalledOrHasData = new IntArray(users.length);
1013         for (int user : users) {
1014             if (getInstalled(user) || readUserState(user).dataExists()) {
1015                 usersInstalledOrHasData.add(user);
1016             }
1017         }
1018         return usersInstalledOrHasData.toArray();
1019     }
1020 
1021     long getCeDataInode(int userId) {
1022         return readUserState(userId).getCeDataInode();
1023     }
1024 
1025     long getDeDataInode(int userId) {
1026         return readUserState(userId).getDeDataInode();
1027     }
1028 
1029     void setCeDataInode(long ceDataInode, int userId) {
1030         modifyUserState(userId).setCeDataInode(ceDataInode);
1031         onChanged();
1032     }
1033 
1034     void setDeDataInode(long deDataInode, int userId) {
1035         modifyUserState(userId).setDeDataInode(deDataInode);
1036         onChanged();
1037     }
1038 
1039     boolean getStopped(int userId) {
1040         return readUserState(userId).isStopped();
1041     }
1042 
1043     void setStopped(boolean stop, int userId) {
1044         modifyUserState(userId).setStopped(stop);
1045         onChanged();
1046     }
1047 
1048     public PackageSetting setScannedAsStoppedSystemApp(boolean stop) {
1049         setBoolean(Booleans.SCANNED_AS_STOPPED_SYSTEM_APP, stop);
1050         onChanged();
1051         return this;
1052     }
1053 
1054     boolean getNotLaunched(int userId) {
1055         return readUserState(userId).isNotLaunched();
1056     }
1057 
1058     void setNotLaunched(boolean stop, int userId) {
1059         modifyUserState(userId).setNotLaunched(stop);
1060         onChanged();
1061     }
1062 
1063     boolean getHidden(int userId) {
1064         return readUserState(userId).isHidden();
1065     }
1066 
1067     void setHidden(boolean hidden, int userId) {
1068         modifyUserState(userId).setHidden(hidden);
1069         onChanged();
1070     }
1071 
1072     int getDistractionFlags(int userId) {
1073         return readUserState(userId).getDistractionFlags();
1074     }
1075 
1076     void setDistractionFlags(int distractionFlags, int userId) {
1077         modifyUserState(userId).setDistractionFlags(distractionFlags);
1078         onChanged();
1079     }
1080 
1081     public boolean getInstantApp(int userId) {
1082         return readUserState(userId).isInstantApp();
1083     }
1084 
1085     void setInstantApp(boolean instantApp, int userId) {
1086         modifyUserState(userId).setInstantApp(instantApp);
1087         onChanged();
1088     }
1089 
1090     boolean getVirtualPreload(int userId) {
1091         return readUserState(userId).isVirtualPreload();
1092     }
1093 
1094     void setVirtualPreload(boolean virtualPreload, int userId) {
1095         modifyUserState(userId).setVirtualPreload(virtualPreload);
1096         onChanged();
1097     }
1098 
1099     void setUserState(int userId, long ceDataInode, long deDataInode, int enabled,
1100                       boolean installed, boolean stopped, boolean notLaunched, boolean hidden,
1101                       int distractionFlags, ArrayMap<UserPackage, SuspendParams> suspendParams,
1102                       boolean instantApp, boolean virtualPreload, String lastDisableAppCaller,
1103                       ArraySet<String> enabledComponents, ArraySet<String> disabledComponents,
1104                       int installReason, int uninstallReason,
1105                       String harmfulAppWarning, String splashScreenTheme,
1106                       long firstInstallTime, int aspectRatio, ArchiveState archiveState) {
1107         modifyUserState(userId)
1108                 .setSuspendParams(suspendParams)
1109                 .setCeDataInode(ceDataInode)
1110                 .setDeDataInode(deDataInode)
1111                 .setEnabledState(enabled)
1112                 .setInstalled(installed)
1113                 .setStopped(stopped)
1114                 .setNotLaunched(notLaunched)
1115                 .setHidden(hidden)
1116                 .setDistractionFlags(distractionFlags)
1117                 .setLastDisableAppCaller(lastDisableAppCaller)
1118                 .setEnabledComponents(enabledComponents)
1119                 .setDisabledComponents(disabledComponents)
1120                 .setInstallReason(installReason)
1121                 .setUninstallReason(uninstallReason)
1122                 .setInstantApp(instantApp)
1123                 .setVirtualPreload(virtualPreload)
1124                 .setHarmfulAppWarning(harmfulAppWarning)
1125                 .setSplashScreenTheme(splashScreenTheme)
1126                 .setFirstInstallTimeMillis(firstInstallTime)
1127                 .setMinAspectRatio(aspectRatio)
1128                 .setArchiveState(archiveState);
1129         onChanged();
1130     }
1131 
1132     void setUserState(int userId, PackageUserStateInternal otherState) {
1133         setUserState(userId, otherState.getCeDataInode(), otherState.getDeDataInode(),
1134                 otherState.getEnabledState(), otherState.isInstalled(), otherState.isStopped(),
1135                 otherState.isNotLaunched(), otherState.isHidden(), otherState.getDistractionFlags(),
1136                 otherState.getSuspendParams() == null
1137                         ? null : otherState.getSuspendParams().untrackedStorage(),
1138                 otherState.isInstantApp(), otherState.isVirtualPreload(),
1139                 otherState.getLastDisableAppCaller(),
1140                 otherState.getEnabledComponentsNoCopy() == null
1141                         ? null : otherState.getEnabledComponentsNoCopy().untrackedStorage(),
1142                 otherState.getDisabledComponentsNoCopy() == null
1143                         ? null : otherState.getDisabledComponentsNoCopy().untrackedStorage(),
1144                 otherState.getInstallReason(), otherState.getUninstallReason(),
1145                 otherState.getHarmfulAppWarning(), otherState.getSplashScreenTheme(),
1146                 otherState.getFirstInstallTimeMillis(), otherState.getMinAspectRatio(),
1147                 otherState.getArchiveState());
1148     }
1149 
1150     WatchedArraySet<String> getEnabledComponents(int userId) {
1151         return readUserState(userId).getEnabledComponentsNoCopy();
1152     }
1153 
1154     WatchedArraySet<String> getDisabledComponents(int userId) {
1155         return readUserState(userId).getDisabledComponentsNoCopy();
1156     }
1157 
1158     /** Test only */
1159     void setEnabledComponents(WatchedArraySet<String> components, int userId) {
1160         modifyUserState(userId).setEnabledComponents(components);
1161         onChanged();
1162     }
1163 
1164     /** Test only */
1165     void setDisabledComponents(WatchedArraySet<String> components, int userId) {
1166         modifyUserState(userId).setDisabledComponents(components);
1167         onChanged();
1168     }
1169 
1170     void setEnabledComponentsCopy(WatchedArraySet<String> components, int userId) {
1171         modifyUserState(userId).setEnabledComponents(components != null
1172                 ? components.untrackedStorage() : null);
1173         onChanged();
1174     }
1175 
1176     void setDisabledComponentsCopy(WatchedArraySet<String> components, int userId) {
1177         modifyUserState(userId).setDisabledComponents(components != null
1178                 ? components.untrackedStorage() : null);
1179         onChanged();
1180     }
1181 
1182     PackageUserStateImpl modifyUserStateComponents(int userId, boolean disabled,
1183             boolean enabled) {
1184         PackageUserStateImpl state = modifyUserState(userId);
1185         boolean changed = false;
1186         if (disabled && state.getDisabledComponentsNoCopy() == null) {
1187             state.setDisabledComponents(new ArraySet<String>(1));
1188             changed = true;
1189         }
1190         if (enabled && state.getEnabledComponentsNoCopy() == null) {
1191             state.setEnabledComponents(new ArraySet<String>(1));
1192             changed = true;
1193         }
1194         if (changed) {
1195             onChanged();
1196         }
1197         return state;
1198     }
1199 
1200     void addDisabledComponent(String componentClassName, int userId) {
1201         modifyUserStateComponents(userId, true, false)
1202                 .getDisabledComponentsNoCopy().add(componentClassName);
1203         onChanged();
1204     }
1205 
1206     void addEnabledComponent(String componentClassName, int userId) {
1207         modifyUserStateComponents(userId, false, true)
1208                 .getEnabledComponentsNoCopy().add(componentClassName);
1209         onChanged();
1210     }
1211 
1212     boolean enableComponentLPw(String componentClassName, int userId) {
1213         PackageUserStateImpl state = modifyUserStateComponents(userId, false, true);
1214         boolean changed = state.getDisabledComponentsNoCopy() != null
1215                 ? state.getDisabledComponentsNoCopy().remove(componentClassName) : false;
1216         changed |= state.getEnabledComponentsNoCopy().add(componentClassName);
1217         if (changed) {
1218             onChanged();
1219         }
1220         return changed;
1221     }
1222 
1223     boolean disableComponentLPw(String componentClassName, int userId) {
1224         PackageUserStateImpl state = modifyUserStateComponents(userId, true, false);
1225         boolean changed = state.getEnabledComponentsNoCopy() != null
1226                 ? state.getEnabledComponentsNoCopy().remove(componentClassName) : false;
1227         changed |= state.getDisabledComponentsNoCopy().add(componentClassName);
1228         if (changed) {
1229             onChanged();
1230         }
1231         return changed;
1232     }
1233 
1234     boolean restoreComponentLPw(String componentClassName, int userId) {
1235         PackageUserStateImpl state = modifyUserStateComponents(userId, true, true);
1236         boolean changed = state.getDisabledComponentsNoCopy() != null
1237                 ? state.getDisabledComponentsNoCopy().remove(componentClassName) : false;
1238         changed |= state.getEnabledComponentsNoCopy() != null
1239                 ? state.getEnabledComponentsNoCopy().remove(componentClassName) : false;
1240         if (changed) {
1241             onChanged();
1242         }
1243         return changed;
1244     }
1245 
1246     void restoreComponentSettings(int userId) {
1247         PackageUserStateImpl state = modifyUserStateComponents(userId, true, true);
1248         WatchedArraySet<String> enabledComponents = state.getEnabledComponentsNoCopy();
1249         WatchedArraySet<String> disabledComponents = state.getDisabledComponentsNoCopy();
1250 
1251         boolean changed = false;
1252         for (int i = enabledComponents.size() - 1; i >= 0; i--) {
1253             if (!AndroidPackageUtils.hasComponentClassName(pkg, enabledComponents.valueAt(i))) {
1254                 enabledComponents.removeAt(i);
1255                 changed = true;
1256             }
1257         }
1258         for (int i = disabledComponents.size() - 1; i >= 0; i--) {
1259             if (!AndroidPackageUtils.hasComponentClassName(pkg, disabledComponents.valueAt(i))) {
1260                 disabledComponents.removeAt(i);
1261                 changed = true;
1262             }
1263         }
1264         if (changed) {
1265             onChanged();
1266         }
1267     }
1268 
1269     int getCurrentEnabledStateLPr(String componentName, int userId) {
1270         PackageUserStateInternal state = readUserState(userId);
1271         if (state.getEnabledComponentsNoCopy() != null
1272                 && state.getEnabledComponentsNoCopy().contains(componentName)) {
1273             return COMPONENT_ENABLED_STATE_ENABLED;
1274         } else if (state.getDisabledComponentsNoCopy() != null
1275                 && state.getDisabledComponentsNoCopy().contains(componentName)) {
1276             return COMPONENT_ENABLED_STATE_DISABLED;
1277         } else {
1278             return COMPONENT_ENABLED_STATE_DEFAULT;
1279         }
1280     }
1281 
1282     void removeUser(int userId) {
1283         mUserStates.delete(userId);
1284         onChanged();
1285     }
1286 
1287     public int[] getNotInstalledUserIds() {
1288         int userStateCount = mUserStates.size();
1289         IntArray notInstalledUsers = new IntArray(userStateCount);
1290         for (int i = 0; i < userStateCount; i++) {
1291             if (!mUserStates.valueAt(i).isInstalled()) {
1292                 notInstalledUsers.add(mUserStates.keyAt(i));
1293             }
1294         }
1295         return notInstalledUsers.toArray();
1296     }
1297 
1298     /**
1299      * TODO (b/170263003) refactor to dump to permissiongr proto Dumps the permissions that are
1300      * granted to users for this package.
1301      */
1302     void writePackageUserPermissionsProto(ProtoOutputStream proto, long fieldId,
1303             List<UserInfo> users, LegacyPermissionDataProvider dataProvider) {
1304         Collection<LegacyPermissionState.PermissionState> runtimePermissionStates;
1305         for (UserInfo user : users) {
1306             final long permissionsToken = proto.start(PackageProto.USER_PERMISSIONS);
1307             proto.write(PackageProto.UserPermissionsProto.ID, user.id);
1308 
1309             runtimePermissionStates = dataProvider.getLegacyPermissionState(mAppId)
1310                     .getPermissionStates(user.id);
1311             for (LegacyPermissionState.PermissionState permission : runtimePermissionStates) {
1312                 if (permission.isGranted()) {
1313                     proto.write(PackageProto.UserPermissionsProto.GRANTED_PERMISSIONS,
1314                             permission.getName());
1315                 }
1316             }
1317             proto.end(permissionsToken);
1318         }
1319     }
1320 
1321     protected void writeUsersInfoToProto(ProtoOutputStream proto, long fieldId) {
1322         int count = mUserStates.size();
1323         for (int i = 0; i < count; i++) {
1324             final long userToken = proto.start(fieldId);
1325             final int userId = mUserStates.keyAt(i);
1326             final PackageUserStateInternal state = mUserStates.valueAt(i);
1327             proto.write(PackageProto.UserInfoProto.ID, userId);
1328             final int installType;
1329             if (state.isInstantApp()) {
1330                 installType = PackageProto.UserInfoProto.INSTANT_APP_INSTALL;
1331             } else if (state.isInstalled()) {
1332                 installType = PackageProto.UserInfoProto.FULL_APP_INSTALL;
1333             } else {
1334                 installType = PackageProto.UserInfoProto.NOT_INSTALLED_FOR_USER;
1335             }
1336             proto.write(PackageProto.UserInfoProto.INSTALL_TYPE, installType);
1337             proto.write(PackageProto.UserInfoProto.IS_HIDDEN, state.isHidden());
1338             proto.write(PackageProto.UserInfoProto.DISTRACTION_FLAGS, state.getDistractionFlags());
1339             proto.write(PackageProto.UserInfoProto.IS_SUSPENDED, state.isSuspended());
1340             if (state.isSuspended()) {
1341                 for (int j = 0; j < state.getSuspendParams().size(); j++) {
1342                     proto.write(PackageProto.UserInfoProto.SUSPENDING_PACKAGE,
1343                             state.getSuspendParams().keyAt(j).packageName);
1344                     if (crossUserSuspensionEnabledRo()) {
1345                         proto.write(PackageProto.UserInfoProto.SUSPENDING_USER,
1346                                 state.getSuspendParams().keyAt(j).userId);
1347                     }
1348                 }
1349             }
1350             proto.write(PackageProto.UserInfoProto.IS_STOPPED, state.isStopped());
1351             proto.write(PackageProto.UserInfoProto.IS_LAUNCHED, !state.isNotLaunched());
1352             proto.write(PackageProto.UserInfoProto.ENABLED_STATE, state.getEnabledState());
1353             proto.write(
1354                     PackageProto.UserInfoProto.LAST_DISABLED_APP_CALLER,
1355                     state.getLastDisableAppCaller());
1356             proto.write(PackageProto.UserInfoProto.FIRST_INSTALL_TIME_MS,
1357                     state.getFirstInstallTimeMillis());
1358             writeArchiveState(proto, state.getArchiveState());
1359             proto.end(userToken);
1360         }
1361     }
1362 
1363     private static void writeArchiveState(ProtoOutputStream proto, ArchiveState archiveState) {
1364         if (archiveState == null) {
1365             return;
1366         }
1367         long archiveStateToken = proto.start(PackageProto.UserInfoProto.ARCHIVE_STATE);
1368         for (ArchiveState.ArchiveActivityInfo activityInfo : archiveState.getActivityInfos()) {
1369             long activityInfoToken = proto.start(
1370                     PackageProto.UserInfoProto.ArchiveState.ACTIVITY_INFOS);
1371             proto.write(ArchiveActivityInfo.TITLE, activityInfo.getTitle());
1372             proto.write(
1373                     ArchiveActivityInfo.ORIGINAL_COMPONENT_NAME,
1374                     activityInfo.getOriginalComponentName().flattenToString());
1375             if (activityInfo.getIconBitmap() != null) {
1376                 proto.write(ArchiveActivityInfo.ICON_BITMAP_PATH,
1377                         activityInfo.getIconBitmap().toAbsolutePath().toString());
1378             }
1379             if (activityInfo.getMonochromeIconBitmap() != null) {
1380                 proto.write(ArchiveActivityInfo.MONOCHROME_ICON_BITMAP_PATH,
1381                         activityInfo.getMonochromeIconBitmap().toAbsolutePath().toString());
1382             }
1383             proto.end(activityInfoToken);
1384         }
1385 
1386         proto.write(PackageProto.UserInfoProto.ArchiveState.INSTALLER_TITLE,
1387                 archiveState.getInstallerTitle());
1388         proto.end(archiveStateToken);
1389     }
1390 
1391     /**
1392      * @see #mPath
1393      */
1394     @VisibleForTesting(visibility = VisibleForTesting.Visibility.PACKAGE)
1395     public PackageSetting setPath(@NonNull File path) {
1396         this.mPath = path;
1397         this.mPathString = path.toString();
1398         onChanged();
1399         return this;
1400     }
1401 
1402     @VisibleForTesting(visibility = VisibleForTesting.Visibility.PACKAGE)
1403     public PackageSetting addOldPath(@NonNull File path) {
1404         if (mOldPaths == null) {
1405             mOldPaths = new LinkedHashSet<>();
1406         }
1407         mOldPaths.add(path);
1408         onChanged();
1409         return this;
1410     }
1411 
1412     @VisibleForTesting(visibility = VisibleForTesting.Visibility.PACKAGE)
1413     public PackageSetting removeOldPath(@Nullable File path) {
1414         if (path == null || mOldPaths == null) {
1415             return this;
1416         }
1417         if (mOldPaths.remove(path)) {
1418             onChanged();
1419         }
1420         return this;
1421     }
1422 
1423     /**
1424      * @param userId the specific user to change the label/icon for
1425      * @see PackageUserStateImpl#overrideLabelAndIcon(ComponentName, String, Integer)
1426      */
1427     @VisibleForTesting(visibility = VisibleForTesting.Visibility.PACKAGE)
1428     public boolean overrideNonLocalizedLabelAndIcon(@NonNull ComponentName component,
1429             @Nullable String label, @Nullable Integer icon, @UserIdInt int userId) {
1430         boolean changed = modifyUserState(userId).overrideLabelAndIcon(component, label, icon);
1431         onChanged();
1432         return changed;
1433     }
1434 
1435     /**
1436      * @param userId the specific user to reset
1437      * @see PackageUserStateImpl#resetOverrideComponentLabelIcon()
1438      */
1439     public void resetOverrideComponentLabelIcon(@UserIdInt int userId) {
1440         modifyUserState(userId).resetOverrideComponentLabelIcon();
1441         onChanged();
1442     }
1443 
1444     /**
1445      * @param userId the specified user to get the theme setting from
1446      * @return the theme name previously persisted for the user or null if no splashscreen theme is
1447      * persisted.
1448      * @see android.window.SplashScreen#setSplashScreenTheme(int)
1449      */
1450     @Nullable
1451     public String getSplashScreenTheme(@UserIdInt int userId) {
1452         return readUserState(userId).getSplashScreenTheme();
1453     }
1454 
1455     public boolean isIncremental() {
1456         return IncrementalManager.isIncrementalPath(mPathString);
1457     }
1458     /**
1459      * @return True if package is still being loaded, false if the package is fully loaded.
1460      */
1461     public boolean isLoading() {
1462         return Math.abs(1.0f - mLoadingProgress) >= 0.00000001f;
1463     }
1464 
1465     public PackageSetting setLoadingProgress(float progress) {
1466         // To prevent race conditions, we don't allow progress to ever go down
1467         if (mLoadingProgress < progress) {
1468             mLoadingProgress = progress;
1469             onChanged();
1470         }
1471         return this;
1472     }
1473 
1474     public PackageSetting setLoadingCompletedTime(long loadingCompletedTime) {
1475         mLoadingCompletedTime = loadingCompletedTime;
1476         onChanged();
1477         return this;
1478     }
1479 
1480     /**
1481      * @param path to app metadata file
1482      */
1483     public PackageSetting setAppMetadataFilePath(String path) {
1484         mAppMetadataFilePath = path;
1485         onChanged();
1486         return this;
1487     }
1488 
1489     /**
1490      * @param source the source of the app metadata that is currently associated with
1491      */
1492     public PackageSetting setAppMetadataSource(int source) {
1493         mAppMetadataSource = source;
1494         onChanged();
1495         return this;
1496     }
1497 
1498     @NonNull
1499     @Override
1500     public long getVersionCode() {
1501         return versionCode;
1502     }
1503 
1504     /**
1505      * @see PackageState#getMimeGroups()
1506      */
1507     @Nullable
1508     @Override
1509     public Map<String, Set<String>> getMimeGroups() {
1510         return CollectionUtils.isEmpty(mimeGroups) ? Collections.emptyMap()
1511                 : Collections.unmodifiableMap(mimeGroups);
1512     }
1513 
1514     @NonNull
1515     @Override
1516     public String getPackageName() {
1517         return mName;
1518     }
1519 
1520     @Nullable
1521     @Override
1522     public AndroidPackage getAndroidPackage() {
1523         return getPkg();
1524     }
1525 
1526     @NonNull
1527     public SigningInfo getSigningInfo() {
1528         return new SigningInfo(signatures.mSigningDetails);
1529     }
1530 
1531     @NonNull
1532     @Override
1533     public String[] getUsesSdkLibraries() {
1534         return usesSdkLibraries == null ? EmptyArray.STRING : usesSdkLibraries;
1535     }
1536 
1537     @NonNull
1538     @Override
1539     public long[] getUsesSdkLibrariesVersionsMajor() {
1540         return usesSdkLibrariesVersionsMajor == null ? EmptyArray.LONG
1541                 : usesSdkLibrariesVersionsMajor;
1542     }
1543 
1544     @NonNull
1545     @Override
1546     public boolean[] getUsesSdkLibrariesOptional() {
1547         return usesSdkLibrariesOptional == null ? EmptyArray.BOOLEAN : usesSdkLibrariesOptional;
1548     }
1549 
1550     @NonNull
1551     @Override
1552     public String[] getUsesStaticLibraries() {
1553         return usesStaticLibraries == null ? EmptyArray.STRING : usesStaticLibraries;
1554     }
1555 
1556     @NonNull
1557     @Override
1558     public long[] getUsesStaticLibrariesVersions() {
1559         return usesStaticLibrariesVersions == null ? EmptyArray.LONG : usesStaticLibrariesVersions;
1560     }
1561 
1562     @NonNull
1563     @Override
1564     public List<SharedLibrary> getSharedLibraryDependencies() {
1565         return Collections.unmodifiableList(pkgState.getUsesLibraryInfos());
1566     }
1567 
1568     @NonNull
1569     public PackageSetting addUsesLibraryInfo(@NonNull SharedLibraryInfo value) {
1570         pkgState.addUsesLibraryInfo(new SharedLibraryWrapper(value));
1571         return this;
1572     }
1573 
1574     @NonNull
1575     @Override
1576     public List<String> getUsesLibraryFiles() {
1577         return Collections.unmodifiableList(pkgState.getUsesLibraryFiles());
1578     }
1579 
1580     @NonNull
1581     public PackageSetting addUsesLibraryFile(String value) {
1582         pkgState.addUsesLibraryFile(value);
1583         return this;
1584     }
1585 
1586     @Override
1587     public boolean isHiddenUntilInstalled() {
1588         return pkgState.isHiddenUntilInstalled();
1589     }
1590 
1591     @NonNull
1592     @Override
1593     public long[] getLastPackageUsageTime() {
1594         return pkgState.getLastPackageUsageTimeInMills();
1595     }
1596 
1597     @Override
1598     public boolean isUpdatedSystemApp() {
1599         return pkgState.isUpdatedSystemApp();
1600     }
1601 
1602     @Override
1603     public boolean isApkInUpdatedApex() {
1604         return pkgState.isApkInUpdatedApex();
1605     }
1606 
1607     @Nullable
1608     @Override
1609     public String getApexModuleName() {
1610         return pkgState.getApexModuleName();
1611     }
1612 
1613     public PackageSetting setDomainSetId(@NonNull UUID domainSetId) {
1614         mDomainSetId = domainSetId;
1615         onChanged();
1616         return this;
1617     }
1618 
1619     public PackageSetting setCategoryOverride(int categoryHint) {
1620         this.categoryOverride = categoryHint;
1621         onChanged();
1622         return this;
1623     }
1624 
1625     /**
1626      * @see Set page size app compat mode.
1627      */
1628     public PackageSetting setPageSizeAppCompatFlags(int mode) {
1629         if (mode < 0 || mode >= ApplicationInfo.PAGE_SIZE_APP_COMPAT_FLAG_MAX) {
1630             throw new IllegalArgumentException("Invalid page size compat mode specified");
1631         }
1632 
1633         // OR assignment is used here to avoid overriding the mode set by the manifest.
1634         this.mPageSizeAppCompatFlags |= mode;
1635 
1636         // Only one bit of the following can be set at same time. Both are needed to detect app
1637         // compat 'disabled' state from settings vs bit was never set.
1638         if (ApplicationInfo.PAGE_SIZE_APP_COMPAT_FLAG_SETTINGS_OVERRIDE_ENABLED == mode) {
1639             this.mPageSizeAppCompatFlags &=
1640                     ~ApplicationInfo.PAGE_SIZE_APP_COMPAT_FLAG_SETTINGS_OVERRIDE_DISABLED;
1641         } else if (ApplicationInfo.PAGE_SIZE_APP_COMPAT_FLAG_SETTINGS_OVERRIDE_DISABLED == mode) {
1642             this.mPageSizeAppCompatFlags &=
1643                     ~ApplicationInfo.PAGE_SIZE_APP_COMPAT_FLAG_SETTINGS_OVERRIDE_ENABLED;
1644         }
1645         onChanged();
1646         return this;
1647     }
1648 
1649     public int getPageSizeAppCompatFlags() {
1650         return mPageSizeAppCompatFlags;
1651     }
1652 
1653     public PackageSetting setLegacyNativeLibraryPath(
1654             String legacyNativeLibraryPathString) {
1655         this.legacyNativeLibraryPath = legacyNativeLibraryPathString;
1656         onChanged();
1657         return this;
1658     }
1659 
1660     public PackageSetting setMimeGroups(@Nullable Map<String, Set<String>> mimeGroups) {
1661         if (mimeGroups != null) {
1662             copyMimeGroups(mimeGroups);
1663             onChanged();
1664         }
1665         return this;
1666     }
1667 
1668     public PackageSetting setUsesSdkLibraries(String[] usesSdkLibraries) {
1669         this.usesSdkLibraries = usesSdkLibraries;
1670         onChanged();
1671         return this;
1672     }
1673 
1674     public PackageSetting setUsesSdkLibrariesVersionsMajor(long[] usesSdkLibrariesVersions) {
1675         this.usesSdkLibrariesVersionsMajor = usesSdkLibrariesVersions;
1676         onChanged();
1677         return this;
1678     }
1679 
1680     public PackageSetting setUsesSdkLibrariesOptional(boolean[] usesSdkLibrariesOptional) {
1681         this.usesSdkLibrariesOptional = usesSdkLibrariesOptional;
1682         onChanged();
1683         return this;
1684     }
1685 
1686     public PackageSetting setUsesStaticLibraries(String[] usesStaticLibraries) {
1687         this.usesStaticLibraries = usesStaticLibraries;
1688         onChanged();
1689         return this;
1690     }
1691 
1692     public PackageSetting setUsesStaticLibrariesVersions(long[] usesStaticLibrariesVersions) {
1693         this.usesStaticLibrariesVersions = usesStaticLibrariesVersions;
1694         onChanged();
1695         return this;
1696     }
1697 
1698     public PackageSetting setApexModuleName(@Nullable String apexModuleName) {
1699         pkgState.setApexModuleName(apexModuleName);
1700         return this;
1701     }
1702 
1703     @NonNull
1704     @Override
1705     public PackageStateUnserialized getTransientState() {
1706         return pkgState;
1707     }
1708 
1709     @NonNull
1710     public SparseArray<? extends PackageUserStateInternal> getUserStates() {
1711         return mUserStates;
1712     }
1713 
1714     public PackageSetting addMimeTypes(String mimeGroup, Set<String> mimeTypes) {
1715         if (mimeGroups == null) {
1716             mimeGroups = new ArrayMap<>();
1717         }
1718 
1719         Set<String> existingMimeTypes = mimeGroups.get(mimeGroup);
1720         if (existingMimeTypes == null) {
1721             existingMimeTypes = new ArraySet<>();
1722             mimeGroups.put(mimeGroup, existingMimeTypes);
1723         }
1724         existingMimeTypes.addAll(mimeTypes);
1725         return this;
1726     }
1727 
1728     @NonNull
1729     @Override
1730     public PackageUserState getStateForUser(@NonNull UserHandle user) {
1731         PackageUserState userState = getUserStates().get(user.getIdentifier());
1732         return userState == null ? PackageUserState.DEFAULT : userState;
1733     }
1734 
1735     @Nullable
1736     public String getPrimaryCpuAbi() {
1737         if (TextUtils.isEmpty(mPrimaryCpuAbi) && pkg != null) {
1738             return AndroidPackageUtils.getRawPrimaryCpuAbi(pkg);
1739         }
1740 
1741         return mPrimaryCpuAbi;
1742     }
1743 
1744     @Nullable
1745     public String getSecondaryCpuAbi() {
1746         if (TextUtils.isEmpty(mSecondaryCpuAbi) && pkg != null) {
1747             return AndroidPackageUtils.getRawSecondaryCpuAbi(pkg);
1748         }
1749 
1750         return mSecondaryCpuAbi;
1751     }
1752 
1753     @Nullable
1754     @Override
1755     public String getSeInfo() {
1756         String overrideSeInfo = getTransientState().getOverrideSeInfo();
1757         if (!TextUtils.isEmpty(overrideSeInfo)) {
1758             return overrideSeInfo;
1759         }
1760 
1761         return getTransientState().getSeInfo();
1762     }
1763 
1764     @Nullable
1765     public String getPrimaryCpuAbiLegacy() {
1766         return mPrimaryCpuAbi;
1767     }
1768 
1769     @Nullable
1770     public String getSecondaryCpuAbiLegacy() {
1771         return mSecondaryCpuAbi;
1772     }
1773 
1774     @ApplicationInfo.HiddenApiEnforcementPolicy
1775     @Override
1776     public int getHiddenApiEnforcementPolicy() {
1777         return AndroidPackageUtils.getHiddenApiEnforcementPolicy(getAndroidPackage(), this);
1778     }
1779 
1780     @Override
1781     public boolean isApex() {
1782         // TODO(b/256637152):
1783         // TODO(b/243839669): Use a flag tracked directly in PackageSetting
1784         return getAndroidPackage() != null && getAndroidPackage().isApex();
1785     }
1786 
1787     @Override
1788     public boolean isForceQueryableOverride() {
1789         return getBoolean(Booleans.FORCE_QUERYABLE_OVERRIDE);
1790     }
1791 
1792     /**
1793      * @see PackageState#isUpdateAvailable()
1794      */
1795     @Override
1796     public boolean isUpdateAvailable() {
1797         return getBoolean(Booleans.UPDATE_AVAILABLE);
1798     }
1799 
1800     @Override
1801     public boolean isInstallPermissionsFixed() {
1802         return getBoolean(Booleans.INSTALL_PERMISSION_FIXED);
1803     }
1804 
1805     /**
1806      * @see PackageState#isDefaultToDeviceProtectedStorage()
1807      */
1808     @Override
1809     public boolean isDefaultToDeviceProtectedStorage() {
1810         return (getPrivateFlags() & PRIVATE_FLAG_DEFAULT_TO_DEVICE_PROTECTED_STORAGE) != 0;
1811     }
1812 
1813     @Override
1814     public boolean isPersistent() {
1815         return (getFlags() & ApplicationInfo.FLAG_PERSISTENT) != 0;
1816     }
1817 
1818     @Override
1819     public boolean isScannedAsStoppedSystemApp() {
1820         return getBoolean(Booleans.SCANNED_AS_STOPPED_SYSTEM_APP);
1821     }
1822 
1823     /** Returns true if ELF files will be loaded in Page size compatibility mode */
1824     @Override
1825     public boolean isPageSizeAppCompatEnabled() {
1826         // If manifest or settings has disabled the compat mode, don't run app in compat mode.
1827         boolean manifestOverrideDisabled = (mPageSizeAppCompatFlags
1828                 &  ApplicationInfo.PAGE_SIZE_APP_COMPAT_FLAG_MANIFEST_OVERRIDE_DISABLED) != 0;
1829         boolean settingsOverrideDisabled = (mPageSizeAppCompatFlags
1830                 &  ApplicationInfo.PAGE_SIZE_APP_COMPAT_FLAG_SETTINGS_OVERRIDE_DISABLED) != 0;
1831         if (manifestOverrideDisabled || settingsOverrideDisabled) {
1832             return false;
1833         }
1834 
1835         int mask =
1836                 ApplicationInfo.PAGE_SIZE_APP_COMPAT_FLAG_ELF_NOT_ALIGNED
1837                         | ApplicationInfo.PAGE_SIZE_APP_COMPAT_FLAG_MANIFEST_OVERRIDE_ENABLED
1838                         | ApplicationInfo.PAGE_SIZE_APP_COMPAT_FLAG_SETTINGS_OVERRIDE_ENABLED;
1839         return (mPageSizeAppCompatFlags & mask) != 0;
1840     }
1841 
1842     /**
1843      * Returns dialog string based on alignment of uncompressed shared libs inside the APK and ELF
1844      * alignment.
1845      */
1846     @Override
1847     public String getPageSizeCompatWarningMessage(Context context) {
1848         boolean manifestOverrideEnabled =  (mPageSizeAppCompatFlags
1849                 & ApplicationInfo.PAGE_SIZE_APP_COMPAT_FLAG_MANIFEST_OVERRIDE_ENABLED) != 0;
1850         boolean settingsOverrideEnabled =  (mPageSizeAppCompatFlags
1851                 & ApplicationInfo.PAGE_SIZE_APP_COMPAT_FLAG_SETTINGS_OVERRIDE_ENABLED) != 0;
1852         boolean settingsOverrideDisabled =  (mPageSizeAppCompatFlags
1853                 & ApplicationInfo.PAGE_SIZE_APP_COMPAT_FLAG_SETTINGS_OVERRIDE_DISABLED) != 0;
1854         if (manifestOverrideEnabled || settingsOverrideEnabled || settingsOverrideDisabled) {
1855             return null;
1856         }
1857 
1858         boolean uncompressedLibsNotAligned = (mPageSizeAppCompatFlags
1859                 & ApplicationInfo.PAGE_SIZE_APP_COMPAT_FLAG_UNCOMPRESSED_LIBS_NOT_ALIGNED) != 0;
1860         boolean elfNotAligned = (mPageSizeAppCompatFlags
1861                 & ApplicationInfo.PAGE_SIZE_APP_COMPAT_FLAG_ELF_NOT_ALIGNED) != 0;
1862 
1863         if (uncompressedLibsNotAligned && elfNotAligned) {
1864             return context.getText(
1865                             com.android.internal.R.string.page_size_compat_apk_and_elf_warning)
1866                     .toString();
1867         }
1868 
1869         if (uncompressedLibsNotAligned) {
1870             return context.getText(com.android.internal.R.string.page_size_compat_apk_warning)
1871                     .toString();
1872         }
1873 
1874         if (elfNotAligned) {
1875             return context.getText(com.android.internal.R.string.page_size_compat_elf_warning)
1876                     .toString();
1877         }
1878 
1879         return null;
1880     }
1881 
1882 
1883 
1884     // Code below generated by codegen v1.0.23.
1885     //
1886     // DO NOT MODIFY!
1887     // CHECKSTYLE:OFF Generated code
1888     //
1889     // To regenerate run:
1890     // $ codegen $ANDROID_BUILD_TOP/frameworks/base/services/core/java/com/android/server/pm/PackageSetting.java
1891     //
1892     // To exclude the generated code from IntelliJ auto-formatting enable (one-time):
1893     //   Settings > Editor > Code Style > Formatter Control
1894     //@formatter:off
1895 
1896 
1897     /**
1898      * The path under which native libraries have been unpacked. This path is
1899      * always derived at runtime, and is only stored here for cleanup when a
1900      * package is uninstalled.
1901      */
1902     @DataClass.Generated.Member
1903     public @Nullable @Deprecated String getLegacyNativeLibraryPath() {
1904         return legacyNativeLibraryPath;
1905     }
1906 
1907     @DataClass.Generated.Member
1908     public @NonNull String getName() {
1909         return mName;
1910     }
1911 
1912     @DataClass.Generated.Member
1913     public @Nullable String getRealName() {
1914         return mRealName;
1915     }
1916 
1917     @DataClass.Generated.Member
1918     public int getAppId() {
1919         return mAppId;
1920     }
1921 
1922     /**
1923      * It is expected that all code that uses a {@link PackageSetting} understands this inner field
1924      * may be null. Note that this relationship only works one way. It should not be possible to
1925      * have an entry inside {@link PackageManagerService#mPackages} without a corresponding
1926      * {@link PackageSetting} inside {@link Settings#mPackages}.
1927      *
1928      * @see PackageState#getAndroidPackage()
1929      */
1930     @DataClass.Generated.Member
1931     public @Nullable AndroidPackageInternal getPkg() {
1932         return pkg;
1933     }
1934 
1935     /**
1936      * @see AndroidPackage#getPath()
1937      */
1938     @DataClass.Generated.Member
1939     public @NonNull File getPath() {
1940         return mPath;
1941     }
1942 
1943     @DataClass.Generated.Member
1944     public @NonNull String getPathString() {
1945         return mPathString;
1946     }
1947 
1948     @DataClass.Generated.Member
1949     public @Nullable LinkedHashSet<File> getOldPaths() {
1950         return mOldPaths;
1951     }
1952 
1953     @DataClass.Generated.Member
1954     public float getLoadingProgress() {
1955         return mLoadingProgress;
1956     }
1957 
1958     @DataClass.Generated.Member
1959     public long getLoadingCompletedTime() {
1960         return mLoadingCompletedTime;
1961     }
1962 
1963     @DataClass.Generated.Member
1964     public @Nullable String getCpuAbiOverride() {
1965         return mCpuAbiOverride;
1966     }
1967 
1968     @DataClass.Generated.Member
1969     public long getLastModifiedTime() {
1970         return mLastModifiedTime;
1971     }
1972 
1973     @DataClass.Generated.Member
1974     public long getLastUpdateTime() {
1975         return lastUpdateTime;
1976     }
1977 
1978     @DataClass.Generated.Member
1979     public @NonNull PackageSignatures getSignatures() {
1980         return signatures;
1981     }
1982 
1983     @DataClass.Generated.Member
1984     public @NonNull PackageKeySetData getKeySetData() {
1985         return keySetData;
1986     }
1987 
1988     @DataClass.Generated.Member
1989     public @NonNull InstallSource getInstallSource() {
1990         return installSource;
1991     }
1992 
1993     /**
1994      * @see PackageState#getVolumeUuid()
1995      */
1996     @DataClass.Generated.Member
1997     public @Nullable String getVolumeUuid() {
1998         return volumeUuid;
1999     }
2000 
2001     /**
2002      * @see PackageState#getCategoryOverride()
2003      */
2004     @DataClass.Generated.Member
2005     public int getCategoryOverride() {
2006         return categoryOverride;
2007     }
2008 
2009     @DataClass.Generated.Member
2010     public @NonNull PackageStateUnserialized getPkgState() {
2011         return pkgState;
2012     }
2013 
2014     @DataClass.Generated.Member
2015     public @NonNull UUID getDomainSetId() {
2016         return mDomainSetId;
2017     }
2018 
2019     @DataClass.Generated.Member
2020     public @Nullable String getAppMetadataFilePath() {
2021         return mAppMetadataFilePath;
2022     }
2023 
2024     @DataClass.Generated.Member
2025     public int getAppMetadataSource() {
2026         return mAppMetadataSource;
2027     }
2028 
2029     @DataClass.Generated.Member
2030     public int getTargetSdkVersion() {
2031         return mTargetSdkVersion;
2032     }
2033 
2034     @DataClass.Generated.Member
2035     public @Nullable byte[] getRestrictUpdateHash() {
2036         return mRestrictUpdateHash;
2037     }
2038 
2039     @DataClass.Generated(
2040             time = 1706698406378L,
2041             codegenVersion = "1.0.23",
2042             sourceFile = "frameworks/base/services/core/java/com/android/server/pm/PackageSetting.java",
2043             inputSignatures = "private  int mBooleans\nprivate  int mSharedUserAppId\nprivate @android.annotation.Nullable java.util.Map<java.lang.String,java.util.Set<java.lang.String>> mimeGroups\nprivate @android.annotation.Nullable java.lang.String[] usesSdkLibraries\nprivate @android.annotation.Nullable long[] usesSdkLibrariesVersionsMajor\nprivate @android.annotation.Nullable boolean[] usesSdkLibrariesOptional\nprivate @android.annotation.Nullable java.lang.String[] usesStaticLibraries\nprivate @android.annotation.Nullable long[] usesStaticLibrariesVersions\nprivate @android.annotation.Nullable @java.lang.Deprecated java.lang.String legacyNativeLibraryPath\nprivate @android.annotation.NonNull java.lang.String mName\nprivate @android.annotation.Nullable java.lang.String mRealName\nprivate  int mAppId\nprivate @android.annotation.Nullable com.android.internal.pm.parsing.pkg.AndroidPackageInternal pkg\nprivate @android.annotation.NonNull java.io.File mPath\nprivate @android.annotation.NonNull java.lang.String mPathString\nprivate @android.annotation.Nullable java.util.LinkedHashSet<java.io.File> mOldPaths\nprivate  float mLoadingProgress\nprivate  long mLoadingCompletedTime\nprivate @android.annotation.Nullable java.lang.String mPrimaryCpuAbi\nprivate @android.annotation.Nullable java.lang.String mSecondaryCpuAbi\nprivate @android.annotation.Nullable java.lang.String mCpuAbiOverride\nprivate  long mLastModifiedTime\nprivate  long lastUpdateTime\nprivate  long versionCode\nprivate @android.annotation.NonNull com.android.server.pm.PackageSignatures signatures\nprivate @android.annotation.NonNull com.android.server.pm.PackageKeySetData keySetData\nprivate final @android.annotation.NonNull android.util.SparseArray<com.android.server.pm.pkg.PackageUserStateImpl> mUserStates\nprivate @android.annotation.NonNull com.android.server.pm.InstallSource installSource\nprivate @android.annotation.Nullable java.lang.String volumeUuid\nprivate  int categoryOverride\nprivate final @android.annotation.NonNull com.android.server.pm.pkg.PackageStateUnserialized pkgState\nprivate @android.annotation.NonNull java.util.UUID mDomainSetId\nprivate @android.annotation.Nullable java.lang.String mAppMetadataFilePath\nprivate  int mAppMetadataSource\nprivate  int mTargetSdkVersion\nprivate @android.annotation.Nullable byte[] mRestrictUpdateHash\nprivate final @android.annotation.NonNull com.android.server.utils.SnapshotCache<com.android.server.pm.PackageSetting> mSnapshot\nprivate  void setBoolean(int,boolean)\nprivate  boolean getBoolean(int)\nprivate  com.android.server.utils.SnapshotCache<com.android.server.pm.PackageSetting> makeCache()\npublic  com.android.server.pm.PackageSetting snapshot()\npublic  void dumpDebug(android.util.proto.ProtoOutputStream,long,java.util.List<android.content.pm.UserInfo>,com.android.server.pm.permission.LegacyPermissionDataProvider)\npublic  com.android.server.pm.PackageSetting setAppId(int)\npublic  com.android.server.pm.PackageSetting setCpuAbiOverride(java.lang.String)\npublic  com.android.server.pm.PackageSetting setFirstInstallTimeFromReplaced(com.android.server.pm.pkg.PackageStateInternal,int[])\npublic  com.android.server.pm.PackageSetting setFirstInstallTime(long,int)\npublic  com.android.server.pm.PackageSetting setForceQueryableOverride(boolean)\npublic  com.android.server.pm.PackageSetting setInstallerPackage(java.lang.String,int)\npublic  com.android.server.pm.PackageSetting setUpdateOwnerPackage(java.lang.String)\npublic  com.android.server.pm.PackageSetting setInstallSource(com.android.server.pm.InstallSource)\n  com.android.server.pm.PackageSetting removeInstallerPackage(java.lang.String)\npublic  com.android.server.pm.PackageSetting setIsOrphaned(boolean)\npublic  com.android.server.pm.PackageSetting setKeySetData(com.android.server.pm.PackageKeySetData)\npublic  com.android.server.pm.PackageSetting setLastModifiedTime(long)\npublic  com.android.server.pm.PackageSetting setLastUpdateTime(long)\npublic  com.android.server.pm.PackageSetting setLongVersionCode(long)\npublic  boolean setMimeGroup(java.lang.String,android.util.ArraySet<java.lang.String>)\npublic  com.android.server.pm.PackageSetting setPkg(com.android.server.pm.pkg.AndroidPackage)\npublic  com.android.server.pm.PackageSetting setPkgStateLibraryFiles(java.util.Collection<java.lang.String>)\npublic  com.android.server.pm.PackageSetting setPrimaryCpuAbi(java.lang.String)\npublic  com.android.server.pm.PackageSetting setSecondaryCpuAbi(java.lang.String)\npublic  com.android.server.pm.PackageSetting setSignatures(com.android.server.pm.PackageSignatures)\npublic  com.android.server.pm.PackageSetting setVolumeUuid(java.lang.String)\npublic @java.lang.Override boolean isExternalStorage()\npublic  com.android.server.pm.PackageSetting setUpdateAvailable(boolean)\npublic  com.android.server.pm.PackageSetting setSharedUserAppId(int)\npublic  com.android.server.pm.PackageSetting setTargetSdkVersion(int)\npublic  com.android.server.pm.PackageSetting setRestrictUpdateHash(byte[])\npublic @java.lang.Override int getSharedUserAppId()\npublic @java.lang.Override boolean hasSharedUser()\npublic @java.lang.Override java.lang.String toString()\nprivate  void copyMimeGroups(java.util.Map<java.lang.String,java.util.Set<java.lang.String>>)\npublic  void updateFrom(com.android.server.pm.PackageSetting)\n  com.android.server.pm.PackageSetting updateMimeGroups(java.util.Set<java.lang.String>)\npublic @java.lang.Deprecated @java.lang.Override com.android.server.pm.permission.LegacyPermissionState getLegacyPermissionState()\npublic  com.android.server.pm.PackageSetting setInstallPermissionsFixed(boolean)\npublic  boolean isPrivileged()\npublic  boolean isOem()\npublic  boolean isVendor()\npublic  boolean isProduct()\npublic @java.lang.Override boolean isRequiredForSystemUser()\npublic  boolean isSystemExt()\npublic  boolean isOdm()\npublic  boolean isSystem()\npublic  boolean isRequestLegacyExternalStorage()\npublic  boolean isUserDataFragile()\npublic  android.content.pm.SigningDetails getSigningDetails()\npublic  com.android.server.pm.PackageSetting setSigningDetails(android.content.pm.SigningDetails)\npublic  void copyPackageSetting(com.android.server.pm.PackageSetting,boolean)\n @com.android.internal.annotations.VisibleForTesting com.android.server.pm.pkg.PackageUserStateImpl modifyUserState(int)\npublic  com.android.server.pm.pkg.PackageUserStateImpl getOrCreateUserState(int)\npublic @android.annotation.NonNull com.android.server.pm.pkg.PackageUserStateInternal readUserState(int)\n  void setEnabled(int,int,java.lang.String)\n  int getEnabled(int)\n  void setInstalled(boolean,int)\n  void setArchiveState(com.android.server.pm.pkg.ArchiveState,int)\n  boolean getInstalled(int)\n  boolean isArchived(int)\n  int getInstallReason(int)\n  void setInstallReason(int,int)\n  int getUninstallReason(int)\n  void setUninstallReason(int,int)\n @android.annotation.NonNull android.content.pm.overlay.OverlayPaths getOverlayPaths(int)\n  boolean setOverlayPathsForLibrary(java.lang.String,android.content.pm.overlay.OverlayPaths,int)\n  boolean isInstalledOnAnyOtherUser(int[],int)\n  boolean hasDataOnAnyOtherUser(int[],int)\n  int[] queryInstalledUsers(int[],boolean)\n  int[] queryUsersInstalledOrHasData(int[])\n  long getCeDataInode(int)\n  long getDeDataInode(int)\n  void setCeDataInode(long,int)\n  void setDeDataInode(long,int)\n  boolean getStopped(int)\n  void setStopped(boolean,int)\npublic  com.android.server.pm.PackageSetting setScannedAsStoppedSystemApp(boolean)\n  boolean getNotLaunched(int)\n  void setNotLaunched(boolean,int)\n  boolean getHidden(int)\n  void setHidden(boolean,int)\n  int getDistractionFlags(int)\n  void setDistractionFlags(int,int)\npublic  boolean getInstantApp(int)\n  void setInstantApp(boolean,int)\n  boolean getVirtualPreload(int)\n  void setVirtualPreload(boolean,int)\n  void setUserState(int,long,long,int,boolean,boolean,boolean,boolean,int,android.util.ArrayMap<android.content.pm.UserPackage,com.android.server.pm.pkg.SuspendParams>,boolean,boolean,java.lang.String,android.util.ArraySet<java.lang.String>,android.util.ArraySet<java.lang.String>,int,int,java.lang.String,java.lang.String,long,int,com.android.server.pm.pkg.ArchiveState)\n  void setUserState(int,com.android.server.pm.pkg.PackageUserStateInternal)\n  com.android.server.utils.WatchedArraySet<java.lang.String> getEnabledComponents(int)\n  com.android.server.utils.WatchedArraySet<java.lang.String> getDisabledComponents(int)\n  void setEnabledComponents(com.android.server.utils.WatchedArraySet<java.lang.String>,int)\n  void setDisabledComponents(com.android.server.utils.WatchedArraySet<java.lang.String>,int)\n  void setEnabledComponentsCopy(com.android.server.utils.WatchedArraySet<java.lang.String>,int)\n  void setDisabledComponentsCopy(com.android.server.utils.WatchedArraySet<java.lang.String>,int)\n  com.android.server.pm.pkg.PackageUserStateImpl modifyUserStateComponents(int,boolean,boolean)\n  void addDisabledComponent(java.lang.String,int)\n  void addEnabledComponent(java.lang.String,int)\n  boolean enableComponentLPw(java.lang.String,int)\n  boolean disableComponentLPw(java.lang.String,int)\n  boolean restoreComponentLPw(java.lang.String,int)\n  void restoreComponentSettings(int)\n  int getCurrentEnabledStateLPr(java.lang.String,int)\n  void removeUser(int)\npublic  int[] getNotInstalledUserIds()\n  void writePackageUserPermissionsProto(android.util.proto.ProtoOutputStream,long,java.util.List<android.content.pm.UserInfo>,com.android.server.pm.permission.LegacyPermissionDataProvider)\nprotected  void writeUsersInfoToProto(android.util.proto.ProtoOutputStream,long)\nprivate static  void writeArchiveState(android.util.proto.ProtoOutputStream,com.android.server.pm.pkg.ArchiveState)\npublic @com.android.internal.annotations.VisibleForTesting com.android.server.pm.PackageSetting setPath(java.io.File)\npublic @com.android.internal.annotations.VisibleForTesting com.android.server.pm.PackageSetting addOldPath(java.io.File)\npublic @com.android.internal.annotations.VisibleForTesting com.android.server.pm.PackageSetting removeOldPath(java.io.File)\npublic @com.android.internal.annotations.VisibleForTesting boolean overrideNonLocalizedLabelAndIcon(android.content.ComponentName,java.lang.String,java.lang.Integer,int)\npublic  void resetOverrideComponentLabelIcon(int)\npublic @android.annotation.Nullable java.lang.String getSplashScreenTheme(int)\npublic  boolean isIncremental()\npublic  boolean isLoading()\npublic  com.android.server.pm.PackageSetting setLoadingProgress(float)\npublic  com.android.server.pm.PackageSetting setLoadingCompletedTime(long)\npublic  com.android.server.pm.PackageSetting setAppMetadataFilePath(java.lang.String)\npublic  com.android.server.pm.PackageSetting setAppMetadataSource(int)\npublic @android.annotation.NonNull @java.lang.Override long getVersionCode()\npublic @android.annotation.Nullable @java.lang.Override java.util.Map<java.lang.String,java.util.Set<java.lang.String>> getMimeGroups()\npublic @android.annotation.NonNull @java.lang.Override java.lang.String getPackageName()\npublic @android.annotation.Nullable @java.lang.Override com.android.server.pm.pkg.AndroidPackage getAndroidPackage()\npublic @android.annotation.NonNull android.content.pm.SigningInfo getSigningInfo()\npublic @android.annotation.NonNull @java.lang.Override java.lang.String[] getUsesSdkLibraries()\npublic @android.annotation.NonNull @java.lang.Override long[] getUsesSdkLibrariesVersionsMajor()\npublic @android.annotation.NonNull @java.lang.Override boolean[] getUsesSdkLibrariesOptional()\npublic @android.annotation.NonNull @java.lang.Override java.lang.String[] getUsesStaticLibraries()\npublic @android.annotation.NonNull @java.lang.Override long[] getUsesStaticLibrariesVersions()\npublic @android.annotation.NonNull @java.lang.Override java.util.List<com.android.server.pm.pkg.SharedLibrary> getSharedLibraryDependencies()\npublic @android.annotation.NonNull com.android.server.pm.PackageSetting addUsesLibraryInfo(android.content.pm.SharedLibraryInfo)\npublic @android.annotation.NonNull @java.lang.Override java.util.List<java.lang.String> getUsesLibraryFiles()\npublic @android.annotation.NonNull com.android.server.pm.PackageSetting addUsesLibraryFile(java.lang.String)\npublic @java.lang.Override boolean isHiddenUntilInstalled()\npublic @android.annotation.NonNull @java.lang.Override long[] getLastPackageUsageTime()\npublic @java.lang.Override boolean isUpdatedSystemApp()\npublic @java.lang.Override boolean isApkInUpdatedApex()\npublic @android.annotation.Nullable @java.lang.Override java.lang.String getApexModuleName()\npublic  com.android.server.pm.PackageSetting setDomainSetId(java.util.UUID)\npublic  com.android.server.pm.PackageSetting setCategoryOverride(int)\npublic  com.android.server.pm.PackageSetting setLegacyNativeLibraryPath(java.lang.String)\npublic  com.android.server.pm.PackageSetting setMimeGroups(java.util.Map<java.lang.String,java.util.Set<java.lang.String>>)\npublic  com.android.server.pm.PackageSetting setUsesSdkLibraries(java.lang.String[])\npublic  com.android.server.pm.PackageSetting setUsesSdkLibrariesVersionsMajor(long[])\npublic  com.android.server.pm.PackageSetting setUsesSdkLibrariesOptional(boolean[])\npublic  com.android.server.pm.PackageSetting setUsesStaticLibraries(java.lang.String[])\npublic  com.android.server.pm.PackageSetting setUsesStaticLibrariesVersions(long[])\npublic  com.android.server.pm.PackageSetting setApexModuleName(java.lang.String)\npublic @android.annotation.NonNull @java.lang.Override com.android.server.pm.pkg.PackageStateUnserialized getTransientState()\npublic @android.annotation.NonNull android.util.SparseArray<? extends PackageUserStateInternal> getUserStates()\npublic  com.android.server.pm.PackageSetting addMimeTypes(java.lang.String,java.util.Set<java.lang.String>)\npublic @android.annotation.NonNull @java.lang.Override com.android.server.pm.pkg.PackageUserState getStateForUser(android.os.UserHandle)\npublic @android.annotation.Nullable java.lang.String getPrimaryCpuAbi()\npublic @android.annotation.Nullable java.lang.String getSecondaryCpuAbi()\npublic @android.annotation.Nullable @java.lang.Override java.lang.String getSeInfo()\npublic @android.annotation.Nullable java.lang.String getPrimaryCpuAbiLegacy()\npublic @android.annotation.Nullable java.lang.String getSecondaryCpuAbiLegacy()\npublic @android.content.pm.ApplicationInfo.HiddenApiEnforcementPolicy @java.lang.Override int getHiddenApiEnforcementPolicy()\npublic @java.lang.Override boolean isApex()\npublic @java.lang.Override boolean isForceQueryableOverride()\npublic @java.lang.Override boolean isUpdateAvailable()\npublic @java.lang.Override boolean isInstallPermissionsFixed()\npublic @java.lang.Override boolean isDefaultToDeviceProtectedStorage()\npublic @java.lang.Override boolean isPersistent()\npublic @java.lang.Override boolean isScannedAsStoppedSystemApp()\nclass PackageSetting extends com.android.server.pm.SettingBase implements [com.android.server.pm.pkg.PackageStateInternal]\nprivate static final  int INSTALL_PERMISSION_FIXED\nprivate static final  int UPDATE_AVAILABLE\nprivate static final  int FORCE_QUERYABLE_OVERRIDE\nprivate static final  int SCANNED_AS_STOPPED_SYSTEM_APP\nclass Booleans extends java.lang.Object implements []\n@com.android.internal.util.DataClass(genGetters=true, genConstructor=false, genSetters=false, genBuilder=false)")
2044     @Deprecated
2045     private void __metadata() {}
2046 
2047     //@formatter:on
2048     // End of generated code
2049 
2050 }
2051