Handler运行机制源码分析

最新推荐文章于 2021-12-20 19:41:12 发布
最新推荐文章于 2021-12-20 19:41:12 发布
阅读量815 收藏
点赞数
分类专栏： Android源码解读 文章标签： 源码 Hanlder
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Dnnis/article/details/53781608
版权
本文深入探讨了Android Handler的运行机制，从主线程的ActivityThread到Looper和MessageQueue的交互，揭示了Handler如何在主线程中处理消息。通过源码分析，解释了Looper.loop()的死循环以及Message的处理流程，同时讨论了自定义Handler和非主线程Message的处理方式，总结了关键知识点和工作原理。
摘要由CSDN通过智能技术生成

Handler运行机制源码分析

问题提出

  • Handler和Android程序运行关系
  • Handler如何Android消息队列
  • Hanlder存在的意义

核心内容

  • 作为Android开发人员都知道，Android App是单进程运行的，而在这个进程里面有一个主线程，这个主线程在代码中称作：android.app.ActivityThread,该类负责管理和执行主线程里面的四大组件相关联的操作。主线程里面的main函数就是整个app的启动入口。我们来瞄一眼代码：

  • public static void main(String[] args) {
Trace.traceBegin(Trace.TRACE_TAG_ACTIVITY_MANAGER, "ActivityThreadMain");
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());

AndroidKeyStoreProvider.install();

// Make sure TrustedCertificateStore looks in the right place for CA certificates
final File configDir = Environment.getUserConfigDirectory(UserHandle.myUserId());
TrustedCertificateStore.setDefaultUserDirectory(configDir);

Process.setArgV0("<pre-initialized>");

Looper.prepareMainLooper();

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

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

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

// End of event ActivityThreadMain.
Trace.traceEnd(Trace.TRACE_TAG_ACTIVITY_MANAGER);
Looper.loop();

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

  • 上面的主要代码是从Looper.prepareMainLooper()；开始的，在这之前的代码大部分都是app的初始化和配置工作。关于prepareMainLooper()具体工作带回描述，先捋顺流程提问题然后在逐个解决，在Looper初始化完成之后，初始化了当前的主线程（主要工作：进行主线程操作，比如平时的UI设置），然后初始化了主线程的Handler,虽然是通过thread.getHandler()调用的，但是他们之间是如何进行通信的呢？thread.getHandler()是继承了Hanlder,用过自定义Handler都明白它里面的handleMessage主要用来处理Message,那在这里它处理的是app主线程的的消息（Message），但是有Message就应该有消息队列呀，但是在上面的代码中我们貌似没有发现MessageQueue的影子，所以我就在深入的进入到具体方法中查看代码，在Looper.loop()找到了答案。看一下源码：

  /**
 * Run the message queue in this thread. Be sure to call
 * {@link #quit()} to end the loop.
 */
public static void loop() {
    final Looper me = myLooper();
    if (me == null) {
        throw new RuntimeException("No Looper; Looper.prepare() wasn't called on this thread.");
    }
    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);

        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.recycleUnchecked();
    }
}
  • 看注释你也明白了，Looper.loop()返回了一个消息队列，并且要求在你想终止消息队列的时候调用quit()；why?为什么要终止loop()呢，再看一眼loop(),发现了一个死循环for(,,){};在这个死循环里面不断的循环从队列中获取Message然后进行dispathMessage(msg),因为Looper具有池的特性所以她还回收了废弃的Message以便再次使用：msg.recycleUnchecked();我们可能会有疑问那这个死循环在mes==null会return呀，那这样岂不是主线程的main()就执行完了,应用岂不是要退出了么，嘿嘿，答案就在 msg.target.dispatchMessage(msg);msg.target主线程的Hanlder的handleMessage()都会转发一下msg.obj哦，瞄一眼MainThreadHandler的代码：
 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");
                final 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&1) != 0, msg.arg2,
                        (msg.arg1&2) != 0);
                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&1) != 0, msg.arg2,
                        (msg.arg1&1) != 0);
                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 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((ActivityConfigChangeData)msg.obj);
                Trace.traceEnd(Trace.TRACE_TAG_ACTIVITY_MANAGER);
                break;
            case PROFILER_CONTROL:
                handleProfilerControl(msg.arg1 != 0, (ProfilerInfo)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_ASSIST_CONTEXT_EXTRAS:
                handleRequestAssistContextExtras((RequestAssistContextExtras)msg.obj);
                break;
            case TRANSLUCENT_CONVERSION_COMPLETE:
                handleTranslucentConversionComplete((IBinder)msg.obj, msg.arg1 == 1);
                break;
            case INSTALL_PROVIDER:
                handleInstallProvider((ProviderInfo) msg.obj);
                break;
            case ON_NEW_ACTIVITY_OPTIONS:
                Pair<IBinder, ActivityOptions> pair = (Pair<IBinder, ActivityOptions>) msg.obj;
                onNewActivityOptions(pair.first, pair.second);
                break;
            case CANCEL_VISIBLE_BEHIND:
                handleCancelVisibleBehind((IBinder) msg.obj);
                break;
            case BACKGROUND_VISIBLE_BEHIND_CHANGED:
                handleOnBackgroundVisibleBehindChanged((IBinder) msg.obj, msg.arg1 > 0);
                break;
            case ENTER_ANIMATION_COMPLETE:
                handleEnterAnimationComplete((IBinder) msg.obj);
                break;
        }
        if (DEBUG_MESSAGES) Slog.v(TAG, "<<< done: " + codeToString(msg.what));
    }
 *****注意在 case EXIT_APPLICATION:
                if (mInitialApplication != null) {
                    mInitialApplication.onTerminate();
                }
                Looper.myLooper().quit();
                break;的时候调用了Looper.myLooper().quit()方法哦这才是整个应用结束了，消息队列回收了。
  • 到这里我们通过主线程的理顺了Hanlder、Message、Looper基本流程：Looper不断从MessageQueue取Message，交给Hanlder去处理Message,处理完成转发Message,然后Looper回收使用完的Message，等待复用。但是还有两个问题需要交代一下：1：自定义Handler Message的处理， 2：非主线程的Message处理
    • 自定义Handler Message:他的Message也会被融到MessageQueue队列中，只不过他的处理是通过我们自定义的Hanlder进行处理的，并不是上面的主线程，这也就是为什么需要我们自己在自定义Hanlder中重写handlerMessage()处理msg逻辑。
    • 非主线程的Message如何处理，他持有自己的Looper不断的发送Message,最终会将Message发送到MessageQueue中，结合自定义Hanlder处理逻辑。官方提供的套路（擦~源码一时半会找不到了，我自己来一个大体结构吧）：
 new Runable()
 {
 run()
 ｛
 Looper.prepare();
 Message message = new Message();
 message.obj = "子线程的消息";
 mHandlerTest1.sendMessage(message);
 Looper.loop();
 ｝
}

总结：

  • 为详细解释的相关知识点ThreadLoacl\Message.obtain()\Looper.perpareMainLooper();
  • 无论主线程子线程都将消息发送到MessageQueue中，每个线程要通过各自持有的Looper调用prepareXXX()方法与MessageQueue建立联系，MessageQueue将Message发送到当前线程持有Hanlder去处理，一般Handler都位于主线程中。

DennisJu
关注
专栏目录
Handler消息机制：面试初级，Android工作经验6年
09-03 229
handleReceiver((ReceiverData)msg.obj); Trace.traceEnd(Trace.TRACE_TAG_ACTIVITY_MANAGER); break; case CREATE_SERVICE: Trace.traceBegin(Trace.TRACE_TAG_ACTIVITY_MANAGER, ("serviceCreate: " + String.val...
android.os.RemoteException：
liangDawn的专栏
06-12 5913
线上bugly收到一个奇怪的crash，而且量还不少，并且没有具体的业务层面的堆栈信息，只能生撸系统源码定位问题了。先贴一下错误日志： 一、分析排查： 1、调用了ActivityThread的handleRequestAssistContextExtras方法(主进程)源码： https://cs.android.com/android/platform/superproject/+/master:frameworks/base/core/java/android/app/ActivityThread
从源码深入理解Context以及相关创建过程
qinggancha的博客
03-02 849
Context关联类 文章较长，分析了Application、Activity、Service各自Context启动过程，耐心看完，会让你思路更清晰 Context意为上下文，是一个应用程序环境信息的入口 使用场景： 使用Context调用方法，比如启动Activity、访问资源、调用系统组件服务等等 调用方法时传入Context，比如弹出Toast、创建Dialog等 Activity...
SharedPreference中apply方法导致的ANR问题
Kslient的博客
12-20 172
crash 堆栈信息如下。从 crash 收集平台上来看，有几个类似的堆栈信息。唯一的区别就是 ActivityThread 的入口方法。除了 ActivityThread 的 handleSleeping 方法之外，还有 handleServiceArgs、handleStopService、handleStopActivity。 ActivityThread 的这几个方法是 Activity 或 Service 的生命周期变化的时候调用的。从堆栈信息来看，组件生命周期变化，导致调用 QueueWork
activitythread.java,RuntimeException：ActivityThread.handleSleeping
weixin_33172728的博客
03-12 247
三星Galaxy S8(Android 8.0)发生此次崩溃：java.lang.RuntimeException：在android.app.ActivityThread.handleSleeping(ActivityThread.java:4403)android.app.ActivityThread.-wrap23(未知来源)android.app.ActivityThread $ H.han...
Android Handler消息派发机制源码分析
01-20
在Android系统中，Handler是一...总的来说，Android Handler的消息派发机制是一个高效且灵活的系统，它使得开发者可以编写出响应性良好、运行流畅的Android应用。理解并熟练运用这一机制对于Android开发来说至关重要。
Android 性能优化（二）Handler运行机制原理，源码分析
csdn_aiyang的博客
03-12 1775
所以，我们需要，能在子线程中做完耗时操作，然后去到主线程更新UI的办法。是 Handler 机制提供的一种，可以在 Looper 事件循环的过程中，当消息队列为空或延迟消息还未执行的时候，执行任务的一种机制。Message内部构建一个链表维护被回收的Message对象，当调用obtain方法时会优先从池中获取，如果池中没有则创建新的Message对象，同时在使用完毕之后，进入池中以便于复用。如果没有消息就一直阻塞。在Looper.loop()方法，使用完毕时候调用了Message的recycle()方法。
android handler 机制 源码
10-17
源码分析： Handler的`sendMessage(Message msg)`方法最终会调用`enqueueMessage(Looper looper, Message msg, long when)`，将消息插入到Looper的消息队列中。而Looper的`loop()`方法则不断地从消息队列中取出...
android的消息处理机制(图文+源码分析)—Looper/Handler/Message
09-05
Android的消息处理机制是Android系统中实现异步通信和线程间通信的核心组件，主要包括三个关键类：Looper、Handler和Message。本文将深入探讨这三个类以及它们如何协同工作来处理应用程序中的消息。 首先，我们来看...
Activity的生命周期理解笔记
u013405006的专栏
06-30 1606
Activity的生命周期理解笔记
插件占坑，四大组件动态注册前奏（一） 系统Activity的启动流程
欢迎关注公众号：【码农突围】，公号后台回复9999，可以获取一份500页的LeetCode刷题笔记。
08-12 4082
转载请注明出处：http://blog.csdn.net/hejjunlin/article/details/52190050前言：为什么要了解系统Activity，Service,,BroadCastReceiver,ContentProvider的启动流程，这是一个对于即将理解插件中的四大组件动态注册，占坑的前提，如果不了解的话，那么很难了解插件hook哪此东西，又是如何骗过AMS来启动Acti
解决如何监听Activity切换
从0到1，突破自己
08-29 1万+
本篇博文在我之前的博文中已经提到了，但是监听Activity切换又可以作为一个单独的内容来叙述，因此这里又单独拿了出来进行赘述。     Activity的切换无非有两种，第一种：启动或者创建一个新的Activity；第二种：唤醒后台运行的Activity。因此如果我们能够成功监听到启动或者创建一个Activity，或者唤醒Activity我们就基本完成了Activity的切换的监听。
分析广播 的 registerReceiver、sendBroadcast、 onReceive 系统到底做了什么?
Android 开发架构
09-11 580
介绍 BroadcastReceiver 是 Android 的四大组件之一，它作用于应用内、进程间重要的一种通信方式，能够将某个消息通过广播的形式传递给订阅的广播接收器中，下面我们就来分析一下 广播注册到接收到消息 Android 源码到底做了些什么？ 源码解析 registerReceiver 时序图 代码讲解 我们跟着上面时序图来讲解代码 先在 MainActivity registerR...
Android4.4 Framework分析——startService的创建过程
东哥日记
11-08 2436
本文主要是简要分析一下startservice的启动源码，给出了service的大概启动过程。
hook ActivityThread的H实现
u012739527的博客
12-21 259
image.png 理论知识 image.png 这次主要是hook住上图中的H类。 H的代码在源码中实现： class H extends Handler { public static final int BIND_APPLICATION = 110; public static final int EXIT_APPLICATI...
Android onSaveInstanceState调用时机
Sander Lee
04-23 3017
onSaveInstanceState介绍 首先看一下onSaveInstanceState 官方API介绍（需要翻墙）。 Called to retrieve per-instance state from an activity before being killed so that the state can be restored in onCreate(Bundle) or onRes...
其实和app无关的anr问题分析
firedancer0089的专栏
08-25 5197
每个Android程序员都会遇到anr问题，anr问题的根源是代码处理中超时，例如超时广播处理超时10s之类的。处理的方法百度google可以见到千篇一律的主线程不要做耗时操作，这个是没错，不过依据我个人这几年的经验来看，大部分app遇到的anr问题和app自生是没有任何关系的。看一份日志： 08-19 12:14:57.269475 1111 1130 E ANRManager: ANR
Caused by: java.lang.SecurityException
热门推荐
lei7143的专栏
12-29 1万+
01-02 03:56:52.751  6767  7344 E SurfaceFlinger: Permission Denial: can't access SurfaceFlinger pid=30533, uid=1000 01-02 03:56:52.753 30533 30533 D AndroidRuntime: Shutting down VM 01-02 03:5
Android广播机制实现源码浅析（三）
hehui1860的专栏
06-14 1997
在上篇的分析广播收发流程的最后，我们留下了两个问题，一个是静态广播以及有序广播的处理过程，还有一个就是提过的广播超时机制。 本篇将针对这两个问题进行详细的叙述。
深入解析Android Handler消息派发机制
"Android Handler消息派发机制源码分析" 在Android系统中，Handler是一个关键的组件，用于在主线程中处理来自其他线程的消息。它提供了异步消息处理的能力，让我们能够更新UI或者执行特定的任务。本文将深入解析...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值