Activity启动流程源码解析（原创）

最新推荐文章于 2023-08-08 14:13:56 发布
最新推荐文章于 2023-08-08 14:13:56 发布
阅读量482 收藏
点赞数
分类专栏： 安卓 文章标签： 源码
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zzzhangzhun/article/details/52381987
版权

1、Activity启动流程

原帖地址
我的GitHub

Intent intent=new Intent(this,activity.class);
startActivity(intent);
  1. 通过以上代码将会启动一个Activity，startActivity方法会有好几种重载方式，但是他们最终都会调用startActivityForResult方法，实现如下：
    public void startActivityForResult(Intent intent, int requestCode, Bundle options) {
        if (mParent == null) {
            Instrumentation.ActivityResult ar =
                mInstrumentation.execStartActivity(
                    this, mMainThread.getApplicationThread(), mToken, this,
                    intent, requestCode, options);
            if (ar != null) {
                mMainThread.sendActivityResult(
                    mToken, mEmbeddedID, requestCode, ar.getResultCode(),
                    ar.getResultData());
            }
            if (requestCode >= 0) {
                // If this start is requesting a result, we can avoid making
                // the activity visible until the result is received.  Setting
                // this code during onCreate(Bundle savedInstanceState) or onResume() will keep the
                // activity hidden during this time, to avoid flickering.
                // This can only be done when a result is requested because
                // that guarantees we will get information back when the
                // activity is finished, no matter what happens to it.
                mStartedActivity = true;
            }
        } else {
            if (options != null) {
                mParent.startActivityFromChild(this, intent, requestCode, options);
            } else {
                // Note we want to go through this method for compatibility with
                // existing applications that may have overridden it.
                mParent.startActivityFromChild(this, intent, requestCode);
            }
        }
    }

我们只需关注mParent==null这部分，mParent代表的是ActivityGroup，一开始被用来嵌入多个Activity，但是API13已经被废弃了，系统目前采用的都是Fragment代替ActivityGroup。然后调用mInstrumentation.execStartActivity方法，方法的参数中的mMainThread.getApplicationThread()类型是ApplicationThread,ApplicationThread是ActivityThread的一个内部类。
2. mInstrumentation.execStartActivity:

    public ActivityResult execStartActivity(
            Context who, IBinder contextThread, IBinder token, Activity target,
            Intent intent, int requestCode, Bundle options) {
        IApplicationThread whoThread = (IApplicationThread) contextThread;
        if (mActivityMonitors != null) {
            synchronized (mSync) {
                final int N = mActivityMonitors.size();
                for (int i=0; i<N; i++) {
                    final ActivityMonitor am = mActivityMonitors.get(i);
                    if (am.match(who, null, intent)) {
                        am.mHits++;
                        if (am.isBlocking()) {
                            return requestCode >= 0 ? am.getResult() : null;
                        }
                        break;
                    }
                }
            }
        }
        try {
            intent.migrateExtraStreamToClipData();
            intent.prepareToLeaveProcess();
            int result = ActivityManagerNative.getDefault()
                .startActivity(whoThread, who.getBasePackageName(), intent,
                        intent.resolveTypeIfNeeded(who.getContentResolver()),
                        token, target != null ? target.mEmbeddedID : null,
                        requestCode, 0, null, null, options);
            checkStartActivityResult(result, intent);
        } catch (RemoteException e) {
        }
        return null;

可以看到，启动Activity的真正实现是由ActivityManagerNative.getDefault()
.startActivity实现的，AMS继承自ActivityManagerNative，ActivityManagerNative.getDefault()是一个AMS，采用单例模式提供对象，第一次调用会通过creat方法初始化AMS，然后后续调用直接返回即可。
3. AMS的startActivity方法

    public final int startActivity(IApplicationThread caller, String callingPackage,
            Intent intent, String resolvedType, IBinder resultTo,
            String resultWho, int requestCode, int startFlags,
            String profileFile, ParcelFileDescriptor profileFd, Bundle options) {
        return startActivityAsUser(caller, callingPackage, intent, resolvedType, resultTo,
                resultWho, requestCode,
                startFlags, profileFile, profileFd, options, UserHandle.getCallingUserId());
    }
  1. startActivity转移到了startActivityAsUser中
    public final int startActivityAsUser(IApplicationThread caller, String callingPackage,
            Intent intent, String resolvedType, IBinder resultTo,
            String resultWho, int requestCode, int startFlags,
            String profileFile, ParcelFileDescriptor profileFd, Bundle options, int userId) {
        enforceNotIsolatedCaller("startActivity");
        userId = handleIncomingUser(Binder.getCallingPid(), Binder.getCallingUid(), userId,
                false, true, "startActivity", null);
        return mMainStack.startActivityMayWait(caller, -1, callingPackage, intent, resolvedType,
                resultTo, resultWho, requestCode, startFlags, profileFile, profileFd,
                null, null, options, userId);
    }
  1. 转移到了ActivityStack的mMainStack.startActivityMayWait中，
 int res = startActivityLocked(caller, intent, resolvedType,
                    aInfo, resultTo, resultWho, requestCode, callingPid, callingUid,
                    callingPackage, startFlags, options, componentSpecified, null);
  1. mMainStack.startActivityMayWait方法中调用了startActivityLocked方法。
    err = startActivityUncheckedLocked(r, sourceRecord,
                startFlags, true, options);
  1. startActivityLocked方法调用startActivityUncheckedLocked方法
resumeTopActivityLocked(null, options);
  1. 接着调用resumeTopActivityLocked
startSpecificActivityLocked(next, true, false);
  1. 接着调用startSpecificActivityLocked
        if (app != null && app.thread != null) {
            try {
                app.addPackage(r.info.packageName);
                realStartActivityLocked(r, app, andResume, checkConfig);
                return;
            } catch (RemoteException e) {
                Slog.w(TAG, "Exception when starting activity "
                        + r.intent.getComponent().flattenToShortString(), e);
            }

            // If a dead object exception was thrown -- fall through to
            // restart the application.
        }
  1. 接着调用realStartActivityLocked方法，
app.thread.scheduleLaunchActivity(new Intent(r.intent), r.appToken,
                    System.identityHashCode(r), r.info,
                    new Configuration(mService.mConfiguration),
                    r.compat, r.icicle, results, newIntents, !andResume,
                    mService.isNextTransitionForward(), profileFile, profileFd,
                    profileAutoStop);
  1. realStartActivityLocked中有一句：app.thread.scheduleLaunchActivity，app.thread类型为IApplicationThread，IApplicationThread的实现类为ApplicationThread，即调用的是ApplicationThread的scheduleLaunchActivity：
        public final void scheduleLaunchActivity(Intent intent, IBinder token, int ident,
                ActivityInfo info, Configuration curConfig, CompatibilityInfo compatInfo,
                Bundle state, List<ResultInfo> pendingResults,
                List<Intent> pendingNewIntents, boolean notResumed, boolean isForward,
                String profileName, ParcelFileDescriptor profileFd, boolean autoStopProfiler) {
            ActivityClientRecord r = new ActivityClientRecord();

            r.token = token;
            r.ident = ident;
            r.intent = intent;
            r.activityInfo = info;
            r.compatInfo = compatInfo;
            r.state = state;

            r.pendingResults = pendingResults;
            r.pendingIntents = pendingNewIntents;

            r.startsNotResumed = notResumed;
            r.isForward = isForward;

            r.profileFile = profileName;
            r.profileFd = profileFd;
            r.autoStopProfiler = autoStopProfiler;

            updatePendingConfiguration(curConfig);

            queueOrSendMessage(H.LAUNCH_ACTIVITY, r);
        }
  1. scheduleLaunchActivity发送一个H.LAUNCH_ACTIVITY的消息来交给Handler处理，Handler H的代码如下：
public void handleMessage(Message msg) {
            if (DEBUG_MESSAGES) Slog.v(TAG, ">>> handling: " + codeToString(msg.what));
            switch (msg.what) {
                case LAUNCH_ACTIVITY: {
                    Trace.traceBegin(Trace.TRACE_TAG_ACTIVITY_MANAGER, "activityStart");
                    ActivityClientRecord r = (ActivityClientRecord)msg.obj;

                    r.packageInfo = getPackageInfoNoCheck(
                            r.activityInfo.applicationInfo, r.compatInfo);
                    handleLaunchActivity(r, null);
                    Trace.traceEnd(Trace.TRACE_TAG_ACTIVITY_MANAGER);
                } break;
                case RELAUNCH_ACTIVITY: {
                    Trace.traceBegin(Trace.TRACE_TAG_ACTIVITY_MANAGER, "activityRestart");
                    ActivityClientRecord r = (ActivityClientRecord)msg.obj;
                    handleRelaunchActivity(r);
                    Trace.traceEnd(Trace.TRACE_TAG_ACTIVITY_MANAGER);
                } break;
                case PAUSE_ACTIVITY:
                    Trace.traceBegin(Trace.TRACE_TAG_ACTIVITY_MANAGER, "activityPause");
                    handlePauseActivity((IBinder)msg.obj, false, msg.arg1 != 0, msg.arg2);
                    maybeSnapshot();
                    Trace.traceEnd(Trace.TRACE_TAG_ACTIVITY_MANAGER);
                    break;
                case PAUSE_ACTIVITY_FINISHING:
                    Trace.traceBegin(Trace.TRACE_TAG_ACTIVITY_MANAGER, "activityPause");
                    handlePauseActivity((IBinder)msg.obj, true, msg.arg1 != 0, msg.arg2);
                    Trace.traceEnd(Trace.TRACE_TAG_ACTIVITY_MANAGER);
                    break;
                case STOP_ACTIVITY_SHOW:
                    Trace.traceBegin(Trace.TRACE_TAG_ACTIVITY_MANAGER, "activityStop");
                    handleStopActivity((IBinder)msg.obj, true, msg.arg2);
                    Trace.traceEnd(Trace.TRACE_TAG_ACTIVITY_MANAGER);
                    break;
                case STOP_ACTIVITY_HIDE:
                    Trace.traceBegin(Trace.TRACE_TAG_ACTIVITY_MANAGER, "activityStop");
                    handleStopActivity((IBinder)msg.obj, false, msg.arg2);
                    Trace.traceEnd(Trace.TRACE_TAG_ACTIVITY_MANAGER);
                    break;
                case SHOW_WINDOW:
                    Trace.traceBegin(Trace.TRACE_TAG_ACTIVITY_MANAGER, "activityShowWindow");
                    handleWindowVisibility((IBinder)msg.obj, true);
                    Trace.traceEnd(Trace.TRACE_TAG_ACTIVITY_MANAGER);
                    break;
                case HIDE_WINDOW:
                    Trace.traceBegin(Trace.TRACE_TAG_ACTIVITY_MANAGER, "activityHideWindow");
                    handleWindowVisibility((IBinder)msg.obj, false);
                    Trace.traceEnd(Trace.TRACE_TAG_ACTIVITY_MANAGER);
                    break;
                case RESUME_ACTIVITY:
                    Trace.traceBegin(Trace.TRACE_TAG_ACTIVITY_MANAGER, "activityResume");
                    handleResumeActivity((IBinder)msg.obj, true,
                            msg.arg1 != 0, true);
                    Trace.traceEnd(Trace.TRACE_TAG_ACTIVITY_MANAGER);
                    break;
                case SEND_RESULT:
                    Trace.traceBegin(Trace.TRACE_TAG_ACTIVITY_MANAGER, "activityDeliverResult");
                    handleSendResult((ResultData)msg.obj);
                    Trace.traceEnd(Trace.TRACE_TAG_ACTIVITY_MANAGER);
                    break;
                case DESTROY_ACTIVITY:
                    Trace.traceBegin(Trace.TRACE_TAG_ACTIVITY_MANAGER, "activityDestroy");
                    handleDestroyActivity((IBinder)msg.obj, msg.arg1 != 0,
                            msg.arg2, false);
                    Trace.traceEnd(Trace.TRACE_TAG_ACTIVITY_MANAGER);
                    break;
                case BIND_APPLICATION:
                    Trace.traceBegin(Trace.TRACE_TAG_ACTIVITY_MANAGER, "bindApplication");
                    AppBindData data = (AppBindData)msg.obj;
                    handleBindApplication(data);
                    Trace.traceEnd(Trace.TRACE_TAG_ACTIVITY_MANAGER);
                    break;
                case EXIT_APPLICATION:
                    if (mInitialApplication != null) {
                        mInitialApplication.onTerminate();
                    }
                    Looper.myLooper().quit();
                    break;
                case NEW_INTENT:
                    Trace.traceBegin(Trace.TRACE_TAG_ACTIVITY_MANAGER, "activityNewIntent");
                    handleNewIntent((NewIntentData)msg.obj);
                    Trace.traceEnd(Trace.TRACE_TAG_ACTIVITY_MANAGER);
                    break;
                case RECEIVER:
                    Trace.traceBegin(Trace.TRACE_TAG_ACTIVITY_MANAGER, "broadcastReceiveComp");
                    handleReceiver((ReceiverData)msg.obj);
                    maybeSnapshot();
                    Trace.traceEnd(Trace.TRACE_TAG_ACTIVITY_MANAGER);
                    break;
                case CREATE_SERVICE:
                    Trace.traceBegin(Trace.TRACE_TAG_ACTIVITY_MANAGER, "serviceCreate");
                    handleCreateService((CreateServiceData)msg.obj);
                    Trace.traceEnd(Trace.TRACE_TAG_ACTIVITY_MANAGER);
                    break;
                case BIND_SERVICE:
                    Trace.traceBegin(Trace.TRACE_TAG_ACTIVITY_MANAGER, "serviceBind");
                    handleBindService((BindServiceData)msg.obj);
                    Trace.traceEnd(Trace.TRACE_TAG_ACTIVITY_MANAGER);
                    break;
                case UNBIND_SERVICE:
                    Trace.traceBegin(Trace.TRACE_TAG_ACTIVITY_MANAGER, "serviceUnbind");
                    handleUnbindService((BindServiceData)msg.obj);
                    Trace.traceEnd(Trace.TRACE_TAG_ACTIVITY_MANAGER);
                    break;
                case SERVICE_ARGS:
                    Trace.traceBegin(Trace.TRACE_TAG_ACTIVITY_MANAGER, "serviceStart");
                    handleServiceArgs((ServiceArgsData)msg.obj);
                    Trace.traceEnd(Trace.TRACE_TAG_ACTIVITY_MANAGER);
                    break;
                case STOP_SERVICE:
                    Trace.traceBegin(Trace.TRACE_TAG_ACTIVITY_MANAGER, "serviceStop");
                    handleStopService((IBinder)msg.obj);
                    maybeSnapshot();
                    Trace.traceEnd(Trace.TRACE_TAG_ACTIVITY_MANAGER);
                    break;
                case REQUEST_THUMBNAIL:
                    Trace.traceBegin(Trace.TRACE_TAG_ACTIVITY_MANAGER, "requestThumbnail");
                    handleRequestThumbnail((IBinder)msg.obj);
                    Trace.traceEnd(Trace.TRACE_TAG_ACTIVITY_MANAGER);
                    break;
                case CONFIGURATION_CHANGED:
                    Trace.traceBegin(Trace.TRACE_TAG_ACTIVITY_MANAGER, "configChanged");
                    mCurDefaultDisplayDpi = ((Configuration)msg.obj).densityDpi;
                    handleConfigurationChanged((Configuration)msg.obj, null);
                    Trace.traceEnd(Trace.TRACE_TAG_ACTIVITY_MANAGER);
                    break;
                case CLEAN_UP_CONTEXT:
                    ContextCleanupInfo cci = (ContextCleanupInfo)msg.obj;
                    cci.context.performFinalCleanup(cci.who, cci.what);
                    break;
                case GC_WHEN_IDLE:
                    scheduleGcIdler();
                    break;
                case DUMP_SERVICE:
                    handleDumpService((DumpComponentInfo)msg.obj);
                    break;
                case LOW_MEMORY:
                    Trace.traceBegin(Trace.TRACE_TAG_ACTIVITY_MANAGER, "lowMemory");
                    handleLowMemory();
                    Trace.traceEnd(Trace.TRACE_TAG_ACTIVITY_MANAGER);
                    break;
                case ACTIVITY_CONFIGURATION_CHANGED:
                    Trace.traceBegin(Trace.TRACE_TAG_ACTIVITY_MANAGER, "activityConfigChanged");
                    handleActivityConfigurationChanged((IBinder)msg.obj);
                    Trace.traceEnd(Trace.TRACE_TAG_ACTIVITY_MANAGER);
                    break;
                case PROFILER_CONTROL:
                    handleProfilerControl(msg.arg1 != 0, (ProfilerControlData)msg.obj, msg.arg2);
                    break;
                case CREATE_BACKUP_AGENT:
                    Trace.traceBegin(Trace.TRACE_TAG_ACTIVITY_MANAGER, "backupCreateAgent");
                    handleCreateBackupAgent((CreateBackupAgentData)msg.obj);
                    Trace.traceEnd(Trace.TRACE_TAG_ACTIVITY_MANAGER);
                    break;
                case DESTROY_BACKUP_AGENT:
                    Trace.traceBegin(Trace.TRACE_TAG_ACTIVITY_MANAGER, "backupDestroyAgent");
                    handleDestroyBackupAgent((CreateBackupAgentData)msg.obj);
                    Trace.traceEnd(Trace.TRACE_TAG_ACTIVITY_MANAGER);
                    break;
                case SUICIDE:
                    Process.killProcess(Process.myPid());
                    break;
                case REMOVE_PROVIDER:
                    Trace.traceBegin(Trace.TRACE_TAG_ACTIVITY_MANAGER, "providerRemove");
                    completeRemoveProvider((ProviderRefCount)msg.obj);
                    Trace.traceEnd(Trace.TRACE_TAG_ACTIVITY_MANAGER);
                    break;
                case ENABLE_JIT:
                    ensureJitEnabled();
                    break;
                case DISPATCH_PACKAGE_BROADCAST:
                    Trace.traceBegin(Trace.TRACE_TAG_ACTIVITY_MANAGER, "broadcastPackage");
                    handleDispatchPackageBroadcast(msg.arg1, (String[])msg.obj);
                    Trace.traceEnd(Trace.TRACE_TAG_ACTIVITY_MANAGER);
                    break;
                case SCHEDULE_CRASH:
                    throw new RemoteServiceException((String)msg.obj);
                case DUMP_HEAP:
                    handleDumpHeap(msg.arg1 != 0, (DumpHeapData)msg.obj);
                    break;
                case DUMP_ACTIVITY:
                    handleDumpActivity((DumpComponentInfo)msg.obj);
                    break;
                case DUMP_PROVIDER:
                    handleDumpProvider((DumpComponentInfo)msg.obj);
                    break;
                case SLEEPING:
                    Trace.traceBegin(Trace.TRACE_TAG_ACTIVITY_MANAGER, "sleeping");
                    handleSleeping((IBinder)msg.obj, msg.arg1 != 0);
                    Trace.traceEnd(Trace.TRACE_TAG_ACTIVITY_MANAGER);
                    break;
                case SET_CORE_SETTINGS:
                    Trace.traceBegin(Trace.TRACE_TAG_ACTIVITY_MANAGER, "setCoreSettings");
                    handleSetCoreSettings((Bundle) msg.obj);
                    Trace.traceEnd(Trace.TRACE_TAG_ACTIVITY_MANAGER);
                    break;
                case UPDATE_PACKAGE_COMPATIBILITY_INFO:
                    handleUpdatePackageCompatibilityInfo((UpdateCompatibilityData)msg.obj);
                    break;
                case TRIM_MEMORY:
                    Trace.traceBegin(Trace.TRACE_TAG_ACTIVITY_MANAGER, "trimMemory");
                    handleTrimMemory(msg.arg1);
                    Trace.traceEnd(Trace.TRACE_TAG_ACTIVITY_MANAGER);
                    break;
                case UNSTABLE_PROVIDER_DIED:
                    handleUnstableProviderDied((IBinder)msg.obj, false);
                    break;
                case REQUEST_ACTIVITY_EXTRAS:
                    handleRequestActivityExtras((RequestActivityExtras)msg.obj);
                    break;
            }
            if (DEBUG_MESSAGES) Slog.v(TAG, "<<< done: " + codeToString(msg.what));
        }
  1. 调用ActivityThread的handleLaunchActivity(r, null)方法
Activity a = performLaunchActivity(r, customIntent);

        if (a != null) {
            r.createdConfig = new Configuration(mConfiguration);
            Bundle oldState = r.state;
            handleResumeActivity(r.token, false, r.isForward,
                    !r.activity.mFinished && !r.startsNotResumed);
  1. performLaunchActivity完成Activity对象的创建，handleResumeActivity完成Activity的onResume一系列方法。

2、performLaunchActivity的流程

  1. 从ActiivtyClientRecord中获取Activity的组建信息
private Activity performLaunchActivity(ActivityClientRecord r, Intent customIntent) {
        // System.out.println("##### [" + System.currentTimeMillis() + "] ActivityThread.performLaunchActivity(" + r + ")");

        ActivityInfo aInfo = r.activityInfo;
        if (r.packageInfo == null) {
            r.packageInfo = getPackageInfo(aInfo.applicationInfo, r.compatInfo,
                    Context.CONTEXT_INCLUDE_CODE);
        }

        ComponentName component = r.intent.getComponent();
        if (component == null) {
            component = r.intent.resolveActivity(
                mInitialApplication.getPackageManager());
            r.intent.setComponent(component);
        }

        if (r.activityInfo.targetActivity != null) {
            component = new ComponentName(r.activityInfo.packageName,
                    r.activityInfo.targetActivity);
        }
  1. 调用mInstrumentation.newActivity创建Activity
activity = mInstrumentation.newActivity(
                    cl, component.getClassName(), r.intent);
    public Activity newActivity(ClassLoader cl, String className,
            Intent intent)
            throws InstantiationException, IllegalAccessException,
            ClassNotFoundException {
        return (Activity)cl.loadClass(className).newInstance();
    }

通过类加载器来创建Activity
3. 通过LoadedApk的makeApplication方法创建Application

    public Application makeApplication(boolean forceDefaultAppClass,
            Instrumentation instrumentation) {
        if (mApplication != null) {
            return mApplication;
        }

        Application app = null;

        String appClass = mApplicationInfo.className;
        if (forceDefaultAppClass || (appClass == null)) {
            appClass = "android.app.Application";
        }

        try {
            java.lang.ClassLoader cl = getClassLoader();
            ContextImpl appContext = new ContextImpl();
            appContext.init(this, null, mActivityThread);
            app = mActivityThread.mInstrumentation.newApplication(
                    cl, appClass, appContext);
            appContext.setOuterContext(app);
        } catch (Exception e) {
            if (!mActivityThread.mInstrumentation.onException(app, e)) {
                throw new RuntimeException(
                    "Unable to instantiate application " + appClass
                    + ": " + e.toString(), e);
            }
        }
        mActivityThread.mAllApplications.add(app);
        mApplication = app;

        if (instrumentation != null) {
            try {
                instrumentation.callApplicationOnCreate(app);
            } catch (Exception e) {
                if (!instrumentation.onException(app, e)) {
                    throw new RuntimeException(
                        "Unable to create application " + app.getClass().getName()
                        + ": " + e.toString(), e);
                }
            }
        }

        return app;

里面有以下代码

app = mActivityThread.mInstrumentation.newApplication(
                    cl, appClass, appContext);
    public Application newApplication(ClassLoader cl, String className, Context context)
            throws InstantiationException, IllegalAccessException, 
            ClassNotFoundException {
        return newApplication(cl.loadClass(className), context);
    }

可以看到也是通过类加载器来加载Application的，然后调用zai makeApplication方法中调用Application的onCreate方法了

instrumentation.callApplicationOnCreate(app);
  1. 调用Activity的onCreate
mInstrumentation.callActivityOnCreate(activity, r.state);

完成！
原帖地址
我的GitHub

zzzhangzhun
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Android Activity的启动过程源码解析
08-27
Android Activity的启动过程源码解析 Android Activity是Android系统中一个非常重要的概念，堪称四大组件之首。Activity的启动过程是一个复杂的过程，涉及到多个类和方法的调用。本文将从源码的角度对Activity的...
（Android 9.0）Activity启动流程源码分析
Peter的专栏
09-09 6970
前言 熟悉Activity的启动流程和运行原理是一个合格的应用开发人员所应该具备的基本素质，其重要程度就不多做描述了。同时，知识栈应该不断的更新，最新发布的Android 9.0版本相较于之前的几个版本也做了许多改动和重构，但是大体流程变化不大。本文基于Android 9.0版本源码，从Activity启动方法startActivity为切入口分析整个流程。 一、发出启动请求 启动一个A...
Activity启动过程详解(Android 12源码分析)
最新发布
yangfengxiao的专栏
08-08 6万+
activity启动流程
【源码解析】Activity的启动过程
Running&H的博客
09-17 188
在平时启动Activity时，我们常用的是在Activity中直接调用startActivity(intent)就可以启动Activity，或者是通过context来启动Activity。归根结底调用的是ContextImpl类的startActivity(intent)方法。所以我们直接从ContextImpl的startActivity(intent)方法开始，而startActivity(i...
Activity启动流程源码分析
start_mao的博客
07-12 1392
不管我们从手机的主菜单进入应用程序的根Activity还是在应用内跳转到某个Activity都会调用startActivity方法。 startActivity方法最终都会走到startActivityForResult方法。然后借助Instrumentation类的execStartActivity方法来执行startActivity的任务，需要注意的是该方法的第二个参数它是Applicati...
源码解析之Activity的启动流程
jhonjson的博客
08-28 215
Activity的启动在我们的Android学习中随处可见，但是它的原理是如何运行的，我相信知道的人并不是很多。 此篇，让我们一起去见证Activity启动之美。 Activity的两种启动流程分别是: 点击Launcher启动新的Activity。 正在运行的app的Activity，即启动子Activity。 区别：launcher本身就是一个应用，当我们点击图标的时候，系统会调用star...
Android Zygote启动流程源码解析
08-03
### Android Zygote启动流程源码解析 #### 引言 在Android系统中，Zygote进程扮演着至关重要的角色，作为所有应用进程和SystemServer进程的“始祖”。了解Zygote的启动流程对于深入理解Android底层机制具有重要...
Activity 启动过程源码+分析过程
10-16
2. **Activity启动源码路径** - **应用程序层**：调用`Context.startActivity()`或`Intent`的`startActivity()`方法，最终会走到`ActivityThread`的`performLaunchActivity()`。 - **Binder层**：`ActivityThread`...
Android Activity启动模式全面解析
09-02
在Android开发中，Activity是应用程序的基本构建块，用于与用户交互。...合理地配置启动模式，可以避免不必要的Activity实例创建，优化导航流程，同时减少由于内存泄漏或不恰当的Activity管理导致的问题。
从源码的角度描述下Activity的启动过程
dengjiamingcsu的博客
04-03 387
Activity启动流程图   当我们点击 app 后，Launcher 进程采用 Binder IPC 向 system_server 进程发起 startActivity 请求，system_server 进程接收到请求后，向 zygote 进程发送创建进程的请求， Zygote 进程 fork 出新的子进程，即 App 进程，然后启动我们 App 的第一个类 ActivityThre...
android intent跳转当前activity,[android]Intent跳转新的Activity可以传递数据过去
weixin_26742753的博客
05-27 155
通过intent.putExra()来传递数据新的Activity通过Intent intent = getInten();例如//Item单击事件，单击后跳转到新的Activyty,并显示完整的内容public void onItemClick(AdapterView> parent, View view, int position,long id) {//获取当前Item的完整数据Blo...
Android Activity的启动流程源码解析(8.0)
小王君的专栏
11-15 2万+
一，写在前面        Activity是Android四大组件之一，用于直接跟用户进行交互，本篇文章将介绍Activity的启动流程。用户启动Activity的方式大致有两种：一种是在桌面点击应用程序的图标，进入应用程序的主界面；另一种是在应用程序中，进入一个新的Activity。前者，桌面其实是系统应用launcher的界面，点击应用程序图标，会进行应用程序的主界面，实质是从一个应用的A
Android源码分析-Activity的启动过程
我是传奇
01-12 461
转载请注明出处：http://blog.csdn.net/singwhatiwanna/article/details/18154335前言 Activity是Android中一个很重要的概念，堪称四大组件之首，关于Activity有很多内容，比如生命周期和启动Flags，这二者想要说清楚，恐怕又要写两篇长文，更何况分析它们的源码呢。不过本文的侧重点不是它们，我要介绍的是一个Activity典型的...
Android源码探究：Activity启动流程完全解析
蓝天白云梦的csdn博客
05-07 1637
概述 本文主要内容是从源码角度进行Activity启动流程的分析。由于整个启动的过程非常长并且代码非常多，同时受限于笔者的水平，所以本文不会细致到解释每一行的代码的具体作用，只能抽取处关键部分的代码就主体流程进行分析，如有错误之处，希望批评指出。 行文脉络 由于本文会非常长，为了方便读者的理解，首先给出笔者的行文脉络。本文主要沿着：在应用程序1的Activity A内打开另一个应用程序2的Acti...
从源码角度分析Activity的启动流程
q1210249579的博客
01-01 312
挥舞着指尖，谱写指尖的艺术 前言 阅读完本章你将收获 Activity的启动流程 AMS与客户端交互实现Activity启动过程 Activity中的任务栈出入流程 Application是何时 在哪创建的 先执行attach()还是先执行onCreate() 这里我们从Activity的启动流程开始分析，一路向西。冲冲冲！ 正题 一. 如何启动(跳转)一个Activity Intent intent = new Intent(this,要跳转的活动.class); startActivity(in.
使用Ultra-Pull-To-Refresh下拉刷新时解决与嵌套的viewpager触摸滑动冲突的问题
前方的征途是星辰大海
12-15 3264
同样是在做的天气app中，使用了开源的Ultra-Pull-To-Refresh下拉刷新控件，由于在项目中有一个viewpager负责显示之后5天的天气预报，但加入Ultra-Pull-To-Refresh时产生了一个问题，就是viewpager左右滑动时非常的难，使用下面的代码可以解决问题： 1、自定义viewpager package com.myzaker.autoinsuran
android Viewpager取消预加载
前方的征途是星辰大海
12-13 2606
1.在使用ViewPager嵌套Fragment的时候，由于VIewPager的几个Adapter的设置来说，都会有一定的预加载。通过设置setOffscreenPageLimit（int number) 来设置预加载的数量，在V4包中，默认的预加载是1，即使你设置为0，也是不起作用的，设置的只能是大于1才会有效果的。 2.限制预加载，会出现滑动过程中卡顿现象。其实Fragment中防止预加
viewpager+fragment(初始化时需要注意的几点问题)
前方的征途是星辰大海
12-13 2501
最近在做一款关于天气预报的app，已经做出一半了，先放张半成品截图吧 可以看出大体使用了viewpager|+fragment这种框架，这里选择的的适配器是FragmentStatePagerAdapter，除了这个之外还有一种适配器FragmentPagerAdapter，下面先简单介绍下这两种适配器的不同点： 使用FragmentPagerAdapter  时，Fragment对象会一
报错：Attribute ”rippleColor“ has already been defined”（纯手打，已解决）
前方的征途是星辰大海
02-15 2329
解决support.design和MaterialDesignLibrary库文件发生冲突的问题
Android启动流程深度解析：从引导到Activity
本文档深入解析了Android系统的启动流程，分为几个关键阶段进行详细探讨。首先，从系统引导阶段开始，介绍了bootloader程序的重要性，它是Android启动的第一步，负责加载内核和引导其他低级组件。接着，核心部分阐述...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值