Welcome to Sky's Blog!

当你的才华配不上你的理想的时候, 就静下心来好好学习!

多线程

2019-10-12

Android

java中的多线程

Read All

Android中Activity启动(下)

2019-10-09

Android

Android进程创建

前言
1.1 涉及到的源码
1.2 在zygote中是怎么创建的

前言

在上一篇中已经提到了，分为两步，一步是开始activity，一步是创建进程，在上面的一篇中已经把开启
开启activity的部分讲到了，下面说下应用是怎么创建进程的.其中大量参考了gityuan先生的博客。并
根据博客的指示，来把代码跟了一遍.

1.1 涉及到的源码

/frameworks/base/core/java/com/android/internal/os/
    - ZygoteInit.java
    - ZygoteConnection.java
    - RuntimeInit.java
    - Zygote.java

/frameworks/base/core/java/android/os/Process.java
/frameworks/base/core/jni/com_android_internal_os_Zygote.cpp
/frameworks/base/core/jni/AndroidRuntime.cpp
/frameworks/base/cmds/app_process/App_main.cpp （内含AppRuntime类）

/bionic/libc/bionic/fork.cpp
/bionic/libc/bionic/pthread_atfork.cpp

/libcore/dalvik/src/main/java/dalvik/system/ZygoteHooks.java
/art/runtime/native/dalvik_system_ZygoteHooks.cc
/art/runtime/Runtime.cc
/art/runtime/Thread.cc
/art/runtime/signal_catcher.cc

在前面说到，启动进程的时候会调用的AMS类里面的startProcessLocked方法，最终还会调用到
Process.start这个方法

public static final ProcessStartResult start(final String processClass,
                                final String niceName,
                                int uid, int gid, int[] gids,
                                int runtimeFlags, int mountExternal,
                                int targetSdkVersion,
                                String seInfo,
                                String abi,
                                String instructionSet,
                                String appDataDir,
                                String invokeWith,
                                String[] zygoteArgs) {
      return zygoteProcess.start(processClass, niceName, uid, gid, gids,
                  runtimeFlags, mountExternal, targetSdkVersion, seInfo,
                  abi, instructionSet, appDataDir, invokeWith, zygoteArgs);
  }

接着调用ZygoteProcess.java里面的startViaZygote方法

private Process.ProcessStartResult startViaZygote(final String processClass,
                                                    final String niceName,
                                                    final int uid, final int gid,
                                                    final int[] gids,
                                                    int runtimeFlags, int mountExternal,
                                                    int targetSdkVersion,
                                                    String seInfo,
                                                    String abi,
                                                    String instructionSet,
                                                    String appDataDir,
                                                    String invokeWith,
                                                    boolean startChildZygote,
                                                    String[] extraArgs)
                                                    throws ZygoteStartFailedEx {
  .........................................................................
436
      synchronized(mLock) {
          return zygoteSendArgsAndGetResult(openZygoteSocketIfNeeded(abi), argsForZygote);
      }
  }

向在zygote进程里面注册的socket发送消息，在zygote进程里面注册新的进程.

private static Process.ProcessStartResult zygoteSendArgsAndGetResult(
          ZygoteState zygoteState, ArrayList<String> args)
          throws ZygoteStartFailedEx {
      try {
          // Throw early if any of the arguments are malformed. This means we can
          // avoid writing a partial response to the zygote.
          int sz = args.size();
          for (int i = 0; i < sz; i++) {
              if (args.get(i).indexOf('\n') >= 0) {
                  throw new ZygoteStartFailedEx("embedded newlines not allowed");
              }
          }
292
          /**
           * See com.android.internal.os.SystemZygoteInit.readArgumentList()
           * Presently the wire format to the zygote process is:
           * a) a count of arguments (argc, in essence)
           * b) a number of newline-separated argument strings equal to count
           *
           * After the zygote process reads these it will write the pid of
           * the child or -1 on failure, followed by boolean to
           * indicate whether a wrapper process was used.
           */
          final BufferedWriter writer = zygoteState.writer;
               //拿到输入流，写入服务器
          final DataInputStream inputStream = zygoteState.inputStream;
305
          writer.write(Integer.toString(args.size()));
          writer.newLine();
308
          for (int i = 0; i < sz; i++) {
              String arg = args.get(i);
              writer.write(arg);
              writer.newLine();
          }
314
          writer.flush();
316
          // Should there be a timeout on this?
          Process.ProcessStartResult result = new Process.ProcessStartResult();
319
          // Always read the entire result from the input stream to avoid leaving
          // bytes in the stream for future process starts to accidentally stumble
          // upon.
              //等待返回的pid
          result.pid = inputStream.readInt();
          result.usingWrapper = inputStream.readBoolean();
325
          if (result.pid < 0) {
              throw new ZygoteStartFailedEx("fork() failed");
          }
          return result;
      } catch (IOException ex) {
          zygoteState.close();
          throw new ZygoteStartFailedEx(ex);
      }
  }

去链接远程的socket

@GuardedBy("mLock")
  private ZygoteState openZygoteSocketIfNeeded(String abi) throws ZygoteStartFailedEx {
      Preconditions.checkState(Thread.holdsLock(mLock), "ZygoteProcess lock not held");
565
      if (primaryZygoteState == null || primaryZygoteState.isClosed()) {
          try {
              primaryZygoteState = ZygoteState.connect(mSocket);
          } catch (IOException ioe) {
              throw new ZygoteStartFailedEx("Error connecting to primary zygote", ioe);
          }
          maybeSetApiBlacklistExemptions(primaryZygoteState, false);
          maybeSetHiddenApiAccessLogSampleRate(primaryZygoteState);
      }
      if (primaryZygoteState.matches(abi)) {
          return primaryZygoteState;
      }
578
      // The primary zygote didn't match. Try the secondary.
      if (secondaryZygoteState == null || secondaryZygoteState.isClosed()) {
          try {
              secondaryZygoteState = ZygoteState.connect(mSecondarySocket);
          } catch (IOException ioe) {
              throw new ZygoteStartFailedEx("Error connecting to secondary zygote", ioe);
          }
          maybeSetApiBlacklistExemptions(secondaryZygoteState, false);
          maybeSetHiddenApiAccessLogSampleRate(secondaryZygoteState);
      }
589
      if (secondaryZygoteState.matches(abi)) {
          return secondaryZygoteState;
      }
593
      throw new ZygoteStartFailedEx("Unsupported zygote ABI: " + abi);
  }
596

1.2 在zygote中是怎么创建的

在前面已经说了, zygot是由init进程创建的，启动起来后会调用ZygoteInit.main方法，创建socket管道
然后runSelectLoop()，的带客户端发消息来创建进程

这些都在前面的章节中讲过，大致的伪代码

public static void main(String argv[]) {
    try {
        runSelectLoop(abiList); //【见小节5】
        ....
    } catch (MethodAndArgsCaller caller) {
        caller.run(); //【见小节16】
    } catch (RuntimeException ex) {
        closeServerSocket();
        throw ex;
    }
}

查看runSelectLoop方法

Runnable runSelectLoop(String abiList) {
      ArrayList<FileDescriptor> fds = new ArrayList<FileDescriptor>();
      ArrayList<ZygoteConnection> peers = new ArrayList<ZygoteConnection>();
176
      fds.add(mServerSocket.getFileDescriptor());
      peers.add(null);
179
      while (true) {
          StructPollfd[] pollFds = new StructPollfd[fds.size()];
          for (int i = 0; i < pollFds.length; ++i) {
              pollFds[i] = new StructPollfd();
              pollFds[i].fd = fds.get(i);
              pollFds[i].events = (short) POLLIN;
          }
          try {
              Os.poll(pollFds, -1);
          } catch (ErrnoException ex) {
              throw new RuntimeException("poll failed", ex);
          }
          for (int i = pollFds.length - 1; i >= 0; --i) {
              if ((pollFds[i].revents & POLLIN) == 0) {
                  continue;
              }
196
              if (i == 0) {
                       //等待远程命令
                  ZygoteConnection newPeer = acceptCommandPeer(abiList);
                  peers.add(newPeer);
                  fds.add(newPeer.getFileDesciptor());
              } else {
                  try {
                      ZygoteConnection connection = peers.get(i);
                           //获取到客户端发来的消息,来创建进程，看下面分析
                      final Runnable command = connection.processOneCommand(this);
205
                      if (mIsForkChild) {
                          // We're in the child. We should always have a command to run at this
                          // stage if processOneCommand hasn't called "exec".
                          if (command == null) {
                              throw new IllegalStateException("command == null");
                          }
212
                          return command;
                      } else {
                          // We're in the server - we should never have any commands to run.
                          if (command != null) {
                              throw new IllegalStateException("command != null");
                          }
219
                          // We don't know whether the remote side of the socket was closed or
                          // not until we attempt to read from it from processOneCommand. This shows up as
                          // a regular POLLIN event in our regular processing loop.
                          if (connection.isClosedByPeer()) {
                              connection.closeSocket();
                              peers.remove(i);
                              fds.remove(i);
                          }
                      }
                  } catch (Exception e) {
                      if (!mIsForkChild) {
                          // We're in the server so any exception here is one that has taken place
                          // pre-fork while processing commands or reading / writing from the
                          // control socket. Make a loud noise about any such exceptions so that
                          // we know exactly what failed and why.
235
                          Slog.e(TAG, "Exception executing zygote command: ", e);
237
                          // Make sure the socket is closed so that the other end knows immediately
                          // that something has gone wrong and doesn't time out waiting for a
                          // response.
                          ZygoteConnection conn = peers.remove(i);
                          conn.closeSocket();
243
                          fds.remove(i);
                      } else {
                          // We're in the child so any exception caught here has happened post
                          // fork and before we execute ActivityThread.main (or any other main()
                          // method). Log the details of the exception and bring down the process.
                          Log.e(TAG, "Caught post-fork exception in child process.", e);
                          throw e;
                      }
                  } finally {
                      // Reset the child flag, in the event that the child process is a child-
                      // zygote. The flag will not be consulted this loop pass after the Runnable
                      // is returned.
                      mIsForkChild = false;
                  }
              }
          }
      }
  }

调用ZygoteConnection 类里面的函数

Runnable processOneCommand(ZygoteServer zygoteServer) {
      String args[];
      .....................................................
233
           //fork进程
      pid = Zygote.forkAndSpecialize(parsedArgs.uid, parsedArgs.gid, parsedArgs.gids,
              parsedArgs.runtimeFlags, rlimits, parsedArgs.mountExternal, parsedArgs.seInfo,
              parsedArgs.niceName, fdsToClose, fdsToIgnore, parsedArgs.startChildZygote,
              parsedArgs.instructionSet, parsedArgs.appDataDir);
238
      try {
          if (pid == 0) {
              // in child
              zygoteServer.setForkChild();
243
              zygoteServer.closeServerSocket();
              IoUtils.closeQuietly(serverPipeFd);
              serverPipeFd = null;
247
              return handleChildProc(parsedArgs, descriptors, childPipeFd,
                      parsedArgs.startChildZygote);
          } else {
              // In the parent. A pid < 0 indicates a failure and will be handled in
              // handleParentProc.
              IoUtils.closeQuietly(childPipeFd);
              childPipeFd = null;
              handleParentProc(pid, descriptors, serverPipeFd);
              return null;
          }
      } finally {
          IoUtils.closeQuietly(childPipeFd);
          IoUtils.closeQuietly(serverPipeFd);
      }
  }

在Zygote.java中

public static int forkAndSpecialize(int uid, int gid, int[] gids, int runtimeFlags,
        int[][] rlimits, int mountExternal, String seInfo, String niceName, int[] fdsToClose,
        int[] fdsToIgnore, boolean startChildZygote, String instructionSet, String appDataDir) {
      VM_HOOKS.preFork();
      // Resets nice priority for zygote process.
      resetNicePriority();
      int pid = nativeForkAndSpecialize(
                uid, gid, gids, runtimeFlags, rlimits, mountExternal, seInfo, niceName, fdsToClose,
                fdsToIgnore, startChildZygote, instructionSet, appDataDir);
      // Enable tracing as soon as possible for the child process.
      if (pid == 0) {
          Trace.setTracingEnabled(true, runtimeFlags);
145
          // Note that this event ends at the end of handleChildProc,
          Trace.traceBegin(Trace.TRACE_TAG_ACTIVITY_MANAGER, "PostFork");
      }
      VM_HOOKS.postForkCommon();
      return pid;
  }

查看nativeForkAndSpecialize方法,调用到jni里面的方法com_android_internal_os_Zygote.cpp

public static int nativeForkAndSpecialize() { ………….. ForkAndSpecializeCommon(); ………….. }

Read All

Android中Activity启动(上)

2019-10-08

Android

Activity的开启

前言
1.1 涉及到的类
1.2 startActivity

前言

从一个App的角度来看，应用启动很简单，只用调用一下Activity中的startActivity方法就行了.但是背后
发生了什么？我想不管是一个App开发者还是FW开发者都应该掌握的.

我把这部分大致分为两个部分.
1. 开启Activity 2. 创建新的进程

1.1 涉及到的类

ActivityThread : 主要的App入口，一个应用的主线程
ApplicationThread ：代理类，继承了aidl接口, 在ActivityThread成员变量中创建
Instrumentation ：负责发起Activity的启动、并具体负责Activity的创建以及Activity生命周期的回调
一个应用里面只有一个Instrumentation对象,并且这个对象是在ActivityThread中创建的
ActivityManagerService ：管理所有Activity, 并且Acivity通过binder跨进程发送信息给
AMS,然后AMS通过Socket来创建进程. ActivityStack ： Activity在AMS的栈管理，用来记录已经启动的Activity的先后关系，状态信息等通
过ActivityStack决定是否需要启动新的进程。 ActivityRecord：ActivityStack的管理对象，每个Activity在AMS对应一个ActivityRecord，
来记录Activity的状态以及其他的管理信息。其实就是服务器端的Activity对象的映像

1.2 startActivity

在Activity中调用startActivity最终会调用到startActivityForResult

public void startActivityForResult(@RequiresPermission Intent intent, int requestCode,
            @Nullable Bundle options) {
        //没有设置父的Activity
        if (mParent == null) {
            options = transferSpringboardActivityOptions(options);
            Instrumentation.ActivityResult ar =
                //开启execStartActivity，mMainThread创建进程的时候的
                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);
            }
        }
    }

接着调用 execStartActivity

public ActivityResult execStartActivity(
          Context who, IBinder contextThread, IBinder token, Activity target,
          Intent intent, int requestCode, Bundle options) {
      .......................
      try {
          intent.migrateExtraStreamToClipData();
          intent.prepareToLeaveProcess(who);
                //通过binder获取AMS，实际上是调用的AMS中的startActivity
          int result = ActivityManager.getService()
              .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;
            ........................
  }
1679

可以看下ActivityManager.getService()实现

/**
   * @hide
   */
  public static IActivityManager getService() {
      return IActivityManagerSingleton.get();
  }
4128
  private static final Singleton<IActivityManager> IActivityManagerSingleton =
          new Singleton<IActivityManager>() {
              @Override
              protected IActivityManager create() {
                  final IBinder b = ServiceManager.getService(Context.ACTIVITY_SERVICE);
                        //就是AMS的binder接口
                  final IActivityManager am = IActivityManager.Stub.asInterface(b);
                  return am;
              }
          };

在AMS里面调用startActivity方法:

@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());
  }

这个地方其实和8.0的代码差别还是挺大的.mActivityStartController这个地方做了一个封装，运用建造者模式.
看来设计模式还要好好学学呀。源码中处处有设计模式的思想

public final int startActivityAsUser(IApplicationThread caller, String callingPackage,
          Intent intent, String resolvedType, IBinder resultTo, String resultWho, int requestCode,
          int startFlags, ProfilerInfo profilerInfo, Bundle bOptions, int userId,
          boolean validateIncomingUser) {
      enforceNotIsolatedCaller("startActivity");
5101
      userId = mActivityStartController.checkTargetUser(userId, validateIncomingUser,
              Binder.getCallingPid(), Binder.getCallingUid(), "startActivityAsUser");
      
      // TODO: Switch to user app stacks here.
      return mActivityStartController.obtainStarter(intent, "startActivityAsUser")
              .setCaller(caller)
              .setCallingPackage(callingPackage)
              .setResolvedType(resolvedType)
              .setResultTo(resultTo)
              .setResultWho(resultWho)
              .setRequestCode(requestCode)
              .setStartFlags(startFlags)
              .setProfilerInfo(profilerInfo)
              .setActivityOptions(bOptions)
              .setMayWait(userId)
              .execute();
5118
  }
5120

接着查看mActivityStartController类里面的obtainStarter方法

我就把这些全部都拿过来了.从代码里面看，构造函数里面传进了DefaultFactory.那接着查看DefaultFactory
在哪里创建。

ActivityStartController(ActivityManagerService service) {
      this(service, service.mStackSupervisor,
              new DefaultFactory(service, service.mStackSupervisor,
                  new ActivityStartInterceptor(service, service.mStackSupervisor)));
  }
119
  @VisibleForTesting
  ActivityStartController(ActivityManagerService service, ActivityStackSupervisor supervisor,
          Factory factory) {
      mService = service;
      mSupervisor = supervisor;
      mHandler = new StartHandler(mService.mHandlerThread.getLooper());
      mFactory = factory;
      mFactory.setController(this);
      mPendingRemoteAnimationRegistry = new PendingRemoteAnimationRegistry(service,
              service.mHandler);
  }
131
  /**
   * @return A starter to configure and execute starting an activity. It is valid until after
   *         {@link ActivityStarter#execute} is invoked. At that point, the starter should be
   *         considered invalid and no longer modified or used.
   */
  ActivityStarter obtainStarter(Intent intent, String reason) {
      return mFactory.obtain().setIntent(intent).setReason(reason);
  }
140

在ActivityStarter里面定义了DefaultFactory，其实就是调用ActivityStarter的execute()方法

static class DefaultFactory implements Factory {
      /**
       * The maximum count of starters that should be active at one time:
       * 1. last ran starter (for logging and post activity processing)
       * 2. current running starter
       * 3. starter from re-entry in (2)
       */
      private final int MAX_STARTER_COUNT = 3;
234
      private ActivityStartController mController;
      private ActivityManagerService mService;
      private ActivityStackSupervisor mSupervisor;
      private ActivityStartInterceptor mInterceptor;
239
      private SynchronizedPool<ActivityStarter> mStarterPool =
              new SynchronizedPool<>(MAX_STARTER_COUNT);
242
      DefaultFactory(ActivityManagerService service,
              ActivityStackSupervisor supervisor, ActivityStartInterceptor interceptor) {
          mService = service;
          mSupervisor = supervisor;
          mInterceptor = interceptor;
      }
249
      @Override
      public void setController(ActivityStartController controller) {
          mController = controller;
      }
254
      @Override
      public ActivityStarter obtain() {
          ActivityStarter starter = mStarterPool.acquire();
258
          if (starter == null) {
              starter = new ActivityStarter(mController, mService, mSupervisor, mInterceptor);
          }
262
          return starter;
      }
265
      @Override
      public void recycle(ActivityStarter starter) {
          starter.reset(true /* clearRequest*/);
          mStarterPool.release(starter);
      }
  }

最终调用到的是ActivityStarter的execute方法. 这里我就省略一下了

private int startActivity(final ActivityRecord r, ActivityRecord sourceRecord,
              IVoiceInteractionSession voiceSession, IVoiceInteractor voiceInteractor,
              int startFlags, boolean doResume, ActivityOptions options, TaskRecord inTask,
              ActivityRecord[] outActivity) {
          
          mService.mWindowManager.deferSurfaceLayout();
          result = startActivityUnchecked(r, sourceRecord, voiceSession, voiceInteractor,
                  startFlags, doResume, options, inTask, outActivity);
      
1213
      postStartActivityProcessing(r, result, mTargetStack);
1215
      return result;
  }

接着调用ActivityStarter的startActivityUnchecked方法

private int startActivityUnchecked(final ActivityRecord r, ActivityRecord sourceRecord,
1221            IVoiceInteractionSession voiceSession, IVoiceInteractor voiceInteractor,
1222            int startFlags, boolean doResume, ActivityOptions options, TaskRecord inTask,
1223            ActivityRecord[] outActivity) {
1224
1225        setInitialState(r, options, inTask, doResume, startFlags, sourceRecord, voiceSession,
1226                voiceInteractor);
1227
1228        computeLaunchingTaskFlags();
1229
1230        computeSourceStack();

            mTargetStack.startActivityLocked(mStartActivity, topFocused, newTask, mKeepCurTransition,

            mSupervisor.resumeFocusedStackTopActivityLocked();
1231}

boolean resumeFocusedStackTopActivityLocked(
          ActivityStack targetStack, ActivityRecord target, ActivityOptions targetOptions) {
2216
      if (!readyToResume()) {
          return false;
      }
2220
      if (targetStack != null && isFocusedStack(targetStack)) {
          return targetStack.resumeTopActivityUncheckedLocked(target, targetOptions);
      }
2224
      final ActivityRecord r = mFocusedStack.topRunningActivityLocked();
      if (r == null || !r.isState(RESUMED)) {
                //调用ActivityStack.java的resumeTopActivityUncheckedLocked
          mFocusedStack.resumeTopActivityUncheckedLocked(null, null);
      } else if (r.isState(RESUMED)) {
          // Kick off any lingering app transitions form the MoveTaskToFront operation.
          mFocusedStack.executeAppTransition(targetOptions);
      }
2232
      return false;
  }

boolean resumeTopActivityUncheckedLocked(ActivityRecord prev, ActivityOptions options) {
      if (mStackSupervisor.inResumeTopActivity) {
          // Don't even start recursing.
          return false;
      }
2287
      boolean result = false;
      try {
          // Protect against recursion.
          mStackSupervisor.inResumeTopActivity = true;
                //自身的resumeTopActivityInnerLocked方法啊
          result = resumeTopActivityInnerLocked(prev, options);
2293
          // When resuming the top activity, it may be necessary to pause the top activity (for
          // example, returning to the lock screen. We suppress the normal pause logic in
          // {@link #resumeTopActivityUncheckedLocked}, since the top activity is resumed at the
          // end. We call the {@link ActivityStackSupervisor#checkReadyForSleepLocked} again here
          // to ensure any necessary pause logic occurs. In the case where the Activity will be
          // shown regardless of the lock screen, the call to
          // {@link ActivityStackSupervisor#checkReadyForSleepLocked} is skipped.
          final ActivityRecord next = topRunningActivityLocked(true /* focusableOnly */);
          if (next == null || !next.canTurnScreenOn()) {
              checkReadyForSleep();
          }
      } finally {
          mStackSupervisor.inResumeTopActivity = false;
      }
2308
      return result;
  }

private boolean resumeTopActivityInnerLocked(ActivityRecord prev, ActivityOptions options) {
  if (mResumedActivity != null) {
2443            if (DEBUG_STATES) Slog.d(TAG_STATES,
2444                    "resumeTopActivityLocked: Pausing " + mResumedActivity);
                //当前的Activiyt肯定执行了resume,所以先调用了自己的onPause方法，通过IPC通信
2445            pausing |= startPausingLocked(userLeaving, false, next, false);
2446        }
      mStackSupervisor.startSpecificActivityLocked(next, true, true);
}

这个地方要注意, 如果这个进程没有启动过，

# com.android.server.am.ActivityStackSupervisor
void startSpecificActivityLocked(ActivityRecord r,
        boolean andResume, boolean checkConfig) {
    ...
    //这个地方取出来的为null,所以肯定会先创建进程
    ProcessRecord app = mService.getProcessRecordLocked(r.processName,
    1682                r.info.applicationInfo.uid, true);
    1683


    if (app != null && app.thread != null) {
        try {
    ...
            realStartActivityLocked(r, app, andResume, checkConfig);
            return;
        } catch (RemoteException e) {
           ...
        }

    }

    //去创建进程，这个在下面一章讲解
    mService.startProcessLocked(r.processName, r.info.applicationInfo, true, 0,
            "activity", r.intent.getComponent(), false, false, true);
}

上面的startProcessLocked会通过ActivityThread这个类创建一个进程，这个会在下面一个章节中讲解
这个地方先记着，会调用到ActivityThread的main函数.创建一个新进程

public static void main(String[] args) {
      Trace.traceBegin(Trace.TRACE_TAG_ACTIVITY_MANAGER, "ActivityThreadMain");
6625
      // CloseGuard defaults to true and can be quite spammy.  We
      // disable it here, but selectively enable it later (via
      // StrictMode) on debug builds, but using DropBox, not logs.
      CloseGuard.setEnabled(false);
6630
      Environment.initForCurrentUser();
6632
      // Set the reporter for event logging in libcore
      EventLogger.setReporter(new EventLoggingReporter());
6635
      // Make sure TrustedCertificateStore looks in the right place for CA certificates
      final File configDir = Environment.getUserConfigDirectory(UserHandle.myUserId());
      TrustedCertificateStore.setDefaultUserDirectory(configDir);
6639
      Process.setArgV0("<pre-initialized>");
6641
      Looper.prepareMainLooper();
6643
      // Find the value for {@link #PROC_START_SEQ_IDENT} if provided on the command line.
      // It will be in the format "seq=114"
      long startSeq = 0;
      if (args != null) {
          for (int i = args.length - 1; i >= 0; --i) {
              if (args[i] != null && args[i].startsWith(PROC_START_SEQ_IDENT)) {
                  startSeq = Long.parseLong(
                          args[i].substring(PROC_START_SEQ_IDENT.length()));
              }
          }
      }
            //创建ActivityThread对象，
      ActivityThread thread = new ActivityThread();
      thread.attach(false, startSeq);
6657
      if (sMainThreadHandler == null) {
          sMainThreadHandler = thread.getHandler();
      }
6661
      if (false) {
          Looper.myLooper().setMessageLogging(new
                  LogPrinter(Log.DEBUG, "ActivityThread"));
      }
6666
      // End of event ActivityThreadMain.
      Trace.traceEnd(Trace.TRACE_TAG_ACTIVITY_MANAGER);
            //开启looper循环，确保进程不退出
      Looper.loop();
6670
      throw new RuntimeException("Main thread loop unexpectedly exited");
  }
6673

函数attach最终调用了ActivityManagerService的远程接口ActivityManagerProxy的attachApplication函数,
传入的参数是mAppThread，这是一个ApplicationThread类型的Binder对象，它的作用是用来进行进程间通信的。

private void attach(boolean system, long startSeq) {
      sCurrentActivityThread = this;
      mSystemThread = system;
      if (!system) {
          ViewRootImpl.addFirstDrawHandler(new Runnable() {
              @Override
              public void run() {
                  ensureJitEnabled();
              }
          });
          android.ddm.DdmHandleAppName.setAppName("<pre-initialized>",
                                                  UserHandle.myUserId());
          RuntimeInit.setApplicationObject(mAppThread.asBinder());
                //获取到AMS对象
          final IActivityManager mgr = ActivityManager.getService();
          try {
                    //这个地方回调到AMS里面的attachApplication方法
              mgr.attachApplication(mAppThread, startSeq);
          } catch (RemoteException ex) {
              throw ex.rethrowFromSystemServer();
          }
          // Watch for getting close to heap limit.
          BinderInternal.addGcWatcher(new Runnable() {
              @Override public void run() {
                  if (!mSomeActivitiesChanged) {
                      return;
                  }
                  Runtime runtime = Runtime.getRuntime();
                  long dalvikMax = runtime.maxMemory();
                  long dalvikUsed = runtime.totalMemory() - runtime.freeMemory();
                  if (dalvikUsed > ((3*dalvikMax)/4)) {
                      if (DEBUG_MEMORY_TRIM) Slog.d(TAG, "Dalvik max=" + (dalvikMax/1024)
                              + " total=" + (runtime.totalMemory()/1024)
                              + " used=" + (dalvikUsed/1024));
                      mSomeActivitiesChanged = false;
                      try {
                          mgr.releaseSomeActivities(mAppThread);
                      } catch (RemoteException e) {
                          throw e.rethrowFromSystemServer();
                      }
                  }
              }
          });

上面获取到AMS并且调用到AMS里面的attachApplication方法, 接着调用AMS里面的attachApplicationLocked方法,

private final boolean attachApplicationLocked(IApplicationThread thread,
          int pid, int callingUid, long startSeq) {
  // See if the top visible activity is waiting to run in this process...
      if (normalMode) {
          try {
                      //调用ActivityStackSupervisor.java里面的attachApplicationLocked方法
              if (mStackSupervisor.attachApplicationLocked(app)) {
                  didSomething = true;
              }
          } catch (Exception e) {
              Slog.wtf(TAG, "Exception thrown launching activities in " + app, e);
              badApp = true;
          }
      }

}

ActivityStackSupervisor类里面的attachApplicationLocked方法

boolean attachApplicationLocked(ProcessRecord app) throws RemoteException {
      final String processName = app.processName;
      boolean didSomething = false;
      for (int displayNdx = mActivityDisplays.size() - 1; displayNdx >= 0; --displayNdx) {
          final ActivityDisplay display = mActivityDisplays.valueAt(displayNdx);
          for (int stackNdx = display.getChildCount() - 1; stackNdx >= 0; --stackNdx) {
              final ActivityStack stack = display.getChildAt(stackNdx);
              if (!isFocusedStack(stack)) {
                  continue;
              }
              stack.getAllRunningVisibleActivitiesLocked(mTmpActivityList);
              final ActivityRecord top = stack.topRunningActivityLocked();
              final int size = mTmpActivityList.size();
              for (int i = 0; i < size; i++) {
                  final ActivityRecord activity = mTmpActivityList.get(i);
                  if (activity.app == null && app.uid == activity.info.applicationInfo.uid
                          && processName.equals(activity.processName)) {
                      try {
                              // startActivity
                          if (realStartActivityLocked(activity, app,
                                  top == activity /* andResume */, true /* checkConfig */)) {
                              didSomething = true;
                          }
                      } catch (RemoteException e) {
                          Slog.w(TAG, "Exception in new application when starting activity "
                                  + top.intent.getComponent().flattenToShortString(), e);
                          throw e;
                      }
                  }
              }
          }
      }
      if (!didSomething) {
          ensureActivitiesVisibleLocked(null, 0, !PRESERVE_WINDOWS);
      }
      return didSomething;
  }

通过realStartActivityLocked方法来调用scheduleTransaction方法

final boolean realStartActivityLocked(ActivityRecord r, ProcessRecord app,
          boolean andResume, boolean checkConfig) throws RemoteException {

  // Create activity launch transaction.
              final ClientTransaction clientTransaction = ClientTransaction.obtain(app.thread,
                      r.appToken);
              clientTransaction.addCallback(LaunchActivityItem.obtain(new Intent(r.intent),
                      System.identityHashCode(r), r.info,
                      // TODO: Have this take the merged configuration instead of separate global
                      // and override configs.
                      mergedConfiguration.getGlobalConfiguration(),
                      mergedConfiguration.getOverrideConfiguration(), r.compat,
                      r.launchedFromPackage, task.voiceInteractor, app.repProcState, r.icicle,
                      r.persistentState, results, newIntents, mService.isNextTransitionForward(),
                      profilerInfo));
1534
              // Set desired final state.
              final ActivityLifecycleItem lifecycleItem;
              if (andResume) {
                  lifecycleItem = ResumeActivityItem.obtain(mService.isNextTransitionForward());
              } else {
                  lifecycleItem = PauseActivityItem.obtain();
              }
              clientTransaction.setLifecycleStateRequest(lifecycleItem);
1543
              // Schedule transaction.//在9.0上面这个地方重构了全部转化为Transaction一类的方法来
                    // 调用launch
              mService.getLifecycleManager().scheduleTransaction(clientTransaction);

}

调用ClientLifecycleManager 里面的scheduleTransaction方法

void scheduleTransaction(ClientTransaction transaction) throws RemoteException {
      final IApplicationThread client = transaction.getClient();
      transaction.schedule();
      if (!(client instanceof Binder)) {
          // If client is not an instance of Binder - it's a remote call and at this point it is
          // safe to recycle the object. All objects used for local calls will be recycled after
          // the transaction is executed on client in ActivityThread.
          transaction.recycle();
      }
  }

其实是调用了ClientTransaction中的schedule方法

private IApplicationThread mClient;
public void schedule() throws RemoteException {
129        mClient.scheduleTransaction(this);
130    }

IApplicationThread其实是一个aidl接口在ActivityThread中定义,
继续查看IApplicationThread里面的scheduleTransaction方法,

private class ApplicationThread extends IApplicationThread.Stub {
  ..........................
@Override
1539        public void scheduleTransaction(ClientTransaction transaction) throws RemoteException {
1540            ActivityThread.this.scheduleTransaction(transaction);
1541        }
}
  ..........................

接着调用ActivityThread里面的scheduleTransaction方法，如果你在ActivityThread类里面搜的话
是找不到的这个方法的.那就去查看是ActivityThread继承了谁ClientTransactionHandler，进而查找
这个里面的方法

/** Prepare and schedule transaction for execution. */
43    void scheduleTransaction(ClientTransaction transaction) {
44        transaction.preExecute(this);
          //调用ActivityThread类里面的方法sendMessage方法
45        sendMessage(ActivityThread.H.EXECUTE_TRANSACTION, transaction);
46    }
47

查看ActivityThread里面的sendMessage方法，不管怎样都会调用到mH的sendMessage方法

void sendMessage(int what, Object obj) {
      sendMessage(what, obj, 0, 0, false);
  }
2759
  private void sendMessage(int what, Object obj, int arg1) {
      sendMessage(what, obj, arg1, 0, false);
  }
2763
  private void sendMessage(int what, Object obj, int arg1, int arg2) {
      sendMessage(what, obj, arg1, arg2, false);
  }
2767
  private void sendMessage(int what, Object obj, int arg1, int arg2, boolean async) {
      if (DEBUG_MESSAGES) Slog.v(
          TAG, "SCHEDULE " + what + " " + mH.codeToString(what)
          + ": " + arg1 + " / " + obj);
      Message msg = Message.obtain();
      msg.what = what;
      msg.obj = obj;
      msg.arg1 = arg1;
      msg.arg2 = arg2;
      if (async) {
          msg.setAsynchronous(true);
      }
      mH.sendMessage(msg);
  }
2782
  private void sendMessage(int what, Object obj, int arg1, int arg2, int seq) {
      if (DEBUG_MESSAGES) Slog.v(
              TAG, "SCHEDULE " + mH.codeToString(what) + " arg1=" + arg1 + " arg2=" + arg2 +
                      "seq= " + seq);
      Message msg = Message.obtain();
      msg.what = what;
      SomeArgs args = SomeArgs.obtain();
      args.arg1 = obj;
      args.argi1 = arg1;
      args.argi2 = arg2;
      args.argi3 = seq;
      msg.obj = args;
      mH.sendMessage(msg);
  }

接着查看mH这个是什么，ActivityThread的成员变量

final H mH = new H();

class H extends Handler {
   public void handleMessage(Message msg) {
      .................
      case EXECUTE_TRANSACTION:
1807                    final ClientTransaction transaction = (ClientTransaction) msg.obj;
1808                    mTransactionExecutor.execute(transaction);
1809                    if (isSystem()) {
1810                        // Client transactions inside system process are recycled on the client side
1811                        // instead of ClientLifecycleManager to avoid being cleared before this
1812                        // message is handled.
1813                        transaction.recycle();
1814                    }
1815                    // TODO(lifecycler): Recycle locally scheduled transactions.
      .................
   }
}

接着查看mTransactionExecutor，这个成员变量是在ActivityThread里面被赋值的.TransactionExecutor.java

public void execute(ClientTransaction transaction) {
      final IBinder token = transaction.getActivityToken();
      log("Start resolving transaction for client: " + mTransactionHandler + ", token: " + token);
      
      executeCallbacks(transaction);
69
      executeLifecycleState(transaction);
      mPendingActions.clear();
      log("End resolving transaction");
  }

对于executeCallbacks和executeLifecycleState来说都是调用到了cycleToPath方法，查看这个方法

private void cycleToPath(ActivityClientRecord r, int finish,
          boolean excludeLastState) {
      final int start = r.getLifecycleState();
      log("Cycle from: " + start + " to: " + finish + " excludeLastState:" + excludeLastState);
      final IntArray path = mHelper.getLifecyclePath(start, finish, excludeLastState);
      performLifecycleSequence(r, path);
  }
167

继续调用到ActivityThread类里面的方法, mTransactionHandler是ActivityThread的父类

/** Transition the client through previously initialized state sequence. */
  private void performLifecycleSequence(ActivityClientRecord r, IntArray path) {
      final int size = path.size();
      for (int i = 0, state; i < size; i++) {
          state = path.get(i);
          log("Transitioning to state: " + state);
          switch (state) {
              case ON_CREATE:
                  mTransactionHandler.handleLaunchActivity(r, mPendingActions,
                          null /* customIntent */);
                  break;
              case ON_START:
                  mTransactionHandler.handleStartActivity(r, mPendingActions);
                  break;
              case ON_RESUME:
                  mTransactionHandler.handleResumeActivity(r.token, false /* finalStateRequest */,
                          r.isForward, "LIFECYCLER_RESUME_ACTIVITY");
                  break;
              case ON_PAUSE:
                  mTransactionHandler.handlePauseActivity(r.token, false /* finished */,
                          false /* userLeaving */, 0 /* configChanges */, mPendingActions,
                          "LIFECYCLER_PAUSE_ACTIVITY");
                  break;
              case ON_STOP:
                  mTransactionHandler.handleStopActivity(r.token, false /* show */,
                          0 /* configChanges */, mPendingActions, false /* finalStateRequest */,
                          "LIFECYCLER_STOP_ACTIVITY");
                  break;
              case ON_DESTROY:
                  mTransactionHandler.handleDestroyActivity(r.token, false /* finishing */,
                          0 /* configChanges */, false /* getNonConfigInstance */,
                          "performLifecycleSequence. cycling to:" + path.get(size - 1));
                  break;
              case ON_RESTART:
                  mTransactionHandler.performRestartActivity(r.token, false /* start */);
                  break;
              default:
                  throw new IllegalArgumentException("Unexpected lifecycle state: " + state);
          }
      }
  }

在ActivityThread里面调用handleLaunchActivity, 接着调用performLaunchActivity这个方法

private Activity performLaunchActivity(ActivityClientRecord r, Intent customIntent) {
   .......
   mInstrumentation.callActivityOnCreate(activity, r.state);
   .......
}

查看Instrumentation.java里面的callActivityOnCreate方法

终于调用到了performCreate的方法，调用Activity里面的oncreate方法
public void callActivityOnCreate(Activity activity, Bundle icicle) {
1270        prePerformCreate(activity);
1271        activity.performCreate(icicle);
1272        postPerformCreate(activity);
1273    }
1274

接着调用handleStartActivity方法，handleResumeActivity等方法，添加view的操作在onresume里面操作

Read All

bootchart性能分析工具

2019-09-27

Android

bootchart
bootchart简介

bootchart 可为整个系统提供所有进程的 CPU 和 I/O 负载细分。该工具不需要重建系统映像，可以用作进入 systrace 之前的快速健全性检查。(systrace)以后在聊

使用方法

首先在电脑上安装bootchart工具
```
sudo apt-get install bootchart
```
1. 启用bootchart
```
adb shell 'touch /data/bootchart/enabled'
adb reboot
```
1. 获取图表
  第一种方式：
  进入源码目录, 启动下面的脚本，会生成一个bootchat.png的图片 $ANDROID_BUILD_TOP/system/core/init/grab-bootchart.sh
第二种方式：
进入/data/bootchart/ 目录里面，执行 tar -czf bootchart.tar * 命令，把下面的资源打包，
然后pull出来, 接着用bootchat bootchart.tar 会自动生成一张bootchat.png图片

下面是我从google pixel2手机上抓取的一个启动时间图

整个图表以时间线为横轴，图标上方为 CPU 和磁盘的利用情况，下方是各进程的运行状态条，
显示各个进程的开始时间与结束时间以及对 CPU、I/O 的利用情况，我们关心的各个进程的运行时间以及
CPU 的使用情况，进而优化系统。
这里统计的是开启init进程到启动完成的时间, 并没有kernel的启动时间. 同样有的设备可以通过boot_completed这个时间段来确定,adb shell输入一下命令，
dmesg | grep -i boot_completed
[ 21.997797] init: processing action (sys.boot_completed=1) from (/init.rc:705)
从上面的意思来看应该是从init进程到boot_completed的时间为22s左右.如果要统计开机时间，还要加上kernel的时间
Read All

Android 开机启动流程之AMS(四)

2019-09-25

Android

AMS启动

4.1 前言
4.2 启动
4.3 AMS.start
4.4 AMS.setSystemProcess
4.5 startOtherServices
4.6 ActivityManagerService.systemReady

4.1 前言

前面已经提到过在SystemServer中启动了AMS，并且AMS是android系统中很重要的服务.记录着Activity的
开启,关闭，以及一些记录，同时我们所能看到的launcher也是通过AMS启动的。
源码:

<http://androidxref.com/9.0.0_r3/xref/frameworks/base/services/core/java/com/android/server/am/ActivityManagerService.java>

4.2 启动

AMS是在SystemServer中创建的，只copy出来了主要代码

private void startBootstrapServices() {
  // Activity manager runs the show.
558        traceBeginAndSlog("StartActivityManager");
           //实例化对象
559        mActivityManagerService = mSystemServiceManager.startService(
560                ActivityManagerService.Lifecycle.class).getService();
           //把自己添加为binder service，从而别的进程调用
           mActivityManagerService.setSystemProcess();

}

先看下Lifecycle这个类是干嘛的，继承了SystemService，然后在构造函数中把AMS的对象实例化出来

public static final class Lifecycle extends SystemService {
      private final ActivityManagerService mService;
2879
      public Lifecycle(Context context) {
          super(context);
          mService = new ActivityManagerService(context);
      }
2884
      @Override
      public void onStart() {
          mService.start();
      }
2889
      @Override
      public void onBootPhase(int phase) {
          mService.mBootPhase = phase;
          if (phase == PHASE_SYSTEM_SERVICES_READY) {
              mService.mBatteryStatsService.systemServicesReady();
              mService.mServices.systemServicesReady();
          }
      }
2898
      @Override
      public void onCleanupUser(int userId) {
          mService.mBatteryStatsService.onCleanupUser(userId);
      }
2903
      public ActivityManagerService getService() {
          return mService;
      }
  }

接着看SystemServiceManager的startService方法，在这个方法里面通过反射实例化了lifecycle这个类

*/
  @SuppressWarnings("unchecked")
  public <T extends SystemService> T startService(Class<T> serviceClass) {
      try {
          final String name = serviceClass.getName();
          Slog.i(TAG, "Starting " + name);
          Trace.traceBegin(Trace.TRACE_TAG_SYSTEM_SERVER, "StartService " + name);
89
          // Create the service.
          if (!SystemService.class.isAssignableFrom(serviceClass)) {
              throw new RuntimeException("Failed to create " + name
                      + ": service must extend " + SystemService.class.getName());
          }
          final T service;
          try {
                  //通过构造函数实例化lifecycle对象
              Constructor<T> constructor = serviceClass.getConstructor(Context.class);
              service = constructor.newInstance(mContext);
          } catch (InstantiationException ex) {
              throw new RuntimeException("Failed to create service " + name
                      + ": service could not be instantiated", ex);
          } catch (IllegalAccessException ex) {
              throw new RuntimeException("Failed to create service " + name
                      + ": service must have a public constructor with a Context argument", ex);
          } catch (NoSuchMethodException ex) {
              throw new RuntimeException("Failed to create service " + name
                      + ": service must have a public constructor with a Context argument", ex);
          } catch (InvocationTargetException ex) {
              throw new RuntimeException("Failed to create service " + name
                      + ": service constructor threw an exception", ex);
          }
112
          startService(service);
          return service;
      } finally {
          Trace.traceEnd(Trace.TRACE_TAG_SYSTEM_SERVER);
      }
  }

//调用lifecycle的onstart方法，也就是调用AMS的onStart方法
public void startService(@NonNull final SystemService service) {
      // Register it.
      mServices.add(service);
      // Start it.
      long time = SystemClock.elapsedRealtime();
      try {
          service.onStart();
      } catch (RuntimeException ex) {
          throw new RuntimeException("Failed to start service " + service.getClass().getName()
                  + ": onStart threw an exception", ex);
      }
      warnIfTooLong(SystemClock.elapsedRealtime() - time, service, "onStart");
  }

到这里AMS的对象通过lifecycle实例化了。并且onStart方法开始运行了,我们来看看AMS里面是怎么实例化的

// handlers to other threads.  So take care to be explicit about the looper.
  public ActivityManagerService(Context systemContext) {
      LockGuard.installLock(this, LockGuard.INDEX_ACTIVITY);
      mInjector = new Injector();
      mContext = systemContext;
3051
      mFactoryTest = FactoryTest.getMode();
      mSystemThread = ActivityThread.currentActivityThread();
      mUiContext = mSystemThread.getSystemUiContext();
3055
      Slog.i(TAG, "Memory class: " + ActivityManager.staticGetMemoryClass());
3057
      mPermissionReviewRequired = mContext.getResources().getBoolean(
              com.android.internal.R.bool.config_permissionReviewRequired);
      /创建名为"ActivityManager"的前台线程，并获取mHandler
      mHandlerThread = new ServiceThread(TAG,
              THREAD_PRIORITY_FOREGROUND, false /*allowIo*/);
      mHandlerThread.start();
      mHandler = new MainHandler(mHandlerThread.getLooper());
      mUiHandler = mInjector.getUiHandler(this);
3066
      mProcStartHandlerThread = new ServiceThread(TAG + ":procStart",
              THREAD_PRIORITY_FOREGROUND, false /* allowIo */);
      mProcStartHandlerThread.start();
      mProcStartHandler = new Handler(mProcStartHandlerThread.getLooper());
3071
      mConstants = new ActivityManagerConstants(this, mHandler);
3073
      /* static; one-time init here */
      if (sKillHandler == null) {
          sKillThread = new ServiceThread(TAG + ":kill",
                  THREAD_PRIORITY_BACKGROUND, true /* allowIo */);
          sKillThread.start();
          sKillHandler = new KillHandler(sKillThread.getLooper());
      }
      
            //前台广播接收器，超时时间为10S
      mFgBroadcastQueue = new BroadcastQueue(this, mHandler,
              "foreground", BROADCAST_FG_TIMEOUT, false);
            //后台广播接收器，超时时间为60S
      mBgBroadcastQueue = new BroadcastQueue(this, mHandler,
              "background", BROADCAST_BG_TIMEOUT, true);
      mBroadcastQueues[0] = mFgBroadcastQueue;
      mBroadcastQueues[1] = mBgBroadcastQueue;
3088
      mServices = new ActiveServices(this);
      mProviderMap = new ProviderMap(this);
      mAppErrors = new AppErrors(mUiContext, this);
      
            //创建目录/data/system
      File dataDir = Environment.getDataDirectory();
      File systemDir = new File(dataDir, "system");
      systemDir.mkdirs();
3096
      mAppWarnings = new AppWarnings(this, mUiContext, mHandler, mUiHandler, systemDir);
      //创建服务BatteryStatsService
      // TODO: Move creation of battery stats service outside of activity manager service.
      mBatteryStatsService = new BatteryStatsService(systemContext, systemDir, mHandler);
      mBatteryStatsService.getActiveStatistics().readLocked();
      mBatteryStatsService.scheduleWriteToDisk();
      mOnBattery = DEBUG_POWER ? true
              : mBatteryStatsService.getActiveStatistics().getIsOnBattery();
      mBatteryStatsService.getActiveStatistics().setCallback(this);
3106
            //创建进程统计服务，信息保存在目录/data/system/procstats，
      mProcessStats = new ProcessStatsService(this, new File(systemDir, "procstats"));
3108
      mAppOpsService = mInjector.getAppOpsService(new File(systemDir, "appops.xml"), mHandler);
3110
      mGrantFile = new AtomicFile(new File(systemDir, "urigrants.xml"), "uri-grants");
3112
      mUserController = new UserController(this);
3114
      mVrController = new VrController(this);
3116
      GL_ES_VERSION = SystemProperties.getInt("ro.opengles.version",
          ConfigurationInfo.GL_ES_VERSION_UNDEFINED);
3119
      if (SystemProperties.getInt("sys.use_fifo_ui", 0) != 0) {
          mUseFifoUiScheduling = true;
      }
3123
      mTrackingAssociations = "1".equals(SystemProperties.get("debug.track-associations"));
      mTempConfig.setToDefaults();
      mTempConfig.setLocales(LocaleList.getDefault());
      mConfigurationSeq = mTempConfig.seq = 1;
      mStackSupervisor = createStackSupervisor();
      mStackSupervisor.onConfigurationChanged(mTempConfig);
      mKeyguardController = mStackSupervisor.getKeyguardController();
      mCompatModePackages = new CompatModePackages(this, systemDir, mHandler);
      mIntentFirewall = new IntentFirewall(new IntentFirewallInterface(), mHandler);
      mTaskChangeNotificationController =
              new TaskChangeNotificationController(this, mStackSupervisor, mHandler);
      mActivityStartController =  new ActivityStartController(this);
      mRecentTasks = createRecentTasks();
      mStackSupervisor.setRecentTasks(mRecentTasks);
      mLockTaskController = new LockTaskController(mContext, mStackSupervisor, mHandler);
      mLifecycleManager = new ClientLifecycleManager();
3140
            //创建名为"CpuTracker"的线程
      mProcessCpuThread = new Thread("CpuTracker") {
          @Override
          public void run() {
              synchronized (mProcessCpuTracker) {
                  mProcessCpuInitLatch.countDown();
                  mProcessCpuTracker.init();
              }
              while (true) {
                  try {
                      try {
                          synchronized(this) {
                              final long now = SystemClock.uptimeMillis();
                              long nextCpuDelay = (mLastCpuTime.get()+MONITOR_CPU_MAX_TIME)-now;
                              lon g nextWriteDelay = (mLastWriteTime+BATTERY_STATS_TIME)-now;
                              //Slog.i(TAG, "Cpu delay=" + nextCpuDelay
                              //        + ", write delay=" + nextWriteDelay);
                              if (nextWriteDelay < nextCpuDelay) {
                                  nextCpuDelay = nextWriteDelay;
                              }
                              if (nextCpuDelay > 0) {
                                  mProcessCpuMutexFree.set(true);
                                  this.wait(nextCpuDelay);
                              }
                          }
                      } catch (InterruptedException e) {
                      }
                            //更新CPU的状态
                      updateCpuStatsNow();
                  } catch (Exception e) {
                      Slog.e(TAG, "Unexpected exception collecting process stats", e);
                  }
              }
          }
      };
3174
      mHiddenApiBlacklist = new HiddenApiSettings(mHandler, mContext);
3176
      Watchdog.getInstance().addMonitor(this);
      Watchdog.getInstance().addThread(mHandler);
3179
      // bind background thread to little cores
      // this is expected to fail inside of framework tests because apps can't touch cpusets directly
      // make sure we've already adjusted system_server's internal view of itself first
      updateOomAdjLocked();
      try {
          Process.setThreadGroupAndCpuset(BackgroundThread.get().getThreadId(),
                  Process.THREAD_GROUP_BG_NONINTERACTIVE);
      } catch (Exception e) {
          Slog.w(TAG, "Setting background thread cpuset failed");
      }
3190
  }

4.3 AMS.start

private void start() {
            //移除所有的进程组
      removeAllProcessGroups();
            //CpuTracker线程开启
      mProcessCpuThread.start();
      //启动电池统计服务
      mBatteryStatsService.publish();
      mAppOpsService.publish(mContext);
      Slog.d("AppOps", "AppOpsService published");
            //添加到本地的service，这个地方只能在同一个进程里面可以调用，这个地方很重要，因为下面还有一个binder service
      LocalServices.addService(ActivityManagerInternal.class, new LocalService());
      // Wait for the synchronized block started in mProcessCpuThread,
      // so that any other acccess to mProcessCpuTracker from main thread
      // will be blocked during mProcessCpuTracker initialization.
      try {
          mProcessCpuInitLatch.await();
      } catch (InterruptedException e) {
          Slog.wtf(TAG, "Interrupted wait during start", e);
          Thread.currentThread().interrupt();
          throw new IllegalStateException("Interrupted wait during start");
      }
  }

4.4 AMS.setSystemProcess

在systemserver类的startBootstrapServices方法会调用setSystemProcess方法,这里有一个地方很重要
我也是找了半天才看出来, 添加binder service,为跨进程通信使用，我当时纳闷了好久，因为在ActivityManager中
会用到这个binder service，我找了很长时间才找到

ServiceManager.addService(Context.ACTIVITY_SERVICE, this, /* allowIsolated= */ true, DUMP_FLAG_PRIORITY_CRITICAL | DUMP_FLAG_PRIORITY_NORMAL |

这个方法里面主要就是注册各种服务

public void setSystemProcess() {
      try {
          ServiceManager.addService(Context.ACTIVITY_SERVICE, this, /* allowIsolated= */ true,
                  DUMP_FLAG_PRIORITY_CRITICAL | DUMP_FLAG_PRIORITY_NORMAL | DUMP_FLAG_PROTO);
          ServiceManager.addService(ProcessStats.SERVICE_NAME, mProcessStats);
          ServiceManager.addService("meminfo", new MemBinder(this), /* allowIsolated= */ false,
                  DUMP_FLAG_PRIORITY_HIGH);
          ServiceManager.addService("gfxinfo", new GraphicsBinder(this));
          ServiceManager.addService("dbinfo", new DbBinder(this));
          if (MONITOR_CPU_USAGE) {
              ServiceManager.addService("cpuinfo", new CpuBinder(this),
                      /* allowIsolated= */ false, DUMP_FLAG_PRIORITY_CRITICAL);
          }
          ServiceManager.addService("permission", new PermissionController(this));
          ServiceManager.addService("processinfo", new ProcessInfoService(this));
2735
          ApplicationInfo info = mContext.getPackageManager().getApplicationInfo(
                  "android", STOCK_PM_FLAGS | MATCH_SYSTEM_ONLY);
          mSystemThread.installSystemApplicationInfo(info, getClass().getClassLoader());
2739
          synchronized (this) {
              ProcessRecord app = newProcessRecordLocked(info, info.processName, false, 0);
              app.persistent = true;
              app.pid = MY_PID;
              app.maxAdj = ProcessList.SYSTEM_ADJ;
              app.makeActive(mSystemThread.getApplicationThread(), mProcessStats);
              synchronized (mPidsSelfLocked) {
                  mPidsSelfLocked.put(app.pid, app);
              }
              updateLruProcessLocked(app, false, null);
              updateOomAdjLocked();
          }
      } catch (PackageManager.NameNotFoundException e) {
          throw new RuntimeException(
                  "Unable to find android system package", e);
      }
2756
      // Start watching app ops after we and the package manager are up and running.
      mAppOpsService.startWatchingMode(AppOpsManager.OP_RUN_IN_BACKGROUND, null,
              new IAppOpsCallback.Stub() {
                  @Override public void opChanged(int op, int uid, String packageName) {
                      if (op == AppOpsManager.OP_RUN_IN_BACKGROUND && packageName != null) {
                          if (mAppOpsService.checkOperation(op, uid, packageName)
                                  != AppOpsManager.MODE_ALLOWED) {
                              runInBackgroundDisabled(uid);
                          }
                      }
                  }
              });
  }

4.5 startOtherServices

//在systemserer里面调用AMS的systemready方法
private void startOtherServices() {
  mActivityManagerService.systemReady(new goingCallback()) {
    startSystemUi();
  }
}

4.6 ActivityManagerService.systemReady

这里大概的流程

public void systemReady(final Runnable goingCallback) {

        ...//更新操作
        mSystemReady = true; //系统处于ready状态
        removeProcessLocked(proc, true, false, "system update done");//杀掉所有非persistent进程
        mProcessesReady = true;  //进程处于ready状态

        goingCallback.run(); //这里有可能启动进程。这里会启动systemui

        addAppLocked(info, false, null); //启动所有的persistent进程
        mBooting = true;  //正在启动中
        startHomeActivityLocked(mCurrentUserId, "systemReady"); //启动launcher
        mStackSupervisor.resumeTopActivitiesLocked(); //恢复栈顶的Activity
    }

avatar 大致的流程:
忽略我的没有注册的staruml软件 ==! avatar

Read All

Android 开机启动流程SystemServer下篇(三)

2019-09-18

Android

SystemServer

3.1 main
3.2 SystemServer run
3.3 createSystemContext

源码

</frameworks/base/services/java/com/android/server/SystemServer.java>

上面的文章中我们知道了怎么通过zygote来启动SystemServer进程，接下来我们来具体分析SystemServer里面的细节

3.1 main

在zygote里面会通过反射来调用到main方法

public static void main(String[] args) {
294        new SystemServer().run();
295    }

3.2 SystemServer run

private void run() {
      try {
          traceBeginAndSlog("InitBeforeStartServices");
          // If a device's clock is before 1970 (before 0), a lot of
          // APIs crash dealing with negative numbers, notably
          // java.io.File#setLastModified, so instead we fake it and
          // hope that time from cell towers or NTP fixes it shortly.
               如果时间比1970年早, 设置为1970年
          if (System.currentTimeMillis() < EARLIEST_SUPPORTED_TIME) {
              Slog.w(TAG, "System clock is before 1970; setting to 1970.");
              SystemClock.setCurrentTimeMillis(EARLIEST_SUPPORTED_TIME);
          }
318
          //
          // Default the timezone property to GMT if not set.
          //
          String timezoneProperty =  SystemProperties.get("persist.sys.timezone");
          if (timezoneProperty == null || timezoneProperty.isEmpty()) {
              Slog.w(TAG, "Timezone not set; setting to GMT.");
              SystemProperties.set("persist.sys.timezone", "GMT");
          }
327
          // If the system has "persist.sys.language" and friends set, replace them with
          // "persist.sys.locale". Note that the default locale at this point is calculated
          // using the "-Duser.locale" command line flag. That flag is usually populated by
          // AndroidRuntime using the same set of system properties, but only the system_server
          // and system apps are allowed to set them.
          //
          // NOTE: Most changes made here will need an equivalent change to
          // core/jni/AndroidRuntime.cpp
          if (!SystemProperties.get("persist.sys.language").isEmpty()) {
              final String languageTag = Locale.getDefault().toLanguageTag();
338
              SystemProperties.set("persist.sys.locale", languageTag);
              SystemProperties.set("persist.sys.language", "");
              SystemProperties.set("persist.sys.country", "");
              SystemProperties.set("persist.sys.localevar", "");
          }
344
          // The system server should never make non-oneway calls
          Binder.setWarnOnBlocking(true);
          // The system server should always load safe labels
          PackageItemInfo.setForceSafeLabels(true);
          // Deactivate SQLiteCompatibilityWalFlags until settings provider is initialized
          SQLiteCompatibilityWalFlags.init(null);
351
          // Here we go!
          Slog.i(TAG, "Entered the Android system server!");
          int uptimeMillis = (int) SystemClock.elapsedRealtime();
          EventLog.writeEvent(EventLogTags.BOOT_PROGRESS_SYSTEM_RUN, uptimeMillis);
          if (!mRuntimeRestart) {
              MetricsLogger.histogram(null, "boot_system_server_init", uptimeMillis);
          }
359
          // In case the runtime switched since last boot (such as when
          // the old runtime was removed in an OTA), set the system
          // property so that it is in sync. We can | xq oqi't do this in
          // libnativehelper's JniInvocation::Init code where we already
          // had to fallback to a different runtime because it is
          // running as root and we need to be the system user to set
          // the property. http://b/11463182
          SystemProperties.set("persist.sys.dalvik.vm.lib.2", VMRuntime.getRuntime().vmLibrary());
368
          // Mmmmmm... more memory!
          VMRuntime.getRuntime().clearGrowthLimit();
371
          // The system server has to run all of the time, so it needs to be
          // as efficient as possible with its memory usage.
          VMRuntime.getRuntime().setTargetHeapUtilization(0.8f);
375
          // Some devices rely on runtime fingerprint generation, so make sure
          // we've defined it before booting further.
          Build.ensureFingerprintProperty();
379
          // Within the system server, it is an error to access Environment paths without
          // explicitly specifying a user.
          Environment.setUserRequired(true);
383
          // Within the system server, any incoming Bundles should be defused
          // to avoid throwing BadParcelableException.
          BaseBundle.setShouldDefuse(true);
387
          // Within the system server, when parceling exceptions, include the stack trace
          Parcel.setStackTraceParceling(true);
390
          // Ensure binder calls into the system always run at foreground priority.
          BinderInternal.disableBackgroundScheduling(true);
393
          // Increase the number of binder threads in system_server
          BinderInternal.setMaxThreads(sMaxBinderThreads);
396
          // Prepare the main looper thread (this thread).
          android.os.Process.setThreadPriority(
              android.os.Process.THREAD_PRIORITY_FOREGROUND);
          android.os.Process.setCanSelfBackground(false);
          Looper.prepareMainLooper();
          Looper.getMainLooper().setSlowLogThresholdMs(
                  SLOW_DISPATCH_THRESHOLD_MS, SLOW_DELIVERY_THRESHOLD_MS);
404
          // Initialize native services.
          System.loadLibrary("android_servers");
407
          // Check whether we failed to shut down last time we tried.
          // This call may not return.
          performPendingShutdown();
411
          // Initialize the system context.
               //创建系统的上下文
          createSystemContext();
414
          // Create the system service manager.
               //系统服务管理者
          mSystemServiceManager = new SystemServiceManager(mSystemContext);
          mSystemServiceManager.setStartInfo(mRuntimeRestart,
                  mRuntimeStartElapsedTime, mRuntimeStartUptime);
          LocalServices.addService(SystemServiceManager.class, mSystemServiceManager);
          // Prepare the thread pool for init tasks that can be parallelized
          SystemServerInitThreadPool.get();
      } finally {
          traceEnd();  // InitBeforeStartServices
      }
425
      // Start services.
      try {
          traceBeginAndSlog("StartServices");
          startBootstrapServices(); // 启动引导服务
          startCoreServices(); //核心服务
          startOtherServices(); //一些其它的服务
          SystemServerInitThreadPool.shutdown();
      } catch (Throwable ex) {
          Slog.e("System", "******************************************");
          Slog.e("System", "************ Failure starting system services", ex);
          throw ex;
      } finally {
          traceEnd();
      }
440
      StrictMode.initVmDefaults(null);
442
      if (!mRuntimeRestart && !isFirstBootOrUpgrade()) {
          int uptimeMillis = (int) SystemClock.elapsedRealtime();
          MetricsLogger.histogram(null, "boot_system_server_ready", uptimeMillis);
          final int MAX_UPTIME_MILLIS = 60 * 1000;
          if (uptimeMillis > MAX_UPTIME_MILLIS) {
              Slog.wtf(SYSTEM_SERVER_TIMING_TAG,
                      "SystemServer init took too long. uptimeMillis=" + uptimeMillis);
          }
      }
      //保证SystemServer进程一直存活
      // Loop forever.
      Looper.loop();
      throw new RuntimeException("Main thread loop unexpectedly exited");
  }

3.3 createSystemContext

private void createSystemContext() {
           //创建ActivityThread, 在systemMain函数里面调用ActivityThread的构造函数
           //ActivityThread thread = new ActivityThread();
522        ActivityThread activityThread = ActivityThread.systemMain();
523        mSystemContext = activityThread.getSystemContext();
524        mSystemContext.setTheme(DEFAULT_SYSTEM_THEME);
525
526        final Context systemUiContext = activityThread.getSystemUiContext();
527        systemUiContext.setTheme(DEFAULT_SYSTEM_THEME);
528    }
529

当然在SystemServer里面启动了好多的java层的service，他们内部通过binder 来进行通信，这个地方就暂时不说了
以后会专门开一篇来说SystemServer里面启动的服务，以及怎么通过binder来进行通信的。到这个地方我们的SystemServer
算是启动完成了，那下面是怎么启动到launcher呢，继续看下一篇文章。

Read All

1/6

Welcome to Sky's Blog!

多线程

Android中Activity启动(下)

前言

1.1 涉及到的源码

1.2 在zygote中是怎么创建的

Android中Activity启动(上)

前言

1.1 涉及到的类

1.2 startActivity

bootchart性能分析工具

bootchart简介

使用方法

下面是我从google pixel2手机上抓取的一个启动时间图

Android 开机启动流程之AMS(四)

4.1 前言

4.2 启动

4.3 AMS.start

4.4 AMS.setSystemProcess

4.5 startOtherServices

4.6 ActivityManagerService.systemReady

Android 开机启动流程SystemServer下篇(三)

3.1 main

3.2 SystemServer run

3.3 createSystemContext