深刻Android系统（十）PMS-3-应用安装过程
研究应用的安装过程，老样子，咱们仍是先从使用入手。java
在Android中，经过发送Intent就能够启动应用的安装过程，好比：android
Uri uri = Uri.fromFile(new File(apkFilePath));
Intent intent = new Intent(Intent.ACTION_VIEW);
intent.setDataAndType(uri,"application/vnd.android.package-archive");
startActivity(intent);
复制代码
而在Android的系统应用PackageInstaller中有一个InstallStart会响应这个Intent，数组
<activity android:name=".InstallStart" android:theme="@style/Installer" android:exported="true" android:excludeFromRecents="true">
<intent-filter android:priority="1">
<action android:name="android.intent.action.VIEW" />
<action android:name="android.intent.action.INSTALL_PACKAGE" />
<category android:name="android.intent.category.DEFAULT" />
<data android:scheme="file" />
<data android:scheme="content" />
<data android:mimeType="application/vnd.android.package-archive" />
</intent-filter>
......
</activity>
复制代码
在InstallStart中会进行各类Uri的判断，最终会跳转到一个叫作PackageInstallerActivity的界面。markdown
国内的厂商基本上会在
InstallStart这里进行修改，替换为本身的安装界面session
对于PackageInstallerActivity来讲，它的主要做用是数据结构
- 解析
Uri协议进行解析，包括file和package两种- 若是是
file协议会解析APK文件获得包信息PackageInfo
- 若是是
- 对未知来源进行处理
- 若是容许安装未知来源或者根据
Intent判断得出该APK不是未知来源，就会初始化安装确认界面 - 若是管理员限制来自未知源的安装, 就弹出提示
Dialog或者跳转到设置界面
- 若是容许安装未知来源或者根据
- 提取并在界面展现应用对应的权限
当点击确认安装后，其实会执行到startInstall()方法，相关内容以下：并发
private void startInstall() {
// Start subactivity to actually install the application
Intent newIntent = new Intent();
......
newIntent.setData(mPackageURI);
newIntent.setClass(this, InstallInstalling.class);
......
startActivity(newIntent);
finish();
}
复制代码
上面的逻辑是跳转到InstallInstalling界面进行安装，咱们看看这个Activity：app
@Override
protected void onCreate(@Nullable Bundle savedInstanceState) {
......
if ("package".equals(mPackageURI.getScheme())) {
// 直接安装 package
try {
getPackageManager().installExistingPackage(appInfo.packageName);
launchSuccess();
} catch (PackageManager.NameNotFoundException e) {
launchFailure(PackageManager.INSTALL_FAILED_INTERNAL_ERROR, null);
}
} else {
// 对于 file 安装，按照session的逻辑去走
// 这部分在onResume中开始
final File sourceFile = new File(mPackageURI.getPath());
......
if (savedInstanceState != null) {
mSessionId = savedInstanceState.getInt(SESSION_ID);
mInstallId = savedInstanceState.getInt(INSTALL_ID);
......
} else {
......
mSessionId = getPackageManager().getPackageInstaller().createSession(params);
......
// 建立应用安装状态的Observer
// 真正注册是在后面 Session 的 commitLocked 中
// InstallEventReceiver 这里是作了二次封装，方便进行持久化操做
InstallEventReceiver.addObserver(this, mInstallId,
this::launchFinishBasedOnResult);
}
......
}
}
@Override
protected void onResume() {
super.onResume();
// This is the first onResume in a single life of the activity
if (mInstallingTask == null) {
PackageInstaller installer = getPackageManager().getPackageInstaller();
PackageInstaller.SessionInfo sessionInfo = installer.getSessionInfo(mSessionId);
// 启动异步安装任务 InstallingAsyncTask 进行一系列的session操做
if (sessionInfo != null && !sessionInfo.isActive()) {
mInstallingTask = new InstallingAsyncTask();
mInstallingTask.execute();
}
......
}
}
复制代码
从上面的方法咱们能够看到安装操做主要分为两个接口：异步
getPackageManager().installExistingPackage()：主要是对已经并扫描到Settings的mPackages集合中的应用进行操做- 根据当前的
userID从集合中查询应用状态，若是存在而且应用没有安装，就进行一些简单的配置工做 - 最后经过
prepareAppDataAfterInstallLIF方法，建立特定userID下的应用数据
- 根据当前的
InstallingAsyncTask任务中的Session系列操做：一个应用完整的安装过程从这里开始private final class InstallingAsyncTask extends AsyncTask<Void, Void, PackageInstaller.Session> { volatile boolean isDone; @Override protected PackageInstaller.Session doInBackground(Void... params) { PackageInstaller.Session session; ...... session = getPackageManager().getPackageInstaller().openSession(mSessionId); try { File file = new File(mPackageURI.getPath()); try (InputStream in = new FileInputStream(file)) { long sizeBytes = file.length(); try (OutputStream out = session.openWrite("PackageInstaller", 0, sizeBytes)) { byte[] buffer = new byte[1024 * 1024]; while (true) { ...... out.write(buffer, 0, numRead); ...... } } } return session; } ...... } @Override protected void onPostExecute(PackageInstaller.Session session) { if (session != null) { ...... session.commit(pendingIntent.getIntentSender()); ...... } else { getPackageManager().getPackageInstaller().abandonSession(mSessionId); ...... } } 复制代码- 任务中作的第一个事情是:根据
APK的Uri，将APK的信息经过IO流的形式写入到PackageInstaller.Session中 - 第二个事情就是
PackageInstallerSession.commit()函数
- 任务中作的第一个事情是:根据
session这个东西看来很重要，那么咱们先来看看PackageInstallerSession吧async
PackageInstallerSession
Android经过PackageInstallerSession来表示一次安装过程，一个PackageInstallerSession包含一个系统中惟一的一个SessionId，若是一个应用的安装必须分几个阶段来完成，即便设备重启了，也能够经过这个ID来继续安装过程
PackageInstallerSession中保存了应用安装的相关数据，例如，安装包的路径、安装的进度、中间数据保存的目录等。
PackageInstallerService提供了接口createSession来建立一个Session对象：
@Override
public int createSession(SessionParams params, String installerPackageName, int userId) {
try {
return createSessionInternal(params, installerPackageName, userId);
} catch (IOException e) {
throw ExceptionUtils.wrap(e);
}
}
复制代码
createSession()方法将返回一个系统惟一值做为Session ID。若是但愿再次使用这个Session，能够经过接口openSession()打开它。openSession()方法的代码以下所示：
@Override
public IPackageInstallerSession openSession(int sessionId) {
try {
return openSessionInternal(sessionId);
} catch (IOException e) {
throw ExceptionUtils.wrap(e);
}
}
复制代码
openSession()方法将返回一个IPackageInstallerSession对象，它是Binder服务PackageInstallerSession的IBinder对象。在PackageInstallerService中mSessions数组保存了全部PackageInstallerSession对象，定义以下：
@GuardedBy("mSessions")
private final SparseArray<PackageInstallerSession> mSessions = new SparseArray<>();
复制代码
咱们知道，当PackageManagerService初始化时会建立PackageInstallerService服务，在这个服务的初始化函数中会读取/data/system目录下的install_sessions.xml文件，这个文件中保存了系统中未完成的Install Session。而后PackageInstallerService会根据文件的内容建立PackageInstallerSession对象并插入到mSessions中。
而对于上面提到的commit()函数，是真正触发PMS安装的函数，定义以下：
@Override
public void commit(@NonNull IntentSender statusReceiver, boolean forTransfer) {
......
mHandler.obtainMessage(MSG_COMMIT).sendToTarget();
......
}
private final Handler.Callback mHandlerCallback = new Handler.Callback() {
@Override
public boolean handleMessage(Message msg) {
switch (msg.what) {
......
case MSG_COMMIT:
synchronized (mLock) {
......
commitLocked();
......
}
break;
......
}
return true;
}
};
private void commitLocked() throws PackageManagerException {
......
mRemoteObserver.onUserActionRequired(intent);
......
mPm.installStage(mPackageName, stageDir, localObserver, params,
mInstallerPackageName, mInstallerUid, user, mSigningDetails);
}
复制代码
commit()函数最后会调用到PMS的installStage()方法，到这里就触发了安装的第一阶段：文件复制
安装第一阶段：复制文件
咱们已经知道PackageInstallerSession经过调用PMS的installStage()方法开启了安装第一阶段，不过整个安装过程比较复杂，咱们先看看这个过程的序列图：
installStage()
咱们继续从installStage()来分析，代码以下：
void installStage(String packageName, File stagedDir, IPackageInstallObserver2 observer, PackageInstaller.SessionParams sessionParams, String installerPackageName, int installerUid, UserHandle user, PackageParser.SigningDetails signingDetails) {
......
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, signingDetails, installReason);
......
msg.obj = params;
......
mHandler.sendMessage(msg);
}
复制代码
installStage()方法主要进行了：
- 建立了一个
InstallParams对象InstallParams是安装过程当中的主要数据结构- 通常状况，安装应用的时间一般比较长，所以
Android把安装过程拆分，把调用过程的参数数据保存到InstallParams中
- 建立并发送了一个
Message消息msg.what为INIT_COPYmsg.obj为InstallParams对象
先来简单了解下InstallParams的类：
上图中的类都是PMS的内部类
InstallParams继承自HandlerParams，用来记录安装应用的参数。InstallParams中有一个成员变量mArgs，是一个抽象类型InstallArgs，主要是用来执行APK的复制，真正的实现类包括：FileInstallArgs：用来完成非ASEC应用的安装asec全称是Android Secure External Cache
MoveInstallArgs：用来完成已安装应用的移动安装
简单了解完InstallParams，咱们继续看INIT_COPY消息的处理过程：
case INIT_COPY: {
HandlerParams params = (HandlerParams) msg.obj;
int idx = mPendingInstalls.size();
......
if (!mBound) {
// 绑定 DefaultContainerService
if (!connectToService()) {
params.serviceError();
......
return;
} else {
// 链接成功，将安装信息保存到 mPendingInstalls 的尾部
mPendingInstalls.add(idx, params);
}
} else {
// 若是已经绑定服务，直接插入到集合尾部
mPendingInstalls.add(idx, params);
if (idx == 0) {
// 若是插入前的集合为空
// 直接发送 MCS_BOUND 消息
mHandler.sendEmptyMessage(MCS_BOUND);
}
}
break;
}
复制代码
整个过程比较简洁：
- 首先是
connectToService()去绑定和启动DefaultContainerService服务。- 服务绑定是一个异步的过程，须要等待绑定结果经过
onServiceConnected()返回 - 从
DefaultContainerConnection中能够看到，当服务链接成功后，会发送MSC_BOUNF消息
class DefaultContainerConnection implements ServiceConnection { public void onServiceConnected(ComponentName name, IBinder service) { final IMediaContainerService imcs = IMediaContainerService.Stub .asInterface(Binder.allowBlocking(service)); mHandler.sendMessage(mHandler.obtainMessage(MCS_BOUND, imcs)); } } 复制代码 - 服务绑定是一个异步的过程，须要等待绑定结果经过
- 而后将安装的参数信息放到了
mPendingInstalls列表中。- 当有多个安装请求到达时，能够经过
mPendingInstalls进行排队
- 当有多个安装请求到达时，能够经过
- 若是添加前的列表为空，说明没有其余的安装请求，此时直接发送
MSC_BOUND消息
那么，重点又转移到了MCS_BOUND的消息处理，代码以下：
case MCS_BOUND: {
if (msg.obj != null) {
mContainerService = (IMediaContainerService) msg.obj;
}
if (mContainerService == null) {
if (!mBound) {
// DefaultContainerService bind失败的状况
for (HandlerParams params : mPendingInstalls) {
params.serviceError();
......
}
mPendingInstalls.clear();
} else {
Slog.w(TAG, "Waiting to connect to media container service");
}
} else if (mPendingInstalls.size() > 0) {
// 取出头部安装参数
HandlerParams params = mPendingInstalls.get(0);
if (params != null) {
......
if (params.startCopy()) {// 执行安装
// 已执行成功，移除头部元素
if (mPendingInstalls.size() > 0) {
mPendingInstalls.remove(0);
}
if (mPendingInstalls.size() == 0) {
if (mBound) {
......
// 若是集合中没有须要安装的信息了，发送MCS_UNBIND延时消息进行解绑
removeMessages(MCS_UNBIND);
Message ubmsg = obtainMessage(MCS_UNBIND);
sendMessageDelayed(ubmsg, 10000);
}
} else {
// 若是集合中还存在安装信息，发送 MCS_BOUND 消息，继续处理
mHandler.sendEmptyMessage(MCS_BOUND);
}
}
}
}
break;
}
复制代码
MCS_BOUND消息的处理过程就是：
- 调用
InstallParams类的startCopy()方法来执行安装- 处理逻辑确定在这个方法里面，下面细讲
- 只要
mPendingInstalls中还有安装信息，就会重复发送MCS_BOUND消息 - 直到全部应用都处理完毕，而后发送一个延时
10s的MCS_UNBIND消息MCS_UNBIND消息的处理很简单，收到消息后若是发现mPendingInstalls中有数据了，则发送MCS_BOUND消息继续安装。- 不然断开
DefaultContainerService链接，安装过程到此结束
case MCS_UNBIND: { if (mPendingInstalls.size() == 0 && mPendingVerification.size() == 0) { if (mBound) { // 断开 DefaultContainerService 链接 disconnectService(); } } else if (mPendingInstalls.size() > 0) { // 继续发送执行安装操做的消息 mHandler.sendEmptyMessage(MCS_BOUND); } break; } 复制代码
针对startCopy()方法的处理过程，代码以下：
private static final int MAX_RETRIES = 4;
final boolean startCopy() {
boolean res;
try {
// 重试超过4次，则推出
if (++mRetries > MAX_RETRIES) {
// 发送 MCS_GIVE_UP 消息取消安装
mHandler.sendEmptyMessage(MCS_GIVE_UP);
handleServiceError();
return false;
} else {
// 核心方法，执行 copy
handleStartCopy();
res = true;
}
} catch (RemoteException e) {
// 出现异常，发送 MCS_RECONNECT 消息，进行重连
mHandler.sendEmptyMessage(MCS_RECONNECT);
res = false;
}
// 开始进入第二阶段
handleReturnCode();
return res;
}
复制代码
startCopy()方法经过调用handleStartCopy()来完成安装过程。考虑到安装过程的不肯定性，startCopy()主要是进行错误处理：
- 在
MCS_RECONNECT消息处理中，会从新绑定DefaultContainerService- 若是绑定成功，安装过程就会从新开始，
startCopy()会被再次调用。 - 重试的次数记录在变量
mRetries中，超过4次，安装失败
- 若是绑定成功，安装过程就会从新开始，
handleStartCopy()执行成功，startCopy()会调用handleReturnCode()来继续处理
handleStartCopy()方法比较长，简要代码以下：
public void handleStartCopy() throws RemoteException {
int ret = PackageManager.INSTALL_SUCCEEDED;
......
if (onInt && onSd) {
// 设置安装路径异常标志
ret = PackageManager.INSTALL_FAILED_INVALID_INSTALL_LOCATION;
} else if (onSd && ephemeral) {
// 设置安装路径异常标志
ret = PackageManager.INSTALL_FAILED_INVALID_INSTALL_LOCATION;
} else {
// 获取安装包中的 PackageInfoLite 对象
pkgLite = mContainerService.getMinimalPackageInfo(origin.resolvedPath, installFlags, packageAbiOverride);
......
if (!origin.staged && pkgLite.recommendedInstallLocation
== PackageHelper.RECOMMEND_FAILED_INSUFFICIENT_STORAGE) {
// TODO: focus freeing disk space on the target device
// 若是安装空间不够，尝试释放cache空间
......
try {
mInstaller.freeCache(null, sizeBytes + lowThreshold, 0, 0);
......
} catch (InstallerException e) {
Slog.w(TAG, "Failed to free cache", e);
}
......
if (pkgLite.recommendedInstallLocation
== PackageHelper.RECOMMEND_FAILED_INVALID_URI) {
pkgLite.recommendedInstallLocation
= PackageHelper.RECOMMEND_FAILED_INSUFFICIENT_STORAGE;
}
}
}
......
final InstallArgs args = createInstallArgs(this);
mArgs = args;
if (ret == PackageManager.INSTALL_SUCCEEDED) {
......
if (!origin.existing && requiredUid != -1 && isVerificationEnabled(verifierUser.getIdentifier(), installFlags, installerUid)) {
// 此部分是在执行应用的校验
// 主要经过向待校验功能的组件发送Intent来完成
......
/* * We don't want the copy to proceed until verification * succeeds, so null out this field. */
mArgs = null;
} else {
// 无需校验，调用 InstallArgs 的 copyAPK 方法继续处理
ret = args.copyApk(mContainerService, true);
}
}
mRet = ret;
}
复制代码
上面handleStartCopy()方法的主要逻辑是：
- 首先经过
getMinimalPackageInfo()方法确认是否还有足够的安装空间，若是安装空间不够，会经过mInstaller.freeCache()来释放一部分 - 接下来经过
createInstallArgs()建立InstallArgs对象，createInstallArgs()方法中会对InstallParams的move成员变量进行判断move不为空使用MoveInstallArgsmove为空使用FileInstallArgs，咱们重点来看这个
- 再接下来对
apk进行校验，这个校验过程是经过发送Intent.ACTION_PACKAGE_NEEDS_VERIFICATION)广播给系统中全部能够接收该Intent的应用来完成的 - 无需校验，执行
InstallArgs的copyApk()方法
InstallArgs的copyApk()方法以下：
int copyApk(IMediaContainerService imcs, boolean temp) throws RemoteException {
......
return doCopyApk(imcs, temp);
}
private int doCopyApk(IMediaContainerService imcs, boolean temp) throws RemoteException {
if (origin.staged) {
codeFile = origin.file;
resourceFile = origin.file;
return PackageManager.INSTALL_SUCCEEDED;
}
try {
final boolean isEphemeral = (installFlags & PackageManager.INSTALL_INSTANT_APP) != 0;
// 在/data/app路径下生成临时文件
final File tempDir = mInstallerService.allocateStageDirLegacy(volumeUuid, isEphemeral);
codeFile = tempDir;
resourceFile = tempDir;
} catch (IOException e) {
Slog.w(TAG, "Failed to create copy file: " + e);
return PackageManager.INSTALL_FAILED_INSUFFICIENT_STORAGE;
}
// 为临时文件建立文件描述符 ParcelFileDescriptor
// 主要是为了将文件序列化，方便经过binder传输
final IParcelFileDescriptorFactory target = new IParcelFileDescriptorFactory.Stub() {
@Override
public ParcelFileDescriptor open(String name, int mode) throws RemoteException {
if (!FileUtils.isValidExtFilename(name)) {
throw new IllegalArgumentException("Invalid filename: " + name);
}
try {
final File file = new File(codeFile, name);
final FileDescriptor fd = Os.open(file.getAbsolutePath(),
O_RDWR | O_CREAT, 0644);
Os.chmod(file.getAbsolutePath(), 0644);
return new ParcelFileDescriptor(fd);
} catch (ErrnoException e) {
throw new RemoteException("Failed to open: " + e.getMessage());
}
}
};
int ret = PackageManager.INSTALL_SUCCEEDED;
// 使用服务 DefaultContainerService 的 copyPackage 方法复制文件
ret = imcs.copyPackage(origin.file.getAbsolutePath(), target);
if (ret != PackageManager.INSTALL_SUCCEEDED) {
Slog.e(TAG, "Failed to copy package");
return ret;
}
// 安装应用中自带的 native 动态库
final File libraryRoot = new File(codeFile, LIB_DIR_NAME);
NativeLibraryHelper.Handle handle = null;
try {
handle = NativeLibraryHelper.Handle.create(codeFile);
ret = NativeLibraryHelper.copyNativeBinariesWithOverride(handle, libraryRoot,
abiOverride);
} catch (IOException e) {
Slog.e(TAG, "Copying native libraries failed", e);
ret = PackageManager.INSTALL_FAILED_INTERNAL_ERROR;
} finally {
IoUtils.closeQuietly(handle);
}
return ret;
}
复制代码
copyApk()最后调用了DefaultContainerService的copyPackage()方法将应用的文件复制到了/data/app目录下。若是应用中还有native的动态库，也会把apk中的库文件提取出来。
执行完copyApk()方法后，安装第一阶段的工做就完成了，应用安装到了/data/app目录下。咱们接下来看看handleReturnCode()的内容，也就是第二阶段。
安装第二阶段：装载应用
第二阶段的工做主要是
- 把应用的格式转换成
oat格式 - 为应用建立数据目录
- 把应用的信息装载进
PMS的数据结构中
handleReturnCode()方法代码以下：
void handleReturnCode() {
if (mArgs != null) {
processPendingInstall(mArgs, mRet);
}
}
复制代码
handleReturnCode()只是调用了processPendingInstall()方法继续处理，这个方法的代码以下：
private void processPendingInstall(final InstallArgs args, final int currentStatus) {
// Queue up an async operation since the package installation may take a little while.
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);
}
......
// 将相关数据记录到 mRunningInstalls 集合中
PostInstallData data = new PostInstallData(args, res);
mRunningInstalls.put(token, data);
...... // 省略备份部分
if (!doRestore) {
Message msg = mHandler.obtainMessage(POST_INSTALL, token, 0);
mHandler.sendMessage(msg);
}
}
});
}
复制代码
processPendingInstall()方法中post了一个任务：
- 任务中的核心是经过
installPackageTracedLI()来装载应用 - 接下来的部分是经过
IBackupManager服务执行备份相关的操做，这部分就不先深刻了，篇幅已通过大。。。 - 备份完成后发送
POST_INSTALL消息继续处理
咱们仍是先看下核心方法installPackageTracedLI()的内容，代码以下：
private void installPackageTracedLI(InstallArgs args, PackageInstalledInfo res) {
installPackageLI(args, res);
}
private void installPackageLI(InstallArgs args, PackageInstalledInfo res) {
......
// Result object to be returned
res.setReturnCode(PackageManager.INSTALL_SUCCEEDED);
res.installerPackageName = installerPackageName;
......
// 建立 APK 解析对象 PackageParser
PackageParser pp = new PackageParser();
pp.setSeparateProcesses(mSeparateProcesses);
......
final PackageParser.Package pkg;
try {
// 解析 APK
pkg = pp.parsePackage(tmpPackageFile, parseFlags);
} catch (PackageParserException e) {
res.setError("Failed parse during installPackageLI", e);
return;
}
......
// 收集应用的签名信息
if (args.signingDetails != PackageParser.SigningDetails.UNKNOWN) {
pkg.setSigningDetails(args.signingDetails);
} else {
PackageParser.collectCertificates(pkg, false /* skipVerify */);
}
......
pp = null;
String oldCodePath = null;
boolean systemApp = false;
synchronized (mPackages) {
// Check if installing already existing package
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);
pkgName = pkg.packageName;
replace = true;
}
......// 省略部分新旧应用的属性比对
}
// 检查已安装的应用集合中是否存在该应用的记录
PackageSetting ps = mSettings.mPackages.get(pkgName);
if (ps != null) {
// 存在同名应用
......// 省略一些本地库的签名判断
// 检查是否为系统应用
oldCodePath = mSettings.mPackages.get(pkgName).codePathString;
if (ps.pkg != null && ps.pkg.applicationInfo != null) {
systemApp = (ps.pkg.applicationInfo.flags &
ApplicationInfo.FLAG_SYSTEM) != 0;
}
res.origUsers = ps.queryInstalledUsers(sUserManager.getUserIds(), true);
}
// 检查应用中定义的Permission是否被重复定义
int N = pkg.permissions.size();
for (int i = N-1; i >= 0; i--) {
final PackageParser.Permission perm = pkg.permissions.get(i);
final BasePermission bp =
(BasePermission) mPermissionManager.getPermissionTEMP(perm.info.name);
......
// 省略部分只要是对系统定义权限和非系统定义权限的区分
// 若是是系统应用定义的权限，则忽略本应用中的定义，而后继续
// 若是是非系统应用定义的权限，则本次安装失败
......
}
}
......
try (PackageFreezer freezer = freezePackageForInstall(pkgName, installFlags,
"installPackageLI")) {
if (replace) {
......
replacePackageLIF(pkg, parseFlags, scanFlags, args.user,
installerPackageName, res, args.installReason);
} else {
installNewPackageLIF(pkg, parseFlags, scanFlags | SCAN_DELETE_DATA_ON_FAILURES,
args.user, installerPackageName, volumeUuid, res, args.installReason);
}
}
...... // 省略 dexopt 相关操做
}
}
复制代码
这部分的代码逻辑和前面介绍的scanDirLI()很像，不详细介绍了，总体流程是：
- 先经过
PackageParser解析了安装的应用文件- 解析过程和
scanDirLI()中的parsePackage()同样
- 解析过程和
- 获得解析结果后，主要是判断新安装的应用是否和已安装的应用构成升级关系
- 若是是，则调用
replacePackageLIF()继续处理 - 不然调用
installNewPackageLIF()处理
- 若是是，则调用
这里不深刻进行分析了哈，跟踪完调用过程后其实都会走到addForInitLI()中
再次吐槽一下
PMS，package解析部分的调用是真滴复杂啊，各类条件判断
咱们继续看下POST_INSTALL消息的处理过程：
case POST_INSTALL: {
PostInstallData data = mRunningInstalls.get(msg.arg1);
final boolean didRestore = (msg.arg2 != 0);
mRunningInstalls.delete(msg.arg1);
if (data != null) {
InstallArgs args = data.args;
PackageInstalledInfo parentRes = data.res;
......
// Handle the parent package
handlePackagePostInstall(parentRes, grantPermissions, killApp,
virtualPreload, grantedPermissions, didRestore,
args.installerPackageName, args.observer);
// Handle the child packages
final int childCount = (parentRes.addedChildPackages != null)
? parentRes.addedChildPackages.size() : 0;
for (int i = 0; i < childCount; i++) {
PackageInstalledInfo childRes = parentRes.addedChildPackages.valueAt(i);
handlePackagePostInstall(childRes, grantPermissions, killApp,
virtualPreload, grantedPermissions, false /*didRestore*/,
args.installerPackageName, args.observer);
}
......
}
......
} break;
复制代码
POST_INSTALL的消息处理基本上都是在执行handlePackagePostInstall()方法，handlePackagePostInstall()方法主要工做包括两个：
- 发广播，广播包括：
Intent.ACTION_PACKAGE_ADDED：新应用安装成功Intent.ACTION_PACKAGE_REPLACED：应用更新成功- 发广播的目的是通知系统中的其余应用
APK安装完成。例如，Launcher中须要增长应用的图标等
- 调用
IPackageInstallObserver2的onPackageInstalled()方法通知观察者- 咱们最初介绍的
PackageInstaller在安装应用时就是经过注册观察者来实现结果监听的
- 咱们最初介绍的
关于
PMS的软件卸载流程，你们一样能够从PackageInstaller入手，关键类是UninstallUninstalling。这里就先跳过了，PMS篇幅占用时间过久了。。。。。
相关文章
- 1. win10系统安装Android studio过程
- 2. 深刻Android系统（一）Build系统
- 3. 【深刻学习linux】Linux系统安装
- 4. 深刻Android系统（九）Android系统的核心-SystemServer进程
- 5. （59）Linux操做系统深刻应用
- 6. 深刻理解Android系统多用户
- 7. Android深刻四大组件（一）应用程序启动过程
- 8. 深刻Android系统（十一）AMS-1-应用组成与服务的启动
- 9. Android 8.1 应用安装过程总结
- 10. Android应用安装过程及原理
- 更多相关文章...
- • XML 应用程序 - XML 教程
- • Wireshark下载安装和使用教程 - TCP/IP教程
- • Composer 安装与使用
- • Docker容器实战(七) - 容器眼光下的文件系统
相关标签/搜索
每日一句
-
每一个你不满意的现在，都有一个你没有努力的曾经。
最新文章
- 1. Window下Ribbit MQ安装
- 2. Linux下Redis安装及集群搭建
- 3. shiny搭建网站填坑战略
- 4. Mysql8.0.22安装与配置详细教程
- 5. Hadoop安装及配置
- 6. Python爬虫初学笔记
- 7. 部署LVS-Keepalived高可用集群
- 8. keepalived+mysql高可用集群
- 9. jenkins 公钥配置
- 10. HA实用详解
欢迎关注本站公众号,获取更多信息
