App端SurfaceView控件绘制流程
SurfaceView,VideoView,GlSurfaceView 中的Surface如何应用
JAVA层：
SurfaceView系列控件与其他View绘制存在很大的差别。有自己的Surface,其他View是共享一个Surface
1.最基本的SurfaceView
SurfaceView.java
public class SurfaceView extends View {
//绘图表面
final Surface mSurface = new Surface();
//wms中Session代表，跟ViewRootImpl中的一样
IWindowSession mSession;
MyWindow mWindow;
private void updateWindow(boolean force, boolean redrawNeeded) {
//创建一个surface
mSession.relayout(
mWindow, mWindow.mSeq, mLayout, mWidth, mHeight,
visible ? VISIBLE : GONE,
WindowManagerGlobal.RELAYOUT_DEFER_SURFACE_DESTROY,
mWinFrame, mOverscanInsets, mContentInsets,
mVisibleInsets, mConfiguration,
mNewSurface);
if (mSurfaceCreated && (surfaceChanged || (!visible && visibleChanged))) {
//释放以前的，以前已经创建过，可见性改变了，隐藏
mSurfaceCreated = false;
SurfaceHolder.Callback.surfaceDestroyed(mSurfaceHolder);
}
//把mNewSurface的NativeObject拷贝到mSurface中
mSurface.transferFrom(mNewSurface);
if (!mSurfaceCreated ...) {//当新创建见surface时候回调，通知创建了新的surface了，可以在这个surface上干活了
SurfaceHolder.Callback.surfaceCreated(mSurfaceHolder);
}
if (sizeChanged ...) {//当大小，格式，等一些属性改变后，回调
SurfaceHolder.Callback.SurfaceChanged(mSurfaceHolder, mFormat, myWidth, myHeight);
}
}
SurfaceView的绘制的核心就是SurfaceHolder几个回调，
1.创建新的surface
2.surface属性改变
3.释放surface
private final SurfaceHolder mSurfaceHolder = new SurfaceHolder(){
//看名字就是跟ViewRootImpl中Surface用的一样了
public Canvas lockCanvas() {
return internalLockCanvas(null);
}
private final Canvas internalLockCanvas(Rect dirty) {
Canvas c = null;
c = mSurface.lockCanvas(dirty);
return null;
}
public void unlockCanvasAndPost(Canvas canvas) {
mSurface.unlockCanvasAndPost(canvas);
mSurfaceLock.unlock();
}
//这个就是SurfaceView创建的Surface，绘制都在这上面
public Surface getSurface() {
return mSurface;
}
}
SurfaceHolder的lock，unlock都是包转了一下Surface，都是在Surface基础上干活的。
封装的没有View其他类那么严实，获取到Surface后（通过回调SurfaceHolder.Callback），
可以在其他线程操作Surface了，不影响主线程的工作
SurfaceView的使用
SurfaceView.getHolder().addCallback(new Callback() {
@Override
public void surfaceDestroyed(SurfaceHolder holder) {
}
@Override
public void surfaceCreated(SurfaceHolder holder) {
通过holder可以获取到surface了，
可以启动一个线程直接直接用Surface或 Canvas
这个Canvas也是包装了Surface,需要lock,unlock
Canvas canvas = holder.lockCanvas();
holder.unlockCanvasAndPost(canvas);
}
@Override
public void surfaceChanged(SurfaceHolder holder, int format,
int width, int height) {
}
});
总结：SurfaceView就是吧Surface的创建，更改等封装好了，使用者只要操作SurfaceHolder就可以了，
通过注册回调
2. VideoView继承SurfaceView,看一下他的Surface怎么用的
class VideoView extends SurfaceView
private void initVideoView() {
getHolder().addCallback(mSHCallback); //注册一个自己处理的回调
getHolder().setType(SurfaceHolder.SURFACE_TYPE_PUSH_BUFFERS);
}
SurfaceHolder.Callback mSHCallback = new SurfaceHolder.Callback()
{
public void surfaceChanged(SurfaceHolder holder, int format,
int w, int h)
{ //播放
start();
}
public void surfaceCreated(SurfaceHolder holder)
{ //初始化video
openVideo();
}
}
//调用了mediaplyer的start
public void start() {
mMediaPlayer.start();
}
private void openVideo() {
mMediaPlayer = new MediaPlayer();
//把holder传给了mediaPlayer了
mMediaPlayer.setDisplay(mSurfaceHolder);
}
Mediaplayer.java
public class MediaPlayer｛
static {
System.loadLibrary("media_jni");
native_init();
}
private native void _setVideoSurface(Surface surface);
public void setDisplay(SurfaceHolder sh) {
mSurfaceHolder = sh;
Surface surface= sh.getSurface();
//把surface取出来，设置给native层了
_setVideoSurface(surface);
}
这个很显然了Java层Surface包装了一个C++的Surface结构,底层直接用surface了,用ANativeWindow(GL)或者Producer
jni层，
android_media_MediaPlayer.cpp
{"
_setVideoSurface", "(Landroid/view/Surface;)V", (void *)android_media_MediaPlayer_setVideoSurface},
static void android_media_MediaPlayer_setVideoSurface(JNIEnv *env, jobject thiz, jobject jsurface)
{
setVideoSurface(env, thiz, jsurface, true);
}
setVideoSurface(JNIEnv *env, jobject thiz, jobject jsurface, jboolean mediaPlayerMustBeAlive)
{
//获取c++层mediaplayer
sp<MediaPlayer> mp = getMediaPlayer(env, thiz);
//通过surface获取IGraphicBufferProducer
sp<IGraphicBufferProducer> new_st;
sp<Surface> surface(android_view_Surface_getSurface(env, jsurface));
new_st = surface->getIGraphicBufferProducer();
//把producer传给mediapalyer了，通过producer直接操作图像缓冲区了
mp->setVideoSurfaceTexture(new_st);
}
Mediaplayer不看了，日后再分析
3. GLSurfaceView 直接在app端使用openGl绘制的
GLSurfaceView.java
public class GLSurfaceView extends SurfaceView implements SurfaceHolder.Callback {
直接都继承Holder.Callback了
构造函数中就init
private void init() {//很直接的注册回调
SurfaceHolder holder = getHolder();
holder.addCallback(this);
}
//看名字都直接转到gl绘制线程中了
public void surfaceCreated(SurfaceHolder holder) {
mGLThread.surfaceCreated();
}
public void surfaceDestroyed(SurfaceHolder holder) {
mGLThread.surfaceDestroyed();
}
public void surfaceChanged(SurfaceHolder holder, int format, int w, int h) {
mGLThread.onWindowResize(w, h);
}
static class GLThread extends Thread {
//都一样的逻辑，设置一个变量，马上通知notifyAll一下，肯定绘制线程等待则获取surface,然后再等待绘制线程干完活
public void surfaceCreated() {
//设置变量，通知更改
mHasSurface = true;
mFinishedCreatingEglSurface = false;
sGLThreadManager.notifyAll();
//等待响应完成
while (mWaitingForSurface&& !mFinishedCreatingEglSurface && !mExited) {
sGLThreadManager.wait();
}
}
}
//这个跟上个函数一样的
public void surfaceDestroyed() {
mHasSurface = false;
sGLThreadManager.notifyAll();
while((!mWaitingForSurface) && (!mExited)) {
sGLThreadManager.wait();
}
}
}
@Override
public void run() {
guardedRun();
}
private void guardedRun(){
while(true){
if (mEglHelper.createSurface()) {//创建完成eglsurface通知surfaceCreated等待的地方
synchronized(sGLThreadManager) {
mFinishedCreatingEglSurface = true;
sGLThreadManager.notifyAll();
}
}
{//调用外部设置的render开始绘制
GLSurfaceView view = mGLSurfaceViewWeakRef.get();
if (view != null) {
view.mRenderer.onDrawFrame(gl);
}
}
//绘制完成提交后台缓冲区
int swapError = mEglHelper.swap();
}
｝
mEglHelper怎么创建EGlSurface的
private static class EglHelper｛
public void start() {//初始化egl环境
mEgl = (EGL10) EGLContext.getEGL(); //这个下面会用到
mEglDisplay = mEgl.eglGetDisplay(EGL10.EGL_DEFAULT_DISPLAY);
mEgl.eglInitialize(mEglDisplay, version)
mEglConfig = view.mEGLConfigChooser.chooseConfig(mEgl, mEglDisplay);
mEglContext = view.mEGLContextFactory.createContext(mEgl, mEglDisplay, mEglConfig)
}
// view.getHolder()设置进去，创建EglSurface ,都是标准的用法
public boolean
createSurface() {
GLSurfaceView view = mGLSurfaceViewWeakRef.get();
mEglSurface = view
.mEGLWindowSurfaceFactory.createWindowSurface(mEgl, mEglDisplay, mEglConfig, view.getHolder());
mEgl.eglMakeCurrent(mEglDisplay, mEglSurface, mEglSurface, mEglContext)
}
GlsurfaceView中
if (mEGLWindowSurfaceFactory == null) {
mEGLWindowSurfaceFactory = new DefaultWindowSurfaceFactory();
}
//还是用的egl
private static class DefaultWindowSurfaceFactory implements EGLWindowSurfaceFactory {
public EGLSurface createWindowSurface(EGL10 egl, EGLDisplay display,
EGLConfig config, Object nativeWindow) {
EGLSurface result = null;
//又回到上面的egl了
result =
egl.eglCreateWindowSurface(display, config, nativeWindow, null);
}
//这是当前的egl
EGLContext.java
public abstract class EGLContext
{
private static final EGL EGL_INSTANCE =
new com.google.android.gles_jni.EGLImpl();
public static EGL getEGL() {
return EGL_INSTANCE;
}
}
EGLImpl.java
public class EGLImpl implements EGL10 {
private
native int _eglCreateWindowSurface(EGLDisplay display, EGLConfig config, Object native_window, int[] attrib_list);
//native_window支持好几个类型的
public EGLSurface eglCreateWindowSurface(EGLDisplay display, EGLConfig config, Object native_window, int[] attrib_list) {
Surface sur = null;
//如果是surfaceholder则获取出他的surface
} else if (native_window instanceof SurfaceHolder) {
SurfaceHolder holder = (SurfaceHolder)native_window;
sur = holder.getSurface();
}
//native创建 一个eglSurface(c++层)
int eglSurfaceId =
_eglCreateWindowSurface(display, config, sur, attrib_list);
//包装到java中
return new EGLSurfaceImpl( eglSurfaceId );
}
JNI层创建EglSurface
android_opengl_EGL14.cpp
static jobject
android_eglCreateWindowSurface
(JNIEnv *_env, jobject _this, jobject dpy, jobject config, jobject win, jintArray attrib_list_ref, jint offset) {
//通过java层Surface(win)获取c++层的ANativeWindow , 其实就是c++层的Surface
// class Surface: public ANativeWindow
android::sp<ANativeWindow> window=android::android_view_Surface_getNativeWindow(_env, win);
//调用c++层eglapi创建EglSurface
_returnValue = eglCreateWindowSurface( (EGLDisplay)dpy_native, (EGLConfig)config_native, (EGLNativeWindowType)window.get(), (EGLint *)attrib_list
);
总结：
为了提高绘制效率增加了SurfaceView系列，可以不在主线程中绘制。
基本的SurfaceView是把Surface包装成Canvas，提供了跟普通控件一样的绘制方式。
VideoView 把Surface（IGraphicBufferProducer）给了底层，底层直接进行绘制，上层就不需要关心绘制了
GlSurfaceView 把Surface(ANativeWindow) 通过Egl包装成EglSurface，上层通过OpenglEs进行3d绘制