AndroidP RRO overlay （二）

最新推荐文章于 2022-05-01 08:30:00 发布
最新推荐文章于 2022-05-01 08:30:00 发布
阅读量1.3k 收藏 4
点赞数 1
分类专栏： overlay RRO android
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/lisiwei1994/article/details/112320620
版权
android 同时被 3 个专栏收录
15 篇文章 6 订阅
订阅专栏
overlay
4 篇文章 1 订阅
订阅专栏
RRO
4 篇文章 0 订阅
订阅专栏

RRO 原理 一

1、create Idmap

我们 AndroidP RRO overlay （一）中介绍了怎么使用命令来替换overlay，那接下来就看看执行这个 adb shell cmd overlay enable --user 0 com.android.car.hvacOverlay 之后做了哪些事。
接收这个命令的类是frameworks/base/services/core/java/com/android/server/om/OverlayManagerShellCommand.java

final class OverlayManagerShellCommand extends ShellCommand {
    private final IOverlayManager mInterface;

    OverlayManagerShellCommand(@NonNull final IOverlayManager iom) {
        mInterface = iom;
    }

    @Override
    public int onCommand(@Nullable final String cmd) {
        if (cmd == null) {
            return handleDefaultCommands(cmd);
        }
        final PrintWriter err = getErrPrintWriter();
        try {
            switch (cmd) {
                case "list":
                    return runList();
                case "enable":
                	//接收到enable命令
                    return runEnableDisable(true); 
                case "disable":
                    return runEnableDisable(false);
                case "enable-exclusive":
                    return runEnableExclusive();
                case "set-priority":
                    return runSetPriority();
                default:
                    return handleDefaultCommands(cmd);
            }
        } catch (IllegalArgumentException e) {
            err.println("Error: " + e.getMessage());
        } catch (RemoteException e) {
            err.println("Remote exception: " + e);
        }
        return -1;
    }
     ........省略部分代码.............
    private int runEnableDisable(final boolean enable) throws RemoteException {
        final PrintWriter err = getErrPrintWriter();

        int userId = UserHandle.USER_SYSTEM;
        String opt;
        while ((opt = getNextOption()) != null) {
            switch (opt) {
                case "--user":
                    userId = UserHandle.parseUserArg(getNextArgRequired());
                    break;
                default:
                    err.println("Error: Unknown option: " + opt);
                    return 1;
            }
        }

        final String packageName = getNextArgRequired();
         // mInterface就是OverlayManagerService，
         // packageName = com.android.car.havc, enable = true, usrid = 0
        return mInterface.setEnabled(packageName, enable, userId) ? 0 : 1; 
    }

frameworks/base/services/core/java/com/android/server/om/OverlayManagerService.java

    ........省略部分代码.............
        @Override
        public boolean setEnabled(@Nullable final String packageName, final boolean enable,
                int userId) throws RemoteException {
            if(DEBUG){
                Slog.d(TAG, "setEnabled overlaymanagerservice : "+ packageName);
            }        
            enforceChangeOverlayPackagesPermission("setEnabled");
            userId = handleIncomingUser(userId, "setEnabled");
            if (packageName == null) {
                return false;
            }

            final long ident = Binder.clearCallingIdentity();
            try {
                synchronized (mLock) {
                    // mImpl 就是 OverlayManagerServiceImpl类
                    return mImpl.setEnabled(packageName, enable, userId);
                }
            } finally {
                Binder.restoreCallingIdentity(ident);
            }
        }

frameworks/base/services/core/java/com/android/server/om/OverlayManagerServiceImpl.java

    ........省略部分代码.............
    boolean setEnabled(@NonNull final String packageName, final boolean enable,
            final int userId) {
        if (DEBUG) {
            Slog.d(TAG, String.format("setEnabled packageName=%s enable=%s userId=%d",
                        packageName, enable, userId));
        }
		//拿到 com.android.car.havc的具体信息
        final PackageInfo overlayPackage = mPackageManager.getPackageInfo(packageName, userId);
        if (overlayPackage == null) {
            return false;
        }
        Slog.d(TAG, String.format("setEnabled overlayPackage=%s ",overlayPackage));
        
        // Ignore static overlays.
        if (overlayPackage.isStaticOverlayPackage()) {
            return false;
        }

        try {
            final OverlayInfo oi = mSettings.getOverlayInfo(packageName, userId);
            boolean modified = mSettings.setEnabled(packageName, userId, enable);
            List<String> targetPackages;

			// oi.targetPackageName = com.android.car.havc
			// oi.packageName = com.android.car.havcOverlay
			// updateState()会调到IdmapManager.createIdmap（）去创建idmap。
            modified |= updateState(oi.targetPackageName, oi.packageName, userId, 0);
            Slog.d(TAG, String.format("setEnabled modified = " + modified + " oi.targetPackageName = " + oi.targetPackageName));
            if (modified) {
                    mListener.onOverlaysChanged(oi.targetPackageName, userId);
                }

            return true;
        } catch (OverlayManagerSettings.BadKeyException e) {
            return false;
        }
    }
    
    ........省略部分代码.............
	private boolean updateState(@NonNull final String targetPackageName,
            @NonNull final String overlayPackageName, final int userId, final int flags)
            throws OverlayManagerSettings.BadKeyException {

        final PackageInfo targetPackage = mPackageManager.getPackageInfo(targetPackageName, userId);
        final PackageInfo overlayPackage = mPackageManager.getPackageInfo(overlayPackageName,
                userId);

        // Static RROs targeting to "android", ie framework-res.apk, are handled by native layers.
        // 最好不要overlay android原生的应用，我们这里能走进来是因为，isStaticOverlayPackage（）返回了false
        // isStaticOverlayPackage 是要非静态的overlay，一般可以在overlay apk的AndroidManifest.xml里面配置，默认为false
        if (targetPackage != null && overlayPackage != null &&
                !("android".equals(targetPackageName)
                        && overlayPackage.isStaticOverlayPackage())) {
            // 将 targetPackage 和 overlayPackage都传递给createIdmap
            mIdmapManager.createIdmap(targetPackage, overlayPackage, userId);
        }

        boolean modified = false;
        if (overlayPackage != null) {
            modified |= mSettings.setBaseCodePath(overlayPackageName, userId,
                    overlayPackage.applicationInfo.getBaseCodePath());
            modified |= mSettings.setCategory(overlayPackageName, userId,
                    overlayPackage.overlayCategory);
        }

        final @OverlayInfo.State int currentState = mSettings.getState(overlayPackageName, userId);
        final @OverlayInfo.State int newState = calculateNewState(targetPackage, overlayPackage,
                userId, flags);
        if (currentState != newState) {
            if (DEBUG) {
                Slog.d(TAG, String.format("%s:%d: %s -> %s",
                            overlayPackageName, userId,
                            OverlayInfo.stateToString(currentState),
                            OverlayInfo.stateToString(newState)));
            }
            modified |= mSettings.setState(overlayPackageName, userId, newState);
        }
        return modified;
    }

frameworks/base/services/core/java/com/android/server/om/IdmapManager.java

    ........省略部分代码.............
    boolean createIdmap(@NonNull final PackageInfo targetPackage,
            @NonNull final PackageInfo overlayPackage, int userId) {
        // unused userId: see comment in OverlayManagerServiceImpl.removeIdmapIfPossible
        Slog.d(TAG, "IdmapManager createIdmap callers=" + Debug.getCallers(10));
        if (DEBUG) {
            Slog.d(TAG, "create idmap for " + targetPackage.packageName + " and "
                    + overlayPackage.packageName + ",userId: "+userId);
        }
        final int sharedGid = UserHandle.getSharedAppGid(targetPackage.applicationInfo.uid);
        final String targetPath = targetPackage.applicationInfo.getBaseCodePath();
        final String overlayPath = overlayPackage.applicationInfo.getBaseCodePath();
        if (DEBUG) {
            Slog.d(TAG, "targetPath = " + targetPath + " overlayPath = " + overlayPath + " sharedGid = " + sharedGid);
         }
        try {
            if(mInstaller == null) {
                Slog.d(TAG, "mInstaller is null ");
            }
            // targetPath = /system/priv-app/CarHvacApp/CarHvacApp.apk
            // overlayPath = /vendor/overlay/hvacOverlay.apk
            // sharedGid 是com.android.hvac 的进程 uid
            mInstaller.idmap(targetPath, overlayPath, sharedGid);
        } catch (InstallerException e) {
            Slog.w(TAG, "failed to generate idmap for " + targetPath + " and "
                    + overlayPath + ": " + e.getMessage());
            return false;
        }
        return true;
    }

frameworks/base/services/core/java/com/android/server/pm/Installer.java

    public void idmap(String targetApkPath, String overlayApkPath, int uid)
            throws InstallerException {
        if (!checkBeforeRemote()) return;
        Slog.d(TAG, " Installer idmap start");
        try {
            if(mInstalld == null) {
                Slog.w(TAG, " mInstalld is null");
            }
            // mInstalld 是 native层的 InstalldNativeService
            mInstalld.idmap(targetApkPath, overlayApkPath, uid);
        } catch (Exception e) {
            throw InstallerException.from(e);
        }
    }

frameworks/native/cmds/installd/InstalldNativeService.cpp


binder::Status InstalldNativeService::idmap(const std::string& targetApkPath,
        const std::string& overlayApkPath, int32_t uid) {
    // 检查用户和路径权限
    ENFORCE_UID(AID_SYSTEM);
    CHECK_ARGUMENT_PATH(targetApkPath);
    CHECK_ARGUMENT_PATH(overlayApkPath);
    std::lock_guard<std::recursive_mutex> lock(mLock);

    const char* target_apk = targetApkPath.c_str();
    const char* overlay_apk = overlayApkPath.c_str();
    
    int idmap_fd = -1;
    char idmap_path[PATH_MAX];
    struct stat idmap_stat;
    bool outdated = false;

    // flatten_path（）就是使
    // idmap_path = vendor@overlay@hvacOverlay.apk@system@priv-app@CarHvacApp@CarHvacApp.apk@idmap
    // vendor@overlay@hvacOverlay.apk@system@priv-app@CarHvacApp@CarHvacApp.apk@idmap在实机 /data/resource-cache下
    if (flatten_path(IDMAP_PREFIX, IDMAP_SUFFIX, overlay_apk,target_apk,
                idmap_path, sizeof(idmap_path)) == -1) {
        ALOGE("idmap::InstalldNativeService cannot generate idmap path for overlay %s\n", overlay_apk);
        goto fail;
    }
    // 获取vendor@overlay@hvacOverlay.apk@system@priv-app@CarHvacApp@CarHvacApp.apk@idmap文件信息，并保存在idmap_sta中，
    //结构体 stat 就是保存了文件信息如，文件的设备编号、用户ID、文件字节数等
    
    if (stat(idmap_path, &idmap_stat)< 0) {
        outdated = true;
    } else {
        // 这里面会效验文件vendor@overlay@hvacOverlay.apk@system@priv-app@CarHvacApp@CarHvacApp.apk@idmap
        outdated = delete_stale_idmap(target_apk, overlay_apk, idmap_path, uid);
    }

    if (outdated) {
        idmap_fd = open(idmap_path, O_RDWR | O_CREAT | O_EXCL, 0644);
    } else {
        idmap_fd = open(idmap_path, O_RDWR);
    }

    if (idmap_fd < 0) {
        ALOGE("idmap::InstalldNativeService cannot open '%s' for output: %s\n", idmap_path, strerror(errno));
        goto fail;
    }
    //改变用户和group id
    if (fchown(idmap_fd, AID_SYSTEM, uid) < 0) {
        ALOGE("idmap::InstalldNativeService cannot chown '%s'\n", idmap_path);
        goto fail;
    }
    if (fchmod(idmap_fd, S_IRUSR | S_IWUSR | S_IRGRP | S_IROTH) < 0) {
        ALOGE("idmap::InstalldNativeService cannot chmod '%s'\n", idmap_path);
        goto fail;
    }

    if (!outdated) {
        close(idmap_fd);
        return ok();
    }

    pid_t pid;
    pid = fork();
    ALOGE("idmap::InstalldNativeService fork pid = %d\n", pid);
    if (pid == 0) {
        /* child -- drop privileges before continuing */
        if (setgid(uid) != 0) {
            ALOGE("setgid(%d) failed during idmap\n", uid);
            exit(1);
        }
        if (setuid(uid) != 0) {
            ALOGE("setuid(%d) failed during idmap\n", uid);
            exit(1);
        }
        if (flock(idmap_fd, LOCK_EX | LOCK_NB) != 0) {
            ALOGE("flock(%s) failed during idmap: %s\n", idmap_path, strerror(errno));
            exit(1);
        }
        // 会调到system/bin/installd
        run_idmap(target_apk, overlay_apk, idmap_fd);
        exit(1); /* only if exec call to idmap failed */
    } else {
        int status = wait_child(pid);
        if (status != 0) {
            ALOGE("idmap failed, status=0x%04x\n", status);
            goto fail;
        }
    }

    close(idmap_fd);
    return ok();
fail:
    if (idmap_fd >= 0) {
        close(idmap_fd);
        unlink(idmap_path);
    }
    return error();
}

........省略部分代码.............
static void run_idmap(const char *target_apk, const char *overlay_apk, int idmap_fd)
{
	// static constexpr const char *kIdMapPath = "/system/bin/idmap";
	// execl 执行bin文件，传递参数target_apk、overlay_apk 和 vendor@overlay@hvacOverlay.apk@system@priv-app@CarHvacApp@CarHvacApp.apk@idmap的文件描述符
    execl(kIdMapPath, kIdMapPath, "--fd", target_apk, overlay_apk,
            StringPrintf("%d", idmap_fd).c_str(), (char*)NULL);
    PLOG(ERROR) << "execl (" << kIdMapPath << ") failed";
}

frameworks/base/cmds/idmap/create.cpp

........省略部分代码.............
int idmap_create_fd(const char *target_apk_path, const char *overlay_apk_path, int fd)
{
    return create_and_write_idmap(target_apk_path, overlay_apk_path, fd, true) == 0 ?
        EXIT_SUCCESS : EXIT_FAILURE;
}


int create_and_write_idmap(const char *target_apk_path, const char *overlay_apk_path,
        int fd, bool check_if_stale)
{
    if (check_if_stale) {
        if (!is_idmap_stale_fd(target_apk_path, overlay_apk_path, fd)) {
            // already up to date -- nothing to do
            return 0;
        }
    }

    uint32_t *data = NULL;
    size_t size;
	// 终于看到了create_idmap， 从create_idmap 读出来的data，都会通过下面的write_idmap存到  vendor@overlay@hvacOverlay.apk@system@priv-app@CarHvacApp@CarHvacApp.apk@idmap中
    if (create_idmap(target_apk_path, overlay_apk_path, &data, &size) == -1) {
        return -1;
    }

    if (write_idmap(fd, data, size) == -1) {
        free(data);
        return -1;
    }

    free(data);
    return 0;
}

int create_idmap(const char *target_apk_path, const char *overlay_apk_path,
            uint32_t **data, size_t *size)
    {
        uint32_t target_crc, overlay_crc;
        if (get_zip_entry_crc(target_apk_path, AssetManager::RESOURCES_FILENAME,
    			&target_crc) == -1) {
            return -1;
        }
        if (get_zip_entry_crc(overlay_apk_path, AssetManager::RESOURCES_FILENAME,
    			&overlay_crc) == -1) {
            return -1;
        }
        ALOGD("create_idmap: target_crc = %d: overlay_crc = %d\n", target_crc, overlay_crc);
        // 最后会调到 AssetManager 的 createIdmap（），这里target_crc 和 overlay_crc应该都是读出来的效验值什么东西吧
        // base crc     0x8bd98da3 
        // overlay crc  0xca131849
        // idmap inspect vendor@overlay@hvacOverlay.apk@system@priv-app@CarHvacApp@CarHvacApp.apk@idmap 可以看到
        AssetManager am;
        bool b = am.createIdmap(target_apk_path, overlay_apk_path, target_crc, overlay_crc,
                data, size);
        return b ? 0 : -1;
    }

frameworks/base/libs/androidfw/AssetManager.cpp

........省略部分代码.............

bool AssetManager::createIdmap(const char* targetApkPath, const char* overlayApkPath,
        uint32_t targetCrc, uint32_t overlayCrc, uint32_t** outData, size_t* outSize)
{
    AutoMutex _l(mLock);
    const String8 paths[2] = { String8(targetApkPath), String8(overlayApkPath) };
    Asset* assets[2] = {NULL, NULL};
    bool ret = false;
    {
        ResTable tables[2];

        for (int i = 0; i < 2; ++i) {
            asset_path ap;
            ap.type = kFileTypeRegular;
            ap.path = paths[i];
            // resources.arsc是个资源索引表，这里具体我也不是很了解，反正可以理解就是它包含了apk所要用的资源并提供了id进行索引吧
            // 拿到targetApkPath的资源索引表
            assets[i] = openNonAssetInPathLocked("resources.arsc",
                    Asset::ACCESS_BUFFER, ap);
            if (assets[i] == NULL) {
                ALOGW("failed to find resources.arsc in %s\n", ap.path.string());
                goto exit;
            }
            if (tables[i].add(assets[i]) != NO_ERROR) {
                ALOGW("failed to add %s to resource table", paths[i].string());
                goto exit;
            }
        }
        // 在targetApkPath所属的对象 ResTable里面调用 createIdmap
        ret = tables[0].createIdmap(tables[1], targetCrc, overlayCrc,
                targetApkPath, overlayApkPath, (void**)outData, outSize) == NO_ERROR;
                
    }

exit:
    delete assets[0];
    delete assets[1];
    return ret;
}

frameworks/base/libs/androidfw/ResourceTypes.cpp
到这里整个createIdmap就算到调用到最后了，至于createIdmap里面细节 请参考这里.


status_t ResTable::createIdmap(const ResTable& overlay,
        uint32_t targetCrc, uint32_t overlayCrc,
        const char* targetPath, const char* overlayPath,
        void** outData, size_t* outSize) const
{
    // see README for details on the format of map
    if (mPackageGroups.size() == 0) {
        ALOGW("idmap: target package has no package groups, cannot create idmap\n");
        return UNKNOWN_ERROR;
    }

    if (mPackageGroups[0]->packages.size() == 0) {
        ALOGW("idmap: target package has no packages in its first package group, "
                "cannot create idmap\n");
        return UNKNOWN_ERROR;
    }

    // The number of resources overlaid that were not explicitly marked overlayable.
    size_t forcedOverlayCount = 0u;

    KeyedVector<uint8_t, IdmapTypeMap> map;

    // overlaid packages are assumed to contain only one package group
    const PackageGroup* pg = mPackageGroups[0];
    // starting size is header
    *outSize = ResTable::IDMAP_HEADER_SIZE_BYTES;

    // target package id and number of types in map
    *outSize += 2 * sizeof(uint16_t);

    // overlay packages are assumed to contain only one package group
    const ResTable_package* overlayPackageStruct = overlay.mPackageGroups[0]->packages[0]->package;
    char16_t tmpName[sizeof(overlayPackageStruct->name)/sizeof(overlayPackageStruct->name[0])];
    strcpy16_dtoh(tmpName, overlayPackageStruct->name, sizeof(overlayPackageStruct->name)/sizeof(overlayPackageStruct->name[0]));
    const String16 overlayPackage(tmpName);

    for (size_t typeIndex = 0; typeIndex < pg->types.size(); ++typeIndex) {
        const TypeList& typeList = pg->types[typeIndex];
        if (typeList.isEmpty()) {
            continue;
        }

        const Type* typeConfigs = typeList[0];

        IdmapTypeMap typeMap;
        typeMap.overlayTypeId = -1;
        typeMap.entryOffset = 0;

        for (size_t entryIndex = 0; entryIndex < typeConfigs->entryCount; ++entryIndex) {
            uint32_t resID = Res_MAKEID(pg->id - 1, typeIndex, entryIndex);
            resource_name resName;
            if (!this->getResourceName(resID, false, &resName)) {
                if (typeMap.entryMap.isEmpty()) {
                    typeMap.entryOffset++;
                }
                continue;
            }

            uint32_t typeSpecFlags = 0u;
            const String16 overlayType(resName.type, resName.typeLen);
            const String16 overlayName(resName.name, resName.nameLen);
            uint32_t overlayResID = overlay.identifierForName(overlayName.string(),
                                                              overlayName.size(),
                                                              overlayType.string(),
                                                              overlayType.size(),
                                                              overlayPackage.string(),
                                                              overlayPackage.size(),
                                                              &typeSpecFlags);
            if (overlayResID == 0) {
                // No such target resource was found.
                if (typeMap.entryMap.isEmpty()) {
                    typeMap.entryOffset++;
                }
                continue;
            }

            // Now that we know this is being overlaid, check if it can be, and emit a warning if
            // it can't.
            if ((dtohl(typeConfigs->typeSpecFlags[entryIndex]) &
                    ResTable_typeSpec::SPEC_OVERLAYABLE) == 0) {
                forcedOverlayCount++;
            }

            if (typeMap.overlayTypeId == -1) {
                typeMap.overlayTypeId = Res_GETTYPE(overlayResID) + 1;
            }

            if (Res_GETTYPE(overlayResID) + 1 != static_cast<size_t>(typeMap.overlayTypeId)) {
                ALOGE("idmap: can't mix type ids in entry map. Resource 0x%08x maps to 0x%08x"
                        " but entries should map to resources of type %02zx",
                        resID, overlayResID, typeMap.overlayTypeId);
                return BAD_TYPE;
            }

            if (typeMap.entryOffset + typeMap.entryMap.size() < entryIndex) {
                // pad with 0xffffffff's (indicating non-existing entries) before adding this entry
                size_t index = typeMap.entryMap.size();
                size_t numItems = entryIndex - (typeMap.entryOffset + index);
                if (typeMap.entryMap.insertAt(0xffffffff, index, numItems) < 0) {
                    return NO_MEMORY;
                }
            }
            typeMap.entryMap.add(Res_GETENTRY(overlayResID));
        }

        if (!typeMap.entryMap.isEmpty()) {
            if (map.add(static_cast<uint8_t>(typeIndex), typeMap) < 0) {
                return NO_MEMORY;
            }
            *outSize += (4 * sizeof(uint16_t)) + (typeMap.entryMap.size() * sizeof(uint32_t));
        }
    }

    if (map.isEmpty()) {
        ALOGW("idmap: no resources in overlay package present in base package");
        return UNKNOWN_ERROR;
    }

    if ((*outData = malloc(*outSize)) == NULL) {
        return NO_MEMORY;
    }

    uint32_t* data = (uint32_t*)*outData;
    *data++ = htodl(IDMAP_MAGIC);
    *data++ = htodl(ResTable::IDMAP_CURRENT_VERSION);
    *data++ = htodl(targetCrc);
    *data++ = htodl(overlayCrc);
    const char* paths[] = { targetPath, overlayPath };
    for (int j = 0; j < 2; ++j) {
        char* p = (char*)data;
        const char* path = paths[j];
        const size_t I = strlen(path);
        if (I > 255) {
            ALOGV("path exceeds expected 255 characters: %s\n", path);
            return UNKNOWN_ERROR;
        }
        for (size_t i = 0; i < 256; ++i) {
            *p++ = i < I ? path[i] : '\0';
        }
        data += 256 / sizeof(uint32_t);
    }
    const size_t mapSize = map.size();
    uint16_t* typeData = reinterpret_cast<uint16_t*>(data);
    *typeData++ = htods(pg->id);
    *typeData++ = htods(mapSize);
    for (size_t i = 0; i < mapSize; ++i) {
        uint8_t targetTypeId = map.keyAt(i);
        const IdmapTypeMap& typeMap = map[i];
        *typeData++ = htods(targetTypeId + 1);
        *typeData++ = htods(typeMap.overlayTypeId);
        *typeData++ = htods(typeMap.entryMap.size());
        *typeData++ = htods(typeMap.entryOffset);

        const size_t entryCount = typeMap.entryMap.size();
        uint32_t* entries = reinterpret_cast<uint32_t*>(typeData);
        for (size_t j = 0; j < entryCount; j++) {
            entries[j] = htodl(typeMap.entryMap[j]);
        }
        typeData += entryCount * 2;
    }

    if (forcedOverlayCount > 0) {
        ALOGW("idmap: overlaid %zu resources not marked overlayable", forcedOverlayCount);
    }

    return NO_ERROR;
}

createIdmap之后就会进行activity重启，见原理三.

干一行，爱一行
关注
  • 1
    点赞
  • 踩
  • 4
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
Android idmap 学习
蜗牛的博客
03-27 5505
代码路径: frameworks/base/cmds/idmap/编译方法: make idmap程序入口: main方法位于idmap.cppBinary在手机的路径: system/bin/idmap查看帮助信息: adb shell idmap –help帮助信息解读: 名字: idmap - 创建或者显示idmap文件. 概要: idmap –help 查看帮助信息. idmap –f
Runtime-Resource-overlay-Target-Package:索尼针对Android的运行时资源覆盖框架的简单实现
05-20
运行时资源覆盖目标包 索尼针对Android的运行时资源覆盖框架的简单实现 这是一个目标软件包。 你可以在找到覆盖包 [阅读有关Sony RRO的更多信息]（ ） 步骤安装和卸载覆盖程序包。 下载目标包apk文件。 安装目标APK文件。 （将安装在/ data / app /中） 通过USB电缆连接手机 运行ADB设备以查看ADB是否检测到该设备。 运行“ ADB root” 运行“ ADB重新挂载”（将重新挂载系统分区） 从下载叠加包apk文件 运行ADB推送“ overlay_package_name.apk” / system / vendor / overlay（这将安装覆盖程序包） 重启手机 您将能够看到更改 现在从手机上卸载覆盖程序包。 （更改仍未恢复） 从adb shell运行“ rm overlay_package_name.apk” 更改将被还原。
Google Maps API Documentation
weixin_34150830的博客
07-02 80
 http://www.google.com/apis/maps/documentation/ The Google Maps API lets you embed Google Maps in your own web pages. To use the API, you need to sign up for an API key and follow the instructions be...
PackageManagerService启动详解(八)之扫描data分区应用安装目录阶段流程分析
IT先森
03-26 7446
PKMS启动详解(八)之BOOT_PROGRESS_PMS_DATA_SCAN_START阶段流程分析 Android PackageManagerService系列博客目录: PKMS启动详解系列博客概要 PKMS启动详解(一)之整体流程分析 PKMS启动详解(二)之怎么通过packages.xml对已安装应用信息进行持久化管理? PKMS启动详解(三)之BOOT_PROGRESS_PMS_START流程分析 PKMS启动详解(四)之Android包信息体和包解析器(上) PKMS启动详解(五)之An
Android 资源加载机制剖析
weixin_33834628的博客
03-27 225
前言 上一篇文章，讲到了Android中进程的启动和一个Activity的创建到显示流程，现在本篇要分析的是在Android中资源的装载机制，例如字符串资源，图片资源是如何被装载的。这里将从字符串和图片两种类型资源展开分析，同时对于后面所利用的资源装载的内容也会做简单的分析。 Resources源码剖析 对于资源的装载机制，这里核心的几...
Android 0.9 API改变中文总结
书生杂记
04-09 5676
最新的Android 0.9 SDK和m5-rc15相比API有什么改变呢? 下面我们一起来看看，有关详细的Package以及API的添加、删除、修改如下：   一、移除了下面的Packageandroid.awt    android.telephony.gsm.stk    android.test.mock    com.google.android.gtalkservice   
Android资源管理中的Runtime Resources Overlay-------之PMS、installd和idmap的处理(二)
大勇的专栏
07-17 2542
前面我们对RRO(Runtime Resources Overlay)
Android资源管理中的Runtime Resources Overlay-------之overlay包的加载（四）
大勇的专栏
07-19 1930
        前文我们介绍了idmap文件的生成过程，剩下来的就是overlay package和idmap的加载和生效了。 overlay package和idmap文件的加载         我们在Android资源管理中的Runti...
Android 5.0 idmap管理
oman111的专栏
05-05 4322
Android 5.0 idmap管理
android 系统如何优雅的debug调试overlay
android 系统定制开发那些事
05-01 1310
今天再来水两篇文章：来说说如何去debug overlay,什么是overlay 就不用我说了。命令很简单，adb shell 下执行cmd overlay. :/ # cmd overlay Overlay manager (overlay) commands: help Print this help text. dump [--verbose] [--user USER_ID] [[FIELD] PACKAGE] （打出所有overlay 的包和被overlay的包以及状态）
RRO.diff.zip
01-14
RRO.diff.zip
android主题设置与主题切换
06-13
android设置多种主题风格，可实现背景，对话框，按钮风格的一键切换
android动态加载外部资源文件
02-27
读取本地不同的资源文件apk，获取不同的图片、文字和颜色，详情请看https://blog.csdn.net/zyw0101/article/details/87939253
Docker-RRO:Docker 革命 R 开放
06-26
Docker-RRO 这个 repo 当前包含一个用于在 Ubuntu 14.04 上打开 Revolution R 的 Docker 文件 有关更多信息，请访问 MRAN 网站： TODO：添加 CentOS Docker 文件
PMS-adb install安装应用流程（Android L）
wyw1015
10-12 742
第一次画流程图画的不好 通过adb install安装应用时对framework来说会首先调用runInstall()方法 private int runInstall(){ int installFlags = 0; int userId = UserHandle.USER_ALL; String installerPackageName = n...
Android 框架实现分析 - 应用 - 细节
luansxx的专栏
10-28 786
关键目录 应用信息存放结构： /etc/ permissions/ *.xml（系统权限信息） /data/（android_data_dir，ENV:ANDROID_DATA） app/（android_app_dir，APP_SUBDIR） app-private/（android_app_private_dir，PRIVATE_APP_SUBDIR） app-lib/（android_app_lib_dir，APP_LIB_SUBDIR） c...
AndroidP RRO overlay （一）
android
01-07 1716
Android RRO overlay1、Android P overlay1.2 静态 overlay原理1.3 动态overlay 1、Android P overlay 新年第一帖，最近又开始接手Android overlay了，说实话一开始接手overlay的时候我是拒绝的，因为我不是很喜欢和界面打交道，但是总是要恰饭的，结果越干还越有意思，这里就给大家分享一下，我的心得。 干overlay的应该都知道，android 的overlay分为静态overlay（SRO）和动态overlay（RRO），
Android，主题切换/换肤/RRO
不止于代码
04-16 654
Android 白天黑夜模式切换 Android实现日夜间模式的三种常用方法（一） Android实现日夜间模式的三种常用方法（二） Android实现日夜间模式的三种常用方法（三） Android主题换肤 无缝切换 Android换肤技术总结 ......
Android 基础库 - 插件框架 - 资源覆盖
luansxx的专栏
10-08 290
往期参考： 需求定义 基本原理 插件实现 插件框架代码已经开源，欢迎使用并反馈。https://github.com/cmguo/android-plugins 多目标 有时候多个应用使用了相同的资源，为了方便定制资源包的管理，需要一个定制资源包可以同时覆盖对多个目标应用。 但是相同资源在每个应用中的资源名称定义的一般都不一样，这就需要我们对Android的ID映射（idmap）机制进...
\"BUILD_RRO_PACKAGE\":
最新发布
04-25
\"BUILD_RRO_PACKAGE\" 是一个用于 Android 应用开发的工具。它是 Resource Overlays 的缩写，可以用来创建和管理应用程序的资源覆盖包。资源覆盖包是一种在不修改原始应用程序代码的情况下，改变应用程序外观和行为的方法。 使用 BUILD_RRO_PACKAGE 工具，开发者可以修改应用程序的资源文件，如布局、颜色、字符串等，以实现个性化的界面效果。这样，开发者就可以在不修改应用程序源代码的情况下，定制和改变应用程序的外观和风格，以满足不同用户的需求。 BUILD_RRO_PACKAGE 提供了一套命令行工具和相关的配置文件，开发者可以使用这些工具和配置文件来创建和管理资源覆盖包。通过 BUILD_RRO_PACKAGE，开发者可以轻松地修改和定制应用程序的外观和行为，同时保持原始应用程序的稳定性和可维护性。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值