如今市面上APP的输入框可以说是千奇百怪，不搞点花样出来貌似代表格局没打开。还在使用系统自带的输入框的兄弟可以停下脚步，哥带你实现一个简易的带边框输入框。

话不多说，直接上图：

要实现这个效果，不得不再回顾下自定义View的流程，感兴趣的童鞋可以自行网上搜索，这里只提及该效果涉及到的内容。总体实现大致流程：

• 继承AppCompatEditText


• 配置可定义的资源属性


• onDraw() 方法的重写

首先还得分析：效果图中最多只能输入6个数字，需要计算出每个文字的宽高和间隙，再分别绘制文字背景和文字本身。从中我们需要提取背景颜色、高度、边距等私有属性，通过新建attrs.xml文件进行配置：

<declare-styleable name="RoundRectEditText">

    <attr name="count" format="integer"/>

    <attr name="itemPading" format="dimension"/>

    <attr name="strokeHight" format="dimension"/>

    <attr name="strokeColor" format="color"/>/>

</declare-styleable>

这样在初始化的时候即可给你默认值：

val typedArray =context.obtainStyledAttributes(it, R.styleable.RoundRectEditText)

count = typedArray.getInt(R.styleable.RoundRectEditText_count, count)

itemPading = typedArray.getDimension(R.styleable.RoundRectEditText_itemPading,0f)

strokeHight = typedArray.getDimension(R.styleable.RoundRectEditText_strokeHight,0f)

strokeColor = typedArray.getColor(R.styleable.RoundRectEditText_strokeColor,strokeColor)

typedArray.recycle()

接下来便是重头戏，如何绘制文字和背景色。思路其实很简单，通过for循环去遍历绘制每一个数字。关键点还在于去计算每个文字的位置及宽高，只要得到了位置和宽高，绘制背景和绘制文字易如反掌。

获取每个文字宽度：

strokeWith =(width.toFloat() - paddingLeft.toFloat() - paddingRight.toFloat() - (count - 1) * itemPading) / count

文字居中需要计算出对应Y值：

val fontMetrics = paint.fontMetrics

val textHeight = fontMetrics.bottom - fontMetrics.top

val distance = textHeight / 2 - fontMetrics.bottom

val baseline = height / 2f + distance

文字的X值则根据当前index和文字宽度以及各边距得出：

private fun getIndexOfX(index: Int): Float {

    return paddingLeft.toFloat() + index * (itemPading + strokeWith) + 0.5f * strokeWith

}

得到了位置，宽高接下来的步骤再简单不过了。使用drawText 绘制文字，使用drawRoundRect 绘制背景。这里有一个细节一定要注意，绘制背景一定要在绘制文字之前，否则背景会把文字给覆盖。

另外，还需要注意一点。如果onDraw方法中不注释掉超类方法，底部会多出一段输入的数字。其实很好理解，这是AppCompatEditText 自身绘制的数字，所以我们把它注释即可，包括光标也是一样。如果想要光标则需要自己在onDraw方法中绘制即可。

//隐藏自带光标

super.setCursorVisible(false)



override fun onDraw(canvas: Canvas) {

        //不注释掉会显示在最底部

//        super.onDraw(canvas)

          ......

}

以上便是实现带边框的输入框的全部类型，希望对大家有所帮助！

探索EdgeEffect的花样玩法

1、EdgeEffect是什么

当用户在一个可滑动的控件内（如RecyclerView），滑动内容已经超过了内容边界时，RecyclerView通过EdgeEffect绘制一个边界图形来提醒用户，滑动已经到边界了，不要再滑动啦。

简言之：就是通过边界图形来提醒用户，没啥内容了，别滑了。

2、EdgeEffect在RecyclerView的现象是什么

1、到达边界后的阴影效果

在RecyclerView列表中，滑动到边界还继续滑动或者快速滑动到边界，则现象如下图中的到达边界后产生的阴影效果。

2、如何去掉阴影效果

在布局中，可以设置overScrollMode的属性值为never即可。

或者在代码中设置，即可取消

recyclerView?.overScrollMode = View.OVER_SCROLL_NEVER

3、EdgeEffect在RecyclerView的实现原理是什么

1、onMove事件对应EdgeEffect的onPull

EdgeEffect在RecyclerView中大致流程可以参考下面这个图，以onMove事件举例

通过上面这个图，并结合下面的源码，就能对这个流程有个大致的理解。

@Override

public boolean onTouchEvent(MotionEvent e) {

    ...

    switch (action) {

       ...

        case MotionEvent.ACTION_MOVE: {

          ...

          // (1) move事件

                if (scrollByInternal(

                        canScrollHorizontally ? dx : 0,

                        canScrollVertically ? dy : 0,

                        e, TYPE_TOUCH)) {

                    getParent().requestDisallowInterceptTouchEvent(true);

                }

               ...

            }

        }

        break;

     }

 }

 

 

boolean scrollByInternal(int x, int y, MotionEvent ev, int type) {

  ...

     // （2）判断是否设置了过度滑动，所以通过布局设置overScrollMode的属性值为never就走不进了分支逻辑中了

    if (getOverScrollMode() != View.OVER_SCROLL_NEVER) {

        if (ev != null && !MotionEventCompat.isFromSource(ev, InputDevice.SOURCE_MOUSE)) {

            pullGlows(ev.getX(), unconsumedX, ev.getY(), unconsumedY);

        }

        considerReleasingGlowsOnScroll(x, y);

    }

   ...

   

    if (!awakenScrollBars()) {

        // 刷新当前界面

        invalidate();

    }

    return consumedNestedScroll || consumedX != 0 || consumedY != 0;

}



private void pullGlows(float x, float overscrollX, float y, float overscrollY) {

    boolean invalidate = false;

   ...

   // 顶部边界

    if (overscrollY < 0) {

        // 构建顶部边界的EdgeEffect对象

        ensureTopGlow();

        // 调用EdgeEffect的onPull方法 设置些属性

        EdgeEffectCompat.onPull(mTopGlow, -overscrollY / getHeight(), x / getWidth());

        invalidate = true;

    } 

    ...



    if (invalidate || overscrollX != 0 || overscrollY != 0) {

        // 刷新界面

        ViewCompat.postInvalidateOnAnimation(this);

    }

}



void ensureTopGlow() {

   ...

    mTopGlow = mEdgeEffectFactory.createEdgeEffect(this, EdgeEffectFactory.DIRECTION_TOP);

    // 设置边界图形的大小

    if (mClipToPadding) {

        mTopGlow.setSize(getMeasuredWidth() - getPaddingLeft() - getPaddingRight(),

                getMeasuredHeight() - getPaddingTop() - getPaddingBottom());

    } else {

        mTopGlow.setSize(getMeasuredWidth(), getMeasuredHeight());

    }



}



// RecyclerView的绘制

@Override

public void draw(Canvas c) {

    super.draw(c);

    ...

    if (mTopGlow != null && !mTopGlow.isFinished()) {

        final int restore = c.save();

        if (mClipToPadding) {

            c.translate(getPaddingLeft(), getPaddingTop());

        }

        // 调用 EdgeEffect的draw方法

        needsInvalidate |= mTopGlow != null && mTopGlow.draw(c);

        c.restoreToCount(restore);

    }

    ...

}



// EdgeEffect的draw方法

public boolean draw(Canvas canvas) {

   ...

    update();

    final int count = canvas.save();

    final float centerX = mBounds.centerX();

    final float centerY = mBounds.height() - mRadius;

   

    canvas.scale(1.f, Math.min(mGlowScaleY, 1.f) * mBaseGlowScale, centerX, 0);



    final float displacement = Math.max(0, Math.min(mDisplacement, 1.f)) - 0.5f;

    float translateX = mBounds.width() * displacement / 2;



    canvas.clipRect(mBounds);

    canvas.translate(translateX, 0);

    mPaint.setAlpha((int) (0xff * mGlowAlpha));

    // 绘制扇弧

    canvas.drawCircle(centerX, centerY, mRadius, mPaint);

    canvas.restoreToCount(count);

        ...

同理：RecyclerView的 up 及Cancel事件对应调用EdgeEffect的onRelease；fling过度滑动对应EdgeEffect的onAbsorb方法

2、EdgeEffect的onPull、onRelease、onAbsorb方法

（1）onPull

对于RecyclerView列表而言，内容已经在顶部到达边界了，此时用户仍向下滑动时，会调用onPull方法及后续流畅，来更新当前视图，提示用户已经到边界了。

（2）onRelease

对于（1）的情况，用户松开了，不向下滑动了，此时释放拉动的距离，并刷新界面消失当前的图形界面。

（3）onAbsorb

用户过度滑动时，RecyclerView调用Fling方法，把内容到达边界后消耗不掉的距离传递给onAbsorb方法，让其显示图形界面提示用户已到达内容边界。

4、使用EdgeEffect在RecyclerView中实现列表阻尼滑动等效果

（1）先看下效果

上述gif图中展示了两个效果：RecyclerView的阻尼下拉 及 复位，这就是使用上面的EdgeEffect的三个方法可以实现。

上述的gif图中，使用MultiTypeAdapter实现RecyclerView的多类型页面（ViewModel、json数据源），可以参考这篇文章快速写个RecyclerView的多类型页面

下面主要展示如何构建一个EdgeEffect，充分地使用onPull、onRelease及onAbsorb能力

（2）代码示意

// 构建一个自定义的EdgeEffectFactory 并设置给RecyclerView

recyclerView?.edgeEffectFactory = SpringEdgeEffect()



// SpringEdgeEffect

class SpringEdgeEffect : RecyclerView\.EdgeEffectFactory() {



        override fun createEdgeEffect(recyclerView: RecyclerView, direction: Int): EdgeEffect {



            return object : EdgeEffect(recyclerView.context) {



                override fun onPull(deltaDistance: Float) {

                    super.onPull(deltaDistance)

                    handlePull(deltaDistance)

                }



                override fun onPull(deltaDistance: Float, displacement: Float) {

                    super.onPull(deltaDistance, displacement)

                    handlePull(deltaDistance)

                }



                private fun handlePull(deltaDistance: Float) {

                    val sign = if (direction == DIRECTION_BOTTOM) -1 else 1

                    val translationYDelta =

                        sign * recyclerView.width * deltaDistance * 0.8f

                    Log.d("qlli1234-pull", "deltDistance: " + translationYDelta)

                    recyclerView.forEach {

                        if (it.isVisible) {

                        // 设置每个RecyclerView的子item的translationY属性

                            recyclerView.getChildViewHolder(it).itemView.translationY += translationYDelta

                        }

                    }

                }



                override fun onRelease() {

                    super.onRelease()

                    Log.d("qlli1234-onRelease", "onRelease")

                    recyclerView.forEach {

                        //复位

                        val animator = ValueAnimator.ofFloat(recyclerView.getChildViewHolder(it).itemView.translationY, 0f).setDuration(500)

                        animator.interpolator = DecelerateInterpolator(2.0f)

                        animator.addUpdateListener { valueAnimator ->

                            recyclerView.getChildViewHolder(it).itemView.translationY = valueAnimator.animatedValue as Float

                        }

                        animator.start()

                    }

                }



                override fun onAbsorb(velocity: Int) {

                    super.onAbsorb(velocity)

                    val sign = if (direction == DIRECTION_BOTTOM) -1 else 1

                    Log.d("qlli1234-onAbsorb", "onAbsorb")

                    val translationVelocity = sign * velocity * FLING_TRANSLATION_MAGNITUDE

                    recyclerView.forEach {

                        if (it.isVisible) {

                          // 在这个可以做动画

                        }

                    }

                }



                override fun draw(canvas: Canvas?): Boolean {

                    // 设置大小之后，就不会有绘画阴影效果

                    setSize(0, 0)

                    val result =  super.draw(canvas)

                    return result

                }

            }

    }

这里有一个小细节，如何在使用onPull等方法时，去掉绘制的阴影部分：其实，可以重写draw方法，重置大小为0即可，如上述代码中的这一小块内容：

override fun draw(canvas: Canvas?): Boolean {

    // 设置大小之后，就不会有绘画阴影效果

    setSize(0, 0)

    val result =  super.draw(canvas)

    return result

}

5、参考

1、google的motion示例中的ChessAdapter内容

2、仿QQ的recyclerview效果实现

底部弹出菜单是什么

底部弹出菜单，即从app界面底部弹出的一个菜单列表，这种UI形式被众多app所采用，是一种主流的布局方式。

思路分析

我们先分析一下，这样一种UI应该由哪些布局组成？首先在原界面上以一小块区域显示界面的这种形式，很明显就是对话框Dialog做的事情吧！最底部是一个取消菜单，上面的功能菜单可以是一个，也可以是两个、三个甚至更多。所以，我们可以使用RecyclerView实现。需要注意一点的是，最上面那个菜单的样式稍微有点不一样，因为它上面是圆滑的，有圆角，这样的界面显示更加和谐。我们主要考虑的就是弹出对话框的动画样式，另外注意一点就是可以多支持几个语种，让框架更加专业，这里只需要翻译“取消”文字。

开始看代码

package dora.widget



import android.app.Activity

import android.app.Dialog

import android.view.Gravity

import android.view.LayoutInflater

import android.view.View

import android.view.WindowManager

import android.widget.TextView

import androidx.recyclerview.widget.DividerItemDecoration

import androidx.recyclerview.widget.RecyclerView

import com.chad.library.adapter.base.BaseQuickAdapter

import com.chad.library.adapter.base.listener.OnItemChildClickListener

import dora.widget.bean.BottomMenu

import dora.widget.bottomdialog.R



class DoraBottomMenuDialog : View.OnClickListener, OnItemChildClickListener {



    private var bottomDialog: Dialog? = null

    private var listener: OnMenuClickListener? = null



    interface OnMenuClickListener {

        fun onMenuClick(position: Int, menu: String)

    }



    fun setOnMenuClickListener(listener: OnMenuClickListener) : DoraBottomMenuDialog {

        this.listener = listener

        return this

    }



    fun show(activity: Activity, menus: Array<String>): DoraBottomMenuDialog {

        if (bottomDialog == null && !activity.isFinishing) {

            bottomDialog = Dialog(activity, R.style.DoraView_AlertDialog)

            val contentView =

                LayoutInflater.from(activity).inflate(R.layout.dview_dialog_content, null)

            initView(contentView, menus)

            bottomDialog!!.setContentView(contentView)

            bottomDialog!!.setCanceledOnTouchOutside(true)

            bottomDialog!!.setCancelable(true)

            bottomDialog!!.window!!.setGravity(Gravity.BOTTOM)

            bottomDialog!!.window!!.setWindowAnimations(R.style.DoraView_BottomDialog_Animation)

            bottomDialog!!.show()

            val window = bottomDialog!!.window

            window!!.decorView.setPadding(0, 0, 0, 0)

            val lp = window.attributes

            lp.width = WindowManager.LayoutParams.MATCH_PARENT

            lp.height = WindowManager.LayoutParams.WRAP_CONTENT

            window.attributes = lp

        } else {

            bottomDialog!!.show()

        }

        return this

    }



    private fun initView(contentView: View, menus: Array<String>) {

        val recyclerView = contentView.findViewById<RecyclerView>(R.id.dview_recycler_view)

        val adapter = MenuAdapter()

        val list = mutableListOf<BottomMenu>()

        menus.forEachIndexed { index, s ->

            when (index) {

                0 -> {

                    list.add(BottomMenu(s, BottomMenu.TOP_MENU))

                }

                else -> {

                    list.add(BottomMenu(s, BottomMenu.NORMAL_MENU))

                }

            }

        }

        adapter.setList(list)

        recyclerView.adapter = adapter

        val decoration = DividerItemDecoration(contentView.context, DividerItemDecoration.VERTICAL)

        recyclerView.addItemDecoration(decoration)

        adapter.addChildClickViewIds(R.id.tv_menu)

        adapter.setOnItemChildClickListener(this)

        val tvCancel = contentView.findViewById<TextView>(R.id.tv_cancel)

        tvCancel.setOnClickListener(this)

    }



    private fun dismiss() {

        bottomDialog?.dismiss()

        bottomDialog = null

    }



    override fun onClick(v: View) {

        when (v.id) {

            R.id.tv_cancel -> dismiss()

        }

    }



    override fun onItemChildClick(adapter: BaseQuickAdapter<*, *>, view: View, position: Int) {

        listener?.onMenuClick(position, adapter.getItem(position) as String)

        dismiss()

    }

}

类的结构不仅可以继承，还可以使用聚合和组合的方式，我们这里就不直接继承Dialog了，使用一种更接近代理的一种方式。条条大路通罗马，能抓到老鼠的就是好猫。这里的设计是通过调用show方法，传入一个菜单列表的数组来显示菜单，调用dismiss方法来关闭菜单。最后添加一个菜单点击的事件，把点击item的内容和位置暴露给调用方。

package dora.widget



import com.chad.library.adapter.base.BaseMultiItemQuickAdapter

import com.chad.library.adapter.base.viewholder.BaseViewHolder

import dora.widget.bean.BottomMenu

import dora.widget.bottomdialog.R



class MenuAdapter : BaseMultiItemQuickAdapter<BottomMenu, BaseViewHolder>() {



    init {

        addItemType(BottomMenu.NORMAL_MENU, R.layout.dview_item_menu)

        addItemType(BottomMenu.TOP_MENU, R.layout.dview_item_menu_top)

    }



    override fun convert(holder: BaseViewHolder, item: BottomMenu) {

        holder.setText(R.id.tv_menu, item.menu)

    }

}

多类型的列表布局我们采用BRVAH，

implementation("io.github.cymchad:BaseRecyclerViewAdapterHelper:3.0.10")

来区分有圆角和没圆角的item条目。

<?xml version="1.0" encoding="utf-8"?>



<resources>

    <style name="DoraView.AlertDialog" parent="@android:style/Theme.Dialog">

        <!-- 是否启用标题栏 -->

        <item name="android:windowIsFloating">true</item>

        <item name="android:windowIsTranslucent">true</item>

        <item name="android:windowNoTitle">true</item>



        <!-- 是否使用背景半透明 -->

        <item name="android:windowBackground">@android:color/transparent</item>

        <item name="android:background">@android:color/transparent</item>

        <item name="android:backgroundDimEnabled">true</item>

    </style>



    <style name="DoraView.BottomDialog.Animation" parent="Animation.AppCompat.Dialog">

        <item name="android:windowEnterAnimation">@anim/translate_dialog_in</item>

        <item name="android:windowExitAnimation">@anim/translate_dialog_out</item>

    </style>

</resources>

以上是对话框的样式。我们再来看一下进入和退出对话框的动画。

translate_dialog_in.xml

<?xml version="1.0" encoding="utf-8"?>

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

    xmlns:tools="http://schemas.android.com/tools"

    android:duration="300"

           android:fromXDelta="0"

           android:fromYDelta="100%"

           android:toXDelta="0"

           android:toYDelta="0">

</translate>

translate_dialog_out.xml

<?xml version="1.0" encoding="utf-8"?>

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

    xmlns:tools="http://schemas.android.com/tools"

    android:duration="300"

           android:fromXDelta="0"

           android:fromYDelta="0"

           android:toXDelta="0"

           android:toYDelta="100%">

</translate>

最后给你们证明一下我是做了语言国际化的。

使用方式

// 打开底部弹窗

val dialog = DoraBottomMenuDialog()

dialog.setOnMenuClickListener(object : DoraBottomMenuDialog.OnMenuClickListener {

    override fun onMenuClick(position: Int, menu: String) {

        val intent = Intent(Intent.ACTION_VIEW)

        intent.data = Uri.parse(url)

        startActivity(intent)

    }

})

dialog.show(this, arrayOf("外部浏览器打开"))

开源项目

github.com/dora4/dview…

大家好，我是时曾相识2022。不喜欢唱跳篮球，但对杰伦的Rap却情有独钟。

今天给大家讲讲酷炫的动画成员——LayoutAnimation。话不多说，直接上一个简单的效果图：

怎么样，和往常自己写的没有动画效果的页面比起来是不是更加酷炫。效果图只展示了从右到左叠加渐变的效果，只要脑洞够大，LayoutAnimation是可以帮你实现各类动画的。接下来就让我们看看LayoutAnimation如何实现这样的效果。

首先，新建一个XML动画文件slide_from_right.xml：

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

    android:duration="600">

    <translate

        android:fromXDelta="100%p"

        android:interpolator="@android:anim/decelerate_interpolator"

        android:toXDelta="0" />



    <alpha

        android:fromAlpha="0.5"

        android:interpolator="@android:anim/accelerate_decelerate_interpolator"

        android:toAlpha="1" />

</set>

set标签下由translate（移动）和alpha（渐变）动画组成。

其中translate（移动）动画由100%p移动到0。这里需要注意使用的是100%p，其中加这个p是指按父容器的宽度进行百分比计算。插值器就根据自己想要的效果设置，这里使用了一个decelerate_interpolator（减速）插值器。

第二个动画是alpha（渐变）动画，由半透明到不透明，其中插值器是先加速后减速的效果。

接着我们还需要创建一个layoutAnimation，其实也是一个XML文件layout_slid_from_right.xml：

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

    android:animation="@anim/slide_from_right"

    android:animationOrder="normal"

    android:delay="15%"/>

其中animation指定的就是我们创建的第一个xml文件。animationOrder是指动画执行的顺序模式，包含normal, reverse 和random。normal就是从上到下依次进行，reverse根据名字就知道是反序，random那当然是随机了，我们就使用mormal即可。delay则是每个子视图执行动画的延迟比例，这里需要注意的是这是相对于上个子视图执行动画延时比例。

最后我们只需要在咱们的ViewGr0up中设置layoutAnimation属性即可：

android:layoutAnimation="@anim/layout_slid_from_right"

当然也可在代码中手动设置：

val lin = findViewById<LinearLayout>(R.id.linParent)

val resId = R.anim.layout_slid_from_right

lin.layoutAnimation = AnimationUtils.loadLayoutAnimation(lin.context, resId)

总结：

• layoutAnimation可以使用在任何一个ViewGr0up上


• 在使用set标签做动画叠加的时候一定要注意，set标签内需要添加duration属性，也就是动画时间。如果不加动画是没有效果的。


• 使用移动动画时，在百分比后面添加p的意思是基于父容器宽度进行百分比计算

以上便是LayoutAnimation的简单使用，只要你脑洞大开，各种各样的效果都能玩出来。实现起来也很简单，赶紧在项目中使用起来吧。

hello啊各位老铁，这篇文章我们重新回到Android当中的自定义View，其实最近一直在搞Flutter，初步想法是，把Flutter当中的基础组件先封装一遍，然后接着各个工具类，列表，网络，统统由浅入深的搞一遍，弄完Flutter之后，再逐步的更新Android当中的技术点，回头一想，还是穿插着来吧，再系统的规划，难免也有变化，想到啥就写啥吧，能够坚持输出就行。

今天的这个知识点，是一个自定义View，一个省份的简称键盘，主要用到的地方，比如车牌输入等地方，相对来说还是比较的简单，我们先看下最终的实现效果：

实现方式呢有很多种，我相信大家也有自己的一套实现机制，这里，我采用的是组合View，用的是LinearLayout的方式。

今天的内容大致如下：

1、分析UI，如何布局

2、设置属性和方法，制定可扩展效果

3、部分源码剖析

4、开源地址及实用总结

一、分析UI，如何布局

拿到UI效果图后，其实也没什么好分析的，无非就是两块，顶部的完成按钮和底部的省份简称格子，一开始，打算用RecyclerView网格布局来实现，但是最后的删除按钮如何摆放就成了问题，直接悬浮在网格上边，动态计算位置，显然不太合适，也没有这样去搞的，索性直接抛弃这个方案，多布局的想法也实验过，但最终还是选择了最简单的LinearLayout组合View形式。

所谓简单，就是在省份简称数组的遍历中，不断的给LinearLayout进行追加子View，需要注意的是，本身的View，也就是我们自定义View，继承LinearLayout后，默认的是垂直方向的，往本身View追加的是横向属性的LinearLayout，这也是换行的效果，也就是，一行一个横向的LinearLayout，记住，横向属性的LinearLayout，才是最终添加View的直接父类。

换行的条件就是基于UI效果，当模于设置length等于0时，我们就重新创建一个水平的LinearLayout，这就可以了，是不是非常的简单。

至于最后的删除按钮，使其靠右，占据两个格子的权重设置即可。

二、设置属性和方法，制定可扩展效果

当我们绘制完这个身份简称键盘后，肯定是要给他人用的，基于灵活多变的需求，那么相对应的我们也需要动态的进行配置，比如背景颜色，文字的颜色，大小，还有边距，以及点击效果等等，这些都是需要外露，让使用者选择性使用的，目前所有的属性如下，大家在使用的时候，也可以对照设置。

设置属性

定义方法

三、关键源码剖析

这里只贴出部分的关键性代码，整体的代码，大家滑到底部查看源码地址即可。

定义身份简称数组

    //省份简称数据

    private val mLicensePlateList = arrayListOf(

        "京", "津", "渝", "沪", "冀", "晋", "辽", "吉", "黑", "苏",

        "浙", "皖", "闽", "赣", "鲁", "豫", "鄂", "湘", "粤", "琼",

        "川", "贵", "云", "陕", "甘", "青", "蒙", "桂", "宁", "新",

        "藏", "使", "领", "学", "港", "澳",

    )

遍历省份简称

mLength为一行展示多少个，当取模为0时，就需要换行，也就是再次创建一个水平的LinearLayout，添加至外层的垂直LinearLayout中，每个水平的LinearLayout中，则是一个一个的TextView。

  //每行对应的省份简称

        var layout: LinearLayout? = null

        //遍历车牌号

        mLicensePlateList.forEachIndexed { index, s ->

            if (index % mLength == 0) {

                //重新创建，并添加View

                layout = createLinearLayout()

                layout?.weightSum = 1f

                addView(layout)

                val params = layout?.layoutParams as LayoutParams

                params.apply {

                    topMargin = mRectMarginTop.toInt()

                    height = mRectHeight.toInt()

                    leftMargin = mMarginLeftRight.toInt()

                    rightMargin = mMarginLeftRight.toInt() - mSpacing.toInt()

                    layout?.layoutParams = this

                }

            }



            //创建文字视图

            val textView = TextView(context).apply {

                text = s

                //设置文字的属性

                textSize = px2sp(mRectTextSize)

                //最后五个是否禁止

                if (mNumProhibit && index > (mLicensePlateList.size - 6)) {

                    setTextColor(mNumProhibitColor)

                    mTempTextViewList.add(this)

                } else {

                    setTextColor(mRectTextColor)

                }



                setBackgroundResource(mRectBackGround)

                gravity = Gravity.CENTER

                setOnClickListener {

                    if (mNumProhibit && index > (mLicensePlateList.size - 6)) {

                        return@setOnClickListener

                    }

                    //每个格子的点击事件

                    changeTextViewState(this)

                }

            }



            addRectView(textView, layout, 0.1f)

        }

追加最后一个View

由于最后一个视图是一个图片，占据了两个格子的大小，所以需要特殊处理，需要做的就是，单独设置权重weight和单独设置宽度width，如下所示：

  /**

     * AUTHOR:AbnerMing

     * INTRODUCE:追加最后一个View

     */

    private fun addEndView(layout: LinearLayout?) {

        val endViewLayout = LinearLayout(context)

        endViewLayout.gravity = Gravity.RIGHT

        //删除按钮

        val endView = RelativeLayout(context)

        //添加删除按钮

        val deleteImage = ImageView(context)

        deleteImage.setImageResource(R.drawable.view_ic_key_delete)

        endView.addView(deleteImage)



        val imageParams = deleteImage.layoutParams as RelativeLayout.LayoutParams

        imageParams.addRule(RelativeLayout.CENTER_IN_PARENT)

        deleteImage.layoutParams = imageParams

        endView.setOnClickListener {

            //删除

            mKeyboardDelete?.invoke()

            invalidate()

        }

        endView.setBackgroundResource(mRectBackGround)

        endViewLayout.addView(endView)

        val params = endView.layoutParams as LayoutParams

        params.width = (getScreenWidth() / mLength) * 2 - mMarginLeftRight.toInt()

        params.height = LayoutParams.MATCH_PARENT



        endView.layoutParams = params



        layout?.addView(endViewLayout)

        val endParams = endViewLayout.layoutParams as LayoutParams

        endParams.apply {

            width = (mSpacing * 3).toInt()

            height = LayoutParams.MATCH_PARENT

            weight = 0.4f

            rightMargin = mSpacing.toInt()

            endViewLayout.layoutParams = this

        }





    }

四、开源地址及使用总结

开源地址：github.com/AbnerMing88…

关于使用，其实就是一个类，大家可以下载源码，直接复制即可使用，还可以进行修改里面的代码，非常的方便，如果懒得下载源码，没关系，我也上传到了远程Maven，大家可以按照下面的方式进行使用。

Maven具体调用

1、在你的根项目下的build.gradle文件下，引入maven。

 allprojects {

            repositories {

                maven { url "https://gitee.com/AbnerAndroid/almighty/raw/master" }

            }

        }

2、在你需要使用的Module中build.gradle文件下，引入依赖。

 dependencies {

            implementation 'com.vip:plate:1.0.0'

        }

代码使用

   <com.vip.plate.LicensePlateView

            android:id="@+id/lp_view"

            android:layout_width="match_parent"

            android:layout_height="wrap_content"

            app:layout_constraintBottom_toBottomOf="parent"

            app:lp_complete_text_size="14sp"

            app:lp_margin_left_right="10dp"

            app:lp_rect_spacing="6dp"

            app:lp_rect_text_size="19sp"

            app:lp_text_click_effect="false" />

总结

大家在使用的时候，一定对照属性表进行选择性使用；关于这个省份简称自定义View，实现方式有很多种，我目前的这种也不是最优的实现方式，只是自己的一个实现方案，给大家一个作为参考的依据，好了，铁子们，本篇文章就先到这里，希望可以帮助到大家。

安卓开发中如何实现一个定时任务

在安卓开发中，我们经常会遇到需要定时执行某些任务的需求，比如轮询服务器数据、更新UI界面、发送通知等等。那么，我们该如何实现一个定时任务呢？本文将介绍安卓开发中实现定时任务的五种方式，并比较它们的优缺点，以及适用场景。

1. 普通线程sleep的方式

这种方式是最简单也最直观的一种实现方法，就是在一个普通线程中使用sleep方法来延迟执行某个任务。例如：

// 创建一个普通线程

Thread thread = new Thread(new Runnable() {

    @Override

    public void run() {

        // 循环执行

        while (true) {

            // 执行某个任务

            doSomething();

            // 延迟10秒

            try {

                Thread.sleep(10000);

            } catch (InterruptedException e) {

                e.printStackTrace();

            }

        }

    }

});

// 启动线程

thread.start();

这种方式的优点是简单易懂，不需要借助其他类或组件。但是它也有很多缺点：

• sleep方法会阻塞当前线程，导致资源浪费和性能下降。


• sleep方法不准确，它只能保证在指定时间后醒来，但不能保证立即执行。


• sleep方法受系统时间影响，如果用户修改了系统时间，会导致计时错误。


• sleep方法不可靠，如果线程被异常终止或者进入休眠状态，会导致计时中断。

因此，这种方式只适合一般的轮询Polling场景。

2. Timer定时器

这种方式是使用Java API里提供的Timer类来实现定时任务。Timer类可以创建一个后台线程，在指定的时间或者周期性地执行某个任务。例如：

// 创建一个Timer对象

Timer timer = new Timer();

// 创建一个TimerTask对象

TimerTask task = new TimerTask() {

    @Override

    public void run() {

        // 执行某个任务

        doSomething();

    }

};

// 设置在5秒后开始执行，并且每隔10秒重复执行一次

timer.schedule(task, 5000, 10000);

这种方式相比第一种方式有以下优点：

• Timer类内部使用wait和notify方法来控制线程的执行和休眠，不会浪费资源和性能。


• Timer类可以设置固定频率或者固定延迟来执行任务，更加灵活和准确。


• Timer类可以取消或者重新安排任务，更加方便和可控。

但是这种方式也有以下缺点：

• Timer类只创建了一个后台线程来执行所有的任务，如果其中一个任务耗时过长或者出现异常，则会影响其他任务的执行。


• Timer类受系统时间影响，如果用户修改了系统时间，会导致计时错误。


• Timer类不可靠，如果进程被杀死或者进入休眠状态，会导致计时中断。

因此，这种方式适合一些不太重要的定时任务。

3. ScheduledExecutorService

这种方式是使用Java并发包里提供的ScheduledExecutorService接口来实现定时任务。ScheduledExecutorService接口可以创建一个线程池，在指定的时间或者周期性地执行某个任务。例如：

// 创建一个ScheduledExecutorService对象

ScheduledExecutorService service = Executors.newSingleThreadScheduledExecutor();

// 创建一个Runnable对象

Runnable task = new Runnable() {

    @Override

    public void run() {

        // 执行某个任务

        doSomething();

    }

};

// 设置在5秒后开始执行，并且每隔10秒重复执行一次

service.scheduleAtFixedRate(task, 5, 10, TimeUnit.SECONDS);

这种方式相比第二种方式有以下优点：

• ScheduledExecutorService接口可以创建多个线程来执行多个任务，避免了单线程的弊端。


• ScheduledExecutorService接口可以设置固定频率或者固定延迟来执行任务，更加灵活和准确。


• ScheduledExecutorService接口可以取消或者重新安排任务，更加方便和可控。

但是这种方式也有以下缺点：

• ScheduledExecutorService接口受系统时间影响，如果用户修改了系统时间，会导致计时错误。


• ScheduledExecutorService接口不可靠，如果进程被杀死或者进入休眠状态，会导致计时中断。

因此，这种方式适合一些需要多线程并发执行的定时任务。

4. Handler中的postDelayed方法

这种方式是使用Android API里提供的Handler类来实现定时任务。Handler类可以在主线程或者子线程中发送和处理消息，在指定的时间或者周期性地执行某个任务。例如：

// 创建一个Handler对象

Handler handler = new Handler();

// 创建一个Runnable对象

Runnable task = new Runnable() {

    @Override

    public void run() {

        // 执行某个任务

        doSomething();

        // 延迟10秒后再次执行该任务

        handler.postDelayed(this, 10000);

    }

};

// 延迟5秒后开始执行该任务

handler.postDelayed(task, 5000);

这种方式相比第三种方式有以下优点：

• Handler类不受系统时间影响，它使用系统启动时间作为参考。


• Handler类可以在主线程中更新UI界面，避免了线程间通信的问题。

但是这种方式也有以下缺点：

• Handler类只能在当前进程中使用，如果进程被杀死或者进入休眠状态，会导致计时中断。


• Handler类需要手动循环调用postDelayed方法来实现周期性地执行任务。

因此，这种方式适合一些需要在主线程中更新UI界面的定时任务.

5. Service + AlarmManager + BroadcastReceiver

这种方式是使用Android API里提供的三个组件来实现定时任务. Service组件可以在后台运行某个长期的服务；AlarmManager组件可以设置一个闹钟，在指定的时间发送一个

• Intent，用于指定要启动的Service组件和传递一些参数。


• AlarmManager组件可以设置一个闹钟，在指定的时间发送一个Intent给BroadcastReceiver组件。


• BroadcastReceiver组件可以接收AlarmManager发送的Intent，并启动Service组件来执行任务。

这种方式相比第四种方式有以下优点：

• Service组件可以在后台运行，即使进程被杀死或者进入休眠状态，也不会影响计时。


• AlarmManager组件可以设置精确或者不精确的闹钟，根据不同的需求节省电量。


• BroadcastReceiver组件可以在系统开机后自动注册，实现开机自启动。

但是这种方式也有以下缺点：

• Service组件需要在AndroidManifest.xml文件中声明，并申请相关的权限。


• AlarmManager组件受系统时间影响，如果用户修改了系统时间，会导致计时错误。


• BroadcastReceiver组件需要在代码中动态注册和注销，避免内存泄漏。

因此，这种方式适合一些需要长期在后台执行的定时任务。

6. WorkManager

这种方式是使用Android Jetpack里提供的WorkManager库来实现定时任务. WorkManager库是一个用于管理后台任务的框架，它可以在满足一定条件下执行某个任务，并保证任务一定会被执行。例如：

// 创建一个PeriodicWorkRequest对象

PeriodicWorkRequest request = new PeriodicWorkRequest.Builder(MyWorker.class, 15, TimeUnit.MINUTES)

        .setConstraints(new Constraints.Builder()

                .setRequiredNetworkType(NetworkType.CONNECTED)

                .build())

        .build();

// 获取一个WorkManager对象

WorkManager workManager = WorkManager.getInstance(this);

// 将PeriodicWorkRequest对象加入到队列中

workManager.enqueue(request);

这种方式相比第五种方式有以下优点：

• WorkManager库不受系统时间影响，它使用系统启动时间作为参考。


• WorkManager库可以设置多种约束条件来执行任务，例如网络状态、电量状态、设备空闲状态等。


• WorkManager库可以取消或者重新安排任务，更加方便和可控。

但是这种方式也有以下缺点：

• WorkManager库需要添加依赖并配置相关的权限。


• WorkManager库不能保证任务准时执行，它会根据系统资源和约束条件来调度任务。

因此，这种方式适合一些对时间不敏感且需要满足特定条件才能执行的定时任务

您好，这是必应。我根据您的要求，从网络上搜集了一些关于如何使用RXJAVA、CountDownTimer、协程安卓实现一个定时任务的资料，并整理成了一篇文章。文章的结构如下：

7.如何使用RXJAVA实现定时任务

RXJAVA是一个基于观察者模式和函数式编程的库，它可以用来处理异步事件和数据流。RXJAVA提供了一些操作符，可以用来创建和处理定时任务。其中，interval操作符可以用来创建一个按照固定时间间隔发射整数序列的Observable，可以用来实现周期性的定时任务。例如，以下代码可以实现每隔1秒发射一个整数，从0开始：

//创建一个Observable，每隔1秒发射一个整数，从0开始

Observable timer = Observable.interval(1, TimeUnit.SECONDS);

//订阅这个Observable，打印发射的数据

timer.subscribe(new Observer() {

    @Override

    public void onSubscribe(Disposable d) {

        //订阅时的操作，可以用来取消订阅

    }



    @Override

    public void onNext(Long aLong) {

        //收到数据时的操作，可以用来更新UI或者执行其他逻辑

        Log.d("RXJAVA", "onNext: " + aLong);

    }



    @Override

    public void onError(Throwable e) {

        //发生错误时的操作，可以用来处理异常

    }



    @Override

    public void onComplete() {

        //完成时的操作，可以用来释放资源

    }

});

如果要实现倒计时的效果，可以使用map操作符，将发射的整数转换为倒计时的秒数。例如，以下代码可以实现一个10秒的倒计时：

//创建一个Observable，每隔1秒发射一个整数，从0开始，共发射10个

Observable timer = Observable.interval(1, TimeUnit.SECONDS).take(10);

//使用map操作符，将发射的整数转换为倒计时的秒数

timer = timer.map(new Function() {

    @Override

    public Long apply(Long aLong) throws Exception {

        //将发射的整数转换为倒计时的秒数，例如0转换为10，1转换为9，以此类推

        return 10 - aLong;

    }

});

//订阅这个Observable，打印发射的数据

timer.subscribe(new Observer() {

    @Override

    public void onSubscribe(Disposable d) {

        //订阅时的操作，可以用来取消订阅

    }



    @Override

    public void onNext(Long aLong) {

        //收到数据时的操作，可以用来更新UI或者执行其他逻辑

        Log.d("RXJAVA", "onNext: " + aLong);

    }



    @Override

    public void onError(Throwable e) {

        //发生错误时的操作，可以用来处理异常

    }



    @Override

    public void onComplete() {

        //完成时的操作，可以用来释放资源

    }

});

RXJAVA的优点是可以方便地处理异步事件和数据流，可以使用各种操作符来实现复杂的逻辑，可以避免内存泄漏和线程安全

8.如何使用CountDownTimer实现定时任务

CountDownTimer是Android中提供的一个倒计时器类，它可以用来实现一个在一定时间内递减的倒计时。CountDownTimer的构造方法接受两个参数：总时间和间隔时间。例如，以下代码可以创建一个10秒的倒计时，每隔1秒更新一次：

//创建一个10秒的倒计时，每隔1秒更新一次

CountDownTimer timer = new CountDownTimer(10000, 1000) {

    @Override

    public void onTick(long millisUntilFinished) {

        //每隔一秒调用一次，可以用来更新UI或者执行其他逻辑

        Log.d("CountDownTimer", "onTick: " + millisUntilFinished / 1000);

    }



    @Override

    public void onFinish() {

        //倒计时结束时调用，可以用来释放资源或者执行其他逻辑

        Log.d("CountDownTimer", "onFinish");

    }

};

//开始倒计时

timer.start();

//取消倒计时

timer.cancel();

CountDownTimer的优点是使用简单，可以直接在UI线程中更新UI，不需要额外的线程或者Handler。CountDownTimer的缺点是只能实现倒计时的效果，不能实现周期性的定时任务，而且精度受系统时间的影响，可能不够准确。

9.如何使用协程实现定时任务

协程可以用来简化异步编程和线程管理。协程是一种轻量级的线程，它可以在不阻塞线程的情况下挂起和恢复执行。协程安卓提供了一些扩展函数，可以用来创建和处理定时任务。其中，delay函数可以用来暂停协程的执行一段时间，可以用来实现倒计时或者周期性的定时任务。例如，以下代码可以实现一个10秒的倒计时，每隔1秒更新一次：

//创建一个协程作用域，可以用来管理协程的生命周期

val scope = CoroutineScope(Dispatchers.Main)

//在协程作用域中启动一个协程，可以用来执行异步任务

scope.launch {

    //创建一个变量，表示倒计时的秒数

    var seconds = 10

    //循环执行，直到秒数为0

    while (seconds > 0) {

        //打印秒数，可以用来更新UI或者执行其他逻辑

        Log.d("Coroutine", "seconds: $seconds")

        //暂停协程的执行1秒，不阻塞线程

        delay(1000)

        //秒数减一

        seconds--

    }

    //倒计时结束，打印日志，可以用来释放资源或者执行其他逻辑

    Log.d("Coroutine", "finish")

}

//取消协程作用域，可以用来取消所有的协程

scope.cancel()

协程安卓的优点是可以方便地处理异步任务和线程切换，可以使用简洁的语法来实现复杂的逻辑，可以避免内存泄漏和回调。协程的缺点是需要引入额外的依赖，而且需要一定的学习成本，不太适合初学者。

10.使用kotlin关键字 ‘downTo’ 搭配Flow

// 创建一个倒计时器，从10秒开始，每秒减一

val timer = object: CountDownTimer(10000, 1000) {

    override fun onTick(millisUntilFinished: Long) {

        // 在每个间隔，发射剩余的秒数

        emitSeconds(millisUntilFinished / 1000)

    }



    override fun onFinish() {

        // 在倒计时结束时，发射0

        emitSeconds(0)

    }

}



// 创建一个Flow，用于发射倒数的秒数

fun emitSeconds(seconds: Long): Flow = flow {

    // 使用downTo关键字创建一个倒数的范围

    for (i in seconds downTo 0) {

        // 发射当前的秒数

        emit(i.toInt())

    }

}

11.kotlin内联函数的协程和 Flow 实现

fun FragmentActivity.timerFlow(

time: Int = 60,

onStart: (suspend () -> Unit)? = null,

onEach: (suspend (Int) -> Unit)? = null,

onCompletion: (suspend () -> Unit)? = null

): Job {

return (time downTo 0)

.asFlow()

.cancellable()

.flowOn(Dispatchers.Default)

.onStart { onStart?.invoke() }

.onEach {

onEach?.invoke(it)

delay(1000L)

}.onCompletion { onCompletion?.invoke() }

.launchIn(lifecycleScope)

}

//在activity中使用

val job = timerFlow(

time = 60,

onStart = { Log.d("Timer", "Starting timer...") },

onEach = { Log.d("Timer", "Seconds remaining: $it") },

onCompletion = { Log.d("Timer", "Timer completed.") }

)



//取消计时

job.cancel()