杂乱无章的小笔记

1、通过strings资源改变部分字体颜色

<Data><![CDATA[<font color="#000000">这是需要改变颜色的字体</font>%这是正常的字体颜色<font color="#ffffff">这是需要改变颜色的字体</font>]]></Data>

此资源需要通过 Html.fromHtml() 来设置，否则无效

2、剪切板

复制文本到剪切板

public static void copyToClipboard(Context context, String copyText) {
        // 从API11开始android推荐使用android.content.ClipboardManager
        // 为了兼容低版本我们这里使用旧版的android.text.ClipboardManager，虽然提示deprecated，但不影响使用。
        ClipboardManager cm = (ClipboardManager) context.getSystemService(Context.CLIPBOARD_SERVICE);
        // 将文本内容放到系统剪贴板里。
        cm.setText(copyText);
}

监听剪切板的变化

final ClipboardManager cm = (ClipboardManager) getSystemService(Context.CLIPBOARD_SERVICE);
        cm.addPrimaryClipChangedListener(new ClipboardManager.OnPrimaryClipChangedListener() {
            @Override
            public void onPrimaryClipChanged() {
                ClipData primaryClip = cm.getPrimaryClip();
                ClipData.Item item = primaryClip.getItemAt(0);
                String text= item.getText().toString();  // 获得复制的文本
            }
        });

3、Dialog全屏时，设置状态栏透明

if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.LOLLIPOP) {
            window.clearFlags(WindowManager.LayoutParams.FLAG_TRANSLUCENT_STATUS | WindowManager.LayoutParams.FLAG_TRANSLUCENT_NAVIGATION);
            window.getDecorView().setSystemUiVisibility(View.SYSTEM_UI_FLAG_LAYOUT_FULLSCREEN | View.SYSTEM_UI_FLAG_LAYOUT_HIDE_NAVIGATION | View.SYSTEM_UI_FLAG_LAYOUT_STABLE);
            window.addFlags(WindowManager.LayoutParams.FLAG_DRAWS_SYSTEM_BAR_BACKGROUNDS);
            window.setStatusBarColor(Color.TRANSPARENT);
        }

这时想要导航栏实现沉浸式效果还需设置dialog的样式

<!--背景颜色及和透明程度-->
<item name="android:windowBackground">@android:color/transparent</item>
<!--是否模糊-->
<item name="android:backgroundDimEnabled">false</item>

保留小数

保留2位小数，当入参不足2位小数时，自动补0，超出2位时不会四舍五入

Log.e("------------>",String.format("%.2f", 1.2));  //输出结果为 1.20
Log.e("------------>",String.format("%.2f", 1.234));  //输出结果为 1.23

保留2位小数，当入参不足2位小数时，不会补0，超出2位时进行四舍五入

NumberFormat nf = NumberFormat.getNumberInstance();
nf.setMaximumFractionDigits(2);
Log.e("------------>",nf.format(1.246));  // 输出结果为1.25
Log.e("------------>",nf.format(1.2));  // 输出结果为1.2

##Edittext限制输入最大和最小值

public static void limitInput(final EditText editText, final double max, final double min, final Activity activity, final String msg) {
        TextWatcher textWatcher = new TextWatcher() {
            @Override
            public void beforeTextChanged(CharSequence charSequence, int i, int i1, int i2) {
            }

            @Override
            public void onTextChanged(CharSequence s, int start, int before, int count) {
                if (StringUtils.isBlank(s.toString())) return;
                s = s.toString().replaceAll(",", "");
                if (max != -1 && min != -1) {
                    // 有多个小数点
                    if (s.toString().indexOf(".") != s.toString().lastIndexOf(".")) {
                        editText.setText("");
                        showToast(activity, msg);
                        return;
                    }
                    double num = Double.parseDouble(s.toString().equals("") || s.toString().equals(".") ? "0" : s.toString());
                    if (num > max) {
                        showToast(activity, msg);
                        s = s.subSequence(0, s.length() - 1);
                        editText.setText("");
                    } else if (num < min) {
                        s = String.valueOf(min);
                        editText.setText("");
                    }
                }
            }

            @Override
            public void afterTextChanged(Editable editable) {
                // 保留两位小数
                String temp = editable.toString();
                if (temp == null) return;
                int posDot = temp.indexOf(".");
                if (posDot <= 0) return;
                if (temp.length() - posDot - 1 > 2) {
                    editable.delete(posDot + 3, posDot + 4);
                }
            }
        };
        editText.addTextChangedListener(textWatcher);
    }

ScrollView嵌套RecyclerView动态计算item高度

    /** row: recyclerView有几列 */
    private void recyclerRefreshHight(RecyclerView.Adapter adapter, RecyclerView recyclerView, int row) {
        try {
            //获取标题项
//            ReserverPictureAdapter adapter = (ReserverPictureAdapter) recyclerView.getAdapter();

            int dataCount = adapter.getItemCount();
            if (dataCount > 1) {
                //获取第一个子项
                View childAt = recyclerView.getLayoutManager().getChildAt(0);
                ViewGroup.MarginLayoutParams marginLayoutParams = (ViewGroup.MarginLayoutParams) recyclerView.getLayoutParams();
                if (itemHeight == 0) {
                    //子项高度
                    itemHeight = childAt.getMeasuredHeight() + marginLayoutParams.topMargin + marginLayoutParams.bottomMargin;
                }
                //计算出子项行数
                int size = dataCount / row;
                if ((dataCount % row) > 0) {
                    size++;
                }
                //算出列表高度
                int i = itemHeight * size;
                ViewGroup.LayoutParams layoutParams = recyclerView.getLayoutParams();
                //将高度赋值给列表
                layoutParams.height = i + recyclerView.getPaddingTop() + recyclerView.getPaddingBottom();
                recyclerView.setLayoutParams(layoutParams);
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

通过CMD查看栈顶Activity

adb shell dumpsys activity | find “mFoc”

将自定义键盘的删除交由系统处理

// 有时候自定义的删除键 像emotion表情之类的，如果自己写的话需要做很多处理，但是系统的键盘删除键则能轻松的删除， 所以这时候我们就可以把删除交由系统去处理了
  mEditText.dispatchKeyEvent(new KeyEvent(KeyEvent.ACTION_DOWN, KeyEvent.KEYCODE_DEL));

retrofit2 请求 通过拦截器进行 多次重试请求（可自定义时间）

    public static class Retry implements Interceptor {
        public int maxRetry;//最大重试次数
        private int retryNum = 0;//假如设置为3次重试的话，则最大可能请求4次（默认1次+3次重试）

        public void setRetryNum(int retryNum) {
            this.retryNum = retryNum;
        }

        public Retry(int maxRetry) {
            this.maxRetry = maxRetry;
        }

        @Override
        public Response intercept(@NonNull Chain chain) throws IOException {
            Request request = chain.request();
            mChain = chain;
            Response response = null;
            try {
                response = mChain.proceed(request);
            } catch (Exception e) {
                e.printStackTrace();
            } finally {
                L.e("retryNum : " + retryNum);
                while ((response == null && retryNum < maxRetry) || (response != null && !response.isSuccessful() && retryNum < maxRetry)) {
                    retryNum++;
                    Log.e("开始Retry", "num:" + retryNum);
                    try {
                        /*
                        // 动态改变时间
                        if(retryNum <= 2) {
                            chain.withReadTimeout(2, TimeUnit.SECONDS);
                            chain.withConnectTimeout(2, TimeUnit.SECONDS);
                        }else {
                            chain.withReadTimeout(10, TimeUnit.SECONDS);
                            chain.withConnectTimeout(10, TimeUnit.SECONDS);
                        }*/
                        response = mChain.proceed(request);
                    } catch (Exception e) {
                        e.printStackTrace();
                        Log.e("失败", "num:" + retryNum);
                    }
                }
            }
            retryNum = 0;
            return response == null ? mChain.proceed(chain.request()) : response;
        }
    }

Edittext 显示（明文） 或 隐藏（密文） 密码（内容）

// 明文
edt.setTransformationMethod(HideReturnsTransformationMethod.getInstance());

// 密文
edt.setTransformationMethod(PasswordTransformationMethod.getInstance());

版本号间的比较

    /**
     * 比较版本号的大小,前者大则返回一个正数,后者大返回一个负数,相等则返回0
     *
     * @param currentVersion 当前版本号
     * @param newVersion     新版本号
     * @return
     */
    public int compareVersion(String currentVersion, String newVersion) throws Exception {
        if (currentVersion == null || newVersion == null) {
            throw new Exception("compareVersion error:illegal params.");
        }
        String[] versionArray1 = currentVersion.split("\\.");//注意此处为正则匹配，不能用"."；
        for (int i = 0; i < versionArray1.length; i++) { //如果位数只有一位则自动补零（防止出现一个是04，一个是5 直接以长度比较）
            if (versionArray1[i].length() == 1) {
                versionArray1[i] = "0" + versionArray1[i];
            }
        }
        String[] versionArray2 = newVersion.split("\\.");
        for (int i = 0; i < versionArray2.length; i++) {//如果位数只有一位则自动补零
            if (versionArray2[i].length() == 1) {
                versionArray2[i] = "0" + versionArray2[i];
            }
        }
        int idx = 0;
        int minLength = Math.min(versionArray1.length, versionArray2.length);//取最小长度值
        int diff = 0;
        while (idx < minLength
                && (diff = versionArray1[idx].length() - versionArray2[idx].length()) == 0//先比较长度
                && (diff = versionArray1[idx].compareTo(versionArray2[idx])) == 0) {//再比较字符
            ++idx;
        }
        //如果已经分出大小，则直接返回，如果未分出大小，则再比较位数，有子版本的为大；
        diff = (diff != 0) ? diff : versionArray1.length - versionArray2.length;
        return diff;
    }