App创建后MainActivity加载到界面

原创 于 2024-08-17 14:45:52 发布 · 370 阅读 · 4 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#java #开发语言 

Q:\SPRO_14_SYS\SPRDROID14_SYS_MAIN_W2x.xx.x\idh.code\frameworks\base\core\java\android\app\ActivityThread.java
public static void main(String[] args) {
        ......
        Looper.prepareMainLooper();
        ActivityThread thread = new ActivityThread();
        ......
        thread.attach(false, startSeq);
        ......
         if (sMainThreadHandler == null) {
            sMainThreadHandler = thread.getHandler();
        }
        Looper.loop();
        ......
        }
        

//在创建ActivityThread时创建ApplicationThread 对象
    final ApplicationThread mAppThread = new ApplicationThread();

    private void attach(boolean system, long startSeq) {
    .......
          if (!system) {
          //非systemserver进程
          .......
          //将Application转为binder，并注册到VM中
          RuntimeInit.setApplicationObject(mAppThread.asBinder());
          //获取AMS
          final IActivityManager mgr = ActivityManager.getService();
          //跨进程通信 Binder
          //将进程的Appilication binder对象传递给AMS，这样AMS和app就可以通信
          mgr.attachApplication(mAppThread, startSeq);

跨进程调用的AMS的attachApplication方法

Q:\SPRO_14_SYS\SPRDROID14_SYS_MAIN_W2x.xx.x\idh.code\frameworks\base\services\core\java\com\android\server\am\ActivityManagerService.java
    @Override
    public final void attachApplication(IApplicationThread thread, long startSeq) {
        if (thread == null) {
            throw new SecurityException("Invalid application interface");
        }
        synchronized (this) {
            int callingPid = Binder.getCallingPid();
            final int callingUid = Binder.getCallingUid();
            final long origId = Binder.clearCallingIdentity();
            attachApplicationLocked(thread, callingPid, callingUid, startSeq);
            Binder.restoreCallingIdentity(origId);
        }
    }
    
    
    @GuardedBy("this")
    private void attachApplicationLocked(@NonNull IApplicationThread thread,
            int pid, int callingUid, long startSeq) {
            ......
            if (pid != MY_PID && pid >= 0) {
            synchronized (mPidsSelfLocked) {
                app = mPidsSelfLocked.get(pid);
            }
            if (app != null && (app.getStartUid() != callingUid || app.getStartSeq() != startSeq)) {
            ......
            //清除之前该pid的Application记录 
            cleanUpApplicationRecordLocked(app, pid, false, false, -1,
                        true /*replacingPid*/, false /* fromBinderDied */);
                removePidLocked(pid, app);
                app = null;
                ......
               }
              ......
           if (app.getThread() != null) {
            handleAppDiedLocked(app, pid, true, true, false /* fromBinderDied */);
        }
        ......
        final String processName = app.processName;
        try {
         //创建进程的AppDeathRecipient 对象
         //进程有crash 等异常退出回回调
        
            AppDeathRecipient adr = new AppDeathRecipient(
                    app, pid, thread);
            thread.asBinder().linkToDeath(adr, 0);
            app.setDeathRecipient(adr);
        }

AppDeathRecipient定义在AMS中，实现了IBinder

private final class AppDeathRecipient implements IBinder.DeathRecipient 

        attachApplicationLocke方法：
        //设置进程的一些参数
        //adj
        synchronized (mProcLock) {
            app.mState.setCurAdj(ProcessList.INVALID_ADJ);
            app.mState.setSetAdj(ProcessList.INVALID_ADJ);
            app.mState.setVerifiedAdj(ProcessList.INVALID_ADJ);
            mOomAdjuster.setAttachingSchedGroupLSP(app);
            app.mState.setForcingToImportant(null);
            clearProcessForegroundLocked(app);
            app.mState.setHasShownUi(false);
            app.mState.setCached(false);
            app.setDebugging(false);
            app.setKilledByAm(false);
            app.setKilled(false);
            // We carefully use the same state that PackageManager uses for
            // filtering, since we use this flag to decide if we need to install
            // providers when user is unlocked later
            app.setUnlocked(StorageManager.isUserKeyUnlocked(app.userId));
        }
        ......
         ApplicationInfo appInfo = instr != null ? instr.mTargetInfo : app.info;
         ......
         //调用app ApplicationThread的bindApplication
         thread.bindApplication(processName, appInfo,
                        app.sdkSandboxClientAppVolumeUuid, app.sdkSandboxClientAppPackage,
                        providerList,
                        instr2.mClass,
                        profilerInfo, instr2.mArguments,
                        instr2.mWatcher,
                        instr2.mUiAutomationConnection, testMode,
                        mBinderTransactionTrackingEnabled, enableTrackAllocation,
                        isRestrictedBackupMode || !normalMode, app.isPersistent(),
                        new Configuration(app.getWindowProcessController().getConfiguration()),
                        app.getCompat(), getCommonServicesLocked(app.isolated),
                        mCoreSettingsObserver.getCoreSettingsLocked(),
                        buildSerial, autofillOptions, contentCaptureOptions,
                        app.getDisabledCompatChanges(), serializedSystemFontMap,
                        app.getStartElapsedTime(), app.getStartUptime());
             //调用ProcessRecord的makeActive          
            synchronized (mProcLock) {
                app.makeActive(thread, mProcessStats);
            }
            //更新Lru列表
            updateLruProcessLocked(app, false, null);

回到ActivityThread

Q:\SPRO_14_SYS\SPRDROID14_SYS_MAIN_W2x.xx.x\idh.code\frameworks\base\core\java\android\app\ActivityThread.java
    private class ApplicationThread extends IApplicationThread.Stub 
    
        @Override
        public final void bindApplication(....){
        ......
            AppBindData data = new AppBindData();
            ......
            //data数据赋值
            ......
            sendMessage(H.BIND_APPLICATION, data);
        }
        
       
       public void handleMessage(Message msg) {
            if (DEBUG_MESSAGES) Slog.v(TAG, ">>> handling: " + codeToString(msg.what));
            switch (msg.what) {
                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;

在这里插入图片描述

    @UnsupportedAppUsage
    private void handleBindApplication(AppBindData data) {
    .......
         //设置一个VM的进程包名
         VMRuntime.setProcessPackageName(data.appInfo.packageName);
        .......
        //设置下时区
        TimeZone.setDefault(null);
        .......
        //一大堆属性check
        //允许抓取binder信息，用于后面抓取systrace
                boolean isAppDebuggable = (data.appInfo.flags & ApplicationInfo.FLAG_DEBUGGABLE) != 0;
        boolean isAppProfileable = isAppDebuggable || data.appInfo.isProfileable();
        Trace.setAppTracingAllowed(isAppProfileable);
        if ((isAppProfileable || Build.IS_DEBUGGABLE) && data.enableBinderTracking) {
            Binder.enableStackTracking();
        }
        .......
        //创建app的ContextImpl对象        
        final IActivityManager mgr = ActivityManager.getService();
        final ContextImpl appContext = ContextImpl.createAppContext(this, data.info);
        mConfigurationController.updateLocaleListFromAppContext(appContext);
        
        .......
        //Instrumentation 类主要用来监控应用程序与系统交互
        // Continue loading instrumentation.
        if (ii != null) {
            initInstrumentation(ii, data, appContext);
        } else {
            mInstrumentation = new Instrumentation();
            mInstrumentation.basicInit(this);
        }
      }
      .......
      //构造Application
      Application app;
      //通过反射去创建Application
      app = data.info.makeApplicationInner(data.restrictedBackupMode, null);
      
      
       try {
                mInstrumentation.onCreate(data.instrumentationArgs);
            }
            catch (Exception e) {
                throw new RuntimeException(
                    "Exception thrown in onCreate() of "
                    + data.instrumentationName + ": " + e.toString(), e);
            }
            try {
                mInstrumentation.callApplicationOnCreate(app);
                CheckTime.checkTime(startTime, "handleBindApplication : callApplicationOnCreate");
            } catch (Exception e) {
                if (!mInstrumentation.onException(app, e)) {
                    throw new RuntimeException(
                      "Unable to create application " + app.getClass().getName()
                      + ": " + e.toString(), e);
                }
            }

AppBindData 是ActivityThread的静态内部类

    static final class AppBindData {
        @UnsupportedAppUsage
        AppBindData() {
        }
        @UnsupportedAppUsage
        LoadedApk info;

Q:\SPRO_14_SYS\SPRDROID14_SYS_MAIN_W2x.xx.x\idh.code\frameworks\base\core\java\android\app\LoadedApk.java
    public Application makeApplicationInner(boolean forceDefaultAppClass,
            Instrumentation instrumentation) {
        return makeApplicationInner(forceDefaultAppClass, instrumentation,
                /* allowDuplicateInstances= */ false);
    }
        private Application makeApplicationInner(boolean forceDefaultAppClass,
            Instrumentation instrumentation, boolean allowDuplicateInstances) {
            ......
            app = mActivityThread.mInstrumentation.newApplication(
                    cl, appClass, appContext);
            appContext.setOuterContext(app);
            ......
            instrumentation.callApplicationOnCreate(app);
            ......
            
         }

Q:\SPRO_14_SYS\SPRDROID14_SYS_MAIN_W2x.xx.x\idh.code\frameworks\base\services\core\java\com\android\server\am\ActivityManagerService.java
回到AMS中
attachApplicationLocked执行完app ApplicationThread的bindApplication
thread.bindApplication
然后继续去创建第一个Activity
finishAttachApplicationInner(startSeq, callingUid, pid);

Q:\SPRO_14_SYS\SPRDROID14_SYS_MAIN_W2x.xx.x\idh.code\frameworks\base\services\core\java\com\android\server\am\ActivityManagerService.java
private void finishAttachApplicationInner(long startSeq, int uid, int pid) {
......
//创建Activity流程
            if (normalMode) {
                try {
                    didSomething = mAtmInternal.attachApplication(app.getWindowProcessController());
                } catch (Exception e) {
                    Slog.wtf(TAG, "Exception thrown launching activities in " + app, e);
                    badApp = true;
                }
            }
 ......
 //service Broadcast拉起
 didSomething |= mServices.attachApplicationLocked(app, processName);
 for (BroadcastQueue queue : mBroadcastQueues) {
       didSomething |= queue.onApplicationAttachedLocked(app);
  }

Q:\SPRO_14_SYS\SPRDROID14_SYS_MAIN_W2x.xx.x\idh.code\frameworks\base\services\core\java\com\android\server\wm\ActivityTaskManagerInternal.java
mAtmInternal是ActivityTaskManagerInternal 对象
    /** Called by AM when an application process attaches. */
    public abstract boolean attachApplication(WindowProcessController wpc) throws RemoteException;

    Q:\SPRO_14_SYS\SPRDROID14_SYS_MAIN_W2x.xx.x\idh.code\frameworks\base\services\core\java\com\android\server\wm\ActivityTaskManagerService.java
    LocalService是ActivityTaskManagerService的内部类，继承了ActivityTaskManagerInternal
    final class LocalService extends ActivityTaskManagerInternal {
    ......
        @Override
        public boolean attachApplication(WindowProcessController wpc) throws RemoteException {
            synchronized (mGlobalLockWithoutBoost) {
                if (Trace.isTagEnabled(TRACE_TAG_WINDOW_MANAGER)) {
                    Trace.traceBegin(TRACE_TAG_WINDOW_MANAGER, "attachApplication:" + wpc.mName);
                }
                try {
                    return mRootWindowContainer.attachApplication(wpc);
                } finally {
                    Trace.traceEnd(TRACE_TAG_WINDOW_MANAGER);
                }
            }
        }

Q:\SPRO_14_SYS\SPRDROID14_SYS_MAIN_W2x.xx.x\idh.code\frameworks\base\services\core\java\com\android\server\wm\RootWindowContainer.java
    boolean attachApplication(WindowProcessController app) throws RemoteException {
        try {
            return mAttachApplicationHelper.process(app);
        } finally {
            mAttachApplicationHelper.reset();
        }
    }
    调用到内部类
private class AttachApplicationHelper implements Consumer<Task>, Predicate<ActivityRecord> {
        boolean process(WindowProcessController app) throws RemoteException {
            mApp = app;
            for (int displayNdx = getChildCount() - 1; displayNdx >= 0; --displayNdx) {
            //调用到Task.java
                getChildAt(displayNdx).forAllRootTasks(this);
                if (mRemoteException != null) {
                    throw mRemoteException;
                }
            }
            if (!mHasActivityStarted) {
                ensureActivitiesVisible(null /* starting */, 0 /* configChanges */,
                        false /* preserveWindows */);
            }
            return mHasActivityStarted;
        }
        
        Q:\SPRO_14_SYS\SPRDROID14_SYS_MAIN_W2x.xx.x\idh.code\frameworks\base\services\core\java\com\android\server\wm\Task.java
    @Override
    boolean forAllRootTasks(Predicate<Task> callback, boolean traverseTopToBottom) {
        return isRootTask() ? callback.test(this) : false;
    }
    回调回来AttachApplicationHelper的test方法
        @Override
        public boolean test(ActivityRecord r) {
        ......
                  if (mTaskSupervisor.realStartActivityLocked(r, mApp,
                        mTop == r && r.getTask().canBeResumed(r) /* andResume */,
                        true /* checkConfig */)) {
                    mHasActivityStarted = true;
                }

Q:\SPRO_14_SYS\SPRDROID14_SYS_MAIN_W2x.xx.x\idh.code\frameworks\base\services\core\java\com\android\server\wm\ActivityTaskSupervisor.java
    boolean realStartActivityLocked(ActivityRecord r, WindowProcessController proc,
            boolean andResume, boolean checkConfig) throws RemoteException {
            ........
            //判断进程是否launcher过Activity
            //通过ATMS获取Activity task client对象
             final IActivityClientController activityClientController =
                    proc.hasEverLaunchedActivity() ? null : mService.mActivityClientController;
           ......
           final Configuration procConfig = proc.prepareConfigurationForLaunchingActivity();
           ......
           // Create activity launch transaction.
           //创建管理进程一切事物的对象
           final ClientTransaction clientTransaction = ClientTransaction.obtain(
                        proc.getThread(), r.token);
            //获取要启动的activity的Intent信息，并加入到clientTransaction对象中
            clientTransaction.addCallback(LaunchActivityItem.obtain(new Intent(r.intent),
                        .........);    
             
             // Schedule transaction.
                mService.getLifecycleManager().scheduleTransaction(clientTransaction);

Q:\SPRO_14_SYS\SPRDROID14_SYS_MAIN_W2x.xx.x\idh.code\frameworks\base\core\java\android\app\servertransaction\ClientTransaction.java
    public void schedule() throws RemoteException {
        if (mClient != null) {
            mClient.scheduleTransaction(this);
        }
    }
    
  /** Target client. */
    private IApplicationThread mClient;

回到进程的ActivityThread

Q:\SPRO_14_SYS\SPRDROID14_SYS_MAIN_W2x.xx.x\idh.code\frameworks\base\core\java\android\app\ActivityThread.java
ApplicationThread是ActivityThread的内部类对象
private class ApplicationThread extends IApplicationThread.Stub 
        @Override
        public void scheduleTransaction(ClientTransaction transaction) throws RemoteException {
            ActivityThread.this.scheduleTransaction(transaction);
        }
        
最终还是调用到了ActivityThread的scheduleTransaction方法

调用到ActivityThread的父类ClientTransactionHandler的scheduleTransaction方法
（以后注意在该类找不到方法的时候，找一下继承的父类，看下是否直接调用了父类的方法）
Q:\SPRO_14_SYS\SPRDROID14_SYS_MAIN_W2x.xx.x\idh.code\frameworks\base\core\java\android\app\ClientTransactionHandler.java
    /** Prepare and schedule transaction for execution. */
    void scheduleTransaction(ClientTransaction transaction) {
        transaction.preExecute(this);
        sendMessage(ActivityThread.H.EXECUTE_TRANSACTION, transaction);
    }
    //发送Message到主线程，等待中线程处理
    

Q:\SPRO_14_SYS\SPRDROID14_SYS_MAIN_W2x.xx.x\idh.code\frameworks\base\core\java\android\app\ActivityThread.java
public void handleMessage(Message msg) {
//接收到Message
                case EXECUTE_TRANSACTION:
                    final ClientTransaction transaction = (ClientTransaction) msg.obj;
                    mTransactionExecutor.execute(transaction);
                    
    private final TransactionExecutor mTransactionExecutor = new TransactionExecutor(this);              

Q:\SPRO_14_SYS\SPRDROID14_SYS_MAIN_W2x.xx.x\idh.code\frameworks\base\core\java\android\app\servertransaction\TransactionExecutor.java
    public void execute(ClientTransaction transaction) {
.......
        executeCallbacks(transaction);

        executeLifecycleState(transaction);
     }
         public void executeCallbacks(ClientTransaction transaction) {
                 final int size = callbacks.size();
                 for (int i = 0; i < size; ++i) {
                             item.execute(mTransactionHandler, token, mPendingActions);
            item.postExecute(mTransactionHandler, token, mPendingActions);
            if (r == null) {
                // Launch activity request will create an activity record.
                r = mTransactionHandler.getActivityClient(token);
            }
            ....}

item.execute 实际上调用的是LaunchActivityItem的execute方法

Q:\SPRO_14_SYS\SPRDROID14_SYS_MAIN_W2x.xx.x\idh.code\frameworks\base\core\java\android\app\servertransaction\LaunchActivityItem.java
    @Override
    public void execute(ClientTransactionHandler client, IBinder token,
            PendingTransactionActions pendingActions) {
        Trace.traceBegin(TRACE_TAG_ACTIVITY_MANAGER, "activityStart");
        ActivityClientRecord r = new ActivityClientRecord(token, mIntent, mIdent, mInfo,
        ........
        client.handleLaunchActivity(r, pendingActions, mDeviceId, null /* customIntent */);
        Trace.traceEnd(TRACE_TAG_ACTIVITY_MANAGER);
    }

Q:\SPRO_14_SYS\SPRDROID14_SYS_MAIN_W2x.xx.x\idh.code\frameworks\base\core\java\android\app\ActivityThread.java
回到ActivityThread的handleLaunchActivity方法
ActivityThread类继承自ClientTransactionHandler
public final class ActivityThread extends ClientTransactionHandler
        implements ActivityThreadInternal {
@Override
    public Activity handleLaunchActivity(ActivityClientRecord r,
            PendingTransactionActions pendingActions, int deviceId, Intent customIntent) {
           .......
           final Activity a = performLaunchActivity(r, customIntent);
           }
           
       /**  Core implementation of activity launch. */
    private Activity performLaunchActivity(ActivityClientRecord r, Intent customIntent) {
    .........
    //获取intent携带的信息，要启动的Activity的信息
    ComponentName component = r.intent.getComponent();
    ContextImpl appContext = createBaseContextForActivity(r);
        Activity activity = null;
        .......
        //通过ClassLoader去反射创建要启动的Activity对象
            java.lang.ClassLoader cl = appContext.getClassLoader();
            long startTime = CheckTime.getTime();
            activity = mInstrumentation.newActivity(
                    cl, component.getClassName(), r.intent);
        ........
         //创建Application对象
         Application app = r.packageInfo.makeApplicationInner(false, mInstrumentation);
         //调用此Activity的attach方法
                        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, window, r.activityConfigCallback,
                        r.assistToken, r.shareableActivityToken);
          ........
          //调用Activity的onCreate方法
         mInstrumentation.callActivityOnCreate(activity, r.state, r.persistentState);

Q:\SPRO_14_SYS\SPRDROID14_SYS_MAIN_W2x.xx.x\idh.code\frameworks\base\core\java\android\app\Activity.java

Activity的attach应该做的是window相关的操作

溜溜1024
关注
Android13 ActivityThread attach流程分析
liuning1985622的博客
05-03 755
ActivityThread的attach是Android应用程序启动的关键步骤之一。在attach过程中，ActivityThread会完成一系列的初始化工作，包括创建Application对象、创建Activity对象、加载资源等。以下是ActivityThread的attach过程的简要描述：创建Application对象：ActivityThread会根据AndroidManifest.xml文件中指定的Application类名，使用反射机制创建一个Application对象。
Android13 ActivityThread handleBindApplication流程分析
liuning1985622的博客
05-03 1654
ActivityThread的handleBindApplication方法是Android应用程序启动过程中的一个重要方法。它负责处理应用程序绑定到ActivityThread的过程。具体来说，handleBindApplication方法执行以下操作：创建Application对象：handleBindApplication方法首先通过LoadedApk.makeApplication方法创建Application对象。
Activity对象创建到显示到屏幕
ZHXLXH的专栏
10-09 535
代码基于Android 28（9.0、pie）分析 一、引子 在Activity启动流程分析一文中，分析了从startActivity()到Activity对象创建的过程，之后分析下Activity对象创建到显示到屏幕的过程。 二、Activity对象创建到显示到屏幕 2.1 activity.attach() 这里从上部分最后的activity.attach()方法讲起 final vo...
2020-08-21
kongziming7799的博客
08-24 240
app启动流程总结 启动一个包和类就启动了一个application 1.点击桌面App图标，Launcher进程采用Binder IPC向system_server进程发起startActivity请求； 2.system_server进程接收到请求后，向zygote进程发送创建进程的请求； 3.Zygote进程fork出新的子进程，即App进程； 4.App进程，通过Binder IPC向sytem_server进程发起attachApplication请求； 5.AMS向ApplicationThre
Android13 Activity启动流程
ss520k的专栏
02-21 6039
Android 13 Activity最详启动流程
java创建activity视图_Android Activity创建到View的显示过程
weixin_42512723的博客
02-28 557
前言当我们点击桌面图标启动App，到App显示完成，这中间到底经历了什么呢？了解了这部分内容，将会对Activity、Window、View之间联系与区别加深印象，更好指导我们编写代码。通过这篇文章，你将了解到：1、Activity创建到onCreate()、onResume方法执行2、Application创建到onCreate方法执行3、Activity生命周期监听4、Window/Windo...
一张图了解Activity的创建到最终View的显示过程
weixin_42260375的博客
06-27 479
从Acitvity的onResume到View的measure、layout、draw
Android 开发使用Activity实现加载等待界面功能示例
08-19
1. 创建主界面（MainActivity） 首先，需要创建一个主界面，例如登录界面。在这个界面中，添加一个按钮，例如登录按钮。然后，编写按钮的点击事件，当用户点击按钮时，打开新的 Activity，显示加载等待界面。 2. ...
Android Studio 利用Splash制作APP启动界面的方法
08-19
Android Studio 利用Splash制作APP启动界面的方法 Android Studio 是一个功能强大且流行的集成开发环境（IDE），它提供了许多功能来帮助开发者快速地创建高质量的 Android 应用程序。在本文中，我们将介绍如何使用 ...
在priv-app中mainactivity界面增加一个文本显示框
03-18
好的，用户想在Android项目的priv-app模块中的MainActivity界面添加一个文本显示框，也就是TextView控件。首先，我需要回忆一下如何在Android应用中添加UI控件。通常，这涉及修改XML布局文件和对应的Activity代码。...
如何在app mainactivity界面加一个显示框（仅显示文字）
03-15
步骤总结：打开activity_main.xml，添加TextView元素，设置必要属性和文本内容，调整布局参数，最后在MainActivity中加载布局。同时，提醒用户如果动态修改文本，可以通过findViewById获取TextView实例并设置文本。 ...
android mvp框架创建mainactivity
最新发布
12-05
在完成一系列搭建 MVP 框架依赖模块的过程后，进入使用阶段，通常在 app 模块中进行操作，当前模块中一般只有一个 MainActivity [^1]。 ### 2. 明确 MVP 框架结构 MVP 框架通过将应用程序分为模型（Model）、视图...
Framework学习之路（一）—— UI绘制深入源码分析
blue_fen的博客
02-27 1341
UI绘制深入源码分析本篇为笔者对Android SDK 33版本的UI绘制入口进行追踪的过程，主要作笔记作用。
Android Activity的启动过程
riley_zhang的博客
10-10 493
这篇文章是记录我对于activity的启动流程的一个大致记录，不会有太详细的代码解析 Activity 其实只是一个普通的类，是因为ActivityThread会在不同的阶段回调Activity的onCreate onResume方法，从而让Activity有生命周期； apk的启动是从ActivityThread的main()方法开始的，main()建立了主线程的looper，并把对
[LMKD] [Android] 进程OomAdj调整分析：OomAdj调整次数(2)
q1210249579的博客
10-03 901
在服务启动流程中，如果发现了DeadObjectException异常，则会通过ASM去杀进程，意思是服务创建过程中，Application死亡，主进程不存在的情况——这里又在想，主进程都死亡了，还去杀进程干啥？非也非也，进程被杀了也需要进行清理动作，进程从Lru移除等动作。调整进程的oomAdj值和进程状态，这里就是AMS#updateOomAdjLocked，并开始进入OomAdjuster.java中调整进程优先级，具体怎么调整的暂不分析，后面分析，这里只分析入口在哪。
Android语言切换原理
热门推荐
Leslie_Yu的博客
11-19 1万+
Android语言切换原理前言   之前因为系统有些国家使用的字体乱码的原因，研究了下Android系统字体加载相关的知识，写了一篇Android系统字体加载流程的总结，浅析Android字体加载原理，然而系统的字体与系统当前的语言有密切的关系，因此抽空了解了下Android系统语言切换的流程，写下总结，加深印象。Android语言切换流程分析概述   有过Android开发经验的人，应该都知道An
安卓application和activity启动流程
weixin_47285644的博客
01-20 1611
安卓application启动流程 源码分析 ActivityThread初始化： public static void main(String[] args) { Trace.traceBegin(Trace.TRACE_TAG_ACTIVITY_MANAGER, "ActivityThreadMain"); // Install selective syscall interception AndroidOs.install(); /
Android四大组件系列3　Activity启动流程（下）
liuwg1226的专栏
05-03 1049
一　概述 Activity 的启动分为不同进程间和相同进程的启动。由于进程间 Activity 启动流程包括了相同进程 Activity 启动的流程。因此本文只分析不同进程间，比如点击 Launcher 桌面图标启动 Activity 的整个过程。在阅读本篇文章之前，建议同学们先了解下 AMS 相关的数据结构和管理机制，可参考 Android四大组件系列1　AMS相关数据结构。 本篇文章接上一篇文章 Android四大组件系列2　Activity启动流程（上）继续分析。上一篇文章我们分析了 startAct
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值