Studio/WinBoLL
4
0
Fork 0
Code Issues Pull Requests Actions 1 Packages Projects Releases Wiki Activity

整理应用调试策略，非调试状态，日志记录功能取消。

Browse Source
This commit is contained in:
ZhangShaojian
2026-05-20 02:50:46 +08:00
parent 12ed35d807
commit 3649020434
13 changed files with 62 additions and 505 deletions
Download Patch File Download Diff File Expand all files Collapse all files

1
libappbase/src/main/java/cc/winboll/studio/libappbase/APPModel.java
View File

@@ -2,6 +2,7 @@ package cc.winboll.studio.libappbase;
import android.util.JsonReader;
import android.util.JsonWriter;
import cc.winboll.studio.libappbase.models.libs1520000.BaseBean;
import java.io.IOException;
/**

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

@@ -1,436 +0,0 @@
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;
}
}

6
libappbase/src/main/java/cc/winboll/studio/libappbase/GlobalApplication.java
View File

@@ -144,7 +144,11 @@ public class GlobalApplication extends Application {
*/
private void initCoreComponents() {
// 初始化日志工具（传入 Application 上下文）
LogUtils.init(this);
// 调试状态下初始化日志工具
if (GlobalApplication.isDebugging()) {
LogUtils.init(this);
}
// 初始化全局异常处理器（捕获应用崩溃信息，用于调试或上报）
CrashHandler.init(this);
// 初始化 Toast 工具（统一 Toast 样式、避免内存泄漏等）

5
libappbase/src/main/java/cc/winboll/studio/libappbase/LogActivity.java
View File

@@ -27,6 +27,11 @@ public class LogActivity extends Activity {
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
if(!GlobalApplication.isDebugging()) {
ToastUtils.show("非调试状态日志功能不可用");
finish();
}
// 设置布局文件（包含 LogView 控件）
setContentView(R.layout.activity_log);

50
libappbase/src/main/java/cc/winboll/studio/libappbase/LogUtils.java
View File

@@ -67,45 +67,26 @@ public class LogUtils {
// ====================== 初始化入口 ======================
public static void init(final Context context) {
init(context, LOG_LEVEL.Off);
init(context, LOG_LEVEL.Off);
}
public static void init(final Context context, final LOG_LEVEL logLevel) {
Log.d(TAG, "init 执行日志工具初始化");
_mContext = context;
Log.d(TAG, "init 执行日志工具初始化");
_mContext = context;
if (GlobalApplication.isDebugging()) {
initDebugDir();
} else {
initReleaseDir();
}
initLogUtilsDir();
initLogConfigBean();
addClassTAGList();
loadTAGBeanSettings();
checkAndTrimLogFileSize();
initLogConfigBean();
addClassTAGList();
loadTAGBeanSettings();
checkAndTrimLogFileSize();
_IsInited = true;
Log.d(TAG, "init 日志工具初始化完成");
_IsInited = true;
Log.d(TAG, "init 执行日志工具初始化完成");
}
// ====================== 目录初始化 ======================
private static void initDebugDir() {
final Context appContext = _mContext.getApplicationContext();
_mfLogCacheDir = new File(appContext.getExternalCacheDir(), TAG);
if (!_mfLogCacheDir.exists()) {
_mfLogCacheDir.mkdirs();
}
_mfLogCatchFile = new File(_mfLogCacheDir, "log.txt");
_mfLogDataDir = appContext.getExternalFilesDir(TAG);
if (!_mfLogDataDir.exists()) {
_mfLogDataDir.mkdirs();
}
_mfLogUtilsBeanFile = new File(_mfLogDataDir, TAG + ".json");
}
private static void initReleaseDir() {
private static void initLogUtilsDir() {
final Context appContext = _mContext.getApplicationContext();
_mfLogCacheDir = new File(appContext.getCacheDir(), TAG);
if (!_mfLogCacheDir.exists()) {
@@ -113,7 +94,7 @@ public class LogUtils {
}
_mfLogCatchFile = new File(_mfLogCacheDir, "log.txt");
_mfLogDataDir = new File(appContext.getFilesDir(), TAG);
_mfLogDataDir = appContext.getExternalFilesDir(TAG);
if (!_mfLogDataDir.exists()) {
_mfLogDataDir.mkdirs();
}
@@ -136,7 +117,7 @@ public class LogUtils {
}
final long KEEP_FILE_SIZE = 25000L; // ~25KB 确保剪贴板可完整复制
final long MAX_FILE_SIZE = 2*KEEP_FILE_SIZE;
final long MAX_FILE_SIZE = 2 * KEEP_FILE_SIZE;
final long fileSize = _mfLogCatchFile.length();
if (fileSize <= MAX_FILE_SIZE) {
@@ -293,10 +274,13 @@ public class LogUtils {
}
public static LOG_LEVEL getLogLevel() {
return _mLogUtilsBean.getLogLevel();
return _mLogUtilsBean == null ?LOG_LEVEL.Off: _mLogUtilsBean.getLogLevel();
}
private static boolean isLoggable(final String tag, final LOG_LEVEL logLevel) {
if (!GlobalApplication.isDebugging()) {
return false;
}
if (!_IsInited) {
return false;
}

1
libappbase/src/main/java/cc/winboll/studio/libappbase/LogUtilsBean.java
View File

@@ -2,6 +2,7 @@ package cc.winboll.studio.libappbase;
import android.util.JsonReader;
import android.util.JsonWriter;
import cc.winboll.studio.libappbase.models.libs1520000.BaseBean;
import java.io.IOException;
/**

1
libappbase/src/main/java/cc/winboll/studio/libappbase/LogUtilsClassTAGBean.java
View File

@@ -2,6 +2,7 @@ package cc.winboll.studio.libappbase;
import android.util.JsonReader;
import android.util.JsonWriter;
import cc.winboll.studio.libappbase.models.libs1520000.BaseBean;
import java.io.IOException;
/**

45
libappbase/src/main/java/cc/winboll/studio/libappbase/LogViewThread.java
View File

@@ -51,30 +51,33 @@ public class LogViewThread extends Thread {
*/
@Override
public void run() {
// 获取日志缓存目录路径（从 LogUtils 统一获取，确保路径一致性）
String logDirPath = LogUtils.getLogCacheDir().getPath();
LogUtils.d(TAG, "启动日志文件监听，监听目录：" + logDirPath);
// 调试状态进行日志输出任务
if (GlobalApplication.isDebugging()) {
// 获取日志缓存目录路径（从 LogUtils 统一获取，确保路径一致性）
String logDirPath = LogUtils.getLogCacheDir().getPath();
LogUtils.d(TAG, "启动日志文件监听，监听目录：" + logDirPath);
// 初始化日志文件监听器（监听目标目录的文件事件）
mLogListener = new LogListener(logDirPath);
// 开始监听文件事件（非阻塞，内部通过 Native 层实现）
mLogListener.startWatching();
// 初始化日志文件监听器（监听目标目录的文件事件）
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;
}
}
// 循环等待退出标志（每 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, "日志文件监听已停止，线程退出");
// 收到退出标志，停止监听并释放资源
mLogListener.stopWatching();
LogUtils.d(TAG, "日志文件监听已停止，线程退出");
}
}
/**

6
libappbase/src/main/java/cc/winboll/studio/libappbase/models/libs1520000/BaseBean.java
View File

@@ -152,7 +152,7 @@ public abstract class BaseBean<T extends BaseBean> {
final JsonReader jsonReader = new JsonReader(stringReader);
try {
final T beanTemp = clazz.newInstance();
return beanTemp.readBeanFromJsonReader(jsonReader);
return (T) beanTemp.readBeanFromJsonReader(jsonReader);
} catch (final InstantiationException e) {
LogUtils.d(TAG, "实体反射实例化失败(InstantiationException)", Thread.currentThread().getStackTrace());
} catch (final IllegalAccessException e) {
@@ -169,7 +169,7 @@ public abstract class BaseBean<T extends BaseBean> {
* @param <T> 实体泛型
* @return 解析结果
*/
public static <T extends BaseBean> boolean parseStringToBeanList(final String szBeanList, final ArrayList<T> beanList, final Class<T> clazz) {
public static <T extends BaseBean> boolean parseStringToBeanList(final String szBeanList, ArrayList<T> beanList, final Class<T> clazz) {
LogUtils.d(TAG, "进入列表字符串解析方法");
try {
if (beanList == null) {
@@ -182,7 +182,7 @@ public abstract class BaseBean<T extends BaseBean> {
jsonReader.beginArray();
while (jsonReader.hasNext()) {
final T beanTemp = clazz.newInstance();
final T bean = beanTemp.readBeanFromJsonReader(jsonReader);
final T bean = (T) beanTemp.readBeanFromJsonReader(jsonReader);
if (bean != null) {
beanList.add(bean);
}