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