Studio/APPBase
3
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

clone https://gitea.winboll.cc/Studio/WinBoLL_Bck20251205_175044_440.git and fix build.gradle file maven key settings.

Browse Source
This commit is contained in:
ZhangShaojian
2025-12-05 18:19:49 +08:00
commit 2a74fd2c30
1439 changed files with 94814 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

1
libappbase/.gitignore vendored Normal file
View File

@@ -0,0 +1 @@
/build

28
libappbase/build.gradle Normal file
View File

@@ -0,0 +1,28 @@
apply plugin: 'com.android.library'
apply plugin: 'maven-publish'
apply from: '../.winboll/winboll_lib_build.gradle'
apply from: '../.winboll/winboll_lint_build.gradle'
android {
// 1. compileSdkVersion：必须 ≥ targetSdkVersion，建议直接等于 targetSdkVersion（30）
compileSdkVersion 30
// 2. buildToolsVersion：需匹配 compileSdkVersion，建议使用 30.x.x 最新稳定版（无需高于 compileSdkVersion）
buildToolsVersion "30.0.3" // 这是 30 对应的最新稳定版，避免使用 beta 版
defaultConfig {
minSdkVersion 23
targetSdkVersion 30
}
buildTypes {
release {
minifyEnabled false
proguardFiles getDefaultProguardFile('proguard-android.txt'), 'proguard-rules.pro'
}
}
}
dependencies {
api fileTree(dir: 'libs', include: ['*.jar'])
}

8
libappbase/build.properties Normal file
View File

@@ -0,0 +1,8 @@
#Created by .winboll/winboll_app_build.gradle
#Fri Nov 21 11:41:04 HKT 2025
stageCount=2
libraryProject=libappbase
baseVersion=15.11
publishVersion=15.11.1
buildCount=0
baseBetaVersion=15.11.2

17
libappbase/proguard-rules.pro vendored Normal file
View File

@@ -0,0 +1,17 @@
# Add project specific ProGuard rules here.
# By default, the flags in this file are appended to flags specified
# in C:/tools/adt-bundle-windows-x86_64-20131030/sdk/tools/proguard/proguard-android.txt
# You can edit the include path and order by changing the proguardFiles
# directive in build.gradle.
#
# For more details, see
# http://developer.android.com/guide/developing/tools/proguard.html
# Add any project specific keep options here:
# If your project uses WebView with JS, uncomment the following
# and specify the fully qualified class name to the JavaScript interface
# class:
#-keepclassmembers class fqcn.of.javascript.interface.for.webview {
# public *;
#}

33
libappbase/src/main/AndroidManifest.xml Normal file
View File

@@ -0,0 +1,33 @@
<?xml version='1.0' encoding='utf-8'?>
<manifest
xmlns:android="http://schemas.android.com/apk/res/android"
package="cc.winboll.studio.libappbase">
<application>
<activity
android:name=".CrashHandler$CrashActivity"
android:label="CrashActivity"
android:launchMode="singleInstance"
android:process=":CrashActivity"/>
<activity
android:name=".GlobalCrashActivity"
android:label="GlobalCrashActivity"
android:launchMode="singleInstance"
android:process=":GlobalCrashActivity"/>
<activity
android:name=".LogActivity"
android:label="LogActivity"
android:resizeableActivity="true"
android:configChanges="screenSize|smallestScreenSize|screenLayout|orientation"
android:exported="true"
android:launchMode="singleInstance"
android:process=":LogActivity">
</activity>
</application>
</manifest>

138
libappbase/src/main/java/cc/winboll/studio/libappbase/APPModel.java Normal file
View File

@@ -0,0 +1,138 @@
package cc.winboll.studio.libappbase;
import android.util.JsonReader;
import android.util.JsonWriter;
import java.io.IOException;
/**
* @Author ZhanGSKen&豆包大模型<zhangsken@qq.com>
* @Date 2025/11/11 20:01
* @Describe WinBoLL 应用全局数据模型类
* 继承自 BaseBean，用于存储和管理应用的核心配置信息（如调试状态），
* 支持 JSON 序列化/反序列化，便于数据持久化或跨组件传递
*/
public class APPModel extends BaseBean {
/**
* 日志打印标签，用于区分当前类的日志输出
*/
public static final String TAG = "APPModel";
/**
* 应用调试状态标识
* true：应用处于调试模式（可输出详细日志、启用调试功能等）
* false：应用处于正式模式（关闭调试相关功能，优化性能）
*/
private boolean isDebugging = false; // 修正拼写：原 isDebuging -> isDebugging（符合命名规范）
/**
* 无参构造方法
* 初始化调试状态为默认值：false（正式模式）
*/
public APPModel() {
this.isDebugging = false;
}
/**
* 带参构造方法
* 可通过参数指定应用的初始调试状态
* @param isDebugging 初始调试状态（true：调试模式；false：正式模式）
*/
public APPModel(boolean isDebugging) {
this.isDebugging = isDebugging;
}
/**
* 设置应用调试状态
* @param isDebugging 目标调试状态（true：开启调试；false：关闭调试）
*/
public void setIsDebugging(boolean isDebugging) {
this.isDebugging = isDebugging;
}
/**
* 获取当前应用调试状态
* @return 调试状态（true：调试中；false：非调试）
*/
public boolean isDebugging() {
return isDebugging;
}
/**
* 重写父类方法，返回当前类的全限定名
* 用于标识数据模型的类类型（可用于反射、序列化校验等场景）
* @return 类的全限定名（如：cc.winboll.studio.libappbase.APPModel）
*/
@Override
public String getName() {
return APPModel.class.getName();
}
/**
* 重写父类方法，将当前模型的字段序列化到 JSON 中
* 用于将调试状态等核心数据转换为 JSON 格式（如持久化到文件、网络传输）
* @param jsonWriter JSON 写入器对象，用于输出 JSON 数据
* @throws IOException 当 JSON 写入失败时抛出（如流关闭、格式错误）
*/
@Override
public void writeThisToJsonWriter(JsonWriter jsonWriter) throws IOException {
// 先调用父类方法，序列化父类中的字段（若 BaseBean 有可序列化字段）
super.writeThisToJsonWriter(jsonWriter);
// 序列化当前类的调试状态字段：key 为 "isDebuging"（保持与原代码一致，避免兼容性问题），value 为当前状态
jsonWriter.name("isDebuging").value(isDebugging());
}
/**
* 重写父类方法，从 JSON 中解析字段并初始化当前对象
* 用于将 JSON 格式的配置数据解析为 APPModel 实例（如从文件读取、网络接收后解析）
* @param jsonReader JSON 读取器对象，用于读取 JSON 数据
* @param name 当前解析的 JSON 字段名
* @return true：字段解析成功；false：字段不属于当前类，需由调用者处理
* @throws IOException 当 JSON 读取失败时抛出（如流关闭、数据格式错误）
*/
@Override
public boolean initObjectsFromJsonReader(JsonReader jsonReader, String name) throws IOException {
// 先调用父类方法，解析父类中的字段（若 BaseBean 有可解析字段）
if (super.initObjectsFromJsonReader(jsonReader, name)) {
return true; // 父类已处理该字段，直接返回成功
} else {
// 解析当前类的字段
if (name.equals("isDebuging")) {
// 读取 JSON 中 "isDebuging" 字段的值，设置为当前对象的调试状态
setIsDebugging(jsonReader.nextBoolean());
} else {
// 字段不属于当前类，返回 false 提示调用者跳过该字段
return false;
}
}
// 字段解析成功，返回 true
return true;
}
/**
* 重写父类方法，从 JSON 读取器中完整解析一个 APPModel 实例
* 负责处理 JSON 对象的开始/结束标记，循环解析所有字段
* @param jsonReader JSON 读取器对象，用于读取 JSON 数据
* @return 解析完成的当前 APPModel 实例（支持链式调用）
* @throws IOException 当 JSON 读取失败时抛出（如流关闭、数据格式错误）
*/
@Override
public BaseBean readBeanFromJsonReader(JsonReader jsonReader) throws IOException {
// 开始解析 JSON 对象（对应 JSON 中的 '{'）
jsonReader.beginObject();
// 循环读取 JSON 中的所有字段（直到对象结束）
while (jsonReader.hasNext()) {
// 获取当前字段名
String name = jsonReader.nextName();
// 解析字段：若当前类无法处理该字段，则跳过（避免解析异常）
if (!initObjectsFromJsonReader(jsonReader, name)) {
jsonReader.skipValue();
}
}
// 结束解析 JSON 对象（对应 JSON 中的 '}'）
jsonReader.endObject();
// 返回解析完成的实例（当前对象）
return this;
}
}

436
libappbase/src/main/java/cc/winboll/studio/libappbase/BaseBean.java Normal file
View File

@@ -0,0 +1,436 @@
package cc.winboll.studio.libappbase;
import android.content.Context;
import android.util.JsonReader;
import android.util.JsonWriter;
import java.io.File;
import java.io.IOException;
import java.io.StringReader;
import java.io.StringWriter;
import java.util.ArrayList;
/**
* @Author ZhanGSKen&豆包大模型<zhangsken@qq.com>
* @Date 2025/11/11 20:03
* @Describe WinBoLL JSON 数据模型基类（抽象类）
* 定义 Json Bean 的核心规范：序列化/反序列化、文件持久化、列表处理等通用逻辑，
* 子类（如 APPModel）需实现抽象方法，实现自身字段的 JSON 读写
* @param <T> 泛型约束，限定子类必须继承自 BaseBean
*/
public abstract class BaseBean<T extends BaseBean> {
/** 日志标签，用于当前基类的日志输出标识 */
public static final String TAG = "BaseBean";
/** JSON 中存储 Bean 类名的字段键（用于校验 Bean 类型一致性） */
static final String BEAN_NAME = "BeanName";
/**
* 无参构造方法（子类需默认实现，支持反射实例化）
*/
public BaseBean() {}
/**
* 抽象方法：获取当前 Bean 的全限定类名
* 子类需实现，用于标识 Bean 类型（序列化/校验时使用）
* @return 类的全限定名（如：cc.winboll.studio.libappbase.APPModel）
*/
public abstract String getName();
/**
* 获取单个 Bean 的 JSON 持久化文件路径
* 路径：外部存储/应用私有目录/BaseBean/[类名].json
* @param context 上下文（用于获取应用存储目录）
* @return 单个 Bean 的文件绝对路径
*/
public String getBeanJsonFilePath(Context context) {
return context.getExternalFilesDir(TAG) + "/" + getName() + ".json";
}
/**
* 获取 Bean 列表的 JSON 持久化文件路径
* 路径：外部存储/应用私有目录/BaseBean/[类名]_List.json
* @param context 上下文（用于获取应用存储目录）
* @return Bean 列表的文件绝对路径
*/
public String getBeanListJsonFilePath(Context context) {
return context.getExternalFilesDir(TAG) + "/" + getName() + "_List.json";
}
/**
* 将 Bean 类名写入 JSON（序列化基础字段）
* 子类可重写扩展，添加自身字段的 JSON 写入逻辑
* @param jsonWriter JSON 写入器（用于输出 JSON 数据）
* @throws IOException JSON 写入失败时抛出（如流异常）
*/
public void writeThisToJsonWriter(JsonWriter jsonWriter) throws IOException {
// 写入 Bean 类名字段（用于反序列化时校验类型）
jsonWriter.name(BEAN_NAME).value(getName());
}
/**
* 从 JSON 读取字段并初始化 Bean（反序列化基础逻辑）
* 子类需重写，实现自身字段的解析逻辑
* @param jsonReader JSON 读取器（用于读取 JSON 数据）
* @param name 当前解析的 JSON 字段名
* @return true：字段解析成功（当前类处理）；false：字段未处理（需跳过）
* @throws IOException JSON 读取失败时抛出（如流异常）
*/
public boolean initObjectsFromJsonReader(JsonReader jsonReader, String name) throws IOException {
return false; // 基类未处理任何字段，返回 false
}
/**
* 抽象方法：从 JSON 读取器解析并返回 Bean 实例
* 子类需实现，处理自身字段的完整解析逻辑
* @param jsonReader JSON 读取器（用于读取 JSON 数据）
* @return 解析完成的 Bean 实例
* @throws IOException JSON 读取失败时抛出（如流异常）
*/
abstract public T readBeanFromJsonReader(JsonReader jsonReader) throws IOException;
/**
* 校验 JSON 文件中的 Bean 列表与目标类是否一致
* 对比文件中每个 Bean 的类名与目标类名，返回不一致信息
* @param szFilePath JSON 文件路径（存储 Bean 列表的文件）
* @param clazz 目标 Bean 类（用于校验类型）
* @return 空串：校验一致；非空串：不一致信息（总数/差异数）或异常信息
* @param <T> 泛型约束，限定为 BaseBean 子类
*/
public static <T extends BaseBean> String checkIsTheSameBeanListAndFile(String szFilePath, Class<T> clazz) {
StringBuilder sbResult = new StringBuilder();
String szErrorInfo = "Check Is The Same Bean List And File Error : ";
try {
int sameCount = 0; // 类名匹配的 Bean 数量
int totalCount = 0; // 文件中 Bean 总数量
// 反射创建目标 Bean 实例（用于获取类名）
T beanTemp = clazz.newInstance();
String targetBeanName = beanTemp.getName();
// 读取文件中的 JSON 字符串
String listJson = UTF8FileUtils.readStringFromFile(szFilePath);
StringReader stringReader = new StringReader(listJson);
JsonReader jsonReader = new JsonReader(stringReader);
jsonReader.beginArray(); // 开始解析 JSON 数组（Bean 列表）
while (jsonReader.hasNext()) {
totalCount++;
jsonReader.beginObject(); // 开始解析单个 Bean 对象
while (jsonReader.hasNext()) {
String name = jsonReader.nextName();
// 只校验 BEAN_NAME 字段，其他字段跳过
if (name.equals(BEAN_NAME)) {
// 对比当前 Bean 类名与目标类名
if (targetBeanName.equals(jsonReader.nextString())) {
sameCount++;
}
} else {
jsonReader.skipValue(); // 跳过非目标字段
}
}
jsonReader.endObject(); // 结束单个 Bean 对象解析
}
jsonReader.endArray(); // 结束 JSON 数组解析
// 生成校验结果
if (sameCount == totalCount) {
return ""; // 全部匹配，返回空串
} else {
// 部分不匹配，返回统计信息
sbResult.append("Total : ").append(totalCount)
.append(" Diff : ").append(totalCount - sameCount);
}
} catch (InstantiationException e) {
// 反射实例化失败（如无无参构造）
sbResult.append(szErrorInfo).append(e);
LogUtils.d(TAG, e.getMessage(), Thread.currentThread().getStackTrace());
} catch (IllegalAccessException e) {
// 反射访问权限异常
sbResult.append(szErrorInfo).append(e);
LogUtils.d(TAG, e.getMessage(), Thread.currentThread().getStackTrace());
} catch (IOException e) {
// 文件读取或 JSON 解析异常
sbResult.append(szErrorInfo).append(e);
LogUtils.d(TAG, e.getMessage(), Thread.currentThread().getStackTrace());
}
return sbResult.toString();
}
/**
* 将 JSON 字符串解析为目标 Bean 实例
* 通过反射创建 Bean 实例，调用子类解析逻辑完成初始化
* @param szBean JSON 字符串（单个 Bean 的 JSON 数据）
* @param clazz 目标 Bean 类（用于反射实例化）
* @return 解析成功的 Bean 实例；失败返回 null
* @throws IOException JSON 解析失败时抛出
* @param <T> 泛型约束，限定为 BaseBean 子类
*/
public static <T extends BaseBean> T parseStringToBean(String szBean, Class<T> clazz) throws IOException {
StringReader stringReader = new StringReader(szBean);
JsonReader jsonReader = new JsonReader(stringReader);
try {
// 反射创建 Bean 实例
T beanTemp = clazz.newInstance();
// 调用子类解析方法，返回解析后的实例
return (T) beanTemp.readBeanFromJsonReader(jsonReader);
} catch (InstantiationException | IllegalAccessException e) {
// 反射异常日志记录
LogUtils.d(TAG, e.getMessage(), Thread.currentThread().getStackTrace());
}
return null;
}
/**
* 将 JSON 字符串解析为 Bean 列表
* 清空目标列表，将解析后的 Bean 逐个添加到列表中
* @param szBeanList JSON 字符串（Bean 列表的 JSON 数组）
* @param beanList 目标列表（存储解析后的 Bean）
* @param clazz 目标 Bean 类（用于反射实例化）
* @return true：解析成功；false：解析失败
* @param <T> 泛型约束，限定为 BaseBean 子类
*/
public static <T extends BaseBean> boolean parseStringToBeanList(String szBeanList, ArrayList<T> beanList, Class<T> clazz) {
try {
// 初始化目标列表（为空则创建，非空则清空）
if (beanList == null) {
beanList = new ArrayList<T>();
} else {
beanList.clear();
}
StringReader stringReader = new StringReader(szBeanList);
JsonReader jsonReader = new JsonReader(stringReader);
jsonReader.beginArray(); // 开始解析 JSON 数组
while (jsonReader.hasNext()) {
// 反射创建 Bean 实例，解析并添加到列表
T beanTemp = clazz.newInstance();
T bean = (T) beanTemp.readBeanFromJsonReader(jsonReader);
if (bean != null) {
beanList.add(bean);
}
}
jsonReader.endArray(); // 结束 JSON 数组解析
return true;
} catch (InstantiationException | IllegalAccessException | IOException e) {
// 异常日志记录
LogUtils.d(TAG, e.getMessage(), Thread.currentThread().getStackTrace());
}
return false;
}
/**
* 重写 toString()，将 Bean 序列化为格式化的 JSON 字符串
* 调用自身序列化逻辑，生成带缩进的 JSON（便于调试）
* @return Bean 的 JSON 字符串；失败返回空串
*/
@Override
public String toString() {
StringWriter stringWriter = new StringWriter();
JsonWriter jsonWriter = new JsonWriter(stringWriter);
jsonWriter.setIndent(" "); // 设置 JSON 缩进（格式化输出）
try {
jsonWriter.beginObject(); // 开始 JSON 对象
writeThisToJsonWriter(jsonWriter); // 写入 Bean 字段（子类扩展）
jsonWriter.endObject(); // 结束 JSON 对象
return stringWriter.toString();
} catch (IOException e) {
LogUtils.d(TAG, e.getMessage(), Thread.currentThread().getStackTrace());
}
return "";
}
/**
* 将 Bean 列表序列化为格式化的 JSON 字符串
* 遍历列表，逐个序列化每个 Bean，生成 JSON 数组
* @param beanList 待序列化的 Bean 列表
* @return 列表的 JSON 字符串；失败返回空串
* @param <T> 泛型约束，限定为 BaseBean 子类
*/
public static <T extends BaseBean> String toStringByBeanList(ArrayList<T> beanList) {
try {
StringWriter stringWriter = new StringWriter();
JsonWriter jsonWriter = new JsonWriter(stringWriter);
jsonWriter.setIndent(" "); // 格式化缩进
jsonWriter.beginArray(); // 开始 JSON 数组
for (int i = 0; i < beanList.size(); i++) {
jsonWriter.beginObject(); // 单个 Bean 开始
beanList.get(i).writeThisToJsonWriter(jsonWriter); // 调用 Bean 自身序列化
jsonWriter.endObject(); // 单个 Bean 结束
}
jsonWriter.endArray(); // 结束 JSON 数组
jsonWriter.close();
return stringWriter.toString();
} catch (IOException e) {
LogUtils.d(TAG, e.getMessage(), Thread.currentThread().getStackTrace());
}
return "";
}
/**
* 从默认路径（getBeanJsonFilePath）加载 Bean 实例
* 读取应用私有目录下的 JSON 文件，解析为目标 Bean
* @param context 上下文（用于获取文件路径）
* @param clazz 目标 Bean 类（用于反射实例化）
* @return 加载成功的 Bean 实例；失败返回 null
* @param <T> 泛型约束，限定为 BaseBean 子类
*/
public static <T extends BaseBean> T loadBean(Context context, Class<T> clazz) {
try {
// 反射创建 Bean 实例，获取默认文件路径
T beanTemp = clazz.newInstance();
return loadBeanFromFile(beanTemp.getBeanJsonFilePath(context), clazz);
} catch (InstantiationException | IllegalAccessException e) {
LogUtils.d(TAG, e.getMessage(), Thread.currentThread().getStackTrace());
}
return null;
}
/**
* 从指定文件路径加载 Bean 实例
* 检查文件是否存在，存在则读取 JSON 并解析为目标 Bean
* @param szFilePath 目标文件路径（存储 Bean 的 JSON 文件）
* @param clazz 目标 Bean 类（用于反射实例化）
* @return 加载成功的 Bean 实例；失败返回 null
* @param <T> 泛型约束，限定为 BaseBean 子类
*/
public static <T extends BaseBean> T loadBeanFromFile(String szFilePath, Class<T> clazz) {
try {
File file = new File(szFilePath);
if (file.exists()) { // 检查文件是否存在
T beanTemp = clazz.newInstance();
// 读取文件 JSON 字符串，解析为 Bean
String json = UTF8FileUtils.readStringFromFile(szFilePath);
return beanTemp.parseStringToBean(json, clazz);
}
} catch (InstantiationException | IllegalAccessException | IOException e) {
LogUtils.d(TAG, e.getMessage(), Thread.currentThread().getStackTrace());
}
return null;
}
/**
* 将 Bean 保存到默认路径（getBeanJsonFilePath）的文件中
* 序列化 Bean 为 JSON，写入应用私有目录下的文件
* @param context 上下文（用于获取文件路径）
* @param bean 待保存的 Bean 实例
* @return true：保存成功；false：保存失败
* @param <T> 泛型约束，限定为 BaseBean 子类
*/
public static <T extends BaseBean> boolean saveBean(Context context, T bean) {
return saveBeanToFile(bean.getBeanJsonFilePath(context), bean);
}
/**
* 将 Bean 保存到指定文件路径
* 序列化 Bean 为 JSON 字符串，写入目标文件（覆盖原有内容）
* @param szFilePath 目标文件路径（保存 JSON 的文件）
* @param bean 待保存的 Bean 实例
* @return true：保存成功；false：保存失败
* @param <T> 泛型约束，限定为 BaseBean 子类
*/
public static <T extends BaseBean> boolean saveBeanToFile(String szFilePath, T bean) {
try {
// 序列化 Bean 为 JSON 字符串
String json = bean.toString();
// 写入文件（UTF-8 编码）
UTF8FileUtils.writeStringToFile(szFilePath, json);
return true;
} catch (IOException e) {
LogUtils.d(TAG, e.getMessage(), Thread.currentThread().getStackTrace());
}
return false;
}
/**
* 从默认路径（getBeanListJsonFilePath）加载 Bean 列表
* 读取应用私有目录下的列表 JSON 文件，解析并填充到目标列表
* @param context 上下文（用于获取文件路径）
* @param beanListDst 目标列表（存储加载后的 Bean）
* @param clazz 目标 Bean 类（用于反射实例化）
* @return true：加载成功；false：加载失败
* @param <T> 泛型约束，限定为 BaseBean 子类
*/
public static <T extends BaseBean> boolean loadBeanList(Context context, ArrayList<T> beanListDst, Class<T> clazz) {
try {
// 反射创建 Bean 实例，获取默认列表文件路径
T beanTemp = clazz.newInstance();
return loadBeanListFromFile(beanTemp.getBeanListJsonFilePath(context), beanListDst, clazz);
} catch (InstantiationException | IllegalAccessException e) {
LogUtils.d(TAG, e.getMessage(), Thread.currentThread().getStackTrace());
}
return false;
}
/**
* 从指定文件路径加载 Bean 列表
* 检查文件是否存在，存在则读取 JSON 数组，解析并填充到目标列表
* @param szFilePath 目标文件路径（存储列表 JSON 的文件）
* @param beanList 目标列表（存储加载后的 Bean）
* @param clazz 目标 Bean 类（用于反射实例化）
* @return true：加载成功；false：加载失败
* @param <T> 泛型约束，限定为 BaseBean 子类
*/
public static <T extends BaseBean> boolean loadBeanListFromFile(String szFilePath, ArrayList<T> beanList, Class<T> clazz) {
try {
File file = new File(szFilePath);
if (file.exists()) { // 检查文件是否存在
// 读取文件中的 JSON 字符串（Bean 列表数组）
String listJson = UTF8FileUtils.readStringFromFile(szFilePath);
// 解析 JSON 字符串为 Bean 列表，填充到目标列表
return parseStringToBeanList(listJson, beanList, clazz);
}
} catch (IOException e) {
// 日志记录文件读取或解析异常
LogUtils.d(TAG, e.getMessage(), Thread.currentThread().getStackTrace());
}
return false;
}
/**
* 将 Bean 列表保存到默认路径（getBeanListJsonFilePath）的文件中
* 序列化列表为 JSON 数组，写入应用私有目录下的文件
* @param context 上下文（用于获取文件路径）
* @param beanList 待保存的 Bean 列表
* @param clazz 目标 Bean 类（用于反射获取保存路径）
* @return true：保存成功；false：保存失败
* @param <T> 泛型约束，限定为 BaseBean 子类
*/
public static <T extends BaseBean> boolean saveBeanList(Context context, ArrayList<T> beanList, Class<T> clazz) {
try {
// 反射创建 Bean 实例，获取默认列表保存路径
T beanTemp = clazz.newInstance();
return saveBeanListToFile(beanTemp.getBeanListJsonFilePath(context), beanList);
} catch (InstantiationException | IllegalAccessException e) {
// 日志记录反射实例化异常
LogUtils.d(TAG, e.getMessage(), Thread.currentThread().getStackTrace());
}
return false;
}
/**
* 将 Bean 列表保存到指定文件路径
* 序列化列表为 JSON 数组字符串，写入目标文件（覆盖原有内容）
* @param szFilePath 目标文件路径（保存列表 JSON 的文件）
* @param beanList 待保存的 Bean 列表
* @return true：保存成功；false：保存失败
* @param <T> 泛型约束，限定为 BaseBean 子类
*/
public static <T extends BaseBean> boolean saveBeanListToFile(String szFilePath, ArrayList<T> beanList) {
try {
// 序列化 Bean 列表为 JSON 字符串（数组格式）
String json = toStringByBeanList(beanList);
// 将 JSON 字符串写入文件（UTF-8 编码）
UTF8FileUtils.writeStringToFile(szFilePath, json);
return true;
} catch (IOException e) {
// 日志记录文件写入或序列化异常
LogUtils.d(TAG, e.getMessage(), Thread.currentThread().getStackTrace());
}
return false;
}
}

550
libappbase/src/main/java/cc/winboll/studio/libappbase/CrashHandler.java Normal file
View File

@@ -0,0 +1,550 @@
package cc.winboll.studio.libappbase;
import android.app.Activity;
import android.app.Application;
import android.content.ActivityNotFoundException;
import android.content.ClipData;
import android.content.ClipboardManager;
import android.content.Context;
import android.content.Intent;
import android.content.pm.PackageInfo;
import android.content.pm.PackageManager;
import android.content.res.Resources;
import android.graphics.Color;
import android.os.Build;
import android.os.Bundle;
import android.os.Handler;
import android.os.Looper;
import android.text.TextUtils;
import android.view.Menu;
import android.view.MenuItem;
import android.view.ViewGroup;
import android.widget.HorizontalScrollView;
import android.widget.ScrollView;
import android.widget.TextView;
import android.widget.Toast;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.io.PrintWriter;
import java.io.StringWriter;
import java.lang.Thread.UncaughtExceptionHandler;
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.Locale;
/**
* @Author ZhanGSKen&豆包大模型<zhangsken@qq.com>
* @Date 2025/11/11 20:14
* @Describe * 应用全局崩溃处理类（单例逻辑）
* 核心功能：捕获应用未捕获异常，记录崩溃日志到文件，启动崩溃报告页面，
* 并通过「崩溃保险丝」机制防止重复崩溃，保障基础功能可用
*/
public final class CrashHandler {
/** 日志标签，用于当前类的日志输出标识 */
public static final String TAG = "CrashHandler";
/** 崩溃报告页面标题 */
public static final String TITTLE = "CrashReport";
/** Intent 传递崩溃信息的键（用于向崩溃页面传递日志） */
public static final String EXTRA_CRASH_INFO = "crashInfo";
/** SharedPreferences 存储键（用于记录崩溃状态） */
final static String PREFS = CrashHandler.class.getName() + "PREFS";
/** SharedPreferences 中存储「是否发生崩溃」的键 */
final static String PREFS_CRASHHANDLER_ISCRASHHAPPEN = "PREFS_CRASHHANDLER_ISCRASHHAPPEN";
/** 崩溃保险丝状态文件路径（存储当前熔断等级） */
public static String _CrashCountFilePath;
/** 系统默认的未捕获异常处理器（用于降级处理，避免 CrashHandler 自身崩溃） */
public static final UncaughtExceptionHandler DEFAULT_UNCAUGHT_EXCEPTION_HANDLER = Thread.getDefaultUncaughtExceptionHandler();
/**
* 初始化崩溃处理器（默认存储路径）
* 调用重载方法，崩溃日志默认存储在应用外部私有目录的 crash 文件夹下
* @param app 全局 Application 实例（用于获取存储目录、包信息等）
*/
public static void init(Application app) {
// 初始化崩溃保险丝状态文件路径（外部存储/CrashHandler/IsCrashHandlerCrashHappen.dat）
_CrashCountFilePath = app.getExternalFilesDir("CrashHandler") + "/IsCrashHandlerCrashHappen.dat";
LogUtils.d(TAG, String.format("_CrashCountFilePath %s", _CrashCountFilePath));
// 调用带目录参数的初始化方法，传入 null 使用默认路径
init(app, null);
}
/**
* 初始化崩溃处理器（指定日志存储目录）
* 替换系统默认的未捕获异常处理器，自定义崩溃处理逻辑
* @param app 全局 Application 实例
* @param crashDir 崩溃日志存储目录（null 则使用默认路径）
*/
public static void init(final Application app, final String crashDir) {
// 设置自定义未捕获异常处理器
Thread.setDefaultUncaughtExceptionHandler(new UncaughtExceptionHandler() {
@Override
public void uncaughtException(Thread thread, Throwable throwable) {
try {
// 尝试处理崩溃（捕获内部异常，避免 CrashHandler 自身崩溃）
tryUncaughtException(thread, throwable);
} catch (Throwable e) {
e.printStackTrace();
// 处理失败时，交给系统默认处理器兜底
if (DEFAULT_UNCAUGHT_EXCEPTION_HANDLER != null) {
DEFAULT_UNCAUGHT_EXCEPTION_HANDLER.uncaughtException(thread, throwable);
}
}
}
/**
* 实际处理崩溃的核心方法
* 1. 熔断保险丝（记录崩溃次数）；2. 收集崩溃信息；3. 写入日志文件；4. 启动崩溃报告页面
* @param thread 发生崩溃的线程
* @param throwable 崩溃异常对象（包含堆栈信息）
*/
private void tryUncaughtException(Thread thread, Throwable throwable) {
// 触发崩溃保险丝（每次崩溃熔断一次，降低防护等级）
AppCrashSafetyWire.getInstance().burnSafetyWire();
// 格式化崩溃发生时间（用于日志文件名和内容）
final String time = new SimpleDateFormat("yyyy_MM_dd-HH_mm_ss", Locale.getDefault()).format(new Date());
// 创建崩溃日志文件（默认路径：外部存储/crash/[时间].txt）
File crashFile = new File(
TextUtils.isEmpty(crashDir) ? new File(app.getExternalFilesDir(null), "crash") : new File(crashDir),
"crash_" + time + ".txt"
);
// 获取应用版本信息（版本名、版本号）
String versionName = "unknown";
long versionCode = 0;
try {
PackageInfo packageInfo = app.getPackageManager().getPackageInfo(app.getPackageName(), 0);
versionName = packageInfo.versionName;
// 适配 Android 9.0+（API 28）的版本号获取方式
versionCode = Build.VERSION.SDK_INT >= 28 ? packageInfo.getLongVersionCode() : packageInfo.versionCode;
} catch (PackageManager.NameNotFoundException ignored) {}
// 将异常堆栈信息转换为字符串
String fullStackTrace;
{
StringWriter sw = new StringWriter();
PrintWriter pw = new PrintWriter(sw);
throwable.printStackTrace(pw); // 将异常堆栈写入 PrintWriter
fullStackTrace = sw.toString();
pw.close();
}
// 拼接崩溃信息（设备信息 + 应用信息 + 堆栈信息）
StringBuilder sb = new StringBuilder();
sb.append("************* Crash Head ****************\n");
sb.append("Time Of Crash : ").append(time).append("\n");
sb.append("Device Manufacturer : ").append(Build.MANUFACTURER).append("\n"); // 设备厂商
sb.append("Device Model : ").append(Build.MODEL).append("\n"); // 设备型号
sb.append("Android Version : ").append(Build.VERSION.RELEASE).append("\n"); // Android 版本
sb.append("Android SDK : ").append(Build.VERSION.SDK_INT).append("\n"); // SDK 版本
sb.append("App VersionName : ").append(versionName).append("\n"); // 应用版本名
sb.append("App VersionCode : ").append(versionCode).append("\n"); // 应用版本号
sb.append("************* Crash Head ****************\n");
sb.append("\n").append(fullStackTrace); // 拼接异常堆栈
final String errorLog = sb.toString();
// 将崩溃日志写入文件（忽略写入失败）
try {
writeFile(crashFile, errorLog);
} catch (IOException ignored) {}
// 启动崩溃报告页面（标签用于代码块折叠）
gotoCrashActiviy: {
Intent intent = new Intent();
LogUtils.d(TAG, "gotoCrashActiviy: ");
// 根据保险丝状态选择启动的崩溃页面
if (AppCrashSafetyWire.getInstance().isAppCrashSafetyWireOK()) {
LogUtils.d(TAG, "gotoCrashActiviy: isAppCrashSafetyWireOK");
// 保险丝正常：启动自定义样式的崩溃报告页面（GlobalCrashActivity）
intent.setClass(app, GlobalCrashActivity.class);
intent.putExtra(EXTRA_CRASH_INFO, errorLog); // 传递崩溃日志
} else {
LogUtils.d(TAG, "gotoCrashActiviy: else");
// 保险丝熔断：启动基础版崩溃页面（CrashActivity，避免复杂页面再次崩溃）
intent.setClass(app, CrashActivity.class);
intent.putExtra(EXTRA_CRASH_INFO, errorLog);
}
// 设置意图标志：清除原有任务栈，创建新任务（避免回到崩溃前页面）
intent.addFlags(
Intent.FLAG_ACTIVITY_NEW_TASK
| Intent.FLAG_ACTIVITY_CLEAR_TOP
| Intent.FLAG_ACTIVITY_CLEAR_TASK
);
try {
// 启动崩溃页面，终止当前进程（确保完全重启）
app.startActivity(intent);
android.os.Process.killProcess(android.os.Process.myPid());
System.exit(0);
} catch (ActivityNotFoundException e) {
// 未找到崩溃页面（如未在 Manifest 注册），交给系统默认处理器
e.printStackTrace();
if (DEFAULT_UNCAUGHT_EXCEPTION_HANDLER != null) {
DEFAULT_UNCAUGHT_EXCEPTION_HANDLER.uncaughtException(thread, throwable);
}
} catch (Exception e) {
// 其他异常，兜底处理
e.printStackTrace();
if (DEFAULT_UNCAUGHT_EXCEPTION_HANDLER != null) {
DEFAULT_UNCAUGHT_EXCEPTION_HANDLER.uncaughtException(thread, throwable);
}
}
}
}
/**
* 将字符串内容写入文件（创建父目录、覆盖写入）
* @param file 目标文件（包含路径）
* @param content 待写入的内容（崩溃日志）
* @throws IOException 文件创建或写入失败时抛出
*/
private void writeFile(File file, String content) throws IOException {
File parentFile = file.getParentFile();
// 父目录不存在则创建
if (parentFile != null && !parentFile.exists()) {
parentFile.mkdirs();
}
file.createNewFile(); // 创建文件
FileOutputStream fos = new FileOutputStream(file);
fos.write(content.getBytes()); // 写入内容（默认 UTF-8 编码）
try {
fos.close(); // 关闭流
} catch (IOException e) {}
}
});
}
/**
* 应用崩溃保险丝内部类（单例）
* 核心作用：限制短时间内重复崩溃，通过「熔断等级」控制崩溃页面启动策略
* 等级范围：MINI（1）~ MAX（2），每次崩溃等级-1，熔断后启动基础版崩溃页面
*/
public static final class AppCrashSafetyWire {
/** 单例实例（volatile 保证多线程可见性） */
private static volatile AppCrashSafetyWire _AppCrashSafetyWire;
/** 当前熔断等级（1：最低防护；2：最高防护；≤0：熔断） */
private volatile Integer currentSafetyLevel;
/** 最低熔断等级（1，再崩溃则熔断） */
private static final int _MINI = 1;
/** 最高熔断等级（2，初始状态） */
private static final int _MAX = 2;
/**
* 私有构造方法（单例模式，禁止外部实例化）
* 初始化时加载本地存储的熔断等级
*/
private AppCrashSafetyWire() {
LogUtils.d(TAG, "AppCrashSafetyWire()");
currentSafetyLevel = loadCurrentSafetyLevel();
}
/**
* 获取单例实例（双重检查锁定，线程安全）
* @return AppCrashSafetyWire 单例
*/
public static synchronized AppCrashSafetyWire getInstance() {
if (_AppCrashSafetyWire == null) {
_AppCrashSafetyWire = new AppCrashSafetyWire();
}
return _AppCrashSafetyWire;
}
/**
* 设置当前熔断等级（内存中）
* @param currentSafetyLevel 目标等级（1~2）
*/
public void setCurrentSafetyLevel(int currentSafetyLevel) {
this.currentSafetyLevel = currentSafetyLevel;
}
/**
* 获取当前熔断等级（内存中）
* @return 当前等级（1~2 或 null）
*/
public int getCurrentSafetyLevel() {
return currentSafetyLevel;
}
/**
* 保存熔断等级到本地文件（持久化，重启应用生效）
* @param currentSafetyLevel 待保存的等级
*/
public void saveCurrentSafetyLevel(int currentSafetyLevel) {
LogUtils.d(TAG, "saveCurrentSafetyLevel()");
this.currentSafetyLevel = currentSafetyLevel;
try {
// 序列化等级到文件（ObjectOutputStream 写入 int）
ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream(_CrashCountFilePath));
oos.writeInt(currentSafetyLevel);
oos.flush();
oos.close();
LogUtils.d(TAG, String.format("saveCurrentSafetyLevel writeInt currentSafetyLevel %d", currentSafetyLevel));
} catch (IOException e) {
LogUtils.d(TAG, e, Thread.currentThread().getStackTrace());
}
}
/**
* 从本地文件加载熔断等级（应用启动时初始化）
* @return 加载的等级（文件不存在则初始化为 MAX（2））
*/
public int loadCurrentSafetyLevel() {
LogUtils.d(TAG, "loadCurrentSafetyLevel()");
try {
File f = new File(_CrashCountFilePath);
if (f.exists()) {
// 反序列化从文件读取等级
ObjectInputStream ois = new ObjectInputStream(new FileInputStream(_CrashCountFilePath));
currentSafetyLevel = ois.readInt();
LogUtils.d(TAG, String.format("loadCurrentSafetyLevel() readInt currentSafetyLevel %d", currentSafetyLevel));
} else {
// 文件不存在，初始化等级为最高（2）并保存
currentSafetyLevel = _MAX;
LogUtils.d(TAG, String.format("loadCurrentSafetyLevel() currentSafetyLevel init to _MAX->%d", _MAX));
saveCurrentSafetyLevel(currentSafetyLevel);
}
} catch (IOException e) {
LogUtils.d(TAG, e, Thread.currentThread().getStackTrace());
}
return currentSafetyLevel;
}
/**
* 熔断保险丝（每次崩溃调用，降低防护等级）
* @return 熔断后是否仍在防护范围内（true：是；false：已熔断）
*/
boolean burnSafetyWire() {
LogUtils.d(TAG, "burnSafetyWire()");
// 加载当前等级
int safeLevel = loadCurrentSafetyLevel();
// 若在防护范围内（1~2），等级-1 并保存
if (isSafetyWireWorking(safeLevel)) {
LogUtils.d(TAG, "burnSafetyWire() use");
saveCurrentSafetyLevel(safeLevel - 1);
// 返回熔断后的状态
return isSafetyWireWorking(safeLevel - 1);
}
return false;
}
/**
* 检查熔断等级是否在有效范围内（1~2）
* @param safetyLevel 待检查的等级
* @return true：在范围内（防护有效）；false：超出范围（已熔断）
*/
boolean isSafetyWireWorking(int safetyLevel) {
LogUtils.d(TAG, "isSafetyWireOK()");
LogUtils.d(TAG, String.format("SafetyLevel %d", safetyLevel));
if (safetyLevel >= _MINI && safetyLevel <= _MAX) {
LogUtils.d(TAG, String.format("In Safety Level"));
return true;
}
LogUtils.d(TAG, String.format("Out of Safety Level"));
return false;
}
/**
* 立即恢复熔断等级到最高（2）
* 用于重启应用后重置防护状态
*/
void resumeToMaximumImmediately() {
LogUtils.d(TAG, "resumeToMaximumImmediately() call saveCurrentSafetyLevel(_MAX)");
AppCrashSafetyWire.getInstance().saveCurrentSafetyLevel(_MAX);
}
/**
* 关闭防护（设置等级为最低（1））
* 下次崩溃直接熔断
*/
void off() {
LogUtils.d(TAG, "off()");
saveCurrentSafetyLevel(_MINI);
}
/**
* 检查当前保险丝是否有效（防护未熔断）
* @return true：有效（等级 1~2）；false：已熔断
*/
boolean isAppCrashSafetyWireOK() {
LogUtils.d(TAG, "isAppCrashSafetyWireOK()");
currentSafetyLevel = loadCurrentSafetyLevel();
return isSafetyWireWorking(currentSafetyLevel);
}
/**
* 延迟恢复保险丝到最高等级（500ms 后）
* 核心作用：崩溃页面启动后，若下次即将熔断，提前恢复防护等级，避免持续崩溃
* @param context 上下文（用于获取主线程 Handler）
*/
void postResumeCrashSafetyWireHandler(final Context context) {
// 主线程延迟 500ms 执行（避免页面启动时阻塞）
new Handler(Looper.getMainLooper()).postDelayed(new Runnable() {
@Override
public void run() {
LogUtils.d(TAG, "Handler run()");
// 检查：若当前等级-1 后超出防护范围（即将熔断），则恢复到最高等级
if (!AppCrashSafetyWire.getInstance().isSafetyWireWorking(currentSafetyLevel - 1)) {
AppCrashSafetyWire.getInstance().resumeToMaximumImmediately();
LogUtils.d(TAG, "postResumeCrashSafetyWireHandler: 恢复保险丝到最高等级");
}
}
}, 500);
}
}
/**
* 基础版崩溃报告页面（保险丝熔断时启动）
* 极简实现：仅展示崩溃日志，提供复制、重启功能，避免复杂布局导致二次崩溃
*/
public static final class CrashActivity extends Activity implements MenuItem.OnMenuItemClickListener {
/** 菜单标识：复制崩溃日志 */
private static final int MENUITEM_COPY = 0;
/** 菜单标识：重启应用 */
private static final int MENUITEM_RESTART = 1;
/** 崩溃日志文本（从 CrashHandler 传递过来） */
private String mLog;
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
// 初始化崩溃保险丝延迟恢复机制
AppCrashSafetyWire.getInstance().postResumeCrashSafetyWireHandler(getApplicationContext());
// 获取传递的崩溃日志
mLog = getIntent().getStringExtra(EXTRA_CRASH_INFO);
// 设置系统默认主题（避免自定义主题冲突）
setTheme(android.R.style.Theme_DeviceDefault_Light_DarkActionBar);
// 动态创建布局（避免 XML 布局加载异常）
setContentView: {
// 垂直滚动视图（处理日志过长）
ScrollView contentView = new ScrollView(this);
contentView.setFillViewport(true);
// 水平滚动视图（处理日志行过长）
HorizontalScrollView hw = new HorizontalScrollView(this);
hw.setBackgroundColor(Color.GRAY); // 背景色设为灰色
// 日志显示文本框
TextView message = new TextView(this);
{
int padding = dp2px(16); // 内边距 16dp（适配不同屏幕）
message.setPadding(padding, padding, padding, padding);
message.setText(mLog); // 设置崩溃日志
message.setTextColor(Color.BLACK); // 文字黑色
message.setTextIsSelectable(true); // 支持文本选择（便于手动复制）
}
// 组装布局：TextView -> HorizontalScrollView -> ScrollView
hw.addView(message);
contentView.addView(hw, ViewGroup.LayoutParams.MATCH_PARENT, ViewGroup.LayoutParams.MATCH_PARENT);
// 设置当前 Activity 布局
setContentView(contentView);
// 配置 ActionBar 标题和副标题
getActionBar().setTitle(TITTLE);
getActionBar().setSubtitle(GlobalApplication.class.getSimpleName() + " Error");
}
}
/**
* 重写返回键逻辑：点击返回键直接重启应用
*/
@Override
public void onBackPressed() {
restart();
}
/**
* 重启当前应用（与 GlobalCrashActivity 逻辑一致）
* 清除任务栈，启动主 Activity，终止当前进程
*/
private void restart() {
PackageManager pm = getPackageManager();
// 获取应用启动意图（默认启动主 Activity）
Intent intent = pm.getLaunchIntentForPackage(getPackageName());
if (intent != null) {
// 设置意图标志：清除原有任务栈，创建新任务
intent.addFlags(
Intent.FLAG_ACTIVITY_NEW_TASK
| Intent.FLAG_ACTIVITY_CLEAR_TOP
| Intent.FLAG_ACTIVITY_CLEAR_TASK
);
startActivity(intent);
}
// 关闭当前页面，终止进程，确保完全重启
finish();
android.os.Process.killProcess(android.os.Process.myPid());
System.exit(0);
}
/**
* dp 转 px（适配不同屏幕密度）
* @param dpValue dp 值
* @return 转换后的 px 值
*/
private int dp2px(final float dpValue) {
final float scale = Resources.getSystem().getDisplayMetrics().density;
return (int) (dpValue * scale + 0.5f); // 四舍五入确保精度
}
/**
* 菜单点击事件回调（处理复制、重启）
* @param item 被点击的菜单项
* @return false：不消费事件（保持默认行为）
*/
@Override
public boolean onMenuItemClick(MenuItem item) {
switch (item.getItemId()) {
case MENUITEM_COPY:
// 复制日志到剪贴板
ClipboardManager cm = (ClipboardManager) getSystemService(Context.CLIPBOARD_SERVICE);
cm.setPrimaryClip(ClipData.newPlainText(getPackageName(), mLog));
Toast.makeText(getApplication(), "The text is copied.", Toast.LENGTH_SHORT).show();
break;
case MENUITEM_RESTART:
// 恢复保险丝到最高等级，然后重启应用
AppCrashSafetyWire.getInstance().resumeToMaximumImmediately();
restart();
break;
}
return false;
}
/**
* 创建 ActionBar 菜单（添加复制、重启项）
* @param menu 菜单容器
* @return true：显示菜单
*/
@Override
public boolean onCreateOptionsMenu(Menu menu) {
// 添加「复制」菜单：有空间时显示在 ActionBar，否则放入溢出菜单
menu.add(0, MENUITEM_COPY, 0, "Copy")
.setOnMenuItemClickListener(this)
.setShowAsAction(MenuItem.SHOW_AS_ACTION_IF_ROOM);
// 添加「重启」菜单：同上
menu.add(0, MENUITEM_RESTART, 0, "Restart")
.setOnMenuItemClickListener(this)
.setShowAsAction(MenuItem.SHOW_AS_ACTION_IF_ROOM);
return true;
}
}
}

174
libappbase/src/main/java/cc/winboll/studio/libappbase/GlobalApplication.java Normal file
View File

@@ -0,0 +1,174 @@
package cc.winboll.studio.libappbase;
import android.app.Application;
import android.content.Context;
import android.content.pm.ApplicationInfo;
import android.content.pm.PackageManager;
import android.content.pm.PackageManager.NameNotFoundException;
/**
* @Author ZhanGSKen&豆包大模型<zhangsken@qq.com>
* @Date 2025/11/11 19:56
* @Describe 全局 Application 类，用于初始化应用核心组件、管理全局状态（如调试模式）
* 需在 AndroidManifest.xml 中配置 android:name=".GlobalApplication" 使其生效
*/
public class GlobalApplication extends Application {
/** 日志标签 */
public static final String TAG = "GlobalApplication";
/** 全局 Application 单例实例（volatile 保证多线程可见性，避免指令重排） */
private static volatile GlobalApplication sInstance;
/**
* 应用调试模式标记（volatile 保证多线程可见性）
* true：调试模式（开启日志、调试功能）；false：正式模式（关闭调试相关功能）
*/
private static volatile boolean isDebugging = false;
/**
* 获取全局 Application 单例实例（外部可通过此方法获取上下文）
* @return GlobalApplication 单例（未初始化时返回 null，需确保配置 AndroidManifest）
*/
public static GlobalApplication getInstance() {
return sInstance;
}
/**
* 设置应用调试模式
* @param debugging 调试模式状态（true/false）
*/
public static void setIsDebugging(boolean debugging) {
isDebugging = debugging;
}
/**
* 保存调试模式状态到本地文件（持久化存储，重启应用后生效）
* @param application 全局 Application 实例（通过 getInstance() 获取更规范）
*/
public static void saveDebugStatus(GlobalApplication application) {
if (application == null) {
LogUtils.e(TAG, "saveDebugStatus: Application 实例为空，保存失败");
return;
}
// 将调试状态封装为 APPModel 并保存到文件
APPModel.saveBeanToFile(
getAppModelFilePath(application),
new APPModel(isDebugging)
);
}
/**
* 获取 APPModel 配置文件的存储路径
* 路径：应用私有数据目录 / APPModel.json（仅当前应用可访问，安全）
* @param application 全局 Application 实例
* @return 配置文件绝对路径
*/
private static String getAppModelFilePath(GlobalApplication application) {
return application.getDataDir().getPath() + "/APPModel.json";
}
/**
* 获取当前应用调试模式状态
* @return true：调试模式；false：正式模式
*/
public static boolean isDebugging() {
return isDebugging;
}
/**
* 应用启动时初始化（仅执行一次）
* 初始化核心框架、恢复调试状态、配置全局异常处理等
*/
@Override
public void onCreate() {
super.onCreate();
// 初始化单例实例（确保在所有初始化操作前完成）
sInstance = this;
// 初始化基础组件（日志、崩溃处理、Toast）
initCoreComponents();
// 恢复/初始化调试模式状态（从本地文件读取，无文件则默认关闭调试）
restoreDebugStatus();
LogUtils.d(TAG, "GlobalApplication 初始化完成，单例实例已创建");
}
/**
* 初始化应用核心组件（日志、崩溃处理、Toast 框架）
*/
private void initCoreComponents() {
// 初始化日志工具（传入 Application 上下文）
LogUtils.init(this);
// 初始化全局异常处理器（捕获应用崩溃信息，用于调试或上报）
CrashHandler.init(this);
// 初始化 Toast 工具（统一 Toast 样式、避免内存泄漏等）
ToastUtils.init(this);
}
/**
* 恢复调试模式状态（从本地配置文件读取）
* 1. 读取本地 APPModel.json 文件
* 2. 读取成功：使用保存的调试状态；读取失败（文件不存在）：默认关闭调试并创建配置文件
*/
private void restoreDebugStatus() {
// 从文件加载 APPModel 实例（存储调试状态的模型类）
APPModel appModel = APPModel.loadBeanFromFile(
getAppModelFilePath(this),
APPModel.class
);
if (appModel == null) {
// 配置文件不存在，默认关闭调试模式并创建文件
setIsDebugging(false);
saveDebugStatus(this);
LogUtils.d(TAG, "调试配置文件不存在，默认关闭调试模式并创建配置文件");
} else {
// 配置文件存在，使用保存的调试状态
setIsDebugging(appModel.isDebugging());
LogUtils.d(TAG, "从配置文件恢复调试模式：" + isDebugging);
}
}
/**
* 获取应用名称（从 AndroidManifest.xml 的 android:label 读取）
* @param context 上下文（建议传入 Application 上下文，避免内存泄漏）
* @return 应用名称（读取失败返回 null）
*/
public static String getAppName(Context context) {
if (context == null) {
LogUtils.w(TAG, "getAppName: 上下文为空，返回 null");
return null;
}
PackageManager packageManager = context.getPackageManager();
try {
// 获取应用信息（包含应用名称、图标等）
ApplicationInfo applicationInfo = packageManager.getApplicationInfo(
context.getPackageName(), // 当前应用包名
0 // 额外标志（0 表示默认获取基本信息）
);
// 从应用信息中获取应用名称（支持多语言）
String appName = (String) packageManager.getApplicationLabel(applicationInfo);
LogUtils.d(TAG, "获取应用名称成功：" + appName);
return appName;
} catch (NameNotFoundException e) {
// 包名不存在（理论上不会发生，捕获异常避免崩溃）
LogUtils.d(TAG, e, Thread.currentThread().getStackTrace());
//LogUtils.e(TAG, "获取应用名称失败：包名不存在", e);
e.printStackTrace();
}
return null;
}
/**
* 应用终止时调用（仅用于释放全局资源）
*/
@Override
public void onTerminate() {
super.onTerminate();
// 释放单例引用（可选，避免内存泄漏风险）
sInstance = null;
LogUtils.d(TAG, "GlobalApplication 终止，单例实例已释放");
}
}

186
libappbase/src/main/java/cc/winboll/studio/libappbase/GlobalCrashActivity.java Normal file
View File

@@ -0,0 +1,186 @@
package cc.winboll.studio.libappbase;
import android.app.Activity;
import android.content.ClipData;
import android.content.ClipboardManager;
import android.content.Context;
import android.content.Intent;
import android.content.pm.PackageManager;
import android.os.Bundle;
import android.view.Menu;
import android.view.MenuItem;
import android.widget.Toast;
import cc.winboll.studio.libappbase.R;
/**
* @Author ZhanGSKen&豆包大模型<zhangsken@qq.com>
* @Date 2025/11/11 19:58
* @Describe 应用异常报告观察活动窗口类
* 核心功能：应用发生未捕获崩溃时，由 CrashHandler 启动此页面，展示崩溃日志详情，
* 并提供「复制日志」「重启应用」操作入口，便于开发者定位问题和用户恢复应用
*/
public final class GlobalCrashActivity extends Activity implements MenuItem.OnMenuItemClickListener {
/** 日志标签（用于调试日志输出，唯一标识当前 Activity） */
public static final String TAG = "GlobalCrashActivity";
/** 菜单标识：复制崩溃日志（用于区分菜单项点击事件） */
private static final int MENU_ITEM_COPY = 0;
/** 菜单标识：重启应用（用于区分菜单项点击事件） */
private static final int MENU_ITEM_RESTART = 1;
/** 崩溃报告展示自定义视图 */
// 负责渲染崩溃日志文本、提供 Toolbar 容器，封装了日志展示和菜单样式控制逻辑
private GlobalCrashReportView mCrashReportView;
/** 崩溃日志文本内容 */
// 从 CrashHandler 通过 Intent 传递过来，包含异常堆栈、设备信息等完整崩溃数据
private String mCrashLog;
/**
* Activity 创建时初始化（生命周期核心方法，仅执行一次）
* @param savedInstanceState 保存的实例状态（崩溃页面无需恢复状态，此处仅作兼容）
*/
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
// 初始化崩溃安全防护机制
// 作用：防止应用重启后短时间内再次崩溃，由 CrashHandler 内部实现防护逻辑
CrashHandler.AppCrashSafetyWire.getInstance()
.postResumeCrashSafetyWireHandler(getApplicationContext());
// 从 Intent 中获取崩溃日志数据（EXTRA_CRASH_INFO 为 CrashHandler 定义的常量键）
mCrashLog = getIntent().getStringExtra(CrashHandler.EXTRA_CRASH_INFO);
// 设置当前 Activity 的布局文件（展示崩溃报告的 UI 结构）
setContentView(R.layout.activity_globalcrash);
// 初始化崩溃报告展示视图（通过布局 ID 找到自定义 View 实例）
mCrashReportView = findViewById(R.id.activityglobalcrashGlobalCrashReportView1);
// 将崩溃日志设置到视图中，由自定义 View 负责排版和显示
mCrashReportView.setReport(mCrashLog);
// 设置页面的 ActionBar（复用自定义 View 中的 Toolbar 作为系统 ActionBar）
setActionBar(mCrashReportView.getToolbar());
// 配置 ActionBar 标题和副标题（非空判断避免空指针异常）
if (getActionBar() != null) {
// 设置标题：使用 CrashHandler 中定义的统一标题（如 "应用崩溃报告"）
getActionBar().setTitle(CrashHandler.TITTLE);
// 设置副标题：显示当前应用名称（从全局 Application 工具方法获取）
getActionBar().setSubtitle(GlobalApplication.getAppName(getApplicationContext()));
}
}
/**
* 重写返回键点击事件
* 逻辑：点击手机返回键时，直接重启应用（而非返回上一页，因崩溃后上一页状态可能异常）
*/
@Override
public void onBackPressed() {
restartApp();
}
/**
* 重启当前应用（核心工具方法）
* 实现逻辑：
* 1. 获取应用的启动意图（默认启动 AndroidManifest 中配置的主 Activity）
* 2. 设置意图标志，清除原有任务栈，避免残留异常页面
* 3. 启动主 Activity 并终止当前进程，确保应用完全重启
*/
private void restartApp() {
// 获取 PackageManager 实例（用于获取应用相关信息和意图）
PackageManager packageManager = getPackageManager();
// 获取应用的启动意图（参数为当前应用包名，返回主 Activity 的意图）
Intent launchIntent = packageManager.getLaunchIntentForPackage(getPackageName());
if (launchIntent != null) {
// 设置意图标志：
// FLAG_ACTIVITY_NEW_TASK：创建新的任务栈启动 Activity
// FLAG_ACTIVITY_CLEAR_TOP：清除目标 Activity 之上的所有 Activity
// FLAG_ACTIVITY_CLEAR_TASK：清除当前任务栈中的所有 Activity
launchIntent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK
| Intent.FLAG_ACTIVITY_CLEAR_TOP
| Intent.FLAG_ACTIVITY_CLEAR_TASK);
// 启动应用主 Activity
startActivity(launchIntent);
}
// 关闭当前崩溃报告页面
finish();
// 终止当前应用进程（确保释放所有资源，避免内存泄漏）
android.os.Process.killProcess(android.os.Process.myPid());
// 强制退出虚拟机（彻底终止应用，防止残留线程继续运行）
System.exit(0);
}
/**
* 菜单项点击事件回调（实现 MenuItem.OnMenuItemClickListener 接口）
* @param item 被点击的菜单项实例
* @return boolean：true 表示事件已消费，不再向下传递；false 表示未消费
*/
@Override
public boolean onMenuItemClick(MenuItem item) {
// 根据菜单项 ID 判断点击的是哪个功能
switch (item.getItemId()) {
case MENU_ITEM_COPY:
// 点击「复制」菜单，执行复制崩溃日志到剪贴板
copyCrashLogToClipboard();
break;
case MENU_ITEM_RESTART:
// 点击「重启」菜单：先恢复崩溃防护机制到最大等级，再重启应用
CrashHandler.AppCrashSafetyWire.getInstance().resumeToMaximumImmediately();
restartApp();
break;
}
return false;
}
/**
* 创建页面顶部菜单（ActionBar 菜单）
* @param menu 菜单容器，用于添加菜单项
* @return boolean：true 表示显示菜单；false 表示不显示
*/
@Override
public boolean onCreateOptionsMenu(Menu menu) {
// 添加「复制」菜单项：
// 参数说明：菜单组 ID（0 表示默认组）、菜单项 ID（MENU_ITEM_COPY）、排序号（0）、菜单文本（"Copy"）
// setOnMenuItemClickListener(this)：绑定点击事件到当前 Activity
// setShowAsAction(MenuItem.SHOW_AS_ACTION_IF_ROOM)：有空间时显示在 ActionBar 上，否则放入溢出菜单
menu.add(0, MENU_ITEM_COPY, 0, "Copy")
.setOnMenuItemClickListener(this)
.setShowAsAction(MenuItem.SHOW_AS_ACTION_IF_ROOM);
// 添加「重启」菜单项（参数含义同上）
menu.add(0, MENU_ITEM_RESTART, 0, "Restart")
.setOnMenuItemClickListener(this)
.setShowAsAction(MenuItem.SHOW_AS_ACTION_IF_ROOM);
// 调用自定义视图的方法，更新菜单文字样式（如颜色、字体大小等，由自定义 View 内部实现）
mCrashReportView.updateMenuStyle();
return true;
}
/**
* 将崩溃日志复制到系统剪贴板（工具方法）
* 功能：用户点击复制菜单后，将完整崩溃日志存入剪贴板，方便粘贴到聊天工具或文档中
*/
private void copyCrashLogToClipboard() {
// 获取系统剪贴板服务（需通过 getSystemService 方法获取）
ClipboardManager clipboardManager = (ClipboardManager) getSystemService(Context.CLIPBOARD_SERVICE);
// 创建剪贴板数据：
// 参数 1：标签（用于标识剪贴板内容来源，此处用应用包名）
// 参数 2：实际复制的文本内容（崩溃日志）
ClipData clipData = ClipData.newPlainText(getPackageName(), mCrashLog);
// 将数据设置到剪贴板（完成复制操作）
clipboardManager.setPrimaryClip(clipData);
// 显示复制成功的 Toast 提示（告知用户操作结果）
Toast.makeText(getApplication(), "The text is copied.", Toast.LENGTH_SHORT).show();
}
}

309
libappbase/src/main/java/cc/winboll/studio/libappbase/GlobalCrashReportView.java Normal file
View File

@@ -0,0 +1,309 @@
package cc.winboll.studio.libappbase;
import android.content.Context;
import android.content.res.TypedArray;
import android.graphics.Color;
import android.text.SpannableString;
import android.text.style.ForegroundColorSpan;
import android.util.AttributeSet;
import android.view.Menu;
import android.view.MenuItem;
import android.widget.LinearLayout;
import android.widget.TextView;
import android.widget.Toolbar;
import cc.winboll.studio.libappbase.R;
/**
* @Author ZhanGSKen&豆包大模型<zhangsken@qq.com>
* @Date 2025/11/11 20:21
* @Describe 全局崩溃报告视图控件
* 用于展示应用崩溃信息，包含顶部工具栏和崩溃日志文本区域，支持自定义配色
*/
public class GlobalCrashReportView extends LinearLayout {
// 日志标签
public static final String TAG = "GlobalCrashReportView";
// 上下文对象
private Context mContext;
// 顶部工具栏（标题栏）
private Toolbar mToolbar;
// 标题文字颜色
private int mTitleColor;
// 标题栏背景颜色
private int mTitleBackgroundColor;
// 日志文本颜色
private int mTextColor;
// 日志区域背景颜色
private int mTextBackgroundColor;
// 崩溃日志显示文本控件
private TextView mTvReport;
/**
* 构造方法：仅上下文
* @param context 上下文
*/
public GlobalCrashReportView(Context context) {
super(context);
mContext = context;
// 初始化默认配置（无自定义属性）
initDefaultConfig();
}
/**
* 构造方法：上下文 + 自定义属性
* @param context 上下文
* @param attrs 自定义属性集合
*/
public GlobalCrashReportView(Context context, AttributeSet attrs) {
super(context, attrs);
mContext = context;
// 初始化视图（解析自定义属性）
initView(attrs);
}
/**
* 构造方法：上下文 + 自定义属性 + 样式属性
* @param context 上下文
* @param attrs 自定义属性集合
* @param defStyleAttr 样式属性
*/
public GlobalCrashReportView(Context context, AttributeSet attrs, int defStyleAttr) {
super(context, attrs, defStyleAttr);
mContext = context;
// 初始化视图（解析自定义属性）
initView(attrs);
}
/**
* 构造方法：上下文 + 自定义属性 + 样式属性 + 样式资源
* @param context 上下文
* @param attrs 自定义属性集合
* @param defStyleAttr 样式属性
* @param defStyleRes 样式资源
*/
public GlobalCrashReportView(Context context, AttributeSet attrs, int defStyleAttr, int defStyleRes) {
super(context, attrs, defStyleAttr, defStyleRes);
mContext = context;
// 初始化视图（解析自定义属性）
initView(attrs);
}
/**
* 设置标题文字颜色
* @param titleColor 颜色值（如 Color.WHITE 或 #FFFFFF）
*/
public void setTitleColor(int titleColor) {
this.mTitleColor = titleColor;
// 实时更新工具栏标题颜色
if (mToolbar != null) {
mToolbar.setTitleTextColor(titleColor);
mToolbar.setSubtitleTextColor(titleColor);
}
}
/**
* 获取标题文字颜色
* @return 标题文字颜色值
*/
public int getTitleColor() {
return mTitleColor;
}
/**
* 设置标题栏背景颜色
* @param titleBackgroundColor 颜色值（如 Color.BLACK 或 #000000）
*/
public void setTitleBackgroundColor(int titleBackgroundColor) {
this.mTitleBackgroundColor = titleBackgroundColor;
// 实时更新工具栏背景颜色
if (mToolbar != null) {
mToolbar.setBackgroundColor(titleBackgroundColor);
}
}
/**
* 获取标题栏背景颜色
* @return 标题栏背景颜色值
*/
public int getTitleBackgroundColor() {
return mTitleBackgroundColor;
}
/**
* 设置日志文本颜色
* @param textColor 颜色值（如 Color.BLACK 或 #000000）
*/
public void setTextColor(int textColor) {
this.mTextColor = textColor;
// 实时更新日志文本颜色
if (mTvReport != null) {
mTvReport.setTextColor(textColor);
}
}
/**
* 获取日志文本颜色
* @return 日志文本颜色值
*/
public int getTextColor() {
return mTextColor;
}
/**
* 设置日志区域背景颜色
* @param textBackgroundColor 颜色值（如 Color.WHITE 或 #FFFFFF）
*/
public void setTextBackgroundColor(int textBackgroundColor) {
this.mTextBackgroundColor = textBackgroundColor;
// 实时更新日志区域和主布局背景颜色
if (mTvReport != null) {
mTvReport.setBackgroundColor(textBackgroundColor);
}
setBackgroundColor(textBackgroundColor);
}
/**
* 获取日志区域背景颜色
* @return 日志区域背景颜色值
*/
public int getTextBackgroundColor() {
return mTextBackgroundColor;
}
/**
* 初始化默认配置（无自定义属性时使用）
*/
private void initDefaultConfig() {
// 设置默认配色
mTitleColor = Color.WHITE;
mTitleBackgroundColor = Color.BLACK;
mTextColor = Color.BLACK;
mTextBackgroundColor = Color.WHITE;
// 加载布局
inflateView();
// 初始化控件样式
initWidgetStyle();
}
/**
* 初始化视图（解析自定义属性 + 加载布局 + 设置样式）
* @param attrs 自定义属性集合
*/
private void initView(AttributeSet attrs) {
// 解析自定义属性（关联 attrs.xml 中的 GlobalCrashActivity 样式）
TypedArray typedArray = mContext.obtainStyledAttributes(
attrs,
R.styleable.GlobalCrashActivity,
R.attr.themeGlobalCrashActivity,
0
);
// 读取自定义属性值（无设置时使用默认值）
mTitleColor = typedArray.getColor(
R.styleable.GlobalCrashActivity_colorTittle,
Color.WHITE
);
mTitleBackgroundColor = typedArray.getColor(
R.styleable.GlobalCrashActivity_colorTittleBackgound, // 注：原拼写错误（Backgound→Background），保持与 attrs.xml 一致
Color.BLACK
);
mTextColor = typedArray.getColor(
R.styleable.GlobalCrashActivity_colorText,
Color.BLACK
);
mTextBackgroundColor = typedArray.getColor(
R.styleable.GlobalCrashActivity_colorTextBackgound, // 注：原拼写错误，保持与 attrs.xml 一致
Color.WHITE
);
// 回收 TypedArray，避免内存泄漏
typedArray.recycle();
// 加载布局文件
inflateView();
// 初始化控件样式
initWidgetStyle();
}
/**
* 加载布局文件
*/
private void inflateView() {
// 加载自定义布局（R.layout.view_globalcrashreport）
inflate(mContext, R.layout.view_globalcrashreport, this);
// 绑定控件
mToolbar = findViewById(R.id.viewglobalcrashreportToolbar1);
mTvReport = findViewById(R.id.viewglobalcrashreportTextView1);
}
/**
* 初始化控件样式（设置配色和基础属性）
*/
private void initWidgetStyle() {
// 设置主布局背景颜色
setBackgroundColor(mTextBackgroundColor);
// 配置工具栏样式
if (mToolbar != null) {
mToolbar.setBackgroundColor(mTitleBackgroundColor);
mToolbar.setTitleTextColor(mTitleColor);
mToolbar.setSubtitleTextColor(mTitleColor);
}
// 配置日志文本控件样式
if (mTvReport != null) {
mTvReport.setTextColor(mTextColor);
mTvReport.setBackgroundColor(mTextBackgroundColor);
// 可选：设置日志文本换行方式（默认已换行，此处增强可读性）
mTvReport.setSingleLine(false);
mTvReport.setHorizontallyScrolling(false);
}
}
/**
* 设置崩溃报告内容到文本控件
* @param report 崩溃日志字符串（通常包含异常信息、调用栈等）
*/
public void setReport(String report) {
if (mTvReport != null) {
mTvReport.setText(report);
}
}
/**
* 获取顶部工具栏对象（用于外部设置标题、添加菜单等）
* @return Toolbar 实例
*/
public Toolbar getToolbar() {
return mToolbar;
}
/**
* 更新工具栏菜单文字颜色（与标题颜色保持一致）
* 需在菜单加载完成后调用（如 Toolbar 加载菜单后）
*/
public void updateMenuStyle() {
if (mToolbar == null) return;
// 获取工具栏菜单
Menu menu = mToolbar.getMenu();
if (menu == null || menu.size() == 0) return;
// 遍历所有菜单项，设置文字颜色
for (int i = 0; i < menu.size(); i++) {
MenuItem menuItem = menu.getItem(i);
String title = menuItem.getTitle().toString();
// 使用 SpannableString 设置文字颜色
SpannableString spanString = new SpannableString(title);
spanString.setSpan(
new ForegroundColorSpan(mTitleColor),
0,
spanString.length(),
0 // Spannable.SPAN_INCLUSIVE_EXCLUSIVE（默认值，包含起始位置，不包含结束位置）
);
menuItem.setTitle(spanString);
}
}
}

240
libappbase/src/main/java/cc/winboll/studio/libappbase/HorizontalListView.java Normal file
View File

@@ -0,0 +1,240 @@
package cc.winboll.studio.libappbase;
import android.content.Context;
import android.util.AttributeSet;
import android.view.View;
import android.widget.ListView;
import android.widget.Scroller;
/**
* @Author ZhanGSKen&豆包大模型<zhangsken@qq.com>
* @Date 2025/11/11 20:26
* @Describe 水平滚动 ListView 控件
* 继承自 ListView，重写布局和测量逻辑，实现子项水平排列和滚动，替代默认垂直布局
*/
public class HorizontalListView extends ListView {
/** 日志标签，用于当前控件的日志输出标识 */
public static final String TAG = "HorizontalListView";
/** 子项垂直偏移量（用于调整子项在垂直方向的位置，默认 0） */
private int mVerticalOffset = 0;
/** 平滑滚动控制器（用于实现水平方向的平滑滚动动画） */
private Scroller mScroller;
/** 所有子项总宽度（包含内边距），用于计算滚动范围 */
private int mTotalWidth;
/**
* 构造方法：仅上下文
* @param context 上下文（Activity/Fragment）
*/
public HorizontalListView(Context context) {
super(context);
init();
}
/**
* 构造方法：上下文 + 自定义属性
* @param context 上下文
* @param attrs 自定义属性集合（如布局文件中设置的属性）
*/
public HorizontalListView(Context context, AttributeSet attrs) {
super(context, attrs);
init();
}
/**
* 构造方法：上下文 + 自定义属性 + 样式属性
* @param context 上下文
* @param attrs 自定义属性集合
* @param defStyle 样式属性（如系统默认样式）
*/
public HorizontalListView(Context context, AttributeSet attrs, int defStyle) {
super(context, attrs, defStyle);
init();
}
/**
* 初始化控件配置
* 初始化滚动控制器，设置滚动条显示状态
*/
private void init() {
// 初始化平滑滚动器（上下文为当前控件所在上下文）
mScroller = new Scroller(getContext());
// 启用水平滚动条（默认显示）
setHorizontalScrollBarEnabled(true);
// 禁用垂直滚动条（水平列表无需垂直滚动）
setVerticalScrollBarEnabled(false);
}
/**
* 设置子项垂直偏移量
* 用于整体调整所有子项在垂直方向的位置（如居中、偏移）
* @param verticalOffset 垂直偏移像素值（正数向下偏移，负数向上偏移）
*/
public void setVerticalOffset(int verticalOffset) {
this.mVerticalOffset = verticalOffset;
}
/**
* 重写布局方法：实现子项水平排列
* 遍历所有子项，按水平方向依次布局（左对齐，叠加排列）
* @param changed 布局是否发生变化（true：首次布局或尺寸变化；false：重绘）
* @param l 控件左边界坐标
* @param t 控件上边界坐标
* @param r 控件右边界坐标
* @param b 控件下边界坐标
*/
@Override
protected void onLayout(boolean changed, int l, int t, int r, int b) {
super.onLayout(changed, l, t, r, b); // 执行父类布局逻辑（确保基础配置生效）
int childCount = getChildCount(); // 获取当前可见子项数量
int left = getPaddingLeft(); // 子项起始左坐标（包含控件左内边距）
// 控件可用高度（总高度 - 上下内边距）
int viewHeight = getMeasuredHeight() - getPaddingTop() - getPaddingBottom();
mTotalWidth = left; // 初始化总宽度为左内边距
// 遍历子项，水平排列
for (int i = 0; i < childCount; i++) {
View child = getChildAt(i); // 获取当前子项
int childWidth = child.getMeasuredWidth(); // 子项测量宽度
int childHeight = child.getMeasuredHeight(); // 子项测量高度
// 布局子项：水平方向从 left 开始，垂直方向偏移 mVerticalOffset
child.layout(
left, // 子项左边界
mVerticalOffset, // 子项上边界（带垂直偏移）
left + childWidth, // 子项右边界（左 + 宽度）
mVerticalOffset + childHeight // 子项下边界（偏移 + 高度）
);
left += childWidth; // 更新下一个子项的起始左坐标
}
// 计算总宽度（所有子项宽度 + 左右内边距）
mTotalWidth = left + getPaddingRight();
}
/**
* 重写测量方法：设置控件测量规则
* 水平方向：允许无限宽度（适应所有子项总宽度）；垂直方向：自适应内容高度
* @param widthMeasureSpec 父控件传递的宽度测量规格
* @param heightMeasureSpec 父控件传递的高度测量规格
*/
@Override
protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) {
// 重写宽度测量规则：最大值（Integer.MAX_VALUE >> 2 避免溢出），自适应内容
int newWidthMeasureSpec = MeasureSpec.makeMeasureSpec(Integer.MAX_VALUE >> 2, MeasureSpec.AT_MOST);
// 重写高度测量规则：同上，自适应子项高度
int newHeightMeasureSpec = MeasureSpec.makeMeasureSpec(Integer.MAX_VALUE >> 2, MeasureSpec.AT_MOST);
// 执行父类测量逻辑（使用重写后的测量规格）
super.onMeasure(newWidthMeasureSpec, newHeightMeasureSpec);
}
/**
* 重写滚动计算方法：实现平滑滚动
* 配合 Scroller 实现水平方向的平滑滚动动画（需在滚动时调用 invalidate() 触发）
*/
@Override
public void computeScroll() {
// 判断滚动是否正在进行（Scroller 计算当前滚动位置）
if (mScroller.computeScrollOffset()) {
// 滚动到当前计算的位置（x 轴水平滚动，y 轴固定 0）
scrollTo(mScroller.getCurrX(), mScroller.getCurrY());
// 触发重绘，持续更新滚动状态
postInvalidate();
}
}
/**
* 平滑滚动到指定坐标
* 基于 Scroller 实现水平方向的平滑滚动（300ms 动画时长）
* @param x 目标 x 轴坐标（水平滚动位置）
* @param y 目标 y 轴坐标（固定 0，无需垂直滚动）
*/
public void smoothScrollTo(int x, int y) {
// 计算滚动距离（目标坐标 - 当前滚动坐标）
int dx = x - getScrollX();
int dy = y - getScrollY();
// 启动平滑滚动：起始坐标（当前滚动位置）、滚动距离、动画时长（300ms）
mScroller.startScroll(getScrollX(), getScrollY(), dx, dy, 300);
// 触发重绘，启动滚动动画
invalidate();
}
/**
* 计算水平滚动总范围（用于滚动条显示比例）
* @return 滚动总宽度（所有子项总宽度 + 内边距）
*/
@Override
public int computeHorizontalScrollRange() {
return mTotalWidth;
}
/**
* 计算当前水平滚动偏移量（用于滚动条位置）
* @return 当前 x 轴滚动坐标
*/
@Override
public int computeHorizontalScrollOffset() {
return getScrollX();
}
/**
* 计算水平滚动可视范围（用于滚动条大小）
* @return 控件可见宽度（当前显示区域宽度）
*/
@Override
public int computeHorizontalScrollExtent() {
return getWidth();
}
/**
* 滚动到指定位置的子项（水平方向）
* 定位目标子项，计算滚动坐标，执行平滑滚动
* @param position 子项索引（从 0 开始，仅当前可见子项有效）
*/
public void scrollToItem(int position) {
// 校验索引有效性（避免数组越界）
if (position < 0 || position >= getChildCount()) {
LogUtils.d(TAG, "无效的子项索引: " + position);
return;
}
View targetView = getChildAt(position); // 获取目标子项
int targetLeft = targetView.getLeft(); // 目标子项左边界坐标
// 计算目标滚动坐标（子项左边界 - 控件左内边距，确保子项左对齐显示）
int scrollX = targetLeft - getPaddingLeft();
// 修正滚动范围（避免超出总宽度或小于 0）
int maxScrollX = mTotalWidth - getWidth(); // 最大滚动坐标（总宽度 - 控件宽度）
scrollX = Math.max(0, Math.min(scrollX, maxScrollX));
// 强制重新布局和绘制（确保子项位置正确）
requestLayout();
invalidateViews();
// 平滑滚动到目标坐标
smoothScrollTo(scrollX, 0);
// 打印滚动日志（调试用）
LogUtils.d(TAG, String.format(
"滚动到子项索引: %d, 目标滚动X: %d, 总滚动范围: %d",
position, scrollX, computeHorizontalScrollRange()
));
}
/**
* 重置滚动到起始位置（最左侧）
* 强制重新布局后，平滑滚动到 x=0 坐标
*/
public void resetScrollToStart() {
// 强制重新布局和绘制（确保滚动位置准确）
requestLayout();
invalidateViews();
// 平滑滚动到最左侧（x=0，y=0）
smoothScrollTo(0, 0);
}
}

65
libappbase/src/main/java/cc/winboll/studio/libappbase/LogActivity.java Normal file
View File

@@ -0,0 +1,65 @@
package cc.winboll.studio.libappbase;
import android.app.Activity;
import android.content.Context;
import android.content.Intent;
import android.os.Bundle;
import cc.winboll.studio.libappbase.LogView;
import cc.winboll.studio.libappbase.R;
/**
* @Author ZhanGSKen&豆包大模型<zhangsken@qq.com>
* @Date 2025/11/11 20:29
* @Describe 应用日志展示 Activity
* 用于单独启动窗口展示应用运行日志，依赖 LogView 控件实现日志加载与显示
*/
public class LogActivity extends Activity {
/** 日志标签，用于当前 Activity 的日志输出标识 */
public static final String TAG = "LogActivity";
/** 日志展示控件（用于加载和显示应用日志） */
private LogView mLogView;
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
// 设置布局文件（包含 LogView 控件）
setContentView(R.layout.activity_log);
// 绑定布局中的 LogView 控件
mLogView = findViewById(R.id.logview);
// 启动 LogView 日志加载（如实时刷新日志内容）
mLogView.start();
}
@Override
protected void onResume() {
super.onResume();
// 恢复 Activity 时重新启动 LogView（确保日志持续更新）
mLogView.start();
}
/**
* 启动日志 Activity 的静态方法（外部调用入口）
* 配置 Intent 标志，以多任务/分屏模式启动，避免与主应用任务栈冲突
* @param context 上下文（Activity/Fragment），用于启动 Activity
*/
public static void startLogActivity(Context context) {
// 创建启动当前 Activity 的 Intent
Intent intent = new Intent(context, LogActivity.class);
// 添加 Intent 标志：支持分屏/多窗口模式（API 24+）
intent.addFlags(Intent.FLAG_ACTIVITY_LAUNCH_ADJACENT);
// 添加 Intent 标志：创建新任务栈（避免并入调用者任务栈）
intent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
// 添加 Intent 标志：标记为新文档（多任务窗口中独立显示）
intent.addFlags(Intent.FLAG_ACTIVITY_NEW_DOCUMENT);
// 添加 Intent 标志：允许创建多个任务实例（支持多次启动独立窗口）
intent.addFlags(Intent.FLAG_ACTIVITY_MULTIPLE_TASK);
// 启动 Activity
context.startActivity(intent);
}
}

637
libappbase/src/main/java/cc/winboll/studio/libappbase/LogUtils.java Normal file
View File

@@ -0,0 +1,637 @@
package cc.winboll.studio.libappbase;
import android.content.Context;
import dalvik.system.DexFile;
import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.lang.reflect.Field;
import java.lang.reflect.Modifier;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Enumeration;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Locale;
import java.util.Map;
/**
* @Author ZhanGSKen&豆包大模型<zhangsken@qq.com>
* @Date 2025/11/11 20:36
* @Describe WinBoLl 应用日志管理工具类（单例逻辑）
* 核心功能：日志分级控制、日志文件读写、TAG 过滤配置、应用内所有 TAG 自动扫描
* 支持 Debug/Release 模式区分存储路径，日志持久化与清理
* 适配 Java 7 语法，移除 Lambda、Stream 等 Java 8+ 特性
*/
public class LogUtils {
/** 当前工具类的日志 TAG */
public static final String TAG = "LogUtils";
/**
* 日志级别枚举（从低到高：关闭→错误→警告→信息→调试→详细）
* 级别越高，输出的日志越详细
*/
public static enum LOG_LEVEL { Off, Error, Warn, Info, Debug, Verbose }
/** 是否初始化完成标志（volatile 保证多线程可见性） */
private static volatile boolean sIsInited = false;
/** 全局上下文（用于获取存储路径、包信息） */
private static Context sContext;
/** 日志时间格式化工具（格式：[yyyyMMdd_HHmmss_SSS]，精确到毫秒） */
private static SimpleDateFormat sSimpleDateFormat = new SimpleDateFormat("[yyyyMMdd_HHmmss_SSS]", Locale.getDefault());
/** 日志缓存文件夹（Debug 模式下存储在外部缓存，Release 存储在内部缓存） */
private static File sLogCacheDir;
/** 日志配置文件夹（存储 TAG 配置文件） */
private static File sLogDataDir;
/** 日志存储文件（所有日志写入此文件） */
private static File sLogFile;
/** 日志配置文件（存储日志级别、TAG 启用状态等配置） */
private static File sLogConfigFile;
/** 日志配置实体类（封装日志级别等配置） */
private static LogUtilsBean sLogConfigBean;
/** TAG 过滤映射表（key：TAG 名称；value：是否启用该 TAG 的日志输出） */
public static Map<String, Boolean> sTagEnableMap = new HashMap<String, Boolean>();
/**
* 初始化日志工具（默认日志级别：Off，不输出日志）
* @param context 全局上下文（建议传入 Application 实例）
*/
public static void init(Context context) {
sContext = context;
init(context, LOG_LEVEL.Off);
}
/**
* 初始化日志工具（指定日志级别）
* 1. 根据 Debug/Release 模式初始化日志存储路径；
* 2. 加载日志配置文件；
* 3. 扫描应用内所有类的 TAG 并初始化过滤映射表；
* 4. 标记初始化完成。
* @param context 全局上下文
* @param logLevel 初始日志级别
*/
public static void init(Context context, LOG_LEVEL logLevel) {
sContext = context;
// 根据 Debug 模式选择存储路径（外部/内部存储）
if (GlobalApplication.isDebugging()) {
// Debug 模式：存储在外部缓存目录（可通过文件管理器查看）
sLogCacheDir = new File(context.getApplicationContext().getExternalCacheDir(), TAG);
sLogDataDir = context.getApplicationContext().getExternalFilesDir(TAG);
} else {
// Release 模式：存储在内部缓存目录（仅应用自身可访问）
sLogCacheDir = new File(context.getApplicationContext().getCacheDir(), TAG);
sLogDataDir = new File(context.getApplicationContext().getFilesDir(), TAG);
}
// 创建日志文件夹（不存在则创建）
createDirIfNotExists(sLogCacheDir);
createDirIfNotExists(sLogDataDir);
// 初始化日志文件和配置文件路径
sLogFile = new File(sLogCacheDir, "log.txt");
sLogConfigFile = new File(sLogDataDir, TAG + ".json");
// 加载日志配置（从文件读取，读取失败则创建默认配置）
sLogConfigBean = LogUtilsBean.loadBeanFromFile(sLogConfigFile.getPath(), LogUtilsBean.class);
if (sLogConfigBean == null) {
sLogConfigBean = new LogUtilsBean();
sLogConfigBean.setLogLevel(logLevel);
// 保存默认配置到文件
sLogConfigBean.saveBeanToFile(sLogConfigFile.getPath(), sLogConfigBean);
}
// 扫描应用内所有类的 TAG 并添加到过滤映射表
scanAllClassTags();
// 加载已保存的 TAG 启用状态配置
loadTagEnableSettings();
// 标记初始化完成
sIsInited = true;
// 打印初始化日志（调试用）
d(TAG, String.format("TAG 过滤映射表初始化完成：%s", sTagEnableMap.toString()));
}
/**
* 获取 TAG 过滤映射表（外部可通过此方法获取所有 TAG 及其启用状态）
* @return TAG 名称与启用状态的映射
*/
public static Map<String, Boolean> getTagEnableMap() {
return sTagEnableMap;
}
/**
* 加载已保存的 TAG 启用状态配置
* 从 LogUtilsClassTAGBean 列表中读取每个 TAG 的启用状态，更新到映射表
*/
private static void loadTagEnableSettings() {
ArrayList<LogUtilsClassTAGBean> tagSettingList = new ArrayList<LogUtilsClassTAGBean>();
// 从文件加载 TAG 配置列表
LogUtilsClassTAGBean.loadBeanList(sContext, tagSettingList, LogUtilsClassTAGBean.class);
// 遍历配置列表，更新 TAG 启用状态（Java 7 增强 for 循环）
for (LogUtilsClassTAGBean tagSetting : tagSettingList) {
String tag = tagSetting.getTag();
boolean isEnable = tagSetting.getEnable();
// 仅更新已存在的 TAG（避免无效配置）
if (sTagEnableMap.containsKey(tag)) {
sTagEnableMap.put(tag, isEnable);
}
}
}
/**
* 保存当前 TAG 启用状态配置到文件
* 将映射表中的 TAG 及其启用状态转换为 LogUtilsClassTAGBean 列表，持久化到文件
*/
private static void saveTagEnableSettings() {
ArrayList<LogUtilsClassTAGBean> tagSettingList = new ArrayList<LogUtilsClassTAGBean>();
// 遍历映射表，构建配置列表（Java 7 迭代器遍历）
Iterator<Map.Entry<String, Boolean>> iterator = sTagEnableMap.entrySet().iterator();
while (iterator.hasNext()) {
Map.Entry<String, Boolean> entry = iterator.next();
tagSettingList.add(new LogUtilsClassTAGBean(entry.getKey(), entry.getValue()));
}
// 保存配置列表到文件
LogUtilsClassTAGBean.saveBeanList(sContext, tagSettingList, LogUtilsClassTAGBean.class);
}
/**
* 扫描应用内所有类的 TAG 并添加到过滤映射表
* 1. 通过 DexFile 读取 APK 中所有类；
* 2. 过滤指定包名前缀（cc.winboll.studio）的类；
* 3. 反射获取类中 public static final String TAG 字段的值；
* 4. 将 TAG 加入映射表，默认禁用（false）。
*/
private static void scanAllClassTags() {
try {
// 应用 APK 路径（通过上下文获取）
String apkPath = sContext.getPackageCodePath();
d(TAG, String.format("APK 路径：%s", apkPath));
// 读取 APK 中的所有类
DexFile dexFile = new DexFile(apkPath);
Enumeration<String> classNames = dexFile.entries();
int totalClassCount = 0; // 总类数（调试用）
List<String> targetClassNames = new ArrayList<String>(); // 目标包名下的类名列表
String targetPackagePrefix = "cc.winboll.studio"; // 目标包名前缀
// 过滤目标包名下的类（Java 7 枚举遍历）
while (classNames.hasMoreElements()) {
totalClassCount++;
String className = classNames.nextElement();
if (className.startsWith(targetPackagePrefix)) {
targetClassNames.add(className);
}
}
// 打印扫描统计（调试用）
d(TAG, String.format("APK 总类数：%d，目标包下类数：%d", totalClassCount, targetClassNames.size()));
// 反射获取每个类的 TAG 字段（Java 7 增强 for 循环）
for (String className : targetClassNames) {
try {
Class<?> clazz = Class.forName(className);
// 获取类中所有声明的字段
Field[] fields = clazz.getDeclaredFields();
for (Field field : fields) {
// 过滤条件：public static String 类型，且字段名是 "TAG"
if (Modifier.isStatic(field.getModifiers())
&& Modifier.isPublic(field.getModifiers())
&& field.getType() == String.class
&& "TAG".equals(field.getName())) {
// 获取 TAG 字段的值（静态字段，传入 null 即可）
String tagValue = (String) field.get(null);
// 添加到映射表，默认禁用
sTagEnableMap.put(tagValue, false);
}
}
} catch (NoClassDefFoundError e) {
// 捕获反射异常，避免单个类扫描失败影响整体
d(TAG, e.getMessage(), Thread.currentThread().getStackTrace());
} catch (ClassNotFoundException e) {
d(TAG, e.getMessage(), Thread.currentThread().getStackTrace());
} catch (IllegalAccessException e) {
d(TAG, e.getMessage(), Thread.currentThread().getStackTrace());
}
}
} catch (IOException e) {
// 捕获 APK 读取异常
d(TAG, e, Thread.currentThread().getStackTrace());
}
}
/**
* 设置单个 TAG 的启用状态
* @param tag TAG 名称
* @param isEnable 是否启用（true：输出该 TAG 的日志；false：不输出）
*/
public static void setTagEnable(String tag, boolean isEnable) {
// 遍历映射表，更新目标 TAG 的状态（Java 7 迭代器遍历）
Iterator<Map.Entry<String, Boolean>> iterator = sTagEnableMap.entrySet().iterator();
while (iterator.hasNext()) {
Map.Entry<String, Boolean> entry = iterator.next();
if (tag.equals(entry.getKey())) {
entry.setValue(isEnable);
break;
}
}
// 保存配置到文件（持久化）
saveTagEnableSettings();
d(TAG, String.format("TAG 配置更新：%s", sTagEnableMap.toString()));
}
/**
* 设置所有 TAG 的启用状态（批量控制）
* @param isEnable 是否启用（true：所有 TAG 均输出日志；false：所有 TAG 均不输出）
*/
public static void setAllTagsEnable(boolean isEnable) {
// 遍历映射表，批量更新所有 TAG 的状态（Java 7 迭代器遍历）
Iterator<Map.Entry<String, Boolean>> iterator = sTagEnableMap.entrySet().iterator();
while (iterator.hasNext()) {
Map.Entry<String, Boolean> entry = iterator.next();
entry.setValue(isEnable);
}
// 保存配置到文件（持久化）
saveTagEnableSettings();
d(TAG, String.format("所有 TAG 配置更新：%s", sTagEnableMap.toString()));
}
/**
* 设置全局日志级别（控制日志输出的详细程度）
* @param logLevel 目标日志级别
*/
public static void setLogLevel(LOG_LEVEL logLevel) {
if (sLogConfigBean != null) {
sLogConfigBean.setLogLevel(logLevel);
// 保存配置到文件（持久化）
sLogConfigBean.saveBeanToFile(sLogConfigFile.getPath(), sLogConfigBean);
}
}
/**
* 获取当前全局日志级别
* @return 当前日志级别
*/
public static LOG_LEVEL getLogLevel() {
return sLogConfigBean != null ? sLogConfigBean.getLogLevel() : LOG_LEVEL.Off;
}
/**
* 判断当前日志是否可输出（校验初始化状态、TAG 启用状态、日志级别）
* @param tag 日志 TAG
* @param logLevel 日志级别
* @return true：可输出；false：不可输出
*/
private static boolean isLoggable(String tag, LOG_LEVEL logLevel) {
// 未初始化：不输出
if (!sIsInited) {
return false;
}
// TAG 未配置或未启用：不输出
if (sTagEnableMap.get(tag) == null || !sTagEnableMap.get(tag)) {
return false;
}
// 日志级别未达到：不输出
if (!isLevelMatched(logLevel)) {
return false;
}
return true;
}
/**
* 判断日志级别是否匹配（当前全局级别 >= 目标级别时可输出）
* 例：全局级别为 Debug（4），则 Error（1）、Warn（2）、Info（3）、Debug（4）均可输出
* @param logLevel 目标日志级别
* @return true：级别匹配；false：不匹配
*/
private static boolean isLevelMatched(LOG_LEVEL logLevel) {
if (sLogConfigBean == null) {
return false;
}
// 枚举的 ordinal() 方法返回索引（Off=0，Error=1，...，Verbose=5）
return sLogConfigBean.getLogLevel().ordinal() >= logLevel.ordinal();
}
/**
* 获取日志缓存文件夹路径（外部可通过此方法获取日志存储目录）
* @return 日志缓存文件夹
*/
public static File getLogCacheDir() {
return sLogCacheDir;
}
/**
* 输出 Error 级别日志
* @param tag TAG 名称
* @param message 日志内容
*/
public static void e(String tag, String message) {
if (isLoggable(tag, LOG_LEVEL.Error)) {
saveLog(tag, LOG_LEVEL.Error, message);
}
}
/**
* 输出 Error 级别日志（带异常信息和调用栈）
* 错误级别专用，包含完整异常详情，便于错误定位和排查
* @param tag TAG 名称
* @param message 日志内容
* @param e 异常对象（存储异常信息和调用栈）
*/
public static void e(String tag, String message, Exception e) {
if (isLoggable(tag, LOG_LEVEL.Error)) {
StackTraceElement[] stackTrace = Thread.currentThread().getStackTrace();
StringBuilder sb = new StringBuilder(message);
// 拼接异常信息（类型 + 消息）
sb.append(" \nException: ")
.append(e.getClass().getSimpleName())
.append(" : ")
.append(e.getMessage() != null ? e.getMessage() : "无异常消息");
// 拼接调用栈信息（stackTrace[2] 为实际调用处）
sb.append(" \nAt ")
.append(stackTrace[2].getMethodName())
.append(" (")
.append(stackTrace[2].getFileName())
.append(":")
.append(stackTrace[2].getLineNumber())
.append(")");
saveLog(tag, LOG_LEVEL.Error, sb.toString());
}
}
/**
* 输出 Warn 级别日志
* @param tag TAG 名称
* @param message 日志内容
*/
public static void w(String tag, String message) {
if (isLoggable(tag, LOG_LEVEL.Warn)) {
saveLog(tag, LOG_LEVEL.Warn, message);
}
}
/**
* 输出 Warn 级别日志（带异常信息和调用栈）
* 包含日志内容、异常详情、调用位置，便于警告场景下的问题定位
* @param tag TAG 名称
* @param message 日志内容
* @param e 异常对象（存储异常信息和调用栈）
*/
public static void w(String tag, String message, Exception e) {
if (isLoggable(tag, LOG_LEVEL.Warn)) {
StackTraceElement[] stackTrace = Thread.currentThread().getStackTrace();
StringBuilder sb = new StringBuilder(message);
// 拼接异常信息（类型 + 消息）
sb.append(" \nException: ")
.append(e.getClass().getSimpleName())
.append(" : ")
.append(e.getMessage() != null ? e.getMessage() : "无异常消息");
// 拼接调用栈信息（stackTrace[2] 为实际调用处）
sb.append(" \nAt ")
.append(stackTrace[2].getMethodName())
.append(" (")
.append(stackTrace[2].getFileName())
.append(":")
.append(stackTrace[2].getLineNumber())
.append(")");
saveLog(tag, LOG_LEVEL.Warn, sb.toString());
}
}
/**
* 输出 Info 级别日志
* @param tag TAG 名称
* @param message 日志内容
*/
public static void i(String tag, String message) {
if (isLoggable(tag, LOG_LEVEL.Info)) {
saveLog(tag, LOG_LEVEL.Info, message);
}
}
/**
* 输出 Debug 级别日志（基础版）
* @param tag TAG 名称
* @param message 日志内容
*/
public static void d(String tag, String message) {
if (isLoggable(tag, LOG_LEVEL.Debug)) {
saveLog(tag, LOG_LEVEL.Debug, message);
}
}
/**
* 输出 Debug 级别日志（带调用栈信息）
* 包含调用方法名、文件名、行号，便于调试定位
* @param tag TAG 名称
* @param message 日志内容
* @param stackTrace 线程调用栈（通常传入 Thread.currentThread().getStackTrace()）
*/
public static void d(String tag, String message, StackTraceElement[] stackTrace) {
if (isLoggable(tag, LOG_LEVEL.Debug)) {
StringBuilder sb = new StringBuilder(message);
// 拼接调用栈信息（stackTrace[2] 为实际调用处）
sb.append(" \nAt ")
.append(stackTrace[2].getMethodName())
.append(" (")
.append(stackTrace[2].getFileName())
.append(":")
.append(stackTrace[2].getLineNumber())
.append(")");
saveLog(tag, LOG_LEVEL.Debug, sb.toString());
}
}
/**
* 输出 Debug 级别日志（带异常信息和调用栈）
* 包含异常类型、异常信息、调用位置，便于异常定位
* @param tag TAG 名称
* @param e 异常对象
* @param stackTrace 线程调用栈
*/
public static void d(String tag, Exception e, StackTraceElement[] stackTrace) {
if (isLoggable(tag, LOG_LEVEL.Debug)) {
StringBuilder sb = new StringBuilder();
// 拼接异常信息
sb.append(e.getClass().getSimpleName())
.append(" : ")
.append(e.getMessage() != null ? e.getMessage() : "无异常消息")
// 拼接调用栈信息
.append(" \nAt ")
.append(stackTrace[2].getMethodName())
.append(" (")
.append(stackTrace[2].getFileName())
.append(":")
.append(stackTrace[2].getLineNumber())
.append(")");
saveLog(tag, LOG_LEVEL.Debug, sb.toString());
}
}
/**
* 输出 Debug 级别日志（带日志内容+异常对象，简化调用）
* 无需手动传入调用栈，内部自动获取，适配常见调试场景
* @param tag TAG 名称
* @param message 日志内容
* @param e 异常对象（存储异常信息和调用栈）
*/
public static void d(String tag, String message, Exception e) {
if (isLoggable(tag, LOG_LEVEL.Debug)) {
// 自动获取当前线程调用栈，简化外部调用
StackTraceElement[] stackTrace = Thread.currentThread().getStackTrace();
StringBuilder sb = new StringBuilder(message);
// 拼接异常信息（类型 + 消息）
sb.append(" \nException: ")
.append(e.getClass().getSimpleName())
.append(" : ")
.append(e.getMessage() != null ? e.getMessage() : "无异常消息");
// 拼接调用栈信息（stackTrace[2] 为实际调用处）
sb.append(" \nAt ")
.append(stackTrace[2].getMethodName())
.append(" (")
.append(stackTrace[2].getFileName())
.append(":")
.append(stackTrace[2].getLineNumber())
.append(")");
saveLog(tag, LOG_LEVEL.Debug, sb.toString());
}
}
/**
* 输出 Verbose 级别日志（最详细级别）
* @param tag TAG 名称
* @param message 日志内容
*/
public static void v(String tag, String message) {
if (isLoggable(tag, LOG_LEVEL.Verbose)) {
saveLog(tag, LOG_LEVEL.Verbose, message);
}
}
/**
* 核心日志保存方法（将日志写入文件）
* 日志格式：[级别] [时间戳] [TAG]
* 日志内容
* @param tag TAG 名称
* @param logLevel 日志级别
* @param message 日志内容
*/
private static void saveLog(String tag, LOG_LEVEL logLevel, String message) {
BufferedWriter writer = null;
try {
// 以追加模式打开日志文件，UTF-8 编码
writer = new BufferedWriter(
new OutputStreamWriter(
new FileOutputStream(sLogFile, true),
"UTF-8"
)
);
// 拼接日志内容（级别 + 时间 + TAG + 消息）
String logContent = String.format(
"[%s] %s [%s]\n%s\n",
logLevel.name(), // 日志级别（如 Debug）
sSimpleDateFormat.format(System.currentTimeMillis()), // 时间戳
tag, // TAG 名称
message // 日志内容
);
// 写入文件
writer.write(logContent);
} catch (IOException e) {
// 日志写入失败时，输出内部调试日志
d(TAG, "日志写入失败：" + (e.getMessage() != null ? e.getMessage() : "未知错误"));
} finally {
// 关闭流，避免资源泄漏（Java 7 手动关闭，不使用 try-with-resources）
if (writer != null) {
try {
writer.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
/**
* 加载历史日志（读取日志文件所有内容）
* @return 历史日志字符串（空字符串表示文件不存在或读取失败）
*/
public static String loadLog() {
// 日志文件不存在，返回空
if (sLogFile == null || !sLogFile.exists()) {
return "";
}
StringBuilder logContent = new StringBuilder();
BufferedReader reader = null;
try {
// 以 UTF-8 编码读取日志文件
reader = new BufferedReader(
new InputStreamReader(
new FileInputStream(sLogFile),
"UTF-8"
)
);
String line;
// 逐行读取并拼接（Java 7 普通 while 循环）
while ((line = reader.readLine()) != null) {
logContent.append(line).append("\n");
}
} catch (IOException e) {
// 读取失败时，输出内部调试日志
d(TAG, "日志读取失败：" + (e.getMessage() != null ? e.getMessage() : "未知错误"));
} finally {
// 关闭流，避免资源泄漏
if (reader != null) {
try {
reader.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
return logContent.toString();
}
/**
* 清理历史日志（清空日志文件内容）
*/
public static void cleanLog() {
if (sLogFile == null || !sLogFile.exists()) {
return;
}
try {
// 写入空字符串到文件，实现清空（Java 7 手动处理流）
BufferedWriter writer = new BufferedWriter(
new OutputStreamWriter(
new FileOutputStream(sLogFile),
"UTF-8"
)
);
writer.write("");
writer.close();
} catch (IOException e) {
// 清空失败时，输出内部调试日志（带调用栈）
d(TAG, e, Thread.currentThread().getStackTrace());
}
}
/**
* 辅助方法：创建文件夹（不存在则创建）
* @param dir 目标文件夹
*/
private static void createDirIfNotExists(File dir) {
if (dir != null && !dir.exists()) {
dir.mkdirs();
}
}
}

131
libappbase/src/main/java/cc/winboll/studio/libappbase/LogUtilsBean.java Normal file
View File

@@ -0,0 +1,131 @@
package cc.winboll.studio.libappbase;
import android.util.JsonReader;
import android.util.JsonWriter;
import java.io.IOException;
/**
* @Author ZhanGSKen<zhangsken@qq.com>
* @Date 2024/08/23 15:39:07
* @Describe LogUtils 配置数据模型（继承 BaseBean，实现 JSON 序列化/反序列化）
* 封装 LogUtils 的核心配置参数（当前仅日志级别），用于配置的持久化存储与读取
*/
public class LogUtilsBean extends BaseBean {
/** 当前类的日志 TAG（用于调试输出） */
public static final String TAG = "LogUtilsBean";
/**
* 全局日志级别（默认值：Off，即不输出任何日志）
* 关联 LogUtils.LOG_LEVEL 枚举，存储日志输出的级别阈值
*/
private LogUtils.LOG_LEVEL logLevel;
/**
* 无参构造方法（默认初始化日志级别为 Off）
* 用于 JSON 反序列化时的实例创建
*/
public LogUtilsBean() {
this.logLevel = LogUtils.LOG_LEVEL.Off;
}
/**
* 有参构造方法（指定初始日志级别）
* @param logLevel 初始日志级别（如 LogUtils.LOG_LEVEL.Debug）
*/
public LogUtilsBean(LogUtils.LOG_LEVEL logLevel) {
this.logLevel = logLevel;
}
/**
* 设置日志级别（更新配置时使用）
* @param logLevel 目标日志级别
*/
public void setLogLevel(LogUtils.LOG_LEVEL logLevel) {
this.logLevel = logLevel;
}
/**
* 获取当前日志级别（读取配置时使用）
* @return 当前配置的日志级别
*/
public LogUtils.LOG_LEVEL getLogLevel() {
return logLevel;
}
/**
* 重写父类方法：获取当前类的全限定名（用于 BaseBean 反射识别）
* @return 类全限定名（如 "cc.winboll.studio.libappbase.LogUtilsBean"）
*/
@Override
public String getName() {
return LogUtilsBean.class.getName();
}
/**
* 重写父类方法：将当前配置对象序列化为 JSON（持久化存储时调用）
* 序列化字段：logLevel（存储枚举的 ordinal 值，确保反序列化一致性）
* @param jsonWriter JSON 写入器（用于输出 JSON 数据）
* @throws IOException JSON 写入异常（如流关闭、格式错误）
*/
@Override
public void writeThisToJsonWriter(JsonWriter jsonWriter) throws IOException {
// 调用父类序列化逻辑（若 BaseBean 有公共字段，需优先处理）
super.writeThisToJsonWriter(jsonWriter);
// 序列化日志级别：存储枚举的索引值（如 Off=0、Error=1...），比存储名称更高效
jsonWriter.name("logLevel").value(this.getLogLevel().ordinal());
}
/**
* 重写父类方法：从 JSON 字段初始化当前对象（读取配置时调用）
* 解析字段：logLevel（通过索引值恢复 LogUtils.LOG_LEVEL 枚举）
* @param jsonReader JSON 读取器（用于读取 JSON 数据）
* @param name JSON 字段名（当前解析的字段）
* @return true：字段解析成功；false：字段不匹配（需父类处理或跳过）
* @throws IOException JSON 读取异常（如字段类型不匹配、流中断）
*/
@Override
public boolean initObjectsFromJsonReader(JsonReader jsonReader, String name) throws IOException {
// 先让父类处理公共字段，处理成功则直接返回
if (super.initObjectsFromJsonReader(jsonReader, name)) {
return true;
}
// 解析当前类专属字段
if ("logLevel".equals(name)) {
// 通过枚举索引值恢复枚举实例（确保与序列化时的 ordinal 对应）
int levelOrdinal = jsonReader.nextInt();
this.setLogLevel(LogUtils.LOG_LEVEL.values()[levelOrdinal]);
} else {
// 字段不匹配，返回 false 表示需要跳过该字段
return false;
}
// 字段解析成功
return true;
}
/**
* 重写父类方法：从 JSON 读取器完整解析配置对象（入口方法）
* 负责 JSON 对象的开始/结束解析，遍历所有字段并调用 initObjectsFromJsonReader 处理
* @param jsonReader JSON 读取器（传入待解析的 JSON 流）
* @return 解析后的当前 LogUtilsBean 实例（支持链式调用）
* @throws IOException JSON 解析异常（如格式错误、字段缺失）
*/
@Override
public BaseBean readBeanFromJsonReader(JsonReader jsonReader) throws IOException {
// 开始解析 JSON 对象（必须与 writeThisToJsonWriter 中的结构对应）
jsonReader.beginObject();
// 遍历 JSON 中的所有字段
while (jsonReader.hasNext()) {
String fieldName = jsonReader.nextName();
// 解析字段，若字段不匹配则跳过该值（避免解析失败）
if (!this.initObjectsFromJsonReader(jsonReader, fieldName)) {
jsonReader.skipValue();
}
}
// 结束 JSON 对象解析（必须调用，否则会导致流异常）
jsonReader.endObject();
// 返回当前实例，支持链式调用（如 new LogUtilsBean().readBeanFromJsonReader(reader)）
return this;
}
}

161
libappbase/src/main/java/cc/winboll/studio/libappbase/LogUtilsClassTAGBean.java Normal file
View File

@@ -0,0 +1,161 @@
package cc.winboll.studio.libappbase;
import android.util.JsonReader;
import android.util.JsonWriter;
import java.io.IOException;
/**
* @Author ZhanGSKen<zhangsken@qq.com>
* @Date 2025/01/04 14:17:02
* @Describe 日志 TAG 过滤配置模型（继承 BaseBean，实现 JSON 序列化/反序列化）
* 封装单个日志 TAG 的名称及其启用状态，用于 LogUtils 的 TAG 过滤规则持久化存储与读取
*/
public class LogUtilsClassTAGBean extends BaseBean {
/** 当前类的日志 TAG（用于调试输出） */
public static final String TAG = "LogUtilsClassTAGBean";
/**
* 日志 TAG 名称（如 "LogViewThread"、"ToastUtils"）
* 与 LogUtils 中扫描的应用内 TAG 一一对应
*/
private String tag;
/**
* TAG 启用状态（控制该 TAG 的日志是否输出）
* true：启用（输出该 TAG 的日志）；false：禁用（不输出该 TAG 的日志）
*/
private Boolean enable;
/**
* 无参构造方法（默认初始化：TAG 为当前类 TAG，启用状态为 true）
* 用于 JSON 反序列化时的实例创建，或默认配置生成
*/
public LogUtilsClassTAGBean() {
this.tag = TAG; // 默认 TAG 为当前类的 TAG
this.enable = true; // 默认启用该 TAG 的日志输出
}
/**
* 有参构造方法（指定 TAG 名称和启用状态）
* 用于主动创建 TAG 过滤配置实例
* @param tag 日志 TAG 名称
* @param enable TAG 启用状态（true/false）
*/
public LogUtilsClassTAGBean(String tag, Boolean enable) {
this.tag = tag;
this.enable = enable;
}
/**
* 设置日志 TAG 名称
* @param tag 目标 TAG 名称
*/
public void setTag(String tag) {
this.tag = tag;
}
/**
* 获取日志 TAG 名称
* @return 当前配置的 TAG 名称
*/
public String getTag() {
return tag;
}
/**
* 设置 TAG 启用状态
* @param enable 目标启用状态（true：启用；false：禁用）
*/
public void setEnable(Boolean enable) {
this.enable = enable;
}
/**
* 获取 TAG 启用状态
* @return 当前 TAG 的启用状态
*/
public Boolean getEnable() {
return enable;
}
/**
* 重写父类方法：获取当前类的全限定名（用于 BaseBean 反射识别）
* @return 类全限定名（如 "cc.winboll.studio.libappbase.LogUtilsClassTAGBean"）
*/
@Override
public String getName() {
return LogUtilsClassTAGBean.class.getName();
}
/**
* 重写父类方法：将当前 TAG 配置对象序列化为 JSON（持久化存储时调用）
* 序列化字段：tag（TAG 名称）、enable（启用状态）
* @param jsonWriter JSON 写入器（用于输出 JSON 数据）
* @throws IOException JSON 写入异常（如流关闭、格式错误）
*/
@Override
public void writeThisToJsonWriter(JsonWriter jsonWriter) throws IOException {
// 调用父类序列化逻辑（若 BaseBean 有公共字段，需优先处理）
super.writeThisToJsonWriter(jsonWriter);
// 序列化 TAG 名称
jsonWriter.name("tag").value(this.getTag());
// 序列化启用状态
jsonWriter.name("enable").value(this.getEnable());
}
/**
* 重写父类方法：从 JSON 字段初始化当前对象（读取配置时调用）
* 解析字段：tag（TAG 名称）、enable（启用状态）
* @param jsonReader JSON 读取器（用于读取 JSON 数据）
* @param name JSON 字段名（当前解析的字段）
* @return true：字段解析成功；false：字段不匹配（需父类处理或跳过）
* @throws IOException JSON 读取异常（如字段类型不匹配、流中断）
*/
@Override
public boolean initObjectsFromJsonReader(JsonReader jsonReader, String name) throws IOException {
// 先让父类处理公共字段，处理成功则直接返回
if (super.initObjectsFromJsonReader(jsonReader, name)) {
return true;
}
// 解析当前类专属字段
if ("tag".equals(name)) {
// 读取 TAG 名称并设置
this.setTag(jsonReader.nextString());
} else if ("enable".equals(name)) {
// 读取启用状态并设置
this.setEnable(jsonReader.nextBoolean());
} else {
// 字段不匹配，返回 false 表示需要跳过该字段
return false;
}
// 字段解析成功
return true;
}
/**
* 重写父类方法：从 JSON 读取器完整解析配置对象（入口方法）
* 负责 JSON 对象的开始/结束解析，遍历所有字段并调用 initObjectsFromJsonReader 处理
* @param jsonReader JSON 读取器（传入待解析的 JSON 流）
* @return 解析后的当前 LogUtilsClassTAGBean 实例（支持链式调用）
* @throws IOException JSON 解析异常（如格式错误、字段缺失）
*/
@Override
public BaseBean readBeanFromJsonReader(JsonReader jsonReader) throws IOException {
// 开始解析 JSON 对象（必须与 writeThisToJsonWriter 中的结构对应）
jsonReader.beginObject();
// 遍历 JSON 中的所有字段
while (jsonReader.hasNext()) {
String fieldName = jsonReader.nextName();
// 解析字段，若字段不匹配则跳过该值（避免解析失败）
if (!this.initObjectsFromJsonReader(jsonReader, fieldName)) {
jsonReader.skipValue();
}
}
// 结束 JSON 对象解析（必须调用，否则会导致流异常）
jsonReader.endObject();
// 返回当前实例，支持链式调用（如 new LogUtilsClassTAGBean().readBeanFromJsonReader(reader)）
return this;
}
}

654
libappbase/src/main/java/cc/winboll/studio/libappbase/LogView.java Normal file
View File

@@ -0,0 +1,654 @@
package cc.winboll.studio.libappbase;
import android.content.ClipData;
import android.content.ClipboardManager;
import android.content.Context;
import android.os.Handler;
import android.os.Message;
import android.text.Editable;
import android.text.TextWatcher;
import android.util.AttributeSet;
import android.view.LayoutInflater;
import android.view.View;
import android.view.ViewGroup;
import android.widget.AdapterView;
import android.widget.ArrayAdapter;
import android.widget.BaseAdapter;
import android.widget.CheckBox;
import android.widget.EditText;
import android.widget.HorizontalScrollView;
import android.widget.RelativeLayout;
import android.widget.ScrollView;
import android.widget.Spinner;
import android.widget.TextView;
import java.text.Collator;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.List;
import java.util.Map;
/**
* @Author ZhanGSKen<zhangsken@qq.com>
* @Date 2024/08/12 14:36:18
* @Describe 日志可视化自定义 View（继承 RelativeLayout）
* 核心功能：日志展示、日志级别筛选、TAG 过滤（启用/禁用）、TAG 搜索定位、日志清理/复制、视图交互控制
* 依赖 LogUtils 进行日志读写，通过 LogViewThread 监听日志文件变化并自动刷新
*/
public class LogView extends RelativeLayout {
/** 当前 View 的日志 TAG（用于调试输出） */
public static final String TAG = "LogView";
/** 日志处理中标志（避免并发刷新，volatile 保证多线程可见性） */
private volatile boolean mIsHandling;
/** 新日志添加标志（标记有未处理的新日志，volatile 保证多线程可见性） */
private volatile boolean mIsAddNewLog;
/** 上下文对象（用于布局加载、系统服务获取） */
private Context mContext;
/** 日志滚动视图（包裹日志文本，支持垂直滚动） */
private ScrollView mLogScrollView;
/** 日志文本展示控件（显示所有日志内容） */
private TextView mLogTextView;
/** TAG 搜索输入框（用于搜索并定位目标 TAG） */
private EditText mTagSearchEt;
/** 文本选择开关（控制是否允许选中日志文本） */
private CheckBox mTextSelectableCb;
/** 全选 TAG 开关（控制所有 TAG 的启用/禁用） */
private CheckBox mSelectAllTagCb;
/** TAG 列表适配器（绑定 TAG 数据与视图，处理勾选状态） */
private TAGListAdapter mTagListAdapter;
/** 日志监听线程（监听日志文件变化，触发视图刷新） */
private LogViewThread mLogViewThread;
/** 日志视图 Handler（主线程更新 UI，避免跨线程操作） */
private LogViewHandler mLogViewHandler;
/** 日志级别选择下拉框（用于切换全局日志输出级别） */
private Spinner mLogLevelSpinner;
/** 日志级别适配器（绑定 LogUtils.LOG_LEVEL 枚举与 Spinner） */
private ArrayAdapter<CharSequence> mLogLevelAdapter;
/** TAG 水平列表视图（横向展示所有 TAG，支持滚动） */
private HorizontalListView mTagHorizontalListView;
// ====================== 构造方法（初始化视图） ======================
public LogView(Context context) {
super(context);
initView(context);
}
public LogView(Context context, AttributeSet attrs) {
super(context, attrs);
initView(context);
}
public LogView(Context context, AttributeSet attrs, int defStyleAttr) {
super(context, attrs, defStyleAttr);
initView(context);
}
public LogView(Context context, AttributeSet attrs, int defStyleAttr, int defStyleRes) {
super(context, attrs, defStyleAttr, defStyleRes);
initView(context);
}
/**
* 启动日志监听与展示
* 1. 初始化并启动 LogViewThread（监听日志文件变化）；
* 2. 初始加载并展示日志内容。
*/
public void start() {
mLogViewThread = new LogViewThread(this);
mLogViewThread.start();
showAndScrollLogView(); // 初始显示日志并滚动到底部
}
/**
* 滚动日志到底部（确保最新日志可见）
* 运行在主线程，通过 post 提交 Runnable 避免 UI 线程阻塞
*/
private void scrollLogToBottom() {
mLogScrollView.post(new Runnable() {
@Override
public void run() {
// 滚动到 ScrollView 底部（FOCUS_DOWN 表示聚焦到底部）
mLogScrollView.fullScroll(ScrollView.FOCUS_DOWN);
// 标记日志处理完成
mLogViewHandler.setIsHandling(false);
// 检查是否有未处理的新日志，有则再次触发刷新
if (mLogViewHandler.isAddNewLog()) {
mLogViewHandler.setIsAddNewLog(false);
Message refreshMsg = mLogViewHandler.obtainMessage(LogViewHandler.MSG_LOG_REFRESH);
mLogViewHandler.sendMessage(refreshMsg);
}
}
});
}
/**
* 初始化视图组件（加载布局、绑定控件、设置监听）
* @param context 上下文对象
*/
private void initView(Context context) {
mContext = context;
mLogViewHandler = new LogViewHandler(); // 初始化主线程 Handler
// 加载日志视图布局（R.layout.view_log 为自定义布局文件）
View rootView = LayoutInflater.from(context).inflate(R.layout.view_log, this, true);
// 绑定布局控件（通过 ID 找到对应组件）
bindViews(rootView);
// 设置 TAG 搜索输入框监听（实时搜索并定位 TAG）
setupTagSearchListener();
// 设置功能按钮监听（清理日志、复制日志）
setupFunctionButtonListeners(rootView);
// 设置文本选择开关监听（控制日志文本是否可选中）
setupTextSelectableListener();
// 初始化日志级别下拉框（绑定级别数据，设置默认值）
initLogLevelSpinner();
// 初始化 TAG 列表（加载所有 TAG，设置全选状态）
initTagListView();
// 设置默认交互模式（默认禁止子视图获取焦点，避免误触）
setDescendantFocusability(ViewGroup.FOCUS_BLOCK_DESCENDANTS);
}
/**
* 绑定布局控件（通过 ID 查找并初始化所有子组件）
* @param rootView 根布局视图
*/
private void bindViews(View rootView) {
mLogScrollView = rootView.findViewById(R.id.viewlogScrollViewLog);
mLogTextView = rootView.findViewById(R.id.viewlogTextViewLog);
mTagSearchEt = rootView.findViewById(R.id.tagsearch_et);
mLogLevelSpinner = rootView.findViewById(R.id.viewlogSpinner1);
mTextSelectableCb = rootView.findViewById(R.id.viewlogCheckBoxSelectable);
mSelectAllTagCb = rootView.findViewById(R.id.viewlogCheckBox1);
mTagHorizontalListView = rootView.findViewById(R.id.tags_listview);
}
/**
* 设置 TAG 搜索输入框监听（文本变化时触发 TAG 定位）
*/
private void setupTagSearchListener() {
mTagSearchEt.addTextChangedListener(new TextWatcher() {
@Override
public void beforeTextChanged(CharSequence s, int start, int count, int after) {}
@Override
public void onTextChanged(CharSequence s, int start, int before, int count) {
String searchText = s.toString().trim();
LogUtils.d(TAG, "TAG 搜索内容：" + searchText);
if (!searchText.isEmpty()) {
// 搜索文本非空，定位匹配的 TAG
scrollToTargetTag(searchText);
} else {
// 搜索文本为空，重置滚动位置
HorizontalScrollView parentHs = findViewById(R.id.viewlogHorizontalScrollView1);
parentHs.smoothScrollTo(0, 0);
mTagHorizontalListView.resetScrollToStart();
}
}
@Override
public void afterTextChanged(Editable s) {}
});
}
/**
* 设置功能按钮监听（清理日志、复制日志）
*/
private void setupFunctionButtonListeners(View rootView) {
// 清理日志按钮（点击清空所有历史日志）
rootView.findViewById(R.id.viewlogButtonClean).setOnClickListener(new View.OnClickListener() {
@Override
public void onClick(View v) {
LogUtils.cleanLog();
LogUtils.d(TAG, "日志已清理");
}
});
// 复制日志按钮（点击复制所有日志到剪贴板）
rootView.findViewById(R.id.viewlogButtonCopy).setOnClickListener(new View.OnClickListener() {
@Override
public void onClick(View v) {
ClipboardManager clipboard = (ClipboardManager) mContext.getSystemService(Context.CLIPBOARD_SERVICE);
// 将日志内容复制到剪贴板（标签为应用包名）
clipboard.setPrimaryClip(ClipData.newPlainText(mContext.getPackageName(), LogUtils.loadLog()));
LogUtils.d(TAG, "日志已复制到剪贴板");
}
});
}
/**
* 设置文本选择开关监听（控制日志文本是否可选中复制）
*/
private void setupTextSelectableListener() {
mTextSelectableCb.setOnClickListener(new View.OnClickListener() {
@Override
public void onClick(View v) {
if (mTextSelectableCb.isChecked()) {
// 允许文本选择：子视图优先获取焦点
setDescendantFocusability(ViewGroup.FOCUS_BEFORE_DESCENDANTS);
} else {
// 禁止文本选择：阻止子视图获取焦点
setDescendantFocusability(ViewGroup.FOCUS_BLOCK_DESCENDANTS);
}
}
});
}
/**
* 初始化日志级别下拉框（Spinner）
* 1. 绑定 LogUtils.LOG_LEVEL 枚举数据；
* 2. 设置默认选中当前全局日志级别；
* 3. 监听级别变化，更新 LogUtils 全局配置。
*/
private void initLogLevelSpinner() {
// 从资源文件加载日志级别数组（R.array.enum_loglevel_array 与 LOG_LEVEL 枚举对应）
mLogLevelAdapter = ArrayAdapter.createFromResource(
mContext, R.array.enum_loglevel_array, android.R.layout.simple_spinner_item);
// 设置下拉列表样式
mLogLevelAdapter.setDropDownViewResource(android.R.layout.simple_spinner_dropdown_item);
mLogLevelSpinner.setAdapter(mLogLevelAdapter);
// 监听下拉框选择变化
mLogLevelSpinner.setOnItemSelectedListener(new AdapterView.OnItemSelectedListener() {
@Override
public void onItemSelected(AdapterView<?> parent, View view, int position, long id) {
// 根据选择的位置设置全局日志级别（position 与 LOG_LEVEL 枚举索引对应）
LogUtils.setLogLevel(LogUtils.LOG_LEVEL.values()[position]);
}
@Override
public void onNothingSelected(AdapterView<?> parent) {}
});
// 设置默认选中当前日志级别
int defaultLevelIndex = LogUtils.getLogLevel().ordinal();
if (defaultLevelIndex >= 0) {
mLogLevelSpinner.setSelection(defaultLevelIndex);
}
}
/**
* 初始化 TAG 水平列表
* 1. 加载 LogUtils 中的所有 TAG 及其启用状态；
* 2. 初始化 TAG 列表适配器；
* 3. 设置全选 TAG 开关监听。
*/
private void initTagListView() {
// 获取 LogUtils 中的 TAG 启用状态映射表
Map<String, Boolean> tagEnableMap = LogUtils.getTagEnableMap();
// 判断是否所有 TAG 都已启用（初始化全选开关状态）
boolean isAllTagEnabled = isAllTagsEnabled(tagEnableMap);
mSelectAllTagCb.setChecked(isAllTagEnabled);
// 初始化 TAG 水平列表（设置垂直偏移，绑定适配器）
mTagHorizontalListView.setVerticalOffset(10);
mTagListAdapter = new TAGListAdapter(mContext, tagEnableMap);
mTagHorizontalListView.setAdapter(mTagListAdapter);
mTagListAdapter.notifyDataSetChanged(); // 刷新列表数据
// 全选 TAG 开关监听（点击时启用/禁用所有 TAG）
mSelectAllTagCb.setOnClickListener(new View.OnClickListener() {
@Override
public void onClick(View v) {
boolean isSelectAll = mSelectAllTagCb.isChecked();
LogUtils.setAllTagsEnable(isSelectAll); // 批量更新所有 TAG 状态
mTagListAdapter.reload(); // 重新加载 TAG 数据并刷新视图
}
});
}
/**
* 判断是否所有 TAG 都已启用
* @param tagEnableMap TAG 启用状态映射表
* @return true：所有 TAG 均启用；false：存在未启用的 TAG
*/
private boolean isAllTagsEnabled(Map<String, Boolean> tagEnableMap) {
for (Map.Entry<String, Boolean> entry : tagEnableMap.entrySet()) {
if (!entry.getValue()) {
return false;
}
}
return true;
}
/**
* 更新日志视图（由 LogViewThread 触发，通知有新日志）
* 避免并发刷新：正在处理时标记新日志，处理完成后再次刷新
*/
public void updateLogView() {
if (mLogViewHandler.isHandling()) {
// 正在处理日志刷新，标记有新日志待处理
mLogViewHandler.setIsAddNewLog(true);
} else {
// 发送刷新消息到主线程
Message refreshMsg = mLogViewHandler.obtainMessage(LogViewHandler.MSG_LOG_REFRESH);
mLogViewHandler.sendMessage(refreshMsg);
mLogViewHandler.setIsAddNewLog(false);
}
}
/**
* 显示日志并滚动到底部
* 1. 从 LogUtils 加载所有历史日志；
* 2. 设置到文本控件并滚动到底部。
*/
private void showAndScrollLogView() {
mLogTextView.setText(LogUtils.loadLog()); // 加载并显示日志
scrollLogToBottom(); // 滚动到底部，显示最新日志
}
/**
* 滚动到目标 TAG（根据搜索文本定位匹配的 TAG 并滚动显示）
* @param prefix 搜索文本（TAG 前缀）
*/
private void scrollToTargetTag(final String prefix) {
if (mTagListAdapter == null || prefix == null || prefix.isEmpty()) {
LogUtils.d(TAG, "TAG 搜索参数为空，无法定位");
return;
}
final List<TAGItemModel> tagItemList = mTagListAdapter.getItemList();
mTagHorizontalListView.post(new Runnable() {
@Override
public void run() {
int targetPosition = -1;
// 遍历 TAG 列表，查找前缀匹配的 TAG（忽略大小写）
for (int i = 0; i < tagItemList.size(); i++) {
String tag = tagItemList.get(i).getTag();
if (tag != null && tag.toLowerCase().startsWith(prefix.toLowerCase())) {
targetPosition = i;
break;
}
}
if (targetPosition != -1) {
final int targetPositionFinal = targetPosition;
// 延迟滚动（确保布局完成，避免滚动失效）
mTagHorizontalListView.postDelayed(new Runnable() {
@Override
public void run() {
LogUtils.d(TAG, "定位到 TAG 位置：" + targetPositionFinal);
mTagHorizontalListView.scrollToItem(targetPositionFinal);
}
}, 100);
} else {
LogUtils.d(TAG, "未找到匹配前缀的 TAG：" + prefix);
}
}
});
}
// ====================== 内部类：日志视图 Handler（主线程更新 UI） ======================
/**
* 日志视图 Handler（运行在主线程，处理日志刷新消息）
* 避免跨线程操作 UI，通过标志位控制并发刷新
*/
private class LogViewHandler extends Handler {
/** 日志刷新消息标识 */
private static final int MSG_LOG_REFRESH = 0;
/** 日志处理中标志（与外部 mIsHandling 同步） */
private volatile boolean isHandling;
/** 新日志添加标志（与外部 mIsAddNewLog 同步） */
private volatile boolean isAddNewLog;
public LogViewHandler() {
setIsHandling(false);
setIsAddNewLog(false);
}
public void setIsHandling(boolean isHandling) {
this.isHandling = isHandling;
}
public boolean isHandling() {
return isHandling;
}
public void setIsAddNewLog(boolean isAddNewLog) {
this.isAddNewLog = isAddNewLog;
}
public boolean isAddNewLog() {
return isAddNewLog;
}
@Override
public void handleMessage(Message msg) {
super.handleMessage(msg);
switch (msg.what) {
case MSG_LOG_REFRESH:
// 未处理日志刷新时，标记为处理中并触发显示
if (!isHandling()) {
setIsHandling(true);
showAndScrollLogView();
}
break;
default:
break;
}
}
}
// ====================== 内部类：TAG 数据模型（封装 TAG 名称与状态） ======================
/**
* TAG 列表项数据模型
* 封装单个 TAG 的名称及其启用状态（用于 Adapter 数据绑定）
*/
private class TAGItemModel {
/** TAG 名称（如 "LogViewThread"、"LogUtils"） */
private String tag;
/** TAG 启用状态（true：启用；false：禁用） */
private boolean isChecked;
public TAGItemModel(String tag, boolean isChecked) {
this.tag = tag;
this.isChecked = isChecked;
}
public String getTag() {
return tag;
}
public void setTag(String tag) {
this.tag = tag;
}
public boolean isChecked() {
return isChecked;
}
public void setChecked(boolean checked) {
isChecked = checked;
}
/**
* 重写 equals 方法（按 TAG 名称判断相等）
* @param o 比较对象
* @return true：TAG 名称相同；false：不同
*/
@Override
public boolean equals(Object o) {
if (this == o) return true;
if (o == null || getClass() != o.getClass()) return false;
TAGItemModel that = (TAGItemModel) o;
// 手动处理空值比较（兼容 Java 7，不依赖 Objects.equals）
if (tag == null) {
return that.tag == null;
} else {
return tag.equals(that.tag);
}
}
/**
* 重写 hashCode 方法（基于 TAG 名称生成哈希值）
* @return 哈希值（空 TAG 返回 0）
*/
@Override
public int hashCode() {
return tag == null ? 0 : tag.hashCode();
}
}
// ====================== 内部类：TAG 列表适配器（绑定数据与视图） ======================
/**
* TAG 水平列表适配器（继承 BaseAdapter）
* 负责 TAG 数据与列表项视图的绑定，处理勾选状态变化
*/
private class TAGListAdapter extends BaseAdapter {
/** 上下文对象（用于加载列表项布局） */
private Context context;
/** 原始 TAG 启用状态映射表（来自 LogUtils） */
private Map<String, Boolean> originTagMap;
/** TAG 列表项数据（转换为 TAGItemModel 列表，便于排序和绑定） */
private List<TAGItemModel> tagItemList;
/**
* 构造方法（初始化数据并加载到列表）
* @param context 上下文
* @param tagMap TAG 启用状态映射表
*/
public TAGListAdapter(Context context, Map<String, Boolean> tagMap) {
this.context = context;
this.originTagMap = tagMap;
loadTagData(originTagMap); // 加载并转换数据
}
/**
* 获取 TAG 列表项数据（供外部定位 TAG 使用）
* @return TAGItemModel 列表
*/
public List<TAGItemModel> getItemList() {
return tagItemList;
}
// ====================== BaseAdapter 抽象方法实现 ======================
@Override
public int getCount() {
return tagItemList == null ? 0 : tagItemList.size();
}
@Override
public Object getItem(int position) {
return tagItemList.get(position);
}
@Override
public long getItemId(int position) {
return position;
}
/**
* 加载 TAG 数据（将 Map 转换为 List 并排序）
* @param tagMap TAG 启用状态映射表
*/
private void loadTagData(Map<String, Boolean> tagMap) {
tagItemList = new ArrayList<>();
// 遍历 Map，转换为 TAGItemModel 并添加到列表
for (Map.Entry<String, Boolean> entry : tagMap.entrySet()) {
tagItemList.add(new TAGItemModel(entry.getKey(), entry.getValue()));
}
// 按 TAG 名称升序排序（中文排序兼容）
Collections.sort(tagItemList, new TagAscComparator(true));
}
/**
* 重新加载 TAG 数据（用于全选/反选后刷新列表）
*/
public void reload() {
loadTagData(originTagMap); // 重新加载数据
notifyDataSetChanged(); // 通知视图刷新
}
/**
* 创建/复用列表项视图（优化性能，避免重复 inflate）
* @param position 列表项位置
* @param convertView 复用视图（可为 null）
* @param parent 父容器
* @return 列表项视图
*/
@Override
public View getView(int position, View convertView, ViewGroup parent) {
ViewHolder holder;
// 复用视图（减少布局加载开销）
if (convertView == null) {
// 加载列表项布局（R.layout.item_logtag 为 TAG 项自定义布局）
convertView = LayoutInflater.from(context).inflate(R.layout.item_logtag, parent, false);
holder = new ViewHolder();
// 绑定列表项控件（TAG 文本和勾选框）
holder.tagTv = convertView.findViewById(R.id.viewlogtagTextView1);
holder.tagCb = convertView.findViewById(R.id.viewlogtagCheckBox1);
convertView.setTag(holder); // 保存 ViewHolder 到视图
} else {
holder = (ViewHolder) convertView.getTag(); // 复用 ViewHolder
}
// 绑定数据到视图
final TAGItemModel item = tagItemList.get(position);
holder.tagTv.setText(item.getTag()); // 设置 TAG 名称
holder.tagCb.setChecked(item.isChecked()); // 设置勾选状态
// 勾选框点击监听（更新 TAG 启用状态）
holder.tagCb.setOnClickListener(new View.OnClickListener() {
@Override
public void onClick(View v) {
boolean isChecked = ((CheckBox) v).isChecked();
// 调用 LogUtils 更新该 TAG 的启用状态
LogUtils.setTagEnable(item.getTag(), isChecked);
// 同步更新本地模型状态（避免刷新后状态不一致）
item.setChecked(isChecked);
}
});
return convertView;
}
/**
* 列表项 ViewHolder（缓存控件，提升列表滑动性能）
*/
private class ViewHolder {
TextView tagTv; // TAG 名称文本控件
CheckBox tagCb; // TAG 启用状态勾选框
}
}
// ====================== 内部类：TAG 排序比较器（中文兼容） ======================
/**
* TAG 名称排序比较器（实现 Comparator）
* 支持中文排序（基于系统默认中文 Locale），可选择升序/降序
*/
private class TagAscComparator implements Comparator<TAGItemModel> {
/** 排序方向（true：升序；false：降序） */
private boolean isAsc;
/** 中文排序器（兼容中文汉字排序） */
private Collator chineseCollator = Collator.getInstance(java.util.Locale.CHINA);
public TagAscComparator(boolean isAsc) {
this.isAsc = isAsc;
}
/**
* 比较两个 TAGItemModel（按 TAG 名称排序）
* @param o1 第一个比较对象
* @param o2 第二个比较对象
* @return 比较结果（正数：o1 在 o2 后；负数：o1 在 o2 前；0：相等）
*/
@Override
public int compare(TAGItemModel o1, TAGItemModel o2) {
String tag1 = o1.getTag();
String tag2 = o2.getTag();
// 处理空值（空 TAG 排在最前）
if (tag1 == null) return -1;
if (tag2 == null) return 1;
// 根据排序方向返回比较结果
if (isAsc) {
return chineseCollator.compare(tag1, tag2); // 升序
} else {
return chineseCollator.compare(tag2, tag1); // 降序
}
}
}
}

140
libappbase/src/main/java/cc/winboll/studio/libappbase/LogViewThread.java Normal file
View File

@@ -0,0 +1,140 @@
package cc.winboll.studio.libappbase;
import android.os.FileObserver;
import java.lang.ref.WeakReference;
/**
* @Author ZhanGSKen<zhangsken@qq.com>
* @Date 2024/08/12 14:43:50
* @Describe 日志视图线程类
* 独立线程监听日志文件目录变化（如写入、删除），触发日志视图更新，避免阻塞主线程
*/
public class LogViewThread extends Thread {
/** 日志标签（用于调试输出） */
public static final String TAG = "LogViewThread";
/** 线程退出标志（volatile 保证多线程可见性，控制循环退出） */
private volatile boolean isExit = false;
/** 日志文件目录监听实例（监听文件写入、删除事件） */
private LogListener mLogListener;
/** 日志视图弱引用（避免持有 LogView 强引用导致内存泄漏） */
private final WeakReference<LogView> mLogViewWeakRef;
/**
* 构造函数
* @param logView 日志显示视图实例（需通过弱引用持有，避免内存泄漏）
*/
public LogViewThread(LogView logView) {
// 使用弱引用包装 LogView，当视图销毁时可被 GC 回收
mLogViewWeakRef = new WeakReference<>(logView);
}
/**
* 设置线程退出标志（触发线程停止监听并退出）
* @param exit true：退出线程；false：继续运行（默认）
*/
public void setExit(boolean exit) {
this.isExit = exit;
}
/**
* 获取当前线程退出状态
* @return true：已标记退出；false：运行中
*/
public boolean isExit() {
return isExit;
}
/**
* 线程核心逻辑：初始化文件监听并启动循环，直到收到退出标志
*/
@Override
public void run() {
// 获取日志缓存目录路径（从 LogUtils 统一获取，确保路径一致性）
String logDirPath = LogUtils.getLogCacheDir().getPath();
LogUtils.d(TAG, "启动日志文件监听，监听目录：" + logDirPath);
// 初始化日志文件监听器（监听目标目录的文件事件）
mLogListener = new LogListener(logDirPath);
// 开始监听文件事件（非阻塞，内部通过 Native 层实现）
mLogListener.startWatching();
// 循环等待退出标志（每 1 秒检查一次，降低 CPU 占用）
while (!isExit()) {
try {
Thread.sleep(1000); // 休眠 1 秒，避免忙等
} catch (InterruptedException e) {
// 线程被中断时，恢复中断标志并退出循环（避免无限阻塞）
Thread.currentThread().interrupt();
LogUtils.d(TAG, "日志监听线程被中断，准备退出。" + e);
break;
}
}
// 收到退出标志，停止监听并释放资源
mLogListener.stopWatching();
LogUtils.d(TAG, "日志文件监听已停止，线程退出");
}
/**
* 日志文件监听内部类（继承 FileObserver，监听目录下文件变化）
* 仅关注文件写入完成（CLOSE_WRITE）和文件删除（DELETE）事件
*/
private class LogListener extends FileObserver {
/**
* 构造函数
* @param path 监听的目录路径（此处为日志缓存目录）
*/
public LogListener(String path) {
// 父类构造：监听指定目录的所有事件（通过位掩码 ALL_EVENTS 指定）
super(path);
}
/**
* 文件事件回调（运行在系统私有线程，非主线程）
* @param event 事件类型（通过位掩码表示，需与 ALL_EVENTS 按位与解析）
* @param path 发生事件的文件名（相对监听目录的路径）
*/
@Override
public void onEvent(int event, String path) {
// 解析事件类型（排除无关事件，只处理目标事件）
int eventType = event & FileObserver.ALL_EVENTS;
switch (eventType) {
// 事件：文件写入完成（如日志写入结束并关闭文件）
case FileObserver.CLOSE_WRITE:
// 触发日志视图更新（需先判断 LogView 是否未被回收）
updateLogView();
break;
// 事件：文件被删除（如日志清理操作）
case FileObserver.DELETE:
LogUtils.d(TAG, "日志文件被删除，文件名：" + (path != null ? path : "未知"));
// 触发日志视图更新（刷新视图显示空状态）
updateLogView();
break;
default:
// 忽略其他无关事件（如文件创建、访问等）
break;
}
}
/**
* 触发日志视图更新（通过弱引用获取 LogView，避免内存泄漏）
*/
private void updateLogView() {
// 从弱引用中获取 LogView 实例（若视图已销毁，get() 返回 null）
LogView logView = mLogViewWeakRef.get();
if (logView != null) {
// 调用 LogView 的更新方法（需确保 updateLogView 内部处理主线程切换）
logView.updateLogView();
} else {
LogUtils.w(TAG, "LogView 已被回收，无法更新日志视图");
}
}
}
}

257
libappbase/src/main/java/cc/winboll/studio/libappbase/ToastUtils.java Normal file
View File

@@ -0,0 +1,257 @@
package cc.winboll.studio.libappbase;
import android.content.Context;
import android.os.Handler;
import android.os.Looper;
import android.os.Message;
import android.widget.Toast;
/**
* @Author ZhanGSKen&豆包大模型<zhangsken@qq.com>
* @Date 2025/11/11 20:51
* @Describe 吐司工具类（单例模式）
* 简化 Android 吐司的创建与展示，通过独立线程 + Handler 处理消息，最终切换到主线程显示吐司，避免内存泄漏
*/
public class ToastUtils {
/** 工具类日志 TAG（用于调试输出） */
public static final String TAG = "ToastUtils";
/** 消息标识：显示短时长吐司 */
private static final int MSG_SHOW_SHORT_TOAST = 1001;
/** 单例实例（volatile 保证多线程下可见性，避免指令重排） */
private static volatile ToastUtils sInstance;
/** 全局上下文（volatile 保证多线程可见性，避免空指针） */
private volatile Context mContext;
/** 独立线程的 Handler（volatile 保证可见性） */
private volatile Handler mWorkerHandler;
/** 主线程 Handler（volatile 保证可见性） */
private volatile Handler mMainHandler;
/** 消息处理独立线程 */
private Thread mWorkerThread;
/** 资源释放标记（volatile 避免多线程误操作） */
private volatile boolean isReleased = false;
/**
* 私有构造方法（禁止外部直接创建实例，确保单例）
* 1. 初始化主线程 Handler；
* 2. 创建并启动独立消息处理线程。
*/
private ToastUtils() {
initMainHandler(); // 优先初始化主线程 Handler
startWorkerThread(); // 启动独立消息处理线程
}
/**
* 初始化主线程 Handler
*/
private void initMainHandler() {
if (Looper.getMainLooper() == null) {
LogUtils.e(TAG, "主线程 Looper 为空，无法初始化 mMainHandler");
throw new IllegalStateException("主线程 Looper 未初始化，无法创建 ToastUtils");
}
mMainHandler = new Handler(Looper.getMainLooper());
LogUtils.d(TAG, "主线程 Handler 初始化完成，线程ID：" + Looper.getMainLooper().getThread().getId());
}
/**
* 启动独立消息处理线程
*/
private void startWorkerThread() {
mWorkerThread = new Thread(new Runnable() {
@Override
public void run() {
LogUtils.d(TAG, "消息处理线程启动，线程ID：" + Thread.currentThread().getId());
Looper.prepare();
mWorkerHandler = new Handler(Looper.myLooper()) {
@Override
public void handleMessage(Message msg) {
super.handleMessage(msg);
// 若已释放，直接返回，不处理消息
if (isReleased) {
LogUtils.w(TAG, "资源已释放，忽略消息处理");
return;
}
LogUtils.d(TAG, "WorkerHandler 接收消息，当前线程ID：" + Thread.currentThread().getId());
if (msg.what == MSG_SHOW_SHORT_TOAST && msg.obj != null) {
String message = (String) msg.obj;
postToMainThreadShowToast(message);
}
}
};
Looper.loop();
LogUtils.d(TAG, "消息处理线程退出");
}
}, "ToastWorkerThread");
mWorkerThread.start();
}
/**
* 获取单例实例（双重检查锁定）
* @return ToastUtils 单例对象
*/
private static ToastUtils getInstance() {
if (sInstance == null) {
synchronized (ToastUtils.class) {
if (sInstance == null) {
sInstance = new ToastUtils();
}
}
}
return sInstance;
}
/**
* 初始化工具类（必须在 Application 启动时调用）
* @param context 全局上下文（推荐 Application 上下文）
*/
public static void init(Context context) {
if (context == null) {
throw new IllegalArgumentException("初始化上下文不能为 null！");
}
ToastUtils instance = getInstance();
// 若已释放，重置释放标记
if (instance.isReleased) {
instance.isReleased = false;
instance.startWorkerThread(); // 重新启动线程
}
instance.mContext = context.getApplicationContext();
LogUtils.d(TAG, "ToastUtils 初始化完成，上下文已设置");
}
/**
* 外部接口：显示短时长吐司
* @param message 吐司内容
*/
public static void show(String message) {
LogUtils.d(TAG, "外部调用 show()，当前线程ID：" + Thread.currentThread().getId());
if (message == null || message.isEmpty()) {
return;
}
ToastUtils instance = getInstance();
// 校验资源是否已释放
if (instance.isReleased) {
LogUtils.w(TAG, "ToastUtils 已释放，无法显示吐司：" + message);
return;
}
// 校验上下文是否初始化
if (instance.mContext == null) {
LogUtils.e(TAG, "ToastUtils 未初始化！请先调用 init(Context) 方法");
// 不抛出异常，避免崩溃，改为日志提示
return;
}
instance.sendToastMessage(message);
}
/**
* 发送吐司消息到 WorkerHandler
* @param message 吐司内容
*/
private void sendToastMessage(String message) {
LogUtils.d(TAG, "发送消息到 WorkerHandler");
// 校验 WorkerHandler 是否就绪
if (mWorkerHandler == null) {
LogUtils.w(TAG, "WorkerHandler 未就绪，直接主线程显示");
postToMainThreadShowToast(message);
return;
}
// 发送消息
Message msg = mWorkerHandler.obtainMessage(MSG_SHOW_SHORT_TOAST);
msg.obj = message;
mWorkerHandler.sendMessage(msg);
}
/**
* 切换到主线程显示吐司
* @param message 吐司内容
*/
private void postToMainThreadShowToast(final String message) {
LogUtils.d(TAG, "切换到主线程显示吐司，当前线程ID：" + Thread.currentThread().getId());
// 校验资源是否已释放
if (isReleased) {
LogUtils.w(TAG, "资源已释放，取消显示吐司");
return;
}
// 校验并初始化 mMainHandler
if (mMainHandler == null) {
LogUtils.e(TAG, "mMainHandler 为空，尝试重新初始化");
initMainHandler();
if (mMainHandler == null) {
LogUtils.e(TAG, "mMainHandler 初始化失败，无法显示吐司：" + message);
return;
}
}
// 主线程显示
mMainHandler.post(new Runnable() {
@Override
public void run() {
if (isReleased) return; // 释放后取消执行
showToastInternal(message);
}
});
}
/**
* 实际显示吐司（主线程）
* @param message 吐司内容
*/
private void showToastInternal(String message) {
LogUtils.d(TAG, "执行 showToastInternal()");
// 最终校验上下文
if (mContext == null) {
LogUtils.w(TAG, "上下文为空，无法显示吐司：" + message);
// 尝试重新获取 Application 上下文（降级策略）
Context appContext = GlobalApplication.getInstance();
if (appContext != null) {
mContext = appContext;
Toast.makeText(mContext, message, Toast.LENGTH_SHORT).show();
LogUtils.d(TAG, "通过 GlobalApplication 获取上下文，成功显示吐司");
}
return;
}
Toast.makeText(mContext, message, Toast.LENGTH_SHORT).show();
}
/**
* 释放资源（仅在应用退出时调用）
*/
public static void release() {
LogUtils.d(TAG, "开始释放 ToastUtils 资源");
ToastUtils instance = getInstance();
// 标记为已释放，阻止后续消息处理
instance.isReleased = true;
// 停止 Worker 线程
if (instance.mWorkerHandler != null && instance.mWorkerHandler.getLooper() != null) {
instance.mWorkerHandler.getLooper().quit();
instance.mWorkerHandler = null;
}
// 清理主线程 Handler
if (instance.mMainHandler != null) {
instance.mMainHandler.removeCallbacksAndMessages(null);
instance.mMainHandler = null;
}
// 等待线程退出
if (instance.mWorkerThread != null && instance.mWorkerThread.isAlive()) {
try {
instance.mWorkerThread.join(1000);
} catch (InterruptedException e) {
LogUtils.d(TAG, e, Thread.currentThread().getStackTrace());
//LogUtils.e(TAG, "线程退出异常", e);
Thread.currentThread().interrupt();
}
instance.mWorkerThread = null;
}
// 清空上下文（避免内存泄漏）
instance.mContext = null;
LogUtils.d(TAG, "ToastUtils 资源释放完成");
}
}

86
libappbase/src/main/java/cc/winboll/studio/libappbase/UTF8FileUtils.java Normal file
View File

@@ -0,0 +1,86 @@
package cc.winboll.studio.libappbase;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.nio.charset.StandardCharsets;
/**
* @Author ZhanGSKen&豆包大模型<zhangsken@qq.com>
* @Date 2025/11/11 20:45
* @Describe UTF-8 编码文件操作工具类
* 提供字符串与文件的相互转换，强制使用 UTF-8 编码，确保跨平台字符兼容性
*/
public class UTF8FileUtils {
/** 工具类日志 TAG（用于调试输出） */
public static final String TAG = "UTF8FileUtils";
/**
* 将字符串写入文件（强制 UTF-8 编码）
* 若文件父目录不存在，自动创建；覆盖原有文件内容
* @param filePath 文件路径（包含文件名，如 "/sdcard/test.txt"）
* @param content 要写入的字符串内容
* @throws IOException 写入失败时抛出（如权限不足、路径无效等）
*/
public static void writeStringToFile(String filePath, String content) throws IOException {
// 根据路径创建文件对象
File file = new File(filePath);
// 获取父目录，若不存在则递归创建
File parentDir = file.getParentFile();
if (parentDir != null && !parentDir.exists()) {
parentDir.mkdirs();
}
// 初始化文件输出流（覆盖模式）
FileOutputStream outputStream = new FileOutputStream(file);
// 包装为 UTF-8 编码的字符输出流
OutputStreamWriter writer = new OutputStreamWriter(outputStream, StandardCharsets.UTF_8);
try {
// 写入字符串内容
writer.write(content);
} finally {
// 强制关闭流，避免资源泄漏（即使写入失败也确保流关闭）
writer.close();
}
}
/**
* 从文件读取字符串（强制 UTF-8 编码）
* 逐字符读取文件内容，拼接为完整字符串返回
* @param filePath 文件路径（包含文件名，如 "/sdcard/test.txt"）
* @return 文件内容字符串（空文件返回空字符串）
* @throws IOException 读取失败时抛出（如文件不存在、权限不足等）
*/
public static String readStringFromFile(String filePath) throws IOException {
// 根据路径创建文件对象
File file = new File(filePath);
// 初始化文件输入流
FileInputStream inputStream = new FileInputStream(file);
// 包装为 UTF-8 编码的字符输入流
InputStreamReader reader = new InputStreamReader(inputStream, StandardCharsets.UTF_8);
// 字符串构建器，用于拼接读取的字符
StringBuilder content = new StringBuilder();
int charCode; // 存储单个字符的 ASCII 码
try {
// 逐字符读取（-1 表示读取到文件末尾）
while ((charCode = reader.read()) != -1) {
// 将 ASCII 码转换为字符，追加到字符串
content.append((char) charCode);
}
} finally {
// 强制关闭流，避免资源泄漏
reader.close();
}
// 返回读取的完整字符串
return content.toString();
}
}

8
libappbase/src/main/res/drawable/bg_border.xml Normal file
View File

@@ -0,0 +1,8 @@
<?xml version="1.0" encoding="utf-8"?>
<shape xmlns:android="http://schemas.android.com/apk/res/android"
android:shape="rectangle">
<stroke
android:width="1dp"
android:color="#000000" /> <!-- 这里可调整边框宽度和颜色 -->
<solid android:color="@android:color/transparent" />
</shape>

13
libappbase/src/main/res/drawable/bg_border_round.xml Normal file
View File

@@ -0,0 +1,13 @@
<?xml version="1.0" encoding="utf-8"?>
<shape xmlns:android="http://schemas.android.com/apk/res/android"
android:shape="rectangle">
<stroke
android:width="1dp"
android:color="#000000" /> <!-- 这里可调整边框宽度和颜色 -->
<solid android:color="@android:color/transparent" />
<corners
android:bottomLeftRadius="6dip"
android:bottomRightRadius="6dip"
android:topLeftRadius="6dip"
android:topRightRadius="6dip" />
</shape>

41
libappbase/src/main/res/drawable/bg_toolbar_log.xml Normal file
View File

@@ -0,0 +1,41 @@
<?xml version="1.0" encoding="utf-8"?>
<layer-list xmlns:android="http://schemas.android.com/apk/res/android" >
<!-- 阴影部分 -->
<!-- 个人觉得更形象的表达：top代表下边的阴影高度，left代表右边的阴影宽度。其实也就是相对应的offset，solid中的颜色是阴影的颜色，也可以设置角度等等 -->
<item
android:left="2dp"
android:top="2dp"
android:right="2dp"
android:bottom="2dp">
<shape android:shape="rectangle" >
<gradient
android:angle="270"
android:endColor="@color/colorPrimary"
android:startColor="@color/colorPrimary" />
<corners
android:bottomLeftRadius="6dip"
android:bottomRightRadius="6dip"
android:topLeftRadius="6dip"
android:topRightRadius="6dip" />
</shape>
</item>
<!-- 背景部分 -->
<!-- 形象的表达：bottom代表背景部分在上边缘超出阴影的高度，right代表背景部分在左边超出阴影的宽度（相对应的offset） -->
<item
android:left="3dp"
android:top="3dp"
android:right="3dp"
android:bottom="5dp">
<shape android:shape="rectangle" >
<gradient
android:angle="270"
android:endColor="@color/colorPrimary"
android:startColor="@color/colorPrimary" />
<corners
android:bottomLeftRadius="6dip"
android:bottomRightRadius="6dip"
android:topLeftRadius="6dip"
android:topRightRadius="6dip" />
</shape>
</item>
</layer-list>

170
libappbase/src/main/res/drawable/ic_launcher_background.xml Normal file
View File

@@ -0,0 +1,170 @@
<?xml version="1.0" encoding="utf-8"?>
<vector xmlns:android="http://schemas.android.com/apk/res/android"
android:width="108dp"
android:height="108dp"
android:viewportWidth="108"
android:viewportHeight="108">
<path
android:fillColor="@color/colorPrimary"
android:pathData="M0,0h108v108h-108z" />
<path
android:fillColor="#00000000"
android:pathData="M9,0L9,108"
android:strokeWidth="0.8"
android:strokeColor="#33FFFFFF" />
<path
android:fillColor="#00000000"
android:pathData="M19,0L19,108"
android:strokeWidth="0.8"
android:strokeColor="#33FFFFFF" />
<path
android:fillColor="#00000000"
android:pathData="M29,0L29,108"
android:strokeWidth="0.8"
android:strokeColor="#33FFFFFF" />
<path
android:fillColor="#00000000"
android:pathData="M39,0L39,108"
android:strokeWidth="0.8"
android:strokeColor="#33FFFFFF" />
<path
android:fillColor="#00000000"
android:pathData="M49,0L49,108"
android:strokeWidth="0.8"
android:strokeColor="#33FFFFFF" />
<path
android:fillColor="#00000000"
android:pathData="M59,0L59,108"
android:strokeWidth="0.8"
android:strokeColor="#33FFFFFF" />
<path
android:fillColor="#00000000"
android:pathData="M69,0L69,108"
android:strokeWidth="0.8"
android:strokeColor="#33FFFFFF" />
<path
android:fillColor="#00000000"
android:pathData="M79,0L79,108"
android:strokeWidth="0.8"
android:strokeColor="#33FFFFFF" />
<path
android:fillColor="#00000000"
android:pathData="M89,0L89,108"
android:strokeWidth="0.8"
android:strokeColor="#33FFFFFF" />
<path
android:fillColor="#00000000"
android:pathData="M99,0L99,108"
android:strokeWidth="0.8"
android:strokeColor="#33FFFFFF" />
<path
android:fillColor="#00000000"
android:pathData="M0,9L108,9"
android:strokeWidth="0.8"
android:strokeColor="#33FFFFFF" />
<path
android:fillColor="#00000000"
android:pathData="M0,19L108,19"
android:strokeWidth="0.8"
android:strokeColor="#33FFFFFF" />
<path
android:fillColor="#00000000"
android:pathData="M0,29L108,29"
android:strokeWidth="0.8"
android:strokeColor="#33FFFFFF" />
<path
android:fillColor="#00000000"
android:pathData="M0,39L108,39"
android:strokeWidth="0.8"
android:strokeColor="#33FFFFFF" />
<path
android:fillColor="#00000000"
android:pathData="M0,49L108,49"
android:strokeWidth="0.8"
android:strokeColor="#33FFFFFF" />
<path
android:fillColor="#00000000"
android:pathData="M0,59L108,59"
android:strokeWidth="0.8"
android:strokeColor="#33FFFFFF" />
<path
android:fillColor="#00000000"
android:pathData="M0,69L108,69"
android:strokeWidth="0.8"
android:strokeColor="#33FFFFFF" />
<path
android:fillColor="#00000000"
android:pathData="M0,79L108,79"
android:strokeWidth="0.8"
android:strokeColor="#33FFFFFF" />
<path
android:fillColor="#00000000"
android:pathData="M0,89L108,89"
android:strokeWidth="0.8"
android:strokeColor="#33FFFFFF" />
<path
android:fillColor="#00000000"
android:pathData="M0,99L108,99"
android:strokeWidth="0.8"
android:strokeColor="#33FFFFFF" />
<path
android:fillColor="#00000000"
android:pathData="M19,29L89,29"
android:strokeWidth="0.8"
android:strokeColor="#33FFFFFF" />
<path
android:fillColor="#00000000"
android:pathData="M19,39L89,39"
android:strokeWidth="0.8"
android:strokeColor="#33FFFFFF" />
<path
android:fillColor="#00000000"
android:pathData="M19,49L89,49"
android:strokeWidth="0.8"
android:strokeColor="#33FFFFFF" />
<path
android:fillColor="#00000000"
android:pathData="M19,59L89,59"
android:strokeWidth="0.8"
android:strokeColor="#33FFFFFF" />
<path
android:fillColor="#00000000"
android:pathData="M19,69L89,69"
android:strokeWidth="0.8"
android:strokeColor="#33FFFFFF" />
<path
android:fillColor="#00000000"
android:pathData="M19,79L89,79"
android:strokeWidth="0.8"
android:strokeColor="#33FFFFFF" />
<path
android:fillColor="#00000000"
android:pathData="M29,19L29,89"
android:strokeWidth="0.8"
android:strokeColor="#33FFFFFF" />
<path
android:fillColor="#00000000"
android:pathData="M39,19L39,89"
android:strokeWidth="0.8"
android:strokeColor="#33FFFFFF" />
<path
android:fillColor="#00000000"
android:pathData="M49,19L49,89"
android:strokeWidth="0.8"
android:strokeColor="#33FFFFFF" />
<path
android:fillColor="#00000000"
android:pathData="M59,19L59,89"
android:strokeWidth="0.8"
android:strokeColor="#33FFFFFF" />
<path
android:fillColor="#00000000"
android:pathData="M69,19L69,89"
android:strokeWidth="0.8"
android:strokeColor="#33FFFFFF" />
<path
android:fillColor="#00000000"
android:pathData="M79,19L79,89"
android:strokeWidth="0.8"
android:strokeColor="#33FFFFFF" />
</vector>

13
libappbase/src/main/res/drawable/ic_winboll.xml Normal file
View File

@@ -0,0 +1,13 @@
<?xml version="1.0" encoding="utf-8"?>
<layer-list xmlns:android="http://schemas.android.com/apk/res/android"
android:clickable="true">
<item
android:width="256dp"
android:height="256dp"
android:left="0dp"
android:top="0dp"
android:right="0dp"
android:bottom="0dp"
android:drawable="@drawable/ic_winboll_logo">
</item>
</layer-list>

11
libappbase/src/main/res/drawable/ic_winboll_beta.xml Normal file
View File

@@ -0,0 +1,11 @@
<?xml version="1.0" encoding="utf-8"?>
<layer-list xmlns:android="http://schemas.android.com/apk/res/android"
android:clickable="true">
<item android:drawable="@drawable/ic_launcher_background"/>
<item
android:left="0dp"
android:top="0dp"
android:right="0dp"
android:bottom="0dp"
android:drawable="@drawable/ic_winboll_logo"/>
</layer-list>

48
libappbase/src/main/res/drawable/ic_winboll_logo.xml Normal file
View File

@@ -0,0 +1,48 @@
<vector xmlns:android="http://schemas.android.com/apk/res/android"
android:width="512dp"
android:height="512dp"
android:viewportWidth="512"
android:viewportHeight="512">
<path
android:fillColor="#FF1E9B54"
android:strokeColor="#FFF8E733"
android:strokeWidth="20.0"
android:strokeLineCap="round"
android:strokeMiterLimit="10"
android:pathData="M254.63 35.45C374.95 35.45 473.38 133.89 473.38 254.2 473.38 374.51 374.95 472.95 254.63 472.95 134.32 472.95 35.88 374.51 35.88 254.2 35.88 133.89 134.32 35.45 254.63 35.45"/>
<path
android:fillColor="#FFFFFFFF"
android:strokeColor="#FFFFFFFF"
android:strokeWidth="1.0"
android:strokeLineCap="round"
android:strokeMiterLimit="10"
android:pathData="M257.28 361.25C266.56 361.25 274.14 368.84 274.14 378.11 274.14 387.39 266.56 394.98 257.28 394.98 248.01 394.98 240.42 387.39 240.42 378.11 240.42 368.84 248.01 361.25 257.28 361.25"/>
<path
android:fillColor="#00000000"
android:strokeColor="#FF000000"
android:strokeWidth="30.0"
android:strokeLineCap="round"
android:strokeMiterLimit="10"
android:pathData="M182.16 214.09C181.42 199.71 182.42 177.87 207.64 155.49 213.64 150.16 220.13 146.12 226.28 143.08 238.64 136.97 249.62 134.91 252.55 134.56 252.7 134.54 252.83 134.53 252.94 134.52 253.05 134.51 253.14 134.5 253.2 134.5 255.01 134.48 294.9 136.66 313.05 160.43 332.29 185.63 344.82 221.3 300.07 263.56 263.08 298.49 258.36 318 258.54 317.72"/>
<path
android:fillColor="#00000000"
android:strokeColor="#FFFFFFFF"
android:strokeWidth="30.0"
android:strokeLineCap="round"
android:strokeMiterLimit="10"
android:pathData="M103.77 307.45C103.02 293.07 104.03 271.24 129.24 248.85 135.25 243.52 141.74 239.48 147.89 236.44 160.24 230.34 171.23 228.28 174.15 227.92 174.31 227.9 174.44 227.89 174.55 227.88 174.66 227.87 174.75 227.86 174.81 227.86 176.62 227.85 216.5 230.02 234.65 253.79 253.9 278.99 266.43 314.66 221.67 356.93 184.69 391.85 179.97 411.36 180.15 411.08"/>
<path
android:fillColor="#00000000"
android:strokeColor="#FFFFFFFF"
android:strokeWidth="30.0"
android:strokeLineCap="round"
android:strokeMiterLimit="10"
android:pathData="M248.17 309.83C247.43 295.45 248.43 273.62 273.64 251.23 279.65 245.9 286.14 241.86 292.29 238.82 304.65 232.72 315.63 230.65 318.55 230.3 318.71 230.28 318.84 230.27 318.95 230.26 319.06 230.25 319.15 230.24 319.21 230.24 321.02 230.22 360.9 232.4 379.06 256.17 398.3 281.37 410.83 317.04 366.08 359.31 329.09 394.23 324.37 413.74 324.55 413.46"/>
<path
android:fillColor="#00000000"
android:strokeColor="#FFFFFFFF"
android:strokeWidth="30.0"
android:strokeLineCap="round"
android:strokeMiterLimit="10"
android:pathData="M182.16 214.09C181.42 199.71 182.42 177.87 207.64 155.49 213.64 150.16 220.13 146.12 226.28 143.08 238.64 136.97 249.62 134.91 252.55 134.56 252.7 134.54 252.83 134.53 252.94 134.52 253.05 134.51 253.14 134.5 253.2 134.5 255.01 134.48 294.9 136.66 313.05 160.43 332.29 185.63 344.82 221.3 300.07 263.56 263.08 298.49 258.36 318 258.54 317.72"/>
</vector>

15
libappbase/src/main/res/layout/activity_globalcrash.xml Normal file
View File

@@ -0,0 +1,15 @@
<?xml version="1.0" encoding="utf-8"?>
<LinearLayout
xmlns:android="http://schemas.android.com/apk/res/android"
xmlns:app="http://schemas.android.com/apk/res-auto"
android:orientation="vertical"
android:layout_width="match_parent"
android:layout_height="match_parent">
<cc.winboll.studio.libappbase.GlobalCrashReportView
android:layout_width="match_parent"
android:layout_height="match_parent"
android:id="@+id/activityglobalcrashGlobalCrashReportView1"/>
</LinearLayout>

14
libappbase/src/main/res/layout/activity_log.xml Normal file
View File

@@ -0,0 +1,14 @@
<?xml version="1.0" encoding="utf-8"?>
<LinearLayout
xmlns:android="http://schemas.android.com/apk/res/android"
xmlns:app="http://schemas.android.com/apk/res-auto"
android:layout_width="match_parent"
android:layout_height="match_parent">
<cc.winboll.studio.libappbase.LogView
android:layout_width="match_parent"
android:layout_height="match_parent"
android:id="@+id/logview"/>
</LinearLayout>

22
libappbase/src/main/res/layout/item_logtag.xml Normal file
View File

@@ -0,0 +1,22 @@
<?xml version="1.0" encoding="utf-8"?>
<LinearLayout
xmlns:android="http://schemas.android.com/apk/res/android"
xmlns:app="http://schemas.android.com/apk/res-auto"
android:orientation="horizontal"
android:layout_width="wrap_content"
android:layout_height="match_parent"
android:background="@drawable/bg_border_round">
<TextView
android:layout_width="wrap_content"
android:layout_height="@dimen/button_height"
android:layout_marginLeft="5dp"
android:id="@+id/viewlogtagTextView1"/>
<CheckBox
android:layout_width="wrap_content"
android:layout_height="@dimen/button_height"
android:id="@+id/viewlogtagCheckBox1"/>
</LinearLayout>

35
libappbase/src/main/res/layout/view_globalcrashreport.xml Normal file
View File

@@ -0,0 +1,35 @@
<?xml version="1.0" encoding="utf-8"?>
<LinearLayout
xmlns:android="http://schemas.android.com/apk/res/android"
xmlns:app="http://schemas.android.com/apk/res-auto"
android:orientation="vertical"
android:layout_width="match_parent"
android:layout_height="match_parent"
android:id="@+id/viewglobalcrashreportLinearLayout1">
<android.widget.Toolbar
android:layout_width="match_parent"
android:layout_height="wrap_content"
android:id="@+id/viewglobalcrashreportToolbar1"/>
<ScrollView
android:layout_width="match_parent"
android:layout_height="0dp"
android:layout_weight="1.0">
<HorizontalScrollView
android:layout_width="match_parent"
android:layout_height="match_parent">
<TextView
android:layout_width="match_parent"
android:layout_height="wrap_content"
android:background="#FFFFFFFF"
android:id="@+id/viewglobalcrashreportTextView1"/>
</HorizontalScrollView>
</ScrollView>
</LinearLayout>

138
libappbase/src/main/res/layout/view_log.xml Normal file
View File

@@ -0,0 +1,138 @@
<?xml version="1.0" encoding="utf-8"?>
<RelativeLayout
xmlns:android="http://schemas.android.com/apk/res/android"
android:orientation="vertical"
android:layout_width="match_parent"
android:layout_height="match_parent"
android:background="#FF000000">
<RelativeLayout
xmlns:app="http://schemas.android.com/apk/res-auto"
android:orientation="horizontal"
android:layout_width="match_parent"
android:layout_height="40dp"
android:layout_alignParentTop="true"
android:background="@drawable/bg_toolbar_log"
android:id="@+id/viewlogRelativeLayoutToolbar">
<Button
android:layout_width="wrap_content"
android:layout_height="36dp"
android:text="Clean"
android:textSize="14dp"
android:layout_centerVertical="true"
android:id="@+id/viewlogButtonClean"
android:layout_marginLeft="5dp"/>
<TextView
android:background="#FF000000"
android:layout_width="wrap_content"
android:layout_height="24dp"
android:text="LV:"
android:layout_toRightOf="@+id/viewlogButtonClean"
android:layout_centerVertical="true"
android:id="@+id/viewlogTextView1"
android:textColor="#FFFFFFFF"/>
<Spinner
android:background="#FFFFFFFF"
android:layout_width="wrap_content"
android:layout_height="24dp"
android:layout_toRightOf="@+id/viewlogTextView1"
android:layout_centerVertical="true"
android:id="@+id/viewlogSpinner1"/>
<CheckBox
android:layout_width="wrap_content"
android:layout_height="24dp"
android:layout_toLeftOf="@+id/viewlogButtonCopy"
android:layout_centerVertical="true"
android:text="Selectable"
android:background="#FFFFFFFF"
android:paddingRight="10dp"
android:textSize="16dp"
android:id="@+id/viewlogCheckBoxSelectable"/>
<Button
android:layout_width="wrap_content"
android:layout_height="36dp"
android:text="Copy"
android:layout_alignParentRight="true"
android:textSize="14dp"
android:layout_centerVertical="true"
android:id="@+id/viewlogButtonCopy"
android:layout_marginRight="5dp"/>
</RelativeLayout>
<LinearLayout
android:orientation="horizontal"
android:layout_width="match_parent"
android:layout_height="40dp"
android:layout_below="@+id/viewlogRelativeLayoutToolbar"
android:id="@+id/viewlogLinearLayout1"
android:gravity="center_vertical"
android:background="@drawable/bg_toolbar_log">
<CheckBox
android:layout_width="wrap_content"
android:layout_height="@dimen/button_height"
android:text="ALL"
android:id="@+id/viewlogCheckBox1"
android:background="@drawable/bg_border_round"
android:layout_marginLeft="5dp"
android:layout_marginRight="5dp"/>
<EditText
android:layout_width="50dp"
android:ems="10"
android:layout_height="wrap_content"
android:singleLine="true"
android:id="@+id/tagsearch_et"/>
<HorizontalScrollView
android:layout_width="0dp"
android:layout_height="match_parent"
android:background="@drawable/bg_border"
android:scrollbars="none"
android:padding="5dp"
android:layout_weight="1.0"
android:id="@+id/viewlogHorizontalScrollView1">
<cc.winboll.studio.libappbase.HorizontalListView
android:layout_width="wrap_content"
android:layout_height="match_parent"
android:id="@+id/tags_listview"/>
</HorizontalScrollView>
</LinearLayout>
<RelativeLayout
android:orientation="vertical"
android:layout_width="match_parent"
android:layout_height="wrap_content"
android:layout_weight="1.0"
android:layout_alignParentBottom="true"
android:layout_below="@+id/viewlogLinearLayout1">
<ScrollView
android:layout_width="match_parent"
android:layout_height="match_parent"
android:background="#FF000000"
android:id="@+id/viewlogScrollViewLog">
<TextView
android:layout_width="match_parent"
android:layout_height="match_parent"
android:text="Text"
android:textColor="#FF00FF00"
android:textIsSelectable="true"
android:id="@+id/viewlogTextViewLog"/>
</ScrollView>
</RelativeLayout>
</RelativeLayout>

11
libappbase/src/main/res/values/array.xml Normal file
View File

@@ -0,0 +1,11 @@
<?xml version="1.0" encoding="utf-8"?>
<resources>
<array name="enum_loglevel_array">
<item>Off</item>
<item>Error</item>
<item>Warn</item>
<item>Info</item>
<item>Debug</item>
<item>Verbose</item>
</array>
</resources>

15
libappbase/src/main/res/values/attrs.xml Normal file
View File

@@ -0,0 +1,15 @@
<?xml version="1.0" encoding="utf-8"?>
<resources>
<attr name="attrColorPrimary" format="color" />
<attr name="themeGlobalCrashActivity" format="reference"/>
<declare-styleable name="GlobalCrashActivity">
<attr name="colorTittle" format="color" />
<attr name="colorTittleBackgound" format="color" />
<attr name="colorText" format="color" />
<attr name="colorTextBackgound" format="color" />
</declare-styleable>
</resources>

7
libappbase/src/main/res/values/colors.xml Normal file
View File

@@ -0,0 +1,7 @@
<?xml version="1.0" encoding="utf-8"?>
<resources>
<color name="colorPrimary">#FF00B322</color>
<color name="colorPrimaryDark">#FF005C12</color>
<color name="colorAccent">#FF8DFFA2</color>
<color name="colorText">#FFFFFB8D</color>
</resources>

9
libappbase/src/main/res/values/dimens.xml Normal file
View File

@@ -0,0 +1,9 @@
<?xml version="1.0" encoding="utf-8"?>
<resources>
<!-- 定义一个名为text_size_normal的尺寸，值为16sp -->
<dimen name="text_size_normal">16sp</dimen>
<!-- 定义一个名为margin_small的尺寸，值为8dp -->
<dimen name="margin_small">8dp</dimen>
<!-- 定义一个名为image_width的尺寸，值为200dp -->
<dimen name="button_height">24dp</dimen>
</resources>

6
libappbase/src/main/res/values/strings.xml Normal file
View File

@@ -0,0 +1,6 @@
<?xml version="1.0" encoding="utf-8"?>
<resources>
<string name="lib_name">libappbase</string>
<string name="hello_world">Hello, world!</string>
</resources>

15
libappbase/src/main/res/values/styles.xml Normal file
View File

@@ -0,0 +1,15 @@
<?xml version="1.0" encoding="utf-8"?>
<resources>
<style name="APPBaseTheme" parent="@android:style/Theme.DeviceDefault.Light.NoActionBar">
<item name="themeGlobalCrashActivity">@style/GlobalCrashActivityTheme</item>
</style>
<style name="GlobalCrashActivityTheme" parent="@android:style/Theme.DeviceDefault.Light.NoActionBar">
<item name="colorTittle">#FFFFF600</item>
<item name="colorTittleBackgound">#FF00B322</item>
<item name="colorText">#FF00B322</item>
<item name="colorTextBackgound">#FF000000</item>
</style>
</resources>