安卓 常用汇总

效果

BottomNavigationView 解决点击默认阴影

<!--解决点击默认阴影-->
app:itemBackground="@color/white"

GridView 高度自动适应

public class CustomGridView extends GridView {

    public CustomGridView(Context context) {
        super(context);
    }

    public CustomGridView(Context context, AttributeSet attrs) {
        super(context, attrs);
    }

    public CustomGridView(Context context, AttributeSet attrs, int defStyleAttr) {
        super(context, attrs, defStyleAttr);
    }

    @TargetApi(Build.VERSION_CODES.LOLLIPOP)
    public CustomGridView(Context context, AttributeSet attrs, int defStyleAttr, int defStyleRes) {
        super(context, attrs, defStyleAttr, defStyleRes);
    }

    @Override
    protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) {
        int height=MeasureSpec.makeMeasureSpec(Integer.MAX_VALUE>>2,MeasureSpec.AT_MOST);
        super.onMeasure(widthMeasureSpec, height);
    }
}

GridView 去掉item点击阴影效果

<!--解决点击默认阴影-->
android:listSelector="@android:color/transparent"

工具类

SharedPreferences 存储工具类

/**
 * 存储
 */
public final class SPUtils {

    private SharedPreferences sp;
    private static final String FILE_SP_NAME = "SpConfig";
    private static SPUtils mSPUtils;

    public SPUtils(Context context) {
        sp = context.getSharedPreferences(FILE_SP_NAME, Context.MODE_PRIVATE);
    }

    public static SPUtils getInstance(Context context) {
        if (mSPUtils == null) {
            synchronized (SPUtils.class) {
                if (mSPUtils == null) {
                    mSPUtils = new SPUtils(context);
                }
            }
        }
        return mSPUtils;
    }

    //    ---------------------  String ----------------------------

    /**
     * SP中写入String
     *
     * @param key   键
     * @param value 值
     */
    public void put(String key, String value) {
        sp.edit().putString(key, value).apply();
    }

    /**
     * SP中读取String
     *
     * @param key 键
     * @return 存在返回对应值，不存在返回默认值{@code ""}
     */
    public String getString(String key) {
        return getString(key, "");
    }

    /**
     * SP中读取String
     *
     * @param key 键
     * @return 存在返回对应值，存在返回默认值{@code defaultValue}
     */
    public String getString(String key, String defaultValue) {
        return sp.getString(key, defaultValue);
    }


    //    ---------------------  int ----------------------------

    /**
     * SP中写入int
     *
     * @param key   键
     * @param value 值
     */
    public void put(String key, int value) {
        sp.edit().putInt(key, value).apply();
    }


    /**
     * SP中读取int
     *
     * @param key 键
     * @return 存在返回对应值，不存在返回默认值{@code ""}
     */
    public int getInt(String key) {
        return getInt(key, -1);
    }

    /**
     * SP中读取int
     *
     * @param key 键
     * @return 存在返回对应值，存在返回默认值{@code defaultValue}
     */
    public int getInt(String key, int defaultValue) {
        return sp.getInt(key, defaultValue);
    }


    //    ---------------------  long ----------------------------

    /**
     * SP中写入long
     *
     * @param key   键
     * @param value 值
     */
    public void put(String key, long value) {
        sp.edit().putLong(key, value).apply();
    }

    /**
     * SP中读取long
     *
     * @param key 键
     * @return 存在返回对应值，不存在返回默认值-1
     */
    public long getLong(String key) {
        return getLong(key, -1L);
    }

    /**
     * SP中读取long
     *
     * @param key          键
     * @param defaultValue 默认值
     * @return 存在返回对应值，不存在返回默认值{@code defaultValue}
     */
    public long getLong(String key, long defaultValue) {
        return sp.getLong(key, defaultValue);
    }


    //    ---------------------  float ----------------------------

    /**
     * SP中写入float
     *
     * @param key   键
     * @param value 值
     */
    public void put(String key, float value) {
        sp.edit().putFloat(key, value).apply();
    }

    /**
     * SP中读取float
     *
     * @param key 键
     * @return 存在返回对应值，不存在返回默认值-1
     */
    public float getFloat(String key) {
        return getFloat(key, -1f);
    }

    /**
     * SP中读取float
     *
     * @param key          键
     * @param defaultValue 默认值
     * @return 存在返回对应值，不存在返回默认值{@code defaultValue}
     */
    public float getFloat(String key, float defaultValue) {
        return sp.getFloat(key, defaultValue);
    }


    //    ---------------------  boolean ----------------------------

    /**
     * SP中写入boolean
     *
     * @param key   键
     * @param value 值
     */
    public void put(String key, boolean value) {
        sp.edit().putBoolean(key, value).apply();
    }


    /**
     * SP中读取boolean
     *
     * @param key 键
     * @return 存在返回对应值，不存在返回默认值{@code false}
     */
    public boolean getBoolean(String key) {
        return getBoolean(key, false);
    }

    /**
     * SP中读取boolean
     *
     * @param key          键
     * @param defaultValue 默认值
     * @return 存在返回对应值，不存在返回默认值{@code defaultValue}
     */
    public boolean getBoolean(String key, boolean defaultValue) {
        return sp.getBoolean(key, defaultValue);
    }

    //    ---------------------  Set ----------------------------

    /**
     * SP中写入Set
     *
     * @param key   键
     * @param values 值
     */
    public void put(String key, Set<String> values) {
        sp.edit().putStringSet(key, values).apply();
    }


    /**
     * SP中读取StringSet
     *
     * @param key 键
     * @return 存在返回对应值，不存在返回默认值{@code Collections.<String>emptySet()}
     */
    public Set<String> getStringSet(String key) {
        return getStringSet(key, Collections.<String>emptySet());
    }

    /**
     * SP中读取StringSet
     *
     * @param key 键
     * @param defaultValue 默认值
     * @return 存在返回对应值，不存在返回默认值{@code defaultValue}
     */
    public Set<String> getStringSet(String key, Set<String> defaultValue) {
        return sp.getStringSet(key, defaultValue);
    }



    /**
     * SP中写入list
     *
     * @param key   键
     * @param values 值
     */
    public void put(String key, List<String> values) {
        Gson gson = new Gson();
        //转换成json数据，再保存
        String strJson = gson.toJson(values);
        sp.edit().putString(key,strJson)
                .apply();
    }

    /**
     * SP中读取list
     *
     * @param key 键
     * @return 存在返回对应值，不存在返回默认值
     */
    public List<String> getStringList(String key){
        List<String> mList = new ArrayList<>();
        String strJson = getString(key);
        if (null == strJson) {
            return mList;
        }
        Gson gson = new Gson();
        mList = gson.fromJson(strJson, new TypeToken<List<String>>() {
        }.getType());
        return mList;
    }

    /**
     * SP中是否存在该key
     *
     * @param key
     * @return {@code true}: 存在<br>{@code false}: 不存在
     */
    public boolean contains(String key) {
        return sp.contains(key);
    }

    /**
     * SP中移除该key
     *
     * @param key 键
     */
    public void remove(String key) {
        sp.edit().remove(key).apply();
    }


    /**
     * SP中清除所有数据
     */
    public void clear() {
        sp.edit().clear().apply();
    }
}

权限

    <uses-permission android:name="android.permission.CALL_PHONE"/> <!-- 拨打电话权限 -->
    <uses-permission android:name="android.permission.SEND_SMS"/><!-- 发送短信权限 -->

public class Permission {
    public static final int REQUEST_CODE = 5;
    //定义权限
    private static final String[] permission = new String[]{
            Manifest.permission.CALL_PHONE,Manifest.permission.SEND_SMS
    };
    //每个权限是否已授
    public static boolean isPermissionGranted(Activity activity){
        if(Build.VERSION.SDK_INT >= 23){
            for(int i = 0; i < permission.length;i++) {
                int checkPermission = ContextCompat.checkSelfPermission(activity,permission[i]);
                /***
                 * checkPermission返回两个值
                 * 有权限: PackageManager.PERMISSION_GRANTED
                 * 无权限: PackageManager.PERMISSION_DENIED
                 */
                if(checkPermission != PackageManager.PERMISSION_GRANTED){
                    return false;
                }
            }
            return true;
        }else{
            return true;
        }
    }

    public static boolean checkPermission(Activity activity){
        if(isPermissionGranted(activity)) {
            return true;
        } else {
            //如果没有设置过权限许可，则弹出系统的授权窗口
            ActivityCompat.requestPermissions(activity,permission,REQUEST_CODE);
            return false;
        }
    }
}

// 使用
 @Override
    protected void onResume() {
        super.onResume();
        if(Permission.isPermissionGranted(this)) {
        }else{
            Permission.checkPermission(this);
        }
    }
    @Override
    public void onRequestPermissionsResult(
            int requestCode, @NonNull String[] permissions, @NonNull int[] grantResults) {
        super.onRequestPermissionsResult(requestCode, permissions, grantResults);
        if (requestCode == Permission.REQUEST_CODE) {
            for (int grantResult : grantResults) {
                if (grantResult != PackageManager.PERMISSION_GRANTED) {
                    // 授权失败，退出应用
                    this.finish();
                    return;
                }
            }
        }
    }

自定义布局

提示

辅助类

public enum PromptType {
    /**
     * 文字提示
     */
    PromptFont(1),
    /**
     * 加载提示
     */
    PromptLoading(2);

    PromptType(int index) {
        this.index = index;
    }

    private int index;

    public int getIndex() {
        return index;
    }

    public void setIndex(int index) {
        this.index = index;
    }
}



public class SLTool {
    private Context context;
    /**
     * 提示  /   加载提示
     */
    private String message = "提示";
    /**
     * 文字提示  /   loading + 文字
     */
    private PromptType promptType = PromptType.PromptFont;
    /**
     * 是否自动隐藏
     */
    private Boolean onHide = true;
    /**
     * 自动隐藏时间
     */
    private int autoTime = 600;
    
    public SLTool(Context context) {
        this.context = context;
    }
    // get / set
}



/**
 * 文字提示   /    loading + 文字
 */
public class DialogView {
    private View popup_view;
    private PopupWindow popupWindow;
    private TextView dialog_message;
    private View imageView;

    public DialogView(Context context, SLTool slTool, Window window) {
        Resources resources = context.getResources();
        DisplayMetrics dm = resources.getDisplayMetrics();
        int widthPixels = dm.widthPixels;
        int heightPixels = dm.heightPixels;
        popup_view = LayoutInflater.from(context).inflate(R.layout.sl_view_prompt, null);
        dialog_message = popup_view.findViewById(R.id.dialog_message);
        imageView = popup_view.findViewById(R.id.imageViewloding);
        if (slTool.getPromptType() == PromptType.PromptFont) {
            imageView.setVisibility(View.GONE);
        }
        if (slTool.getPromptType() == PromptType.PromptLoading) {
            imageView.setVisibility(View.VISIBLE);
        }
        popupWindow = new PopupWindow(widthPixels, heightPixels);
        popupWindow.setContentView(popup_view);
        popupWindow.setOutsideTouchable(false);
        popupWindow.setFocusable(true);
    }

    /**
     * 设置弹窗信息
     */
    public void setMessage(String Message) {
        dialog_message.setText(Message);
    }

    public void show(SLTool slTool, Window window) {
        SLUtils.DarkenBackground(.5f,window);
        popupWindow.showAsDropDown(popup_view);
        if (slTool.getOnHide()) {
            dialog_message.postDelayed(new Runnable() {
                @Override
                public void run() { // 弹窗自动关闭
                    hide(window);
                }
            }, slTool.getAutoTime());
        }
    }

    public void hide(Window window) { // 提供给外部的隐藏
        SLUtils.DarkenBackground(1f,window);
        popupWindow.dismiss();
    }
}

布局

<?xml version="1.0" encoding="utf-8"?>
<RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android"
                android:layout_width="wrap_content"
                android:layout_height="wrap_content"
                android:id="@+id/dialog_view">
    <LinearLayout android:layout_width="wrap_content"
                  android:layout_centerInParent="true"
                  android:layout_height="wrap_content"
                  android:orientation="vertical">

        <pl.droidsonroids.gif.GifImageView
                android:visibility="gone"
                android:id="@+id/imageViewloding"
                android:layout_width="fill_parent"
                android:layout_height="wrap_content"
                android:src="@drawable/loding"
        />
        <TextView
                android:id="@+id/dialog_message"
                android:layout_width="wrap_content"
                android:layout_height="wrap_content"
                android:gravity="center"
                android:textColor="@color/teal_200"
                android:textSize="22sp"
        />
    </LinearLayout>

</RelativeLayout>

模态框

辅助类

public class SLToolPrompt {
    private Context context;
    private Handler handler; // 事件传递
    /**
     * 文本内容
     */
    private String message = "文本内容";
    /**
     * 标题
     */
    private String title = "标题";
    /**
     * 标题是否显示
     */
    private Boolean ISTitle = true;


    /**
     * 按钮文本
     */
    private String cancel = "取消";
    private String confirm = "确认";

    /**
     * 取消是否显示
     */
    private Boolean ISCancel = true;

    public SLToolPrompt(Context context,Handler handler) {
        this.context = context;
        this.handler = handler;
    }
    // get / set
}


/**
 * 取消   /   确认
 */
public class DialogPrompt {
    private View popup_view;
    private PopupWindow popupWindow;
    private TextView confirm_title;
    private TextView confirm_message;
    private Button confirm_cancel;
    private Button confirm_confirm;


    public DialogPrompt(SLToolPrompt slToolPrompt, Window window) {
        Resources resources = slToolPrompt.getContext().getResources();
        DisplayMetrics dm = resources.getDisplayMetrics();
        popup_view = LayoutInflater.from(slToolPrompt.getContext()).inflate(R.layout.sl_view_confirm, null);
        confirm_title = popup_view.findViewById(R.id.confirm_title);
        if(slToolPrompt.getISTitle()){
            confirm_title.setText(slToolPrompt.getTitle());
            confirm_title.setVisibility(View.VISIBLE);
        }else{
            confirm_title.setVisibility(View.GONE);
        }
        confirm_message = popup_view.findViewById(R.id.confirm_message);
        confirm_message.setText(slToolPrompt.getMessage());
        confirm_cancel = popup_view.findViewById(R.id.confirm_cancel);
        if(slToolPrompt.getISCancel()){
            confirm_cancel.setText(slToolPrompt.getCancel());
            confirm_cancel.setVisibility(View.VISIBLE);
            confirm_cancel.setOnClickListener(new View.OnClickListener() {
                @Override
                public void onClick(View v) {
                    Message mes = new Message();
                    mes.what = 1;
                    mes.obj = "取消事件触发";
                    slToolPrompt.getHandler().sendMessage(mes);
                    hide(window);
                }
            });
        }else{
            confirm_cancel.setVisibility(View.GONE);
        }
        confirm_confirm = popup_view.findViewById(R.id.confirm_confirm);
        confirm_confirm.setText(slToolPrompt.getConfirm());
        confirm_confirm.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                Message mes = new Message();
                mes.what = 1;
                mes.obj = "确认事件触发";
                slToolPrompt.getHandler().sendMessage(mes);
                hide(window);
            }
        });
        popupWindow = new PopupWindow(popup_view,dm.widthPixels,dm.heightPixels);
        popupWindow.setOnDismissListener(new PopupWindow.OnDismissListener() {
            @Override
            public void onDismiss() {
                hide(window);
            }
        });
        popupWindow.setOutsideTouchable(true);
        popupWindow.setFocusable(true);
    }

    public void show(Window window) { // 提供给外部的显示
        SLUtils.DarkenBackground(.5f,window);
        popupWindow.showAsDropDown(popup_view);
    }

    public void hide(Window window) { // 提供给外部的隐藏
        SLUtils.DarkenBackground(1f,window);
        popupWindow.dismiss();
    }
}

布局

<?xml version="1.0" encoding="utf-8"?>
<RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android"
                android:layout_width="match_parent"
                android:layout_height="match_parent"
                android:id="@+id/dialog_view"
                android:background="@color/transparent">
    <LinearLayout android:layout_width="match_parent"
                  android:paddingTop="20dp"
                  android:layout_marginRight="40dp"
                  android:layout_marginLeft="40dp"
                  android:paddingRight="20dp"
                  android:paddingLeft="20dp"
                  android:paddingBottom="6dp"
                  android:layout_centerInParent="true"
                  android:layout_height="wrap_content"
                  android:background="@drawable/prompt_confirm"
                  android:orientation="vertical">

        <TextView android:layout_width="wrap_content"
                  android:text="标题"
                  android:id="@+id/confirm_title"
                  android:layout_marginBottom="10dp"
                  android:layout_gravity="center"
                  android:layout_height="match_parent">

        </TextView>

        <ScrollView
                android:id="@+id/sv"
                android:layout_width="match_parent"
                android:layout_height="80dp"
        >
            <RelativeLayout android:layout_width="match_parent"
                            android:layout_height="match_parent">
                <TextView android:layout_width="match_parent"
                          android:textSize="12sp"
                          android:background="@color/white"
                          android:text="文本内容"
                          android:id="@+id/confirm_message"
                          android:layout_gravity="center"
                          android:textColor="@color/promptcancel"
                          android:layout_marginBottom="10dp"
                          android:layout_height="wrap_content">
                </TextView>
            </RelativeLayout>
        </ScrollView>


        <LinearLayout android:layout_width="match_parent"
                      android:background="@color/gray"
                      android:layout_height="1dp">

        </LinearLayout>
        <LinearLayout android:layout_width="match_parent"
                      android:background="@color/white"
                      android:layout_height="50dp">
            <Button android:layout_weight="1"
                    android:text="取消"
                    android:layout_gravity="center"
                    android:layout_width="wrap_content"
                    android:background="@color/white"
                    android:layout_height="45dp"
                    android:id="@+id/confirm_cancel"
                    android:stateListAnimator="@null">

            </Button>
            <LinearLayout android:layout_width="1dp"
                          android:background="@color/gray"
                          android:layout_height="60dp">

            </LinearLayout>
            <Button android:layout_weight="1"
                    android:text="确认"
                    android:layout_gravity="center"
                    android:id="@+id/confirm_confirm"
                    android:textColor="@color/promptconfirmfont"
                    android:background="@color/white"
                    android:layout_width="wrap_content"
                    android:layout_height="45dp"
                    android:stateListAnimator="@null">
            </Button>
        </LinearLayout>
    </LinearLayout>

</RelativeLayout>

汇总 SLUtils

public class SLUtils {
    /**
     * APP 开始开发时间
     * @return
     */
    public static Long GetStartTime() {
        return 1696811598000L;
    }

    /**
     * 提示
     *
     * @param slTool 辅助类
     * @param window 窗体
     * @return
     */
    public static DialogView GetSlDialogView(SLTool slTool, Window window) {
        DialogView mDialogView = new DialogView(slTool.getContext(), slTool, window);
        mDialogView.setMessage(slTool.getMessage());
        mDialogView.show(slTool, window);
        return mDialogView;
    }

    /**
     * 模态框
     *
     * @param slToolPrompt 辅助类
     * @param window       窗体
     * @return
     */
    public static DialogPrompt GetSlDialogPrompt(SLToolPrompt slToolPrompt, Window window) {
        DialogPrompt mDialogView = new DialogPrompt(slToolPrompt, window);
        mDialogView.show(window);
        return mDialogView;
    }

    /**
     * 改变背景颜色
     */
    public static void DarkenBackground(Float bgcolor, Window window) {
        WindowManager.LayoutParams lp = window.getAttributes();
        lp.alpha = bgcolor;
        window.addFlags(WindowManager.LayoutParams.FLAG_DIM_BEHIND);
        window.setAttributes(lp);
    }
}