1

2

3

4

5

adb_commandline

install_app_legacy or install_app

pm_command

send_shell_command

Pm.runInstall()

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

private int runInstall() throws RemoteException {

final InstallParams params = makeInstallParams();

// 1. 创建session

final int sessionId = doCreateSession(params.sessionParams,

params.installerPackageName, params.userId);

try {

final String inPath = nextArg();

if (inPath == null && params.sessionParams.sizeBytes == 0) {

System.err.println("Error: must either specify a package size or an APK file");

return 1;

}

// 2. 写session

if (doWriteSession(sessionId, inPath, params.sessionParams.sizeBytes, "base.apk",

false /*logSuccess*/) != PackageInstaller.STATUS_SUCCESS) {

return 1;

}

// 3. 提交Session

if (doCommitSession(sessionId, false /*logSuccess*/)

!= PackageInstaller.STATUS_SUCCESS) {

return 1;

}

System.out.println("Success");

return 0;

} finally {

try {

mInstaller.abandonSession(sessionId);

} catch (Exception ignore) {

}

}

}

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

33

34

35

void installStage(String packageName, File stagedDir, String stagedCid,

IPackageInstallObserver2 observer, PackageInstaller.SessionParams sessionParams,

String installerPackageName, int installerUid, UserHandle user,

Certificate[][] certificates) {

if (DEBUG_EPHEMERAL) {

if ((sessionParams.installFlags & PackageManager.INSTALL_EPHEMERAL) != 0) {

Slog.d(TAG, "Ephemeral install of " + packageName);

}

}

final VerificationInfo verificationInfo = new VerificationInfo(

sessionParams.originatingUri, sessionParams.referrerUri,

sessionParams.originatingUid, installerUid);

final OriginInfo origin;

if (stagedDir != null) {

origin = OriginInfo.fromStagedFile(stagedDir);

} else {

origin = OriginInfo.fromStagedContainer(stagedCid);

}

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);

params.setTraceMethod("installStage").setTraceCookie(System.identityHashCode(params));

msg.obj = params;

Trace.asyncTraceBegin(TRACE_TAG_PACKAGE_MANAGER, "installStage",

System.identityHashCode(msg.obj));

Trace.asyncTraceBegin(TRACE_TAG_PACKAGE_MANAGER, "queueInstall",

System.identityHashCode(msg.obj));

mHandler.sendMessage(msg);

}

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

public void installPackage(Uri packageURI, PackageInstallObserver observer,

int flags, String installerPackageName) {

installCommon(packageURI, observer, flags, installerPackageName, mContext.getUserId());

}

private void installCommon(Uri packageURI,

PackageInstallObserver observer, int flags, String installerPackageName,

int userId) {

if (!"file".equals(packageURI.getScheme())) {

throw new UnsupportedOperationException("Only file:// URIs are supported");

}

final String originPath = packageURI.getPath();

try {

// PMS.installPackageAsUser

mPM.installPackageAsUser(originPath, observer.getBinder(), flags, installerPackageName,

userId);

} catch (RemoteException e) {

throw e.rethrowFromSystemServer();

}

}

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

@Override

public void installPackageAsUser(String originPath, IPackageInstallObserver2 observer,

int installFlags, String installerPackageName, int userId) {

...

final Message msg = mHandler.obtainMessage(INIT_COPY);

final VerificationInfo verificationInfo = new VerificationInfo(

null /*originatingUri*/, null /*referrer*/, -1 /*originatingUid*/, callingUid);

final InstallParams params = new InstallParams(origin, null /*moveInfo*/, observer,

installFlags, installerPackageName, null /*volumeUuid*/, verificationInfo, user,

null /*packageAbiOverride*/, null /*grantedPermissions*/,

null /*certificates*/);

params.setTraceMethod("installAsUser").setTraceCookie(System.identityHashCode(params));

msg.obj = params;

mHandler.sendMessage(msg);

....

}

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

33

34

35

36

37

38

39

40

41

42

43

44

45

class PackageHandler extends Handler {

...

void doHandleMessage(Message msg) {

switch (msg.what) {

case INIT_COPY: {

//这里取出的其实就是InstallParams

HandlerParams params = (HandlerParams) msg.obj;

//idx为当前等待处理处理的安装请求的个数

int idx = mPendingInstalls.size();

............

//初始时，mBound的值为false

if (!mBound) {

............

// If this is the only one pending we might

// have to bind to the service again.

//连接安装服务

if (!connectToService()) {

..................

} else {

// Once we bind to the service, the first

// pending request will be processed.

//绑定服务成功后，将新的请求加入到mPendingIntalls中，等待处理

mPendingInstalls.add(idx, params);

}

} else {

//如果之前已经绑定过服务，同样将新的请求加入到mPendingIntalls中，等待处理

mPendingInstalls.add(idx, params);

// Already bound to the service. Just make

// sure we trigger off processing the first request.

if (idx == 0) {

//如果是第一个请求，则直接发送事件MCS_BOUND，触发处理流程

mHandler.sendEmptyMessage(MCS_BOUND);

}

}

break;

}

}

}

...

}

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

33

34

35

36

37

38

39

40

41

42

43

44

45

46

47

48

49

50

51

52

53

54

55

56

void doHandleMessage(Message msg) {

.......

case MCS_BOUND: {

........

if (msg.obj != null) {

mContainerService = (IMediaContainerService) msg.obj;

.......

}

if (mContainerService == null) {

if (!mBound) {

// Something seriously wrong since we are not bound and we are not

// waiting for connection. Bail out.

............

} else {

Slog.w(TAG, "Waiting to connect to media container service");

}

// 请求队列mPendingInstalls不为空

} else if (mPendingInstalls.size() > 0) {

HandlerParams params = mPendingInstalls.get(0);

if (params != null) {

........

//调用参数的startCopy函数处理安装请求

if (params.startCopy()) {

........

// Delete pending install

if (mPendingInstalls.size() > 0) {

mPendingInstalls.remove(0);

}

if (mPendingInstalls.size() == 0) {

if (mBound) {

..........

removeMessages(MCS_UNBIND);

Message ubmsg = obtainMessage(MCS_UNBIND);

// Unbind after a little delay, to avoid

// continual thrashing.

sendMessageDelayed(ubmsg, 10000);

}

} else {

// There are more pending requests in queue.

// Just post MCS_BOUND message to trigger processing

// of next pending install.

......

mHandler.sendEmptyMessage(MCS_BOUND);

}

}

.........

}

} else {

// Should never happen ideally.

Slog.w(TAG, "Empty queue");

}

break;

}

.......

}

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

final boolean startCopy() {

boolean res;

try {

if (DEBUG_INSTALL) Slog.i(TAG, "startCopy " + mUser + ": " + this);

if (++mRetries > MAX_RETRIES) {

Slog.w(TAG, "Failed to invoke remote methods on default container service. Giving up");

mHandler.sendEmptyMessage(MCS_GIVE_UP);

handleServiceError();

return false;

} else {

// 调用handleStartCopy()处理

handleStartCopy();

Slog.i(TAG, "Apk copy done");

res = true;

}

} catch (RemoteException e) {

if (DEBUG_INSTALL) Slog.i(TAG, "Posting install MCS_RECONNECT");

mHandler.sendEmptyMessage(MCS_RECONNECT);

res = false;

}

//

handleReturnCode();

return res;

}

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

33

34

35

36

37

38

39

40

41

42

43

public void handleStartCopy() throws RemoteException {

int ret = PackageManager.INSTALL_SUCCEEDED;

// 决定是安装在手机内还是sdcard中，设置对应标志位

if (origin.staged) {

if (origin.file != null) {

installFlags |= PackageManager.INSTALL_INTERNAL;

installFlags &= ~PackageManager.INSTALL_EXTERNAL;

} else if (origin.cid != null) {

installFlags |= PackageManager.INSTALL_EXTERNAL;

installFlags &= ~PackageManager.INSTALL_INTERNAL;

} else {

throw new IllegalStateException("Invalid stage location");

}

}

...

// 检查APK的安装位置是否正确

if (onInt && onSd) {

// Check if both bits are set.

Slog.w(TAG, "Conflicting flags specified for installing on both internal and external");

ret = PackageManager.INSTALL_FAILED_INVALID_INSTALL_LOCATION;

} else if (onSd && ephemeral) {

Slog.w(TAG, "Conflicting flags specified for installing ephemeral on external");

ret = PackageManager.INSTALL_FAILED_INVALID_INSTALL_LOCATION;

} else {

...

}

...

// createInstallArgs用于创建一个安装参数对象

final InstallArgs args = createInstallArgs(this);

if (ret == PackageManager.INSTALL_SUCCEEDED) {

...

// 调用InstallArgs的copyApk函数

ret = args.copyApk(mContainerService, true);

}

}

mRet = ret;

}

1

2

3

4

5

6

7

8

void handleReturnCode() {

// If mArgs is null, then MCS couldn't be reached. When it

// reconnects, it will try again to install. At that point, this

// will succeed.

if (mArgs != null) {

processPendingInstall(mArgs, mRet);

}

}

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

33

34

private void processPendingInstall(final InstallArgs args, final int currentStatus) {

mHandler.post(new Runnable() {

public void run() {

mHandler.removeCallbacks(this);

// Result object to be returned

PackageInstalledInfo res = new PackageInstalledInfo();

res.setReturnCode(currentStatus);

res.uid = -1;

res.pkg = null;

res.removedInfo = null;

if (res.returnCode == PackageManager.INSTALL_SUCCEEDED) {

//1、预安装，检查包状态，确保环境ok，如果环境不ok，那么会清理拷贝的文件

args.doPreInstall(res.returnCode);

synchronized (mInstallLock) {

//2、安装，调用installPackageTracedLI进行安装

installPackageTracedLI(args, res);

}

//3、安装收尾

args.doPostInstall(res.returnCode, res.uid);

}

if (!doRestore) {

.......

//4、生成一个POST_INSTALL消息给PackageHanlder

Message msg = mHandler.obtainMessage(POST_INSTALL, token, 0);

mHandler.sendMessage(msg);

}

}

});

}

1

2

3

4

5

6

7

8

private void installPackageTracedLI(InstallArgs args, PackageInstalledInfo res) {

try {

Trace.traceBegin(TRACE_TAG_PACKAGE_MANAGER, "installPackage");

installPackageLI(args, res);

} finally {

Trace.traceEnd(TRACE_TAG_PACKAGE_MANAGER);

}

}

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

33

34

35

36

37

38

39

40

41

42

43

44

45

46

47

48

49

50

51

52

53

54

55

56

57

58

59

60

61

62

63

64

65

66

67

68

69

70

71

72

private void installPackageLI(InstallArgs args, PackageInstalledInfo res) {

// PackageParser对象

PackageParser pp = new PackageParser();

pp.setSeparateProcesses(mSeparateProcesses);

pp.setDisplayMetrics(mMetrics);

Trace.traceBegin(TRACE_TAG_PACKAGE_MANAGER, "parsePackage");

final PackageParser.Package pkg;

try {

if (DEBUG_INSTALL) Slog.i(TAG, "Start parsing apk: " + installerPackageName);

// 1.开始解析我们的package

pkg = pp.parsePackage(tmpPackageFile, parseFlags);

if (DEBUG_INSTALL) Slog.i(TAG, "Parsing done for apk: " + installerPackageName);

} catch (PackageParserException e) {

res.setError("Failed parse during installPackageLI", e);

return;

} finally {

Trace.traceEnd(TRACE_TAG_PACKAGE_MANAGER);

}

...

//2. 加载证书，获取签名信息

try {

// either use what we've been given or parse directly from the APK

if (args.certificates != null) {

try {

PackageParser.populateCertificates(pkg, args.certificates);

} catch (PackageParserException e) {

PackageParser.collectCertificates(pkg, parseFlags);

}

} else {

PackageParser.collectCertificates(pkg, parseFlags);

}

} catch (PackageParserException e) {

res.setError("Failed collect during installPackageLI", e);

return;

}

...

synchronized (mPackages) {

// 3.检测packages是否存在

if ((installFlags & PackageManager.INSTALL_REPLACE_EXISTING) != 0) {

...

replace = true;

} else if (mPackages.containsKey(pkgName)) {

...

replace = true;

if (DEBUG_INSTALL) Slog.d(TAG, "Replace existing pacakge: " + pkgName);

}

...

}

}

...

try (PackageFreezer freezer = freezePackageForInstall(pkgName, installFlags,

"installPackageLI")) {

if (replace) {

// 4.更新已经存在的packages

replacePackageLIF(pkg, parseFlags, scanFlags | SCAN_REPLACING, args.user,

installerPackageName, res);

} else {

// 5.安装新的packages

installNewPackageLIF(pkg, parseFlags, scanFlags | SCAN_DELETE_DATA_ON_FAILURES,

args.user, installerPackageName, volumeUuid, res);

}

}

...

}

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

replacePackageLIF

replaceSystemPackageLIF // 系统 pkg

removePackageLI

disableSystemPackageLPw

clearAppDataLIF

scanPackageTracedLI //安装apk

scanPackageLI

scanPackageDirtyLI

updateSettingsLI

updatePermissionsLPw

mSettings.writeLPr();

replaceNonSystemPackageLIF // 非系统 pkg

deletePackageLIF

clearAppDataLIF

clearAppProfilesLIF

scanPackageTracedLI // 安装apk

scanPackageLI

scanPackageDirtyLI

updateSettingsLI

updatePermissionsLPw

mSettings.writeLPr();

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

33

34

35

36

37

38

39

40

41

42

43

44

45

46

47

48

49

50

51

52

53

private void installNewPackageLIF(PackageParser.Package pkg, final int policyFlags,

int scanFlags, UserHandle user, String installerPackageName, String volumeUuid,

PackageInstalledInfo res) {

Trace.traceBegin(TRACE_TAG_PACKAGE_MANAGER, "installNewPackage");

// Remember this for later, in case we need to rollback this install

String pkgName = pkg.packageName;

if (DEBUG_INSTALL) Slog.d(TAG, "installNewPackageLI: " + pkg);

// package已经存在

synchronized(mPackages) {

if (mSettings.mRenamedPackages.containsKey(pkgName)) {

// A package with the same name is already installed, though

// it has been renamed to an older name. The package we

// are trying to install should be installed as an update to

// the existing one, but that has not been requested, so bail.

res.setError(INSTALL_FAILED_ALREADY_EXISTS, "Attempt to re-install " + pkgName

+ " without first uninstalling package running as "

+ mSettings.mRenamedPackages.get(pkgName));

return;

}

if (mPackages.containsKey(pkgName)) {

// Don't allow installation over an existing package with the same name.

res.setError(INSTALL_FAILED_ALREADY_EXISTS, "Attempt to re-install " + pkgName

+ " without first uninstalling.");

return;

}

}

try {

// 1. 安装apk

PackageParser.Package newPackage = scanPackageTracedLI(pkg, policyFlags, scanFlags,

System.currentTimeMillis(), user);

// 2. 更新setting

updateSettingsLI(newPackage, installerPackageName, null, res, user);

if (res.returnCode == PackageManager.INSTALL_SUCCEEDED) {

prepareAppDataAfterInstallLIF(newPackage);

} else {

// Remove package from internal structures, but keep around any

// data that might have already existed

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);

}