精华内容
下载资源
问答
  • surfaceView和View区别

    2016-04-05 16:13:47
    surfaceView和View最本质的区别在于:  --------------------------------------------------------------------------------------------------- surfaceView是在一个新起的单独线程中可以重新  绘制画面,而...
    surfaceView和View最本质的区别在于: 
    ---------------------------------------------------------------------------------------------------
    surfaceView是在一个新起的单独线程中可以重新 
    绘制画面,而View必须在UI的主线程中更新画面。那么在UI的主线程中更新画面可能会引发 
    问题,比如你更新画面的时间过长,那么你的主UI线程会被你正在画的函数阻塞。 那么将无
    法响应按键,触屏等消息。当使用surfaceView 由于是在新的线程中更新画面所以不会阻塞
    你搜索的UI主线程。但这也带来了另外一个问题 ,就是事件同步。比如你触屏了一下,你需
    要surfaceView中 thread处理,一般就需要有一个event queue的设计来保存touchevent,
    这会稍稍复杂一点,因为涉及到线程同步。  


    所以基于以上,根据游戏特点,一般分成 两类。 
    ----------------------------------------------------------------------------------------------------
    1 被动更新画面的。比如棋类,这种用view就好了。因为画面的更新是依赖于 onTouch 来更
    新,可以直接使用 invalidate。 因为这种情况下,这一次Touch和下一次的Touch需要的时间
    比较长些,不会产生影响。  
    2 主动更新。比如一个人在一直跑动。这就需要一个单独的thread不停的重绘人的状态,避免
    阻 塞main UI thread。所以显然view不合适,需要surfaceView来控制。


    SurfaceView简介  
    ----------------------------------------------------------------------------------------------------
    在一般的情况 下,应用程序的View都是在相同的GUI线程中绘制的。这个主应用程序线程同时
    也用来处理所 有的用户交互(例如,按钮单击或者文本输入)。我们已经学习了如何把容易阻塞的 
    处理移动到后台线程中。遗憾的是,对于一个View的onDraw方法,不能这样做,因为从后台线
    程 修改一个GUI元素会被显式地禁止的。当需要快速地更新View的UI,或者当渲染代码阻塞 GUI
    线程的时间过长的时候,SurfaceView就是解决上述问题的最佳选择。 


    SurfaceView封装了一个Surface对象,而不是Canvas。这一点很重要,因为Surface可以使用后 
    台线程绘制。对于那些资源敏感的 操作,或者那些要求快速更新或者高速帧率的地方,例如,使
    用3D图形,创建游戏,或者实时预览摄像头,这一点特别有用。独立于GUI线程进行绘图的代价
    是额外的内存消耗,所以,虽然它是创建定制的View的有效方式--有时甚至是必须的,但是使用
    SurfaceView的时候仍然要保持谨慎。


    1. 何时应该使用SurfaceView?
    SurfaceView使用的方式与任何View所派生的类都是完全相同 的。可以像其他View那样应用动画
    ,并把它们放到布局中。SurfaceView封装的Surface支持使用所有标准Canvas方法进行绘图,同
    时也支持完全的OpenGL ES库。使用OpenGL,你可以再Surface上绘制任何支持的2D或者3D对象
    ,与在2D画布上模拟 相同的效果相比,这种方法可以依靠硬件加速(可用的时候)来极大地提高性能。
    对于显示动态的3D图像来说,例如,那些使用Google Earth功能的应用程序,或者那些提供沉浸体
    验的交互式游戏,SurfaceView特别有用。它还是 实时显示摄像头预览的最佳选择。
    2. 创建一个新的SurfaceView控件  
    要创建一个新的SurfaceView,需要创建一个新的扩展了SurfaceView的类,并实现SurfaceHolder.Callback。
    SurfaceHolder回调可以在底层的Surface被创建和销毁的时候通知View,并传递给它对SurfaceHolder
    对象的引用,其中包含了当 前有效的Surface。一个典型的SurfaceView设计模型包括一个由Thread
    所派生的类,它可以接收对当前的SurfaceHolder的引用,并独 立地更新它。
    展开全文
  • SurfaceView View 区别

    千次阅读 2013-09-09 23:15:36
    android.view.View android.view.SurfaceView SurfaceView 是从 View 基类中派生出来的显示类,直接子类有 GLSurfaceViewVideoView ,可以 看出 GL 视频播放以及 Camera 摄像头一般均使用 SurfaceView ...

    android.view.View 和 android.view.SurfaceView

    SurfaceView 是从 View 基类中派生出来的显示类,直接子类有 GLSurfaceView和VideoView ,可以
    看出 GL 和视频播放以及 Camera 摄像头一般均使用 SurfaceView

    View获得焦点:setFocusable(true);

    在继承view中,因为onDraw方法是系统自动调用的,不像在surfaceview这里这样去在run里面自己去不断调用,在view中我们可以抵用 invalidate()/postInvalidate() 这两种方法实现让系统调用onDraw方法,这里也是和surfaceview中的不同之一!

    SurfaceView和View最本质的区别

    surfaceView 是在一个新起的单独线程中可以重新绘制画面而 View 必须在 UI 的主线程中更新画面。

    SurfaceView 和 View 用处
    1 被动更新画面的。比如棋类,这种用view就好了。因为画面的更新是依赖于 onTouch 来更新,可以直接使用 invalidate。 因为这种情况下,这一次Touch和下一次的Touch需要的时间比较长些,不会产生影响。 

    2 主动更新。比如一个人在一直跑动。这就需要一个单独的thread不停的重绘人的状态,避免阻塞main UI thread。所以显然view不合适,需要surfaceView来控制。

     

    3.Android中的SurfaceView类就是双缓冲机制。因此,开发游戏时尽量使用SurfaceView而不要使用View,这样的话效率较高,而且SurfaceView的功能也更加完善。

     

     考虑以上几点,所以我一直都选用 SurfaceView 来进行游戏开发。


    SurfaceView 优势

    SurfaceView 可以控制表面的格式,比如大小,显示在屏幕中的位置,最关键是的提供了 SurfaceHolder 类,使用 getHolder 方法获取,相关有
    Canvas lockCanvas(),  Canvas lockCanvas(Rect dirty) 、void removeCallback(SurfaceHolder.Callback callback)、void unlockCanvasAndPost(Canvas canvas) 控制图形以及绘制,而在SurfaceHolder.Callback 接口回调中可以通过重写下面方法实现。 

    使用的SurfaceView的时候,一般情况下要对其进行创建,销毁,改变时的情况进行监视,这就要用到 SurfaceHolder.Callback. 
    class XxxView extends SurfaceView implements SurfaceHolder.Callback { 

    public void surfaceChanged(SurfaceHolder holder,int format,int width,int height){} 
    //看其名知其义,在surface的大小发生改变时激发 
    public void surfaceCreated(SurfaceHolder holder){} 
    //同上,在创建时激发,一般在这里调用画图的线程。 
    public void surfaceDestroyed(SurfaceHolder holder) {} 
    //同上,销毁时激发,一般在这里将画图的线程停止、释放。 



    对于Surface相关的,Android底层还提供了 GPU 加速功能,所以一般实时性很强的应用中主要使用 SurfaceView 而不是直接从 View 构建,同时后来做 android 3d OpenGL 中的 GLSurfaceView 也是从该类实现。 

    surfaceview 的结构


    备注1

    callback接口:

         只要继承SurfaceView类并实现SurfaceHolder.Callback接口就可以实现一个自定义的SurfaceView了,SurfaceHolder.Callback在底层的Surface状态发生变化的时候通知View,SurfaceHolder.Callback具有如下的接口:

    •  surfaceCreated(SurfaceHolder holder):当Surface第一次创建后会立即调用该函数。程序可以在该函数中做些和绘制界面相关的初始化工作,一般情况下都是在另外的线程来绘制界面,所以不要在这个函数中绘制Surface。
    •  surfaceChanged(SurfaceHolder holder, int format, int width,int height):当Surface的状态(大小和格式)发生变化的时候会调用该函数,在surfaceCreated调用后该函数至少会被调用一次。

    SurfaceHolder 类:

    它是一个用于控制surface的接口,它提供了控制surface 的大小,格式,上面的像素,即监视其改变的。 

    SurfaceView的getHolder()函数可以获取SurfaceHolder对象,Surface 就在SurfaceHolder对象内。虽然Surface保存了当前窗口的像素数据,但是在使用过程中是不直接和Surface打交道的,由SurfaceHolder的Canvas lockCanvas()或则Canvas lockCanvas()函数来获取Canvas对象,通过在Canvas上绘制内容来修改Surface中的数据。如果Surface不可编辑或则尚未创建调用该函数会返回null,在 unlockCanvas() 和 lockCanvas()中Surface的内容是不缓存的,所以需要完全重绘Surface的内容,为了提高效率只重绘变化的部分则可以调用lockCanvas(Rect rect)函数来指定一个rect区域,这样该区域外的内容会缓存起来。在调用lockCanvas函数获取Canvas后,SurfaceView会获取Surface的一个同步锁直到调用unlockCanvasAndPost(Canvas canvas)函数才释放该锁,这里的同步机制保证在Surface绘制过程中不会被改变(被摧毁、修改)。

     

    // 备注2

    我没有在该surfaceview的初始化函数中将其 ScreenW 与 ScreenH 进行赋值,这里要特别注意,如果你在初始化调用ScreenW = this.getWidth();和ScreenH = this.getHeight();那么你将得到很失望的值 全部为0;原因是和接口Callback接口机制有关,当我们继承callback接口会重写它的surfaceChanged()、surfaceCreated()、surfaceDestroyed(),这几个函数当surfaceCreated()被执行的时候,真正的view才被创建,也就是说之前得到的值为0 ,是因为初始化会在surfaceCreated()方法执行以前执行,view没有的时候我们去取屏幕宽高肯定是0,所以这里要注意这一点;


    //备注3

     

    这里我把draw的代码都try起来,主要是为了当画的内容中一旦抛出异常了,那么我们也能 在finally中执行该操作。这样当代码抛出异常的时候不会导致Surface出去不一致的状态。   

     

     

     其实这就是一个简单的游戏架构了,当然还少了按键处理,声音播放等等,这些我后续会写出相关的学习文章。对于surfaceview的介绍差不多就介绍到这里了,其中的理解是看了别人的文章和自己的理解、当然可能理解的会有些偏差,但是我想不会太离谱 呵呵。



    展开全文
  • SurfaceView和View区别

    2012-12-21 15:30:23
    SurfaceView和View最本质的区别在于,surfaceView是在一个新起的单独线程中可以重新绘制画面而View必须在UI的主线程中更新画面。 那么在UI的主线程中更新画面 可能会引发问题,比如你更新画面的时间过长,那么你的...
    SurfaceView和View最本质的区别在于,surfaceView是在一个新起的单独线程中可以重新绘制画面而View必须在UI的主线程中更新画面。
    那么在UI的主线程中更新画面 可能会引发问题,比如你更新画面的时间过长,那么你的主UI线程会被你正在画的函数阻塞。那么将无法响应按键,触屏等消息。

    当使用surfaceView 由于是在新的线程中更新画面所以不会阻塞你的UI主线程。但这也带来了另外一个问题,就是事件同步。比如你触屏了一下,你需要surfaceView中thread处理,一般就需要有一个event queue的设计来保存touch event,这会稍稍复杂一点,因为涉及到线程同步。

    所以基于以上,根据游戏特点,一般分成两类。

    1 被动更新画面的。比如棋类,这种用view就好了。因为画面的更新是依赖于 onTouch 来更新,可以直接使用 invalidate。 因为这种情况下,这一次Touch和下一次的Touch需要的时间比较长些,不会产生影响。

    2 主动更新。比如一个人在一直跑动。这就需要一个单独的thread不停的重绘人的状态,避免阻塞main UI thread。所以显然view不合适,需要surfaceView来控制
    展开全文
  • 一、View简介 View一般在onDraw方法里面绘图,onDraw在UI主线程执行。onDraw默认只在View初始化的时候调用一遍,所以View不会自动刷新画面,一般要调用invalidate或者postInvalidate来重新执行onDraw里面的代码进行...

    一、View简介

    View一般在onDraw方法里面绘图,onDrawUI主线程执行。onDraw默认只在View初始化的时候调用一遍,所以View不会自动刷新画面,一般要调用invalidate或者postInvalidate来重新执行onDraw里面的代码进行刷新画面。UI主线程一般用来渲染组件、处理组件与用户之间的交互事件,比如说按钮的点击事件、文本框的输入事件。如果你的画图任务相当繁重,那么onDraw方法里面的代码要执行好长一段时间,就可能会造成UI主线程阻塞。比如,如果在绘图的同时,用户刚好点击了某个按钮,那UI主线程会怎么处理点击事件呢?肯定是在绘图完毕后再处理点击事件,因为onDraw方法跟按钮点击事件处理都是在UI主线程内操作的。这样就给用户造成按钮点击延时处理的坏体验。

    绘图原理:


     

    主线程绘图代码和效果:

    protected void onDraw(Canvas canvas) {
    // 初始化画笔
    Paint paint = new Paint();
    // 设置抗锯齿, 文字清晰点, 不过相对比较耗性能
    paint.setAntiAlias(true);
    // 设置画笔颜色为红色
    paint.setColor(Color.RED);
    // 设置文字大小
    paint.setTextSize(50);
    // 画文字, 所画的内容都会缓存到Surface中
    canvas.drawText("ITCAST", 100, 100, paint);
    }
    
     
    //既然在主线程内绘图可能会造成线程阻塞,那我们可不可以在onDraw里面开启一个新线程进行绘图呢?
    //在后台线程绘图代码和效果:
    protected void onDraw(final Canvas canvas) {
    new Thread(){
    public void run() {
    // 初始化画笔
    Paint paint = new Paint();
    // 设置抗锯齿, 文字清晰点, 不过相对比较耗性能
    paint.setAntiAlias(true);
    // 设置画笔颜色为红色
    paint.setColor(Color.RED);
    // 设置文字大小
    paint.setTextSize(50);
    // 画文字, 所画的内容都会缓存到Surface中
    canvas.drawText("ITCAST", 100, 100, paint);
    }
    }.start();
    }
    绘图效果:


     

    可以发现屏幕上并没有显示任何文字,说明绘图不成功,因为android只允许在UI主线程内改变UI界面,绘图完毕后渲染到屏幕上的实质就是改变UI界面。

     

    二、 SurfaceView简介

    SurfaceView也可以在onDraw方法里面绘图,即直接在UI主线程绘图并渲染,因为SurfaceViewView的子类。上面已经介绍,绘图完毕后只能在UI主线程内渲染到屏幕上。为了不阻塞主线程,我们可以考虑采取这样的方案:在后台线程执行繁重的绘图任务,把所绘制的东西缓存起来;绘图完毕后,再回到UI主线程,一次性把所绘制的东西渲染到屏幕上。(本质就是后台线程绘图,UI主线程渲染)

    只使用ViewonDraw方法是无法实现这种方案的,而SurfaceView可以实现这种方案。

    先看看SurfaceView的工作原理图:


     

    首先,可以确定的2点:1.使用Canvas对象进行绘图2.一定是在主线内渲染屏幕。由图可以看出,Canvas在后台线程绘制的东西先缓存到Surface中,然后让Surface回到UI主线程渲染到屏幕上。因此,要有Surface对象存在,才能够在屏幕上显示东西。顺着下面的问题来了解SurfaceView的整个工作原理。

    1Surface是什么?

    SurfaceSurfaceView里面的一个成员变量,它的创建和销毁过程都是自动的。Surface里面有个Canvas成员变量,将来我们就是要得到这个Canvas对象进行绘图。不过只能通过SurfaceHolder对象来控制和访问SurfaceSurface的主要作用是缓存Canvas绘制的东西,并渲染到屏幕上。

    2SurfaceHolder对象怎么获取?

    使用SurfaceViewgetHolder()

    3)在什么时候开启后台绘图线程?

    最好在Surface被创建的时候,开启绘图线程。因为没有Surface,绘制再多的东西也无法渲染到屏幕上。

    4)在什么时候销毁后台绘图线程?

    最好在Surface被销毁的时候,销毁绘图线程。因为没有Surface,绘制再多的东西也无法渲染到屏幕上。

    5) 既然要在创建Surface时开启绘图线程,在销毁Surface时销毁绘图线程。那我们怎么知道Surface在什么时候创建,什么时候销毁呢?

    那就需要监听Surface的生命周期,使用SurfaceHolder对象的addCallback()来添加Surface的生命周期监听器——SurfaceHolder.Callback

    Callback里面对应的方法

    //Surface的大小发生改变时调用

    public void surfaceChanged(SurfaceHolder holder,int format,int width,int height){}

    //Surface创建时调用,一般在这里开启绘图线程

    public void surfaceCreated(SurfaceHolder holder){}

    //Surface销毁时调用,一般在这里销毁绘图线程

    public void surfaceDestroyed(SurfaceHolder holder) {}

     

    再来看看如果搭建SurfaceView的游戏开发框架

    1> 新建一个继承SurfaceView的类——GameView

     

    2> 得到SurfaceHolder对象,并监听Surface的生命周期

    SurfaceHolder holder;
    public GameView(Context context) {
    super(context);
    // 获取SurfaceHolder对象
    holder = getHolder();
    // 监听Surface的生命周期
    holder.addCallback(this);
    }


    可以看到addCallback传的参数是this,所以GameView必须实现Callback接口

    public class GameView extends SurfaceView implements Callback

    实现相应的方法

    /**
     * Surface的大小发生改变时调用
     */
    public void surfaceChanged(SurfaceHolder holder, int format, int width, int height) {}
    /**
     * Surface创建时调用,一般在这里开启绘图线程
     */
    public void surfaceCreated(SurfaceHolder holder) {}
    /**
     * Surface销毁时调用,一般在这里销毁绘图线程
     */
    public void surfaceDestroyed(SurfaceHolder holder) {}


     

    3> 开启绘图线程、销毁绘图线程

    先保留一个线程成员变量

    /**
    * 绘图线程
    */
    Thread thread;
    /**
     * Surface的大小发生改变时调用
     */
    public void surfaceChanged(SurfaceHolder holder, int format, int width,int height) {}
    /**
     * Surface创建时调用,一般在这里开启绘图线程
     */
    public void surfaceCreated(SurfaceHolder holder) {
    // 开启绘图线程
    thread = new Thread(this);
    thread.start();
    }
    /**
     * Surface销毁时调用,一般在这里销毁绘图线程
     */
    public void surfaceDestroyed(SurfaceHolder holder) {
    if (thread != null && thread.isAlive()) {
    try {
    // 销毁绘图线程
    thread.join();
    } catch (InterruptedException e) {
    e.printStackTrace();
    }
    }
    }
    Thread里面传的是this,所以GameView必须实现Runnable接口
    public class GameView extends SurfaceView implements Callback, Runnable
    实现run方法
    /**
     * 这是后台绘图线程, 在这里得到Surface中Canvas进行绘图
     */
    public void run() {}


     

    4> run方法中尝试进行绘图

    public void run() {
    // 通过Holder对象获得Surface的Canvas成员变量
    Canvas canvas = holder.lockCanvas();
    // 初始化画笔
    Paint paint = new Paint();
    // 设置抗锯齿, 文字清晰点, 不过相对比较耗性能
    paint.setAntiAlias(true);
    // 设置画笔颜色为红色
    paint.setColor(Color.RED);
    // 设置文字大小
    paint.setTextSize(50);
    // 画文字, 所画的内容都会缓存到Surface中
    canvas.drawText("ITCAST", 100, 100, paint);
    // 画完之后, 再将缓存的东西渲染到屏幕上
    holder.unlockCanvasAndPost(canvas);
    }


    效果:

     

    虽然可以画东西了,但是我们都知道,这个run方法只执行一遍,画一次就没了。我们游戏中一般都是不断地刷新屏幕,所以我们应该循环调用那段绘图代码进行刷新屏幕。我们尝试让文字动起来,就改变它的y值吧。

     

    5> 动态刷新屏幕

    先搞个循环标记

    /**
     * 是否正在绘图
     */
    boolean running;
    在开启绘图线程前改变循环标记
    /**
     * Surface创建时调用,一般在这里开启绘图线程
     */
    public void surfaceCreated(SurfaceHolder holder) {
    // 开启绘图线程
    running = true;
    thread = new Thread(this);
    thread.start();
    }
    /**
     * Surface销毁时调用,一般在这里销毁绘图线程
     */
    public void surfaceDestroyed(SurfaceHolder holder) {
    // 改变循环标记
    running = false;
    if (thread != null && thread.isAlive()) {
    try {
    // 销毁绘图线程
    thread.join();
    } catch (InterruptedException e) {
    e.printStackTrace();
    }
    }
    }


    接下来循环绘图,让文字从上到下移动

    int y = 0;
    public void run() {
       while (running) {
    // 通过Holder对象获得Surface的Canvas成员变量
    Canvas canvas = holder.lockCanvas();
    // 先清理屏幕
    canvas.drawColor(Color.BLACK);
    // 初始化画笔
    Paint paint = new Paint();
    // 设置抗锯齿, 文字清晰点, 不过相对比较耗性能
    paint.setAntiAlias(true);
    // 设置画笔颜色为红色
    paint.setColor(Color.RED);
    // 设置文字大小
    paint.setTextSize(50);
    // 画文字, 所画的内容都会缓存到Surface中
    canvas.drawText("ITCAST", 100, y++, paint);
    // 画完之后, 再将缓存的东西渲染到屏幕上
    holder.unlockCanvasAndPost(canvas);
    }
    }


    这里需要注意的是,每次绘图前都要先清理屏幕canvas.drawColor(Color.BLACK);

    .

    6> 改善下代码

    public void run() {
    // 把Canvas放在外面提高性能,不必每次都定义这个变量
    Canvas canvas = null;
    // 将成员变量转为局部变量,也是提高性能
    SurfaceHolder holder = this.holder;
    while(running) {
    // 由于涉及到多线程,这个对象最好同步
    synchronized (holder) {
    // 画完后最好一定释放Canvas,渲染屏幕,避免内存泄露,所以用try-finally
    try {
    // 通过Holder对象获得Surface的Canvas成员变量
    canvas = holder.lockCanvas();
    // 在这里进行绘图
    render(canvas);
    // 画完之后可以适当暂停,没必要持续画,人的眼睛有一定的反应时间
    Thread.sleep(100);
    } catch (InterruptedException e) {
    e.printStackTrace();
    } finally {
    // 严谨起见,最好判断canvas是否为null,不然unlockCanvasAndPost(null)会抛异常
    if (canvas != null) {
    // 画完之后, 再将缓存的东西渲染到屏幕上
    holder.unlockCanvasAndPost(canvas);
    }
    }
    }
    }
    }
    int y = 0;
    /**
     * 绘图逻辑
     */
    public void render(Canvas canvas) {
    // 先清理屏幕
    canvas.drawColor(Color.BLACK);
    // 初始化画笔
    Paint paint = new Paint();
    // 设置抗锯齿, 文字清晰点, 不过相对比较耗性能
    paint.setAntiAlias(true);
    // 设置画笔颜色为红色
    paint.setColor(Color.RED);
    // 设置文字大小
    paint.setTextSize(50);
    // 画文字, 所画的内容都会缓存到Surface中
    canvas.drawText("ITCAST", 100, y++, paint);
    }


     

    这就是整个SurfaceView的游戏框架

     

    三、ViewSurfaceView对比

    View:必须在UI的主线程中更新画面,用于被动更新画面

    surfaceViewUI线程和子线程中都可以。在一个新启动的线程中重新绘制画面,主动更新画面。

    展开全文
  • surfaceView和View区别

    2020-02-18 11:08:31
    SurfaceView和普通view的区别及简单使用 SurfaceView 与view区别详解 一、SurfaceView原理: 在Android系统中,有一种特殊的视图,称为SurfaceView,它拥有独立的绘图表面,即它不与其宿主窗口共享同一个绘图表面,...
  • SurfaceView和View区别

    2019-09-30 11:20:57
    SurfaceView是从View基类中派生出来的显示类,他和View区别有: View需要在UI线程对画面进行刷新,而SurfaceView可在子线程进行页面的刷新,View适用于主动更新的情况,View频繁刷新会阻塞主线程,导致界面卡顿 ...
  • Surfaceview和view区别

    千次阅读 2016-08-10 21:54:15
    Surfaceview是视图(view)的一个继承类,这个视图里内嵌了一个专门用于绘制的Surface。你可以控制这个这个Surface的格式尺寸,Surfaceview控制这个Surface的绘制位置。 SurfaceView的目的是提供给应用一个额外...
  • SurfaceView和View最本质的区别在于,surfaceView是在一个新起的单独线程中可以重新绘制画面,而View 必须在UI的主线程中更新画面(onDraw方法是在UI线程中执行的)。 那么在UI的主线程中更新画面 可能会引发问题,...
  • SurfaceView View区别

    千次阅读 2010-07-14 17:16:00
    SurfaceView和View最本质的区别在于,surfaceView是在一个新起的单独线程中可以重新绘制画面而View必须在UI的主线程中更新画面。 那么在UI的主线程中更新画面 可能会引发问题,比如你更新画面的时间过长,那么你的...
  • surfaceView和View最本质的区别在于: surfaceView是在一个新起的单独线程中可以重新绘制画面,而View必须在UI的主线程中更新画面。那么在UI的主线程中更新画面 可能会引发问题
  • SurfaceView和View最本质的区别在于,surfaceView是在一个新起的单独线程中可以重新绘制画面而View必须在UI的主线程中更新画面。 那么在UI的主线程中更新画面 可能会引发问题,比如你更新画面的时间过长,那么你的...
  • 总结 特点 适用环境 surfaceView 在一个新起的单独线程中可以重新绘制画面 ...主动更新(比如一个人在一直跑动) ...surfaceView和View最本质的区别在于: surfaceView和View最本质的区别
  • 如果你的游戏不吃CPU,用View就比较好,符合标准Android操作方式,由系统决定刷新surface的时机。  但如果很不幸的,你做不到不让你的程序吃CPU,你就只好使用SurfaceView来强制刷新surface了,不然系统的UI进程很...

空空如也

空空如也

1 2 3 4 5 ... 15
收藏数 284
精华内容 113
关键字:

surfaceview和view区别