CrayfishXu

专注Android，填坑铺路

0%

Posted on Edited on In

前言

我觉得是时候开始深入源码进行学习了，开刀一个当然是我们最常用的Activity。平常startActivity也是最常用的跳转，但是重来没有了解过其内部逻辑，今天就来揭开它的面目。参照源码是Android7.1.1。其实类似的文章已经遍地都是了，我在这里也是为了记录一下我的学习过程。

Activity跳转

首先我们在跳转Activity的时候都会使用startActivity(Intent intent),那么我们Ctrl+左键进入看源码。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
@Override
public void startActivity(Intent intent) {
	this.startActivity(intent, null);
}
@Override
   public void startActivity(Intent intent, @Nullable Bundle options) {
       if (options != null) {
           startActivityForResult(intent, -1, options);
       } else {
           // Note we want to go through this call for compatibility with
           // applications that may have overridden the method.
           startActivityForResult(intent, -1);
       }
   }

原来都调用了startActivityForResult(),如果我们需要Activity返回数据，触发onActivityResult回调的时候就是用的这个，这里写死了-1就是不回调。然后接着往下看。

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
public void startActivityForResult(@RequiresPermission Intent intent, int requestCode,
           @Nullable Bundle options) {
       if (mParent == null) {
	    //数据进行转换 新加入的
           options = transferSpringboardActivityOptions(options);
		//启动新的Activity,核心在mMainThread.getApplicationThread()中完成
           Instrumentation.ActivityResult ar =
               mInstrumentation.execStartActivity(
                   this, mMainThread.getApplicationThread(), mToken, this,
                   intent, requestCode, options);
           if (ar != null) {
               mMainThread.sendActivityResult(
                   mToken, mEmbeddedID, requestCode, ar.getResultCode(),
                   ar.getResultData());
           }
           if (requestCode >= 0) {
               // If this start is requesting a result, we can avoid making
               // the activity visible until the result is received.  Setting
               // this code during onCreate(Bundle savedInstanceState) or onResume() will keep the
               // activity hidden during this time, to avoid flickering.
               // This can only be done when a result is requested because
               // that guarantees we will get information back when the
               // activity is finished, no matter what happens to it.
               mStartedActivity = true;
           }
		//取消输入和开始退出变化 新加入的
           cancelInputsAndStartExitTransition(options);
           // TODO Consider clearing/flushing other event sources and events for child windows.
       } else {
           if (options != null) {
               mParent.startActivityFromChild(this, intent, requestCode, options);
           } else {
               // Note we want to go through this method for compatibility with
               // existing applications that may have overridden it.
               mParent.startActivityFromChild(this, intent, requestCode);
           }
       }
   }

这里出现了mParent的判断，那么我们就找到这个值的说明，如下

1
2
3
4
5
6
7
8
9
/** Is this activity embedded inside of another activity? */
   public final boolean isChild() {
       return mParent != null;
   }

   /** Return the parent activity if this view is an embedded child. */
   public final Activity getParent() {
       return mParent;
   }

英文不太好，找了百度翻译，大致就是内嵌的时候返回的mParent不为空。据说是用在ActivityGroup中，现在已弃用。那么我们还是先分析不为空的情况，因为最后逻辑是又走到一起去的。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
public void startActivityFromChild(@NonNull Activity child, @RequiresPermission Intent intent,
           int requestCode, @Nullable Bundle options) {
       options = transferSpringboardActivityOptions(options);
       Instrumentation.ActivityResult ar =
           mInstrumentation.execStartActivity(
               this, mMainThread.getApplicationThread(), mToken, child,
               intent, requestCode, options);
       if (ar != null) {
           mMainThread.sendActivityResult(
               mToken, child.mEmbeddedID, requestCode,
               ar.getResultCode(), ar.getResultData());
       }
       cancelInputsAndStartExitTransition(options);
   }

接下来就关注Instrumentation，它调用了execStartActivity方法。

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
public ActivityResult execStartActivity(
           Context who, IBinder contextThread, IBinder token, Activity target,
           Intent intent, int requestCode, Bundle options) {
	//核心功能在whoThread中完成，器内部scheduleLaunchActivity方法用于完成activity的打开
       IApplicationThread whoThread = (IApplicationThread) contextThread;
       Uri referrer = target != null ? target.onProvideReferrer() : null;
       if (referrer != null) {
           intent.putExtra(Intent.EXTRA_REFERRER, referrer);
       }
       if (mActivityMonitors != null) {
           synchronized (mSync) {
               final int N = mActivityMonitors.size();
               for (int i=0; i<N; i++) {
                   final ActivityMonitor am = mActivityMonitors.get(i);
                   if (am.match(who, null, intent)) {
                       am.mHits++;
                       if (am.isBlocking()) {
                           return requestCode >= 0 ? am.getResult() : null;
                       }
                       break;
                   }
               }
           }
       }
       try {
           intent.migrateExtraStreamToClipData();
           intent.prepareToLeaveProcess(who);
		//这里是打开activity的地方，核心功能在whoThread中完成
           int result = ActivityManagerNative.getDefault()
               .startActivity(whoThread, who.getBasePackageName(), intent,
                       intent.resolveTypeIfNeeded(who.getContentResolver()),
                       token, target != null ? target.mEmbeddedID : null,
                       requestCode, 0, null, options);
		//专业抛异常的			
           checkStartActivityResult(result, intent);
       } catch (RemoteException e) {
           throw new RuntimeException("Failure from system", e);
       }
       return null;
   }

然后切入到ActivityManagerNative.getDefault().startActivity中，它是ActivityManagerProxy类，这里就是在处理一系列的数据。

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
public int startActivity(IApplicationThread caller, String callingPackage, Intent intent,
        String resolvedType, IBinder resultTo, String resultWho, int requestCode,
        int startFlags, ProfilerInfo profilerInfo, Bundle options) throws RemoteException {
    Parcel data = Parcel.obtain();
    Parcel reply = Parcel.obtain();
    data.writeInterfaceToken(IActivityManager.descriptor);
    data.writeStrongBinder(caller != null ? caller.asBinder() : null);
    data.writeString(callingPackage);
    intent.writeToParcel(data, 0);
    data.writeString(resolvedType);
    data.writeStrongBinder(resultTo);
    data.writeString(resultWho);
    data.writeInt(requestCode);
    data.writeInt(startFlags);
    if (profilerInfo != null) {
        data.writeInt(1);
        profilerInfo.writeToParcel(data, Parcelable.PARCELABLE_WRITE_RETURN_VALUE);
    } else {
        data.writeInt(0);
    }
    if (options != null) {
        data.writeInt(1);
        options.writeToParcel(data, 0);
    } else {
        data.writeInt(0);
    }
    mRemote.transact(START_ACTIVITY_TRANSACTION, data, reply, 0);
    reply.readException();
    int result = reply.readInt();
    reply.recycle();
    data.recycle();
    return result;
}

所以我们得看ActivityManagerNative.getDefault()，这里用了一个单例返回IActivityManager对象，并调用了asInterface来获取。关键就是mRemote发送了一个START_ACTIVITY_TRANSACTION消息给ActivityManagerNative。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
   /**
    * Retrieve the system's default/global activity manager.
    */
   static public IActivityManager getDefault() {
       return gDefault.get();
   }
private static final Singleton<IActivityManager> gDefault = new Singleton<IActivityManager>() {
       protected IActivityManager create() {
           IBinder b = ServiceManager.getService("activity");
           if (false) {
               Log.v("ActivityManager", "default service binder = " + b);
           }
           IActivityManager am = asInterface(b);
           if (false) {
               Log.v("ActivityManager", "default service = " + am);
           }
           return am;
       }
   };

这里就开始涉及Binder机制，大致就是ActivityManagerProxy作为客户端调用了startActivity方法，而具体的实现是在服务端(进行了startActivity调用)，对应的类为ActivityManagerService(同样继承自ActivityManagerNative)。接下来先看ActivityManagerNative。

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
public boolean onTransact(int code, Parcel data, Parcel reply, int flags)
           throws RemoteException {
       switch (code) {
       case START_ACTIVITY_TRANSACTION:
       {
           data.enforceInterface(IActivityManager.descriptor);
           IBinder b = data.readStrongBinder();
           IApplicationThread app = ApplicationThreadNative.asInterface(b);
           Intent intent = Intent.CREATOR.createFromParcel(data);
           String resolvedType = data.readString();
           Uri[] grantedUriPermissions = data.createTypedArray(Uri.CREATOR);
           int grantedMode = data.readInt();
           IBinder resultTo = data.readStrongBinder();
           String resultWho = data.readString();    
           int requestCode = data.readInt();
           boolean onlyIfNeeded = data.readInt() != 0;
           boolean debug = data.readInt() != 0;
           String profileFile = data.readString();
           ParcelFileDescriptor profileFd = data.readInt() != 0
                   ? data.readFileDescriptor() : null;
           boolean autoStopProfiler = data.readInt() != 0;
		//调用AMS的startActivity
           int result = startActivity(app, intent, resolvedType,
                   grantedUriPermissions, grantedMode, resultTo, resultWho,
                   requestCode, onlyIfNeeded, debug, profileFile, profileFd, autoStopProfiler);
           reply.writeNoException();
           reply.writeInt(result);
           return true;
       }
	//省略...
	}
}

之后就开始调用AMS中的startActivity了，服务端的startActivity从这里开始。

1
2
3
4
5
6
7
8
@Override
   public final int startActivity(IApplicationThread caller, String callingPackage,
           Intent intent, String resolvedType, IBinder resultTo, String resultWho, int requestCode,
           int startFlags, ProfilerInfo profilerInfo, Bundle bOptions) {
       return startActivityAsUser(caller, callingPackage, intent, resolvedType, resultTo,
               resultWho, requestCode, startFlags, profilerInfo, bOptions,
               UserHandle.getCallingUserId());
   }

整个客户端时序图如下：
启动流程第一部分

结束语

startActivity第一部分就到这里，从Binder机制来理解，这就是客户端部分，后面会深入到服务端部分。要注意这里是基于Android7.1.1的源码来分析，因为我发现Android4.0.3的代码中AMS中的startActivity就有一定的区别。

Posted on In

注册域名

为了让自己写博分享有一个更好的坚持，我在2017/10/10注册了本域名。经过了一整天的查找资料、创建github博客、配置Next主题，如今已基本成型，后续加入评论功能。

一个过程

使用Hexo和github搭建个人博客的文章已经很多了但是我还是要说说我个人搭建的一个过程。首先要知道搭建的环境，我们需要安装Git、Node.js、Hexo。这些安装过程网上都很多了，我这里推荐一篇博文,要注意的就是Hexo的初始化、生成、部署。
初始化

1
hexo init

生成

1
hexo generate

在部署前要记得执行以下命令，安装关联的git包

1
npm install hexo-deployer-git --save

如果npm执行失败，我们可以安装成淘宝镜像，之后用cnpm执行。

1
npm install -g cnpm --registry=https://registry.npm.taobao.org

如果前面hexo使用npm命令来安装，安装失败时也可以使用cnpm命令安装

1
cnpm install -g hexo-cli

生成完成后，就可以启动服务通过localhost:4000来预览了。

1
hexo server

以上都搞定后，我们进行注册一个github的帐号，接着创建一个项目
![New repository](/img/new repository.png)
创建的时候记得要跟Owner一样，这是github博客的一个规则。
接下就是配置git信息了，在hexo根目录下_config.yml文件，找到deploy标签，修改如下

1
2
3
4
deploy:
  type: git
  repo: https://github.com/username/username.github.io.git
  branch: master

接着我们要把东西部署到github上咯，
执行部署

1
hexo deploy

成功之后，我们就可以通过username.github.io来访问我们的个人博客了。
感觉是不是很神奇，结束了吗？还没有，如果你有自己的域名，就是可以配置上去。接下来开始配置域名。
我是阿里云买的域名，所以前往阿里云控制台，找到云解析DNS
云解析DNS
点击自己的域名后进入解析设置界面了，然后添加解析
添加解析
这里有很多类型,我们要添加其中两种A和CNAME。
新建A类设置中主机记录为空，记录值是IP地址，该地址有ping username.github.io得到。新建CNAME类设置中主机记录为www，记录值为username.github.io。这些都设置有之后我们找到Hexo根目录下的source文件夹中，新建CNAME文件没有后缀，通过记事本或者Notepad打开加入自己的域名。
这次真的完工了，在浏览器输入www.域名就可以访问到你的博客了。

结尾

最后就是说说以后写博的事，最少一个月一篇，多则一个星期一篇，希望在这个过程中不断提示自己的能力，提示自己的学习力。

————专注Android，填坑铺路