Android Loop机制中Looper与handler详细分析

目录
  • Looper是什么
  • 简单使用
  • 从源码了解loop原理
    • loop分析
      • myLooper()
      • next()
      • handler.dispatchMessage
    • handler分析
      • 消息入队
      • 同步屏障
  • 总结

Looper是什么

用于为线程运行消息循环的类。默认情况下,线程没有与之关联的消息循环。要创建一个,在要运行循环的线程中调用 prepare(),然后调用loop()让它处理消息,直到循环停止为止。与消息循环的大多数交互是通过 Handler类进行的。

意思大概就是让线程有处理消息的能力,并且这种能力是无限循环的,直到被停止为止。

简单使用

 public Handler handler;
 public void looperThread(){
     new Thread(new Runnable() {
         @Override
         public void run() {
             Looper.prepare();
             handler = new Handler(Looper.myLooper(),new Handler.Callback() {
                 @Override
                 public boolean handleMessage(Message msg) {
                     Log.e(TAG,"收到发送过来的消息:"+msg.obj.toString());
                     return false;
                 }
             });
             Looper.loop();
         }
     }).start();
 }
 @Override
 public void onClick(View view) {
     Message message = Message.obtain();
     message.obj = "点击事件消息时间戳:"+System.currentTimeMillis()%10000;
     handler.sendMessage(message);
 }

创建一个具有消息循环的线程,该线程中创建一个和该looper绑定的handler对象,然后点击事件中不断的去发送消息给looper循环,看下最后的效果如下:

18:17:45.459 12495-12538/com.example.myapplication E/[MainActivity]: 收到发送过来的消息:点击事件消息时间戳:5458
18:17:45.690 12495-12538/com.example.myapplication E/[MainActivity]: 收到发送过来的消息:点击事件消息时间戳:5690
18:17:45.887 12495-12538/com.example.myapplication E/[MainActivity]: 收到发送过来的消息:点击事件消息时间戳:5886
...省略
18:18:40.010 12495-12538/com.example.myapplication E/[MainActivity]: 收到发送过来的消息:点击事件消息时间戳:9
18:18:40.840 12495-12538/com.example.myapplication E/[MainActivity]: 收到发送过来的消息:点击事件消息时间戳:839
18:18:41.559 12495-12538/com.example.myapplication E/[MainActivity]: 收到发送过来的消息:点击事件消息时间戳:1558

可以看到我一直点击,一直有消息可以被处理,那么说明我创建的线程是一直运行的,并没有结束。那么looper具体是怎么实现的这样的功能的呢?

从源码了解loop原理

在分析源码之前,先看下整体的类图关系:

loop分析

我们从Looper.prepare();这句代码开始分析:

Looper.prepare();
public final class Looper {
    static final ThreadLocal<Looper> sThreadLocal = new ThreadLocal<Looper>();
    private static Looper sMainLooper;  // guarded by Looper.class
    final MessageQueue mQueue;
    final Thread mThread;
    ...省略
    public static void prepare() {
        prepare(true);
    }
  	...省略

可以看到调用了prepare()方法后,接着调用了有参函数prepare:

private static void prepare(boolean quitAllowed) {
    if (sThreadLocal.get() != null) {
        throw new RuntimeException("Only one Looper may be created per thread");
    }
    sThreadLocal.set(new Looper(quitAllowed));
}

sThreadLocal的泛型参数是Looper,那么知道Looper保存在了线程所持有的map容器中,首先就是判断sThreadLocal.get()是否为空,这个方法在上一章说过,是根据当前线程来获取的,如果这个prepare方法在ui线程中调用那么返回的就是ui线程中的Looper,如果调用的是子线程中,那么返回的就是子线程的Looper了,如果不为空,抛出异常,意思就是一个线程只能持有一个Looper对象;如果为空的话,那么调用sThreadLocal的set方法将创建的Looper对象存放到对应线程的map容器中。

接着调用了loop函数:

Looper.loop();
    public static void loop() {
        final Looper me = myLooper();
        ...省略
        final MessageQueue queue = me.mQueue;
        for (;;) {
            Message msg = queue.next(); // might block
            if (msg == null) {
                return;
            }
      		...省略
            try {
                msg.target.dispatchMessage(msg);
            } finally {
         	   ...省略
            }
 			...省略
            msg.recycleUnchecked();
        }
    }

大概是这样的,其中去掉了一些和业务无关的代码。

myLooper()

第一步调用myLooper()方法:

final Looper me = myLooper();
final MessageQueue queue = me.mQueue;
public static @Nullable Looper myLooper() {
    return sThreadLocal.get();
}

获取当前线程的sThreadLocal中的Looper对象。从Looper对象获取队列。

第二步开始for循环,Message msg = queue.next(); // might block 在循环中不断的从queue中取Message消息,

获取msg判断是否为空,空的话直接返回,不为空的话,调用msg的Target的dispatchMessage方法。最后msg使用完毕之后就回收msg对象。

首先来看下

Message msg = queue.next(); // might block

next()

调用的是MessageQueue的next方法,代码如下:

 Message next() {
   		 ...省略
        int pendingIdleHandlerCount = -1; // -1 only during first iteration
        int nextPollTimeoutMillis = 0;
        for (;;) {
            if (nextPollTimeoutMillis != 0) {
                Binder.flushPendingCommands();
            }
            nativePollOnce(ptr, nextPollTimeoutMillis);
        	 ...省略
            synchronized (this) {
                // Try to retrieve the next message.  Return if found.
                final long now = SystemClock.uptimeMillis();
                Message prevMsg = null;
                Message msg = mMessages;
                if (msg != null && msg.target == null) {
                    // Stalled by a barrier.  Find the next asynchronous message in the queue.
                    do {
                        prevMsg = msg;
                        msg = msg.next;
                    } while (msg != null && !msg.isAsynchronous());
                }
                if (msg != null) {
                    if (now < msg.when) {
                        // Next message is not ready.  Set a timeout to wake up when it is ready.
                        nextPollTimeoutMillis = (int) Math.min(msg.when - now, Integer.MAX_VALUE);
                    } else {
                        // Got a message.
                        mBlocked = false;
                        if (prevMsg != null) {
                            prevMsg.next = msg.next;
                        } else {
                            mMessages = msg.next;
                        }
                        msg.next = null;
                        if (DEBUG) Log.v(TAG, "Returning message: " + msg);
                        msg.markInUse();
                        return msg;
                    }
                } else {
                    // No more messages.
                    nextPollTimeoutMillis = -1;
                }
 				...省略
            }
            ...省略
        }
    }

首先调用nativePollOnce(ptr, nextPollTimeoutMillis); 这个方法是调用的native方法,意思就是阻塞当前线程,在延迟nextPollTimeoutMillis时长后唤醒当前线程。

接着调用:

final long now = SystemClock.uptimeMillis();
Message prevMsg = null;
Message msg = mMessages;
if (msg != null && msg.target == null) {
    // Stalled by a barrier.  Find the next asynchronous message in the queue.
    do {
        prevMsg = msg;
        msg = msg.next;
    } while (msg != null && !msg.isAsynchronous());
}

其中的判断是msg.target == null这个条件,这个条件说明当前的msg是没有设置Target的,msg的Target一般是handler,如果这里是空的话,那么这个msg就是同步屏障消息,用于拦截同步消息的,让异步消息有优先处理权。如果当前是同步屏障的话,那么while循环,一直向后遍历msg节点,条件是这个msg非空和非异步消息,所以这里能够跳出循环的情况就是msg到了尾部为空了,要么就是向后遍历发现了异步消息。接着往下看:

if (msg != null) {
    if (now < msg.when) {
        // Next message is not ready.  Set a timeout to wake up when it is ready.
        nextPollTimeoutMillis = (int) Math.min(msg.when - now, Integer.MAX_VALUE);
    } else {
        // Got a message.
        mBlocked = false;
        if (prevMsg != null) {
            prevMsg.next = msg.next;
        } else {
            mMessages = msg.next;
        }
        msg.next = null;
        if (DEBUG) Log.v(TAG, "Returning message: " + msg);
        msg.markInUse();
        return msg;
    }
} else {
    // No more messages.
    nextPollTimeoutMillis = -1;
}

分为两种情况:

(1)如果msg为空的话,先设置延迟时长nextPollTimeoutMillis = -1;接着这趟for循环结束,回到起点的位置,又开始执行nativePollOnce(ptr, nextPollTimeoutMillis);延迟时间是-1那么线程就会阻塞下去,直到被唤醒,不会执行for循环了(msg在进入队列的时候会去唤醒线程的,所以这里不会一直阻塞的)。

(2)如果msg不为空的话,假设消息设置的时间点大于现在的时间点,那么设置nextPollTimeoutMillis 为时间差和整数最大值中的最小值。这样的话,线程在下次循环中的开头就会阻塞到可以执行该消息的when时间节点再次运行(线程在阻塞的时候不会去轮转cpu时间片所以可以节约cpu资源,同样的,如果阻塞期间有消息进来可以马上运行,那么还是会被唤醒的);假设消息设置的时间点小于现在的时间点,那么从msg消息链中把该消息摘取出来,msg标记为使用中,将msg返回。

思考:队列中头部msg是同步屏障的话,那么优先从前往后去查找异步消息进行处理,所以在同步屏障消息之后的同步消息不会被执行,直到被移除为止。队列头部是普通的消息的时候,是根据when时间节点来判断,是直接返回msg,还是等待when-now时间差在去循环一遍查找头结点msg。

handler.dispatchMessage

handler = new Handler(Looper.myLooper(),new Handler.Callback() {
	           @Override
	           public boolean handleMessage(Message msg) {
	               Log.e(TAG,"收到发送过来的消息:"+msg.obj.toString());
	               return false;
	           }
	       });

handler在创建的参数是Looper和Callback,接着再来看下dispatchMessage是如何实现的:

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

如果msg存在callback的话,直接调用callbakc的run方法,这里不存在我们传递msg没有设置callback,那么走下面的那个逻辑,我们给handler设置了mCallback,那么就直接回调handler的mCallback.handleMessage的方法:

    @Override
    public boolean handleMessage(Message msg) {
        Log.e(TAG,"收到发送过来的消息:"+msg.obj.toString());
        return false;
    }

这样也就出现了我们开头demo中的打印消息了。

handler分析

我们通过上面的next方法分析了如何从队列中获取消息,那么我们还没有分析消息是如何入队的,接下来我们来分析下handler的几个关键的问题,(1)handler的消息一个分为几种;(2)handler发送消息到哪去了。

我们从handler的构造函数入手:

handler = new Handler(Looper.myLooper(),new Handler.Callback() {
               @Override
               public boolean handleMessage(Message msg) {
                   Log.e(TAG,"收到发送过来的消息:"+msg.obj.toString());
                   return false;
               }
           });
public Handler(Looper looper, Callback callback) {
    this(looper, callback, false);
}
public Handler(Looper looper, Callback callback, boolean async) {
    mLooper = looper;
    mQueue = looper.mQueue;
    mCallback = callback;
    mAsynchronous = async;
}

我们可以看到,handler一共持有四个关键变量,Looper循环(和looper关联,handler发送的消息只会发到这个队列中),mQueue 持有Looper的队列,mCallback 用于处理消息的回调函数,mAsynchronous 标志这个handler发送的消息是同步的还是异步的。

我们再来看一下消息是怎么发送的:

Message message = Message.obtain();
message.obj = "点击事件消息时间戳:"+System.currentTimeMillis()%10000;
handler.sendMessage(message);

首先从Message中获取一个message,这个Message其实里面保存着msg的链表,遍历链表,返回的是回收的msg,其中flags整数变量标志着msg是否正在使用中,是否是异步消息等等状态。

handler.sendMessage(message);

然后使用handler去发送一个msg对象、接着进去看下:

public final boolean sendMessage(Message msg) {
    return sendMessageDelayed(msg, 0);
}
public final boolean sendMessageDelayed(Message msg, long delayMillis){
	if (delayMillis < 0) {
	    delayMillis = 0;
	}
	return sendMessageAtTime(msg, SystemClock.uptimeMillis() + delayMillis);
}
public boolean sendMessageAtTime(Message msg, long uptimeMillis) {
    MessageQueue queue = mQueue;
    if (queue == null) {
        RuntimeException e = new RuntimeException(
                this + " sendMessageAtTime() called with no mQueue");
        Log.w("Looper", e.getMessage(), e);
        return false;
    }
    return enqueueMessage(queue, msg, uptimeMillis);
}

msg初始状态下是同步消息,sendMessage方法发送出去的消息delayMillis 延迟时间是0;

 private boolean enqueueMessage(MessageQueue queue, Message msg, long uptimeMillis) {
     msg.target = this;
     if (mAsynchronous) {
         msg.setAsynchronous(true);
     }
     return queue.enqueueMessage(msg, uptimeMillis);
 }

在入队列之前,将msg的Target设置为当前handler,然后根据handler是否是异步的,设置msg是否是异步的,然后调用队列的入队函数,将消息入队。

这里先回答第二个问题,如何入队的:

消息入队

  boolean enqueueMessage(Message msg, long when) {
        synchronized (this) {
            msg.markInUse();
            msg.when = when;
            Message p = mMessages;
            boolean needWake;
            if (p == null || when == 0 || when < p.when) {
                msg.next = p;
                mMessages = msg;
                needWake = mBlocked;
            } else {
                needWake = mBlocked && p.target == null && msg.isAsynchronous();
                Message prev;
                for (;;) {
                    prev = p;
                    p = p.next;
                    if (p == null || when < p.when) {
                        break;
                    }
                    if (needWake && p.isAsynchronous()) {
                        needWake = false;
                    }
                }
                msg.next = p; // invariant: p == prev.next
                prev.next = msg;
            }
            if (needWake) {
                nativeWake(mPtr);
            }
        }
        return true;
    }

首先判断当前入队msg的when时间是否比队列中的头结点的when时间节点靠前,靠前的话,就将入队的msg加入到队列的头部,并且调用nativeWake(mPtr);方法唤醒looper所在的线程,那么next()开始执行了,可以马上遍历队列,消耗msg消息。如果当前消息msg的时间节点when大于头部节点,首先设置needWake标志, 是否需要唤醒分为:如果队列头部是同步屏障,并且入队消息msg是异步消息,那么就需要唤醒线程,其他情况不需要唤醒;接着执行for循环,循环里面寻找队列中第一个节点时间是大于msg消息的时间节点的(这意味着队列中消息是按照时间节点排序的),循环结束后,将入队的msg插入到队列中,最后根据需要是否唤醒线程。

同步屏障

同步屏障功能是让队列中的同步消息暂时不执行,直到同步屏障被移除,异步消息可以不受影响的被执行,相当于排队买票的队列中头部有个人一直卡着不走,只有vip的人才能正常在窗口中买票,其他普通人买不了票,如果那个头部卡着的那个人不走的话。这个同步屏障非常有用,用于优先执行某些任务。

同步屏障我们使用的比较少,但是安卓frame层代码有使用这个同步屏障的功能,例如ViewRootImp中:

ViewRootImp中:
    void scheduleTraversals() {
   			...省略
            mTraversalBarrier = mHandler.getLooper().getQueue().postSyncBarrier();
            mChoreographer.postCallback(
                    Choreographer.CALLBACK_TRAVERSAL, mTraversalRunnable, null);
            ...省略
    }
Choreographer中:
   	private void postCallbackDelayedInternal(int callbackType, Object action, Object token, long delayMillis) {
        	...省略
            mCallbackQueues[callbackType].addCallbackLocked(dueTime, action, token);
            if (dueTime <= now) {
                scheduleFrameLocked(now);
            } else {
                Message msg = mHandler.obtainMessage(MSG_DO_SCHEDULE_CALLBACK, action);
                msg.arg1 = callbackType;
                msg.setAsynchronous(true);
                mHandler.sendMessageAtTime(msg, dueTime);
            }
        }
    }         

向队列中发送一个同步屏障getQueue().postSyncBarrier();看下源码如何实现的:

   public int postSyncBarrier() {
        return postSyncBarrier(SystemClock.uptimeMillis());
    }
    private int postSyncBarrier(long when) {
        // Enqueue a new sync barrier token.
        // We don't need to wake the queue because the purpose of a barrier is to stall it.
        synchronized (this) {
            final Message msg = Message.obtain();
            msg.markInUse();
            msg.when = when;
            msg.arg1 = token;
            Message prev = null;
            Message p = mMessages;
            if (when != 0) {
                while (p != null && p.when <= when) {
                    prev = p;
                    p = p.next;
                }
            }
            if (prev != null) { // invariant: p == prev.next
                msg.next = p;
                prev.next = msg;
            } else {
                msg.next = p;
                mMessages = msg;
            }
            return token;
        }
    }

同步屏障的时间节点是当前时间,还可以知道同步屏障消息的Target是空的,成员变量arg1保存的是同步屏障的自增值。接下来就是找到队列中第一个时间节点比自己大的节点位置,然后插入到队列中,所以屏障也是按照时间来排列的,没有特殊待遇。

接着使用handler向Looper中发送了一个异步消息:

   Message msg = mHandler.obtainMessage(MSG_DO_SCHEDULE_CALLBACK, action);
   msg.arg1 = callbackType;
   msg.setAsynchronous(true);
   mHandler.sendMessageAtTime(msg, dueTime);

可以看到异步消息需要设置msg.setAsynchronous(true);

执行ui的任务使用异步消息去执行,为啥要用异步,因为在5.0以上的安卓系统中已经开始使用了垂直同步技术了,所以重绘页面的操作需要按照屏幕刷新率来执行,假如一个16ms里面有多次重绘请求,最终也只会抛弃掉,只保留一个重绘消息,所以,为了保证重绘操作能够在收到同步信号的时间节点马上执行,必须使用同步屏障,这样前面排队的同步消息暂时不执行,优先执行我们的重绘界面的异步消息,这样可以保证我们的界面尽量能够及时刷新,避免丢帧。、

再来看下handler.post()方法:

    public final boolean post(Runnable r){
       return  sendMessageDelayed(getPostMessage(r), 0);
    }
    private static Message getPostMessage(Runnable r) {
        Message m = Message.obtain();
        m.callback = r;
        return m;
    }

可以看到,其实也是封装了一个msg对象,将callback传递给它,我们在dispatchMessge函数中也知道,如果msg如果有自己的callback 就会调用这个回调处理消息,不会使用handler自己的callback 来处理消息。

总结

根据以上所说的关系,画一张图:

结论:

handler的消息分为:同步消息,异步消息,屏障消息。

handler的消息发送:消息都发送到了和它绑定的Looper的队列中去了。

那么queue一对一looper,looper一对多handler,looper对象保存在所在线程的ThreadLocal中。

到此这篇关于Android Loop机制中Looper与handler详细分析的文章就介绍到这了,更多相关Android Looper与handler内容请搜索我们以前的文章或继续浏览下面的相关文章希望大家以后多多支持我们!

时间: 2022-11-13

Android消息处理机制Looper和Handler详解

Message:消息,其中包含了消息ID,消息处理对象以及处理的数据等,由MessageQueue统一列队,终由Handler处理. Handler:处理者,负责Message的发送及处理.使用Handler时,需要实现handleMessage(Message msg)方法来对特定的Message进行处理,例如更新UI等. MessageQueue:消息队列,用来存放Handler发送过来的消息,并按照FIFO规则执行.当然,存放Message并非实际意义的保存,而是将Message以链表的方

Android Handle原理(Looper,Handler和Message三者关系案例详解

介绍 前面的内容对Handler做了介绍,也讲解了如何使用handler,但是我们并不知道他的实现原理.本文从源码的角度来分析如何实现的. 首先我们得知道Handler,Looper,Message Queue三者之间的关系 - Handler封装了消息的发送,也负责接收消.内部会跟Looper关联. - Looper 消息封装的载,内部包含了MessageQueue,负责从MessageQueue取出消息,然后交给Handler处理 - MessageQueue 就是一个消息队列,负责存储消息

详解Android Handler机制和Looper Handler Message关系

概述 我们就从以下六个问题来探讨Handler 机制和Looper.Handler.Message之前的关系? 1.一个线程有几个Handler? 2.一个线程有几个Looper?如何保证? 3.Handler内存泄漏原因?为什么其他的内部类没有说过这个问题? 4.为何主线程可以new Handler?如果在想要在子线程中new Handler 要做些什么准备? 5.子线程中维护的Looper,消息队列无消息的时候的处理方案是什么?有什么用? 6.Looper死循环为什么不会导致应用卡死? 一.

深入Android Handler,MessageQueue与Looper关系

关联篇:HandlerThread 使用及其源码完全解析 关联篇:Handler内存泄漏详解及其解决方案 一说到Android的消息机制,自然就会联想到Handler,我们知道Handler是Android消息机制的上层接口,因此我们在开发过程中也只需要和Handler交互即可,很多人认为Handler的作用就是更新UI,这也确实没错,但除了更新UI,Handler其实还有很多其他用途,比如我们需要在子线程进行耗时的I/O操作,可能是读取某些文件或者去访问网络等,当耗时操作完成后我们可能需要在U

android的消息处理机制(图文+源码分析)—Looper/Handler/Message

这篇文章写的非常好,深入浅出,关键还是一位大三学生自己剖析的心得.这是我喜欢此文的原因.下面请看正文: 作为一个大三的预备程序员,我学习android的一大乐趣是可以通过源码学习google大牛们的设计思想.android源码中包含了大量的设 计模式,除此以外,android sdk还精心为我们设计了各种helper类,对于和我一样渴望水平得到进阶的人来说,都太值得一读了.这不,前几天为了了解android的消息处理机 制,我看了Looper,Handler,Message这几个类的源码,结果又

android异步消息机制 从源码层面解析(2)

AsyncTask 什么是AsyncTask AsyncTask是一个轻量级的异步任务类,它可以在线程池中执行后台任务,然后把执行的进度和结果传递给主线程并在主线程中更新UI. AsyncTask这个类的声明如下 public abstract class AsyncTask<Params, Progress, Result> 它提供了Params, Progress和 Result三个泛型参数,在下面会仔细分析这三个泛型参数的具体含义. AsyncTask提供了四个核心方法 onPreExe

Android AsyncTask源码分析

Android中只能在主线程中进行UI操作,如果是其它子线程,需要借助异步消息处理机制Handler.除此之外,还有个非常方便的AsyncTask类,这个类内部封装了Handler和线程池.本文先简要介绍AsyncTask的用法,然后分析具体实现. 基本用法 AsyncTask是一个抽象类,我们需要创建子类去继承它,并且重写一些方法.AsyncTask接受三个泛型参数: Params: 指定传给任务执行时的参数的类型 Progress: 指定后台任务执行时将任务进度返回给UI线程的参数类型 Re

Android实例HandlerThread源码分析

HandlerThread 简介: 我们知道Thread线程是一次性消费品,当Thread线程执行完一个耗时的任务之后,线程就会被自动销毁了.如果此时我又有一 个耗时任务需要执行,我们不得不重新创建线程去执行该耗时任务.然而,这样就存在一个性能问题:多次创建和销毁线程是很耗 系统资源的.为了解这种问题,我们可以自己构建一个循环线程Looper Thread,当有耗时任务投放到该循环线程中时,线程执行耗 时任务,执行完之后循环线程处于等待状态,直到下一个新的耗时任务被投放进来.这样一来就避免了多次

简略分析Android的Retrofit应用开发框架源码

面对一个项目,对于Android应用开发框架的选择,我想过三种方案: 1.使用Loader + HttpClient + GreenDao + Gson + Fragment,优点是可定制性强,由于使用Google家自己的Loader和LoaderManager,代码健壮性强. 缺点是整套代码学习成本较高,使用过程中样板代码较多,(比如每一个Request都需要产生一个新类) 2.Volley,作为Google在IO大会上得瑟过的一个网络库,其实不算什么新东西(2013 IO发布),使用较为简单

由浅入深讲解Javascript继承机制与simple-inheritance源码分析

老生常谈的问题,大部分人也不一定可以系统的理解.Javascript语言对继承实现的并不好,需要工程师自己去实现一套完整的继承机制.下面我们由浅入深的系统掌握使用javascript继承的技巧. 1. 直接使用原型链 这是最简粗暴的一种方式,基本没法用于具体的项目中.一个简单的demo如下: function SuperType(){ this.property = true; } SuperType.prototype.getSuperValue = function(){ return th

Android透明化和沉浸式状态栏实践及源码分析

本文所提到的透明状态栏其实指的是将顶部的导航栏延伸到状态栏,使之浑然一体(Google官方建议状态栏颜色比导航栏的颜色略深一点),并不代表一定不设置背景色,比如导航栏是白色,则可设置状态栏为白色,视情况而定. 相比于iOS系统,Android系统对于状态栏的设置就显得稍微复杂了一点.Android系统提供了API 19以上对状态栏的设置接口,而直到API 23以上才提供对于icon颜色的设置,还有就是各家厂商(如魅族,小米等)对于状态栏的有自己的定制,对于需要使用浅色背景状态栏的应用,没处理好的

Android getJSONObject与optJSONObject的区别结合源码分析

Android getJSONObject与optJSONObject的区别结合源码分析 json解析常见问题: getJSONObject与optJSONObject的区别,下面结合源码和案例来分析当我们使用这两周方法来解析数据时,哪种比较好. 源码分析: //使用getJSONObject时,如果返回的对象不是JSONObject,抛出JSONException异常 /** * Returns the value mapped by {@code name} if it exists and

浅谈Android的Lifecycle源码分析

1. 简介 很早就听说了Google的Lifecycle组件,因为项目没有使用过,所以并没有过多的接触.不过最近看到了一篇文章,其中的一条评论提到了LiveData.恰巧这两天工作内容不多,所以赶紧研究一波! 不过在看LiveData之前,我觉得还是先看下Lifecycle吧(Lifecycle更像是LiveData的基础). 2. Lifecycle的简单介绍 Lifecycle的介绍,我们还是拿Google的官方文档作为参考吧. Lifecycle主要解决的是业务和Activity/Frag

Android开发Retrofit源码分析

目录 项目结构 retrofit 使用 Retrofit #create ServiceMethod #parseAnnotations HttpServiceMethod#parseAnnotations 第二种 非Kotlin协程情况 DefaultCallAdapterFactory#get 第一种 Kotlin协程情况 总结 项目结构 把源码 clone 下来 , 可以看到 retrofit 整体结构如下 图 http包目录下就是一些http协议常用接口 , 比如 请求方法 url ,