Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit 022e707f authored by Winson's avatar Winson
Browse files

Split ParsedComponents 

This creates individual files for each Parsed_ object.

Each also has a corresponding _Utils class for holding the
parsing logic for each object. This was done to keep the data
class as simple as possible.

This commit does not migrate existing usages of ComponentParseUtils
subclasses, so there will be duplicates of everything. A follow up
change will migrate all the parsing logic to use these new classes.

Bug: 135203078

Test: none, all testing for Parsed_ is to-be-merged and/or TBD
Change-Id: I7bea3b1742bc5d945d1ad287f406488d3bf46476
parent 3dc4af47

core/java/android/content/pm/parsing/ParsingPackageImpl.java

+6 −6
Original line number Diff line number Diff line
@@ -84,16 +84,16 @@ public class ParsingPackageImpl implements ParsingPackage, Parcelable { 


    private static final String TAG = "PackageImpl";



    protected static ForBoolean sForBoolean = Parcelling.Cache.getOrCreate(ForBoolean.class);

    protected static ForInternedString sForString = Parcelling.Cache.getOrCreate(

    public static ForBoolean sForBoolean = Parcelling.Cache.getOrCreate(ForBoolean.class);

    public static ForInternedString sForString = Parcelling.Cache.getOrCreate(

            ForInternedString.class);

    protected static ForInternedStringArray sForStringArray = Parcelling.Cache.getOrCreate(

    public static ForInternedStringArray sForStringArray = Parcelling.Cache.getOrCreate(

            ForInternedStringArray.class);

    protected static ForInternedStringList sForStringList = Parcelling.Cache.getOrCreate(

    public static ForInternedStringList sForStringList = Parcelling.Cache.getOrCreate(

            ForInternedStringList.class);

    protected static ForInternedStringValueMap sForStringValueMap = Parcelling.Cache.getOrCreate(

    public static ForInternedStringValueMap sForStringValueMap = Parcelling.Cache.getOrCreate(

            ForInternedStringValueMap.class);

    protected static ForInternedStringSet sForStringSet = Parcelling.Cache.getOrCreate(

    public static ForInternedStringSet sForStringSet = Parcelling.Cache.getOrCreate(

            ForInternedStringSet.class);



    // These are objects because null represents not explicitly set

core/java/android/content/pm/parsing/component/ComponentParseUtils.java

0 → 100644
+178 −0
Original line number Diff line number Diff line 
/*

 * Copyright (C) 2020 The Android Open Source Project

 *

 * Licensed under the Apache License, Version 2.0 (the "License");

 * you may not use this file except in compliance with the License.

 * You may obtain a copy of the License at

 *

 *      http://www.apache.org/licenses/LICENSE-2.0

 *

 * Unless required by applicable law or agreed to in writing, software

 * distributed under the License is distributed on an "AS IS" BASIS,

 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

 * See the License for the specific language governing permissions and

 * limitations under the License.

 */



package android.content.pm.parsing.component;



import android.annotation.AttrRes;

import android.annotation.NonNull;

import android.annotation.Nullable;

import android.content.Intent;

import android.content.pm.PackageParser;

import android.content.pm.PackageUserState;

import android.content.pm.parsing.ParsingPackage;

import android.content.pm.parsing.ParsingUtils;

import android.content.res.Resources;

import android.content.res.TypedArray;

import android.content.res.XmlResourceParser;

import android.text.TextUtils;



import android.content.pm.parsing.ParsingPackageUtils;

import android.content.pm.parsing.result.ParseInput;

import android.content.pm.parsing.result.ParseResult;



import org.xmlpull.v1.XmlPullParser;

import org.xmlpull.v1.XmlPullParserException;



import java.io.IOException;



/** @hide */

public class ComponentParseUtils {



    private static final String TAG = ParsingPackageUtils.TAG;



    public static boolean isImplicitlyExposedIntent(ParsedIntentInfo intentInfo) {

        return intentInfo.hasCategory(Intent.CATEGORY_BROWSABLE)

                || intentInfo.hasAction(Intent.ACTION_SEND)

                || intentInfo.hasAction(Intent.ACTION_SENDTO)

                || intentInfo.hasAction(Intent.ACTION_SEND_MULTIPLE);

    }



    static <Component extends ParsedComponent> ParseResult<Component> parseAllMetaData(

            ParsingPackage pkg, Resources res, XmlResourceParser parser, String tag,

            Component component, ParseInput input) throws XmlPullParserException, IOException {

        final int depth = parser.getDepth();

        int type;

        while ((type = parser.next()) != XmlPullParser.END_DOCUMENT

                && (type != XmlPullParser.END_TAG || parser.getDepth() > depth)) {

            if (type != XmlPullParser.START_TAG) {

                continue;

            }



            final ParseResult result;

            if ("meta-data".equals(parser.getName())) {

                result = ParsedComponentUtils.addMetaData(component, pkg, res, parser, input);

            } else {

                result = ParsingUtils.unknownTag(tag, pkg, parser, input);

            }



            if (result.isError()) {

                return input.error(result);

            }

        }



        return input.success(component);

    }



    @NonNull

    public static ParseResult<String> buildProcessName(@NonNull String pkg, String defProc,

            CharSequence procSeq, int flags, String[] separateProcesses, ParseInput input) {

        if ((flags & PackageParser.PARSE_IGNORE_PROCESSES) != 0 && !"system".contentEquals(

                procSeq)) {

            return input.success(defProc != null ? defProc : pkg);

        }

        if (separateProcesses != null) {

            for (int i = separateProcesses.length - 1; i >= 0; i--) {

                String sp = separateProcesses[i];

                if (sp.equals(pkg) || sp.equals(defProc) || sp.contentEquals(procSeq)) {

                    return input.success(pkg);

                }

            }

        }

        if (procSeq == null || procSeq.length() <= 0) {

            return input.success(defProc);

        }



        ParseResult<String> nameResult = ComponentParseUtils.buildCompoundName(pkg, procSeq,

                "process", input);

        return input.success(TextUtils.safeIntern(nameResult.getResult()));

    }



    @NonNull

    public static ParseResult<String> buildTaskAffinityName(String pkg, String defProc,

            CharSequence procSeq, ParseInput input) {

        if (procSeq == null) {

            return input.success(defProc);

        }

        if (procSeq.length() <= 0) {

            return input.success(null);

        }

        return buildCompoundName(pkg, procSeq, "taskAffinity", input);

    }



    public static ParseResult<String> buildCompoundName(String pkg, CharSequence procSeq,

            String type, ParseInput input) {

        String proc = procSeq.toString();

        char c = proc.charAt(0);

        if (pkg != null && c == ':') {

            if (proc.length() < 2) {

                return input.error("Bad " + type + " name " + proc + " in package " + pkg

                        + ": must be at least two characters");

            }

            String subName = proc.substring(1);

            String nameError = PackageParser.validateName(subName, false, false);

            if (nameError != null) {

                return input.error("Invalid " + type + " name " + proc + " in package " + pkg

                        + ": " + nameError);

            }

            return input.success(pkg + proc);

        }

        String nameError = PackageParser.validateName(proc, true, false);

        if (nameError != null && !"system".equals(proc)) {

            return input.error("Invalid " + type + " name " + proc + " in package " + pkg

                    + ": " + nameError);

        }

        return input.success(proc);

    }



    public static int flag(int flag, @AttrRes int attribute, TypedArray typedArray) {

        return typedArray.getBoolean(attribute, false) ? flag : 0;

    }



    public static int flag(int flag, @AttrRes int attribute, boolean defaultValue,

            TypedArray typedArray) {

        return typedArray.getBoolean(attribute, defaultValue) ? flag : 0;

    }



    /**

     * This is not state aware. Avoid and access through PackageInfoUtils in the system server.

     */

    @Nullable

    public static CharSequence getNonLocalizedLabel(

            ParsedComponent component) {

        return component.nonLocalizedLabel;

    }



    /**

     * This is not state aware. Avoid and access through PackageInfoUtils in the system server.

     *

     * This is a method of the utility class to discourage use.

     */

    public static int getIcon(ParsedComponent component) {

        return component.icon;

    }



    public static boolean isMatch(PackageUserState state, boolean isSystem,

            boolean isPackageEnabled, ParsedMainComponent component, int flags) {

        return state.isMatch(isSystem, isPackageEnabled, component.isEnabled(),

                component.isDirectBootAware(), component.getName(), flags);

    }



    public static boolean isEnabled(PackageUserState state, boolean isPackageEnabled,

            ParsedMainComponent parsedComponent, int flags) {

        return state.isEnabled(isPackageEnabled, parsedComponent.isEnabled(),

                parsedComponent.getName(), flags);

    }

}

core/java/android/content/pm/parsing/component/ParsedActivity.java

0 → 100644
+448 −0
Original line number Diff line number Diff line 
/*

 * Copyright (C) 2020 The Android Open Source Project

 *

 * Licensed under the Apache License, Version 2.0 (the "License");

 * you may not use this file except in compliance with the License.

 * You may obtain a copy of the License at

 *

 *      http://www.apache.org/licenses/LICENSE-2.0

 *

 * Unless required by applicable law or agreed to in writing, software

 * distributed under the License is distributed on an "AS IS" BASIS,

 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

 * See the License for the specific language governing permissions and

 * limitations under the License.

 */



package android.content.pm.parsing.component;



import static android.content.pm.ActivityInfo.RESIZE_MODE_FORCE_RESIZEABLE;

import static android.content.pm.ActivityInfo.RESIZE_MODE_RESIZEABLE;

import static android.content.pm.ActivityInfo.RESIZE_MODE_RESIZEABLE_VIA_SDK_VERSION;

import static android.content.pm.ActivityInfo.SCREEN_ORIENTATION_UNSPECIFIED;

import static android.content.pm.parsing.ParsingPackageImpl.sForString;

import static android.view.WindowManager.LayoutParams.ROTATION_ANIMATION_UNSPECIFIED;



import android.annotation.Nullable;

import android.app.ActivityTaskManager;

import android.content.ComponentName;

import android.content.pm.ActivityInfo;

import android.content.pm.PackageManager;

import android.content.pm.PackageParser;

import android.content.pm.parsing.ParsingPackageImpl;

import android.os.Parcel;

import android.os.Parcelable;

import android.text.TextUtils;



import com.android.internal.util.DataClass;

import com.android.internal.util.Parcelling;

import com.android.internal.util.Parcelling.BuiltIn.ForInternedString;



/** @hide **/

public class ParsedActivity extends ParsedMainComponent {



    int theme;

    int uiOptions;



    @Nullable

    @DataClass.ParcelWith(ForInternedString.class)

    private String targetActivity;



    @Nullable

    @DataClass.ParcelWith(ForInternedString.class)

    private String parentActivityName;

    @Nullable

    String taskAffinity;

    int privateFlags;

    @Nullable

    @DataClass.ParcelWith(ForInternedString.class)

    private String permission;



    int launchMode;

    int documentLaunchMode;

    int maxRecents;

    int configChanges;

    int softInputMode;

    int persistableMode;

    int lockTaskLaunchMode;



    int screenOrientation = ActivityInfo.SCREEN_ORIENTATION_UNSPECIFIED;

    int resizeMode = ActivityInfo.RESIZE_MODE_RESIZEABLE;



    @Nullable

    private Float maxAspectRatio;



    @Nullable

    private Float minAspectRatio;



    @Nullable

    String requestedVrComponent;

    int rotationAnimation = -1;

    int colorMode;



    boolean preferMinimalPostProcessing;



    @Nullable

    ActivityInfo.WindowLayout windowLayout;



    public ParsedActivity(ParsedActivity other) {

        super(other);

        this.theme = other.theme;

        this.uiOptions = other.uiOptions;

        this.targetActivity = other.targetActivity;

        this.parentActivityName = other.parentActivityName;

        this.taskAffinity = other.taskAffinity;

        this.privateFlags = other.privateFlags;

        this.permission = other.permission;

        this.launchMode = other.launchMode;

        this.documentLaunchMode = other.documentLaunchMode;

        this.maxRecents = other.maxRecents;

        this.configChanges = other.configChanges;

        this.softInputMode = other.softInputMode;

        this.persistableMode = other.persistableMode;

        this.lockTaskLaunchMode = other.lockTaskLaunchMode;

        this.screenOrientation = other.screenOrientation;

        this.resizeMode = other.resizeMode;

        this.maxAspectRatio = other.maxAspectRatio;

        this.minAspectRatio = other.minAspectRatio;

        this.requestedVrComponent = other.requestedVrComponent;

        this.rotationAnimation = other.rotationAnimation;

        this.colorMode = other.colorMode;

        this.windowLayout = other.windowLayout;

    }



    /**

     * Generate activity object that forwards user to App Details page automatically.

     * This activity should be invisible to user and user should not know or see it.

     */

    public static ParsedActivity makeAppDetailsActivity(String packageName, String processName,

            int uiOptions, String taskAffinity, boolean hardwareAccelerated) {

        ParsedActivity activity = new ParsedActivity();

        activity.setPackageName(packageName);

        activity.theme = android.R.style.Theme_NoDisplay;

        activity.exported = true;

        activity.setName(PackageManager.APP_DETAILS_ACTIVITY_CLASS_NAME);

        activity.setProcessName(processName);

        activity.uiOptions = uiOptions;

        activity.taskAffinity = taskAffinity;

        activity.launchMode = ActivityInfo.LAUNCH_MULTIPLE;

        activity.documentLaunchMode = ActivityInfo.DOCUMENT_LAUNCH_NONE;

        activity.maxRecents = ActivityTaskManager.getDefaultAppRecentsLimitStatic();

        activity.configChanges = PackageParser.getActivityConfigChanges(0, 0);

        activity.softInputMode = 0;

        activity.persistableMode = ActivityInfo.PERSIST_NEVER;

        activity.screenOrientation = SCREEN_ORIENTATION_UNSPECIFIED;

        activity.resizeMode = RESIZE_MODE_FORCE_RESIZEABLE;

        activity.lockTaskLaunchMode = 0;

        activity.setDirectBootAware(false);

        activity.rotationAnimation = ROTATION_ANIMATION_UNSPECIFIED;

        activity.colorMode = ActivityInfo.COLOR_MODE_DEFAULT;

        activity.preferMinimalPostProcessing = ActivityInfo.MINIMAL_POST_PROCESSING_DEFAULT;

        if (hardwareAccelerated) {

            activity.setFlags(activity.getFlags() | ActivityInfo.FLAG_HARDWARE_ACCELERATED);

        }

        return activity;

    }



    static ParsedActivity makeAlias(String targetActivityName, ParsedActivity target) {

        ParsedActivity alias = new ParsedActivity();

        alias.setPackageName(target.getPackageName());

        alias.setTargetActivity(targetActivityName);

        alias.configChanges = target.configChanges;

        alias.flags = target.flags;

        alias.privateFlags = target.privateFlags;

        alias.icon = target.icon;

        alias.logo = target.logo;

        alias.banner = target.banner;

        alias.labelRes = target.labelRes;

        alias.nonLocalizedLabel = target.nonLocalizedLabel;

        alias.launchMode = target.launchMode;

        alias.lockTaskLaunchMode = target.lockTaskLaunchMode;

        alias.descriptionRes = target.descriptionRes;

        alias.screenOrientation = target.screenOrientation;

        alias.taskAffinity = target.taskAffinity;

        alias.theme = target.theme;

        alias.softInputMode = target.softInputMode;

        alias.uiOptions = target.uiOptions;

        alias.parentActivityName = target.parentActivityName;

        alias.maxRecents = target.maxRecents;

        alias.windowLayout = target.windowLayout;

        alias.resizeMode = target.resizeMode;

        alias.maxAspectRatio = target.maxAspectRatio;

        alias.minAspectRatio = target.minAspectRatio;

        alias.requestedVrComponent = target.requestedVrComponent;

        alias.directBootAware = target.directBootAware;

        alias.setProcessName(target.getProcessName());

        return alias;



        // Not all attributes from the target ParsedActivity are copied to the alias.

        // Careful when adding an attribute and determine whether or not it should be copied.

//        alias.enabled = target.enabled;

//        alias.exported = target.exported;

//        alias.permission = target.permission;

//        alias.splitName = target.splitName;

//        alias.documentLaunchMode = target.documentLaunchMode;

//        alias.persistableMode = target.persistableMode;

//        alias.rotationAnimation = target.rotationAnimation;

//        alias.colorMode = target.colorMode;

//        alias.intents.addAll(target.intents);

//        alias.order = target.order;

//        alias.metaData = target.metaData;

    }



    public void setMaxAspectRatio(int resizeMode, float maxAspectRatio) {

        if (resizeMode == ActivityInfo.RESIZE_MODE_RESIZEABLE

                || resizeMode == ActivityInfo.RESIZE_MODE_RESIZEABLE_VIA_SDK_VERSION) {

            // Resizeable activities can be put in any aspect ratio.

            return;

        }



        if (maxAspectRatio < 1.0f && maxAspectRatio != 0) {

            // Ignore any value lesser than 1.0.

            return;

        }



        this.maxAspectRatio = maxAspectRatio;

    }



    public void setMinAspectRatio(int resizeMode, float minAspectRatio) {

        if (resizeMode == RESIZE_MODE_RESIZEABLE

                || resizeMode == RESIZE_MODE_RESIZEABLE_VIA_SDK_VERSION) {

            // Resizeable activities can be put in any aspect ratio.

            return;

        }



        if (minAspectRatio < 1.0f && minAspectRatio != 0) {

            // Ignore any value lesser than 1.0.

            return;

        }



        this.minAspectRatio = minAspectRatio;

    }



    public void setFlags(int flags) {

        this.flags = flags;

    }



    public ParsedActivity setResizeMode(int resizeMode) {

        this.resizeMode = resizeMode;

        return this;

    }



    public ParsedActivity setTargetActivity(String targetActivity) {

        this.targetActivity = TextUtils.safeIntern(targetActivity);

        return this;

    }



    public ParsedActivity setParentActivity(String parentActivity) {

        this.parentActivityName = TextUtils.safeIntern(parentActivity);

        return this;

    }



    public ParsedActivity setPermission(String permission) {

        // Empty string must be converted to null

        this.permission = TextUtils.isEmpty(permission) ? null : permission.intern();

        return this;

    }



    public String toString() {

        StringBuilder sb = new StringBuilder(128);

        sb.append("Activity{");

        sb.append(Integer.toHexString(System.identityHashCode(this)));

        sb.append(' ');

        ComponentName.appendShortString(sb, getPackageName(), getName());

        sb.append('}');

        return sb.toString();

    }



    @Override

    public int describeContents() {

        return 0;

    }



    @Override

    public void writeToParcel(Parcel dest, int flags) {

        super.writeToParcel(dest, flags);

        dest.writeInt(this.theme);

        dest.writeInt(this.uiOptions);

        sForString.parcel(this.targetActivity, dest, flags);

        sForString.parcel(this.parentActivityName, dest, flags);

        dest.writeString(this.taskAffinity);

        dest.writeInt(this.privateFlags);

        sForString.parcel(this.permission, dest, flags);

        dest.writeInt(this.launchMode);

        dest.writeInt(this.documentLaunchMode);

        dest.writeInt(this.maxRecents);

        dest.writeInt(this.configChanges);

        dest.writeInt(this.softInputMode);

        dest.writeInt(this.persistableMode);

        dest.writeInt(this.lockTaskLaunchMode);

        dest.writeInt(this.screenOrientation);

        dest.writeInt(this.resizeMode);

        dest.writeValue(this.maxAspectRatio);

        dest.writeValue(this.minAspectRatio);

        dest.writeString(this.requestedVrComponent);

        dest.writeInt(this.rotationAnimation);

        dest.writeInt(this.colorMode);

        dest.writeBoolean(this.preferMinimalPostProcessing);

        dest.writeBundle(this.metaData);



        if (windowLayout != null) {

            dest.writeBoolean(true);

            dest.writeInt(windowLayout.width);

            dest.writeFloat(windowLayout.widthFraction);

            dest.writeInt(windowLayout.height);

            dest.writeFloat(windowLayout.heightFraction);

            dest.writeInt(windowLayout.gravity);

            dest.writeInt(windowLayout.minWidth);

            dest.writeInt(windowLayout.minHeight);

        } else {

            dest.writeBoolean(false);

        }

    }



    public ParsedActivity() {

    }



    protected ParsedActivity(Parcel in) {

        super(in);

        this.theme = in.readInt();

        this.uiOptions = in.readInt();

        this.targetActivity = sForString.unparcel(in);

        this.parentActivityName = sForString.unparcel(in);

        this.taskAffinity = in.readString();

        this.privateFlags = in.readInt();

        this.permission = sForString.unparcel(in);

        this.launchMode = in.readInt();

        this.documentLaunchMode = in.readInt();

        this.maxRecents = in.readInt();

        this.configChanges = in.readInt();

        this.softInputMode = in.readInt();

        this.persistableMode = in.readInt();

        this.lockTaskLaunchMode = in.readInt();

        this.screenOrientation = in.readInt();

        this.resizeMode = in.readInt();

        this.maxAspectRatio = (Float) in.readValue(Float.class.getClassLoader());

        this.minAspectRatio = (Float) in.readValue(Float.class.getClassLoader());

        this.requestedVrComponent = in.readString();

        this.rotationAnimation = in.readInt();

        this.colorMode = in.readInt();

        this.preferMinimalPostProcessing = in.readBoolean();

        this.metaData = in.readBundle();

        if (in.readBoolean()) {

            windowLayout = new ActivityInfo.WindowLayout(in);

        }

    }



    public static final Parcelable.Creator<ParsedActivity> CREATOR = new Creator<ParsedActivity>() {

        @Override

        public ParsedActivity createFromParcel(Parcel source) {

            return new ParsedActivity(source);

        }



        @Override

        public ParsedActivity[] newArray(int size) {

            return new ParsedActivity[size];

        }

    };



    public int getTheme() {

        return theme;

    }



    public int getUiOptions() {

        return uiOptions;

    }



    @Nullable

    public String getTargetActivity() {

        return targetActivity;

    }



    @Nullable

    public String getParentActivityName() {

        return parentActivityName;

    }



    @Nullable

    public String getTaskAffinity() {

        return taskAffinity;

    }



    public int getPrivateFlags() {

        return privateFlags;

    }



    @Nullable

    public String getPermission() {

        return permission;

    }



    public int getLaunchMode() {

        return launchMode;

    }



    public int getDocumentLaunchMode() {

        return documentLaunchMode;

    }



    public int getMaxRecents() {

        return maxRecents;

    }



    public int getConfigChanges() {

        return configChanges;

    }



    public int getSoftInputMode() {

        return softInputMode;

    }



    public int getPersistableMode() {

        return persistableMode;

    }



    public int getLockTaskLaunchMode() {

        return lockTaskLaunchMode;

    }



    public int getScreenOrientation() {

        return screenOrientation;

    }



    public int getResizeMode() {

        return resizeMode;

    }



    @Nullable

    public Float getMaxAspectRatio() {

        return maxAspectRatio;

    }



    @Nullable

    public Float getMinAspectRatio() {

        return minAspectRatio;

    }



    @Nullable

    public String getRequestedVrComponent() {

        return requestedVrComponent;

    }



    public int getRotationAnimation() {

        return rotationAnimation;

    }



    public int getColorMode() {

        return colorMode;

    }



    public boolean isPreferMinimalPostProcessing() {

        return preferMinimalPostProcessing;

    }



    @Nullable

    public ActivityInfo.WindowLayout getWindowLayout() {

        return windowLayout;

    }

}

core/java/android/content/pm/parsing/component/ParsedActivityUtils.java

0 → 100644
+476 −0

File added.

Preview size limit exceeded, changes collapsed.

core/java/android/content/pm/parsing/component/ParsedComponent.java

0 → 100644
+208 −0

File added.

Preview size limit exceeded, changes collapsed.