从源码的角度探究Activity的启动过程

最新推荐文章于 2021-01-01 23:21:30 发布
最新推荐文章于 2021-01-01 23:21:30 发布
阅读量566 收藏
点赞数
分类专栏： 系统分析
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Small_Lee/article/details/50844613
版权

一.概述

今天我们来搞一下底层一点的东西，大家可能对Activity的生命周期比较熟悉，但是一个Activity是如何启动起来的，你知道吗？今天就来探究一下。

二.分析

我们先随便写一个demo，然后在某个地方打开断点，debug模式运行程序，然后我们在Debug视图中把主线程暂停，我们可以看到调用栈，如下图所示，

这里写图片描述

在android中，应用程序的入口是ActivityThead中的main函数。

于是我们先看android.app.ActivityThread的main()方法。我们进入到这个方法里面。

 public static void main(String[] args) {
        SamplingProfilerIntegration.start();

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

        Environment.initForCurrentUser();

        // Set the reporter for event logging in libcore
        EventLogger.setReporter(new EventLoggingReporter());

        Security.addProvider(new AndroidKeyStoreProvider());

        Process.setArgV0("<pre-initialized>");
        //获取Looper
        Looper.prepareMainLooper();

        ActivityThread thread = new ActivityThread();
        thread.attach(false);

        if (sMainThreadHandler == null) {
            sMainThreadHandler = thread.getHandler();
        }

        AsyncTask.init();

        if (false) {
            Looper.myLooper().setMessageLogging(new
                    LogPrinter(Log.DEBUG, "ActivityThread"));
        }

        Looper.loop();

        throw new RuntimeException("Main thread loop unexpectedly exited");

main方法中先调用下面的方法对Looper进行初始化

 Looper.prepareMainLooper();

我们进入Looper中的这个方法

  public static void prepareMainLooper() {
        prepare(false);
        synchronized (Looper.class) {
            if (sMainLooper != null) {
                throw new IllegalStateException("The main Looper has already been prepared.");
            }
            sMainLooper = myLooper();
        }
    }

又调用了prepare方法

   private static void prepare(boolean quitAllowed) {
        if (sThreadLocal.get() != null) {
            throw new RuntimeException("Only one Looper may be created per thread");
        }
        //创建Looper对象，放入ThreadLocal中
        sThreadLocal.set(new Looper(quitAllowed));
    }

我们看看Looper的构造函数

 private Looper(boolean quitAllowed) {
        mQueue = new MessageQueue(quitAllowed);
        mRun = true;
        mThread = Thread.currentThread();
    }

然后调用了myLooper()方法

  public static Looper myLooper() {
        return sThreadLocal.get();
    }

这里从存放Looper的线程池里面取出一个Looper对象。
最后main方法里面调用Looper.loop()方法，我们看看

 public static void loop() {
         //取出当前线程对应的Looper对象
        final Looper me = myLooper();
        if (me == null) {
        //调用Looper.loop()方法前如果不掉用prepareMainLooper()方法就会抛出这个异常
            throw new RuntimeException("No Looper; Looper.prepare() wasn't called on this thread.");
        }
        //获得Looper对应的消息队列
        final MessageQueue queue = me.mQueue;

        // Make sure the identity of this thread is that of the local process,
        // and keep track of what that identity token actually is.
        Binder.clearCallingIdentity();
        final long ident = Binder.clearCallingIdentity();
        //死循环，不断从消息队列中取出消息，没有则阻塞
        for (;;) {
            Message msg = queue.next(); // might block
            if (msg == null) {
                // No message indicates that the message queue is quitting.
                return;
            }

            // This must be in a local variable, in case a UI event sets the logger
            Printer logging = me.mLogging;
            if (logging != null) {
                logging.println(">>>>> Dispatching to " + msg.target + " " +
                        msg.callback + ": " + msg.what);
            }
            //调用了msg.target的dispatchMessage方法处理消息，其实这个msg.target就是当前线程的Handler对象
            msg.target.dispatchMessage(msg);

            if (logging != null) {
                logging.println("<<<<< Finished to " + msg.target + " " + msg.callback);
            }

            // Make sure that during the course of dispatching the
            // identity of the thread wasn't corrupted.
            final long newIdent = Binder.clearCallingIdentity();
            if (ident != newIdent) {
                Log.wtf(TAG, "Thread identity changed from 0x"
                        + Long.toHexString(ident) + " to 0x"
                        + Long.toHexString(newIdent) + " while dispatching to "
                        + msg.target.getClass().getName() + " "
                        + msg.callback + " what=" + msg.what);
            }

            msg.recycle();

这里我们看下面这行代码

msg.target.dispatchMessage(msg);

通过查看源码我们知道msg.target是一个Handler对象，于是我们进入到Handler中的dispatchMessage方法中去，

 public void dispatchMessage(Message msg) {
        if (msg.callback != null) {
            handleCallback(msg);
        } else {
            if (mCallback != null) {
                if (mCallback.handleMessage(msg)) {
                    return;
                }
            }
            handleMessage(msg);
        }
    }

最终我们可以看到，调用了handleMessage方法，而handleMessage方法在Handler里面是一个空的方法，因为我们需要自己来处理消息，这下大家明白了我们使用Handler时的handleMessage方法是如何被调用的了吧。

接下来回到正题，既然在main方法里面初始化了Looper，那么我们去找找和这个Looper相关联的Handler对象，经过漫长的寻找，我们终于找到了，

private class H extends Handler {
        public static final int LAUNCH_ACTIVITY         = 100;
        public static final int PAUSE_ACTIVITY          = 101;
        public static final int PAUSE_ACTIVITY_FINISHING= 102;
        public static final int STOP_ACTIVITY_SHOW      = 103;
        public static final int STOP_ACTIVITY_HIDE      = 104;
        public static final int SHOW_WINDOW             = 105;
        public static final int HIDE_WINDOW             = 106;
        public static final int RESUME_ACTIVITY         = 107;
        public static final int SEND_RESULT             = 108;
        public static final int DESTROY_ACTIVITY        = 109;
        public static final int BIND_APPLICATION        = 110;
        public static final int EXIT_APPLICATION        = 111;

这是一个内部类，名字叫做H,继承自Handler,然后我们去看它的handleMessage方法，

 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;

那么这个消息是从哪发送过来的呢？是在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);
           }

handleMessage中调用了一个重要的方法handleLaunchActivity，从名字上看我们觉得应该是处理Activity的启动的，进去看看，

  private void handleLaunchActivity(ActivityClientRecord r, Intent customIntent) {
        // If we are getting ready to gc after going to the background, well
        // we are back active so skip it.
        unscheduleGcIdler();

        if (r.profileFd != null) {
            mProfiler.setProfiler(r.profileFile, r.profileFd);
            mProfiler.startProfiling();
            mProfiler.autoStopProfiler = r.autoStopProfiler;
        }

        // Make sure we are running with the most recent config.
        handleConfigurationChanged(null, null);

        if (localLOGV) Slog.v(
            TAG, "Handling launch of " + r);
            //执行启动Activity的方法
        Activity a = performLaunchActivity(r, customIntent);

        if (a != null) {
            r.createdConfig = new Configuration(mConfiguration);
            Bundle oldState = r.state;
            //执行activity的resume操作
            handleResumeActivity(r.token, false, r.isForward,
                    !r.activity.mFinished && !r.startsNotResumed);

            if (!r.activity.mFinished && r.startsNotResumed) {

                try {
                    r.activity.mCalled = false;
                    mInstrumentation.callActivityOnPause(r.activity);

                    if (r.isPreHoneycomb()) {
                        r.state = oldState;
                    }
                    if (!r.activity.mCalled) {
                        throw new SuperNotCalledException(
                            "Activity " + r.intent.getComponent().toShortString() +
                            " did not call through to super.onPause()");
                    }

                } catch (SuperNotCalledException e) {
                    throw e;

                } catch (Exception e) {
                    if (!mInstrumentation.onException(r.activity, e)) {
                        throw new RuntimeException(
                                "Unable to pause activity "
                                + r.intent.getComponent().toShortString()
                                + ": " + e.toString(), e);
                    }
                }
                r.paused = true;
            }
        } else {
            // If there was an error, for any reason, tell the activity
            // manager to stop us.
            try {
                ActivityManagerNative.getDefault()
                    .finishActivity(r.token, Activity.RESULT_CANCELED, null);
            } catch (RemoteException ex) {
                // Ignore
            }
        }

这里调用了两个比较重要的方法，performLaunchActivity和handleResumeActivity。

我们先看performLaunchActivity做了什么事情，

  private Activity performLaunchActivity(ActivityClientRecord r, Intent customIntent) {
    //省去大量代码

        Activity activity = null;
        try {
            java.lang.ClassLoader cl = r.packageInfo.getClassLoader();
            //通过Activity的类名构建一个Activity对象，具体的创建Activity对象的操作在mInstrumentation中
            activity = mInstrumentation.newActivity(
                    cl, component.getClassName(), r.intent);
                    //省去一些代码
               if (activity != null) {
                Context appContext = createBaseContextForActivity(r, activity);
                CharSequence title = r.activityInfo.loadLabel(appContext.getPackageManager());
                Configuration config = new Configuration(mCompatConfiguration);
                if (DEBUG_CONFIGURATION) Slog.v(TAG, "Launching activity "
                        + r.activityInfo.name + " with config " + config);
                        //调用activity的attach方法
                activity.attach(appContext, this, getInstrumentation(), r.token,
                        r.ident, app, r.intent, r.activityInfo, title, r.parent,
                        r.embeddedID, r.lastNonConfigurationInstances, config);

//省去一些代码
 activity.mCalled = false;
//通过Instrumentation对象执行Activity的onCreate()方法，Activity的生命周期方法都是由Instrumentation对象来调用的。                mInstrumentation.callActivityOnCreate(activity, r.state);
                if (!activity.mCalled) {
                    throw new SuperNotCalledException(
                        "Activity " + r.intent.getComponent().toShortString() +
                        " did not call through to super.onCreate()");
                }

其实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) {
        attachBaseContext(context);

        mFragments.attachActivity(this, mContainer, null);
          //给Window对象赋值
        mWindow = PolicyManager.makeNewWindow(this);
        mWindow.setCallback(this);
        mWindow.getLayoutInflater().setPrivateFactory(this);
        if (info.softInputMode != WindowManager.LayoutParams.SOFT_INPUT_STATE_UNSPECIFIED) {
            mWindow.setSoftInputMode(info.softInputMode);
        }
        if (info.uiOptions != 0) {
            mWindow.setUiOptions(info.uiOptions);
        }
        mUiThread = Thread.currentThread();

        mMainThread = aThread;
        mInstrumentation = instr;
        mToken = token;
        mIdent = ident;
        mApplication = application;
        mIntent = intent;
        mComponent = intent.getComponent();
        mActivityInfo = info;
        mTitle = title;
        mParent = parent;
        mEmbeddedID = id;
        mLastNonConfigurationInstances = lastNonConfigurationInstances;
        //给Window对象设置WindowManager
        mWindow.setWindowManager(
                (WindowManager)context.getSystemService(Context.WINDOW_SERVICE),
                mToken, mComponent.flattenToString(),
                (info.flags & ActivityInfo.FLAG_HARDWARE_ACCELERATED) != 0);
        if (mParent != null) {
            mWindow.setContainer(mParent.getWindow());
        }
        //给Activity的mWindowManager 赋值
        mWindowManager = mWindow.getWindowManager();
        mCurrentConfig = config;

mWindow是一个Window类型的变量，但实际上它是一个PhoneWindow对象，与Activity的内容显示相关。

上面的attach()方法调用完成后，就自然而然的调用了Activity的onCreate()方法了。在onCreate方法中，我们会调用setContentView方法，关于这个方法的讲解，请看
setContentView源码解析

当setContentView执行完毕以后，这个时候界面还没有显示出任何东西来，而仅仅是将mDecor->mContentParent->(customer layout)一个这样的树状结构给搭建好了而已。

假设setContentView()方法是onCreate()方法中唯一一个方法，那么onCreate()方法也执行完了，调用栈继续回退，就回到了android.app.ActivityThread.handleLaunchActivity()中，以上的所以就是刚刚执行完了android.app.ActivityThread.performLaunchActivity()。

接下来执行第二个关键性的方法handleResumeActivity()。

//省去一些代码
        ActivityClientRecord r = performResumeActivity(token, clearHide);

        if (r != null) {
            final Activity a = r.activity;

            if (localLOGV) Slog.v(
                TAG, "Resume " + r + " started activity: " +
                a.mStartedActivity + ", hideForNow: " + r.hideForNow
                + ", finished: " + a.mFinished);

            final int forwardBit = isForward ?
                    WindowManager.LayoutParams.SOFT_INPUT_IS_FORWARD_NAVIGATION : 0;

            // If the window hasn't yet been added to the window manager,
            // and this guy didn't finish itself or start another activity,
            // then go ahead and add the window.
            boolean willBeVisible = !a.mStartedActivity;
            if (!willBeVisible) {
                try {
                    willBeVisible = ActivityManagerNative.getDefault().willActivityBeVisible(
                            a.getActivityToken());
                } catch (RemoteException e) {
                }
            }
            if (r.window == null && !a.mFinished && willBeVisible) {
            //获取window
                r.window = r.activity.getWindow();
                //获取DecorView
                View decor = r.window.getDecorView();
                decor.setVisibility(View.INVISIBLE);
                //获取ViewManager,ViewManager是WindowManager的父类
                ViewManager vm = a.getWindowManager();
                WindowManager.LayoutParams l = r.window.getAttributes();
                a.mDecor = decor;
                l.type = WindowManager.LayoutParams.TYPE_BASE_APPLICATION;
                l.softInputMode |= forwardBit;
                if (a.mVisibleFromClient) {
                    a.mWindowAdded = true;
                    vm.addView(decor, l);//添加decorview到Activity中
                }
//省去海量代码

先是调用performResumeActivity方法，这个方法内就是通过Instrumentation调用Activity的onResume()方法。下面的addView方法非常关键，vm是上面的a.getWindowManager()获得的，a是activity对象，Activity中的getWindowManager返回的是mWindowManager，而WindowManager的实现类是WindowManagerImpl，于是我们看它里面的addView方法


    @Override
    public void addView(View view, ViewGroup.LayoutParams params) {
        mGlobal.addView(view, params, mDisplay, mParentWindow);
    }

又调用了mGlobal里面的addView方法，mGlobal是WindowManagerGlobal的对象，然后进去WindowManagerGlobal里面

  public void addView(View view, ViewGroup.LayoutParams params,
            Display display, Window parentWindow) {
      //省去大量代码

        ViewRootImpl root;
        View panelParentView = null;
//省去部分代码

            root = new ViewRootImpl(view.getContext(), display);

            view.setLayoutParams(wparams);

            if (mViews == null) {
                index = 1;
                mViews = new View[1];
                mRoots = new ViewRootImpl[1];
                mParams = new WindowManager.LayoutParams[1];
            } else {
                index = mViews.length + 1;
                Object[] old = mViews;
                mViews = new View[index];
                System.arraycopy(old, 0, mViews, 0, index-1);
                old = mRoots;
                mRoots = new ViewRootImpl[index];
                System.arraycopy(old, 0, mRoots, 0, index-1);
                old = mParams;
                mParams = new WindowManager.LayoutParams[index];
                System.arraycopy(old, 0, mParams, 0, index-1);
            }
            index--;

            mViews[index] = view;
            mRoots[index] = root;
            mParams[index] = wparams;
             try {
            root.setView(view, wparams, panelParentView);
        } catch (RuntimeException e) {
            // BadTokenException or InvalidDisplayException, clean up.
            synchronized (mLock) {
                final int index = findViewLocked(view, false);
                if (index >= 0) {
                    removeViewLocked(index, true);
                }
            }
            throw e;
        }

这里创建了ViewRootImpl对象，然后调用了setView方法

public void setView(View view, WindowManager.LayoutParams attrs, View panelParentView) {
    synchronized (this) {
        if (mView == null) {
            mView = view;//这个view是上面层层传递下来的decorview
            //省去大量代码
            requestLayout();
            //省去海量代码
            view.assignParent(this);//将viewParent标记为decorview的父类
            //省去部分代码
        }
    }
}

省略后的代码如上所示，首先将传进来的参数view赋值给mView，这里有一点要明确ViewRootImpl其实并不是一个View的子类……因此我认为，mView将是这个对象所认识的root节点，也是整个Activity的root的节点。

接下来调用了requestLayout()方法，这个方法是有效的！

最后设置DecorView的父类为ViewParent。终于终于，mDecor知道了自己父亲是谁，或者说，整个Activity设置了一个根节点，在此之前，我们setContentView()将自己的layout布局add到PhoneWindow.mContentParent的时候，mDecor都不知道自己的parent是哪个，现在整个view的树形结构中有了根节点，也就是ViewRootImpl，那么requestLayout()就有效了，就可以进行后面的measure，layout，draw三步操作了。

  @Override
    public void requestLayout() {
        if (!mHandlingLayoutInLayoutRequest) {
            checkThread();
            mLayoutRequested = true;
            scheduleTraversals();
        }
    }

该方法首先检查是否在主线程，然后就执行了scheduleTraversals()方法。看这个方法的名字，就知道是执行一次遍历，遍历的对象就是根节点开始的view tree。

void scheduleTraversals() {
        if (!mTraversalScheduled) {
            mTraversalScheduled = true;
            mTraversalBarrier = mHandler.getLooper().postSyncBarrier();
            mChoreographer.postCallback(
                    Choreographer.CALLBACK_TRAVERSAL, mTraversalRunnable, null);
            scheduleConsumeBatchedInput();
        }
    }

我们注意这个mTraversalRunnable对象，这时会调用run方法

final class TraversalRunnable implements Runnable {
        @Override
        public void run() {
            doTraversal();
        }
    }

run方法里面会调用doTraversal方法，

 void doTraversal() {
        if (mTraversalScheduled) {
            mTraversalScheduled = false;
            mHandler.getLooper().removeSyncBarrier(mTraversalBarrier);

            if (mProfile) {
                Debug.startMethodTracing("ViewAncestor");
            }

            Trace.traceBegin(Trace.TRACE_TAG_VIEW, "performTraversals");
            try {
                performTraversals();//开始绘制view
            } finally {
                Trace.traceEnd(Trace.TRACE_TAG_VIEW);
            }

            if (mProfile) {
                Debug.stopMethodTracing();
                mProfile = false;
            }
        }

这里又调用了performTraversals()方法，这个方法非常长，依次调用了performMeasure()，performLayout()，performDraw()三个方法，终于开始了控件层的测量，布局，绘制三个步骤。

lxn_李小牛
关注
专栏目录
Android系统源码阅读（3）：子Activity在进程内的启动过程
天天吃吃
08-17 757
Android系统源码阅读（3）：子Activity在进程内的启动过程 该系列只记录阅读代码时遇到的问题和心得体会，具体代码讲解可以参考老罗的《Android系统源代码情景分析》，我就不班门弄斧了。我编译的AOSP版本：6.0.1_r50。 Android系统源码阅读3子Activity在进程内的启动过程 子Activity在进程内的启动过程 Step1 从旧Activity开始启动 Step2
Android源码探究：Activity启动流程完全解析
蓝天白云梦的csdn博客
05-07 1647
概述 本文主要内容是从源码角度进行Activity启动流程的分析。由于整个启动的过程非常长并且代码非常多，同时受限于笔者的水平，所以本文不会细致到解释每一行的代码的具体作用，只能抽取处关键部分的代码就主体流程进行分析，如有错误之处，希望批评指出。 行文脉络 由于本文会非常长，为了方便读者的理解，首先给出笔者的行文脉络。本文主要沿着：在应用程序1的Activity A内打开另一个应用程序2的Acti...
从源码的角度描述下Activity的启动过程
dengjiamingcsu的博客
04-03 391
Activity启动流程图   当我们点击 app 后，Launcher 进程采用 Binder IPC 向 system_server 进程发起 startActivity 请求，system_server 进程接收到请求后，向 zygote 进程发送创建进程的请求， Zygote 进程 fork 出新的子进程，即 App 进程，然后启动我们 App 的第一个类 ActivityThre...
从源码的角度看Activity是如何启动的
weixin_34085658的博客
07-05 70
前言 终于申请成为掘金的专栏啦！以后就可以在这里与大家一起分享知识咯！！！还是希望大家访问我的个人博客 ,这篇文章的原文地址在这里 。今天想与大家一起分享的是Activity。我们平时接触的最多的就是Activity了，作为四大组件中最为重要的老大，Activity究竟是如何启动的呢？这篇文章将会从源码的角度为大家进行全方位的解析，为了方便大家理解整个的过程，我会用流程图的方式将整个过程串起来，希...
从源码角度分析Activity的启动流程
q1210249579的博客
01-01 318
挥舞着指尖，谱写指尖的艺术 前言 阅读完本章你将收获 Activity的启动流程 AMS与客户端交互实现Activity启动过程 Activity中的任务栈出入流程 Application是何时 在哪创建的 先执行attach()还是先执行onCreate() 这里我们从Activity的启动流程开始分析，一路向西。冲冲冲！ 正题 一. 如何启动(跳转)一个Activity Intent intent = new Intent(this,要跳转的活动.class); startActivity(in.
从源码的角度描述Activity的启动过程
cylzll的博客
04-02 274
从源码的角度描述Activity的启动过程Activity作为Android四大组件之一，也是我们平时开发中使用的最多的组件。作为四大组件中最为重要的老大，Activity究竟是如何启动的呢？这篇文章从源码的角度简单的为大家进行解析。（PS：本文源码基于7.0系统）一般启动Activity有两种方法，这里就不再详细说这两种方法了，但是他们都是调用了同样的一个逻辑startActivity()方法。...
从源码角度解析Android中APK安装过程
张许平的博客
11-28 2750
从源码角度解析Android中APK的安装过程 1. Android中APK简介 Android应用Apk的安装有如下四种方式： 1.1 系统应用安装 没有安装界面，在开机时自动完成 1.2 网络下载应用安装 没有安装界面，在应用市场完成 1.3 ADB命令安装 没有安装界面，通过命令直接安装 1.4 外部设备安装 有安装界面，通过SD卡等外部设备安装，由packageInstaller处理...
学徒浅析Android——从setContentView()角度分析View、Window、Activity三者关系
lz8362的专栏
04-06 7765
本篇文章已授权微信公众号 guolin_blog （郭霖）独家发布参考码源：Android Oreo 8.0.0工具：Layout Inspector 我们在Activity的onCreate()方法中设置setContentView()，但是一直不明白其中的原理，正好公司在开展技术交流活动，分到的课题是View、Activity、Window的关系，借这个机会梳理一番。Activity生命周期的...
安卓Android源码——animation.rar
10-11
在安卓（Android）平台上，动画（Animation）是用户体验设计中的重要组成部分，它可以为...在分析“animation.rar”压缩包中的源码时，可以参照这些知识点，探究其实现细节，学习如何将动画功能融入到自己的项目中。
android源码
06-04
本文将从核心组件、框架结构、API实现等多个角度，深入解析Android SDK 14的源码，旨在帮助开发者更全面地理解和掌握Android系统。 一、核心组件分析 1. Linux内核：Android基于Linux内核，提供了硬件抽象层（HAL...
源码角度分析Android启动流程
Jefferyleng的专栏
06-09 617
作为一个Android开发者，开发时总是对于Andorid底层的实现充满了好奇，处于这种强烈的好奇心，我决定到源码中一探究竟，今天就带大家基于源码的角度简单分析一下Android系统从启动到显示出Launcher界面的流程吧！ 先来贴一张图，我们就依据这张图，跟到源码中去爽一把！（注意：由于高版本的Android版本太过于复杂和庞大，本文主要基于Android 2.3版本进行分析） Andro
Activity的启动过程
猩程变的专栏
12-13 1023
第十三周 Activity的启动过程 话题：从源码的角度描述下Activity的启动过程（高级必问） 应用进程启动activity流程,请结合源码阅读此文章 method:startActivity() @Override public void startActivity(Intent intent) { this.startActivity(intent,...
源码角度深入理解Activity
小一的专栏
12-30 3332
目录 目录 前言 Activity相关类介绍 ActivityThread 前言 这篇博客的名字起的很大，我自己也很担心是否有能力来从源码的角度深入分析Activity。 写这篇博客的起因是因为最近一直利用空闲时间在学习《Android开发艺术探索》，今天总算读完一遍，但是其中第九章节“四大组件的工作过程”一直让我介怀，感觉自己并没有真正的搞懂。 所以这里也是花时
Android源码分析-Activity的启动过程
我是传奇
01-12 471
转载请注明出处：http://blog.csdn.net/singwhatiwanna/article/details/18154335前言 Activity是Android中一个很重要的概念，堪称四大组件之首，关于Activity有很多内容，比如生命周期和启动Flags，这二者想要说清楚，恐怕又要写两篇长文，更何况分析它们的源码呢。不过本文的侧重点不是它们，我要介绍的是一个Activity典型的...
Android源码解析之（十四）-->Activity启动流程
热门推荐
一片枫叶的专栏
04-23 4万+
好吧，终于要开始讲解Activity的启动流程了，Activity的启动流程相对复杂一下，涉及到了Activity中的生命周期方法，涉及到了Android体系的CS模式，涉及到了Android中进程通讯Binder机制等等，首先介绍一下Activity，这里引用一下Android guide中对Activity的介绍： An activity represents a single screen
Activity 启动过程源码详解
zhangqiluGrubby的博客
04-11 1837
Activity 在我们应用程序的开发当中经常用到，我们可以通过下面代码启动一个Activity。 Intent intent = new Intent(this,FirstActivity.class); startActivity(intent); 上面代码很简单，调用Android SDK API ，但是我们不知道系统底层的工作原理。我们要成为高级工程...
android 面试Activity启动流程
北京流年
07-18 1万+
android 面试题之Activity的启动流程 面试中高级的时候，很多公司都会问对Activity的启动流程了解吗？这时候内心真是一万只草泥马奔腾而过，都没准备说啥啊！市场上对Activity启动这块分析的文章很多，但是面试过程中简短的描述就需要很熟悉源码并且用精炼的语言描述出来。先看下大佬是怎么回答这个问题的： Activity的启动过程，我们可以从Context的startAct...
浅析Android Activity的启动过程
LeBron_Six的专栏
04-07 6585
Activity作为Android的四大组件之一，也是最基本的组件，负责与用户交互的所有功能。Activity的启动过程也并非一件神秘的事情，接下来就简单的从源码的角度分析一下Activity的启动过程。根Activity一般就是指我们项目中的MainActivity，代表了一个Android应用程序，一般也是在一个新的进程中启动起来。在Android系统中，所有的Activity组件都保存在堆栈
沈阳建筑大学在河南2021-2024各专业最低录取分数及位次表.pdf
最新发布
09-16
全国各大学在河北2021-2024年各专业最低录取分数及录取位次数据，高考志愿必备参考数据
揭秘Android Activity启动源码全过程
本文将深入解析Android Activity的启动过程，重点关注其源码层面的工作原理。作为Android应用的核心组成部分，Activity负责界面展示和交互，而启动Activity涉及到一系列关键步骤和类的协同工作。 首先，从`Activity...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值