您的位置: 首页  >  文章  >  UI卡顿检测的两种方法

UI卡顿检测的两种方法

分类: 文章 • 2024-12-18 16:24:22

前言：我们都知道android开发负责的就是移动端用户与界面的交互，是用户和后端的桥梁，一个美观，流畅的界面大大提高用户的操作体验。但在一些情况下，炫酷的界面布局，复杂的动画或者自定义控件的绘制会造成一定的UI卡顿，这与我们设计的原则是相悖的。那么，造成UI卡顿的原因无非也就那几种，重要的是怎么检测是哪个地方造成了界面卡顿。

造成卡顿有可能发生在XML文件中，也可能是我们代码中的逻辑太复杂造成的，那么我们分两种不同的方法来分别对这两种情况进行具体检测

1.首先，我们看看是否是我们的界面是否过度绘制

手机开发者选项打开，我们看看里面有个显示边界布局的选项，打开它

UI卡顿检测的两种方法

我们可以看到，我们的手机界面布满一层层的色层次

打开我们的app

UI卡顿检测的两种方法

可以了解到，我们的布局绘制了越多层，红色就越深，越不合理，

像下面布局就是楼主为了实现一个自定义的特殊布局，嵌套了太多层布局，导致出现UI卡顿，可以看到我们的界面

UI卡顿检测的两种方法

了解了这些，我们就可以看到我们的布局是否合理，定位哪里可能造成了UI卡顿




2.卡顿如果是发生在代码部分，那么怎么定位

首先我们来了解一下dispatchMessage这个方法



1.  dispatchMessage方法在哪

dispatchMessage()是在Looper.loop()里调用，源码如下：

[java] view plain copy
  1. public static void loop() {  
  2.     final Looper me = myLooper();  
  3.     if (me == null) {  
  4.         throw new RuntimeException("No Looper; Looper.prepare() wasn't called on this thread.");  
  5.     }  
  6.     final MessageQueue queue = me.mQueue;  
  7.   
  8.     // Make sure the identity of this thread is that of the local process,  
  9.     // and keep track of what that identity token actually is.  
  10.     Binder.clearCallingIdentity();  
  11.     final long ident = Binder.clearCallingIdentity();  
  12.   
  13.     for (;;) {  
  14.         Message msg = queue.next(); // might block  
  15.         if (msg == null) {  
  16.             // No message indicates that the message queue is quitting.  
  17.             return;  
  18.         }  
  19.   
  20.         // This must be in a local variable, in case a UI event sets the logger  
  21.         Printer logging = me.mLogging;  
  22.         if (logging != null) {  
  23.             logging.println(">>>>> Dispatching to " + msg.target + " " +  
  24.                     msg.callback + ": " + msg.what);  
  25.         }  
  26.   
  27.         msg.target.dispatchMessage(msg);  
  28.   
  29.         if (logging != null) {  
  30.             logging.println("<<<<< Finished to " + msg.target + " " + msg.callback);  
  31.         }  
  32.   
  33.         // Make sure that during the course of dispatching the  
  34.         // identity of the thread wasn't corrupted.  
  35.         final long newIdent = Binder.clearCallingIdentity();  
  36.         if (ident != newIdent) {  
  37.             Log.wtf(TAG, "Thread identity changed from 0x"  
  38.                     + Long.toHexString(ident) + " to 0x"  
  39.                     + Long.toHexString(newIdent) + " while dispatching to "  
  40.                     + msg.target.getClass().getName() + " "  
  41.                     + msg.callback + " what=" + msg.what);  
  42.         }  
  43.   
  44.         msg.recycleUnchecked();  
  45.     }  
  46. }  

所以说，第27行的代码就是可能发生UI卡顿的地方。注意这行代码的前后，有两个logging。也就是说在执行第27代码的前后，如果设置了logging，会分别打印出“>>>>> Dispatching to”和“<<<<< Finished to”这样的Log。这样就给我们监视两次Log之间的时间差，来判断是否发生了卡顿。


2.  设置logging

主要看一下21行的mLogging是什么，源码如下所示：

[java] view plain copy
  1. public final class Looper {  
  2.     private Printer mLogging;  
  3.     public void setMessageLogging(@Nullable Printer printer) {  
  4.         mLogging = printer;  
  5.     }  
  6. }  
  7. public interface Printer {  
  8.     void println(String x);  
  9. }  

Looper的mLogging是私有的，并且提供了setMessageLogging(@Nullable Printer printer)方法，所以我们可以自己实现一个Printer，在通过setMessageLogging()方法传入即可。

[java] view plain copy
  1. public class AppContext extends Application {  
  2.     @Override  
  3.     public void onCreate() {  
  4.         super.onCreate();  
  5.        Looper.getMainLooper().setMessageLogging(new Printer() {  
  6.   
  7.             private static final String START = ">>>>> Dispatching";  
  8.             private static final String END = "<<<<< Finished";  
  9.   
  10.             @Override  
  11.             public void println(String x) {  
  12.                 if (x.startsWith(START)) {  
  13.                     LogMonitor.getInstance().startMonitor();  
  14.                 }  
  15.                 if (x.startsWith(END)) {  
  16.                     LogMonitor.getInstance().removeMonitor();  
  17.                 }  
  18.             }  
  19.         });  
  20.     }  
  21. }  

当我们设置了mLogging之后，loop()方法中就会回调logging.println，并将带有“>>>>> Dispatching to”和“<<<<< Finished to”的字符串传入，我们就可以拿到这两条信息。

如果“>>>>> Dispatching to”信号发生了，我们就假定发生了卡顿（这里我们设定1秒钟的卡顿判定阈值），并且发送一个延迟1秒钟的任务，这个任务就用于在子线程打印出造成卡顿的UI线程里的堆栈信息。而如果没有卡顿，即在1秒钟之内我们检测到了“<<<<< Finished to”信号，就会移除这个延迟1秒的任务。

 

3.  LogMonitor的实现

[java] view plain copy
  1. public class LogMonitor {  
  2.     private static LogMonitor sInstance = new LogMonitor();  
  3.     private HandlerThread mHandlerThread = new HandlerThread("log");  
  4.     private Handler mHandler;  
  5.   
  6.     private LogMonitor() {  
  7.         mHandlerThread.start();  
  8.         mHandler = new Handler(mHandlerThread.getLooper());  
  9.     }  
  10.   
  11.     private static Runnable mRunnable = new Runnable() {  
  12.         @Override  
  13.         public void run() {  
  14.             StringBuilder sb = new StringBuilder();  
  15.             StackTraceElement[] stackTrace = Looper.getMainLooper().getThread().getStackTrace();  
  16.             for (StackTraceElement s : stackTrace) {  
  17.                 sb.append(s.toString() + "\n");  
  18.             }  
  19.             Log.e("TAG", sb.toString());  
  20.         }  
  21.     };  
  22.   
  23.     public static LogMonitor getInstance() {  
  24.         return sInstance;  
  25.     }  
  26.   
  27.     public void startMonitor() {  
  28.         mHandler.postDelayed(mRunnable, 1000);  
  29.     }  
  30.   
  31.     public void removeMonitor() {  
  32.         mHandler.removeCallbacks(mRunnable);  
  33.     }  
  34.   
  35. }  

这里我们使用HandlerThread来构造一个Handler，HandlerThread继承自Thread，实际上就一个Thread，只不过它比普通的Thread多了一个Looper，对外提供自己这个Looper对象的get方法，然后创建Handler时将HandlerThread中的looper对象传入。这样我们的mHandler对象就是与HandlerThread这个非UI线程绑定的了，这样它处理耗时操作将不会阻塞UI。

总之，如果UI线程阻塞超过1秒，就会在子线程中执行mRunnable，打印出UI线程当前的堆栈信息，如果处理消息没有超过1秒，则会实时的remove掉这个mRunnable。

 

4.  测试

在Activity中设置一个按钮，并且设置点击后睡3秒。便可以看见打印出的Log信息。帮助我们定位到耗时的地方。



相关推荐