Android 高度自定义的粒子框架（支持普通View和surfaceView）

最新推荐文章于 2021-10-06 13:14:33 发布
最新推荐文章于 2021-10-06 13:14:33 发布
阅读量347 收藏
点赞数
分类专栏： android UI
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/wkk_ly/article/details/105712099
版权
android 同时被 2 个专栏收录
28 篇文章 0 订阅
订阅专栏
UI
6 篇文章 0 订阅
订阅专栏

序言

当前Android 主流的系统中粒子的实现方式大致可以分为两类三种

  1. 继承普通的View，主线程刷新绘制
  2. 使用surfaceView，子线程刷新绘制
  3. 使用surfaceView+openGl，子线程刷新绘制

因为第三种方式不是很常用，这里使用前两种方式实现粒子

效果图（视频转GIf有点卡）

在这里插入图片描述

实现功能

  1. 可以自定义粒子刷新的频率，每次刷新的数量
  2. 粒子自己维护自己的生命周期
  3. 可以预先自己定义的粒子数量加载粒子 避免一加载就是满屏粒子的尴尬
  4. 复用消亡粒子
  5. 实现粒子的高度自定义 避免过度封装

理论概述

两种实现方式 对粒子的处理大致相同 不同的是绘制的位置区别
这里以第一种方式为例 画出粒子的UML框架：
在这里插入图片描述
如上图所示

ParticleView继承Runnable 使用handler定时刷新，每次刷新进行以下一个步骤

  1. 新增粒子 从cacheItems集合中获取缓存粒子 如果没有则调用adapter进行创建
  2. 调用transForms 移动粒子并将消亡粒子移除绘制集合中
  3. 调用drawItems方法绘制所有的粒子

使用

这里因为是高度资质粒子，所以如果我们想要绘制粒子需要首先继承BaseItem接口定义自己的粒子类：
然后实现适配器ParticleAdapter
如：

   particle.setAdapter(object : ParticleAdapter() {
        override fun newItem(parentWidth: Int, parentHeight: Int): BaseItem {
			//返回自己实现的粒子
            return BubbleItem(parentWidth, parentHeight, this@MainActivity)
        }

        override fun preCreateCount(): Int {
            return 50
        }

    })
    particle.setIncreaseParticleInterval(100)
    particle.setRenderTime(16)
    particle.setIncreaseParticleCount(1)

我这里实现的粒子如下：BubbleItem.kotlin

class BubbleItem(private val parentWidth: Int, private val parentHeight: Int,context: Context) :
BaseItem {

companion object {
    const val STATE_LIVE = 1
    const val STATE_DIE = 0
}
private val baseBubbleRadius = ScreenUtil.dip2px(context,2f)
private val intervalBubbleRadius = ScreenUtil.dip2px(context,3f)

//起点
private var origX: Float = 0f
private var origY: Float = parentHeight.toFloat()

//终点
private var desY: Float = 0f
//当前的位置
private var curX = 0f
private var curY = 0f

//每次刷新 在Y轴的偏移量
private var speedY = ScreenUtil.dip2px(context,2f)
private val baseSpeedX =ScreenUtil.dip2px(context,0.5f)
//每次刷新 在X轴的偏移量
private var speedX = 0f

var radius = 20f
//透明的距离
private var alphaDis = 0f
var state = STATE_DIE
private val paint = Paint(Paint.ANTI_ALIAS_FLAG)

private var drawBitmap: Bitmap? = null
private var resRect: Rect? = null

init {
    paint.style = Paint.Style.FILL_AND_STROKE
    paint.color = Color.BLUE
}

/**
 * 初始化 随机生成气泡的出生地点
 */
override fun init(context: Context) {
    //获取气泡的bitmap
    if (drawBitmap == null) {
        drawBitmap = BitmapFactory.decodeResource(context.resources, R.drawable.bubble)
        resRect = Rect(0, 0, drawBitmap?.width ?: 0, drawBitmap?.height ?: 0)
    }
    origX = Random.nextInt(100, parentWidth - 100).toFloat()
    desY = 2 * parentHeight / 3 - Random.nextInt(0, parentHeight / 2).toFloat()
    alphaDis = (origY - desY) * 0.2f
    radius = Random.nextFloat() * intervalBubbleRadius + baseBubbleRadius
    speedX = baseSpeedX * Random.nextFloat() * if (Random.nextBoolean()) {
        1
    } else {
        -1
    }
    curX = origX
    curY = origY
    state = STATE_LIVE
    //在边界处的粒子 没有横向速度
    if (curX <= 200 || curX > (parentWidth - 200)) {
        speedX = 0f
    }
    paint.alpha = 255
}

override fun preInit(context: Context) {
    //起点的X轴坐标
    init(context)
    curY = desY + max((origY - desY) * Random.nextFloat(), 0f)
}

override fun move(): Boolean {
    curY -= speedY
    curX += speedX
    val diff = curY - desY
    if (diff <= alphaDis) {
        if (diff <= alphaDis * 0.4 && diff >=0.3 * alphaDis) {
            paint.alpha = 255
        } else {
            //开始透明
            paint.alpha = (255 * diff / alphaDis + 0.5f).toInt()
        }
    }
    if (curY < desY) {
        state = STATE_DIE
        return false
    }
    if (curX <= 20 || curX >= parentWidth - 20) {
        state = STATE_DIE
        return false
    }
    return true
}


override fun reset() {

}

override fun draw(canvas: Canvas) {
    drawBitmap?.apply {
        if (!isRecycled) {
            canvas.drawBitmap(this, resRect, RectF(curX - radius, curY - radius, curX + radius, curY + radius), paint)
        }
    }

}

override fun isLive(): Boolean {
    return state == STATE_LIVE
}


override fun destroy() {
    drawBitmap?.recycle()
    drawBitmap = null
}
}

使用普通View 主线程刷新绘制

普通的View绘制就是 使用handler主线程绘制刷新实现如下：

class ParticleView(context: Context, attributeSet: AttributeSet) : View(context, attributeSet),
BaseParticle, Runnable {
private var particleAdapter: ParticleAdapter? = null
private var isAutoPlay = true
private var intervalTime = 10 * Constant.RENDER_TIME
private var renderTime = Constant.RENDER_TIME
private var increaseParticleCount = 1
private var childTotal = Int.MAX_VALUE
private var temTime = -1


//缓存的view
private var cacheItems = LinkedList<BaseItem>()
//要绘制的所有View
private var drawItems = ArrayList<BaseItem>()

private var renderHandler: Handler = Handler()

private var isInit: Boolean = false

override fun preCreate() {
    repeat(particleAdapter?.preCreateCount() ?: 0) {
        val newItem = particleAdapter!!.newItem(measuredWidth, measuredHeight)
        newItem.preInit(context)
        drawItems.add(newItem)
    }
}

override fun getItem(): BaseItem {
    val newItem = if (cacheItems.size > 0) {
        cacheItems.removeFirst()
    } else {
        particleAdapter!!.newItem(measuredWidth, measuredHeight)
    }
    newItem.init(context)
    return newItem
}

override fun drawItems(canvas: Canvas) {
    if (drawItems.size < childTotal) {
        if (temTime == -1) {
            temTime = ((intervalTime / renderTime.toFloat() + 0.5).toInt())
        } else if (temTime == 0) {
            repeat(increaseParticleCount) {
                drawItems.add(getItem())
            }
        }
        temTime--
    }
    drawItems.forEach {
        it.draw(canvas)
    }
}

override fun transForms() {
    val iterator = drawItems.iterator()
    while (iterator.hasNext()) {
        val next = iterator.next()
        val isLive = next.move()
        if (!isLive) {
            iterator.remove()
            cacheItems.add(next)
        }
    }
}

override fun destroyAllView() {
    drawItems.forEach {
        it.destroy()
    }
    cacheItems.forEach {
        it.destroy()
    }
}

override fun startAnimation() {
    renderHandler.removeCallbacks(this)
    renderHandler.post(this)
}

override fun stopAnimation() {
    renderHandler.removeCallbacks(this)
}

override fun setAdapter(adapter: ParticleAdapter) {
    particleAdapter = adapter
    if (particleAdapter!!.maxParticleCount() <= 0) {
        return
    }
    childTotal = particleAdapter!!.maxParticleCount()
}

override fun setRenderTime(renderTime: Long) {
    if (intervalTime < renderTime || renderTime < 0) {
        return
    }
    this.renderTime = renderTime
}

override fun setIncreaseParticleInterval(intervalTime: Long) {
    if (intervalTime < renderTime || renderTime < 0) {
        return
    }
    this.intervalTime = intervalTime
}

override fun setIncreaseParticleCount(count: Int) {
    if (count <= 0) {
        return
    }
    increaseParticleCount = count
}

override fun setIsAutoPlay(isAuto: Boolean) {
    isAutoPlay = isAuto
}

/**
 * 设置大小则按照设置的大小计算 否则按照屏幕的宽高来计算
 */
override fun onMeasure(widthMeasureSpec: Int, heightMeasureSpec: Int) {
    //获取屏幕宽高
    val screenWidth = ScreenUtil.getScreenWidth(context)
    val screenHeight = ScreenUtil.getScreenRealHeight(context)
    setMeasuredDimension(
        getDefaultSize(screenWidth, widthMeasureSpec),
        getDefaultSize(screenHeight, screenHeight)
    )
}

override fun onLayout(changed: Boolean, left: Int, top: Int, right: Int, bottom: Int) {
    super.onLayout(changed, left, top, right, bottom)
    if (!isInit) {
        isInit = true
        preCreate()
    }
}

override fun onDraw(canvas: Canvas?) {
    if (visibility != VISIBLE) {
        return
    }
    if (canvas == null) {
        renderHandler.removeCallbacks(this)
        return
    }
    drawItems(canvas)
}

override fun run() {
    transForms()
    invalidate()
    renderHandler.postDelayed(this, renderTime)
}

override fun setVisibility(visibility: Int) {
    super.setVisibility(visibility)
    if (isAutoPlay) {
        if (visibility == VISIBLE) {
            startAnimation()
        } else {
            renderHandler.removeCallbacksAndMessages(null)
        }
    }
}


override fun onDetachedFromWindow() {
    super.onDetachedFromWindow()
    renderHandler.removeCallbacks(this)
}

override fun onAttachedToWindow() {
    super.onAttachedToWindow()
    renderHandler.post(this)
}


}

使用surfaceView，子线程刷新绘制

实现如下：

class ParticleSurfaceView(context: Context, attributeSet: AttributeSet) :
SurfaceView(context, attributeSet), BaseParticle, SurfaceHolder.Callback, Runnable {

private var particleAdapter: ParticleAdapter? = null
private var isAutoPlay = true
private var intervalTime = 10 * Constant.RENDER_TIME
private var renderTime = Constant.RENDER_TIME
private var increaseParticleCount = 1
private var childTotal = Int.MAX_VALUE
private var temTime = -1

private val surfaceHolder: SurfaceHolder = holder
private lateinit var handlerThread: HandlerThread
private lateinit var renderHandler: Handler

//缓存的view
private var cacheItems = LinkedList<BaseItem>()
//要绘制的所有View
private var drawItems = ArrayList<BaseItem>()

init {
    surfaceHolder.setKeepScreenOn(true)
    surfaceHolder.addCallback(this)
    isFocusable = true
    isFocusableInTouchMode = true
    setZOrderOnTop(true)
    //设置背景为透明色
    surfaceHolder.setFormat(PixelFormat.TRANSPARENT)
}

override fun preCreate() {
    repeat(particleAdapter?.preCreateCount() ?: 0) {
        val newItem = particleAdapter!!.newItem(measuredWidth, measuredHeight)
        newItem.preInit(context)
        drawItems.add(newItem)
    }
}

override fun getItem(): BaseItem {
    val newItem = if (cacheItems.size > 0) {
        cacheItems.removeFirst()
    } else {
        particleAdapter!!.newItem(measuredWidth, measuredHeight)
    }
    newItem.init(context)
    return newItem
}

override fun drawItems(canvas: Canvas) {
    if (drawItems.size < childTotal) {
        if (temTime == -1) {
            temTime = ((intervalTime / renderTime.toFloat() + 0.5).toInt())
        } else if (temTime == 0) {
            repeat(increaseParticleCount) {
                drawItems.add(getItem())
            }
        }
        temTime--
    }
    drawItems.forEach {
        it.draw(canvas)
    }
}

override fun transForms() {
    val iterator = drawItems.iterator()
    while (iterator.hasNext()) {
        val next = iterator.next()
        val isLive = next.move()
        if (!isLive) {
            iterator.remove()
            cacheItems.add(next)
        }
    }
}

override fun destroyAllView() {
    drawItems.forEach {
        it.destroy()
    }
    cacheItems.forEach {
        it.destroy()
    }
}

override fun startAnimation() {
    renderHandler.removeCallbacks(this)
    renderHandler.post(this)
}

override fun stopAnimation() {
    renderHandler.removeCallbacks(this)
}

override fun setAdapter(adapter: ParticleAdapter) {
    particleAdapter = adapter
    if (particleAdapter!!.maxParticleCount() <= 0) {
        return
    }
    childTotal = particleAdapter!!.maxParticleCount()
}

override fun setRenderTime(renderTime: Long) {
    if (intervalTime < renderTime || renderTime < 0) {
        return
    }
    this.renderTime = renderTime
}

override fun setIncreaseParticleInterval(intervalTime: Long) {
    if (intervalTime < renderTime || renderTime < 0) {
        return
    }
    this.intervalTime = intervalTime
}

override fun setIncreaseParticleCount(count: Int) {
    if (count <= 0) {
        return
    }
    increaseParticleCount = count
}

override fun setIsAutoPlay(isAuto: Boolean) {
    isAutoPlay = isAuto
}

override fun surfaceChanged(holder: SurfaceHolder?, format: Int, width: Int, height: Int) {
}

override fun surfaceDestroyed(holder: SurfaceHolder?) {
    renderHandler.removeCallbacks(this)
    destroyAllView()
}

override fun surfaceCreated(holder: SurfaceHolder?) {
    if (particleAdapter == null) {
        throw NullPointerException("particleAdapter must not be null")
    }
    handlerThread = HandlerThread("BaseSurfaceView")
    handlerThread.start()
    renderHandler = Handler(handlerThread.looper)
    preCreate()
    if (isAutoPlay) {
        renderHandler.post(this)
    }
}

override fun run() {
    transForms()
    val lockCanvas = surfaceHolder.lockCanvas(null)
    lockCanvas.drawColor(Color.TRANSPARENT, PorterDuff.Mode.CLEAR)
    drawItems(lockCanvas)
    surfaceHolder.unlockCanvasAndPost(lockCanvas)
    renderHandler.postDelayed(this, renderTime)
}
}

项目地址:项目地址传送门 点我 点我 点我!!!

wkk_ly
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
android 粒子动画,使用animator实现粒子动画效果
weixin_39700215的博客
05-25 1345
1、前言本文围绕着实现粒子放大效果，着重讲解android中涉及到动画缩放以及动画集的使用，并且会将讲解一些插值器相关的知识。阅读本文需要读者有一定的自定义View的基础知识，本文将不再讲解自定义View的相关知识，读者需要可以自行去学习，也可以阅读笔者的文章，自定义View的基本知识。2、着色器为了让效果的色彩比较的绚丽，需要让粒子(这里其实就是用小圆点代替)有一个色彩的过渡，所以需要用到着色器...
Android粒子系统
未来~超越自己
01-03 1491
一、粒子属性 粒子图片，粒子大小，粒子缩放比例，粒子位置（X,Y），粒子移动方向与速度（X,Y坐标与时间t的关系） 计算粒子所处位置，绘制渲染 粒子系统，是大量基础图元构成的具有一定规律的不规律渲染图像。即要够成粒子系统，需要有基本图元，保持基本图元的一定规律性，并细化不规律性。 一个基本图元即是粒子系统中展示的一个粒子，有以下基本属性：粒子纹理【图片】，粒子的大小，粒子缩放，粒子
android 粒子爆炸特效
weixin_45253393的博客
06-23 1513
先上图： 这是一个高级UI特效，是个动画。 完成这个动画只要3步： 1、控件完成振动效果动画。 2、控件振动动画完成后消失，然后将控件转换成Bitmap. 3、Bitmap完成粒子爆炸特效。 其实完成粒子爆炸特效的并不是控件View本身，而是Bitmap，将Bitmap分割成多个小球，小球在x轴上随机地左右晃动，在y轴上径直下落就行了。 代码介绍： Particle: public abstr...
Android 自定义SurfaceView详解
09-01
本文主要介绍Android SurfaceView自定义方法，这里对SurfaceView的基础知识做了详解，并附简单的示例代码，以便参考，有需要的小伙伴可以参考下
android 矢量粒子动画,android 手摸手教你用 Canvas 实现简单粒子动画
weixin_29798025的博客
05-25 293
ArticleAttributesnameformatdescription中文解释pv_host_textstringset left host text设置左边主文案pv_host_text_sizedimensionset host text size设置主文案的大小pv_particle_textstringset right particle text设置右边粒子上的文案pv_parti...
android-粒子系统
03-26
android 粒子系统 android游戏开发大全
Android-一个用于Android的轻量级粒子动画库
08-13
一个用于Android的轻量级粒子动画库
Android制作粒子爆炸特效
热门推荐
crazychen的专栏
12-02 3万+
简介最近在闲逛的时候，发现了一款粒子爆炸特效的控件，觉得比较有意思，效果也不错。 但是代码不好扩展，也就是说如果要提供不同的爆炸效果，需要修改的地方比较多。于是我对源代码进行了一些重构，将爆炸流程和粒子运动分离。 对于源码，大家可以参考以下链接 链接1 链接2上面两套代码，其实结构都是一样的，但是实现的效果不同(其实就是粒子运动的算法不同)。 本篇文章，将给大家介绍粒子爆炸特效的实现方式，
Android粒子系统库——DroidParticle
sunty2016的博客
06-25 3223
今天给大家介绍一款粒子系统库，并简要介绍下粒子系统的工作原理。 首先这款名为DroidParticle的库其实就是我自己没事做的，因为以前看过HGE的C++的粒子系统，觉得很有趣，现在从事Android开发工作就模仿着做了一个，希望对大家有用处。 先给大家看一下效果： 源代码下载地址： https://github.com/sunty2016/DroidParticle 下面
Android OpenGL ES2.0粒子系统
08-15
Android OpenGL ES2.0粒子系统，包含了VBO的使用方法，用时间来做参数传递给顶点shader，让shader根据时间变换，从而改变当前绘制点的位子，从而形成粒子流
Android 粒子效果之雨（自定义View）
01-13
Android 自定义 View 基础和原理实现 1.绘制下雨场景的个体、雨点（直线） 2.让直线动起来 3.处理边界问题 4.构造雨点对象 5.雨点大小设置 6.速度设置和角度设置等 7.添加多个雨点 8.抽离可以在 XML 中影响的属性
ParticleAndroid:用Java编写的Android粒子系统
05-23
安卓 === 用Java编写的Android粒子系统。 演示视频记录： 介绍 目标 我们想要提供一个基于JAVA的轻量级粒子系统，以便快速轻松地集成到Android项目中。 特征 支持两种发射器模式：“重力”和“半径”。 从plist格式为cocos2d创建粒子系统。 plist文件的嵌入式纹理资源（PNG / JPEG / BMP，但不支持TIFF格式）。 混合模式。 开始吧 集成ParticleSystemView ParticleSystemView是androd.view.View的子类，它负责管理粒子发射器的生命周期。 可以直接创建它，也可以从布局文件中添加它： 通过代码创建ParticleSystemView // Create ParticleSystemView by code: ParticleSystemView particleSyste
OpenGL实现的烟花粒子系统（Android）
10-27
Android上用OpenGL实现的烟花粒子系统，非常漂亮，欢迎大家交流。还有一个VC平台实现的，在我的资源列表里可以找到。 我这个程序是在模拟器里写的，所以，运行的时候可能需要调整一下slowdown、y方向的初始速度和加速度才能看到较好的效果。
Android-Particles:在Android应用中像粒子动画一样实现Particle.js
05-14
Android粒子 在Android应用中像粒子动画一样实现Particle.js
Android中SurfaceView和view画出触摸轨迹
09-02
主要介绍了Android中SurfaceView和view画出触摸轨迹的相关资料,需要的朋友可以参考下
Android自定义SurfaceView实现画板功能
01-05
接触了这么久的View，总不能一直停留在View里，现在开始呢，就要学习一个新的知识点：SurfaceView，实际上SurfaceView与View的原理都差不多，只是效率和渲染方式上，SurfaceView要优于View，这也是我们写这个的原因...
Android显示系统之View与SurfaceView更新屏幕的区别
01-31
AccessibilityEventSourcejava.lang.Objectandroid.view.ViewAnalogClock,ImageView,KeyboardView,MediaRouteButton,ProgressBar,Space,SurfaceView,TextView,TextureView,ViewGroup,ViewStuAbsListView,AbsSeekBar,...
Android超强大的粒子动画库，流星雨，爆炸，满屏飞花，等粒子特效快速实现
mymolit的博客
03-16 2万+
因为公司项目，需要做粒子动画的特效，找了很多资料，偶然间在github上发现了一个比较强大的粒子特效动画leonids，分享给大家。Leonids是一个与标准Android UI配合使用的粒子系统库。该库非常轻巧，LeonidsLib.jar只有81Kb。流星雨效果爆炸效果涟漪效果飞花效果首先我们把库引进来，方式非常简单，目前最新版本是1.3.2的 compile 'com.plattysoft....
Android自定义View高级动效---粒子动效实现|音乐播放器粒子动效|实现酷我网易云粒子动效
qq_38237224的博客
10-06 1461
篇章目标介绍 之前看到网易云，酷我音乐都发布过用于播放器页面粒子动效的效果，于是打算自己也动手做一个，产品目标是对标酷我手机app的动效设计，实现过程完全基于自身的推测理解予以实现。计划通过两次完全完成这个项目，第一篇文章重点介绍粒子动效实现的核心问题和完成效果的主要代码介绍；计划在第二篇文章针对粒子动效的资源占用进行优化和完善UI展示效果。本文是第一篇文章 粒子动效核心问题 粒子动效的是需要模拟太阳光扩散的效果，要体现粒子运动的规律和源源不断的粒子发散的效果。要达成目标，重点需要认识以下4个问题 问题1：
android surfaceview 技术,Android中SurfaceView的理解和使用
最新发布
05-30
Android中的SurfaceView是一个可以在自己的线程中绘制UI的控件，通常用于实现游戏、视频播放等需要高性能绘制的场景。相较于普通的View，SurfaceView的绘制是在一个独立的缓冲区中进行的，这个缓冲区可以在后台线程中进行绘制，然后在主线程中进行显示，这样可以确保UI的流畅性和性能。 使用SurfaceView的步骤如下： 1.定义SurfaceView 在布局文件中定义SurfaceView，例如： ``` <android.view.SurfaceView android:id="@+id/surface_view" android:layout_width="match_parent" android:layout_height="match_parent" /> ``` 2.获取SurfaceHolder 在Activity或者Fragment中获取SurfaceView的SurfaceHolder对象，用于控制SurfaceView的绘制： ``` SurfaceView surfaceView = findViewById(R.id.surface_view); SurfaceHolder holder = surfaceView.getHolder(); ``` 3.实现SurfaceHolder.Callback接口 实现SurfaceHolder.Callback接口，它包含三个方法：surfaceCreated、surfaceChanged和surfaceDestroyed。其中，surfaceCreated在SurfaceView创建时调用，surfaceChanged在SurfaceView绘制区域大小发生变化时调用，surfaceDestroyed在SurfaceView销毁时调用。在这些方法中，我们可以进行SurfaceView的初始化、绘制、销毁等操作。 ``` holder.addCallback(new SurfaceHolder.Callback() { @Override public void surfaceCreated(SurfaceHolder holder) { // 初始化SurfaceView } @Override public void surfaceChanged(SurfaceHolder holder, int format, int width, int height) { // SurfaceView绘制区域大小发生变化 } @Override public void surfaceDestroyed(SurfaceHolder holder) { // 销毁SurfaceView } }); ``` 4.在后台线程中进行绘制 在surfaceCreated方法中，我们可以启动一个后台线程，用于进行SurfaceView的绘制。在这个线程中，我们可以使用Canvas对象进行绘制。在绘制完成后，我们需要调用SurfaceHolder的lockCanvas方法获取到Canvas对象，然后进行绘制，最后调用SurfaceHolder的unlockCanvasAndPost方法提交绘制结果。 ``` Thread drawThread = new Thread(new Runnable() { @Override public void run() { while (true) { Canvas canvas = holder.lockCanvas(); // 绘制操作 holder.unlockCanvasAndPost(canvas); } } }); drawThread.start(); ``` 5.在主线程中更新UI 在surfaceChanged和surfaceDestroyed方法中，我们需要在主线程中更新UI，例如修改控件的可见性、修改控件的属性等操作。可以使用runOnUiThread方法或者Handler来实现。 ``` runOnUiThread(new Runnable() { @Override public void run() { // 在主线程中更新UI } }); ```

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值