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

Commit 21a3d1ad authored by Mårten Kongstad's avatar Mårten Kongstad Committed by Adam Lesinski
Browse files

OMS: integrate OverlayManagerService into framework 



Hand over ownership of overlays to OverlayManagerService.

Changes to a package's overlays are propagated using the activity life
cycle. Affected activities will be recreated as needed. This provides a
well-defined point to modify an application's assets while the
application is paused.

Consolidate how overlays targeting the system and overlays targeting
regular applications are handled. Previously, system overlays were
handled as a special case. Now, everything is handled identically. As a
side effect, the call to idmap --scan during Zygote boot has become
obsolete and is removed.

Information on what overlays to use is recorded in
ApplicationInfo.resourceDirs. The PackageManagerService is responsible
for the creation of ApplicationInfo objects. The OverlayManagerService
is responsible for informing the PackageManagerService in advance about
what resourceDirs to use.

When launching an application, the ApplicationInfo is already populated
with up-to-date information about overlays.

When enabling or disabling an overlay for a running application, the
OverlayManagerService first notifies the PackageManagerService about the
updated resourceDirs. It then tells the ActivityManagerService to push
the new ApplicationInfo object to the application's ActivityThread.
Finally the application requests its ResourcesManager to create new
ResourcesImpl objects based on the updated paths.

Co-authored-by: default avatarMartin Wallgren <martin.wallgren@sonymobile.com>
Signed-off-by: default avatarZoran Jovanovic <zoran.jovanovic@sonymobile.com>
Bug: 31052947
Test: run tests from 'OMS: tests for OverlayManagerService'
Change-Id: Idc96dae6fc075d5373aa055bbf50e919136d7353
parent f9bd2944

cmds/idmap/Android.mk

+1 −1
Original line number Diff line number Diff line
@@ -15,7 +15,7 @@ 
LOCAL_PATH:= $(call my-dir)

include $(CLEAR_VARS)



LOCAL_SRC_FILES := idmap.cpp create.cpp scan.cpp inspect.cpp

LOCAL_SRC_FILES := idmap.cpp create.cpp inspect.cpp



LOCAL_SHARED_LIBRARIES := liblog libutils libandroidfw

cmds/idmap/idmap.cpp

+0 −55
Original line number Diff line number Diff line
@@ -13,8 +13,6 @@ SYNOPSIS \n\ 
      idmap --help \n\

      idmap --fd target overlay fd \n\

      idmap --path target overlay idmap \n\

      idmap --scan target-package-name-to-look-for path-to-target-apk dir-to-hold-idmaps \\\

                   dir-to-scan [additional-dir-to-scan [additional-dir-to-scan [...]]]\n\

      idmap --inspect idmap \n\

\n\

DESCRIPTION \n\
@@ -48,11 +46,6 @@ OPTIONS \n\ 
\n\

      --path: create idmap for target package 'target' (path to apk) and overlay package \n\

              'overlay' (path to apk); write results to 'idmap' (path). \n\

\n\

      --scan: non-recursively search directory 'dir-to-scan' (path) for overlay packages with \n\

              target package 'target-package-name-to-look-for' (package name) present at\n\

              'path-to-target-apk' (path to apk). For each overlay package found, create an\n\

              idmap file in 'dir-to-hold-idmaps' (path). \n\

\n\

      --inspect: decode the binary format of 'idmap' (path) and display the contents in a \n\

                 debug-friendly format. \n\
@@ -97,16 +90,6 @@ EXAMPLES \n\ 
NOTES \n\

      This tool and its expected invocation from installd is modelled on dexopt.";



    bool verify_directory_readable(const char *path)

    {

        return access(path, R_OK | X_OK) == 0;

    }



    bool verify_directory_writable(const char *path)

    {

        return access(path, W_OK) == 0;

    }



    bool verify_file_readable(const char *path)

    {

        return access(path, R_OK) == 0;
@@ -167,36 +150,6 @@ NOTES \n\ 
        return idmap_create_path(target_apk_path, overlay_apk_path, idmap_path);

    }



    int maybe_scan(const char *target_package_name, const char *target_apk_path,

            const char *idmap_dir, const android::Vector<const char *> *overlay_dirs)

    {

        if (!verify_root_or_system()) {

            fprintf(stderr, "error: permission denied: not user root or user system\n");

            return -1;

        }



        if (!verify_file_readable(target_apk_path)) {

            ALOGD("error: failed to read apk %s: %s\n", target_apk_path, strerror(errno));

            return -1;

        }



        if (!verify_directory_writable(idmap_dir)) {

            ALOGD("error: no write access to %s: %s\n", idmap_dir, strerror(errno));

            return -1;

        }



        const size_t N = overlay_dirs->size();

        for (size_t i = 0; i < N; i++) {

            const char *dir = overlay_dirs->itemAt(i);

            if (!verify_directory_readable(dir)) {

                ALOGD("error: no read access to %s: %s\n", dir, strerror(errno));

                return -1;

            }

        }



        return idmap_scan(target_package_name, target_apk_path, idmap_dir, overlay_dirs);

    }



    int maybe_inspect(const char *idmap_path)

    {

        // anyone (not just root or system) may do --inspect
@@ -235,14 +188,6 @@ int main(int argc, char **argv) 
        return maybe_create_path(argv[2], argv[3], argv[4]);

    }



    if (argc >= 6 && !strcmp(argv[1], "--scan")) {

        android::Vector<const char *> v;

        for (int i = 5; i < argc; i++) {

            v.push(argv[i]);

        }

        return maybe_scan(argv[2], argv[3], argv[4], &v);

    }



    if (argc == 3 && !strcmp(argv[1], "--inspect")) {

        return maybe_inspect(argv[2]);

    }

cmds/idmap/idmap.h

+0 −6
Original line number Diff line number Diff line
@@ -25,12 +25,6 @@ int idmap_create_path(const char *target_apk_path, const char *overlay_apk_path, 


int idmap_create_fd(const char *target_apk_path, const char *overlay_apk_path, int fd);



// Regarding target_package_name: the idmap_scan implementation should

// be able to extract this from the manifest in target_apk_path,

// simplifying the external API.

int idmap_scan(const char *target_package_name, const char *target_apk_path,

        const char *idmap_dir, const android::Vector<const char *> *overlay_dirs);



int idmap_inspect(const char *idmap_path);



#endif // _IDMAP_H_

cmds/idmap/scan.cpp

deleted100644 → 0
+0 −239
Original line number Diff line number Diff line 
#include <dirent.h>

#include <inttypes.h>

#include <sys/file.h>

#include <sys/stat.h>



#include "idmap.h"



#include <memory>

#include <androidfw/ResourceTypes.h>

#include <androidfw/StreamingZipInflater.h>

#include <androidfw/ZipFileRO.h>

#include <private/android_filesystem_config.h> // for AID_SYSTEM

#include <utils/SortedVector.h>

#include <utils/String16.h>

#include <utils/String8.h>



#define NO_OVERLAY_TAG (-1000)



using namespace android;



namespace {

    struct Overlay {

        Overlay() {}

        Overlay(const String8& a, const String8& i, int p) :

            apk_path(a), idmap_path(i), priority(p) {}



        bool operator<(Overlay const& rhs) const

        {

            return rhs.priority > priority;

        }



        String8 apk_path;

        String8 idmap_path;

        int priority;

    };



    bool writePackagesList(const char *filename, const SortedVector<Overlay>& overlayVector)

    {

        // the file is opened for appending so that it doesn't get truncated

        // before we can guarantee mutual exclusion via the flock

        FILE* fout = fopen(filename, "a");

        if (fout == NULL) {

            return false;

        }



        if (TEMP_FAILURE_RETRY(flock(fileno(fout), LOCK_EX)) != 0) {

            fclose(fout);

            return false;

        }



        if (TEMP_FAILURE_RETRY(ftruncate(fileno(fout), 0)) != 0) {

            TEMP_FAILURE_RETRY(flock(fileno(fout), LOCK_UN));

            fclose(fout);

            return false;

        }



        for (size_t i = 0; i < overlayVector.size(); ++i) {

            const Overlay& overlay = overlayVector[i];

            fprintf(fout, "%s %s\n", overlay.apk_path.string(), overlay.idmap_path.string());

        }



        TEMP_FAILURE_RETRY(fflush(fout));

        TEMP_FAILURE_RETRY(flock(fileno(fout), LOCK_UN));

        fclose(fout);



        // Make file world readable since Zygote (running as root) will read

        // it when creating the initial AssetManger object

        const mode_t mode = S_IRUSR | S_IWUSR | S_IRGRP | S_IROTH; // 0644

        if (chmod(filename, mode) == -1) {

            unlink(filename);

            return false;

        }



        return true;

    }



    String8 flatten_path(const char *path)

    {

        String16 tmp(path);

        tmp.replaceAll('/', '@');

        return String8(tmp);

    }



    int parse_overlay_tag(const ResXMLTree& parser, const char *target_package_name)

    {

        const size_t N = parser.getAttributeCount();

        String16 target;

        int priority = -1;

        for (size_t i = 0; i < N; ++i) {

            size_t len;

            String16 key(parser.getAttributeName(i, &len));

            if (key == String16("targetPackage")) {

                const char16_t *p = parser.getAttributeStringValue(i, &len);

                if (p != NULL) {

                    target = String16(p, len);

                }

            } else if (key == String16("priority")) {

                Res_value v;

                if (parser.getAttributeValue(i, &v) == sizeof(Res_value)) {

                    priority = v.data;

                    if (priority < 0 || priority > 9999) {

                        return -1;

                    }

                }

            }

        }

        if (target == String16(target_package_name)) {

            return priority;

        }

        return NO_OVERLAY_TAG;

    }



    int parse_manifest(const void *data, size_t size, const char *target_package_name)

    {

        ResXMLTree parser;

        parser.setTo(data, size);

        if (parser.getError() != NO_ERROR) {

            ALOGD("%s failed to init xml parser, error=0x%08x\n", __FUNCTION__, parser.getError());

            return -1;

        }



        ResXMLParser::event_code_t type;

        do {

            type = parser.next();

            if (type == ResXMLParser::START_TAG) {

                size_t len;

                String16 tag(parser.getElementName(&len));

                if (tag == String16("overlay")) {

                    return parse_overlay_tag(parser, target_package_name);

                }

            }

        } while (type != ResXMLParser::BAD_DOCUMENT && type != ResXMLParser::END_DOCUMENT);



        return NO_OVERLAY_TAG;

    }



    int parse_apk(const char *path, const char *target_package_name)

    {

        std::unique_ptr<ZipFileRO> zip(ZipFileRO::open(path));

        if (zip.get() == NULL) {

            ALOGW("%s: failed to open zip %s\n", __FUNCTION__, path);

            return -1;

        }

        ZipEntryRO entry;

        if ((entry = zip->findEntryByName("AndroidManifest.xml")) == NULL) {

            ALOGW("%s: failed to find entry AndroidManifest.xml\n", __FUNCTION__);

            return -1;

        }

        uint32_t uncompLen = 0;

        uint16_t method;

        if (!zip->getEntryInfo(entry, &method, &uncompLen, NULL, NULL, NULL, NULL)) {

            ALOGW("%s: failed to read entry info\n", __FUNCTION__);

            return -1;

        }

        if (method != ZipFileRO::kCompressDeflated) {

            ALOGW("%s: cannot handle zip compression method %" PRIu16 "\n", __FUNCTION__, method);

            return -1;

        }

        FileMap *dataMap = zip->createEntryFileMap(entry);

        if (dataMap == NULL) {

            ALOGW("%s: failed to create FileMap\n", __FUNCTION__);

            return -1;

        }

        char *buf = new char[uncompLen];

        if (NULL == buf) {

            ALOGW("%s: failed to allocate %" PRIu32 " byte\n", __FUNCTION__, uncompLen);

            delete dataMap;

            return -1;

        }

        StreamingZipInflater inflater(dataMap, uncompLen);

        if (inflater.read(buf, uncompLen) < 0) {

            ALOGW("%s: failed to inflate %" PRIu32 " byte\n", __FUNCTION__, uncompLen);

            delete[] buf;

            delete dataMap;

            return -1;

        }



        int priority = parse_manifest(buf, static_cast<size_t>(uncompLen), target_package_name);

        delete[] buf;

        delete dataMap;

        return priority;

    }

}



int idmap_scan(const char *target_package_name, const char *target_apk_path,

        const char *idmap_dir, const android::Vector<const char *> *overlay_dirs)

{

    String8 filename = String8(idmap_dir);

    filename.appendPath("overlays.list");



    SortedVector<Overlay> overlayVector;

    const size_t N = overlay_dirs->size();

    for (size_t i = 0; i < N; ++i) {

        const char *overlay_dir = overlay_dirs->itemAt(i);

        DIR *dir = opendir(overlay_dir);

        if (dir == NULL) {

            return EXIT_FAILURE;

        }



        struct dirent *dirent;

        while ((dirent = readdir(dir)) != NULL) {

            struct stat st;

            char overlay_apk_path[PATH_MAX + 1];

            snprintf(overlay_apk_path, PATH_MAX, "%s/%s", overlay_dir, dirent->d_name);

            if (stat(overlay_apk_path, &st) < 0) {

                continue;

            }

            if (!S_ISREG(st.st_mode)) {

                continue;

            }



            int priority = parse_apk(overlay_apk_path, target_package_name);

            if (priority < 0) {

                continue;

            }



            String8 idmap_path(idmap_dir);

            idmap_path.appendPath(flatten_path(overlay_apk_path + 1));

            idmap_path.append("@idmap");



            if (idmap_create_path(target_apk_path, overlay_apk_path, idmap_path.string()) != 0) {

                ALOGE("error: failed to create idmap for target=%s overlay=%s idmap=%s\n",

                        target_apk_path, overlay_apk_path, idmap_path.string());

                continue;

            }



            Overlay overlay(String8(overlay_apk_path), idmap_path, priority);

            overlayVector.add(overlay);

        }



        closedir(dir);

    }



    if (!writePackagesList(filename.string(), overlayVector)) {

        return EXIT_FAILURE;

    }



    return EXIT_SUCCESS;

}

core/java/android/content/pm/PackageParser.java

+1 −12
Original line number Diff line number Diff line
@@ -2065,9 +2065,6 @@ public class PackageParser { 
                        com.android.internal.R.styleable.AndroidManifestResourceOverlay);

                pkg.mOverlayTarget = sa.getString(

                        com.android.internal.R.styleable.AndroidManifestResourceOverlay_targetPackage);

                pkg.mOverlayPriority = sa.getInt(

                        com.android.internal.R.styleable.AndroidManifestResourceOverlay_priority,

                        -1);

                sa.recycle();



                if (pkg.mOverlayTarget == null) {
@@ -2075,12 +2072,6 @@ public class PackageParser { 
                    mParseError = PackageManager.INSTALL_PARSE_FAILED_MANIFEST_MALFORMED;

                    return null;

                }

                if (pkg.mOverlayPriority < 0 || pkg.mOverlayPriority > 9999) {

                    outError[0] = "<overlay> priority must be between 0 and 9999";

                    mParseError =

                        PackageManager.INSTALL_PARSE_FAILED_MANIFEST_MALFORMED;

                    return null;

                }

                XmlUtils.skipCurrentTag(parser);



            } else if (tagName.equals(TAG_KEY_SETS)) {
@@ -5518,7 +5509,6 @@ public class PackageParser { 
        public String mRequiredAccountType;



        public String mOverlayTarget;

        public int mOverlayPriority;

        public boolean mTrustedOverlay;



        /**
@@ -5995,7 +5985,6 @@ public class PackageParser { 
            mRestrictedAccountType = dest.readString();

            mRequiredAccountType = dest.readString();

            mOverlayTarget = dest.readString();

            mOverlayPriority = dest.readInt();

            mTrustedOverlay = (dest.readInt() == 1);

            mSigningKeys = (ArraySet<PublicKey>) dest.readArraySet(boot);

            mUpgradeKeySets = (ArraySet<String>) dest.readArraySet(boot);
@@ -6111,7 +6100,6 @@ public class PackageParser { 
            dest.writeString(mRestrictedAccountType);

            dest.writeString(mRequiredAccountType);

            dest.writeString(mOverlayTarget);

            dest.writeInt(mOverlayPriority);

            dest.writeInt(mTrustedOverlay ? 1 : 0);

            dest.writeArraySet(mSigningKeys);

            dest.writeArraySet(mUpgradeKeySets);
@@ -6560,6 +6548,7 @@ public class PackageParser { 
            ai.category = FallbackCategoryProvider.getFallbackCategory(ai.packageName);

        }

        ai.seInfoUser = SELinuxUtil.assignSeinfoUser(state);

        ai.resourceDirs = state.resourceDirs;

    }



    public static ApplicationInfo generateApplicationInfo(Package p, int flags,