自拍偷在线精品自拍偷,亚洲欧美中文日韩v在线观看不卡

屏幕刷新機(jī)制 Choreographer 原理分析

作者：Android開發(fā)編程
移動開發(fā) Android
Android平臺提供兩種信號，一種是硬件信號，另一種是軟件信號，由SurfaceFlinger進(jìn)程的一個線程定時發(fā)出，硬件信號由硬件發(fā)出。

[[439195]]

本文轉(zhuǎn)載自微信公眾號「Android開發(fā)編程」，作者Android開發(fā)編程。轉(zhuǎn)載本文請聯(lián)系A(chǔ)ndroid開發(fā)編程公眾號。

前言

Android平臺提供兩種信號，一種是硬件信號，另一種是軟件信號，由SurfaceFlinger進(jìn)程的一個線程定時發(fā)出，硬件信號由硬件發(fā)出;

App進(jìn)程若要通過gpu實(shí)現(xiàn)圖像繪制，需要在接收到Vsync信號的條件下進(jìn)行，因此，App進(jìn)程訪問SurfaceFlinger進(jìn)程獲取這個信號，再進(jìn)行g(shù)pu繪制;

Android4.1之后增加了Choreographer機(jī)制，用于同Vsync機(jī)制配合，統(tǒng)一動畫、輸入和繪制時機(jī);

Choreographer就是負(fù)責(zé)獲取Vsync同步信號并控制App線程(主線程)完成圖像繪制的類;

今天我們就來聊聊Choreographer機(jī)制;

一、Choreographer類介紹

1、實(shí)例初始化

  1. public ViewRootImpl(Context context, Display display) { 
  2.     ... 
  3.     //獲取Choreographer實(shí)例 
  4.     mChoreographer = Choreographer.getInstance(); 
  5.     ... 
  6. } 
  7. public static Choreographer getInstance() { 
  8.     return sThreadInstance.get(); 
  9. } 
  10. private static final ThreadLocal<Choreographer> sThreadInstance = 
  11.         new ThreadLocal<Choreographer>() { 
  12.     @Override 
  13.     protected Choreographer initialValue() { 
  14.         Looper looper = Looper.myLooper(); 
  15.         if (looper == null) { 
  16.             throw new IllegalStateException("The current thread must have a looper!"); 
  17.         } 
  18.         return new Choreographer(looper); 
  19.     } 
  20. }; 
  • 每個線程中保存一個Choreographer實(shí)例對象;
  • 線程本地存儲ThreadLocal變量，Choreographer類型，在主線程中初始化變量時，創(chuàng)建Choreographer對象，綁定主線程Looper;
  • 同一個App的每個窗體旗下ViewRootImpl使用的同一個Choregrapher對象，他控制者整個App中大部分視圖的繪制節(jié)奏。

2、構(gòu)造方法

  1. private Choreographer(Looper looper, int vsyncSource) { 
  2.         mLooper = looper; 
  3.         //使用當(dāng)前線程looper創(chuàng)建 mHandler 
  4.         mHandler = new FrameHandler(looper); 
  5.         //USE_VSYNC 4.1以上默認(rèn)是true，表示 具備接受VSync的能力，這個接受能力就是FrameDisplayEventReceiver 
  6.         mDisplayEventReceiver = USE_VSYNC 
  7.                 ? new FrameDisplayEventReceiver(looper, vsyncSource) 
  8.                 : null; 
  9.         mLastFrameTimeNanos = Long.MIN_VALUE; 
  10.         // 計(jì)算一幀的時間，Android手機(jī)屏幕是60Hz的刷新頻率，就是16ms 
  11.         mFrameIntervalNanos = (long)(1000000000 / getRefreshRate()); 
  12.         // 創(chuàng)建一個鏈表類型CallbackQueue的數(shù)組，大小為5， 
  13.         //也就是數(shù)組中有五個鏈表，每個鏈表存相同類型的任務(wù)：輸入、動畫、遍歷繪制等任務(wù)（CALLBACK_INPUT、CALLBACK_ANIMATION、CALLBACK_TRAVERSAL） 
  14.         mCallbackQueues = new CallbackQueue[CALLBACK_LAST + 1]; 
  15.         for (int i = 0; i <= CALLBACK_LAST; i++) { 
  16.             mCallbackQueues[i] = new CallbackQueue(); 
  17.         } 
  18.         // b/68769804: For low FPS experiments. 
  19.         setFPSDivisor(SystemProperties.getInt(ThreadedRenderer.DEBUG_FPS_DIVISOR, 1)); 
  20.     } 
  • 有一個Looper和一個FrameHandler變量;
  • 變量USE_VSYNC用于表示系統(tǒng)是否是用了Vsync同步機(jī)制，該值是通過讀取系統(tǒng)屬性debug.choreographer.vsync來獲取的;
  • 系統(tǒng)使用了Vsync同步機(jī)制，創(chuàng)建一個FrameDisplayEventReceiver對象用于請求并接收Vsync事件;
  • Choreographer創(chuàng)建了一個大小為3的CallbackQueue隊(duì)列數(shù)組，用于保存不同類型的Callback。

3、Callback類型

  1. //輸入事件，首先執(zhí)行 
  2.     public static final int CALLBACK_INPUT = 0; 
  3.     //動畫，第二執(zhí)行 
  4.     public static final int CALLBACK_ANIMATION = 1; 
  5.     //插入更新的動畫，第三執(zhí)行 
  6.     public static final int CALLBACK_INSETS_ANIMATION = 2; 
  7.     //繪制，第四執(zhí)行 
  8.     public static final int CALLBACK_TRAVERSAL = 3; 
  9.     //提交，最后執(zhí)行， 
  10.     public static final int CALLBACK_COMMIT = 4; 

五種類型任務(wù)對應(yīng)存入對應(yīng)的CallbackQueue中;

每當(dāng)收到 VSYNC 信號時，Choreographer 將首先處理 INPUT 類型的任務(wù)，然后是 ANIMATION 類型，最后才是 TRAVERSAL 類型。

4、FrameHandler處理的消息

  • CallbackQueue是一個容量為4的數(shù)組，每一個元素作為頭指針，引出對應(yīng)類型的鏈表，4種事件就是通過這4個鏈表來維護(hù)的;
  • 而FrameHandler中主要處理三類消息：
  1. private final class FrameHandler extends Handler { 
  2.    public FrameHandler(Looper looper) { 
  3.        super(looper); 
  4.    } 
  5.    @Override 
  6.    public void handleMessage(Message msg) { 
  7.        switch (msg.what) { 
  8.            case MSG_DO_FRAME: 
  9.                doFrame(System.nanoTime(), 0); 
  10.                break; 
  11.            case MSG_DO_SCHEDULE_VSYNC: 
  12.                doScheduleVsync();   // 請求VSYNC信號 
  13.                break; 
  14.            case MSG_DO_SCHEDULE_CALLBACK: 
  15.                doScheduleCallback(msg.arg1); 
  16.                break; 
  17.        } 
  18.    } 
  19. } 
  • MSG_DO_FRAME 處理注冊在Choreographer 的Runnable;
  • MSG_DO_SCHEDULE_VSYNC 直接請求下一幀的VSync信號;
  • MSG_DO_SCHEDULE_CALLBACK 根據(jù)Choreographer的配置執(zhí)行合適的Handler延時處理;

二、Choreographer執(zhí)行流程

1、requestLayout

  1. @Override 
  2.     public void requestLayout() { 
  3.         if (!mHandlingLayoutInLayoutRequest) { 
  4.             checkThread();//檢查是否在當(dāng)前線程 
  5.             mLayoutRequested = true;//mLayoutRequested 是否measure和layout布局。 
  6.             scheduleTraversals(); 
  7.         } 
  8.     } 
  9.     void scheduleTraversals() { 
  10.         if (!mTraversalScheduled) {//同一幀內(nèi)不會多次調(diào)用遍歷 
  11.             mTraversalScheduled = true; 
  12.             mTraversalBarrier = mHandler.getLooper().getQueue().postSyncBarrier();//攔截同步Message 
  13.             //Choreographer回調(diào)，執(zhí)行繪制操作 
  14.             mChoreographer.postCallback( 
  15.                     Choreographer.CALLBACK_TRAVERSAL, mTraversalRunnable, null); 
  16.         } 
  17.     } 
  • postSyncBarrier : Handler 的同步屏障，它的作用是可以攔截 Looper 對同步消息的獲取和分發(fā)，加入同步屏障之后，Looper 只會獲取和處理異步消息，如果沒有異步消息那么就會進(jìn)入阻塞狀態(tài);
  • Choreographer: 編舞者，統(tǒng)一動畫、輸入和繪制時機(jī);
  1. mChoreographer.postCallback( 
  2.                     Choreographer.CALLBACK_TRAVERSAL, mTraversalRunnable, null); 
  3. postCallback()->postCallbackDelayed()->postCallbackDelayedInternal(): 

2、postCallbackDelayedInternal

  1. private void postCallbackDelayedInternal(int callbackType, 
  2.        Object action, Object token, long delayMillis) { 
  3.    synchronized (mLock) { 
  4.        // 當(dāng)前時間 
  5.        final long now = SystemClock.uptimeMillis(); 
  6.        // 回調(diào)執(zhí)行時間，為當(dāng)前時間加上延遲的時間 
  7.        final long dueTime = now + delayMillis; 
  8.        // obtainCallbackLocked(long dueTime, Object action, Object token)會將傳入的3個參數(shù)轉(zhuǎn)換為CallbackRecord(具體請看源碼，非主要部分，此處略過)，然后CallbackQueue根據(jù)回調(diào)類型將CallbackRecord添加到鏈表上。 
  9.        mCallbackQueues[callbackType].addCallbackLocked(dueTime, action, token); 
  10.        if (dueTime <= now) { 
  11.            // 如果delayMillis=0的話，dueTime=now，則會馬上執(zhí)行 
  12.            scheduleFrameLocked(now); 
  13.        } else { 
  14.            // 如果dueTime>now，則發(fā)送一個what為MSG_DO_SCHEDULE_CALLBACK類型的定時消息，等時間到了再處理，其最終處理也是執(zhí)行scheduleFrameLocked(long now)方法 
  15.            Message msg = mHandler.obtainMessage(MSG_DO_SCHEDULE_CALLBACK, action); 
  16.            msg.arg1 = callbackType; 
  17.            msg.setAsynchronous(true); 
  18.            mHandler.sendMessageAtTime(msg, dueTime); 
  19.        } 
  20.    } 
  21. } 
  • mCallbackQueues先把對應(yīng)的callback添加到鏈表上來，然后判斷是否有延遲;
  • 如果沒有則會馬上執(zhí)行scheduleFrameLocked，如果有，則發(fā)送一個what為MSG_DO_SCHEDULE_CALLBACK類型的定時消息，等時間到了再處理;
  • 其最終處理也是執(zhí)行scheduleFrameLocked(long now)方法;

3、scheduleFrameLocked

  1. private void scheduleFrameLocked(long now) { 
  2.    if (!mFrameScheduled) { 
  3.        mFrameScheduled = true; 
  4.        if (USE_VSYNC) { 
  5.            // 如果使用了VSYNC，由系統(tǒng)值確定 
  6.            if (DEBUG_FRAMES) { 
  7.                Log.d(TAG, "Scheduling next frame on vsync."); 
  8.            } 
  9.            if (isRunningOnLooperThreadLocked()) { 
  10.                // 請求VSYNC信號，最終會調(diào)到Native層，Native處理完成后觸發(fā)FrameDisplayEventReceiver的onVsync回調(diào)，回調(diào)中最后也會調(diào)用doFrame(long frameTimeNanos, int frame)方法 
  11.                scheduleVsyncLocked(); 
  12.            } else { 
  13.                // 在UI線程上直接發(fā)送一個what=MSG_DO_SCHEDULE_VSYNC的消息，最終也會調(diào)到scheduleVsyncLocked()去請求VSYNC信號 
  14.                Message msg = mHandler.obtainMessage(MSG_DO_SCHEDULE_VSYNC); 
  15.                msg.setAsynchronous(true); 
  16.                mHandler.sendMessageAtFrontOfQueue(msg); 
  17.            } 
  18.        } else { 
  19.            // 沒有使用VSYNC 
  20.            final long nextFrameTime = Math.max( 
  21.                    mLastFrameTimeNanos / TimeUtils.NANOS_PER_MS + sFrameDelay, now); 
  22.            if (DEBUG_FRAMES) { 
  23.                Log.d(TAG, "Scheduling next frame in " + (nextFrameTime - now) + " ms."); 
  24.            } 
  25.            // 直接發(fā)送一個what=MSG_DO_FRAME的消息，消息處理時調(diào)用doFrame(long frameTimeNanos, int frame)方法 
  26.            Message msg = mHandler.obtainMessage(MSG_DO_FRAME); 
  27.            msg.setAsynchronous(true); 
  28.            mHandler.sendMessageAtTime(msg, nextFrameTime); 
  29.        } 
  30.    } 
  31. } 
  1. // Enable/disable vsync for animations and drawing. 
  2.     private static final boolean USE_VSYNC = SystemProperties.getBoolean( 
  3.             "debug.choreographer.vsync", true); 

常量USE_VSYNC，表示是否允許動畫和繪制的垂直同步，默認(rèn)是為true;

判斷USE_VSYNC，如果使用了VSYNC:走scheduleVsyncLocked，即請求VSYNC信號，最終調(diào)用doFrame;

如果沒使用VSYNC，則通過消息執(zhí)行doFrame;

4、scheduleVsyncLocked

請求VSYNC信號的流程;

  1. private void scheduleVsyncLocked() { 
  2.     mDisplayEventReceiver.scheduleVsync(); 
  3. } 
  4. public void scheduleVsync() { 
  5.     if (mReceiverPtr == 0) { 
  6.         Log.w(TAG, "Attempted to schedule a vertical sync pulse but the display event " 
  7.                 + "receiver has already been disposed."); 
  8.     } else { 
  9.         nativeScheduleVsync(mReceiverPtr); 
  10.     } 
  11. } 
  • mDisplayEventReceiver 對應(yīng)的是FrameDisplayEventReceiver，它繼承自 DisplayEventReceiver ， 主要是用來接收同步脈沖信號 VSYNC;
  • scheduleVsync()方法通過底層nativeScheduleVsync()向SurfaceFlinger 服務(wù)注冊，即在下一次脈沖接收后會調(diào)用 DisplayEventReceiver的dispatchVsync()方法;
  • 這里類似于訂閱者模式，但是每次調(diào)用nativeScheduleVsync()方法都有且只有一次dispatchVsync()方法回調(diào);
  • 底層向應(yīng)用層發(fā)送VSYNC信號，java層通過dispatchVsync()接收，最后回調(diào)在FrameDisplayEventReceiver的onVsync;

5、FrameDisplayEventReceiver

  1. private final class FrameDisplayEventReceiver extends DisplayEventReceiver implements Runnable { 
  2.     private boolean mHavePendingVsync; 
  3.     private long mTimestampNanos; 
  4.     private int mFrame; 
  5.     @Override 
  6.     public void onVsync(long timestampNanos, int builtInDisplayId, int frame) { 
  7.         //忽略來自第二顯示屏的Vsync 
  8.         if (builtInDisplayId != SurfaceControl.BUILT_IN_DISPLAY_ID_MAIN) { 
  9.             scheduleVsync(); 
  10.             return; 
  11.         } 
  12.         ... 
  13.         mTimestampNanos = timestampNanos; 
  14.         mFrame = frame; 
  15.         //該消息的callback為當(dāng)前對象FrameDisplayEventReceiver 
  16.         Message msg = Message.obtain(mHandler, this); 
  17.         msg.setAsynchronous(true); 
  18.         //此處mHandler為FrameHandler 
  19.         mHandler.sendMessageAtTime(msg, timestampNanos / TimeUtils.NANOS_PER_MS); 
  20.     } 
  21.     @Override 
  22.     public void run() { 
  23.         mHavePendingVsync = false; 
  24.         doFrame(mTimestampNanos, mFrame);  
  25.     } 
  26. } 
  • onVsync()過程是通過FrameHandler向主線程Looper發(fā)送了一個自帶callback的消息 callback為FrameDisplayEventReceiver;
  • 當(dāng)主線程Looper執(zhí)行到該消息時，則調(diào)用FrameDisplayEventReceiver.run()方法，緊接著便是調(diào)用doFrame;

6、doFrame

  1. void doFrame(long frameTimeNanos, int frame) { 
  2.         final long startNanos; 
  3.         synchronized (mLock) { 
  4.             ... 
  5.             //是否有跳幀，如果有那么就打印log并且修正偏差 
  6.         } 
  7.         //執(zhí)行callback 
  8.         try { 
  9.             Trace.traceBegin(Trace.TRACE_TAG_VIEW, "Choreographer#doFrame"); 
  10.             AnimationUtils.lockAnimationClock(frameTimeNanos / TimeUtils.NANOS_PER_MS); 
  11.             mFrameInfo.markInputHandlingStart(); 
  12.             doCallbacks(Choreographer.CALLBACK_INPUT, frameTimeNanos); 
  13.             mFrameInfo.markAnimationsStart(); 
  14.             doCallbacks(Choreographer.CALLBACK_ANIMATION, frameTimeNanos); 
  15.             mFrameInfo.markPerformTraversalsStart(); 
  16.             doCallbacks(Choreographer.CALLBACK_TRAVERSAL, frameTimeNanos); 
  17.             doCallbacks(Choreographer.CALLBACK_COMMIT, frameTimeNanos); 
  18.         } finally { 
  19.             AnimationUtils.unlockAnimationClock(); 
  20.             Trace.traceEnd(Trace.TRACE_TAG_VIEW); 
  21.         } 
  22.         if (DEBUG_FRAMES) { 
  23.             final long endNanos = System.nanoTime(); 
  24.             Log.d(TAG, "Frame " + frame + ": Finished, took " 
  25.                     + (endNanos - startNanos) * 0.000001f + " ms, latency " 
  26.                     + (startNanos - frameTimeNanos) * 0.000001f + " ms."); 
  27.         } 
  28.     } 

doFrame方法做的就是渲染下一幀，檢測是否卡頓并修補(bǔ)卡頓，然后開始做渲染工作，doCallbacks方法的參數(shù)：

  • CALLBACK_INPUT：輸入;
  • CALLBACK_ANIMATION:動畫;
  • CALLBACK_TRAVERSAL:遍歷，執(zhí)行measure、layout、draw;
  • CALLBACK_COMMIT：遍歷完成的提交操作，用來修正動畫啟動時間;

7、doCallbacks

  1. void doCallbacks(int callbackType, long frameTimeNanos) { 
  2.     CallbackRecord callbacks; 
  3.     synchronized (mLock) { 
  4.         final long now = SystemClock.uptimeMillis(); 
  5.         //從指定類型的CallbackQueue隊(duì)列中查找執(zhí)行時間到的CallbackRecord 
  6.         callbacks = mCallbackQueues[callbackType].extractDueCallbacksLocked(now); 
  7.         if (callbacks == null) { 
  8.             return; 
  9.         } 
  10.         mCallbacksRunning = true; 
  11.     } 
  12.     try { 
  13.         //由于CallbackQueues是按時間先后順序排序的，因此遍歷執(zhí)行所有時間到的CallbackRecord 
  14.         for (CallbackRecord c = callbacks; c != null; c = c.next) { 
  15.             c.run(frameTimeNanos); 
  16.         } 
  17.     } finally { 
  18.         synchronized (mLock) { 
  19.             mCallbacksRunning = false; 
  20.             do { 
  21.                 final CallbackRecord next = callbacks.next; 
  22.                 recycleCallbackLocked(callbacks); 
  23.                 callbacks = next; 
  24.             } while (callbacks != null); 
  25.         } 
  26.     } 
  27. } 

Choreographer內(nèi)部維護(hù)了這四種鏈表，渲染每一幀的時候都會從上往下的去執(zhí)行相應(yīng)的渲染操作，有輸入那么就先渲染輸入隊(duì)列，有動畫就渲染動畫，然后遍歷，然后提交;

8、Choreographer總結(jié)

  • 控制外部輸入事件處理，動畫執(zhí)行，UI變化，以及提交執(zhí)行都是在同一個類中做的處理，即是Choreographer;
  • Choreographer支持4種類型事件：輸入、繪制、動畫、提交，并通過postCallback在對應(yīng)需要同步vsync進(jìn)行刷新處進(jìn)行注冊，等待回調(diào);
  • 每次執(zhí)行的時候，Choreographer會根據(jù)當(dāng)前的時間，只處理事件鏈表中最后一個事件，當(dāng)有耗時操作在主線程時，事件不能及時執(zhí)行，就會出現(xiàn)所謂的“跳幀”，“卡頓”現(xiàn)象;
  • Choreographer的共有方法postCallback(callbackType, Object)是往事件鏈表中放事件的方法，而doFrame()是消耗這些事件的方法;
  • Choreographer監(jiān)聽底層Vsync信號，一旦接收到回調(diào)信號，則通過doFrame統(tǒng)一對java層4種類型事件進(jìn)行回調(diào)。

 

責(zé)任編輯：武曉燕 來源： Android開發(fā)編程
Choreographer屏幕機(jī)制
相關(guān)推薦

2011-07-15 09:57:03

MongoDB緩存刷新

2021-04-21 07:53:13

Android屏幕刷新

2020-10-13 08:36:30

React 架構(gòu)機(jī)制

2020-09-21 14:35:20

VuenextTick前端

2025-05-07 08:00:00

刷新令牌自動續(xù)簽FastAPI

2010-09-06 08:43:13

.NET 4

2010-03-10 11:55:30

Mocha BSM運(yùn)維管理摩卡軟件

2010-06-02 11:33:26

Linux 內(nèi)存監(jiān)控

2024-01-03 21:50:32

緩存機(jī)制請求

2016-10-21 09:29:53

嵌入式Linux更新機(jī)制

2021-02-25 11:12:31

人工智能生物技術(shù)肺纖維化藥物

2012-12-03 16:57:37

HDFS

2025-04-03 00:45:00

2022-11-02 15:56:45

littlefscommit機(jī)制

2024-06-17 08:55:52

2018-08-10 04:40:56

2021-12-06 14:52:08

動畫Android補(bǔ)間動畫

2009-11-13 17:20:35

ADO.NET數(shù)據(jù)集工

2012-12-10 09:52:15

2018-09-03 15:45:48

Windows 10Windows驅(qū)動程序
點(diǎn)贊
收藏

51CTO技術(shù)棧公眾號