欢迎您访问程序员文章站本站旨在为大家提供分享程序员计算机编程知识!
您现在的位置是: 首页  >  移动技术

Android更新UI的四种方法详解

程序员文章站 2024-03-31 18:23:28
前言 相信每位android开发者们都知道更新ui只能在主线程中进行,若是在子线程执行任务后需要更新ui,则需要借助handler跳转到主线程中。以下介绍几种操作ui的方...

前言

相信每位android开发者们都知道更新ui只能在主线程中进行,若是在子线程执行任务后需要更新ui,则需要借助handler跳转到主线程中。以下介绍几种操作ui的方法。

一、使用handler的handlemessage()

handler的构造

public handler() {
this(null, false);
}

public handler(callback callback, boolean async) {
 if (find_potential_leaks) { 
   final class<? extends handler> klass= getclass(); 
   if ((klass.isanonymousclass() ||klass.ismemberclass() || klass.islocalclass()) && 
       (klass.getmodifiers() &modifier.static) == 0) { 
     log.w(tag, "the followinghandler class should be static or leaks might occur: " + 
       klass.getcanonicalname()); 
   } 
 } 
 mlooper = looper.mylooper(); 
 if (mlooper == null) { 
   throw new runtimeexception( 
     "can't create handler insidethread that has not called looper.prepare()"); 
 } 
 mqueue = mlooper.mqueue; 
 mcallback = null; 
}

可见构造handler需要looper,没有的话会抛出异常。looper.mylooper()

会返回一个looper对象,怎么返回呢,看下源码

public static finallooper mylooper() { 
 return (looper)sthreadlocal.get(); 
}

显然,mylooper()从threadlocal中取出了looper对象。那么问题来了,我们又是什么时候将looper对象存进threadlocal呢?其实奥秘在于我们调用looper.prepare()的时候,看下源码

public static final void prepare() { 
  if (sthreadlocal.get() != null) { 
    throw new runtimeexception("only one looper may be created per thread"); 
  } 
  sthreadlocal.set(new looper()); 
}

可见当sthreadlocal取出的looper对象为空时,会创建一个新的looper对象。

由此可见,当实例化一个hanlder之前需要先调用looper.prepare() ,否则会抛出异常,除非是主线程中构建handler。因为主线程在创建的时候系统已经为其建立了一个looper。

message的创建

一般情况最普遍的做法就是

message message = new message();  
mhandler.sendmessage(message);

但这么做的话每次都需要new一个message,比较浪费空间,我们可以使用obtainmessage();看一下源码

public final message obtainmessage(int what, int arg1, int arg2, object obj){ 
  return message.obtain(this, what, arg1,arg2, obj); 
}

这个方法返回了message.obtain(this, what, arg1,arg2, obj) ,也就是说和obtainmessage()作用一样,所以也可以直接使用message.obtain(this, what, arg1,arg2, obj)

再看obtain()的源码

public static message obtain(handler h, int what, int arg1, int arg2, object obj) { 
   message m = obtain(); 
   m.target = h; 
   m.what = what; 
   m.arg1 = arg1; 
   m.arg2 = arg2; 
   m.obj = obj; 
   return m; 
}

看上面的代码我们还得找到obtain的无参构造

public static message obtain() { 
   synchronized (spoolsync) { 
     if (spool != null) { 
       message m = spool; 
       spool = m.next; 
       m.next = null; 
       m.flags = 0; // clear in-useflag 
       spoolsize--; 
       return m; 
     } 
   } 
   return new message(); 
 }

不难看出,obtain从消息池中返回了一个message对象,如果消息池为空再创建一个新的消息,所以一般使用obtain()得到一个消息比较合理。

message的参数

public int arg1
public int arg2

如果只需要存储整型数据,使用arg1 和 arg2即可

public object obj

发送给接收器的任意对象。当使用message对象在线程间传递消息时,如果它包含一个parcelable的结构类(不是由应用程序实现的类),此字段必须为非空(non-null)。

public int what

用户自定义的消息代码,这样接受者可以了解这个消息的信息。每个handler各自包含自己的消息代码,所以不用担心自定义的消息跟其他handlers有冲突。

如果需要传递bundle对象,则使用setdata(bundle)

public handler target

接收此消息的handler对象。

处理消息的几个方法

public final boolean sendmessage(message msg){
  return sendmessagedelayed(msg, 0);//直接调用sendmessagedelayed(),只是没有时间延迟
}
public final boolean sendmessagedelayed(message msg, long delaymillis){
  if (delaymillis < 0) {
    delaymillis = 0;
  } 
  return sendmessageattime(msg, systemclock.uptimemillis() + delaymillis);//调用sendmessageattime,当前时间加上延迟时间。
}

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);//调用enqueuemessage,附上消息队列和时间
}
private boolean enqueuemessage(messagequeue queue, message msg, long uptimemillis) {
 msg.target = this;  
 if (masynchronous) {    
  msg.setasynchronous(true);  
 }  
 return queue.enqueuemessage(msg, uptimemillis);//最后调用队列的插入消息方法,只是插入的时间有制定。
}

通过上面的分析,不管handler调用哪个sendmessage()的方法,最后都是将消息插入队列而已,没有其他操作。通过queue.enqueuemessage(msg, uptimemillis这个方法我们也知道looper处理消息的顺序是根据消息插入的时间快慢来轮询。

补充一下空消息的方法

public final boolean sendemptymessage(int what){
  return sendemptymessagedelayed(what, 0);
}
public final boolean sendemptymessagedelayed(int what, long delaymillis) { 
message msg = message.obtain(); 
msg.what = what; 
return sendmessagedelayed(msg, delaymillis); 
}

二、handler的post()方法

使用步骤

handler.post(new runnable() { 
      @override 
      public void run() { 
        //这里就可以进行ui操作。
      } 
    });

来看下post方法的源码

public final boolean post(runnable r){ 
  return sendmessagedelayed(getpostmessage(r), 0); 
}

看到这里是不是就恍然大悟了,原来post方法其实也是发送了一则消息。

再看getpostmessage(r)的源码

private final message getpostmessage(runnable r) {
  message m = message.obtain();
  m.callback = r;
  return m;
}

这下一清二楚了,这个方法将runnable对象封装为message,然后sendmessagedelayed发送过去给handler处理。

这里我们要先知道消息是如何被取出来的,当前messagequeue中存在mmessages(即待处理消息),就把这个消息取出来,然后让下一条消息成为mmessages,否则就进入一个阻塞状态,一直等到有新的消息入队。每当有一个消息取出,就将它传递到msg.target的dispatchmessage()中,这个msg.target是handler的enqueuemessage方法中的msg.target = this语句,也就是当前handler对象。所以接下来的重点自然就是回到dispatchmessage()

public void dispatchmessage(message msg) { 
  if (msg.callback != null) { 
    handlecallback(msg); 
  } else { 
    if (mcallback != null) { 
      if (mcallback.handlemessage(msg)) { 
        return; 
      } 
    } 
    handlemessage(msg); 
  } 
}

如果调用了handler.post()方法,则callback != null ,所以执行了 handlecallback(msg);方法

private final void handlecallback(message message) {
  message.callback.run();
}

也就是最终runnable对象被handle处理了。根据handler的原理,handler需要实例化在主线程post方法才能更新ui。

三、view的post方法

看下源码

public boolean post(runnable action) {
  handler handler;
  if (mattachinfo != null) {
    handler = mattachinfo.mhandler;
  } else {
    viewroot.getrunqueue().post(action);
    return true;
  }
  return handler.post(action);
}

一目了然,调用handlerd的post方法,本质是一样的。

四、activity中的runonuithread()方法

public final void runonuithread(runnable action) { 
  if (thread.currentthread() != muithread) { 
    mhandler.post(action); 
  } else { 
    action.run(); 
  } 
}

这个方法想必没什么好说的,如果是ui线程,直接run,不是的话借助handler.post()
有一点要注意,这个方法只能运行在activity中。

总结

以上就是这篇文章的全部内容了,希望能对大家的学习或者工作能带来一定的帮助,如果有疑问大家可以留言交流。