APK安装过程

最新推荐文章于 2023-05-19 17:04:48 发布
最新推荐文章于 2023-05-19 17:04:48 发布
阅读量512 收藏
点赞数
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_43724742/article/details/96006157
版权
安装过程：

PackageManagerService的installStage方法负责安装应用:

void installStage(){
	 final Message msg = mHandler.obtainMessage(INIT_COPY);
	 final InstallParams params = new InstallParams(origin, null, observer,
                sessionParams.installFlags, installerPackageName, sessionParams.volumeUuid,
                verificationInfo, user, sessionParams.abiOverride,
                sessionParams.grantedRuntimePermissions, certificates, installReason);//2
     params.setTraceMethod("installStage").setTraceCookie(System.identityHashCode(params));
     msg.obj = params;
     //PackageHandler发送一个INIT_COPY标记，和InstallParams参数
     mHandler.sendMessage(msg);
}

PackageHandler对INIT_COPY消息的处理：

case INIT_COPY: {
 	HandlerParams params = (HandlerParams) msg.obj;
 	if (!mBound) {					//用于标识是否绑定了DefaultContainerService，默认值为false
 		connectToService()			//绑定服务，并把mBound置为true，并发送MCS_BOUND类型的message
 	}else{
		//绑定服务成功，将请求添加到ArrayList类型的mPendingInstalls中，等待处理
        mPendingInstalls.add(idx, params);
	}
}

DefaultContainerService是用于检查和复制可移动文件的服务，这是一个比较耗时的操作，因此DefaultContainerService没有和PMS运行在同一进程中

PackageHandler对MCS_BOUND消息的处理：

if (mPendingInstalls.size() > 0) {
	//从安装列表里获取第一个任务
	HandlerParams params = mPendingInstalls.get(0);
	if (params.startCopy()) {		//开始复制APK，完成后返回true
		//如果APK安装成功，删除本次安装请求
        if (mPendingInstalls.size() > 0) {
        	mPendingInstalls.remove(0);
        }
		if (mPendingInstalls.size() == 0) {
			//如果没有安装请求了，发送解绑服务的message
			removeMessages(MCS_UNBIND);
            Message ubmsg = obtainMessage(MCS_UNBIND);
            sendMessageDelayed(ubmsg, 10000);
		} else {
			//如果还有其他的安装请求，接着发送MCS_BOUND消息继续处理剩余的安装请求      
			 mHandler.sendEmptyMessage(MCS_BOUND);
		}
	}
}

HandlerParams.startCopy()方法：

 	final boolean startCopy() {
            boolean res;
            try {
                if (++mRetries > MAX_RETRIES) {
                 	//startCopy方法尝试的次数，超过了4次，就放弃这个安装请求
                    mHandler.sendEmptyMessage(MCS_GIVE_UP);
                    handleServiceError();
                    return false;
                } else {
                    handleStartCopy();
                    res = true;
                }
            } catch (RemoteException e) {
                mHandler.sendEmptyMessage(MCS_RECONNECT);
                res = false;
            }
            handleReturnCode();
            return res;
    }

InstallParams.handleStartCopy()方法：

 	public void handleStartCopy() throws RemoteException {
            //onSd：安装到SD卡;   
            final boolean onSd = (installFlags & PackageManager.INSTALL_EXTERNAL) != 0;
            //onInt：内部存储即Data分区;
            final boolean onInt = (installFlags & PackageManager.INSTALL_INTERNAL) != 0;
            //ephemeral：安装到临时存储（Instant Apps安装）        
            final boolean ephemeral = (installFlags & PackageManager.INSTALL_INSTANT_APP) != 0;
            PackageInfoLite pkgLite = null;
            if (onInt && onSd) {
              	// APK不能同时安装在SD卡和Data分区
                ret = PackageManager.INSTALL_FAILED_INVALID_INSTALL_LOCATION;
            } else if (onSd && ephemeral) {
            	//安装标志冲突，Instant Apps不能安装到SD卡中
                ret = PackageManager.INSTALL_FAILED_INVALID_INSTALL_LOCATION;
            } else {
                 //获取APK的少量的信息
                pkgLite = mContainerService.getMinimalPackageInfo(origin.resolvedPath, installFlags,
                        packageAbiOverride);
            if (ret == PackageManager.INSTALL_SUCCEEDED) {
                 //判断安装的位置
                int loc = pkgLite.recommendedInstallLocation;
                if (loc == PackageHelper.RECOMMEND_FAILED_INVALID_LOCATION) {
                    ret = PackageManager.INSTALL_FAILED_INVALID_INSTALL_LOCATION;
                } else if (loc == PackageHelper.RECOMMEND_FAILED_ALREADY_EXISTS) {
                    ret = PackageManager.INSTALL_FAILED_ALREADY_EXISTS;
                } 
                ...
                }else{
                  //确定APK的安装位置
                  loc = installLocationPolicy(pkgLite);
                  ...
                }
            }
            //根据InstallParams创建InstallArgs对象
            //InstallParams有三个子类，分别是FileInstallArgs,AsecInstallArgs,MoveInsteaaArgs
            //FileInstallArgs用于安装到内部存储（Data分区）
            //AsecInstallArgs用于安装到ASEC（SD卡）
            //MoveInsteaaArgs用于处理已安装的APK的移动逻辑
            final InstallArgs args = createInstallArgs(this);//3
            mArgs = args;
            if (ret == PackageManager.INSTALL_SUCCEEDED) {
                   ...
                if (!origin.existing && requiredUid != -1
                        && isVerificationEnabled(
                              verifierUser.getIdentifier(), installFlags, installerUid)) {
                      ...
                } else{
                	//复制APK到特定的地址
                    ret = args.copyApk(mContainerService, true);
                }
            }
            mRet = ret;
      }

APK安装：

  private void processPendingInstall(final InstallArgs args, final int currentStatus) {
        mHandler.post(new Runnable() {
            public void run() {
                mHandler.removeCallbacks(this);
                PackageInstalledInfo res = new PackageInstalledInfo();
                res.setReturnCode(currentStatus);
                res.uid = -1;
                res.pkg = null;
                res.removedInfo = null;
                if (res.returnCode == PackageManager.INSTALL_SUCCEEDED) {
                    //安装前处理
                    args.doPreInstall(res.returnCode);
                    synchronized (mInstallLock) {
                    	//安装的具体过程
                        installPackageTracedLI(args, res);
                    }
                    //安装后收尾
                    args.doPostInstall(res.returnCode, res.uid);
                }
              ...
            }
        });
    }

PackageManagerService.installPackageLI()方法:

private void installPackageLI(InstallArgs args, PackageInstalledInfo res) {
    PackageParser pp = new PackageParser();
    pp.setSeparateProcesses(mSeparateProcesses);
    pp.setDisplayMetrics(mMetrics);
    pp.setCallback(mPackageParserCallback);
    final PackageParser.Package pkg;
    try {
        //解析APK,解析过程会在后面具体描述
        pkg = pp.parsePackage(tmpPackageFile, parseFlags);
    } catch (PackageParserException e) {
     
    }
    ...
    pp = null;
    String oldCodePath = null;
    boolean systemApp = false;
    synchronized (mPackages) {
        // 检查APK是否已经存在，用来确认需要替换APK，还是使用全新的APK安装
        if ((installFlags & PackageManager.INSTALL_REPLACE_EXISTING) != 0) {
            String oldName = mSettings.getRenamedPackageLPr(pkgName);//获取没被改名前的包名
            if (pkg.mOriginalPackages != null
                    && pkg.mOriginalPackages.contains(oldName)
                    && mPackages.containsKey(oldName)) {
                pkg.setPackageName(oldName);//2
                pkgName = pkg.packageName;
                replace = true;//设置标志位表示是替换安装
            } 
            ...
        }
        PackageSetting ps = mSettings.mPackages.get(pkgName);
        //查看Settings中是否存有要安装的APK的信息，如果有就获取签名信息
        if (ps != null) {
            PackageSetting signatureCheckPs = ps;
            if (pkg.applicationInfo.isStaticSharedLibrary()) {
                SharedLibraryEntry libraryEntry = getLatestSharedLibraVersionLPr(pkg);
                if (libraryEntry != null) {
                    signatureCheckPs = mSettings.getPackageLPr(libraryEntry.apk);
                }
            }
            //APK签名校验
            if (shouldCheckUpgradeKeySetLP(signatureCheckPs, scanFlags)) {
                if (!checkUpgradeKeySetLP(signatureCheckPs, pkg)) {
                    res.setError("xxx");
                    return;
                }
            } 
            ...
        }

        int N = pkg.permissions.size();
        for (int i = N-1; i >= 0; i--) {
           //遍历每个权限，对权限进行处理
            PackageParser.Permission perm = pkg.permissions.get(i);
            BasePermission bp = mSettings.mPermissions.get(perm.info.name);
         
            }
        }
    }
    if (systemApp) {
        if (onExternal) {
            //系统APP不能在SD卡上替换安装
            res.setError(INSTALL_FAILED_INVALID_INSTALL_LOCATION,
                    "Cannot install updates to system apps on sdcard");
            return;
        } else if (instantApp) {
            //系统APP不能被Instant App替换
            res.setError(INSTALL_FAILED_INSTANT_APP_INVALID,
                    "Cannot update a system app with an instant app");
            return;
        }
    }
    ...
    //重命名临时文件
    //新的APK包会在名字后面添加1作为ID，每次升级这个数字都会+1
    if (!args.doRename(res.returnCode, pkg, oldCodePath)) {
        res.setError(INSTALL_FAILED_INSUFFICIENT_STORAGE, "Failed rename");
        return;
    }

    startIntentFilterVerifications(args.user.getIdentifier(), replace, pkg);

    try (PackageFreezer freezer = freezePackageForInstall(pkgName, installFlags,
            "installPackageLI")) {
        if (replace) {
         	//替换安装   
            replacePackageLIF(pkg, parseFlags, scanFlags | SCAN_REPLACING, args.user,
                    installerPackageName, res, args.installReason);
        } else {
        	//安装新的APK
            installNewPackageLIF(pkg, parseFlags, scanFlags | SCAN_DELETE_DATA_ON_FAILURES,
                    args.user, installerPackageName, volumeUuid, res, args.installReason);
        }
    }

    synchronized (mPackages) {
        final PackageSetting ps = mSettings.mPackages.get(pkgName);
        if (ps != null) {
            //更新应用程序所属的用户
            res.newUsers = ps.queryInstalledUsers(sUserManager.getUserIds(), true);
            ps.setUpdateAvailable(false /*updateAvailable*/);
        }
        ...
    }
}

安装全新的APK：

 private void installNewPackageLIF(PackageParser.Package pkg, final int policyFlags,
            int scanFlags, UserHandle user, String installerPackageName, String volumeUuid,
            PackageInstalledInfo res, int installReason) {
        ...
        try {
            //扫描APK,将APK的信息存储在PackageParser.Package类型的newPackage中;
            //一个Package的信息包含了1个base APK以及0个或者多个split APK。
            PackageParser.Package newPackage = scanPackageTracedLI(pkg, policyFlags, scanFlags,
                    System.currentTimeMillis(), user);
            //更新Settings信息
            updateSettingsLI(newPackage, installerPackageName, null, res, user, installReason);
            if (res.returnCode == PackageManager.INSTALL_SUCCEEDED) {
                //安装成功后，为新安装的应用程序准备数据
                prepareAppDataAfterInstallLIF(newPackage);

            } else {
                //安装失败则删除APK
                deletePackageLIF(pkgName, UserHandle.ALL, false, null,
                        PackageManager.DELETE_KEEP_DATA, res.removedInfo, true, null);
            }
        } catch (PackageManagerException e) {
            res.setError("Package couldn't be installed in " + pkg.codePath, e);
        }
        Trace.traceEnd(TRACE_TAG_PACKAGE_MANAGER);
}

APK的解析过程：

 public Package parsePackage(File packageFile, int flags, boolean useCaches)
            throws PackageParserException {
        Package parsed = useCaches ? getCachedResult(packageFile, flags) : null;
        if (parsed != null) {
            return parsed;
        }
        if (packageFile.isDirectory()) {		//packageFile是一个目录，说明这是一个Mutiple APK
            parsed = parseClusterPackage(packageFile, flags);
        } else {
            parsed = parseMonolithicPackage(packageFile, flags);
        }
        cacheResult(packageFile, flags, parsed);
        return parsed;
}

解析Mutiple APK：

private Package parseClusterPackage(File packageDir, int flags) throws PackageParserException {
		//解析APK目录
	    final PackageLite lite = parseClusterPackageLite(packageDir, 0);
	    //mOnlyCoreApps = 是否只解析核心APK
	    //lite.coreApp = 当前包是否包含核心应用
        if (mOnlyCoreApps && !lite.coreApp) {	
            throw new PackageParserException(INSTALL_PARSE_FAILED_MANIFEST_MALFORMED,
                    "Not a coreApp: " + packageDir);
        }
        ...
        try {
            final AssetManager assets = assetLoader.getBaseAssetManager();
            final File baseApk = new File(lite.baseCodePath);
            //解析BaseAPK
            final Package pkg = parseBaseApk(baseApk, assets, flags);
            if (pkg == null) {
                throw new PackageParserException(INSTALL_PARSE_FAILED_NOT_APK,
                        "Failed to parse base APK: " + baseApk);
            }
            if (!ArrayUtils.isEmpty(lite.splitNames)) {
            	//获取APK分包的数量	
                final int num = lite.splitNames.length;
                pkg.splitNames = lite.splitNames;
                pkg.splitCodePaths = lite.splitCodePaths;
                pkg.splitRevisionCodes = lite.splitRevisionCodes;
                pkg.splitFlags = new int[num];
                pkg.splitPrivateFlags = new int[num];
                pkg.applicationInfo.splitNames = pkg.splitNames;
                pkg.applicationInfo.splitDependencies = splitDependencies;
                //依次解析每个其他APK文件
                for (int i = 0; i < num; i++) {
                    final AssetManager splitAssets = assetLoader.getSplitAssetManager(i);
                    parseSplitApk(pkg, i, splitAssets, flags);
                }
            }
            pkg.setCodePath(packageDir.getAbsolutePath());
            pkg.setUse32bitAbi(lite.use32bitAbi);
            return pkg;
        } finally {
            IoUtils.closeQuietly(assetLoader);
        }
    }

PackageParser.parseBaseApk方法解析BaseAPK：

 private Package parseBaseApk(String apkPath, Resources res, XmlResourceParser parser, int flags,
            String[] outError) throws XmlPullParserException, IOException {
        //创建Package对象，Package对象中包含四大组件的集合，解析之后会将四个组件填写到Package对象中
        final Package pkg = new Package(pkgName);
        //从资源中提取自定义属性集com.android.internal.R.styleable.AndroidManifest得到TypedArray 
        TypedArray sa = res.obtainAttributes(parser,
                com.android.internal.R.styleable.AndroidManifest);//2
        //使用typedarray获取AndroidManifest中的versionCode赋值给Package的对应属性        
        pkg.mVersionCode = pkg.applicationInfo.versionCode = sa.getInteger(
                com.android.internal.R.styleable.AndroidManifest_versionCode, 0);
        pkg.baseRevisionCode = sa.getInteger(
                com.android.internal.R.styleable.AndroidManifest_revisionCode, 0);
        pkg.mVersionName = sa.getNonConfigurationString(
                com.android.internal.R.styleable.AndroidManifest_versionName, 0);
        if (pkg.mVersionName != null) {
            pkg.mVersionName = pkg.mVersionName.intern();
        }
        pkg.coreApp = parser.getAttributeBooleanValue(null, "coreApp", false);//3
        //获取资源后要回收
        sa.recycle();
        //主要用来解析APK的AndroidManifest中的各个标签，比如application、permission、uses-sdk、feature-group等等
        return parseBaseApkCommon(pkg, null, res, parser, flags, outError);
    }

解析四大组件：

  private boolean parseBaseApplication(Package owner, Resources res,
            XmlResourceParser parser, int flags, String[] outError)
        throws XmlPullParserException, IOException {
        ...
        while ((type = parser.next()) != XmlPullParser.END_DOCUMENT
                && (type != XmlPullParser.END_TAG || parser.getDepth() > innerDepth)) {
            if (type == XmlPullParser.END_TAG || type == XmlPullParser.TEXT) {
                continue;
            }
            String tagName = parser.getName();
            if (tagName.equals("activity")) {				//解析activity标签
                Activity a = parseActivity(owner, res, parser, flags, outError, false,
                        owner.baseHardwareAccelerated);		//解析activity标签并得到一个Activity对象
                if (a == null) {
                    mParseError = PackageManager.INSTALL_PARSE_FAILED_MANIFEST_MALFORMED;
                    return false;
                }
                owner.activities.add(a);				//将解析得到的Activity对象保存在Package的列表activities中
            } else if (tagName.equals("receiver")) {
                Activity a = parseActivity(owner, res, parser, flags, outError, true, false);
                if (a == null) {
                    mParseError = PackageManager.INSTALL_PARSE_FAILED_MANIFEST_MALFORMED;
                    return false;
                }
                owner.receivers.add(a);
            } else if (tagName.equals("service")) {
                Service s = parseService(owner, res, parser, flags, outError);
                if (s == null) {
                    mParseError = PackageManager.INSTALL_PARSE_FAILED_MANIFEST_MALFORMED;
                    return false;
                }
                owner.services.add(s);
            } else if (tagName.equals("provider")) {
                Provider p = parseProvider(owner, res, parser, flags, outError);
                if (p == null) {
                    mParseError = PackageManager.INSTALL_PARSE_FAILED_MANIFEST_MALFORMED;
                    return false;
                }
                owner.providers.add(p);
            } 
        }
}

Package数据结构：

public final static class Package implements Parcelable {
    public String packageName;
    public String manifestPackageName;
    public String[] splitNames;
    public String volumeUuid;
    public String codePath;
    public String baseCodePath;
    ...
    public ApplicationInfo applicationInfo = new ApplicationInfo();
    public final ArrayList<Permission> permissions = new ArrayList<Permission>(0);
    public final ArrayList<PermissionGroup> permissionGroups = new ArrayList<PermissionGroup>(0);
    public final ArrayList<Activity> activities = new ArrayList<Activity>(0);//1
    public final ArrayList<Activity> receivers = new ArrayList<Activity>(0);
    public final ArrayList<Provider> providers = new ArrayList<Provider>(0);
    public final ArrayList<Service> services = new ArrayList<Service>(0);
    public final ArrayList<Instrumentation> instrumentation = new ArrayList<Instrumentation>(0);
}

这里的Activity，Provider，Permission是PackageParser的静态内部类，它们都继承基类Component，解析的结果会产生一个Package对象，里面的成员代表了这个APK中包含了哪些组件

参考：
https://blog.csdn.net/itachi85/article/details/81321138
https://blog.csdn.net/itachi85/article/details/84311559

qfan95
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
XAPK安装程序.apk
02-16
亲测可用，安装到Android手机或平板，打卡XAPK安装程序，会自动手撕鸡手机或平板中的Xapk格式文件，点击即可安装Xapk格式的APP。
android 安装应用过程
Lud的博客
05-04 2296
文章目录管理会话的服务 - PackageInstallerService安装应用的开端应用安装的第一阶段-复制文件第二阶段-装载应用 PMS 在创建的时候创建了PackageInstallerService，所以在安装应用之前先了解一下 PackageInstallerService ：用于管理安装的服务 附带的是 Android 9.0 的源码 管理会话的服务 - PackageInstallerService PackageInstallerService 主要用于管理安装会话服务，可以通过
Android PackageManagerService总结(四) APK安装流程
u012514113的专栏
03-25 3620
管理本地apk，主要包括安装、删除 本篇文章重点介绍一下apk安装流程
Android之限制安装apk的个数
liangtianmeng的专栏
05-22 1516
了解apk安装流程的都知道apk的安装主要涉及的frameworks层下的PackageManagerService.java类的installPackageLI方法。 找到，添加，本例以6个为例： try (PackageFreezer freezer = freezePackageForInstall(pkgName, installFlags, "ins...
一文带你搞懂APK安装过程
chuyouyinghe的专栏
02-28 3872
本篇从用户感受的APK安装讲起，分别详细梳理了 包管理器服务——PackageManagerService 的服务开启、初始化扫描过程；然后分析了对应原生系统的安装过程及页面；接着就是详细分析了安装流程，包括创建Session 发送APK、PMS中的APK拷贝操作、包括APK解析校验和dexOpt等具体安装流程；最后是安装结果的发送。内容确实很多，但是我们只需要重点了解 PMS的初始化、APK安装 的整体流程即可，无需关注繁杂的细节。
APK安装流程:点击下载应用了解安装的全过程
m0_64420071的博客
07-08 3825
一讲到APK安装流程，它有四种安装方式：先说个大概：1.将APK的信息通过IO流的形式写入到PackageInstaller.Session中。
APK安装过程及原理详解
12-19
APK安装过程及原理详解
SAI:Android拆分APK安装程序
05-08
拆分APK安装程序SAI： Filepicker库： SAI（Split APKs安装程序）是一个Android应用程序，可让您安装Split APK（例如，作为Android App Bundle分发的APK）。 它具有无根和无根安装方法。SAI的状态SAI有点死，因为我...
Android APK文件结构 完整打包编译的流程 APK安装过程 详解
01-03
Android apk文件结构 打包编译的流程Android官网 配置构建 流程Configure your buildThe build processAPK文件... zipAlign阶段APK安装过程 不管是 Android 知识的学习 还是其他知识的学习 ，最好还是去 官网 学习。
java实现静默安装apk
09-03
本文给大家分享的是如何实现偷偷的把一个安卓apk应用安装到手机上，而且不显示确认框，主要是通过反射来实现，好了，小伙伴们仔细看下代码吧，有需要的小伙伴可以参考下。
androidP: apk安装流程
zhuowalun8427的博客
12-28 5158
一、Android应用安装有如下四种方式 1 系统应用安装――开机时完成，没有安装界面 2.网络下载应用安装――通过market应用完成，没有安装界面 3.ADB工具安装――没有安装界面。 4. 第三方应用安装――通过SD卡里的APK文件安装，有安装界面，由packageinstaller.apk应用处理安装及卸载过程的界面。 二、安装相关 1、应用安装的流程及路径 （1）应用安装涉及到如下几个目录： system/app 系统自带的应用程序，无法删除 （2）data/app 用户程序安装的目录，有删除权限
Android下载apk并安装apk（用于软件版本升级用途）
qq_41008818的博客
04-04 8972
Android下载apk并执行安装
安卓网apk安装器_短视频无水印下载，apk提取，带壳截图 iOS Android极客必备的三款软件，你全都用上了吗？...
weixin_39582656的博客
10-21 434
短视频无水印下载，apk提取，带壳截图iOSAndroid极客必备的三款软件，你全都用上了吗？7SIZE丨插图内容来自于网络侵权删给大家介绍Android，iOS上三款在生活中必备的三款神器，特别是极客朋友们，你一定用得上。▍短视频无水印下载『 Android』关注花卷TEST，后台回复【去水印】即可获得下载链接。极小身材仅仅4.4MB大小，解析去除短视频内的水印。本...
Android-Apk的安装流程分析（二）
诺~~~
01-11 2925
Android app的安装流程分析
android 用户应用使用系统权限如reboot的permission办法 包括顺利安装到手机上INSTALL_FAILED_INVALID_INSTALL_LOCATION
学习笔记
10-11 5001
昨天搞了setCurrentTimeMillis 不能修改时间的问题。不甘心今天上午又搞上了。 主要原因是因为SystemClock的setCurrentTimeMillis 的permission是signatureOrSystem等级的，直接使用user-permission没有作用。需要做两方面的事情： 一方面是相同的uid. Android 的系统用户id是android.ui
android应用市场点击下载APK安装详解
allen_xu_2012_new的博客
05-19 3440
android的APK安装流程，有四种安装方式：1，系统应用和预制应用安装，开机时完成，没有安装界面，在PKMS的构造函数中欧冠完成安装2，网络下载应用安装，通过应用商店来完成，调用PackageManager.installPackages()，有安装界面3，ADB工具安装，没有安装界面，它通过启动pm脚本的形式，然后调用com.android.commands.pm.Pm类，之后调用到PMS.installStage()完成安装。
apk安装流程
weixin_42904469的博客
05-27 8906
android系统启动之后调用PackageManagerService服务并解析系统特定目录，解析apk文件并安装的过程，这个安装过程实际上是没有图形界面的，底层调用的是我们平时比较熟悉的adb命令，那么我们平时安装apk文件的时候大部分是都过图形界面安装的，那么这种方式安装apk具体的流程是怎样的呢？ 本文我们就来具体看一下apk的具体安装过程，通过本文的学习希望帮助大家大概的了解到Android系统安装Apk文件的基本流程。 相信大家都知道如果我们想在代码里执行apk的安装，那么一般都是这样： Int
APK安装过程详解
qq_30531517的博客
09-10 1437
安装应用的过程解析     一.开机安装          PackageManagerService处理各种应用的安装，卸载，管理等工作，开机时由systemServer启动此服务         (源文件路径：android\frameworks\base\services\Java\com\android\server\PackageManagerService.java)        ...
Android PackageManagerService（二）下载安装详解
FeiPeng_的博客
07-23 1270
下载安装可分为两部分：拷贝应用和安装应用。拷贝过程的函数调用时序图如图2所示 下载安装frameworks层的入口函数为PackageManager.installPackage，由应用市场APP调用，然后调用PMS.installPackageAsUser，然后发送消息INIT_COPY、MCS_BOUND开始复制，调用HandlerParams.startCopy。这个方法主要分两部分，一部分是拷贝应用的执行程序，另一部分是创建应用的数据目录，拷贝部分由handleStartCopy完成。之后调用ha
apk安卓软件安装程序电脑
最新发布
02-05
APK是Android应用程序的安装包文件格式，通常用于在Android设备上安装软件。在电脑上安装APK文件通常需要借助安卓模拟器或者安卓开发调试工具。其中比较常用的安卓模拟器有BlueStacks、Nox Player、LDPlayer等，在...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值