Android 拯救者光效实现

已于 2024-02-22 18:11:51 修改
阅读量1.6k 收藏 3
点赞数 2
分类专栏： android 自定义View 文章标签： android ui
于 2022-04-21 17:04:39 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/sqq_yj/article/details/124269794
版权

记录下之前开发ui效果。

实际效果

  • Doom 圆环实现
public class RoundScaleView2 extends View {
    private static final String TAG = "RoundScaleView2";

    private Context mContext;
    /**
     * 画笔对象的引用
     */
    private Paint paint;

    /**
     * 圆环的宽度
     */
    private float roundWidth;

    /**
     * 最大进度
     */
    private int max;

    /**
     * 当前进度
     */
    private int progress = 0;
    private int progress2 = 0;

    private boolean lightType = false;
    public static final int LIGHTID = 66;

    private int last_y = -1;
    private int last_y2 = -1;

    private int numberOfPointers = 1;

    String[] paintColors = {
            "#FF0000", "#FF2525", "#FF9C00", "#FFEF00", "#CBFF00", "#7BFF00", "#00FF37", "#02E863", "#00D35E", "#00C45C", "#00D795", "#00C1FF"
            ,"#0082FF", "#0050FF", "#0032FF", "#0000FF", "#2814FF", "#4E00FF", "#6A10FF", "#BD0EFF", "#FF00E3", "#FF2288", "#FF1666", "#FF0039"
            ,"#E60000", "#FF0000", "#FF0000", "#FF0000", "#FF0000", "#FF0000", "#FF0000", "#FF0000", "#FF0000", "#FF0000", "#FF0000", "#FF0000"
    };

    // 调整后颜色值
    int[] colors = {
             0xFF0000, 0xFF0500, 0xFF5000, 0xC8C800, 0x82FF00, 0x64FF00, 0x46FF00, 0x1EFF00, 0x28C800, 0x146400, 0x14DC05, 0x00A00F
            ,0x14641E, 0x003232, 0x003296, 0x0032E6, 0x0000FF, 0x1E00FF, 0x3C00FF, 0x6400FF, 0x960064, 0xC8001E, 0xEB000A, 0xFF0005
            ,0xE60000, 0xFF0000, 0xFF0000, 0xFF0000, 0xFF0000, 0xFF0000, 0xFF0000, 0xFF0000, 0xFF0000, 0xFF0000, 0xFF0000, 0xFF0000
    };

    int[] progress_rate = {
             0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11
            ,12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23
            ,24, -11, -10, -9, -8, -7, -6, -5, -4, -3, -2, -1};

    private PointF mProgressPoint;
    private PointF mProgressPoint2;
    private Boolean isEnabled = true;

    public RoundScaleView2(Context context) {
        this(context, null);
    }

    public RoundScaleView2(Context context, AttributeSet attrs) {
        this(context, attrs, 0);
    }

    public RoundScaleView2(Context context, AttributeSet attrs, int defStyleAttr) {
        super(context, attrs, defStyleAttr);
        mContext = context;
        paint = new Paint();

        //获取自定义属性和默认值
        roundWidth = dip2px(context,9);
        //最大刻度
        max = 36;
        //外边距
        paddingOuterThumb = dip2px(mContext,10);
    }

    @Override
    public void onDraw(Canvas canvas) {

        /**
         * 圆环颜色
         */
        paint.setStrokeWidth(roundWidth); //设置圆环的宽度
        paint.setColor(getResources().getColor(R.color.transparent));  //设置进度的颜色
//        paint.setColor(getResources().getColor(R.color.light_effectt_red));
        RectF oval2 = new RectF(centerX - radius  , centerY - radius , centerX + radius , centerY +
                radius);  //用于定义的圆弧的形状和大小的界限
        paint.setStyle(Paint.Style.STROKE);
        paint.setAntiAlias(true);  //消除锯齿
        canvas.drawArc(oval2, 270, 360, false, paint);  //根据进度画圆弧

        // 画Thumb
        canvas.save();

        //画可拖动的圆点
        if (isLightType()){
            drawTouchBar(canvas);
        }
    }

    /**
     * 画可拖动的圆点
     * @param canvas
     */
    private void drawTouchBar(Canvas canvas) {
        mProgressPoint = calcArcEndPointXY(centerX, centerY, radius + 30, 360 *
                progress / max, (float) 150.5);
//        //直接用画笔画
        paint.setColor(Color.parseColor(getPaintColors()));
        canvas.drawCircle(mProgressPoint.x, mProgressPoint.y,1,paint);
//        canvas.rotate(getTouchBarOffset(),progressPoint.x, progressPoint.y);
//        canvas.drawRect(progressPoint.x, progressPoint.y,progressPoint.x, progressPoint.y,paint);
        canvas.restore();
        canvas.save();


        mProgressPoint2 = calcArcEndPointXY(centerX, centerY, radius + 30, 360 *
                progress2 / max, (float) 150.5);
//        //直接用画笔画
        paint.setColor(Color.parseColor(getPaintColors2()));
        canvas.drawCircle(mProgressPoint2.x, mProgressPoint2.y,1,paint);
        canvas.restore();

    }

    public String getPaintColors() {
        String color = "#000000";
        HashMap<Integer, Object> map = new HashMap<>();
        for (int i = 0; i < paintColors.length; i++) {
            map.put(progress_rate[i], paintColors[i]);
        }
        if (map.size() >0) {
            for (int i = 0; i < map.size(); i++) {
                if (progress == progress_rate[i]) {
                    color = paintColors[i];
                }
            }
        }
        if (!isEnabled){
            color = "#00000000";
        }
        return color;
    }

    public String getPaintColors2() {
        String color = "#000000";
        HashMap<Integer, Object> map = new HashMap<>();
        for (int i = 0; i < paintColors.length; i++) {
            map.put(progress_rate[i], paintColors[i]);
        }
        if (map.size() >0) {
            for (int i = 0; i < map.size(); i++) {
                if (progress2 == progress_rate[i]) {
                    color = paintColors[i];
                }
            }
        }
        if (getNumberOfPointers() == 1){
            color = "#00000000";
        }
        return color;
    }

    private boolean downOnArc = false;
    private int downOnPointNum = 0;

    public void setViewEnabled(boolean enabled) {
        isEnabled = enabled;
        if (isEnabled){
            setAlpha(1f);
        }else {
            setAlpha(0.4f);
        }
    }

    @Override
    public boolean onTouchEvent(MotionEvent event) {
        if (!isEnabled){
            return false;
        }
        int action = event.getAction();
        int x = (int) event.getX();
        int y = (int) event.getY();
        switch (action) {
            case MotionEvent.ACTION_DOWN:
                if (isLightType()&&isTouchArc(x, y)) {
                    downOnArc = true;
                    if (isPointerOne(x,y) && downOnPointNum == 0){
                        updateArc(x, y,1);
                        downOnPointNum = 1;
                    }
                    if (!isPointerOne(x,y) && downOnPointNum == 0){
                        updateArc(x, y,2);
                        downOnPointNum = 2;
                    }
                    return true;
                }
                break;
            case MotionEvent.ACTION_MOVE:
                if (isLightType()&&downOnArc) {
                    if (downOnPointNum == 1){
                        updateArc(x, y,1);
                    }else {
                        updateArc(x, y,2);
                    }
                    setUpVibration();
                    final ViewParent parent = getParent();
                    if (parent != null) {
                        //通知父控件不要拦截事件
                        parent.requestDisallowInterceptTouchEvent(true);
                    }
                    return true;
                }
                break;
            case MotionEvent.ACTION_UP:
                downOnArc = false;
                downOnPointNum = 0;

                if (progress2 == progress){
                    if (progress2 == 24){
                        progress2 = progress - 1;
                    }else {
                        progress2 = progress + 1;
                    }
                }
                invalidate();
                if (isLightType()&&changeListener != null) {
                    changeListener.onProgressChangeEnd(max, progress,progress2);
                    if (!valueInTheDarkArea(progress)){
                        // 调用振动
                        LightEffectUtils.performKeyPressHapticFeedback(getContext(),this);
                    }
                }
                break;
        }
        return super.onTouchEvent(event);
    }

    private void setUpVibration() {
        if (last_y != getProgress() && !valueInTheDarkArea(getProgress())){
            for (int i = 0; i <progress_rate.length ; i++) {
                if (getProgress() == progress_rate[i]){
                    // 调用振动
                    LightEffectUtils.performKeyPressHapticFeedback(getContext(),this);
                    last_y = getProgress();
                }
            }
        }
        if (last_y2 != getProgress2() && !valueInTheDarkArea(getProgress2())){
            for (int i = 0; i <progress_rate.length ; i++) {
                if (getProgress2() == progress_rate[i]){
                    // 调用振动
                    LightEffectUtils.performKeyPressHapticFeedback(getContext(),this);
                    last_y2 = getProgress2();
                }
            }
        }
    }

    private int centerX, centerY;
    private int radius;
    private int paddingOuterThumb;

    @Override
    protected void onSizeChanged(int width, int height, int oldw, int oldh) {
        centerX = width / 2;
        centerY = height / 2;
        int minCenter = Math.min(centerX, centerY);

        radius = (int) (minCenter - roundWidth / 2 - paddingOuterThumb); //圆环的半径
        minValidateTouchArcRadius = (int) (radius - paddingOuterThumb * 1.5f);
        maxValidateTouchArcRadius = (int) (radius + paddingOuterThumb * 1.5f);
        super.onSizeChanged(width, height, oldw, oldh);
    }

    // 根据点的位置，更新进度
    private void updateArc(int x, int y,int downOnPointNum) {
        // 当前移动或者点击位置
        int cx = x - getWidth() / 2;
        int cy = y - getHeight() / 2;
        // 计算角度，得出（-1->1）之间的数据，等同于（-180°->180°）
        double angle = Math.atan2(cy, cx) / Math.PI;
        // 将角度转换成（0->2）之间的值，然后减去145°的偏移量
        angle = ((2 + angle) % 2 - (145 / 180f)) % 2;

        // 用（0->2）之间的角度值乘以总进度，等于当前进度
        // 当前变化进度
        int i = (int) (angle * max / 2);
        int adjustProgress = progressFormatConversion(i);

        if (isLeftDarkArea(adjustProgress)){
            adjustProgress = 0;
        }else if (isRightDarkArea(adjustProgress)){
            adjustProgress = 24;
        }
        if (downOnPointNum == 1){
            progress = adjustProgress;
        }else if(downOnPointNum == 2){
            progress2 = adjustProgress;
        }
        if (changeListener != null) {
            changeListener.onProgressChange(max, progress,progress2);
        }
        invalidate();
    }

     private int progressFormatConversion(int num){
        switch (num){
            case -14:
                num = 22;
                break;
            case -13:
                num = 23;
                break;
            case -12:
                num = 24;
                break;
        }
        return num;
     }

    // 判断是指针1
    private boolean isPointerOne(int x, int y){
        // 当前移动或者点击位置
        int cx = x - getWidth() / 2;
        int cy = y - getHeight() / 2;
        // 计算角度，得出（-1->1）之间的数据，等同于（-180°->180°）
        double angle = Math.atan2(cy, cx) / Math.PI;
        // 将角度转换成（0->2）之间的值，然后减去145°的偏移量
        angle = ((2 + angle) % 2 - (145 / 180f)) % 2;

        // 用（0->2）之间的角度值乘以总进度，等于当前进度
        // 当前变化进度
        int i = (int) (angle * max / 2);
        int adjustProgress = progressFormatConversion(i);

        if (isLeftDarkArea(adjustProgress)){
            adjustProgress = 0;
        }else if (isRightDarkArea(adjustProgress)){
            adjustProgress = 24;
        }
        if (getNumberOfPointers() != 1){
            int abs1 = Math.abs(adjustProgress - progress);
            int abs2 = Math.abs(adjustProgress - progress2);
            if (abs1 > abs2){
                return false;
            }else {
               return true;
            }
        }else {
            return true;
        }
    }


    private int minValidateTouchArcRadius; // 最小有效点击半径
    private int maxValidateTouchArcRadius; // 最大有效点击半径

    // 判断是否按在圆边上
    private boolean isTouchArc(int x, int y) {
        double d = getTouchRadius(x, y);
        if (d >= minValidateTouchArcRadius && d <= maxValidateTouchArcRadius) {
            return true;
        }
        return false;
    }

    // 计算某点到圆点的距离
    private double getTouchRadius(int x, int y) {
        int cx = x - getWidth() / 2;
        int cy = y - getHeight() / 2;
        return Math.hypot(cx, cy);
    }


    public synchronized int getMax() {
        return max;
    }

    /**
     * 设置进度的最大值
     *
     * @param max
     */
    public synchronized void setMax(int max) {
        if (max < 0) {
            throw new IllegalArgumentException("max not less than 0");
        }
        this.max = max;
    }
    /**
     *  获取指针数量
     *
     * @return
     */
    public int getNumberOfPointers() {
        return numberOfPointers;
    }

    /**
     *  设置指针数量
     *
     * @return
     */
    public void setNumberOfPointers(int numberOfPointers) {
        this.numberOfPointers = numberOfPointers;
    }

    /**
     * 获取进度.需要同步
     *
     * @return
     */
    public synchronized int getProgress() {
        return progress;
    }

    /**
     * 获取进度.需要同步
     *
     * @return
     */
    public synchronized int getProgress2() {
        return progress2;
    }

    /**
     * 设置进度，此为线程安全控件，由于考虑多线的问题，需要同步
     * 刷新界面调用postInvalidate()能在非UI线程刷新
     *
     * @param mProgress
     */
    public synchronized void setProgress(int mProgress) {
        if (mProgress < 0) {
            throw new IllegalArgumentException("progress not less than 0");
        }
        if (mProgress > max) {
            progress = max;
        }
        if (mProgress <= max) {
            this.progress = mProgress;
            postInvalidate();
        }
    }

    /**
     * 设置进度，此为线程安全控件，由于考虑多线的问题，需要同步
     * 刷新界面调用postInvalidate()能在非UI线程刷新
     *
     * @param mProgress2
     */
    public synchronized void setProgress2(int mProgress2) {
        if (mProgress2 < 0) {
            throw new IllegalArgumentException("progress2 not less than 0");
        }
        if (mProgress2 > max) {
            progress2 = max;
        }
        if (mProgress2 <= max) {
            if (mProgress2 == progress){
                if (progress2 == 24){
                    progress2 = progress - 1;
                }else {
                    progress2 = progress + 1;
                }
            }else {
                this.progress2 = mProgress2;
            }
            postInvalidate();
        }
    }

    public void setViewColorfulType(int type){
        if (type == 2){
            if (progress2 == progress){
                if (progress2 == 24){
                    progress2 = progress - 1;
                }else {
                    progress2 = progress + 1;
                }
            }else {
                progress2 = 0;
            }
            setNumberOfPointers(2);
        }else {
            progress2 = progress;
            setNumberOfPointers(1);
        }
        postInvalidate();
    }



    /**
     * 根据手机的分辨率从 dp 的单位 转成为 px(像素)
     */
    public static int dip2px(Context context, float dpValue) {
        final float scale = context.getResources().getDisplayMetrics().density;
        return (int) (dpValue * scale + 0.5f);
    }

    /**
     * 根据手机的分辨率从 px(像素) 的单位 转成为 dp
     */
    public static int px2dip(Context context, float pxValue) {
        final float scale = context.getResources().getDisplayMetrics().density;
        return (int) (pxValue / scale + 0.5f);
    }

    /**
     *  是否是黑暗不可点击区域
     * @param mProgress
     * @return
     */
    public static boolean valueInTheDarkArea(int mProgress){
        int[] progress = {-11,-10,-9,-8,-7,-6,-5,-4,-3,-2,-1 };
        for (int i = 0; i < progress.length; i++) {
            if (mProgress == progress[i]){
                return true;
            }
        }
        return false;
    }

    /**
     *  是否是左区域
     * @param mProgress
     * @return
     */
    public static boolean isLeftDarkArea(int mProgress){
        int [] progress = {-5,-4,-3,-2,-1};
        for (int i = 0; i < progress.length; i++) {
            if (mProgress == progress[i]){
                return true;
            }
        }
        return false;
    }

    /**
     *  是否是左区域
     * @param mProgress
     * @return
     */
    public static boolean isRightDarkArea(int mProgress){
        int[] progress = {-11,-10,-9,-8,-7,-6};
        for (int i = 0; i < progress.length; i++) {
            if (mProgress == progress[i]){
                return true;
            }
        }
        return false;
    }


    /**
     * 依圆心坐标，半径，扇形角度，计算出扇形终射线与圆弧交叉点的xy坐标
     *
     * @param cirX       圆centerX
     * @param cirY       圆centerY
     * @param radius     圆半径
     * @param cirAngle   当前弧角度
     * @param orginAngle 起点弧角度
     * @return 扇形终射线与圆弧交叉点的xy坐标
     */
    public static PointF calcArcEndPointXY(float cirX, float cirY, float radius, float
            cirAngle, float orginAngle) {
        cirAngle = (orginAngle + cirAngle) % 360;
        return calcArcEndPointXYForDoom(cirX, cirY, radius, cirAngle);
    }

    /**
     * For Doom
     * 依圆心坐标，半径，扇形角度，计算出扇形终射线与圆弧交叉点的xy坐标
     *
     * @param cirX     圆centerX
     * @param cirY     圆centerY
     * @param radius   圆半径
     * @param cirAngle 当前弧角度
     * @return 扇形终射线与圆弧交叉点的xy坐标
     */
    public static PointF calcArcEndPointXYForDoom(float cirX, float cirY, float radius, float
            cirAngle) {
        float posX = 0.0f;
        float posY = 0.0f;
        float arcAngle = 0.0f;
        //将角度转换为弧度
        if (cirAngle<90&&cirAngle>28) {
            arcAngle = (float) (Math.PI * 28.0 / 180.0);
        }else {
            arcAngle = (float) (Math.PI * cirAngle / 180.0);
        }
        if (cirAngle < 90) {
            posX = cirX + (float) (Math.cos(arcAngle)) * radius;
            posY = cirY + (float) (Math.sin(arcAngle)) * radius;
        } else if (cirAngle == 90) {
            posX = cirX;
            posY = cirY + radius;
        } else if (cirAngle > 90 && cirAngle < 180) {
            if(cirAngle>90&&cirAngle<150.5){
                arcAngle = (float) (Math.PI * (180 - 150.5) / 180.0);
            }else{
                arcAngle = (float) (Math.PI * (180 - cirAngle) / 180.0);
            }
            posX = cirX - (float) (Math.cos(arcAngle)) * radius;
            posY = cirY + (float) (Math.sin(arcAngle)) * radius;
        } else if (cirAngle == 180) {
            posX = cirX - radius;
            posY = cirY;
        } else if (cirAngle > 180 && cirAngle < 270) {
            arcAngle = (float) (Math.PI * (cirAngle - 180) / 180.0);
            posX = cirX - (float) (Math.cos(arcAngle)) * radius;
            posY = cirY - (float) (Math.sin(arcAngle)) * radius;
        } else if (cirAngle == 270) {
            posX = cirX;
            posY = cirY - radius;
        } else {
            arcAngle = (float) (Math.PI * (360 - cirAngle) / 180.0);
            posX = cirX + (float) (Math.cos(arcAngle)) * radius;
            posY = cirY - (float) (Math.sin(arcAngle)) * radius;
        }
        return new PointF(posX, posY);
    }


    private OnProgressChangeListener changeListener;

    public void setChangeListener(OnProgressChangeListener changeListener) {
        this.changeListener = changeListener;
    }

    public interface OnProgressChangeListener {
        void onProgressChange(int duration, int progress ,int progress2);

        void onProgressChangeEnd(int duration, int progress ,int progress2);
    }


    public boolean isLightType() {
        return lightType;
    }

    public void setLightType(boolean lightType) {
        this.lightType = lightType;
    }

  }
广强_
关注
  • 2
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Android ShimmerLayout实现微光效果解析
01-20
前阵子在github上看到一个很不错的动画效果，叫做ShimmerLayout，是一个用于实现内部视图微光效果的布局。 如何实现 通过使用PorterDuff，我们可以制造出微光效果。PorterDuff是canvas绘制图像处理中的一种渲染模式，当我们需要绘制出区域覆盖的图形效果的时候，我们可以使用这种方式来绘制。 这里我们采用的是PorterDuff.MODE.SRC_IN，意思是在绘制的时候，显示上下图层相交的部分，且这部分显示上层图层。 1） 首先我们需要绘制出最上层的微光，这里通过LinearGradient线性渐变渲染器来绘制微光渐变效果，为了使得渐变自然，我们看到，代码里在前
[Android开发]支持高亮灯光移动效果的TextView、ImageView及ViewGroup
u013077428的博客
11-08 1100
[Android开发]支持高亮灯光移动效果的TextView、ImageView及ViewGroup
自学mui--【读心术】
小屁孩大帅-保密的博客
02-28 468
1 目录 2 图片 3 index.html &lt;!doctype html&gt;&lt;html lang="zh-cn"&gt;&lt;head&gt; &lt;meta charset="utf-8"&gt; &lt;meta name="viewport" content="width=device-width, initial
联发科天玑战队霸榜安卓性能排行榜 高端芯片市场格局大变天
New_Mobi的博客
07-12 246
7 月 1 日下午，知名跑分测试机构安兔兔公布了 6 月 Android 手机性能榜。其中旗舰榜单和次旗舰榜单被联发科天玑系列芯片和高通芯片霸榜。 在 6 月份安兔兔旗舰手机性能排行榜中，联发科凭借年度旗舰芯片天玑 9000 芯片成功进入榜单前十，跑分接近了 100 万。不过，超过 100 万的前三款手机都是游戏手机。第一名黑鲨游戏手机 5Pro，平均成绩为 1040111，得益于 SSD+UFS3.1 方案，大幅领先于其它 Android 手机。第二名红魔 7Pro 屏下版最大的功劳就是风冷散热方案，有着
slidingMenu 百度地图在Fragment中切换黑边解决方法
cqrf2006的专栏
09-07 2076
由于android opengl绘制机制的原因，在使用slidingMenu和百度地图在切换的时候会出现黑边的现象，查了百度地图官方也没有找到好的解决办法，于是想到使用截图的方式来解决，大致的步骤如下： 1.slidingMenu打开的时候调用BaiduMap的snapshot方法截图获取Bitmap对象； 2.使用ImageView替换BaiduMap View并显示截取的图片; 3.sl
Android控件扫光动画,[android]利用动画实现view跑马灯效果
weixin_42604188的博客
05-25 776
该方法实现跑马灯简单,Android框架自带最近接手一个项目终端机应用项目,顶部的广告条是可以滚动的跑马灯形式的文字产品嫌弃这个跑马灯太慢了,让我调整一下速度该跑马灯是用原生的TextView实现的android:singleLine="true"android:ellipsize="marquee"android:marqueeRepeatLimit="-1"//需要获取焦点 才可以正常工作te...
Android实现流光效果、光影移动效果
红尘、困住我年少的博客
12-21 3881
概述： 开发过程中，看到有些界面用到一道光线在屏幕中掠过的效果，觉得挺炫的。所以查找相关资料自己实现了一遍。 先上个预览图： 实现思路： 简单来说就是在一个view中绘制好一道光影，并不断改变光影在view中的位置。 1.首先我们先了解一下光影怎么绘制 在了解如何绘制之前，我们先看一下LinearGradient的构造方法 /** * Create a shader that draws a linear gradient along a line. * * @pa
android 3D系列之光效篇
何明桂的小窝
09-01 9981
By 何明桂（http://blog.csdn.net/hmg25） 转载请注明出处      继续我们的android 3D之旅，我们将讨论光效。从今天开始我们将逐渐添加光效。 光效三要素 在 OpenGL ES中，光由三个元素组成，分别是环境元素（ambient component）， 散射元素（diffuse component）和 高光元素（specular compon
Android——实现光点模糊渐变的自旋转圆环特效，实现水滴波纹特效源码
02-06
Android——实现光点模糊渐变的自旋转圆环特效，实现水滴波纹特效的源代码。 博客地址：http://blog.csdn.net/qq_22770457?viewmode=contents
拯救者笔记本电源计划文件
10-13
联想拯救者电源计划文件， 重装系统必备。包括安静模式、均很模式、野兽模式。r9000k，r9000p实测可用。
联想拯救者壁纸4K超清完整版
03-22
联想拯救者壁纸4K超高清 壁纸是4K分辨率的 完整版
联想拯救者Y7000P电池固件
01-19
适用于电池充不进去电的情况
联想拯救者电池固件升级.zip
12-28
联想Y7000电脑不插电无法开机，插电显示正在充电，但是电量不提升。官方下载的电池固件升级包，安装教程有相应文档说明，亲测有效，省了500多元。
联想拯救者Y空间.zip
08-02
自己的拯救者R720笔记本换了win10专业版系统,强大的内置软件Y空间没有了，录频这些都不方便，还有开启自己的极致散热风扇，官网也没有这个软件的下载，只有Lenove Vantage这些。找寻许久才找到这款原装初版软件，...
2018 Android 文字转语音(中文) TextToSpeech+科大讯飞语音引擎3.0
热门推荐
人生只是一种体验，不必用来演绎完美。
09-06 2万+
最近项目中需要用到文字转语音。 本来是想使用朗读女生成的声音文件放到项目资源中进行播放。 但是产品要求改成动态的。于是就用了Google为我们封装好的类TTS，即TextToSpeech：大家可以看下详细文档。 代码其实不多，但是写完之后测试就有问题，没声音，，，，看了之后才知道谷歌这个官方api不支持中文。。很Tmd. 给大家科普下： 文字转语音的引擎： com.svox...
Android 判断字符串是否包含指定字符
人生只是一种体验，不必用来演绎完美。
07-30 9106
目前做的是系统设置，搜索这个功能。 需求是对搜索到的指定字符进行高亮显示。 效果如下： public SpannableString matcherSearchText(String text, String keyword) { SpannableString ss = new SpannableString(text); Pattern pattern = ...
java.lang.NoClassDefFoundError: Failed resolution of: Landroidx/core/view/ViewCompat;
人生只是一种体验，不必用来演绎完美。
04-23 9105
解决方案在这里 FlexboxLayout 1.1.0，该库预计将与AndroidX一起使用。 如果要使用而1.1.0 and above 不是迁移到AndroidX 用于AndroidX此 dependencies { implementation ‘com.google.android:flexbox:1.1.0’ } 对于 com.android.support:appcompat depe...
2018 Android Studio (清理空间) 修改模拟器存放路径
人生只是一种体验，不必用来演绎完美。
09-07 7772
Android Studio 安装之后，默认的会给我们创建模拟器的镜像文件放在了： C:\Users\Administrator.android 中。 如下图，三个模拟器占了我10个G。。 大家可以这样解决 &gt;&gt;&gt; 将 .avd 文件夹 移出c盘，然后配置 .ini 文件即可. 修改 .inl 文件avd 为你刚才修改的地址。保存。 如果是正在运...
拯救者独显pytorch
最新发布
03-11
拯救者独显pytorch是联想旗下的一款显卡产品，它采用了NVIDIA的GPU架构，并且支持PyTorch深度学习框架。PyTorch是一个开源的机器学习框架，它提供了丰富的工具和库，方便用户进行深度学习模型的开发和训练。 拯救者...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值