AI 助理
备案控制台
开发者社区 开发与运维 文章 正文

[Android]从Launcher开始启动App流程源码分析

2015-12-03 783
版权
版权声明：
本文内容由阿里云实名注册用户自发贡献，版权归原作者所有，阿里云开发者社区不拥有其著作权，亦不承担相应法律责任。具体规则请查看《 阿里云开发者社区用户服务协议》和 《阿里云开发者社区知识产权保护指引》。如果您发现本社区中有涉嫌抄袭的内容，填写 侵权投诉表单进行举报，一经查实，本社区将立刻删除涉嫌侵权内容。
简介： 以下内容为原创，欢迎转载，转载请注明来自天天博客：http://www.cnblogs.com/tiantianbyconan/p/5017056.html从Launcher开始启动App流程源码分析com.


以下内容为原创，欢迎转载，转载请注明
来自天天博客：http://www.cnblogs.com/tiantianbyconan/p/5017056.html

从Launcher开始启动App流程源码分析

com.android.launcher.Launcher就是我们的Launcher页面了，可以看到Launcher其实也是一个Activity：

public final class Launcher extends Activity implements View.OnClickListener, OnLongClickListener {
    // ...
}

既然是Activity，那当然也会有onCreate、onResume等生命周期了，按照逻辑，应该会去加载所有App，以网格的布局显示在页面上，果然，在onResume看到了这个方法：

@Override
protected void onResume() {
    super.onResume();
    if (mRestoring) {
        startLoaders();
    }
    // ...
}

看方法名就可以猜到这个方法就是用来加载所有App信息的，进入这个方法：

private void startLoaders() {
    boolean loadApplications = sModel.loadApplications(true, this, mLocaleChanged);
    sModel.loadUserItems(!mLocaleChanged, this, mLocaleChanged, loadApplications);
    mRestoring = false;
}

这里调用sModel（LauncherModel类型）的loadUserItems方法去加载数据了，sModel明显属于Model层，进入loadUserItems方法：

void loadUserItems(boolean isLaunching, Launcher launcher, boolean localeChanged,
            boolean loadApplications) {
    // ...
        mDesktopItemsLoaded = false;
        mDesktopItemsLoader = new DesktopItemsLoader(launcher, localeChanged, loadApplications,
                isLaunching);
        mDesktopLoaderThread = new Thread(mDesktopItemsLoader, "Desktop Items Loader");
        mDesktopLoaderThread.start();
    // ...
}

然后使用DesktopItemsLoader在mDesktopLoaderThread线程中加载，：

private class DesktopItemsLoader implements Runnable {
    // ...
    public void run() {
        // ...
        final Cursor c = contentResolver.query(LauncherSettings.Favorites.CONTENT_URI, null, null, null, null);
        // ...
        final int idIndex = c.getColumnIndexOrThrow(LauncherSettings.Favorites._ID);
        final int intentIndex = c.getColumnIndexOrThrow(LauncherSettings.Favorites.INTENT);
        final int titleIndex = c.getColumnIndexOrThrow(LauncherSettings.Favorites.TITLE);
        final int iconTypeIndex = c.getColumnIndexOrThrow(LauncherSettings.Favorites.ICON_TYPE);
        final int iconIndex = c.getColumnIndexOrThrow(LauncherSettings.Favorites.ICON);
        final int iconPackageIndex = c.getColumnIndexOrThrow(LauncherSettings.Favorites.ICON_PACKAGE);
        final int iconResourceIndex = c.getColumnIndexOrThrow(LauncherSettings.Favorites.ICON_RESOURCE);
        final int containerIndex = c.getColumnIndexOrThrow(LauncherSettings.Favorites.CONTAINER);
        final int itemTypeIndex = c.getColumnIndexOrThrow(LauncherSettings.Favorites.ITEM_TYPE);
        final int appWidgetIdIndex = c.getColumnIndexOrThrow(LauncherSettings.Favorites.APPWIDGET_ID);
        final int screenIndex = c.getColumnIndexOrThrow(LauncherSettings.Favorites.SCREEN);
        final int cellXIndex = c.getColumnIndexOrThrow(LauncherSettings.Favorites.CELLX);
        final int cellYIndex = c.getColumnIndexOrThrow(LauncherSettings.Favorites.CELLY);
        final int spanXIndex = c.getColumnIndexOrThrow(LauncherSettings.Favorites.SPANX);
        final int spanYIndex = c.getColumnIndexOrThrow(LauncherSettings.Favorites.SPANY);
        final int uriIndex = c.getColumnIndexOrThrow(LauncherSettings.Favorites.URI);
        final int displayModeIndex = c.getColumnIndexOrThrow(LauncherSettings.Favorites.DISPLAY_MODE);
        // ...
        // 通过launcher回调返回数据
        launcher.onDesktopItemsLoaded(uiDesktopItems, uiDesktopWidgets);
        // ...
    }
    // ...
}

然后我们回到Launcher的onDesktopItemsLoaded方法：

void onDesktopItemsLoaded(ArrayList<ItemInfo> shortcuts, ArrayList<LauncherAppWidgetInfo> appWidgets) {
    // ...
    bindDesktopItems(shortcuts, appWidgets);
}

继续进入bindDesktopItems方法：

private void bindDesktopItems(ArrayList<ItemInfo> shortcuts, ArrayList<LauncherAppWidgetInfo> appWidgets) {
    // ...
    mBinder = new DesktopBinder(this, shortcuts, appWidgets, drawerAdapter);
    mBinder.startBindingItems();
}

进入startBindingItems方法：

public void startBindingItems() {
    // ...
    obtainMessage(MESSAGE_BIND_ITEMS, 0, mShortcuts.size()).sendToTarget();
}

这里使用了Handler发送消息，进入Handler的handleMessage方法：

@Override
public void handleMessage(Message msg) {
    // ...
    switch (msg.what) {
        // ...
        case MESSAGE_BIND_ITEMS: {
            launcher.bindItems(this, mShortcuts, msg.arg1, msg.arg2);
            break;
        }
        // ...
    }
}

接收到消息之后调用bindItems方法：

private void bindItems(Launcher.DesktopBinder binder, ArrayList<ItemInfo> shortcuts, int start, int count) {
    // ...
    case LauncherSettings.Favorites.ITEM_TYPE_APPLICATION:
    case LauncherSettings.Favorites.ITEM_TYPE_SHORTCUT:
        final View shortcut = createShortcut((ApplicationInfo) item);
        workspace.addInScreen(shortcut, item.screen, item.cellX, item.cellY, 1, 1, !desktopLocked);
    // ...
}

这里我们只考虑app或者app快捷方式的情况，文件夹和widgets暂时不考虑。app或者app快捷方式实质上都是进入了这个逻辑中，调用createShortcut方法：

// 重载方法，最终都会调用这个方法
View createShortcut(int layoutResId, ViewGroup parent, ApplicationInfo info) {
    // ...
    TextView favorite = (TextView) mInflater.inflate(layoutResId, parent, false);
    // ...
    favorite.setCompoundDrawablesWithIntrinsicBounds(null, info.icon, null, null);
    favorite.setText(info.title);
    favorite.setTag(info);
    favorite.setOnClickListener(this);
    // ...
}

这里首先inflater出item的布局，然后设置text和OnClickListener，还有tag，这个tag是ApplicationInfo，里面包含了各种App信息，是从App的AndroidManifest.xml的<application>标签中解析出来的。既然设置了点击事件，显然，点击后应该会打开对应的App才对。所以继续看onClick方法：

public void onClick(View v) {
    Object tag = v.getTag();
    if (tag instanceof ApplicationInfo) {
        // Open shortcut
        final Intent intent = ((ApplicationInfo) tag).intent;
        startActivitySafely(intent);
    } else if (tag instanceof FolderInfo) {
        handleFolderClick((FolderInfo) tag);
    }
}

点击App就会通过startActivitySafely方法使用刚才设置的tag，也就是ApplicationInfo中的intent进行跳转：

void startActivitySafely(Intent intent) {
    intent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
    // ...
    startActivity(intent);
    // ...
}



然后我们来看看打开某个app的时候整个流程是怎么走的。接着上面的的startActivity()方法走：

public void startActivity(Intent intent, @Nullable Bundle options) {
    // ...
    if (options != null) {
        startActivityForResult(intent, -1, options);
    } else {
        startActivityForResult(intent, -1);
    }
    // ...
}

可以看到，不管你是调用了startActivity还是startActivityForResult方法，startActivityForResult方法，并且如果是调用的startActivity，则默认requestCode就是-1，所以如果你想调用startActivityForResult的时候，注意不能把requestCode设置为-1，否则它的效果就跟startActivity一样了，不会再回调onActivityResult！，再看看startActivityForResult的实现：

public void startActivityForResult(Intent intent, int requestCode, @Nullable Bundle options) {
    Instrumentation.ActivityResult ar = mInstrumentation.execStartActivity(
            this, mMainThread.getApplicationThread(), mToken, this,
            intent, requestCode, options);
    // ...
}

可以看到，Activity内部是使用mInstrumentation（Instrumentation类型）执行execStartActivity方法来实现Activity跳转的，执行完毕后会返回一个Instrumentation.ActivityResult。

然后查看Instrumentation::execStartActivity：

public ActivityResult execStartActivity(
    // ...
    int result = ActivityManagerNative.getDefault()
        .startActivity(whoThread, who.getBasePackageName(), intent,
                intent.resolveTypeIfNeeded(who.getContentResolver()),
                token, target != null ? target.mEmbeddedID : null,
                requestCode, 0, null, options);
    // ...
}

首先通过ActivityManagerNative.getDefault()获得一个IActivityManager的实现类：

static public IActivityManager getDefault() {
    return gDefault.get();
}

private static final Singleton<IActivityManager> gDefault = new Singleton<IActivityManager>() {
    protected IActivityManager create() {
        // 通过Binder IPC获取ActivityManager（IBinder）
        IBinder b = ServiceManager.getService("activity");
        // ...
        IActivityManager am = asInterface(b);
        // ...
        return am;
    }
};

static public IActivityManager asInterface(IBinder obj) {
    if (obj == null) {
        return null;
    }
    IActivityManager in =
        (IActivityManager)obj.queryLocalInterface(descriptor);
    if (in != null) {
        return in;
    }
    return new ActivityManagerProxy(obj);
}

先通过Binder IPC的方式从服务端获取一个Activity Manager，然后通过ActivityManagernative封装成一个代理ActivityManagerProxy对象，然后调用startActivity也是使用了Binder IPC进行与服务器端的通信，（整个Android系统的通信机制使用了大量的Binder IPC，这个以后再专门讨论这个吧），接着，我们进入到了com.android.server.am.ActivityManagerService的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 options) {
    return startActivityAsUser(caller, callingPackage, intent, resolvedType, resultTo, resultWho, requestCode, startFlags, profilerInfo, options, UserHandle.getCallingUserId());
}

接下来的调用链：

-> startActivityAsUser
-> startActivityMayWait
-> startActivityLocked
-> startActivityUncheckedLocked
-> targetStack.startActivityLocked(r, newTask, doResume, keepCurTransition, options)
-> mStackSupervisor.resumeTopActivitiesLocked(this, r, options)
-> resumeTopActivityInnerLocked(prev, options);
-> mStackSupervisor.startSpecificActivityLocked(next, true, true)

startSpecificActivityLocked方法如下：

void startSpecificActivityLocked(ActivityRecord r, boolean andResume, boolean checkConfig) {
    ProcessRecord app = mService.getProcessRecordLocked(r.processName,
            r.info.applicationInfo.uid, true);
    // ...
    if (app != null && app.thread != null) {
        // ...
        realStartActivityLocked(r, app, andResume, checkConfig);
        return;
    }
    // ...
    mService.startProcessLocked(r.processName, r.info.applicationInfo, true, 0, "activity", r.intent.getComponent(), false, false, true);
}

首先从mService找出对应需要启动Activity的进程（通过进程名字和uid，进程名字可以在AndroidManifest.xml中配置）如果可以获取到，说明这个Activity所属的进程已经存在了，也就是说app已经在运行了，那就会调用realStartActivityLocked，否则，如果该Activity所在的App是第一次启动，则会调用mService.startProcessLocked方法：

final ProcessRecord startProcessLocked(/*...*/){
    // ...
    startProcessLocked(app, hostingType, hostingNameStr, abiOverride, entryPoint, entryPointArgs);
    // ...
}

final ProcessRecord startProcessLocked(String processName, ApplicationInfo info, boolean knownToBeDead, int intentFlags, String hostingType, ComponentName hostingName, boolean allowWhileBooting, boolean isolated, int isolatedUid, boolean keepIfLarge, String abiOverride, String entryPoint, String[] entryPointArgs, Runnable crashHandler) {
    // ...
    app = getProcessRecordLocked(processName, info.uid, keepIfLarge);
    // ...
    if (app == null) {
        app = newProcessRecordLocked(info, processName, isolated, isolatedUid);
    }
    // ...
}

private final void startProcessLocked(ProcessRecord app, String hostingType, String hostingNameStr, String abiOverride, String entryPoint, String[] entryPointArgs) {
    // ...
    // entryPoint表示一个类，它用来作为新创建的进程的主入口，会调用这个类的静态main方法，这个参数在startProcessLocked方法中会被检查重置，如果是null的话，就默认是android.app.ActivityThread。
    if (entryPoint == null) entryPoint = "android.app.ActivityThread";
    // ...
    Process.ProcessStartResult startResult = Process.start(entryPoint,
            app.processName, uid, uid, gids, debugFlags, mountExternal,
            app.info.targetSdkVersion, app.info.seinfo, requiredAbi, 
            instructionSet, app.info.dataDir, entryPointArgs);
    // ...  
}

这3个重载方法做的事情就是，先根据进程名字调用getProcessRecordLocked()获取ProcessRecord，如果ProcessRecord不存在，则调用newProcessRecordLocked()方法建立一个ProcessRecord，并且新的ProcessRecord绑定了ApplicationInfo，uid等信息，但后进入第三个重载方法，执行新建、启动进程。

再看Process::start的实现：

public static final ProcessStartResult start(/*...*/){
    // ...
    return startViaZygote(processClass, niceName, uid, gid, gids,
              debugFlags, mountExternal, targetSdkVersion, seInfo,
              abi, instructionSet, appDataDir, zygoteArgs);
    // ...
}

接下来就是通过Zygote进程fork一个新的进程作为app的进程。这里要需要讲的一个参数是processClass，这个参数表示一个类，它用来作为新创建的进程的主入口，会调用这个类的静态main方法，这个参数在startProcessLocked方法中会被检查重置，如果是null的话，就默认是android.app.ActivityThread。

现在App的进程也创建成功了，就会进入android.app.ActivityThread的静态的main中：

public static void main(String[] args) {
    // ...
    // 初始化主线程Looper
    Looper.prepareMainLooper();
    // ...
    ActivityThread thread = new ActivityThread();
    thread.attach(false);   
    // ...
    // 启动消息循环
    Looper.loop()
    // ...
}

然后创建了一个ActivityThread，说明每当一个新的app进程被创建，都会对应一个新的ActivityThread实例，然后调用它的attach方法：

private void attach(boolean system) {
    // ...
    if (!system) {
        // ...
        final IActivityManager mgr = ActivityManagerNative.getDefault();
        // ...
        mgr.attachApplication(mAppThread);
        // ...
    }else{
        // ...
    }
    // ...
}

然后再次通过Binder IPC调用ActivityManagerProxy的attachApplication，传入的ApplicationThread（Binder）参数用于在服务端进行回调通信。最后进入ActivityManagerService::attachApplication，再调用attachApplicationLocked(thread, callingPid)

private final boolean attachApplicationLocked(IApplicationThread thread, int pid) {
    // ...
    app = mPidsSelfLocked.get(pid);
    // ...
    app.makeActive(thread, mProcessStats);
    app.curAdj = app.setAdj= -100;
    app.curSchedGroup = app.setSchedGroup = Process.THREAD_GROUP_DEFAULT;
    app.forcingToForeground = null;
    updateProcessForegroundLocked(app, false, false);
    app.hasShownUi = false;
    app.debugging = false;
    app.cached = false;
    app.killedByAm = false;
    // ...
    thread.bindApplication(processName, appInfo, providers, app.instrumentationClass, profilerInfo, app.instrumentationArguments, app.instrumentationWatcher, app.instrumentationUiAutomationConnection, testMode, enableOpenGlTrace, enableTrackAllocation, isRestrictedBackupMode || !normalMode, app.persistent, new Configuration(mConfiguration), app.compat, getCommonServicesLocked(app.isolated), mCoreSettingsObserver.getCoreSettingsLocked());
    // ...
    if (normalMode) {
        try {
            if (mStackSupervisor.attachApplicationLocked(app)) {
                didSomething = true;
            }
        } catch (Exception e) {
            Slog.wtf(TAG, "Exception thrown launching activities in " + app, e);
            badApp = true;
        }
    }
    // ...
}

首先，通过pid获取刚刚创建的进程，然后对app进行一些初始化工作，然后调用bindApplication远程调用客户端ActivityThread::bindApplication，再通过Handler调用到ActivityThread::handleBindApplication方法：

private void handleBindApplication(AppBindData data) {
    // ...
    final ContextImpl appContext = ContextImpl.createAppContext(this, data.info);
    if (data.instrumentationName != null) {
        // ...
        mInstrumentationPackageName = ii.packageName;
        mInstrumentationAppDir = ii.sourceDir;
        mInstrumentationSplitAppDirs = ii.splitSourceDirs;
        mInstrumentationLibDir = ii.nativeLibraryDir;
        mInstrumentedAppDir = data.info.getAppDir();
        mInstrumentedSplitAppDirs = data.info.getSplitAppDirs();
        mInstrumentedLibDir = data.info.getLibDir();

        ApplicationInfo instrApp = new ApplicationInfo();
        instrApp.packageName = ii.packageName;
        instrApp.sourceDir = ii.sourceDir;
        instrApp.publicSourceDir = ii.publicSourceDir;
        instrApp.splitSourceDirs = ii.splitSourceDirs;
        instrApp.splitPublicSourceDirs = ii.splitPublicSourceDirs;
        instrApp.dataDir = ii.dataDir;
        instrApp.nativeLibraryDir = ii.nativeLibraryDir;
        LoadedApk pi = getPackageInfo(instrApp, data.compatInfo,
                appContext.getClassLoader(), false, true, false);
        ContextImpl instrContext = ContextImpl.createAppContext(this, pi);
        // ...
java.lang.ClassLoader cl = instrContext.getClassLoader();
        mInstrumentation = (Instrumentation) cl.loadClass(data.instrumentationName.getClassName()).newInstance();
        mInstrumentation.init(this, instrContext, appContext, new ComponentName(ii.packageName, ii.name), data.instrumentationWatcher, data.instrumentationUiAutomationConnection);
        // ...
    }else{
        mInstrumentation = new Instrumentation();
    }
    // ...
    Application app = data.info.makeApplication(data.restrictedBackupMode, null);
    mInitialApplication = app;
    // ...
    mInstrumentation.callApplicationOnCreate(app);
    // ...
}

首先，创建一个当前App的Context，然后如果data.instrumentationName != null，则初始化Instrumentation相关的变量，并创建Instrumentation的ApplicationInfo等对象来创建Instrumentation的Context，然后创建Instrumentation对象，并调用它的init方法进行初始化。如果data.instrumentationName == null，则new一个Instrumentation（在一个进程中只会有一个Instrumentation实例）然后创建Application对象，并调用它的onCreate方法，这样Application就会被回调了。

然后我们回到ActivityManagerService::attachApplicationLocked方法，远程执行完thread.bindApplication方法之后，接下来会调用mStackSupervisor.attachApplicationLocked(app)方法：

boolean attachApplicationLocked(ProcessRecord app) throws RemoteException {
    // ...
    ActivityRecord hr = stack.topRunningActivityLocked(null);
    // ...
    realStartActivityLocked(hr, app, true, true)
    // ...
}

先通过topRunningActivityLocked从堆栈顶端获取要启动的Activity，然后realStartActivityLocked(hr, app, true, true)：

final boolean realStartActivityLocked(ActivityRecord r,
            ProcessRecord app, boolean andResume, boolean checkConfig)
            throws RemoteException {
    // ...
    app.thread.scheduleLaunchActivity(new Intent(r.intent), r.appToken, System.identityHashCode(r), r.info, new Configuration(mService.mConfiguration), new Configuration(stack.mOverrideConfig), r.compat, r.launchedFromPackage, task.voiceInteractor, app.repProcState, r.icicle, r.persistentState, results, newIntents, !andResume, mService.isNextTransitionForward(), profilerInfo);
    // ...
}

继续通过Binder IPC远程调用scheduleLaunchActivity方法，然后进入ActivityThread的scheduleLaunchActivity方法中，然后通过Handler进入handleLaunchActivity方法：

private void handleLaunchActivity(ActivityClientRecord r, Intent customIntent){
    // ...
    Activity a = performLaunchActivity(r, customIntent);
    
    handleResumeActivity(r.token, false, r.isForward, !r.activity.mFinished && !r.startsNotResumed);
    // ...
}

先调用performLaunchActivity方法返回一个Activity，然后调用handleResumeActivity方法让该Activity进入onResume状态。所以很显然在performLaunchActivity中肯定是生成了Activity实例，并调用了onCreate方法了，来看下代码：

private Activity performLaunchActivity(ActivityClientRecord r, Intent customIntent) {
    // ...
    ActivityInfo aInfo = r.activityInfo;
    if (r.packageInfo == null) {
        r.packageInfo = getPackageInfo(aInfo.applicationInfo, r.compatInfo,
                Context.CONTEXT_INCLUDE_CODE);
    }
    // ...
    java.lang.ClassLoader cl = r.packageInfo.getClassLoader();
    activity = mInstrumentation.newActivity(cl, component.getClassName(), r.intent);
    // ...
    Context appContext = createBaseContextForActivity(r, activity);
    // ...
    activity.attach(appContext, this, getInstrumentation(), r.token, r.ident, app, r.intent, r.activityInfo, title, r.parent, r.embeddedID, r.lastNonConfigurationInstances, config, r.referrer, r.voiceInteractor);
    // ...
    if (r.isPersistable()) {
     mInstrumentation.callActivityOnCreate(activity, r.state, r.persistentState);
    } else {
        mInstrumentation.callActivityOnCreate(activity, r.state);
    }
    // ...
    mInstrumentation.callActivityOnRestoreInstanceState(activity, r.state, r.persistentState);
    // ...
    mInstrumentation.callActivityOnPostCreate(activity, r.state, r.persistentState);
    // ...
}

首先，初始化LoadedApk，然后通过Instrumentation来创建一个Activity实例，通过createBaseContextForActivity方法创建一个Activity Context，调用activity的attach方法，然后依次触发该Activity的onCreate、onRestoreInstanceState、onPostCreate等生命周期方法。

createBaseContextForActivity方法如下：

private Context createBaseContextForActivity(ActivityClientRecord r, final Activity activity) {
    // ...
    ContextImpl appContext = ContextImpl.createActivityContext(this, r.packageInfo, displayId, r.overrideConfig);
    appContext.setOuterContext(activity);
    Context baseContext = appContext;
    // ...
}

通过ContextImpl::createActivityContext创建的Context对象，可以发现，不论是System Context/App Context/Activity Context，这些Context都是通过ContextImpl生成的，具体这里再挖个坑先。

再继续进入Activity::attach方法：

final void attach(Context context, ActivityThread aThread,
            Instrumentation instr, IBinder token, int ident,
            Application application, Intent intent, ActivityInfo info,
            CharSequence title, Activity parent, String id,
            NonConfigurationInstances lastNonConfigurationInstances,
            Configuration config, String referrer, IVoiceInteractor voiceInteractor) {
    // ...
    mMainThread = aThread;
    mInstrumentation = instr;
    mToken = token;
    mIdent = ident;
    mApplication = application;
    mIntent = intent;
    mReferrer = referrer;
    mComponent = intent.getComponent();
    mActivityInfo = info;
    mTitle = title;
    mParent = parent;
    mEmbeddedID = id;
    mLastNonConfigurationInstances = lastNonConfigurationInstances;
    // ...
}

上面对Activity与ActivityThread、Instrumentation等进行了绑定，所以说每个Activity都含有一个ActivityThread引用和一个Instrumentation引用，而ActivityThread实例和Instrumentation实例在一个进程中都只有一个实例，因为ActivityThread是在进程被创建成功后，进入ActivityThread的static main()时才会被创建，而Instrumentation则是在ActivityThread被创建后进行attach的之后被创建。


启动应用流程所有方法链调用总结：

  • Activity::startActivity

  • Activity::startActivityForResult

  • Instrumentation::execStartActivity：
    携带参数：
  1. who：from的Context
  2. contextThread：from的ActivityThread的ApplicationThread，ApplicationThread中可以通过Binder IPC提供给服务端回调Activity生命周期等操作（from的主线程）。
  3. mToken：Binder类型，用来标识from的Activity，可能为null。
  4. target：from的Activity（所以是用来接收跳转结果的），如果不是从Activity跳转则为null。
  5. intent：跳转Intent。
  6. requestCode：如果是startActivity，则为-1。
  7. options：额外Bundle数据。
  • ActivityManagerProxy::startActivity()：
    携带参数：
  1. caller：上面的contextThread，from主线程。
  2. callingPackage：from的Context包名。
  3. intent：跳转Intent。
  4. resolvedType：跳转Intent的MIME类型。
  5. resultTo：上面的token，Binder类型，用来标识from的Activity。
  6. resultWho：from的Activity的mEmbeddedID（唯一标示字符串）
  7. requestCode：如果是startActivity，则为-1。
  8. startFlags：默认传入为0。
  9. profilerInfo：默认传入为null。
  10. options：额外Bundle数据。

  • ActivityManagerService::startActivity()（通过Binder IPC调用）：
    携带参数跟上面一样。

  • ActivityManagerService::startActivityAsUser
    携带参数包括ActivityManagerService::startActivity()所有的参数，最再加一个：
  1. userId：userId，根据给当前进程分配的Linux UID（这个UID可以用来让上层系统服务进行身份识别和权限检查）得到一个userId（如果不是多用户，则直接返回0）。
  • ActivityStackSupervisor::startActivityMayWait()
    参数：
  1. caller：上面的caller/contextThread，from主线程。
  2. callingUid：调用用户uid。
  3. callingPackage：from的Context包名。
  4. intent：跳转Intent。
  5. resolvedType：跳转Intent的MIME类型。
  6. voiceSession：传null。
  7. voiceInteractor：传null。
  8. resultTo：上面的resultTo/token，Binder类型，用来标识from的Activity。
  9. resultWho：from的Activity的mEmbeddedID（唯一标示字符串）
  10. requestCode：如果是startActivity，则为-1。
  11. startFlags：传null。
  12. profilerInfo：传null。
  13. outResult：传null。
  14. config：传null。
  15. options：额外数据。
  16. ignoreTargetSecurity：false。
  17. userId：上面的userId，根据给当前进程分配的Linux UID（这个UID可以用来让上层系统服务进行身份识别和权限检查）得到一个userId（如果不是多用户，则直接返回0）。
  18. iContainer：传null。
  19. inTask：null。
  • ActivityStackSupervisor::startActivityLocked()：
    参数：
  1. caller：上面的caller/contextThread，from主线程。
  2. intent：跳转Intent。
  3. resolvedType：跳转Intent的MIME类型。
  4. aInfo：ActivityInfo类型，解析from的Activity的Intent信息。
  5. voiceSession：传null。
  6. voiceInteractor：传null。
  7. resultTo：上面的resultTo/token，Binder类型，用来标识from的Activity。
  8. resultWho：from的Activity的mEmbeddedID（唯一标示字符串）
  9. requestCode：如果是startActivity，则为-1。
  10. callingPackage：from的Context包名。
  11. startFlags：传null。
  12. options：额外数据。
  13. ignoreTargetSecurity：false。
  14. componentSpecified：是否显示指定了component。
  15. outActivity：传null。
  16. container：上面的iContainer，转型成了ActivityContainer，还是null。
  17. inTask：null。
    在这个方法中，通过ProcessRecord callerApp = mService.getRecordForAppLocked(caller);获取到之前创建的ProcessRecord，然后从Activity栈中根据resultTo/token获取到对应from Activity的ActivityRecord（sourceRecord），然后__创建将要跳转的Activity的ActivityRecord对象__（Token也是在这个时候生成的）。
  • ActivityStackSupervisor::startActivityUncheckedLocked()：
    参数：
  1. r：ActivityRecord类型，就是ActivityStackSupervisor::startActivityLocked()中创建的将要跳转的Activity的ActivityRecord对象。
  2. sourceRecord：就是ActivityStackSupervisor::startActivityLocked()方法获取的from Activity的sourceRecord。
  3. voiceSession：传null。
  4. voiceInteractor：传null。
  5. startFlags：传null。
  6. doResume：传true。
  7. options：额外数据。
  8. inTask：null。
    这个方法中有大量的代码来处理task/stack等方面的逻辑，以后再仔细深入这个方法。
  • ActivityStrack::startActivityLocked()：
    方法调用者：ActivityStack类型，
    targetStack：在ActivityStackSupervisor::startActivityUncheckedLocked()中确定的需要添加到的ActivityStack。
    参数：
  1. r：ActivityRecord类型，就是ActivityStackSupervisor::startActivityLocked()中创建的跳转的Activity的ActivityRecord对象。
  2. newTask：是否Intent是否设置了Intent.FLAG_ACTIVITY_NEW_TASK。
  3. doResume：传true。
  4. keepCurTransition：这个具体后面再研究，跟Intent的flag有关。
  5. options：额外数据。
    同样，这个方法中有大量的代码来处理task/stack等方面的逻辑，以后再仔细深入这个方法__（执行完这个方法后，ActivityRecord就会被真正加入到ActivityStack中）__。
  • ActivityStackSupervisor::resumeTopActivitiesLocked()：
    参数：
  1. targetStack：在ActivityStackSupervisor::startActivityUncheckedLocked()中确定的需要添加到的ActivityStack。
  2. target：ActivityRecord类型，就是ActivityStackSupervisor::startActivityLocked()中创建的跳转的Activity的ActivityRecord对象。
  3. targetOptions：额外数据。
  • ActivityStack::resumeTopActivityLocked()：
    参数：
  1. prev：ActivityRecord类型，就是ActivityStackSupervisor::startActivityLocked()中创建的跳转的Activity的ActivityRecord对象。
  2. options：额外数据。
  • ActivityStack::resumeTopActivityInnerLocked()：
    参数：
  1. prev：ActivityRecord类型，就是ActivityStackSupervisor::startActivityLocked()中创建的跳转的Activity的ActivityRecord对象。
  2. options：额外数据。
  • ActivityStackSupervisor::startSpecificActivityLocked()：
    参数：
  1. r：最顶部没有处于finishing的Activity，就是刚刚在startActivityLocked中加入的将要跳转的ActivityRecord，通过topRunningActivityLocked(null)查找
  2. andResume：传true
  3. checkConfig：传true
  • ActivityManagerService::startProcessLocked()：
    参数：
  1. processName：创建进程的名称，就是ActivityStack::startSpecificActivityLocked()中的r.processName
  2. info：ApplicationInfo，也是r.info.applicaitonInfo，具体可以查看ActivityStackSupervisor::startActivityLocked()中创建ActivityRecord的代码。
  3. knownToBeDead：传true。
  4. intentFlags：传0。
  5. hostingType：传字符串“activity”。
  6. hostingName：ComponentName类型，intent中的Componentname
  7. allowWhileBooting：传false。
  8. isolated：传false
  9. keepIfLarge传true
  • ActivityManagerService::startProcessLocked()（重载方法）：
    参数包含上面所有，多了以下几个：
  1. isolatedUid：传0
  2. abiOverride：传null
  3. entryPoint：传null
  4. entryPointArgs传null
  5. crashHandler传null
    注意：在这个方法中，会创建新进程的ProcessRecord对象，并绑定ApplicationInfo等信息，这样，启动进程后进行bindApplicaiton的时候就可以根据进程PID获取到所有的ApplicationInfo信息了。
  • ActivityManagerService::startProcessLocked()（重载方法）：
    参数：
  1. app：ProcessRecord类型，创建的进程。
  2. hostingType：传字符串“activity”。
  3. hostingNameStr：通过hostingName生成的字符串（包名 + "/" + 类的简单类名）
  4. abiOverride：传null
  5. entryPoint：传null
  6. entryPointArgs传null
  • Process.start()
    参数（省略部分参数）：
  1. processClass：上面的entryPoint，但是并不是null了，而是android.app.ActivityThread，因为在ActivityManagerService::startProcessLocked()中被设置默认值了，它表示一个类，用来作为新创建的进程的主入口，会调用这个类的静态main方法。所以启动完这个进程就会进入ActivityThread的static main()方法。
  2. zygoteArgs：fork zygote进程时的参数。

  • ActivityThread::main()

  • ActivityThread::attach()

  • ActivityManagerProxy::attachApplication()：
    参数：
  1. mAppThread：ApplicationThread()类型，Binder，用来提供给AMS调用。
  • ActivityManagerService::attachApplication()：
    参数：
  1. mAppThread：ApplicationThread()类型，Binder，用来提供给AMS调用。
  • ActivityManagerService::attachApplicationLocked()：
    参数：
  1. thread：ApplicationThread()类型，Binder，用来提供给AMS调用。上面的mAppThread。
  2. pid：当前调用的进程PID。
  • IApplicationThread::bindApplication()：
    方法调用调用者：上面的thread/mAppThread，Binder，用来提供给AMS调用。
    参数（省略部分参数）：
  1. packageName：用的进程名字processName
  2. info：ApplicationInfo类型，从ProcessRecord中的instrumentationInfo或者info，这个ApplicationInfo是在建立ProcessRecord时就保存了。

  • ActivityThread::bindApplication()：
    参数：同上

  • ActivityThread::handleBindApplication()：
    通过Handler调用。
    参数：
  1. data：AppBindData类型，里面包含的类型processName，providers，instrumentationName，instrumentationArgs，instrumentationWatcher，instrumentationUiAutomationConnection，config等数据。


  • ActivityManagerService中的ActivityThread::bindApplication()执行完毕之后

  • ActivityStackSupervisor::attachApplicationLocked()：
    参数：
  1. app：新建的进程绑定的ProcessRecord。
  • ActivityStackSupervisor::realStartActivityLocked()：
    参数：
  1. r：ActivityRecord类型，topRunningActivityLocked从堆栈顶端获取要启动的Activity。
  2. app：新建的进程绑定的ProcessRecord。
  3. andResume：传入true
  4. checkConfig：传入true
  • IApplicationThread::scheduleLaunchActivity()：
    参数（部分）：
  1. intent：将要启动的ActivityRecord中的intent。
  2. token：将要启动的ActivityRecord中的token。
  3. info：将要启动的ActivityRecord中的ApplicationInfo。

  • ActivityThread::scheduleLaunchActivity()：
    Binder IPC调用，参数与IApplicationThread::scheduleLaunchActivity()相同。

  • ActivityThread::handleLaunchActivity()：
    该方法通过Handler调用，参数同上。
  1. r：ActivityClientRecord类型，在ActivityThread::scheduleLaunchActivity()中封装，包括的数据有token, ident, intent, activityInfo等等，但是LoadedApk是这时根据包名从ActivityThread中弱引用缓存中获取的的。
  2. customIntent：null

  • ActivityThread::performLaunchActivity()：
    参数与ActivityThread::handleLaunchActivity()相同。

  • Activity::attach()：
    参数（部分）：
  1. context：ActivityThread::performLaunchActivity()中创建的Activity Context。
  2. aThread：ActivityThread类型，主线程，一个进程都共用一个。
  3. token：构建ActivityRecord时生成的token。
  4. application：Application第一次的时候创建一遍。
  5. intent：将要启动的ActivityRecord中的intent。
  6. info：ActivityInfo类型，将要启动的ActivityRecord中的ActivityInfo。
  • Instrumentation::callActivityOnCreate()：
    参数（部分）：
  1. activity：ActivityThread::performLaunchActivity()中创建的Activity。

  • Activity::performCreate()

  • Activity::onCreate()

文章标签：
Android开发
容器
vr&ar
Linux
缓存
关键词：
APP源码分析
咕噜不爱猫
目录
相关文章
i校长
|
数据可视化
Matrix源码分析系列-如何计算App启动耗时（二）
Matrix源码分析系列-如何计算App启动耗时
i校长
148 0
Matrix源码分析系列-如何计算App启动耗时（二）
i校长
|
监控 Java 测试技术
Matrix源码分析系列-如何计算App启动耗时（一）
Matrix源码分析系列-如何计算App启动耗时
i校长
157 0
Matrix源码分析系列-如何计算App启动耗时（一）
游客g2r3yknu46ngq
|
JavaScript 测试技术 Android开发
干货|app自动化测试之Appium 源码分析
干货|app自动化测试之Appium 源码分析
游客g2r3yknu46ngq
110 0
文艺小青年
|
存储 API 前端开发
移动web app开发必备 - Deferred 源码分析
文艺小青年
1225 0
aqi00
|
16天前
|
Web App开发 Java 视频直播
FFmpeg开发笔记（四十九）助您在毕业设计中脱颖而出的几个流行APP
对于软件、计算机等专业的毕业生,毕业设计需实现实用软件或APP。新颖的设计应结合最新技术，如5G时代的音视频技术。示例包括: 1. **短视频分享APP**: 集成FFmpeg实现视频剪辑功能，如添加字幕、转场特效等。 2. **电商购物APP**: 具备直播带货功能，使用RTMP/SRT协议支持流畅直播体验。 3. **同城生活APP**: 引入WebRTC技术实现可信的视频通话功能。这些应用不仅实用，还能展示开发者紧跟技术潮流的能力。
aqi00
45 4
FFmpeg开发笔记（四十九）助您在毕业设计中脱颖而出的几个流行APP
夏天49597
|
10天前
|
移动开发 小程序 JavaScript
uni-app开发微信小程序
本文详细介绍如何使用 uni-app 开发微信小程序，涵盖需求分析、架构思路及实施方案。主要功能包括用户登录、商品列表展示、商品详情、购物车及订单管理。技术栈采用 uni-app、uView UI 和 RESTful API。文章通过具体示例代码展示了从初始化项目、配置全局样式到实现各页面组件及 API 接口的全过程，并提供了完整的文件结构和配置文件示例。此外，还介绍了微信授权登录及后端接口模拟方法，确保项目的稳定性和安全性。通过本教程，读者可快速掌握使用 uni-app 开发微信小程序的方法。
夏天49597
27 3
aqi00
|
1月前
|
Web App开发 Android开发
FFmpeg开发笔记（四十六）利用SRT协议构建手机APP的直播Demo
实时数据传输在互联网中至关重要，不仅支持即时通讯如QQ、微信的文字与图片传输，还包括音视频通信。一对一通信常采用WebRTC技术，如《Android Studio开发实战》中的App集成示例；而一对多的在线直播则需部署独立的流媒体服务器，使用如SRT等协议。SRT因其优越的直播质量正逐渐成为主流。本文档概述了SRT协议的使用，包括通过OBS Studio和SRT Streamer进行SRT直播推流的方法，并展示了推流与拉流的成功实例。更多细节参见《FFmpeg开发实战》一书。
aqi00
37 1
FFmpeg开发笔记（四十六）利用SRT协议构建手机APP的直播Demo
aqi00
|
1月前
|
Web App开发 5G Linux
FFmpeg开发笔记（四十四）毕业设计可做的几个拉满颜值的音视频APP
一年一度的毕业季来临，计算机专业的毕业设计尤为重要，不仅关乎学业评价还积累实战经验。选择紧跟5G技术趋势的音视频APP作为课题极具吸引力。这里推荐三类应用：一是融合WebRTC技术实现视频通话的即时通信APP；二是具备在线直播功能的短视频分享平台，涉及RTMP/SRT等直播技术；三是具有自定义动画特效及卡拉OK歌词字幕功能的视频剪辑工具。这些项目不仅技术含量高，也符合市场需求，是毕业设计的理想选择。
aqi00
60 6
FFmpeg开发笔记（四十四）毕业设计可做的几个拉满颜值的音视频APP
aqi00
|
1月前
|
编解码 Java Android开发
FFmpeg开发笔记（四十五）使用SRT Streamer开启APP直播推流
​SRT Streamer是一个安卓手机端的开源SRT协议直播推流框架，可用于RTMP直播和SRT直播。SRT Streamer支持的视频编码包括H264、H265等等，支持的音频编码包括AAC、OPUS等等，可谓功能强大的APP直播框架。另一款APP直播框架RTMP Streamer支持RTMP直播和RTSP直播，不支持SRT协议的直播。而本文讲述的SRT Streamer支持RTMP直播和SRT直播，不支持RTSP协议的直播。有关RTMP Streamer的说明参见之前的文章《使用RTMP Streamer开启APP直播推流》，下面介绍如何使用SRT Streamer开启手机直播。
aqi00
52 4
FFmpeg开发笔记（四十五）使用SRT Streamer开启APP直播推流
请看我回答~
|
24天前
|
IDE Java 开发工具
探索安卓开发之旅：打造你的第一款App
【8月更文挑战第24天】在这篇文章中，我们将一起踏上激动人心的安卓开发之旅。不论你是编程新手还是希望扩展技能的老手，本文将为你提供一份详尽指南，帮助你理解安卓开发的基础知识并实现你的第一个应用程序。从搭建开发环境到编写“Hello World”，每一步都将用浅显易懂的语言进行解释。那么，让我们开始吧！
请看我回答~
28 1

热门文章

最新文章

  • 1
    【83行代码获奖代码】高中生@青藤木子 耗费一周给妈妈编写了一款语音识别APP
  • 2
    3个常用外贸软件及app工具整理
  • 3
    创意设计展示：折叠效果在移动 App 中的应用
  • 4
    Android第二十九期 - 各种Android的App框架
  • 5
    为什么别人家的APP，上报日志就这么省流量？
  • 6
    Android开发者指南(18) —— Web Apps Overview
  • 7
    苹果App Store今现技术故障：无法升级应用
  • 8
    阐述“羊了个羊”游戏APP小程序系统开发逻辑方案（源码部署哦）
  • 9
    Google App Engine平台下JDOQL查询报异常的问题解决方案
  • 10
    重新想象 Windows 8 Store Apps (18) - 绘图: Shape, Path, Stroke, Brush
  • 1
    【专栏：HTML与CSS前端技术趋势篇】HTML与CSS在PWA（Progressive Web Apps）中的应用
    83
  • 2
    【Flutter前端技术开发专栏】Flutter中的混合应用(Hybrid Apps)开发
    112
  • 3
    浅蓝色的APP下载界面HMTL源码
    56
  • 4
    【专栏】在 create-react-app 中集成 less/sass 预处理器和 react-css-modules 的方法
    376
  • 5
    【专栏】从网页轻松转换为应用越来越便捷
    120
  • 6
    Serverless 应用引擎操作报错合集之阿里函数计算中出现'python app.py'的错误如何解决
    64
  • 7
    Java智慧工地云平台源码带APP SaaS模式 支持私有化部署和云部署
    104
  • 8
    [AI 阿里 EMO] 集成进通义千问app，全民演唱，人人可用！
    478
  • 9
    react-app框架——使用monaco editor实现online编辑html代码编辑器
    232
  • 10
    【SpringBoot】Error starting ApplicationContext. To display the conditions report re--run your app
    189

    • 相关课程

    更多
  • 互联网安全-移动APP漏洞风险与解决方案
  • 开源Android容器化框架Atlas开发者指南

    • 相关电子书

    更多
  • 女性移动App安全攻防战
  • 汇聚云计算的生态核能——云市场，云上APP Store
  • 千万级用户直播App——服务端架构设计和思考

    • 相关实验场景

    更多
  • 星轨-钉钉APP分发实训
    • 下一篇
    基于LNMP搭建WordPress