这次要把抖音网红文字时钟设置为壁纸了~

<wallpaper xmlns:android="http://schemas.android.com/apk/res/android" />

class TextClockWallpaperService : WallpaperService() {

    override fun onCreateEngine(): Engine {
        return MyEngine()
    }

    inner class MyEngine : Engine() {
        /**
         * 准备画笔
         */
        private val mPaint = Paint().apply {
            this.color = Color.RED
            this.isAntiAlias = true
            this.textSize = 60f
            this.textAlign = Paint.Align.CENTER
        }

        /**
         * Called to inform you of the wallpaper becoming visible or
         * hidden.  <em>It is very important that a wallpaper only use
         * CPU while it is visible.</em>.
         *
         * 当壁纸显示或隐藏时会回调该方法。
         * 很重要的一点是，要只在壁纸显示的时候做绘制操作（占用CPU）。
         */
        override fun onVisibilityChanged(visible: Boolean) {
            super.onVisibilityChanged(visible)
            Log.d("clock", "onVisibilityChanged >>> $visible")

            //只在壁纸显示的做绘制操作，这很重要！
            if (visible) {
                surfaceHolder.lockCanvas()?.let { canvas ->
                    //将原点移动到画布中心
                    canvas.save()
                    canvas.translate((canvas.width / 2).toFloat(), (canvas.height / 2).toFloat())

                    //绘制文字
                    canvas.drawText("Hong Kong is part of China!", 0f, 0f, mPaint)

                    canvas.restore()
                    surfaceHolder.unlockCanvasAndPost(canvas)
                }
            }
        }
    }
}

<!--动态壁纸服务-->
<service
    android:name=".view.TextClockWallpaperService"
    android:permission="android.permission.BIND_WALLPAPER">
    <intent-filter>
        <action android:name="android.service.wallpaper.WallpaperService" />
    </intent-filter>
    <meta-data
        android:name="android.service.wallpaper"
        android:resource="@xml/text_clock_wallpaper" />
</service>

btnSet.setOnClickListener {
    val intent = Intent().apply {
        action = WallpaperManager.ACTION_CHANGE_LIVE_WALLPAPER
        putExtra(
            WallpaperManager.EXTRA_LIVE_WALLPAPER_COMPONENT,
            ComponentName(
                context,
                TextClockWallpaperService::class.java
            )
        )
    }
    startActivity(intent)
}

//示例代码
<?xml version="1.0" encoding="utf-8"?>
<wallpaper xmlns:android="http://schemas.android.com/apk/res/android"
    android:description="@string/description"
    android:settingsActivity="me.erwa.xxx.SettingsActivity"
    android:thumbnail="@mipmap/ic_launcher">
</wallpaper>

/**
 * 必须实现并返回一个壁纸引擎的新实例。
 * 注意同一时间可能有多个实例在运行，比如当前壁纸正在运行时，用户在挑选壁纸页面浏览该壁纸的预览画面。
 */
public abstract Engine onCreateEngine();

/**
 * 壁纸的实际实现。一个壁纸服务可能有多个实例在运行（例如一个是真实的壁纸和一个处于预览的壁纸），
 * 每个壁纸都只能由其相应的引擎实例来做实现。
 * 你必须实现{@link WallpaperService#onCreateEngine()}并返回你创建的引擎的实例。
 */
public class Engine {
    ...省略代码
}

inner class MyEngine : Engine() {

    override fun onCreate(surfaceHolder: SurfaceHolder?) {
        super.onCreate(surfaceHolder)
        Log.d("clock", "onCreate")
    }

    override fun onSurfaceCreated(holder: SurfaceHolder?) {
        super.onSurfaceCreated(holder)
        Log.d("clock", "onSurfaceCreated")
    }

    override fun onSurfaceChanged(holder: SurfaceHolder?, format: Int, width: Int, height: Int) {
        super.onSurfaceChanged(holder, format, width, height)
        Log.d("clock", "onSurfaceChanged")
    }

    /**
     * Called to inform you of the wallpaper becoming visible or
     * hidden.  <em>It is very important that a wallpaper only use
     * CPU while it is visible.</em>.
     *
     * 当壁纸显示或隐藏是会回调该方法。
     * 很重要的一点是，要只在壁纸显示的时候做绘制操作（占用CPU）。
     */
    override fun onVisibilityChanged(visible: Boolean) {
        super.onVisibilityChanged(visible)
        Log.d("clock", "onVisibilityChanged >>> $visible")
    }

    override fun onSurfaceDestroyed(holder: SurfaceHolder?) {
        super.onSurfaceDestroyed(holder)
        Log.d("clock", "onSurfaceDestroyed")
    }

    override fun onDestroy() {
        super.onDestroy()
        Log.d("clock", "onDestroy")
    }

}

/**
 * 提供对绘制壁纸时实际Surface（表面）的访问
 */
public SurfaceHolder getSurfaceHolder() {
    return mSurfaceHolder;
}

/**
 * 开始在Surface上编辑像素。这个返回的画布可以用来在Surface的位图上绘制。如果Surface还没创建或者不能被编辑会返回null。
 * 一般情况下，你需要通过实现{@link Callback#surfaceCreated Callback.surfaceCreated}这个方法，
 * 来得知surface什么时候可用。
 *
 * Surface的内容在unlockCanvas()和lockCanvas()之间是不会保存的，因此，Surface区域必须写入每个像素。
 * 这个规则有个例外就是指定一个特殊的脏矩形区域，这种情况下，非脏区域的像素才会被保存。
 *
 * 如果你在Surface创建前或销毁后重复调用该方法，为了避免占用CPU，你的调用将被限制为慢速率。

 * 如果返回值不为null，该方法内部持有锁，直到相应的{@link #unlockCanvasAndPost}方法被调用，并会防止Surface
 * 在绘制时被创建、销毁或修改。这样比直接访问Surface更方便，因为你不需要在{@link Callback#surfaceDestroyed
 * Callback.surfaceDestroyed}和绘制线程中做特殊的同步。
  * 返回一个用来绘制到Surface上的画布
 */
public Canvas lockCanvas();

/**
 * 完成Surface上像素的编辑。该方法调用完，Surface上的像素将会展示到屏幕上，但是它的内容会丢失，
 * 尤其再次调用lockCanvas()时也不能保证它的内容不会变动。
 *
 * 参数需传入之前lockCanvas()返回的画布
 */
public void unlockCanvasAndPost(Canvas canvas);

/**
 * 初始化宽高，供动态壁纸使用
 */
fun initWidthHeight(width: Float, height: Float) {
    if (this.mWidth < 0) {
        this.mWidth = width
        this.mHeight = height

        mHourR = mWidth * 0.143f
        mMinuteR = mWidth * 0.35f
        mSecondR = mWidth * 0.35f
    }
}

/**
 * 开始绘制
 */
fun doInvalidate(block: (() -> Unit)? = null) {
    this.mBlock = block

    Calendar.getInstance().run {
        ...省略代码
        mAnimator.addUpdateListener {
            ...省略代码
            if ([email protected] != null) {
                [email protected]?.invoke()
            } else {
                invalidate()
            }
        }
        mAnimator.start()
    }
}

/**
 * 停止后续绘制，供动态壁纸使用
 */
fun stopInvalidate() {
    mAnimator.removeAllUpdateListeners()
}

inner class MyEngine : Engine() {
    private val mClockView = TextClockView([email protected])
    private val mHandler = Handler()
    private var mTimer: Timer? = null
    ...省略代码
}

override fun onVisibilityChanged(visible: Boolean) {
    super.onVisibilityChanged(visible)
    Log.d("clock", "onVisibilityChanged >>> $visible")
    if (visible) {
        startClock()
    } else {
        stopClock()
    }
}

/**
 * 开始绘制
 */
private fun startClock() {
    if (mTimer != null) return

    mTimer = timer(period = 1000) {
        mHandler.post {
            mClockView.doInvalidate {
                if (mTimer != null && surfaceHolder != null) {
                    surfaceHolder.lockCanvas()?.let { canvas ->
                        mClockView.initWidthHeight(canvas.width.toFloat(), canvas.height.toFloat())
                        mClockView.draw(canvas)
                        surfaceHolder.unlockCanvasAndPost(canvas)
                    }
                }
            }
        }
    }
}

/**
 * 停止绘制
 */
private fun stopClock() {
    mTimer?.cancel()
    mTimer = null
    mClockView.stopInvalidate()
}