• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
1 /*
2  * Copyright (C) 2020 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 android.content.pm.parsing;
18 
19 import static java.util.Collections.emptyList;
20 import static java.util.Collections.emptyMap;
21 import static java.util.Collections.emptySet;
22 
23 import android.annotation.NonNull;
24 import android.annotation.Nullable;
25 import android.content.Intent;
26 import android.content.IntentFilter;
27 import android.content.pm.ApplicationInfo;
28 import android.content.pm.ConfigurationInfo;
29 import android.content.pm.FeatureGroupInfo;
30 import android.content.pm.FeatureInfo;
31 import android.content.pm.PackageInfo;
32 import android.content.pm.PackageParser;
33 import android.content.pm.parsing.component.ParsedActivity;
34 import android.content.pm.parsing.component.ParsedAttribution;
35 import android.content.pm.parsing.component.ParsedComponent;
36 import android.content.pm.parsing.component.ParsedInstrumentation;
37 import android.content.pm.parsing.component.ParsedIntentInfo;
38 import android.content.pm.parsing.component.ParsedMainComponent;
39 import android.content.pm.parsing.component.ParsedPermission;
40 import android.content.pm.parsing.component.ParsedPermissionGroup;
41 import android.content.pm.parsing.component.ParsedProcess;
42 import android.content.pm.parsing.component.ParsedProvider;
43 import android.content.pm.parsing.component.ParsedService;
44 import android.content.res.TypedArray;
45 import android.os.Build;
46 import android.os.Bundle;
47 import android.os.Parcel;
48 import android.os.Parcelable;
49 import android.os.storage.StorageManager;
50 import android.text.TextUtils;
51 import android.util.ArraySet;
52 import android.util.Pair;
53 import android.util.SparseArray;
54 import android.util.SparseIntArray;
55 
56 import com.android.internal.R;
57 import com.android.internal.annotations.VisibleForTesting;
58 import com.android.internal.util.ArrayUtils;
59 import com.android.internal.util.CollectionUtils;
60 import com.android.internal.util.DataClass;
61 import com.android.internal.util.Parcelling;
62 import com.android.internal.util.Parcelling.BuiltIn.ForBoolean;
63 import com.android.internal.util.Parcelling.BuiltIn.ForInternedString;
64 import com.android.internal.util.Parcelling.BuiltIn.ForInternedStringArray;
65 import com.android.internal.util.Parcelling.BuiltIn.ForInternedStringList;
66 import com.android.internal.util.Parcelling.BuiltIn.ForInternedStringSet;
67 import com.android.internal.util.Parcelling.BuiltIn.ForInternedStringValueMap;
68 import com.android.internal.util.Parcelling.BuiltIn.ForStringSet;
69 
70 import java.security.PublicKey;
71 import java.util.Collections;
72 import java.util.Comparator;
73 import java.util.List;
74 import java.util.Map;
75 import java.util.Set;
76 
77 /**
78  * The backing data for a package that was parsed from disk.
79  *
80  * The field nullability annotations here are for internal reference. For effective nullability,
81  * see the parent interfaces.
82  *
83  * TODO(b/135203078): Convert Lists used as sets into Sets, to better express intended use case
84  *
85  * @hide
86  */
87 public class ParsingPackageImpl implements ParsingPackage, Parcelable {
88 
89     private static final String TAG = "PackageImpl";
90 
91     public static ForBoolean sForBoolean = Parcelling.Cache.getOrCreate(ForBoolean.class);
92     public static ForInternedString sForInternedString = Parcelling.Cache.getOrCreate(
93             ForInternedString.class);
94     public static ForInternedStringArray sForInternedStringArray = Parcelling.Cache.getOrCreate(
95             ForInternedStringArray.class);
96     public static ForInternedStringList sForInternedStringList = Parcelling.Cache.getOrCreate(
97             ForInternedStringList.class);
98     public static ForInternedStringValueMap sForInternedStringValueMap =
99             Parcelling.Cache.getOrCreate(ForInternedStringValueMap.class);
100     public static ForStringSet sForStringSet = Parcelling.Cache.getOrCreate(ForStringSet.class);
101     public static ForInternedStringSet sForInternedStringSet =
102             Parcelling.Cache.getOrCreate(ForInternedStringSet.class);
103     protected static ParsedIntentInfo.StringPairListParceler sForIntentInfoPairs =
104             Parcelling.Cache.getOrCreate(ParsedIntentInfo.StringPairListParceler.class);
105 
106     private static final Comparator<ParsedMainComponent> ORDER_COMPARATOR =
107             (first, second) -> Integer.compare(second.getOrder(), first.getOrder());
108 
109     // These are objects because null represents not explicitly set
110     @Nullable
111     @DataClass.ParcelWith(ForBoolean.class)
112     private Boolean supportsSmallScreens;
113     @Nullable
114     @DataClass.ParcelWith(ForBoolean.class)
115     private Boolean supportsNormalScreens;
116     @Nullable
117     @DataClass.ParcelWith(ForBoolean.class)
118     private Boolean supportsLargeScreens;
119     @Nullable
120     @DataClass.ParcelWith(ForBoolean.class)
121     private Boolean supportsExtraLargeScreens;
122     @Nullable
123     @DataClass.ParcelWith(ForBoolean.class)
124     private Boolean resizeable;
125     @Nullable
126     @DataClass.ParcelWith(ForBoolean.class)
127     private Boolean anyDensity;
128 
129     protected int versionCode;
130     protected int versionCodeMajor;
131     private int baseRevisionCode;
132     @Nullable
133     @DataClass.ParcelWith(ForInternedString.class)
134     private String versionName;
135 
136     private int compileSdkVersion;
137     @Nullable
138     @DataClass.ParcelWith(ForInternedString.class)
139     private String compileSdkVersionCodeName;
140 
141     @NonNull
142     @DataClass.ParcelWith(ForInternedString.class)
143     protected String packageName;
144 
145     @Nullable
146     @DataClass.ParcelWith(ForInternedString.class)
147     private String realPackage;
148 
149     @NonNull
150     protected String baseCodePath;
151 
152     private boolean requiredForAllUsers;
153     @Nullable
154     @DataClass.ParcelWith(ForInternedString.class)
155     private String restrictedAccountType;
156     @Nullable
157     @DataClass.ParcelWith(ForInternedString.class)
158     private String requiredAccountType;
159 
160     @Nullable
161     @DataClass.ParcelWith(ForInternedString.class)
162     private String overlayTarget;
163     @Nullable
164     @DataClass.ParcelWith(ForInternedString.class)
165     private String overlayTargetName;
166     @Nullable
167     @DataClass.ParcelWith(ForInternedString.class)
168     private String overlayCategory;
169     private int overlayPriority;
170     private boolean overlayIsStatic;
171     @NonNull
172     @DataClass.ParcelWith(ForInternedStringValueMap.class)
173     private Map<String, String> overlayables = emptyMap();
174 
175     @Nullable
176     @DataClass.ParcelWith(ForInternedString.class)
177     private String staticSharedLibName;
178     private long staticSharedLibVersion;
179     @NonNull
180     @DataClass.ParcelWith(ForInternedStringList.class)
181     private List<String> libraryNames = emptyList();
182     @NonNull
183     @DataClass.ParcelWith(ForInternedStringList.class)
184     protected List<String> usesLibraries = emptyList();
185     @NonNull
186     @DataClass.ParcelWith(ForInternedStringList.class)
187     protected List<String> usesOptionalLibraries = emptyList();
188 
189     @NonNull
190     @DataClass.ParcelWith(ForInternedStringList.class)
191     private List<String> usesStaticLibraries = emptyList();
192     @Nullable
193     private long[] usesStaticLibrariesVersions;
194 
195     @Nullable
196     private String[][] usesStaticLibrariesCertDigests;
197 
198     @Nullable
199     @DataClass.ParcelWith(ForInternedString.class)
200     private String sharedUserId;
201 
202     private int sharedUserLabel;
203     @NonNull
204     private List<ConfigurationInfo> configPreferences = emptyList();
205     @NonNull
206     private List<FeatureInfo> reqFeatures = emptyList();
207     @NonNull
208     private List<FeatureGroupInfo> featureGroups = emptyList();
209 
210     @Nullable
211     private byte[] restrictUpdateHash;
212 
213     @NonNull
214     @DataClass.ParcelWith(ForInternedStringList.class)
215     protected List<String> originalPackages = emptyList();
216     @NonNull
217     @DataClass.ParcelWith(ForInternedStringList.class)
218     protected List<String> adoptPermissions = emptyList();
219 
220     @NonNull
221     @DataClass.ParcelWith(ForInternedStringList.class)
222     private List<String> requestedPermissions = emptyList();
223     @NonNull
224     @DataClass.ParcelWith(ForInternedStringList.class)
225     private List<String> implicitPermissions = emptyList();
226 
227     @NonNull
228     private Set<String> upgradeKeySets = emptySet();
229     @NonNull
230     private Map<String, ArraySet<PublicKey>> keySetMapping = emptyMap();
231 
232     @NonNull
233     @DataClass.ParcelWith(ForInternedStringList.class)
234     protected List<String> protectedBroadcasts = emptyList();
235 
236     @NonNull
237     protected List<ParsedActivity> activities = emptyList();
238 
239     @NonNull
240     protected List<ParsedActivity> receivers = emptyList();
241 
242     @NonNull
243     protected List<ParsedService> services = emptyList();
244 
245     @NonNull
246     protected List<ParsedProvider> providers = emptyList();
247 
248     @NonNull
249     private List<ParsedAttribution> attributions = emptyList();
250 
251     @NonNull
252     protected List<ParsedPermission> permissions = emptyList();
253 
254     @NonNull
255     protected List<ParsedPermissionGroup> permissionGroups = emptyList();
256 
257     @NonNull
258     protected List<ParsedInstrumentation> instrumentations = emptyList();
259 
260     @NonNull
261     @DataClass.ParcelWith(ParsedIntentInfo.ListParceler.class)
262     private List<Pair<String, ParsedIntentInfo>> preferredActivityFilters = emptyList();
263 
264     @NonNull
265     private Map<String, ParsedProcess> processes = emptyMap();
266 
267     @Nullable
268     private Bundle metaData;
269 
270     @Nullable
271     @DataClass.ParcelWith(ForInternedString.class)
272     protected String volumeUuid;
273     @Nullable
274     private PackageParser.SigningDetails signingDetails;
275 
276     @NonNull
277     @DataClass.ParcelWith(ForInternedString.class)
278     protected String codePath;
279 
280     private boolean use32BitAbi;
281     private boolean visibleToInstantApps;
282 
283     private boolean forceQueryable;
284 
285     @NonNull
286     @DataClass.ParcelWith(ForInternedStringList.class)
287     private List<Intent> queriesIntents = emptyList();
288 
289     @NonNull
290     @DataClass.ParcelWith(ForInternedStringList.class)
291     private List<String> queriesPackages = emptyList();
292 
293     @NonNull
294     @DataClass.ParcelWith(ForInternedStringSet.class)
295     private Set<String> queriesProviders = emptySet();
296 
297     @Nullable
298     @DataClass.ParcelWith(ForInternedStringArray.class)
299     private String[] splitClassLoaderNames;
300     @Nullable
301     protected String[] splitCodePaths;
302     @Nullable
303     private SparseArray<int[]> splitDependencies;
304     @Nullable
305     private int[] splitFlags;
306     @Nullable
307     @DataClass.ParcelWith(ForInternedStringArray.class)
308     private String[] splitNames;
309     @Nullable
310     private int[] splitRevisionCodes;
311 
312     @Nullable
313     @DataClass.ParcelWith(ForInternedString.class)
314     private String appComponentFactory;
315     @Nullable
316     @DataClass.ParcelWith(ForInternedString.class)
317     private String backupAgentName;
318     private int banner;
319     private int category;
320     @Nullable
321     @DataClass.ParcelWith(ForInternedString.class)
322     private String classLoaderName;
323     @Nullable
324     @DataClass.ParcelWith(ForInternedString.class)
325     private String className;
326     private int compatibleWidthLimitDp;
327     private int descriptionRes;
328 
329     // Usually there's code to set this to true during parsing, but it's possible to install an APK
330     // targeting <R that doesn't contain an <application> tag. That code would be skipped and never
331     // assign this, so initialize this to true for those cases.
332     private boolean enabled = true;
333 
334     private boolean crossProfile;
335     private int fullBackupContent;
336     private int iconRes;
337     private int installLocation = PackageParser.PARSE_DEFAULT_INSTALL_LOCATION;
338     private int labelRes;
339     private int largestWidthLimitDp;
340     private int logo;
341     @Nullable
342     @DataClass.ParcelWith(ForInternedString.class)
343     private String manageSpaceActivityName;
344     private float maxAspectRatio;
345     private float minAspectRatio;
346     @Nullable
347     private SparseIntArray minExtensionVersions;
348     private int minSdkVersion;
349     private int networkSecurityConfigRes;
350     @Nullable
351     private CharSequence nonLocalizedLabel;
352     @Nullable
353     @DataClass.ParcelWith(ForInternedString.class)
354     private String permission;
355     @Nullable
356     @DataClass.ParcelWith(ForInternedString.class)
357     private String processName;
358     private int requiresSmallestWidthDp;
359     private int roundIconRes;
360     private int targetSandboxVersion;
361     private int targetSdkVersion;
362     @Nullable
363     @DataClass.ParcelWith(ForInternedString.class)
364     private String taskAffinity;
365     private int theme;
366 
367     private int uiOptions;
368     @Nullable
369     @DataClass.ParcelWith(ForInternedString.class)
370     private String zygotePreloadName;
371 
372     private boolean externalStorage;
373     private boolean baseHardwareAccelerated;
374     private boolean allowBackup;
375     private boolean killAfterRestore;
376     private boolean restoreAnyVersion;
377     private boolean fullBackupOnly;
378     private boolean persistent;
379     private boolean debuggable;
380     private boolean vmSafeMode;
381     private boolean hasCode;
382     private boolean allowTaskReparenting;
383     private boolean allowClearUserData;
384     private boolean largeHeap;
385     private boolean usesCleartextTraffic;
386     private boolean supportsRtl;
387     private boolean testOnly;
388     private boolean multiArch;
389     private boolean extractNativeLibs;
390     private boolean game;
391 
392     /**
393      * @see ParsingPackageRead#getResizeableActivity()
394      */
395     @Nullable
396     @DataClass.ParcelWith(ForBoolean.class)
397     private Boolean resizeableActivity;
398 
399     private boolean staticSharedLibrary;
400     private boolean overlay;
401     private boolean isolatedSplitLoading;
402     private boolean hasDomainUrls;
403     private boolean profileableByShell;
404     private boolean backupInForeground;
405     private boolean useEmbeddedDex;
406     private boolean defaultToDeviceProtectedStorage;
407     private boolean directBootAware;
408     private boolean partiallyDirectBootAware;
409     private boolean resizeableActivityViaSdkVersion;
410     private boolean allowClearUserDataOnFailedRestore;
411     private boolean allowAudioPlaybackCapture;
412     private boolean requestLegacyExternalStorage;
413     private boolean usesNonSdkApi;
414     private boolean hasFragileUserData;
415     private boolean cantSaveState;
416     private boolean allowNativeHeapPointerTagging;
417     private int autoRevokePermissions;
418     private boolean preserveLegacyExternalStorage;
419 
420     protected int gwpAsanMode;
421 
422     // TODO(chiuwinson): Non-null
423     @Nullable
424     private ArraySet<String> mimeGroups;
425 
426     @VisibleForTesting
ParsingPackageImpl(@onNull String packageName, @NonNull String baseCodePath, @NonNull String codePath, @Nullable TypedArray manifestArray)427     public ParsingPackageImpl(@NonNull String packageName, @NonNull String baseCodePath,
428             @NonNull String codePath, @Nullable TypedArray manifestArray) {
429         this.packageName = TextUtils.safeIntern(packageName);
430         this.baseCodePath = baseCodePath;
431         this.codePath = codePath;
432 
433         if (manifestArray != null) {
434             versionCode = manifestArray.getInteger(R.styleable.AndroidManifest_versionCode, 0);
435             versionCodeMajor = manifestArray.getInteger(
436                     R.styleable.AndroidManifest_versionCodeMajor, 0);
437             setBaseRevisionCode(
438                     manifestArray.getInteger(R.styleable.AndroidManifest_revisionCode, 0));
439             setVersionName(manifestArray.getNonConfigurationString(
440                     R.styleable.AndroidManifest_versionName, 0));
441 
442             setCompileSdkVersion(manifestArray.getInteger(
443                     R.styleable.AndroidManifest_compileSdkVersion, 0));
444             setCompileSdkVersionCodename(manifestArray.getNonConfigurationString(
445                     R.styleable.AndroidManifest_compileSdkVersionCodename, 0));
446 
447             setIsolatedSplitLoading(manifestArray.getBoolean(
448                     R.styleable.AndroidManifest_isolatedSplits, false));
449 
450         }
451     }
452 
isSupportsSmallScreens()453     public boolean isSupportsSmallScreens() {
454         if (supportsSmallScreens == null) {
455             return targetSdkVersion >= Build.VERSION_CODES.DONUT;
456         }
457 
458         return supportsSmallScreens;
459     }
460 
isSupportsNormalScreens()461     public boolean isSupportsNormalScreens() {
462         return supportsNormalScreens == null || supportsNormalScreens;
463     }
464 
isSupportsLargeScreens()465     public boolean isSupportsLargeScreens() {
466         if (supportsLargeScreens == null) {
467             return targetSdkVersion >= Build.VERSION_CODES.DONUT;
468         }
469 
470         return supportsLargeScreens;
471     }
472 
isSupportsExtraLargeScreens()473     public boolean isSupportsExtraLargeScreens() {
474         if (supportsExtraLargeScreens == null) {
475             return targetSdkVersion >= Build.VERSION_CODES.GINGERBREAD;
476         }
477 
478         return supportsExtraLargeScreens;
479     }
480 
isResizeable()481     public boolean isResizeable() {
482         if (resizeable == null) {
483             return targetSdkVersion >= Build.VERSION_CODES.DONUT;
484         }
485 
486         return resizeable;
487     }
488 
isAnyDensity()489     public boolean isAnyDensity() {
490         if (anyDensity == null) {
491             return targetSdkVersion >= Build.VERSION_CODES.DONUT;
492         }
493 
494         return anyDensity;
495     }
496 
497     @Override
sortActivities()498     public ParsingPackageImpl sortActivities() {
499         Collections.sort(this.activities, ORDER_COMPARATOR);
500         return this;
501     }
502 
503     @Override
sortReceivers()504     public ParsingPackageImpl sortReceivers() {
505         Collections.sort(this.receivers, ORDER_COMPARATOR);
506         return this;
507     }
508 
509     @Override
sortServices()510     public ParsingPackageImpl sortServices() {
511         Collections.sort(this.services, ORDER_COMPARATOR);
512         return this;
513     }
514 
515     @Override
hideAsParsed()516     public Object hideAsParsed() {
517         // There is no equivalent for core-only parsing
518         throw new UnsupportedOperationException();
519     }
520 
521     @Override
addConfigPreference(ConfigurationInfo configPreference)522     public ParsingPackageImpl addConfigPreference(ConfigurationInfo configPreference) {
523         this.configPreferences = CollectionUtils.add(this.configPreferences, configPreference);
524         return this;
525     }
526 
527     @Override
addReqFeature(FeatureInfo reqFeature)528     public ParsingPackageImpl addReqFeature(FeatureInfo reqFeature) {
529         this.reqFeatures = CollectionUtils.add(this.reqFeatures, reqFeature);
530         return this;
531     }
532 
533     @Override
addFeatureGroup(FeatureGroupInfo featureGroup)534     public ParsingPackageImpl addFeatureGroup(FeatureGroupInfo featureGroup) {
535         this.featureGroups = CollectionUtils.add(this.featureGroups, featureGroup);
536         return this;
537     }
538 
539     @Override
addProtectedBroadcast(String protectedBroadcast)540     public ParsingPackageImpl addProtectedBroadcast(String protectedBroadcast) {
541         if (!this.protectedBroadcasts.contains(protectedBroadcast)) {
542             this.protectedBroadcasts = CollectionUtils.add(this.protectedBroadcasts,
543                     TextUtils.safeIntern(protectedBroadcast));
544         }
545         return this;
546     }
547 
548     @Override
addInstrumentation(ParsedInstrumentation instrumentation)549     public ParsingPackageImpl addInstrumentation(ParsedInstrumentation instrumentation) {
550         this.instrumentations = CollectionUtils.add(this.instrumentations, instrumentation);
551         return this;
552     }
553 
554     @Override
addOriginalPackage(String originalPackage)555     public ParsingPackageImpl addOriginalPackage(String originalPackage) {
556         this.originalPackages = CollectionUtils.add(this.originalPackages, originalPackage);
557         return this;
558     }
559 
560     @Override
addOverlayable(String overlayableName, String actorName)561     public ParsingPackage addOverlayable(String overlayableName, String actorName) {
562         this.overlayables = CollectionUtils.add(this.overlayables, overlayableName,
563                 TextUtils.safeIntern(actorName));
564         return this;
565     }
566 
567     @Override
addAdoptPermission(String adoptPermission)568     public ParsingPackageImpl addAdoptPermission(String adoptPermission) {
569         this.adoptPermissions = CollectionUtils.add(this.adoptPermissions,
570                 TextUtils.safeIntern(adoptPermission));
571         return this;
572     }
573 
574     @Override
addPermission(ParsedPermission permission)575     public ParsingPackageImpl addPermission(ParsedPermission permission) {
576         this.permissions = CollectionUtils.add(this.permissions, permission);
577         return this;
578     }
579 
580     @Override
addPermissionGroup(ParsedPermissionGroup permissionGroup)581     public ParsingPackageImpl addPermissionGroup(ParsedPermissionGroup permissionGroup) {
582         this.permissionGroups = CollectionUtils.add(this.permissionGroups, permissionGroup);
583         return this;
584     }
585 
586     @Override
addRequestedPermission(String permission)587     public ParsingPackageImpl addRequestedPermission(String permission) {
588         this.requestedPermissions = CollectionUtils.add(this.requestedPermissions,
589                 TextUtils.safeIntern(permission));
590         return this;
591     }
592 
593     @Override
addImplicitPermission(String permission)594     public ParsingPackageImpl addImplicitPermission(String permission) {
595         this.implicitPermissions = CollectionUtils.add(this.implicitPermissions,
596                 TextUtils.safeIntern(permission));
597         return this;
598     }
599 
600     @Override
addKeySet(String keySetName, PublicKey publicKey)601     public ParsingPackageImpl addKeySet(String keySetName, PublicKey publicKey) {
602         ArraySet<PublicKey> publicKeys = keySetMapping.get(keySetName);
603         if (publicKeys == null) {
604             publicKeys = new ArraySet<>();
605         }
606         publicKeys.add(publicKey);
607         keySetMapping = CollectionUtils.add(this.keySetMapping, keySetName, publicKeys);
608         return this;
609     }
610 
611     @Override
addActivity(ParsedActivity parsedActivity)612     public ParsingPackageImpl addActivity(ParsedActivity parsedActivity) {
613         this.activities = CollectionUtils.add(this.activities, parsedActivity);
614         addMimeGroupsFromComponent(parsedActivity);
615         return this;
616     }
617 
618     @Override
addReceiver(ParsedActivity parsedReceiver)619     public ParsingPackageImpl addReceiver(ParsedActivity parsedReceiver) {
620         this.receivers = CollectionUtils.add(this.receivers, parsedReceiver);
621         addMimeGroupsFromComponent(parsedReceiver);
622         return this;
623     }
624 
625     @Override
addService(ParsedService parsedService)626     public ParsingPackageImpl addService(ParsedService parsedService) {
627         this.services = CollectionUtils.add(this.services, parsedService);
628         addMimeGroupsFromComponent(parsedService);
629         return this;
630     }
631 
632     @Override
addProvider(ParsedProvider parsedProvider)633     public ParsingPackageImpl addProvider(ParsedProvider parsedProvider) {
634         this.providers = CollectionUtils.add(this.providers, parsedProvider);
635         addMimeGroupsFromComponent(parsedProvider);
636         return this;
637     }
638 
639     @Override
addAttribution(ParsedAttribution attribution)640     public ParsingPackageImpl addAttribution(ParsedAttribution attribution) {
641         this.attributions = CollectionUtils.add(this.attributions, attribution);
642         return this;
643     }
644 
645     @Override
addLibraryName(String libraryName)646     public ParsingPackageImpl addLibraryName(String libraryName) {
647         this.libraryNames = CollectionUtils.add(this.libraryNames,
648                 TextUtils.safeIntern(libraryName));
649         return this;
650     }
651 
652     @Override
addUsesOptionalLibrary(String libraryName)653     public ParsingPackageImpl addUsesOptionalLibrary(String libraryName) {
654         this.usesOptionalLibraries = CollectionUtils.add(this.usesOptionalLibraries,
655                 TextUtils.safeIntern(libraryName));
656         return this;
657     }
658 
659     @Override
addUsesLibrary(String libraryName)660     public ParsingPackageImpl addUsesLibrary(String libraryName) {
661         this.usesLibraries = CollectionUtils.add(this.usesLibraries,
662                 TextUtils.safeIntern(libraryName));
663         return this;
664     }
665 
666     @Override
removeUsesOptionalLibrary(String libraryName)667     public ParsingPackageImpl removeUsesOptionalLibrary(String libraryName) {
668         this.usesOptionalLibraries = CollectionUtils.remove(this.usesOptionalLibraries,
669                 libraryName);
670         return this;
671     }
672 
673     @Override
addUsesStaticLibrary(String libraryName)674     public ParsingPackageImpl addUsesStaticLibrary(String libraryName) {
675         this.usesStaticLibraries = CollectionUtils.add(this.usesStaticLibraries,
676                 TextUtils.safeIntern(libraryName));
677         return this;
678     }
679 
680     @Override
addUsesStaticLibraryVersion(long version)681     public ParsingPackageImpl addUsesStaticLibraryVersion(long version) {
682         this.usesStaticLibrariesVersions = ArrayUtils.appendLong(this.usesStaticLibrariesVersions,
683                 version, true);
684         return this;
685     }
686 
687     @Override
addUsesStaticLibraryCertDigests(String[] certSha256Digests)688     public ParsingPackageImpl addUsesStaticLibraryCertDigests(String[] certSha256Digests) {
689         this.usesStaticLibrariesCertDigests = ArrayUtils.appendElement(String[].class,
690                 this.usesStaticLibrariesCertDigests, certSha256Digests, true);
691         return this;
692     }
693 
694     @Override
addPreferredActivityFilter(String className, ParsedIntentInfo intentInfo)695     public ParsingPackageImpl addPreferredActivityFilter(String className,
696             ParsedIntentInfo intentInfo) {
697         this.preferredActivityFilters = CollectionUtils.add(this.preferredActivityFilters,
698                 Pair.create(className, intentInfo));
699         return this;
700     }
701 
702     @Override
addQueriesIntent(Intent intent)703     public ParsingPackageImpl addQueriesIntent(Intent intent) {
704         this.queriesIntents = CollectionUtils.add(this.queriesIntents, intent);
705         return this;
706     }
707 
708     @Override
addQueriesPackage(String packageName)709     public ParsingPackageImpl addQueriesPackage(String packageName) {
710         this.queriesPackages = CollectionUtils.add(this.queriesPackages,
711                 TextUtils.safeIntern(packageName));
712         return this;
713     }
714 
715     @Override
addQueriesProvider(String authority)716     public ParsingPackageImpl addQueriesProvider(String authority) {
717         this.queriesProviders = CollectionUtils.add(this.queriesProviders, authority);
718         return this;
719     }
720 
721     @Override
setSupportsSmallScreens(int supportsSmallScreens)722     public ParsingPackageImpl setSupportsSmallScreens(int supportsSmallScreens) {
723         if (supportsSmallScreens == 1) {
724             return this;
725         }
726 
727         this.supportsSmallScreens = supportsSmallScreens < 0;
728         return this;
729     }
730 
731     @Override
732     public ParsingPackageImpl setSupportsNormalScreens(int supportsNormalScreens) {
733         if (supportsNormalScreens == 1) {
734             return this;
735         }
736 
737         this.supportsNormalScreens = supportsNormalScreens < 0;
738         return this;
739     }
740 
741     @Override
742     public ParsingPackageImpl setSupportsLargeScreens(int supportsLargeScreens) {
743         if (supportsLargeScreens == 1) {
744             return this;
745         }
746 
747         this.supportsLargeScreens = supportsLargeScreens < 0;
748         return this;
749     }
750 
751     @Override
752     public ParsingPackageImpl setSupportsExtraLargeScreens(int supportsExtraLargeScreens) {
753         if (supportsExtraLargeScreens == 1) {
754             return this;
755         }
756 
757         this.supportsExtraLargeScreens = supportsExtraLargeScreens < 0;
758         return this;
759     }
760 
761     @Override
762     public ParsingPackageImpl setResizeable(int resizeable) {
763         if (resizeable == 1) {
764             return this;
765         }
766 
767         this.resizeable = resizeable < 0;
768         return this;
769     }
770 
771     @Override
772     public ParsingPackageImpl setAnyDensity(int anyDensity) {
773         if (anyDensity == 1) {
774             return this;
775         }
776 
777         this.anyDensity = anyDensity < 0;
778         return this;
779     }
780 
781     @Override
782     public ParsingPackageImpl asSplit(String[] splitNames, String[] splitCodePaths,
783             int[] splitRevisionCodes, SparseArray<int[]> splitDependencies) {
784         this.splitNames = splitNames;
785         this.splitCodePaths = splitCodePaths;
786         this.splitRevisionCodes = splitRevisionCodes;
787         this.splitDependencies = splitDependencies;
788 
789         int count = splitNames.length;
790         this.splitFlags = new int[count];
791         this.splitClassLoaderNames = new String[count];
792         return this;
793     }
794 
795     @Override
796     public ParsingPackageImpl setSplitHasCode(int splitIndex, boolean splitHasCode) {
797         this.splitFlags[splitIndex] = splitHasCode
798                 ? this.splitFlags[splitIndex] | ApplicationInfo.FLAG_HAS_CODE
799                 : this.splitFlags[splitIndex] & ~ApplicationInfo.FLAG_HAS_CODE;
800         return this;
801     }
802 
803     @Override
804     public ParsingPackageImpl setSplitClassLoaderName(int splitIndex, String classLoaderName) {
805         this.splitClassLoaderNames[splitIndex] = classLoaderName;
806         return this;
807     }
808 
809     @Override
810     public ParsingPackageImpl setRequiredAccountType(@Nullable String requiredAccountType) {
811         this.requiredAccountType = TextUtils.nullIfEmpty(requiredAccountType);
812         return this;
813     }
814 
815     @Override
816     public ParsingPackageImpl setOverlayTarget(@Nullable String overlayTarget) {
817         this.overlayTarget = TextUtils.safeIntern(overlayTarget);
818         return this;
819     }
820 
821     @Override
822     public ParsingPackageImpl setVolumeUuid(@Nullable String volumeUuid) {
823         this.volumeUuid = TextUtils.safeIntern(volumeUuid);
824         return this;
825     }
826 
827     @Override
828     public ParsingPackageImpl setStaticSharedLibName(String staticSharedLibName) {
829         this.staticSharedLibName = TextUtils.safeIntern(staticSharedLibName);
830         return this;
831     }
832 
833     @Override
834     public ParsingPackageImpl setSharedUserId(String sharedUserId) {
835         this.sharedUserId = TextUtils.safeIntern(sharedUserId);
836         return this;
837     }
838 
839     @NonNull
840     @Override
841     public String getProcessName() {
842         return processName != null ? processName : packageName;
843     }
844 
845     @Override
846     public String toString() {
847         return "Package{"
848                 + Integer.toHexString(System.identityHashCode(this))
849                 + " " + packageName + "}";
850     }
851 
852     @Deprecated
853     @Override
854     public ApplicationInfo toAppInfoWithoutState() {
855         ApplicationInfo appInfo = toAppInfoWithoutStateWithoutFlags();
856         appInfo.flags = PackageInfoWithoutStateUtils.appInfoFlags(this);
857         appInfo.privateFlags = PackageInfoWithoutStateUtils.appInfoPrivateFlags(this);
858         return appInfo;
859     }
860 
861     @Override
862     public ApplicationInfo toAppInfoWithoutStateWithoutFlags() {
863         ApplicationInfo appInfo = new ApplicationInfo();
864 
865         appInfo.appComponentFactory = appComponentFactory;
866         appInfo.backupAgentName = backupAgentName;
867         appInfo.banner = banner;
868         appInfo.category = category;
869         appInfo.classLoaderName = classLoaderName;
870         appInfo.className = className;
871         appInfo.compatibleWidthLimitDp = compatibleWidthLimitDp;
872         appInfo.compileSdkVersion = compileSdkVersion;
873         appInfo.compileSdkVersionCodename = compileSdkVersionCodeName;
874 //        appInfo.credentialProtectedDataDir = credentialProtectedDataDir;
875 //        appInfo.dataDir = dataDir;
876         appInfo.descriptionRes = descriptionRes;
877 //        appInfo.deviceProtectedDataDir = deviceProtectedDataDir;
878         appInfo.enabled = enabled;
879         appInfo.fullBackupContent = fullBackupContent;
880 //        appInfo.hiddenUntilInstalled = hiddenUntilInstalled;
881         appInfo.icon = (PackageParser.sUseRoundIcon && roundIconRes != 0) ? roundIconRes : iconRes;
882         appInfo.iconRes = iconRes;
883         appInfo.roundIconRes = roundIconRes;
884         appInfo.installLocation = installLocation;
885         appInfo.labelRes = labelRes;
886         appInfo.largestWidthLimitDp = largestWidthLimitDp;
887         appInfo.logo = logo;
888         appInfo.manageSpaceActivityName = manageSpaceActivityName;
889         appInfo.maxAspectRatio = maxAspectRatio;
890         appInfo.metaData = metaData;
891         appInfo.minAspectRatio = minAspectRatio;
892         appInfo.minSdkVersion = minSdkVersion;
893         appInfo.name = className;
894         if (appInfo.name != null) {
895             appInfo.name = appInfo.name.trim();
896         }
897 //        appInfo.nativeLibraryDir = nativeLibraryDir;
898 //        appInfo.nativeLibraryRootDir = nativeLibraryRootDir;
899 //        appInfo.nativeLibraryRootRequiresIsa = nativeLibraryRootRequiresIsa;
900         appInfo.networkSecurityConfigRes = networkSecurityConfigRes;
901         appInfo.nonLocalizedLabel = nonLocalizedLabel;
902         if (appInfo.nonLocalizedLabel != null) {
903             appInfo.nonLocalizedLabel = appInfo.nonLocalizedLabel.toString().trim();
904         }
905         appInfo.packageName = packageName;
906         appInfo.permission = permission;
907 //        appInfo.primaryCpuAbi = primaryCpuAbi;
908         appInfo.processName = getProcessName();
909         appInfo.requiresSmallestWidthDp = requiresSmallestWidthDp;
910 //        appInfo.secondaryCpuAbi = secondaryCpuAbi;
911 //        appInfo.secondaryNativeLibraryDir = secondaryNativeLibraryDir;
912 //        appInfo.seInfo = seInfo;
913 //        appInfo.seInfoUser = seInfoUser;
914 //        appInfo.sharedLibraryFiles = usesLibraryFiles.isEmpty()
915 //                ? null : usesLibraryFiles.toArray(new String[0]);
916 //        appInfo.sharedLibraryInfos = usesLibraryInfos.isEmpty() ? null : usesLibraryInfos;
917         appInfo.splitClassLoaderNames = splitClassLoaderNames;
918         appInfo.splitDependencies = splitDependencies;
919         appInfo.splitNames = splitNames;
920         appInfo.storageUuid = StorageManager.convert(volumeUuid);
921         appInfo.targetSandboxVersion = targetSandboxVersion;
922         appInfo.targetSdkVersion = targetSdkVersion;
923         appInfo.taskAffinity = taskAffinity;
924         appInfo.theme = theme;
925 //        appInfo.uid = uid;
926         appInfo.uiOptions = uiOptions;
927         appInfo.volumeUuid = volumeUuid;
928         appInfo.zygotePreloadName = zygotePreloadName;
929         appInfo.crossProfile = isCrossProfile();
930         appInfo.setGwpAsanMode(gwpAsanMode);
931         appInfo.setBaseCodePath(baseCodePath);
932         appInfo.setBaseResourcePath(baseCodePath);
933         appInfo.setCodePath(codePath);
934         appInfo.setResourcePath(codePath);
935         appInfo.setSplitCodePaths(splitCodePaths);
936         appInfo.setSplitResourcePaths(splitCodePaths);
937         appInfo.setVersionCode(PackageInfo.composeLongVersionCode(versionCodeMajor, versionCode));
938 
939         // TODO(b/135203078): Can this be removed? Looks only used in ActivityInfo.
940 //        appInfo.showUserIcon = pkg.getShowUserIcon();
941         // TODO(b/135203078): Unused?
942 //        appInfo.resourceDirs = pkg.getResourceDirs();
943         // TODO(b/135203078): Unused?
944 //        appInfo.enabledSetting = pkg.getEnabledSetting();
945         // TODO(b/135203078): See ParsingPackageImpl#getHiddenApiEnforcementPolicy
946 //        appInfo.mHiddenApiPolicy = pkg.getHiddenApiPolicy();
947 
948         return appInfo;
949     }
950 
951     @Override
952     public int describeContents() {
953         return 0;
954     }
955 
956     @Override
957     public void writeToParcel(Parcel dest, int flags) {
958         sForBoolean.parcel(this.supportsSmallScreens, dest, flags);
959         sForBoolean.parcel(this.supportsNormalScreens, dest, flags);
960         sForBoolean.parcel(this.supportsLargeScreens, dest, flags);
961         sForBoolean.parcel(this.supportsExtraLargeScreens, dest, flags);
962         sForBoolean.parcel(this.resizeable, dest, flags);
963         sForBoolean.parcel(this.anyDensity, dest, flags);
964         dest.writeInt(this.versionCode);
965         dest.writeInt(this.versionCodeMajor);
966         dest.writeInt(this.baseRevisionCode);
967         sForInternedString.parcel(this.versionName, dest, flags);
968         dest.writeInt(this.compileSdkVersion);
969         dest.writeString(this.compileSdkVersionCodeName);
970         sForInternedString.parcel(this.packageName, dest, flags);
971         dest.writeString(this.realPackage);
972         dest.writeString(this.baseCodePath);
973         dest.writeBoolean(this.requiredForAllUsers);
974         dest.writeString(this.restrictedAccountType);
975         dest.writeString(this.requiredAccountType);
976         sForInternedString.parcel(this.overlayTarget, dest, flags);
977         dest.writeString(this.overlayTargetName);
978         dest.writeString(this.overlayCategory);
979         dest.writeInt(this.overlayPriority);
980         dest.writeBoolean(this.overlayIsStatic);
981         sForInternedStringValueMap.parcel(this.overlayables, dest, flags);
982         sForInternedString.parcel(this.staticSharedLibName, dest, flags);
983         dest.writeLong(this.staticSharedLibVersion);
984         sForInternedStringList.parcel(this.libraryNames, dest, flags);
985         sForInternedStringList.parcel(this.usesLibraries, dest, flags);
986         sForInternedStringList.parcel(this.usesOptionalLibraries, dest, flags);
987         sForInternedStringList.parcel(this.usesStaticLibraries, dest, flags);
988         dest.writeLongArray(this.usesStaticLibrariesVersions);
989 
990         if (this.usesStaticLibrariesCertDigests == null) {
991             dest.writeInt(-1);
992         } else {
993             dest.writeInt(this.usesStaticLibrariesCertDigests.length);
994             for (int index = 0; index < this.usesStaticLibrariesCertDigests.length; index++) {
995                 dest.writeStringArray(this.usesStaticLibrariesCertDigests[index]);
996             }
997         }
998 
999         sForInternedString.parcel(this.sharedUserId, dest, flags);
1000         dest.writeInt(this.sharedUserLabel);
1001         dest.writeTypedList(this.configPreferences);
1002         dest.writeTypedList(this.reqFeatures);
1003         dest.writeTypedList(this.featureGroups);
1004         dest.writeByteArray(this.restrictUpdateHash);
1005         dest.writeStringList(this.originalPackages);
1006         sForInternedStringList.parcel(this.adoptPermissions, dest, flags);
1007         sForInternedStringList.parcel(this.requestedPermissions, dest, flags);
1008         sForInternedStringList.parcel(this.implicitPermissions, dest, flags);
1009         sForStringSet.parcel(this.upgradeKeySets, dest, flags);
1010         dest.writeMap(this.keySetMapping);
1011         sForInternedStringList.parcel(this.protectedBroadcasts, dest, flags);
1012         dest.writeTypedList(this.activities);
1013         dest.writeTypedList(this.receivers);
1014         dest.writeTypedList(this.services);
1015         dest.writeTypedList(this.providers);
1016         dest.writeTypedList(this.attributions);
1017         dest.writeTypedList(this.permissions);
1018         dest.writeTypedList(this.permissionGroups);
1019         dest.writeTypedList(this.instrumentations);
1020         sForIntentInfoPairs.parcel(this.preferredActivityFilters, dest, flags);
1021         dest.writeMap(this.processes);
1022         dest.writeBundle(this.metaData);
1023         sForInternedString.parcel(this.volumeUuid, dest, flags);
1024         dest.writeParcelable(this.signingDetails, flags);
1025         dest.writeString(this.codePath);
1026         dest.writeBoolean(this.use32BitAbi);
1027         dest.writeBoolean(this.visibleToInstantApps);
1028         dest.writeBoolean(this.forceQueryable);
1029         dest.writeParcelableList(this.queriesIntents, flags);
1030         sForInternedStringList.parcel(this.queriesPackages, dest, flags);
1031         sForInternedStringSet.parcel(this.queriesProviders, dest, flags);
1032         dest.writeString(this.appComponentFactory);
1033         dest.writeString(this.backupAgentName);
1034         dest.writeInt(this.banner);
1035         dest.writeInt(this.category);
1036         dest.writeString(this.classLoaderName);
1037         dest.writeString(this.className);
1038         dest.writeInt(this.compatibleWidthLimitDp);
1039         dest.writeInt(this.descriptionRes);
1040         dest.writeBoolean(this.enabled);
1041         dest.writeBoolean(this.crossProfile);
1042         dest.writeInt(this.fullBackupContent);
1043         dest.writeInt(this.iconRes);
1044         dest.writeInt(this.installLocation);
1045         dest.writeInt(this.labelRes);
1046         dest.writeInt(this.largestWidthLimitDp);
1047         dest.writeInt(this.logo);
1048         dest.writeString(this.manageSpaceActivityName);
1049         dest.writeFloat(this.maxAspectRatio);
1050         dest.writeFloat(this.minAspectRatio);
1051         dest.writeInt(this.minSdkVersion);
1052         dest.writeInt(this.networkSecurityConfigRes);
1053         dest.writeCharSequence(this.nonLocalizedLabel);
1054         dest.writeString(this.permission);
1055         dest.writeString(this.processName);
1056         dest.writeInt(this.requiresSmallestWidthDp);
1057         dest.writeInt(this.roundIconRes);
1058         dest.writeInt(this.targetSandboxVersion);
1059         dest.writeInt(this.targetSdkVersion);
1060         dest.writeString(this.taskAffinity);
1061         dest.writeInt(this.theme);
1062         dest.writeInt(this.uiOptions);
1063         dest.writeString(this.zygotePreloadName);
1064         dest.writeStringArray(this.splitClassLoaderNames);
1065         dest.writeStringArray(this.splitCodePaths);
1066         dest.writeSparseArray(this.splitDependencies);
1067         dest.writeIntArray(this.splitFlags);
1068         dest.writeStringArray(this.splitNames);
1069         dest.writeIntArray(this.splitRevisionCodes);
1070 
1071         dest.writeBoolean(this.externalStorage);
1072         dest.writeBoolean(this.baseHardwareAccelerated);
1073         dest.writeBoolean(this.allowBackup);
1074         dest.writeBoolean(this.killAfterRestore);
1075         dest.writeBoolean(this.restoreAnyVersion);
1076         dest.writeBoolean(this.fullBackupOnly);
1077         dest.writeBoolean(this.persistent);
1078         dest.writeBoolean(this.debuggable);
1079         dest.writeBoolean(this.vmSafeMode);
1080         dest.writeBoolean(this.hasCode);
1081         dest.writeBoolean(this.allowTaskReparenting);
1082         dest.writeBoolean(this.allowClearUserData);
1083         dest.writeBoolean(this.largeHeap);
1084         dest.writeBoolean(this.usesCleartextTraffic);
1085         dest.writeBoolean(this.supportsRtl);
1086         dest.writeBoolean(this.testOnly);
1087         dest.writeBoolean(this.multiArch);
1088         dest.writeBoolean(this.extractNativeLibs);
1089         dest.writeBoolean(this.game);
1090 
1091         sForBoolean.parcel(this.resizeableActivity, dest, flags);
1092 
1093         dest.writeBoolean(this.staticSharedLibrary);
1094         dest.writeBoolean(this.overlay);
1095         dest.writeBoolean(this.isolatedSplitLoading);
1096         dest.writeBoolean(this.hasDomainUrls);
1097         dest.writeBoolean(this.profileableByShell);
1098         dest.writeBoolean(this.backupInForeground);
1099         dest.writeBoolean(this.useEmbeddedDex);
1100         dest.writeBoolean(this.defaultToDeviceProtectedStorage);
1101         dest.writeBoolean(this.directBootAware);
1102         dest.writeBoolean(this.partiallyDirectBootAware);
1103         dest.writeBoolean(this.resizeableActivityViaSdkVersion);
1104         dest.writeBoolean(this.allowClearUserDataOnFailedRestore);
1105         dest.writeBoolean(this.allowAudioPlaybackCapture);
1106         dest.writeBoolean(this.requestLegacyExternalStorage);
1107         dest.writeBoolean(this.usesNonSdkApi);
1108         dest.writeBoolean(this.hasFragileUserData);
1109         dest.writeBoolean(this.cantSaveState);
1110         dest.writeBoolean(this.allowNativeHeapPointerTagging);
1111         dest.writeInt(this.autoRevokePermissions);
1112         dest.writeBoolean(this.preserveLegacyExternalStorage);
1113         dest.writeArraySet(this.mimeGroups);
1114         dest.writeInt(this.gwpAsanMode);
1115         dest.writeSparseIntArray(this.minExtensionVersions);
1116     }
1117 
1118     public ParsingPackageImpl(Parcel in) {
1119         // We use the boot classloader for all classes that we load.
1120         final ClassLoader boot = Object.class.getClassLoader();
1121         this.supportsSmallScreens = sForBoolean.unparcel(in);
1122         this.supportsNormalScreens = sForBoolean.unparcel(in);
1123         this.supportsLargeScreens = sForBoolean.unparcel(in);
1124         this.supportsExtraLargeScreens = sForBoolean.unparcel(in);
1125         this.resizeable = sForBoolean.unparcel(in);
1126         this.anyDensity = sForBoolean.unparcel(in);
1127         this.versionCode = in.readInt();
1128         this.versionCodeMajor = in.readInt();
1129         this.baseRevisionCode = in.readInt();
1130         this.versionName = sForInternedString.unparcel(in);
1131         this.compileSdkVersion = in.readInt();
1132         this.compileSdkVersionCodeName = in.readString();
1133         this.packageName = sForInternedString.unparcel(in);
1134         this.realPackage = in.readString();
1135         this.baseCodePath = in.readString();
1136         this.requiredForAllUsers = in.readBoolean();
1137         this.restrictedAccountType = in.readString();
1138         this.requiredAccountType = in.readString();
1139         this.overlayTarget = sForInternedString.unparcel(in);
1140         this.overlayTargetName = in.readString();
1141         this.overlayCategory = in.readString();
1142         this.overlayPriority = in.readInt();
1143         this.overlayIsStatic = in.readBoolean();
1144         this.overlayables = sForInternedStringValueMap.unparcel(in);
1145         this.staticSharedLibName = sForInternedString.unparcel(in);
1146         this.staticSharedLibVersion = in.readLong();
1147         this.libraryNames = sForInternedStringList.unparcel(in);
1148         this.usesLibraries = sForInternedStringList.unparcel(in);
1149         this.usesOptionalLibraries = sForInternedStringList.unparcel(in);
1150         this.usesStaticLibraries = sForInternedStringList.unparcel(in);
1151         this.usesStaticLibrariesVersions = in.createLongArray();
1152 
1153         int digestsSize = in.readInt();
1154         if (digestsSize >= 0) {
1155             this.usesStaticLibrariesCertDigests = new String[digestsSize][];
1156             for (int index = 0; index < digestsSize; index++) {
1157                 this.usesStaticLibrariesCertDigests[index] = sForInternedStringArray.unparcel(in);
1158             }
1159         }
1160 
1161         this.sharedUserId = sForInternedString.unparcel(in);
1162         this.sharedUserLabel = in.readInt();
1163         this.configPreferences = in.createTypedArrayList(ConfigurationInfo.CREATOR);
1164         this.reqFeatures = in.createTypedArrayList(FeatureInfo.CREATOR);
1165         this.featureGroups = in.createTypedArrayList(FeatureGroupInfo.CREATOR);
1166         this.restrictUpdateHash = in.createByteArray();
1167         this.originalPackages = in.createStringArrayList();
1168         this.adoptPermissions = sForInternedStringList.unparcel(in);
1169         this.requestedPermissions = sForInternedStringList.unparcel(in);
1170         this.implicitPermissions = sForInternedStringList.unparcel(in);
1171         this.upgradeKeySets = sForStringSet.unparcel(in);
1172         this.keySetMapping = in.readHashMap(boot);
1173         this.protectedBroadcasts = sForInternedStringList.unparcel(in);
1174 
1175         this.activities = in.createTypedArrayList(ParsedActivity.CREATOR);
1176         this.receivers = in.createTypedArrayList(ParsedActivity.CREATOR);
1177         this.services = in.createTypedArrayList(ParsedService.CREATOR);
1178         this.providers = in.createTypedArrayList(ParsedProvider.CREATOR);
1179         this.attributions = in.createTypedArrayList(ParsedAttribution.CREATOR);
1180         this.permissions = in.createTypedArrayList(ParsedPermission.CREATOR);
1181         this.permissionGroups = in.createTypedArrayList(ParsedPermissionGroup.CREATOR);
1182         this.instrumentations = in.createTypedArrayList(ParsedInstrumentation.CREATOR);
1183         this.preferredActivityFilters = sForIntentInfoPairs.unparcel(in);
1184         this.processes = in.readHashMap(boot);
1185         this.metaData = in.readBundle(boot);
1186         this.volumeUuid = sForInternedString.unparcel(in);
1187         this.signingDetails = in.readParcelable(boot);
1188         this.codePath = in.readString();
1189         this.use32BitAbi = in.readBoolean();
1190         this.visibleToInstantApps = in.readBoolean();
1191         this.forceQueryable = in.readBoolean();
1192         this.queriesIntents = in.createTypedArrayList(Intent.CREATOR);
1193         this.queriesPackages = sForInternedStringList.unparcel(in);
1194         this.queriesProviders = sForInternedStringSet.unparcel(in);
1195         this.appComponentFactory = in.readString();
1196         this.backupAgentName = in.readString();
1197         this.banner = in.readInt();
1198         this.category = in.readInt();
1199         this.classLoaderName = in.readString();
1200         this.className = in.readString();
1201         this.compatibleWidthLimitDp = in.readInt();
1202         this.descriptionRes = in.readInt();
1203         this.enabled = in.readBoolean();
1204         this.crossProfile = in.readBoolean();
1205         this.fullBackupContent = in.readInt();
1206         this.iconRes = in.readInt();
1207         this.installLocation = in.readInt();
1208         this.labelRes = in.readInt();
1209         this.largestWidthLimitDp = in.readInt();
1210         this.logo = in.readInt();
1211         this.manageSpaceActivityName = in.readString();
1212         this.maxAspectRatio = in.readFloat();
1213         this.minAspectRatio = in.readFloat();
1214         this.minSdkVersion = in.readInt();
1215         this.networkSecurityConfigRes = in.readInt();
1216         this.nonLocalizedLabel = in.readCharSequence();
1217         this.permission = in.readString();
1218         this.processName = in.readString();
1219         this.requiresSmallestWidthDp = in.readInt();
1220         this.roundIconRes = in.readInt();
1221         this.targetSandboxVersion = in.readInt();
1222         this.targetSdkVersion = in.readInt();
1223         this.taskAffinity = in.readString();
1224         this.theme = in.readInt();
1225         this.uiOptions = in.readInt();
1226         this.zygotePreloadName = in.readString();
1227         this.splitClassLoaderNames = in.createStringArray();
1228         this.splitCodePaths = in.createStringArray();
1229         this.splitDependencies = in.readSparseArray(boot);
1230         this.splitFlags = in.createIntArray();
1231         this.splitNames = in.createStringArray();
1232         this.splitRevisionCodes = in.createIntArray();
1233         this.externalStorage = in.readBoolean();
1234         this.baseHardwareAccelerated = in.readBoolean();
1235         this.allowBackup = in.readBoolean();
1236         this.killAfterRestore = in.readBoolean();
1237         this.restoreAnyVersion = in.readBoolean();
1238         this.fullBackupOnly = in.readBoolean();
1239         this.persistent = in.readBoolean();
1240         this.debuggable = in.readBoolean();
1241         this.vmSafeMode = in.readBoolean();
1242         this.hasCode = in.readBoolean();
1243         this.allowTaskReparenting = in.readBoolean();
1244         this.allowClearUserData = in.readBoolean();
1245         this.largeHeap = in.readBoolean();
1246         this.usesCleartextTraffic = in.readBoolean();
1247         this.supportsRtl = in.readBoolean();
1248         this.testOnly = in.readBoolean();
1249         this.multiArch = in.readBoolean();
1250         this.extractNativeLibs = in.readBoolean();
1251         this.game = in.readBoolean();
1252         this.resizeableActivity = sForBoolean.unparcel(in);
1253 
1254         this.staticSharedLibrary = in.readBoolean();
1255         this.overlay = in.readBoolean();
1256         this.isolatedSplitLoading = in.readBoolean();
1257         this.hasDomainUrls = in.readBoolean();
1258         this.profileableByShell = in.readBoolean();
1259         this.backupInForeground = in.readBoolean();
1260         this.useEmbeddedDex = in.readBoolean();
1261         this.defaultToDeviceProtectedStorage = in.readBoolean();
1262         this.directBootAware = in.readBoolean();
1263         this.partiallyDirectBootAware = in.readBoolean();
1264         this.resizeableActivityViaSdkVersion = in.readBoolean();
1265         this.allowClearUserDataOnFailedRestore = in.readBoolean();
1266         this.allowAudioPlaybackCapture = in.readBoolean();
1267         this.requestLegacyExternalStorage = in.readBoolean();
1268         this.usesNonSdkApi = in.readBoolean();
1269         this.hasFragileUserData = in.readBoolean();
1270         this.cantSaveState = in.readBoolean();
1271         this.allowNativeHeapPointerTagging = in.readBoolean();
1272         this.autoRevokePermissions = in.readInt();
1273         this.preserveLegacyExternalStorage = in.readBoolean();
1274         this.mimeGroups = (ArraySet<String>) in.readArraySet(boot);
1275         this.gwpAsanMode = in.readInt();
1276         this.minExtensionVersions = in.readSparseIntArray();
1277     }
1278 
1279     public static final Parcelable.Creator<ParsingPackageImpl> CREATOR =
1280             new Parcelable.Creator<ParsingPackageImpl>() {
1281                 @Override
1282                 public ParsingPackageImpl createFromParcel(Parcel source) {
1283                     return new ParsingPackageImpl(source);
1284                 }
1285 
1286                 @Override
1287                 public ParsingPackageImpl[] newArray(int size) {
1288                     return new ParsingPackageImpl[size];
1289                 }
1290             };
1291 
1292     @Override
1293     public int getVersionCode() {
1294         return versionCode;
1295     }
1296 
1297     @Override
1298     public int getVersionCodeMajor() {
1299         return versionCodeMajor;
1300     }
1301 
1302     @Override
1303     public int getBaseRevisionCode() {
1304         return baseRevisionCode;
1305     }
1306 
1307     @Nullable
1308     @Override
1309     public String getVersionName() {
1310         return versionName;
1311     }
1312 
1313     @Override
1314     public int getCompileSdkVersion() {
1315         return compileSdkVersion;
1316     }
1317 
1318     @Nullable
1319     @Override
1320     public String getCompileSdkVersionCodeName() {
1321         return compileSdkVersionCodeName;
1322     }
1323 
1324     @NonNull
1325     @Override
1326     public String getPackageName() {
1327         return packageName;
1328     }
1329 
1330     @Nullable
1331     @Override
1332     public String getRealPackage() {
1333         return realPackage;
1334     }
1335 
1336     @NonNull
1337     @Override
1338     public String getBaseCodePath() {
1339         return baseCodePath;
1340     }
1341 
1342     @Override
1343     public boolean isRequiredForAllUsers() {
1344         return requiredForAllUsers;
1345     }
1346 
1347     @Nullable
1348     @Override
1349     public String getRestrictedAccountType() {
1350         return restrictedAccountType;
1351     }
1352 
1353     @Nullable
1354     @Override
1355     public String getRequiredAccountType() {
1356         return requiredAccountType;
1357     }
1358 
1359     @Nullable
1360     @Override
1361     public String getOverlayTarget() {
1362         return overlayTarget;
1363     }
1364 
1365     @Nullable
1366     @Override
1367     public String getOverlayTargetName() {
1368         return overlayTargetName;
1369     }
1370 
1371     @Nullable
1372     @Override
1373     public String getOverlayCategory() {
1374         return overlayCategory;
1375     }
1376 
1377     @Override
1378     public int getOverlayPriority() {
1379         return overlayPriority;
1380     }
1381 
1382     @Override
1383     public boolean isOverlayIsStatic() {
1384         return overlayIsStatic;
1385     }
1386 
1387     @NonNull
1388     @Override
1389     public Map<String,String> getOverlayables() {
1390         return overlayables;
1391     }
1392 
1393     @Nullable
1394     @Override
1395     public String getStaticSharedLibName() {
1396         return staticSharedLibName;
1397     }
1398 
1399     @Override
1400     public long getStaticSharedLibVersion() {
1401         return staticSharedLibVersion;
1402     }
1403 
1404     @NonNull
1405     @Override
1406     public List<String> getLibraryNames() {
1407         return libraryNames;
1408     }
1409 
1410     @NonNull
1411     @Override
1412     public List<String> getUsesLibraries() {
1413         return usesLibraries;
1414     }
1415 
1416     @NonNull
1417     @Override
1418     public List<String> getUsesOptionalLibraries() {
1419         return usesOptionalLibraries;
1420     }
1421 
1422     @NonNull
1423     @Override
1424     public List<String> getUsesStaticLibraries() {
1425         return usesStaticLibraries;
1426     }
1427 
1428     @Nullable
1429     @Override
1430     public long[] getUsesStaticLibrariesVersions() {
1431         return usesStaticLibrariesVersions;
1432     }
1433 
1434     @Nullable
1435     @Override
1436     public String[][] getUsesStaticLibrariesCertDigests() {
1437         return usesStaticLibrariesCertDigests;
1438     }
1439 
1440     @Nullable
1441     @Override
1442     public String getSharedUserId() {
1443         return sharedUserId;
1444     }
1445 
1446     @Override
1447     public int getSharedUserLabel() {
1448         return sharedUserLabel;
1449     }
1450 
1451     @NonNull
1452     @Override
1453     public List<ConfigurationInfo> getConfigPreferences() {
1454         return configPreferences;
1455     }
1456 
1457     @NonNull
1458     @Override
1459     public List<FeatureInfo> getReqFeatures() {
1460         return reqFeatures;
1461     }
1462 
1463     @NonNull
1464     @Override
1465     public List<FeatureGroupInfo> getFeatureGroups() {
1466         return featureGroups;
1467     }
1468 
1469     @Nullable
1470     @Override
1471     public byte[] getRestrictUpdateHash() {
1472         return restrictUpdateHash;
1473     }
1474 
1475     @NonNull
1476     @Override
1477     public List<String> getOriginalPackages() {
1478         return originalPackages;
1479     }
1480 
1481     @NonNull
1482     @Override
1483     public List<String> getAdoptPermissions() {
1484         return adoptPermissions;
1485     }
1486 
1487     @NonNull
1488     @Override
1489     public List<String> getRequestedPermissions() {
1490         return requestedPermissions;
1491     }
1492 
1493     @NonNull
1494     @Override
1495     public List<String> getImplicitPermissions() {
1496         return implicitPermissions;
1497     }
1498 
1499     @NonNull
1500     @Override
1501     public Set<String> getUpgradeKeySets() {
1502         return upgradeKeySets;
1503     }
1504 
1505     @NonNull
1506     @Override
1507     public Map<String,ArraySet<PublicKey>> getKeySetMapping() {
1508         return keySetMapping;
1509     }
1510 
1511     @NonNull
1512     @Override
1513     public List<String> getProtectedBroadcasts() {
1514         return protectedBroadcasts;
1515     }
1516 
1517     @NonNull
1518     @Override
1519     public List<ParsedActivity> getActivities() {
1520         return activities;
1521     }
1522 
1523     @NonNull
1524     @Override
1525     public List<ParsedActivity> getReceivers() {
1526         return receivers;
1527     }
1528 
1529     @NonNull
1530     @Override
1531     public List<ParsedService> getServices() {
1532         return services;
1533     }
1534 
1535     @NonNull
1536     @Override
1537     public List<ParsedProvider> getProviders() {
1538         return providers;
1539     }
1540 
1541     @NonNull
1542     @Override
1543     public List<ParsedAttribution> getAttributions() {
1544         return attributions;
1545     }
1546 
1547     @NonNull
1548     @Override
1549     public List<ParsedPermission> getPermissions() {
1550         return permissions;
1551     }
1552 
1553     @NonNull
1554     @Override
1555     public List<ParsedPermissionGroup> getPermissionGroups() {
1556         return permissionGroups;
1557     }
1558 
1559     @NonNull
1560     @Override
1561     public List<ParsedInstrumentation> getInstrumentations() {
1562         return instrumentations;
1563     }
1564 
1565     @NonNull
1566     @Override
1567     public List<Pair<String,ParsedIntentInfo>> getPreferredActivityFilters() {
1568         return preferredActivityFilters;
1569     }
1570 
1571     @NonNull
1572     @Override
1573     public Map<String,ParsedProcess> getProcesses() {
1574         return processes;
1575     }
1576 
1577     @Nullable
1578     @Override
1579     public Bundle getMetaData() {
1580         return metaData;
1581     }
1582 
1583     private void addMimeGroupsFromComponent(ParsedComponent component) {
1584         for (int i = component.getIntents().size() - 1; i >= 0; i--) {
1585             IntentFilter filter = component.getIntents().get(i);
1586             for (int groupIndex = filter.countMimeGroups() - 1; groupIndex >= 0; groupIndex--) {
1587                 mimeGroups = ArrayUtils.add(mimeGroups, filter.getMimeGroup(groupIndex));
1588             }
1589         }
1590     }
1591 
1592     @Override
1593     @Nullable
1594     public Set<String> getMimeGroups() {
1595         return mimeGroups;
1596     }
1597 
1598     @Nullable
1599     @Override
1600     public String getVolumeUuid() {
1601         return volumeUuid;
1602     }
1603 
1604     @Nullable
1605     @Override
1606     public PackageParser.SigningDetails getSigningDetails() {
1607         return signingDetails;
1608     }
1609 
1610     @NonNull
1611     @Override
1612     public String getCodePath() {
1613         return codePath;
1614     }
1615 
1616     @Override
1617     public boolean isUse32BitAbi() {
1618         return use32BitAbi;
1619     }
1620 
1621     @Override
1622     public boolean isVisibleToInstantApps() {
1623         return visibleToInstantApps;
1624     }
1625 
1626     @Override
1627     public boolean isForceQueryable() {
1628         return forceQueryable;
1629     }
1630 
1631     @NonNull
1632     @Override
1633     public List<Intent> getQueriesIntents() {
1634         return queriesIntents;
1635     }
1636 
1637     @NonNull
1638     @Override
1639     public List<String> getQueriesPackages() {
1640         return queriesPackages;
1641     }
1642 
1643     @NonNull
1644     @Override
1645     public Set<String> getQueriesProviders() {
1646         return queriesProviders;
1647     }
1648 
1649     @Nullable
1650     @Override
1651     public String[] getSplitClassLoaderNames() {
1652         return splitClassLoaderNames;
1653     }
1654 
1655     @Nullable
1656     @Override
1657     public String[] getSplitCodePaths() {
1658         return splitCodePaths;
1659     }
1660 
1661     @Nullable
1662     @Override
1663     public SparseArray<int[]> getSplitDependencies() {
1664         return splitDependencies;
1665     }
1666 
1667     @Nullable
1668     @Override
1669     public int[] getSplitFlags() {
1670         return splitFlags;
1671     }
1672 
1673     @Nullable
1674     @Override
1675     public String[] getSplitNames() {
1676         return splitNames;
1677     }
1678 
1679     @Nullable
1680     @Override
1681     public int[] getSplitRevisionCodes() {
1682         return splitRevisionCodes;
1683     }
1684 
1685     @Nullable
1686     @Override
1687     public String getAppComponentFactory() {
1688         return appComponentFactory;
1689     }
1690 
1691     @Nullable
1692     @Override
1693     public String getBackupAgentName() {
1694         return backupAgentName;
1695     }
1696 
1697     @Override
1698     public int getBanner() {
1699         return banner;
1700     }
1701 
1702     @Override
1703     public int getCategory() {
1704         return category;
1705     }
1706 
1707     @Nullable
1708     @Override
1709     public String getClassLoaderName() {
1710         return classLoaderName;
1711     }
1712 
1713     @Nullable
1714     @Override
1715     public String getClassName() {
1716         return className;
1717     }
1718 
1719     @Override
1720     public int getCompatibleWidthLimitDp() {
1721         return compatibleWidthLimitDp;
1722     }
1723 
1724     @Override
1725     public int getDescriptionRes() {
1726         return descriptionRes;
1727     }
1728 
1729     @Override
1730     public boolean isEnabled() {
1731         return enabled;
1732     }
1733 
1734     @Override
1735     public boolean isCrossProfile() {
1736         return crossProfile;
1737     }
1738 
1739     @Override
1740     public int getFullBackupContent() {
1741         return fullBackupContent;
1742     }
1743 
1744     @Override
1745     public int getIconRes() {
1746         return iconRes;
1747     }
1748 
1749     @Override
1750     public int getInstallLocation() {
1751         return installLocation;
1752     }
1753 
1754     @Override
1755     public int getLabelRes() {
1756         return labelRes;
1757     }
1758 
1759     @Override
1760     public int getLargestWidthLimitDp() {
1761         return largestWidthLimitDp;
1762     }
1763 
1764     @Override
1765     public int getLogo() {
1766         return logo;
1767     }
1768 
1769     @Nullable
1770     @Override
1771     public String getManageSpaceActivityName() {
1772         return manageSpaceActivityName;
1773     }
1774 
1775     @Override
1776     public float getMaxAspectRatio() {
1777         return maxAspectRatio;
1778     }
1779 
1780     @Override
1781     public float getMinAspectRatio() {
1782         return minAspectRatio;
1783     }
1784 
1785     @Nullable
1786     @Override
1787     public SparseIntArray getMinExtensionVersions() {
1788         return minExtensionVersions;
1789     }
1790 
1791     @Override
1792     public int getMinSdkVersion() {
1793         return minSdkVersion;
1794     }
1795 
1796     @Override
1797     public int getNetworkSecurityConfigRes() {
1798         return networkSecurityConfigRes;
1799     }
1800 
1801     @Nullable
1802     @Override
1803     public CharSequence getNonLocalizedLabel() {
1804         return nonLocalizedLabel;
1805     }
1806 
1807     @Nullable
1808     @Override
1809     public String getPermission() {
1810         return permission;
1811     }
1812 
1813     @Override
1814     public int getRequiresSmallestWidthDp() {
1815         return requiresSmallestWidthDp;
1816     }
1817 
1818     @Override
1819     public int getRoundIconRes() {
1820         return roundIconRes;
1821     }
1822 
1823     @Override
1824     public int getTargetSandboxVersion() {
1825         return targetSandboxVersion;
1826     }
1827 
1828     @Override
1829     public int getTargetSdkVersion() {
1830         return targetSdkVersion;
1831     }
1832 
1833     @Nullable
1834     @Override
1835     public String getTaskAffinity() {
1836         return taskAffinity;
1837     }
1838 
1839     @Override
1840     public int getTheme() {
1841         return theme;
1842     }
1843 
1844     @Override
1845     public int getUiOptions() {
1846         return uiOptions;
1847     }
1848 
1849     @Nullable
1850     @Override
1851     public String getZygotePreloadName() {
1852         return zygotePreloadName;
1853     }
1854 
1855     @Override
1856     public boolean isExternalStorage() {
1857         return externalStorage;
1858     }
1859 
1860     @Override
1861     public boolean isBaseHardwareAccelerated() {
1862         return baseHardwareAccelerated;
1863     }
1864 
1865     @Override
1866     public boolean isAllowBackup() {
1867         return allowBackup;
1868     }
1869 
1870     @Override
1871     public boolean isKillAfterRestore() {
1872         return killAfterRestore;
1873     }
1874 
1875     @Override
1876     public boolean isRestoreAnyVersion() {
1877         return restoreAnyVersion;
1878     }
1879 
1880     @Override
1881     public boolean isFullBackupOnly() {
1882         return fullBackupOnly;
1883     }
1884 
1885     @Override
1886     public boolean isPersistent() {
1887         return persistent;
1888     }
1889 
1890     @Override
1891     public boolean isDebuggable() {
1892         return debuggable;
1893     }
1894 
1895     @Override
1896     public boolean isVmSafeMode() {
1897         return vmSafeMode;
1898     }
1899 
1900     @Override
1901     public boolean isHasCode() {
1902         return hasCode;
1903     }
1904 
1905     @Override
1906     public boolean isAllowTaskReparenting() {
1907         return allowTaskReparenting;
1908     }
1909 
1910     @Override
1911     public boolean isAllowClearUserData() {
1912         return allowClearUserData;
1913     }
1914 
1915     @Override
1916     public boolean isLargeHeap() {
1917         return largeHeap;
1918     }
1919 
1920     @Override
1921     public boolean isUsesCleartextTraffic() {
1922         return usesCleartextTraffic;
1923     }
1924 
1925     @Override
1926     public boolean isSupportsRtl() {
1927         return supportsRtl;
1928     }
1929 
1930     @Override
1931     public boolean isTestOnly() {
1932         return testOnly;
1933     }
1934 
1935     @Override
1936     public boolean isMultiArch() {
1937         return multiArch;
1938     }
1939 
1940     @Override
1941     public boolean isExtractNativeLibs() {
1942         return extractNativeLibs;
1943     }
1944 
1945     @Override
1946     public boolean isGame() {
1947         return game;
1948     }
1949 
1950     /**
1951      * @see ParsingPackageRead#getResizeableActivity()
1952      */
1953     @Nullable
1954     @Override
1955     public Boolean getResizeableActivity() {
1956         return resizeableActivity;
1957     }
1958 
1959     @Override
1960     public boolean isStaticSharedLibrary() {
1961         return staticSharedLibrary;
1962     }
1963 
1964     @Override
1965     public boolean isOverlay() {
1966         return overlay;
1967     }
1968 
1969     @Override
1970     public boolean isIsolatedSplitLoading() {
1971         return isolatedSplitLoading;
1972     }
1973 
1974     @Override
1975     public boolean isHasDomainUrls() {
1976         return hasDomainUrls;
1977     }
1978 
1979     @Override
1980     public boolean isProfileableByShell() {
1981         return profileableByShell;
1982     }
1983 
1984     @Override
1985     public boolean isBackupInForeground() {
1986         return backupInForeground;
1987     }
1988 
1989     @Override
1990     public boolean isUseEmbeddedDex() {
1991         return useEmbeddedDex;
1992     }
1993 
1994     @Override
1995     public boolean isDefaultToDeviceProtectedStorage() {
1996         return defaultToDeviceProtectedStorage;
1997     }
1998 
1999     @Override
2000     public boolean isDirectBootAware() {
2001         return directBootAware;
2002     }
2003 
2004     @Override
2005     public int getGwpAsanMode() {
2006         return gwpAsanMode;
2007     }
2008 
2009     @Override
2010     public boolean isPartiallyDirectBootAware() {
2011         return partiallyDirectBootAware;
2012     }
2013 
2014     @Override
2015     public boolean isResizeableActivityViaSdkVersion() {
2016         return resizeableActivityViaSdkVersion;
2017     }
2018 
2019     @Override
2020     public boolean isAllowClearUserDataOnFailedRestore() {
2021         return allowClearUserDataOnFailedRestore;
2022     }
2023 
2024     @Override
2025     public boolean isAllowAudioPlaybackCapture() {
2026         return allowAudioPlaybackCapture;
2027     }
2028 
2029     @Override
2030     public boolean isRequestLegacyExternalStorage() {
2031         return requestLegacyExternalStorage;
2032     }
2033 
2034     @Override
2035     public boolean isUsesNonSdkApi() {
2036         return usesNonSdkApi;
2037     }
2038 
2039     @Override
2040     public boolean isHasFragileUserData() {
2041         return hasFragileUserData;
2042     }
2043 
2044     @Override
2045     public boolean isCantSaveState() {
2046         return cantSaveState;
2047     }
2048 
2049     @Override
2050     public boolean isAllowNativeHeapPointerTagging() {
2051         return allowNativeHeapPointerTagging;
2052     }
2053 
2054     @Override
2055     public int getAutoRevokePermissions() {
2056         return autoRevokePermissions;
2057     }
2058 
2059     @Override
2060     public boolean hasPreserveLegacyExternalStorage() {
2061         return preserveLegacyExternalStorage;
2062     }
2063 
2064     @Override
2065     public ParsingPackageImpl setBaseRevisionCode(int value) {
2066         baseRevisionCode = value;
2067         return this;
2068     }
2069 
2070     @Override
2071     public ParsingPackageImpl setCompileSdkVersion(int value) {
2072         compileSdkVersion = value;
2073         return this;
2074     }
2075 
2076     @Override
2077     public ParsingPackageImpl setRequiredForAllUsers(boolean value) {
2078         requiredForAllUsers = value;
2079         return this;
2080     }
2081 
2082     @Override
2083     public ParsingPackageImpl setOverlayPriority(int value) {
2084         overlayPriority = value;
2085         return this;
2086     }
2087 
2088     @Override
2089     public ParsingPackageImpl setOverlayIsStatic(boolean value) {
2090         overlayIsStatic = value;
2091         return this;
2092     }
2093 
2094     @Override
2095     public ParsingPackageImpl setStaticSharedLibVersion(long value) {
2096         staticSharedLibVersion = value;
2097         return this;
2098     }
2099 
2100     @Override
2101     public ParsingPackageImpl setSharedUserLabel(int value) {
2102         sharedUserLabel = value;
2103         return this;
2104     }
2105 
2106     @Override
2107     public ParsingPackageImpl setRestrictUpdateHash(@Nullable byte... value) {
2108         restrictUpdateHash = value;
2109         return this;
2110     }
2111 
2112     @Override
2113     public ParsingPackageImpl setUpgradeKeySets(@NonNull Set<String> value) {
2114         upgradeKeySets = value;
2115         return this;
2116     }
2117 
2118     @Override
2119     public ParsingPackageImpl setProcesses(@NonNull Map<String,ParsedProcess> value) {
2120         processes = value;
2121         return this;
2122     }
2123 
2124     @Override
2125     public ParsingPackageImpl setMetaData(@Nullable Bundle value) {
2126         metaData = value;
2127         return this;
2128     }
2129 
2130     @Override
2131     public ParsingPackageImpl setSigningDetails(@Nullable PackageParser.SigningDetails value) {
2132         signingDetails = value;
2133         return this;
2134     }
2135 
2136     @Override
2137     public ParsingPackageImpl setUse32BitAbi(boolean value) {
2138         use32BitAbi = value;
2139         return this;
2140     }
2141 
2142     @Override
2143     public ParsingPackageImpl setVisibleToInstantApps(boolean value) {
2144         visibleToInstantApps = value;
2145         return this;
2146     }
2147 
2148     @Override
2149     public ParsingPackageImpl setForceQueryable(boolean value) {
2150         forceQueryable = value;
2151         return this;
2152     }
2153 
2154     @Override
2155     public ParsingPackageImpl setBanner(int value) {
2156         banner = value;
2157         return this;
2158     }
2159 
2160     @Override
2161     public ParsingPackageImpl setCategory(int value) {
2162         category = value;
2163         return this;
2164     }
2165 
2166     @Override
2167     public ParsingPackageImpl setCompatibleWidthLimitDp(int value) {
2168         compatibleWidthLimitDp = value;
2169         return this;
2170     }
2171 
2172     @Override
2173     public ParsingPackageImpl setDescriptionRes(int value) {
2174         descriptionRes = value;
2175         return this;
2176     }
2177 
2178     @Override
2179     public ParsingPackageImpl setEnabled(boolean value) {
2180         enabled = value;
2181         return this;
2182     }
2183 
2184     @Override
2185     public ParsingPackageImpl setCrossProfile(boolean value) {
2186         crossProfile = value;
2187         return this;
2188     }
2189 
2190     @Override
2191     public ParsingPackageImpl setFullBackupContent(int value) {
2192         fullBackupContent = value;
2193         return this;
2194     }
2195 
2196     @Override
2197     public ParsingPackageImpl setIconRes(int value) {
2198         iconRes = value;
2199         return this;
2200     }
2201 
2202     @Override
2203     public ParsingPackageImpl setInstallLocation(int value) {
2204         installLocation = value;
2205         return this;
2206     }
2207 
2208     @Override
2209     public ParsingPackageImpl setLabelRes(int value) {
2210         labelRes = value;
2211         return this;
2212     }
2213 
2214     @Override
2215     public ParsingPackageImpl setLargestWidthLimitDp(int value) {
2216         largestWidthLimitDp = value;
2217         return this;
2218     }
2219 
2220     @Override
2221     public ParsingPackageImpl setLogo(int value) {
2222         logo = value;
2223         return this;
2224     }
2225 
2226     @Override
2227     public ParsingPackageImpl setMaxAspectRatio(float value) {
2228         maxAspectRatio = value;
2229         return this;
2230     }
2231 
2232     @Override
2233     public ParsingPackageImpl setMinAspectRatio(float value) {
2234         minAspectRatio = value;
2235         return this;
2236     }
2237 
2238     @Override
2239     public ParsingPackageImpl setMinExtensionVersions(@Nullable SparseIntArray value) {
2240         minExtensionVersions = value;
2241         return this;
2242     }
2243 
2244     @Override
2245     public ParsingPackageImpl setMinSdkVersion(int value) {
2246         minSdkVersion = value;
2247         return this;
2248     }
2249 
2250     @Override
2251     public ParsingPackageImpl setNetworkSecurityConfigRes(int value) {
2252         networkSecurityConfigRes = value;
2253         return this;
2254     }
2255 
2256     @Override
2257     public ParsingPackageImpl setNonLocalizedLabel(@Nullable CharSequence value) {
2258         nonLocalizedLabel = value;
2259         return this;
2260     }
2261 
2262     @Override
2263     public ParsingPackageImpl setRequiresSmallestWidthDp(int value) {
2264         requiresSmallestWidthDp = value;
2265         return this;
2266     }
2267 
2268     @Override
2269     public ParsingPackageImpl setRoundIconRes(int value) {
2270         roundIconRes = value;
2271         return this;
2272     }
2273 
2274     @Override
2275     public ParsingPackageImpl setTargetSandboxVersion(int value) {
2276         targetSandboxVersion = value;
2277         return this;
2278     }
2279 
2280     @Override
2281     public ParsingPackageImpl setTargetSdkVersion(int value) {
2282         targetSdkVersion = value;
2283         return this;
2284     }
2285 
2286     @Override
2287     public ParsingPackageImpl setTheme(int value) {
2288         theme = value;
2289         return this;
2290     }
2291 
2292     @Override
2293     public ParsingPackageImpl setUiOptions(int value) {
2294         uiOptions = value;
2295         return this;
2296     }
2297 
2298     @Override
2299     public ParsingPackageImpl setExternalStorage(boolean value) {
2300         externalStorage = value;
2301         return this;
2302     }
2303 
2304     @Override
2305     public ParsingPackageImpl setBaseHardwareAccelerated(boolean value) {
2306         baseHardwareAccelerated = value;
2307         return this;
2308     }
2309 
2310     @Override
2311     public ParsingPackageImpl setAllowBackup(boolean value) {
2312         allowBackup = value;
2313         return this;
2314     }
2315 
2316     @Override
2317     public ParsingPackageImpl setKillAfterRestore(boolean value) {
2318         killAfterRestore = value;
2319         return this;
2320     }
2321 
2322     @Override
2323     public ParsingPackageImpl setRestoreAnyVersion(boolean value) {
2324         restoreAnyVersion = value;
2325         return this;
2326     }
2327 
2328     @Override
2329     public ParsingPackageImpl setFullBackupOnly(boolean value) {
2330         fullBackupOnly = value;
2331         return this;
2332     }
2333 
2334     @Override
2335     public ParsingPackageImpl setPersistent(boolean value) {
2336         persistent = value;
2337         return this;
2338     }
2339 
2340     @Override
2341     public ParsingPackageImpl setDebuggable(boolean value) {
2342         debuggable = value;
2343         return this;
2344     }
2345 
2346     @Override
2347     public ParsingPackageImpl setVmSafeMode(boolean value) {
2348         vmSafeMode = value;
2349         return this;
2350     }
2351 
2352     @Override
2353     public ParsingPackageImpl setHasCode(boolean value) {
2354         hasCode = value;
2355         return this;
2356     }
2357 
2358     @Override
2359     public ParsingPackageImpl setAllowTaskReparenting(boolean value) {
2360         allowTaskReparenting = value;
2361         return this;
2362     }
2363 
2364     @Override
2365     public ParsingPackageImpl setAllowClearUserData(boolean value) {
2366         allowClearUserData = value;
2367         return this;
2368     }
2369 
2370     @Override
2371     public ParsingPackageImpl setLargeHeap(boolean value) {
2372         largeHeap = value;
2373         return this;
2374     }
2375 
2376     @Override
2377     public ParsingPackageImpl setUsesCleartextTraffic(boolean value) {
2378         usesCleartextTraffic = value;
2379         return this;
2380     }
2381 
2382     @Override
2383     public ParsingPackageImpl setSupportsRtl(boolean value) {
2384         supportsRtl = value;
2385         return this;
2386     }
2387 
2388     @Override
2389     public ParsingPackageImpl setTestOnly(boolean value) {
2390         testOnly = value;
2391         return this;
2392     }
2393 
2394     @Override
2395     public ParsingPackageImpl setMultiArch(boolean value) {
2396         multiArch = value;
2397         return this;
2398     }
2399 
2400     @Override
2401     public ParsingPackageImpl setExtractNativeLibs(boolean value) {
2402         extractNativeLibs = value;
2403         return this;
2404     }
2405 
2406     @Override
2407     public ParsingPackageImpl setGame(boolean value) {
2408         game = value;
2409         return this;
2410     }
2411 
2412     /**
2413      * @see ParsingPackageRead#getResizeableActivity()
2414      */
2415     @Override
2416     public ParsingPackageImpl setResizeableActivity(@Nullable Boolean value) {
2417         resizeableActivity = value;
2418         return this;
2419     }
2420 
2421     @Override
2422     public ParsingPackageImpl setStaticSharedLibrary(boolean value) {
2423         staticSharedLibrary = value;
2424         return this;
2425     }
2426 
2427     @Override
2428     public ParsingPackageImpl setOverlay(boolean value) {
2429         overlay = value;
2430         return this;
2431     }
2432 
2433     @Override
2434     public ParsingPackageImpl setIsolatedSplitLoading(boolean value) {
2435         isolatedSplitLoading = value;
2436         return this;
2437     }
2438 
2439     @Override
2440     public ParsingPackageImpl setHasDomainUrls(boolean value) {
2441         hasDomainUrls = value;
2442         return this;
2443     }
2444 
2445     @Override
2446     public ParsingPackageImpl setProfileableByShell(boolean value) {
2447         profileableByShell = value;
2448         return this;
2449     }
2450 
2451     @Override
2452     public ParsingPackageImpl setBackupInForeground(boolean value) {
2453         backupInForeground = value;
2454         return this;
2455     }
2456 
2457     @Override
2458     public ParsingPackageImpl setUseEmbeddedDex(boolean value) {
2459         useEmbeddedDex = value;
2460         return this;
2461     }
2462 
2463     @Override
2464     public ParsingPackageImpl setDefaultToDeviceProtectedStorage(boolean value) {
2465         defaultToDeviceProtectedStorage = value;
2466         return this;
2467     }
2468 
2469     @Override
2470     public ParsingPackageImpl setDirectBootAware(boolean value) {
2471         directBootAware = value;
2472         return this;
2473     }
2474 
2475     @Override
2476     public ParsingPackageImpl setGwpAsanMode(int value) {
2477         gwpAsanMode = value;
2478         return this;
2479     }
2480 
2481     @Override
2482     public ParsingPackageImpl setPartiallyDirectBootAware(boolean value) {
2483         partiallyDirectBootAware = value;
2484         return this;
2485     }
2486 
2487     @Override
2488     public ParsingPackageImpl setResizeableActivityViaSdkVersion(boolean value) {
2489         resizeableActivityViaSdkVersion = value;
2490         return this;
2491     }
2492 
2493     @Override
2494     public ParsingPackageImpl setAllowClearUserDataOnFailedRestore(boolean value) {
2495         allowClearUserDataOnFailedRestore = value;
2496         return this;
2497     }
2498 
2499     @Override
2500     public ParsingPackageImpl setAllowAudioPlaybackCapture(boolean value) {
2501         allowAudioPlaybackCapture = value;
2502         return this;
2503     }
2504 
2505     @Override
2506     public ParsingPackageImpl setRequestLegacyExternalStorage(boolean value) {
2507         requestLegacyExternalStorage = value;
2508         return this;
2509     }
2510 
2511     @Override
2512     public ParsingPackageImpl setUsesNonSdkApi(boolean value) {
2513         usesNonSdkApi = value;
2514         return this;
2515     }
2516 
2517     @Override
2518     public ParsingPackageImpl setHasFragileUserData(boolean value) {
2519         hasFragileUserData = value;
2520         return this;
2521     }
2522 
2523     @Override
2524     public ParsingPackageImpl setCantSaveState(boolean value) {
2525         cantSaveState = value;
2526         return this;
2527     }
2528 
2529     @Override
2530     public ParsingPackageImpl setAllowNativeHeapPointerTagging(boolean value) {
2531         allowNativeHeapPointerTagging = value;
2532         return this;
2533     }
2534 
2535     @Override
2536     public ParsingPackageImpl setAutoRevokePermissions(int value) {
2537         autoRevokePermissions = value;
2538         return this;
2539     }
2540 
2541     @Override
2542     public ParsingPackageImpl setPreserveLegacyExternalStorage(boolean value) {
2543         preserveLegacyExternalStorage = value;
2544         return this;
2545     }
2546 
2547     @Override
2548     public ParsingPackageImpl setVersionName(String versionName) {
2549         this.versionName = versionName;
2550         return this;
2551     }
2552 
2553     @Override
2554     public ParsingPackage setCompileSdkVersionCodename(String compileSdkVersionCodename) {
2555         this.compileSdkVersionCodeName = compileSdkVersionCodename;
2556         return this;
2557     }
2558 
2559     @Override
2560     public ParsingPackageImpl setProcessName(String processName) {
2561         this.processName = processName;
2562         return this;
2563     }
2564 
2565     @Override
2566     public ParsingPackageImpl setRealPackage(@Nullable String realPackage) {
2567         this.realPackage = realPackage;
2568         return this;
2569     }
2570 
2571     @Override
2572     public ParsingPackageImpl setRestrictedAccountType(@Nullable String restrictedAccountType) {
2573         this.restrictedAccountType = restrictedAccountType;
2574         return this;
2575     }
2576 
2577     @Override
2578     public ParsingPackageImpl setOverlayTargetName(@Nullable String overlayTargetName) {
2579         this.overlayTargetName = overlayTargetName;
2580         return this;
2581     }
2582 
2583     @Override
2584     public ParsingPackageImpl setOverlayCategory(@Nullable String overlayCategory) {
2585         this.overlayCategory = overlayCategory;
2586         return this;
2587     }
2588 
2589     @Override
2590     public ParsingPackageImpl setAppComponentFactory(@Nullable String appComponentFactory) {
2591         this.appComponentFactory = appComponentFactory;
2592         return this;
2593     }
2594 
2595     @Override
2596     public ParsingPackageImpl setBackupAgentName(@Nullable String backupAgentName) {
2597         this.backupAgentName = backupAgentName;
2598         return this;
2599     }
2600 
2601     @Override
2602     public ParsingPackageImpl setClassLoaderName(@Nullable String classLoaderName) {
2603         this.classLoaderName = classLoaderName;
2604         return this;
2605     }
2606 
2607     @Override
2608     public ParsingPackageImpl setClassName(@Nullable String className) {
2609         this.className = className;
2610         return this;
2611     }
2612 
2613     @Override
2614     public ParsingPackageImpl setManageSpaceActivityName(@Nullable String manageSpaceActivityName) {
2615         this.manageSpaceActivityName = manageSpaceActivityName;
2616         return this;
2617     }
2618 
2619     @Override
2620     public ParsingPackageImpl setPermission(@Nullable String permission) {
2621         this.permission = permission;
2622         return this;
2623     }
2624 
2625     @Override
2626     public ParsingPackageImpl setTaskAffinity(@Nullable String taskAffinity) {
2627         this.taskAffinity = taskAffinity;
2628         return this;
2629     }
2630 
2631     @Override
2632     public ParsingPackageImpl setZygotePreloadName(@Nullable String zygotePreloadName) {
2633         this.zygotePreloadName = zygotePreloadName;
2634         return this;
2635     }
2636 }
2637