Android自定义带矩形进度框的布局

最新推荐文章于 2024-05-05 13:47:51 发布
最新推荐文章于 2024-05-05 13:47:51 发布
阅读量2.2k 收藏 2
点赞数
分类专栏： android 文章标签： android kotlin
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zcl875921355/article/details/121870298
版权

1.需求

1、需要一个RelativeLayout, 进度条环绕此布局，进度条可以设置宽度，颜色，背景

2、可设置进度起点，方向

3、可设置进度文字提示

先看效果

2.实现

根据需求定义参数和属性，定义四个起点 和 进度条的方向：顺时针和逆时针等

companion object {
        //起点位置
        const val LEFT_TOP = 0
        const val RIGHT_TOP = 1
        const val RIGHT_BOTTOM = 2
        const val LEFT_BOTTOM = 3

        //方向
        const val CLOCKWISE = 0
        const val ANTI_CLOCKWISE = 1
    }

    /**
     * 进度条宽度
     */
    var progressWidth = 0f

    /**
     * 进度条颜色
     */
    var progressColor = Color.GREEN

    /**
     * 进度条背景
     */
    var progressBgColor = Color.TRANSPARENT

    /**
     * 进度条开始点
     */
    var startPoint = LEFT_TOP

    /**
     * 进度条进度方向
     */
    var orientation = CLOCKWISE

    /**
     * 文字颜色
     */
    var textColor = Color.BLACK

    /**
     * 文字大小
     */
    var textSize = 0f

    /**
     * 当前进度
     */
    var currentProgress = 0

添加对应的attr

 <declare-styleable name="RecProgressLayout">

        <attr name="rpl_progress_width" format="dimension" />
        <attr name="rpl_progress_color" format="color|reference" />
        <attr name="rpl_progress_bg_color" format="color|reference" />
        <attr name="rpl_start_point" format="enum">
            <enum name="left_top" value="0" />
            <enum name="right_top" value="1" />
            <enum name="right_bottom" value="2" />
            <enum name="left_bottom" value="3" />
        </attr>
        <attr name="rpl_orientation" format="enum">
            <enum name="clockwise" value="0" />
            <enum name="anti_clockwise" value="1" />
        </attr>
        <attr name="rpl_text_color" format="color|reference" />
        <attr name="rpl_text_size" format="dimension" />
        <attr name="rpl_current_progress" format="integer" />

    </declare-styleable>

然后画进度条，根据进度刷新进度条和文字进度提示，根据不同起点和方向计算进度条的长度和位置，刷新进度即可，详细看源码

3.源码

有很多要优化的地方，在此就不做了，实现功能就行了

class RecProgressLayout @JvmOverloads constructor(
    context: Context,
    attrs: AttributeSet? = null,
    defStyleAttr: Int = 0
) : RelativeLayout(context, attrs, defStyleAttr) {

    companion object {
        //起点位置
        const val LEFT_TOP = 0
        const val RIGHT_TOP = 1
        const val RIGHT_BOTTOM = 2
        const val LEFT_BOTTOM = 3

        //方向
        const val CLOCKWISE = 0
        const val ANTI_CLOCKWISE = 1
    }

    /**
     * 进度条宽度
     */
    var progressWidth = 0f

    /**
     * 进度条颜色
     */
    var progressColor = Color.GREEN

    /**
     * 进度条背景
     */
    var progressBgColor = Color.TRANSPARENT

    /**
     * 进度条开始点
     */
    var startPoint = LEFT_TOP

    /**
     * 进度条进度方向
     */
    var orientation = CLOCKWISE

    /**
     * 文字颜色
     */
    var textColor = Color.BLACK

    /**
     * 文字大小
     */
    var textSize = 0f

    /**
     * 当前进度
     */
    var currentProgress = 0

    private var progressBgPaint: Paint
    private var progressPaint: Paint
    var textView: TextView? = null
    var layoutParams: LayoutParams

    init {
        val a = context.obtainStyledAttributes(attrs, R.styleable.RecProgressLayout)
        progressWidth = a.getDimension(R.styleable.RecProgressLayout_rpl_progress_width, 1f)
        progressColor = a.getColor(R.styleable.RecProgressLayout_rpl_progress_color, Color.GREEN)
        progressBgColor =
            a.getColor(R.styleable.RecProgressLayout_rpl_progress_bg_color, Color.TRANSPARENT)
        startPoint = a.getInteger(R.styleable.RecProgressLayout_rpl_start_point, LEFT_TOP)
        orientation = a.getInteger(R.styleable.RecProgressLayout_rpl_orientation, CLOCKWISE)
        textColor = a.getColor(R.styleable.RecProgressLayout_rpl_text_color, Color.BLACK)
        textSize = a.getDimension(R.styleable.RecProgressLayout_rpl_text_size, 0f)
        currentProgress = a.getInteger(R.styleable.RecProgressLayout_rpl_current_progress, 0)
        a.recycle()

        progressBgPaint = Paint(Paint.ANTI_ALIAS_FLAG)
        progressBgPaint.color = progressBgColor
        progressBgPaint.strokeWidth = progressWidth
        progressBgPaint.style = Paint.Style.STROKE

        progressPaint = Paint(Paint.ANTI_ALIAS_FLAG)
        progressPaint.color = progressColor
        progressPaint.strokeWidth = progressWidth
        progressPaint.style = Paint.Style.STROKE

        if (textSize != 0f) {
            textView = TextView(context)
            textView?.setTextColor(textColor)
            textView?.setTextSize(TypedValue.COMPLEX_UNIT_PX, textSize)
        }

        layoutParams = LayoutParams(LayoutParams.WRAP_CONTENT, LayoutParams.WRAP_CONTENT)

        setWillNotDraw(false)
    }

    override fun onDraw(canvas: Canvas?) {
        super.onDraw(canvas)
        drawProgressBg(canvas)
        drawProgress(canvas)
        if (textView != null)
            drawText()
    }

    fun setProgress(progress: Int) {
        currentProgress = progress
        invalidate()
    }

    /**
     * 绘制进度条背景
     * @param canvas Canvas?
     */
    private fun drawProgressBg(canvas: Canvas?) {
        if (orientation == CLOCKWISE) {
            drawTop(canvas, progressBgPaint, width.toFloat())
            drawRight(canvas, progressBgPaint, height.toFloat())
            drawBottom(canvas, progressBgPaint, 0f)
            drawLeft(canvas, progressBgPaint, 0f)
        } else {
            drawTop(canvas, progressBgPaint, 0f)
            drawRight(canvas, progressBgPaint, 0f)
            drawBottom(canvas, progressBgPaint, width.toFloat())
            drawLeft(canvas, progressBgPaint, height.toFloat())
        }
    }

    /**
     * 绘制进度条
     * @param canvas Canvas?
     */
    private fun drawProgress(canvas: Canvas?) {
        val totalWidth = 2 * (width + height) - 4 * progressWidth
        val progress = totalWidth * (currentProgress / 100.0f)
        when (startPoint) {
            LEFT_TOP -> {
                drawAtLeftTop(canvas, totalWidth, progress)
            }
            LEFT_BOTTOM -> {
                drawAtLeftBottom(canvas, totalWidth, progress)
            }
            RIGHT_TOP -> {
                drawAtRightTop(canvas, totalWidth, progress)
            }
            RIGHT_BOTTOM -> {
                drawAtRightBottom(canvas, totalWidth, progress)
            }
        }
    }

    @SuppressLint("NewApi")
    private fun drawText() {
        removeView(textView)
        val content = "$currentProgress%"
        textView?.text = content
        layoutParams.addRule(CENTER_IN_PARENT)
        textView?.layoutParams = layoutParams
        addView(textView)
    }

    /**
     * 绘制上方边进度条
     * @param canvas Canvas?
     */
    private fun drawTop(canvas: Canvas?, paint: Paint, width: Float) {
        if (orientation == CLOCKWISE) {
            canvas?.drawLine(
                progressWidth,
                progressWidth / 2.0f,
                width,
                progressWidth / 2.0f,
                paint
            )
        } else {
            canvas?.drawLine(
                this.width - progressWidth,
                progressWidth / 2.0f,
                width,
                progressWidth / 2.0f,
                paint
            )
        }
    }

    /**
     * 绘制右边进度条
     * @param canvas Canvas?
     */
    private fun drawRight(canvas: Canvas?, paint: Paint, height: Float) {
        if (orientation == CLOCKWISE) {
            canvas?.drawLine(
                width.toFloat() - progressWidth / 2.0f,
                progressWidth,
                width.toFloat() - progressWidth / 2.0f,
                height,
                paint
            )
        } else {
            canvas?.drawLine(
                width - progressWidth / 2.0f,
                this.height - progressWidth,
                width - progressWidth / 2.0f,
                height,
                paint
            )
        }
    }

    /**
     * 绘制下方进度条
     * @param canvas Canvas?
     */
    private fun drawBottom(canvas: Canvas?, paint: Paint, width: Float) {
        if (orientation == CLOCKWISE) {
            canvas?.drawLine(
                this.width - progressWidth,
                height.toFloat() - progressWidth / 2.0f,
                width,
                height.toFloat() - progressWidth / 2.0f,
                paint
            )
        } else {
            canvas?.drawLine(
                progressWidth,
                height - progressWidth / 2.0f,
                width,
                height - progressWidth / 2.0f,
                paint
            )
        }
    }

    /**
     * 绘制左边进度条
     * @param canvas Canvas?
     */
    private fun drawLeft(canvas: Canvas?, paint: Paint, height: Float) {
        if (orientation == CLOCKWISE) {
            canvas?.drawLine(
                progressWidth / 2.0f,
                this.height - progressWidth,
                progressWidth / 2.0f,
                height,
                paint
            )
        } else {
            canvas?.drawLine(
                progressWidth / 2.0f,
                progressWidth,
                progressWidth / 2.0f,
                height,
                paint
            )
        }
    }

    /**
     * 绘制起点在左上
     * @param canvas Canvas?
     * @param totalWidth Float
     * @param progress Float
     */
    private fun drawAtLeftTop(canvas: Canvas?, totalWidth: Float, progress: Float) {
        if (orientation == CLOCKWISE) {
            if (progress >= width - progressWidth) {
                drawTop(canvas, progressPaint, width.toFloat())
                if (currentProgress >= 50) {
                    drawRight(canvas, progressPaint, height.toFloat())
                    if (progress >= width * 2 + height - 3 * progressWidth) {
                        drawBottom(canvas, progressPaint, 0f)
                        if (currentProgress == 100) {
                            drawLeft(canvas, progressPaint, 0f)
                        } else {
                            drawLeft(canvas, progressPaint, totalWidth - progress)
                        }
                    } else {
                        drawBottom(
                            canvas,
                            progressPaint,
                            2 * width + height - 3 * progressWidth - progress
                        )
                    }
                } else {
                    drawRight(
                        canvas,
                        progressPaint,
                        progress - width + 2 * progressWidth
                    )
                }
            } else {
                drawTop(canvas, progressPaint, progressWidth + progress)
            }
        } else {
            if (progress >= height - progressWidth) {
                drawLeft(canvas, progressPaint, height.toFloat())
                if (currentProgress >= 50) {
                    drawBottom(canvas, progressPaint, height.toFloat())
                    if (progress >= height * 2 + width - 3 * progressWidth) {
                        drawRight(canvas, progressPaint, 0f)
                        if (currentProgress == 100) {
                            drawTop(canvas, progressPaint, 0f)
                        } else {
                            drawTop(canvas, progressPaint, width - (totalWidth - progress))
                        }
                    } else {
                        drawRight(
                            canvas,
                            progressPaint,
                            2 * height + width - (progress + 3 * progressWidth)
                        )
                    }
                } else {
                    drawBottom(
                        canvas,
                        progressPaint,
                        progress + 2 * progressWidth - height
                    )
                }
            } else {
                drawLeft(canvas, progressPaint, progressWidth + progress)
            }
        }
    }

    /**
     * 绘制起点在左下
     * @param canvas Canvas?
     * @param totalWidth Float
     * @param progress Float
     */
    private fun drawAtLeftBottom(canvas: Canvas?, totalWidth: Float, progress: Float) {
        if (orientation == CLOCKWISE) {
            if (progress >= height - progressWidth) {
                drawLeft(canvas, progressPaint, 0f)
                if (currentProgress >= 50) {
                    drawTop(canvas, progressPaint, width.toFloat())
                    if (progress >= height * 2 + width - 3 * progressWidth) {
                        drawRight(canvas, progressPaint, height.toFloat())
                        if (currentProgress == 100) {
                            drawBottom(canvas, progressPaint, 0f)
                        } else {
                            drawBottom(canvas, progressPaint, totalWidth - progress)
                        }
                    } else {
                        drawRight(
                            canvas,
                            progressPaint,
                            progress - 3 * progressWidth - height - width
                        )
                    }
                } else {
                    drawTop(
                        canvas,
                        progressPaint,
                        progress - height + 2 * progressWidth
                    )
                }
            } else {
                drawLeft(canvas, progressPaint, height - progress)
            }
        } else {
            if (progress >= width - progressWidth) {
                drawBottom(canvas, progressPaint, width.toFloat())
                if (currentProgress >= 50) {
                    drawRight(canvas, progressPaint, 0f)
                    if (progress >= width * 2 + height - 3 * progressWidth) {
                        drawTop(canvas, progressPaint, 0f)
                        if (currentProgress == 100) {
                            drawLeft(canvas, progressPaint, height.toFloat())
                        } else {
                            drawLeft(
                                canvas,
                                progressPaint,
                                height - (totalWidth - progress)
                            )
                        }
                    } else {
                        drawTop(
                            canvas,
                            progressPaint,
                            2 * width + height - (progress + 3 * progressWidth)
                        )
                    }
                } else {
                    drawRight(
                        canvas,
                        progressPaint,
                        height + width - (progress + 2 * progressWidth)
                    )
                }
            } else {
                drawBottom(canvas, progressPaint, progress)
            }
        }
    }

    /**
     * 绘制起点在右上
     * @param canvas Canvas?
     * @param totalWidth Float
     * @param progress Float
     */
    private fun drawAtRightTop(canvas: Canvas?, totalWidth: Float, progress: Float) {
        if (orientation == CLOCKWISE) {
            if (progress >= height - progressWidth) {
                drawRight(canvas, progressPaint, height.toFloat())
                if (currentProgress >= 50) {
                    drawBottom(canvas, progressPaint, 0f)
                    if (progress >= height * 2 + width - 3 * progressWidth) {
                        drawLeft(canvas, progressPaint, 0f)
                        if (currentProgress == 100) {
                            drawTop(canvas, progressPaint, width.toFloat())
                        } else {
                            drawTop(canvas, progressPaint, width - (totalWidth - progress))
                        }
                    } else {
                        drawLeft(
                            canvas,
                            progressPaint,
                            2 * height + width - 3 * progressWidth - progress
                        )
                    }
                } else {
                    drawBottom(
                        canvas,
                        progressPaint,
                        width + height - progress - 2 * progressWidth
                    )
                }
            } else {
                drawRight(canvas, progressPaint, progressWidth + progress)
            }
        } else {
            if (progress >= width - progressWidth) {
                drawTop(canvas, progressPaint, 0f)
                if (currentProgress >= 50) {
                    drawLeft(canvas, progressPaint, height.toFloat())
                    if (progress >= width * 2 + height - 3 * progressWidth) {
                        drawBottom(canvas, progressPaint, width.toFloat())
                        if (currentProgress == 100) {
                            drawRight(canvas, progressPaint, 0f)
                        } else {
                            drawRight(canvas, progressPaint, totalWidth - progress)
                        }
                    } else {
                        drawBottom(
                            canvas,
                            progressPaint,
                            progress + 3 * progressWidth - width - height
                        )
                    }
                } else {
                    drawLeft(
                        canvas,
                        progressPaint,
                        progress + 2 * progressWidth - width
                    )
                }
            } else {
                drawTop(canvas, progressPaint, width - progressWidth - progress)
            }
        }
    }

    /**
     * 绘制起点在左上
     * @param canvas Canvas?
     * @param totalWidth Float
     * @param progress Float
     */
    private fun drawAtRightBottom(canvas: Canvas?, totalWidth: Float, progress: Float) {
        if (orientation == CLOCKWISE) {
            if (progress >= width - progressWidth) {
                drawBottom(canvas, progressPaint, 0f)
                if (currentProgress >= 50) {
                    drawLeft(canvas, progressPaint, 0f)
                    if (progress >= width * 2 + height - 3 * progressWidth) {
                        drawTop(canvas, progressPaint, width.toFloat())
                        if (currentProgress == 100) {
                            drawRight(canvas, progressPaint, height.toFloat())
                        } else {
                            drawRight(canvas, progressPaint, totalWidth - progress)
                        }
                    } else {
                        drawTop(
                            canvas,
                            progressPaint,
                            3 * progressWidth + progress - width - height
                        )
                    }
                } else {
                    drawLeft(
                        canvas,
                        progressPaint,
                        width + height - progress - 2 * progressWidth
                    )
                }
            } else {
                drawBottom(canvas, progressPaint, width - progressWidth - progress)
            }
        } else {
            if (progress >= height - progressWidth) {
                drawRight(canvas, progressPaint, 0f)
                if (currentProgress >= 50) {
                    drawTop(canvas, progressPaint, 0f)
                    if (progress >= height * 2 + width - 3 * progressWidth) {
                        drawLeft(canvas, progressPaint, height.toFloat())
                        if (currentProgress == 100) {
                            drawBottom(canvas, progressPaint, width.toFloat())
                        } else {
                            drawBottom(canvas, progressPaint, width - (totalWidth - progress))
                        }
                    } else {
                        drawLeft(
                            canvas,
                            progressPaint,
                            progress + 3 * progressWidth - width - height
                        )
                    }
                } else {
                    drawTop(
                        canvas,
                        progressPaint,
                        height + width - progress - 2 * progressWidth
                    )
                }
            } else {
                drawRight(canvas, progressPaint, height - progress - progressWidth)
            }
        }
    }
}

4.使用

<com.xx.xxx.widget.RecProgressLayout
    android:id="@+id/rec_layout"
    android:layout_width="200dp"
    android:layout_height="300dp"
    app:layout_constraintStart_toStartOf="parent"
    app:layout_constraintEnd_toEndOf="parent"
    app:layout_constraintTop_toTopOf="parent"
    app:layout_constraintBottom_toBottomOf="parent"
    app:rpl_orientation="clockwise"
    app:rpl_start_point="left_top"
    app:rpl_progress_width="8dp"
    app:rpl_current_progress="0"
    app:rpl_progress_color="@color/progress_color"
    app:rpl_progress_bg_color="@color/transparent_color">

    <ImageView
        android:id="@+id/iv_image"
        android:layout_width="match_parent"
        android:layout_height="match_parent"
        android:layout_margin="8dp"
        android:scaleType="centerCrop"
        android:src="@mipmap/ic_logo"
        android:visibility="visible"/>
</com.xx.xxx.widget.RecProgressLayout>

代码中直接 调用 binding.recProgressLayout.setProgress(进度1-100)就可以了

浪漫三藏
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
Android自定义方形进度条
二十不悔，三十而立
02-14 4088
自定义view是进阶中级Android开发师的必经之路，这里描述了怎么继承自view实现一个方形进度条，文章最后也有圆形进度条的Demo.
android自定义圆角进度条,Android自定义进度条的圆角横向进度条实例详解
weixin_30019517的博客
05-25 1063
1.本文将向你介绍自定义进度条的写法，比较简单，但还是有些知识点是需要注意的：invalidate()方法RectF方法的应用onMeasure方法的应用2.原理画3层圆角矩形，底层为黑色，第二层为灰色，最上一层为进度条颜色，示例图如下：3.效果图实现圆角进度条还有很多其他方法，比如在Progress控件里填充圆角图片，通过拉伸图片来达到预想的效果，虽然听起来很简单，但实现起来还是有些麻烦的。4....
android圆角矩形进度条
05-29
思路介绍 http://blog.csdn.net/li_xiao_kang/article/details/46225927
【Android UI】绘制圆角矩形进度条 ① ( 像素值转化 dp -＞ px | Paint 标志位设置 | Paint 画笔线帽样式设置 | Paint 画笔线段连接处样式设置 )
让 学习 成为一种 习惯 ( 韩曙亮 の 技术博客 )
07-05 1395
一、绘制圆角矩形进度条、 二、像素值转化 dp -> px、 三、Paint 标志位设置、 四、Paint 画笔线帽样式设置、 五、Paint 画笔线段连接处样式设置、
Android圆角正方形加载框
李平的博客
06-03 202
Android圆角正方形加载框。
smartrefreshlayout简单使用
12-20
一款不错的上拉加载下拉刷新控件--------SmartRefreshLayout 一.导入依赖 二.在mainActivity中添加xml布局 三.MainActivity中初始化和刷新加载事件
android 自定义进度条矩形框,Android 自定义方形进度条
weixin_42332131的博客
05-25 664
效果图如上，自定义方形的进度条，第一个是100%，第二个是70%其实很简单的，就Path类public class SquareProgressBar extends View { private int progress = 70;//进度 private int strokeWidth = 20; private Paint paint = null; private Path p...
Android绘图：自定义View之——矩形进度条、圆环进度条、填充型进度条、时钟
liujiaoruiIT的博客
09-17 4681
主函数 矩形进度条自定义View 矩形进度条的布局 成像图 圆环形进度条自定义View 圆环形进度条的布局 成像图 填充型进度条自定义View 填充型进度条布局 成像图 时钟自定义View 时钟自定义View布局 成像图 主函数这几种进度条的主函数都是类似的，所以下面我只给出了一个填充型进度条的主函数，其他几个主函数只是在这基础上改动一下按钮id(即与各自布局里面的id相同即可)，还有改动一下相对应
android 动态矩形条,Android View : 自定义方形 进度条
weixin_39556891的博客
05-25 399
腾讯的狼人杀。玩家发言在矩形的头相框，动态展示倒计时进度条，感觉很好玩，参考网上一些做法：最终可以实现效果：Paste_Image.png可以控制 修改颜色显示 ，是否显示小球等：先给出demo地址：链接: https://pan.baidu.com/s/1bp8NbGz 密码: 75sg主界面大体上就是通过handler 发送消息更新ui的思想，布局也比较简单。重点是绘制：import andr...
Android 自带描边颜色渐变炫酷进度条
m0_70083062的博客
05-08 585
/** 外描边的宽度 */ private float BORDER_STROCK; /** 进度条进度矩形与控件边界的距离,≥BORDER_STROCK */ private float PROGRESS_STROCK; //进度条的宽高 private int mWidth, mHeight; /** 画进度条的矩形 */ private RectF mRec 《Android学习笔记总结+最新移动架构视频+大厂安卓面试真题+项目实战源码讲义》无偿开源 徽信搜索公众号【编程进阶路】 tF;
Android自定义View实现可拖拽缩放的矩形框
08-19
主要为大家详细介绍了Android自定义View实现可拖拽缩放的矩形框，文中示例代码介绍的非常详细，具有一定的参考价值，感兴趣的小伙伴们可以参考一下
Android-RectangleProgressView矩形倒计时进度框矩形进度框
08-12
RectangleProgressView 矩形倒计时进度框 矩形进度框
Android自定义彩色织带分割线
08-31
主要为大家详细介绍了Android自定义彩色织带分割线的相关资料，具有一定的参考价值，感兴趣的小伙伴们可以参考一下
Android自定义ViewGroup实现带箭头的圆角矩形菜单
01-04
本文和大家一起做一个带箭头的圆角矩形菜单，大概长下面这个样子：  要求顶上的箭头要对准菜单锚点，菜单项按压反色，菜单背景色和按压色可配置。 最简单的做法就是让UX给个三角形的图片往上一贴，但是转念一想这样是不是太low了点，而且不同分辨率也不太好适配，干脆自定义一个ViewGroup吧！ 自定义ViewGroup其实很简单，基本都是按一定的套路来的。  一、定义一个attrs.xml 就是声明一下你的这个自定义View有哪些可配置的属性，将来使用的时候可以自由配置。这里声明了7个属性，分别是：箭头宽度、箭头高度、箭头水平偏移、圆角半径、菜单背景色、阴影色、阴影厚度。 &lt;res
【Web】CTFSHOW 中期测评刷题记录(1)
uuzeray的博客
05-02 1425
访问./cache/6a992d5529f459a44fee58c733255e86.php，命令执行拿flag。login.php是在./templates下的，而./flag.php与./templates均为web目录。注意到用./template/error.php中存在{{username}}，可以用其cache来写马。这时候重开下靶机再去读./templates/index.php，发现是给了提示的。访问./config/settings.php，命令执行拿到flag。
php利用阿里云短信SDK实现短信发送功能
赛时科技
05-02 918
在阿里云控制台的AccessKey管理中，创建或查看AccessKey ID和AccessKey Secret，这是用于API调用的身份凭证。用户在前端接收到短信验证码后，需要在你的系统中进行验证。在实际部署之前，确保在测试环境中充分测试你的短信验证码登录功能。首先，你需要有一个阿里云账号，并在阿里云控制台中开通短信服务（Dysmsapi）。你可以使用Composer来安装阿里云短信服务的PHP SDK。在PHP中，你需要编写一个函数来调用阿里云短信服务API发送短信验证码。
Android NDK开发——Android Studio 3.5.2安装与配置踩坑
最新发布
君莫笑lucky的博客
05-05 747
本博客主要记录Android Studio 3.5.2旧版本安装与配置时遇到的主要踩坑。
安卓获取SHA
qq_36237165的博客
04-30 474
1、电脑上来存在eclipse的用户或正在使用此开发工具的用户就简单了，直接利用eclipse 走打包流程，再打包的时候选择相应的签名，那么在当前面板的下面便会出现签名的相关信息。3）确保安装了jdk并且正确配置了环境变量， 在该目录下打开cmd，输入命令 ：keytool -printcert -file CERT.RSA。1） 将apk解压(1.可以直接用解压工具直接解压，如果不行就修改后缀为 .rar文件后)，下面解压后的文件。便会出现响应的签名的信息了，如下图。然后输入相关的签名口令 回车。
翻译插件Translation和AndroidLocalize
qq_45649553的博客
04-28 473
翻译插件Translation和AndroidLocalize
android 矩形带文字进度条
06-08
为了在进度条上显示文字，你可以在布局文件中在 ProgressBar 控件的外部套上一个 TextView 控件，并在代码中通过 setProgress() 方法设置进度值。以下是一个示例代码： ```xml android:layout_width="match_...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值