从 FrameCallback 理解 Choreographer 原理及简单帧率监控应用

adison927
9,547 阅读5分钟

简单来说，Choreographer主要作用是协调动画，输入和绘制的时间，它从显示子系统接收定时脉冲（例如垂直同步），然后安排渲染下一个frame的一部分工作。

自定义FrameCallback

FrameCallback是和Choreographer交互，在下一个frame被渲染时触发的接口类。开发者可以设置自己的FrameCallback。我们就从自定义FrameCallback作为切入口，尝试窥探一下Choreographer的实现原理。简单实现如下：

private static final String TAG = "Choreographer_test";
 @Override
 public void onCreate(Bundle savedInstanceState) {
     super.onCreate(savedInstanceState);
     setContentView(R.layout.activity_main);
     final ImageView imageView= (ImageView) findViewById(R.id.iv_anim);
     imageView.setOnClickListener(new View.OnClickListener() {
         @Override
         public void onClick(View v) {
             final long starTime=System.nanoTime();
             Choreographer.getInstance().postFrameCallback(new Choreographer.FrameCallback() {
                 @Override
                 public void doFrame(long frameTimeNanos) {
                     Log.e(TAG,"starTime="+starTime+", frameTimeNanos="+frameTimeNanos+", frameDueTime="+(frameTimeNanos-starTime)/1000000);
                 }
             });
         }
     });
 }

在这里，我们自定义的FrameCallback只是简单把时间打印了一下。输入如下信息：

E/Choreographer_test: starTime=232157742945242, frameTimeNanos=232157744964255, frameDueTime=2

从log可以看出，这一帧大概2ms就处理完毕。下面我们从源码角度窥探一下它具体的实现原理。

实现原理

1. 关键成员变量

构造函数

private Choreographer(Looper looper) {
     mLooper = looper;
    //1.创建Handler对象，用于处理消息
     mHandler = new FrameHandler(looper);
    //2.创建接收VSYNC信号的对象
     mDisplayEventReceiver = USE_VSYNC ? new FrameDisplayEventReceiver(looper) : null;
    //3.初始化上一次frame渲染的时间点
     mLastFrameTimeNanos = Long.MIN_VALUE;
    //4.帧率，也就是渲染一帧的时间，getRefreshRate是刷新率，一般是60
     mFrameIntervalNanos = (long)(1000000000 / getRefreshRate());
    //5.创建回调队列
     mCallbackQueues = new CallbackQueue[CALLBACK_LAST + 1];
     for (int i = 0; i <= CALLBACK_LAST; i++) {
         mCallbackQueues[i] = new CallbackQueue();
     }
 }

FrameHandler

private final class FrameHandler extends Handler {
       public FrameHandler(Looper looper) {
           super(looper);
       }
       @Override
       public void handleMessage(Message msg) {
           switch (msg.what) {
               case MSG_DO_FRAME:
                //渲染下一个frame
                   doFrame(System.nanoTime(), 0);
                   break;
               case MSG_DO_SCHEDULE_VSYNC:
                //请求VSNYC信号
                   doScheduleVsync();
                   break;
               case MSG_DO_SCHEDULE_CALLBACK:
                //执行Callback
                   doScheduleCallback(msg.arg1);
                   break;
           }
       }
   }

FrameDisplayEventReceiver

FrameDisplayEventReceiver是DisplayEventReceiver的子类，DisplayEventReceiver是接收VSYNC信息的java层实现。

public abstract class DisplayEventReceiver {
    public void onVsync(long timestampNanos, int builtInDisplayId, int frame) {}
    public void scheduleVsync() {
        if (mReceiverPtr == 0) {
            Log.w(TAG, "Attempted to schedule a vertical sync pulse but the display event "
                    + "receiver has already been disposed.");
        } else {
            nativeScheduleVsync(mReceiverPtr);
        }
    }
    private void dispatchVsync(long timestampNanos, int builtInDisplayId, int frame) {
        onVsync(timestampNanos, builtInDisplayId, frame);
    }
}

VSYNC信息一般由硬件中断产生，SurfaceFlinger处理。具体实现和监听机制可以参考链接，scheduleVsync方法用于请求VSNYC信号， Native方法接收到VSYNC信息处理后会调用java层dispatchVsync方法，最终调用到FrameDisplayEventReceiver的onVsync方法，具体实现我们一会再说。

CallbackQueue

CallbackQueue是个单链表实现，每种类型的callback(CallbackRecord)按照设置的执行时间(dueTime)顺序排序分别保存在其各自CallbackQueue。在Choreographer中有四种类型callback：Input、Animation、Draw，还有一种是用来解决动画启动问题的。

private final class CallbackQueue {
        private CallbackRecord mHead;
        public boolean hasDueCallbacksLocked(long now) {
            return mHead != null && mHead.dueTime <= now;
        }
        //根据当前时间得到callback
        public CallbackRecord extractDueCallbacksLocked(long now) {
              ....
              ....
        }
        //根据时间添加callback
        public void addCallbackLocked(long dueTime, Object action, Object token) {
            ....
            ....
        }
        //移除callback
        public void removeCallbacksLocked(Object action, Object token) {
                 ....
                 ....
            }
        }
    }

2. 流程分析

大致分析完Choreographer关键的几个成员变量后，我们再回到postFrameCallback方法

public void postFrameCallbackDelayed(FrameCallback callback, long delayMillis) {
      if (callback == null) {
          throw new IllegalArgumentException("callback must not be null");
      }
//默认为CALLBACK_ANIMATION类型
      postCallbackDelayedInternal(CALLBACK_ANIMATION,
              callback, FRAME_CALLBACK_TOKEN, delayMillis);
  }

postCallbackDelayedInternal

private void postCallbackDelayedInternal(int callbackType,
            Object action, Object token, long delayMillis) {
        synchronized (mLock) {
            final long now = SystemClock.uptimeMillis();
            final long dueTime = now + delayMillis;
            //添加callback到回调队列
            mCallbackQueues[callbackType].addCallbackLocked(dueTime, action, token);
            if (dueTime <= now) {
                scheduleFrameLocked(now);
            } else {
                //设定的执行时间在当前时间之后,发送MSG_DO_SCHEDULE_CALLBACK，由FrameHanlder安排执行scheduleFrameLocked
                Message msg = mHandler.obtainMessage(MSG_DO_SCHEDULE_CALLBACK, action);
                msg.arg1 = callbackType;
                msg.setAsynchronous(true);
                mHandler.sendMessageAtTime(msg, dueTime);`
            }
        }
    }

scheduleFrameLocked

private void scheduleFrameLocked(long now) {
            ....
             if (isRunningOnLooperThreadLocked()) {
               //若当前线程是UI线程，执行scheduleVsyncLocked请求VSYNC信号
               scheduleVsyncLocked();
             } else {
               //非UI线程，发送MSG_DO_SCHEDULE_VSYNC消息到主线程
               Message msg = mHandler.obtainMessage(MSG_DO_SCHEDULE_VSYNC);
               msg.setAsynchronous(true);
               mHandler.sendMessageAtFrontOfQueue(msg);
             }
         ....
   }

scheduleVsyncLocked最终调用FrameDisplayEventReceiver#scheduleVsync，收到Vsync信息后，调用FrameDisplayEventReceiver#onVsync

FrameDisplayEventReceiver#onVsync

private final class FrameDisplayEventReceiver extends DisplayEventReceiver
         implements Runnable {
     private boolean mHavePendingVsync;
     private long mTimestampNanos;
     private int mFrame;
     public FrameDisplayEventReceiver(Looper looper) {
         super(looper);
     }
     @Override
     public void onVsync(long timestampNanos, int builtInDisplayId, int frame) {
            ....
            ....
         mTimestampNanos = timestampNanos;
         mFrame = frame;
        //该消息的callback为当前对象FrameDisplayEventReceiver,收到消息调用其run方法,然后调用doFrame方法
         Message msg = Message.obtain(mHandler, this);
         msg.setAsynchronous(true);
         mHandler.sendMessageAtTime(msg, timestampNanos / TimeUtils.NANOS_PER_MS);
     }
     @Override
     public void run() {
         mHavePendingVsync = false;
         doFrame(mTimestampNanos, mFrame);
     }
 }

doFrame

void doFrame(long frameTimeNanos, int frame) {
        ....
        //Vsync信号到来时间    
        long intendedFrameTimeNanos = frameTimeNanos;
        //实际开始执行当前frame的时间
        startNanos = System.nanoTime();
        //时间差
        final long jitterNanos = startNanos - frameTimeNanos;
        //时间差大于帧率，则认为是跳帧
        if (jitterNanos >= mFrameIntervalNanos) {
            final long skippedFrames = jitterNanos / mFrameIntervalNanos;
            if (skippedFrames >= SKIPPED_FRAME_WARNING_LIMIT) {
                Log.i(TAG, "Skipped " + skippedFrames + " frames!  "
                        + "The application may be doing too much work on its main thread.");
            }
          ....
          ....
         //记录当前frame信息   
        mFrameInfo.setVsync(intendedFrameTimeNanos, frameTimeNanos);
        mFrameScheduled = false;
          //记录上一次frame渲染的时间点
        mLastFrameTimeNanos = frameTimeNanos;
    }
    try {
        //执行CallBack，优先级为：CALLBACK_INPUT>CALLBACK_ANIMATION>CALLBACK_TRAVERSAL>CALLBACK_COMMIT
        Trace.traceBegin(Trace.TRACE_TAG_VIEW, "Choreographer#doFrame");
        mFrameInfo.markInputHandlingStart();
        doCallbacks(Choreographer.CALLBACK_INPUT, frameTimeNanos);
        mFrameInfo.markAnimationsStart();
        doCallbacks(Choreographer.CALLBACK_ANIMATION, frameTimeNanos);
        mFrameInfo.markPerformTraversalsStart();
        doCallbacks(Choreographer.CALLBACK_TRAVERSAL, frameTimeNanos);
        doCallbacks(Choreographer.CALLBACK_COMMIT, frameTimeNanos);
    } finally {
        Trace.traceEnd(Trace.TRACE_TAG_VIEW);
    }
    ....
}

doCallbacks

void doCallbacks(int callbackType, long frameTimeNanos) {
    CallbackRecord callbacks;
    synchronized (mLock) {
        final long now = System.nanoTime();
        // 从队列查找相应类型的CallbackRecord对象
        callbacks = mCallbackQueues[callbackType].extractDueCallbacksLocked(
                now / TimeUtils.NANOS_PER_MS);
        if (callbacks == null) {
            return;
        }
        mCallbacksRunning = true;
      ....
      ....  
    try {
        Trace.traceBegin(Trace.TRACE_TAG_VIEW, CALLBACK_TRACE_TITLES[callbackType]);
        for (CallbackRecord c = callbacks; c != null; c = c.next) {
            ....
            //调用CallbackRecord的run方法
            c.run(frameTimeNanos);
        }
    } finally {
        synchronized (mLock) {
            mCallbacksRunning = false;
            //回收callbacks，加入mCallbackPool对象池
            do {
                final CallbackRecord next = callbacks.next;
                recycleCallbackLocked(callbacks);
                callbacks = next;
            } while (callbacks != null);
        }
        Trace.traceEnd(Trace.TRACE_TAG_VIEW);
    }
}

CallbackRecord#run

 public void run(long frameTimeNanos) {
   if (token == FRAME_CALLBACK_TOKEN) {
      //调用自定义FrameCallback的doFrame方法
     ((FrameCallback)action).doFrame(frameTimeNanos);
   } else {
     ((Runnable)action).run();
   }
}

至此，关于Choreographer的整个调用流程及其原理已经分析完成。至于系统某些调用，如View的invalidate，触发ViewRootImpl#scheduleTraversals，最终调用Choreographer#postCallback( Choreographer.CALLBACK_TRAVERSAL, mTraversalRunnable, null);，只是明确了Callbac的类型以及回调处理Runnable而已，基本流程和自定义FrameCallback一样。

总结

  • 尽量避免在执行动画或渲染操作之后在主线程执行操作，在之前或之后都应该尽量避免发送消息到主线程looper

  • 既然自定义FrameCallback可以在下一个frame被渲染的时候会被回调，那我们是不是可以根据这个原理实现应用的帧率监听呢，答案是肯定的，下面是我的简单实现:

1.自定义FrameCallback：FPSFrameCallback

public class FPSFrameCallback implements Choreographer.FrameCallback {
   private static final String TAG = "FPS_TEST";
    private long mLastFrameTimeNanos = 0;
    private long mFrameIntervalNanos;
    public FPSFrameCallback(long lastFrameTimeNanos) {
        mLastFrameTimeNanos = lastFrameTimeNanos;
        mFrameIntervalNanos = (long)(1000000000 / 60.0);
    }
    @Override
    public void doFrame(long frameTimeNanos) {
        //初始化时间
        if (mLastFrameTimeNanos == 0) {
            mLastFrameTimeNanos = frameTimeNanos;
        }
        final long jitterNanos = frameTimeNanos - mLastFrameTimeNanos;
        if (jitterNanos >= mFrameIntervalNanos) {
            final long skippedFrames = jitterNanos / mFrameIntervalNanos;
            if(skippedFrames>30){
                Log.i(TAG, "Skipped " + skippedFrames + " frames!  "
                        + "The application may be doing too much work on its main thread.");
            }
        }
        mLastFrameTimeNanos=frameTimeNanos;
        //注册下一帧回调
        Choreographer.getInstance().postFrameCallback(this);
    }
}

2.在Application中注册

@Override
   public void onCreate() {
       super.onCreate();
       Choreographer.getInstance().postFrameCallback(new FPSFrameCallback(System.nanoTime()));
   }

3.测试

public class MainActivity extends FragmentActivity {
    @Override
    public void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
    }
    @Override
    protected void onResume() {
        super.onResume();
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

LOG输出如下：

I/Choreographer: Skipped 64 frames!  The application may be doing too much work on its main thread.
I/FPS_TEST: Skipped 65 frames!  The application may be doing too much work on its main thread.

基本和系统监控数值一致

Adison wechat 欢迎您扫一扫上面的微信公众号，订阅我的博客！
avatar
文章
阅读
粉丝

友情链接：