commit dea2d84a218c52bfeea4e7a0370d510841df4905 Author: zhangyuan <2432903928@qq.com> Date: Mon May 19 16:51:33 2025 +0800 提交 diff --git a/doc/小米便签开源代码泛读报告 张媛 汪廷哲(2).docx b/doc/小米便签开源代码泛读报告 张媛 汪廷哲(2).docx new file mode 100644 index 0000000..48440eb Binary files /dev/null and b/doc/小米便签开源代码泛读报告 张媛 汪廷哲(2).docx differ diff --git a/doc/张媛运行截图.png b/doc/张媛运行截图.png new file mode 100644 index 0000000..a242ad3 Binary files /dev/null and b/doc/张媛运行截图.png differ diff --git a/doc/汪廷哲运行截图.png b/doc/汪廷哲运行截图.png new file mode 100644 index 0000000..c1810fe Binary files /dev/null and b/doc/汪廷哲运行截图.png differ diff --git a/doc/质量分析报告.docx b/doc/质量分析报告.docx new file mode 100644 index 0000000..d1a11f5 Binary files /dev/null and b/doc/质量分析报告.docx differ diff --git a/src/Date/MetaData.java b/src/Date/MetaData.java new file mode 100644 index 0000000..377521f --- /dev/null +++ b/src/Date/MetaData.java @@ -0,0 +1,132 @@ +/* + * 版权所有 (c) 2010-2011，MiCode 开源社区 (www.micode.net) + * 根据 Apache 许可证 2.0 版本（"许可证"）授权； + * 除非符合许可证的规定，否则不得使用本文件。 + * 您可以从以下网址获取许可证副本： + * http://www.apache.org/licenses/LICENSE-2.0 + * 除非适用法律要求或书面同意，本软件按"原样"分发， + * 没有任何明示或暗示的保证或条件。 + * 详见许可证中规定的权限和限制。 + * （注：这是一份标准的Apache许可证2.0版本的开源声明） + */ + +// 定义MetaData类所在的包路径 +package net.micode.notes.gtask.data; + +// 导入Android数据库Cursor类 +import android.database.Cursor; +// 导入Android日志工具类 +import android.util.Log; + +// 导入应用中自定义的字符串工具类 +import net.micode.notes.tool.GTaskStringUtils; + +// 导入JSON处理相关类 +import org.json.JSONException; +import org.json.JSONObject; + +/** + * MetaData类 - 继承自Task类 + * 功能：处理Google Tasks元数据信息 + * 特性： + * 1. 存储关联任务的GID（Google ID） + * 2. 将元数据信息以JSON格式存储在notes字段中 + * 3. 仅用于远程数据同步，不支持本地操作 + */ +public class MetaData extends Task { + // 日志标签，使用类名作为标识 + private final static String TAG = MetaData.class.getSimpleName(); + + // 存储关联任务的Google ID + private String mRelatedGid = null; + + /** + * 设置元数据信息 + * @param gid 关联任务的Google ID + * @param metaInfo 包含元数据的JSON对象 + */ + public void setMeta(String gid, JSONObject metaInfo) { + try { + // 将GID添加到元数据JSON中 + metaInfo.put(GTaskStringUtils.META_HEAD_GTASK_ID, gid); + } catch (JSONException e) { + Log.e(TAG, "failed to put related gid"); // 记录错误日志 + } + // 将JSON对象转为字符串存储到notes字段 + setNotes(metaInfo.toString()); + // 设置固定名称标识这是一个元数据任务 + setName(GTaskStringUtils.META_NOTE_NAME); + } + + /** + * 获取关联任务的Google ID + * @return 关联GID，可能为null + */ + public String getRelatedGid() { + return mRelatedGid; + } + + /** + * 判断是否值得保存 + * @return notes字段不为空时返回true + */ + @Override + public boolean isWorthSaving() { + return getNotes() != null; + } + + /** + * 从远程JSON数据设置内容 + * @param js 包含远程数据的JSON对象 + */ + @Override + public void setContentByRemoteJSON(JSONObject js) { + // 先调用父类方法处理基础字段 + super.setContentByRemoteJSON(js); + + // 如果notes字段不为空，解析其中的GID + if (getNotes() != null) { + try { + // 将notes字符串转为JSON对象 + JSONObject metaInfo = new JSONObject(getNotes().trim()); + // 从JSON中获取关联GID + mRelatedGid = metaInfo.getString(GTaskStringUtils.META_HEAD_GTASK_ID); + } catch (JSONException e) { + Log.w(TAG, "failed to get related gid"); // 记录警告日志 + mRelatedGid = null; // 解析失败时重置GID + } + } + } + + /** + * 从本地JSON设置内容（不支持） + * @param js JSON对象 + * @throws IllegalAccessError 总是抛出此异常 + */ + @Override + public void setContentByLocalJSON(JSONObject js) { + // 元数据不应从本地JSON设置，直接抛出异常 + throw new IllegalAccessError("MetaData:setContentByLocalJSON should not be called"); + } + + /** + * 获取本地JSON内容（不支持） + * @throws IllegalAccessError 总是抛出此异常 + */ + @Override + public JSONObject getLocalJSONFromContent() { + // 元数据不应生成本地JSON，直接抛出异常 + throw new IllegalAccessError("MetaData:getLocalJSONFromContent should not be called"); + } + + /** + * 获取同步动作（不支持） + * @param c 数据库Cursor + * @throws IllegalAccessError 总是抛出此异常 + */ + @Override + public int getSyncAction(Cursor c) { + // 元数据不支持同步动作查询，直接抛出异常 + throw new IllegalAccessError("MetaData:getSyncAction should not be called"); + } +} \ No newline at end of file diff --git a/src/Date/Node.java b/src/Date/Node.java new file mode 100644 index 0000000..ec33700 --- /dev/null +++ b/src/Date/Node.java @@ -0,0 +1,157 @@ +/* + * 版权所有 (c) 2010-2011，MiCode 开源社区 (www.micode.net) + * 根据 Apache 许可证 2.0 版本（"许可证"）授权； + * 除非符合许可证的规定，否则不得使用本文件。 + * 您可以从以下网址获取许可证副本： + * http://www.apache.org/licenses/LICENSE-2.0 + * 除非适用法律要求或书面同意，本软件按"原样"分发， + * 没有任何明示或暗示的保证或条件。 + * 详见许可证中规定的权限和限制。 + * （注：这是一份标准的Apache许可证2.0版本的开源声明） + */ +// 定义Node类所在的包路径 +package net.micode.notes.gtask.data; +// 导入Android数据库Cursor类（用于本地数据操作） +import android.database.Cursor; +// 导入JSON处理类 +import org.json.JSONObject; +/** + * 抽象Node类 - GTasks数据同步的基础节点类 + * 功能： + * 1. 定义通用的同步动作常量 + * 2. 提供基本属性管理（GID、名称、修改时间等） + * 3. 声明数据同步的核心抽象方法 + */ +public abstract class Node { + // 同步动作常量：无操作 + public static final int SYNC_ACTION_NONE = 0; + // 同步动作常量：添加到远程 + public static final int SYNC_ACTION_ADD_REMOTE = 1; + // 同步动作常量：添加到本地 + public static final int SYNC_ACTION_ADD_LOCAL = 2; + // 同步动作常量：从远程删除 + public static final int SYNC_ACTION_DEL_REMOTE = 3; + // 同步动作常量：从本地删除 + public static final int SYNC_ACTION_DEL_LOCAL = 4; + // 同步动作常量：更新远程 + public static final int SYNC_ACTION_UPDATE_REMOTE = 5; + // 同步动作常量：更新本地 + public static final int SYNC_ACTION_UPDATE_LOCAL = 6; + // 同步动作常量：更新冲突 + public static final int SYNC_ACTION_UPDATE_CONFLICT = 7; + // 同步动作常量：错误状态 + public static final int SYNC_ACTION_ERROR = 8; + // Google任务ID（全局唯一标识） + private String mGid; + // 节点名称 + private String mName; + // 最后修改时间戳（毫秒） + private long mLastModified; + // 删除标记 + private boolean mDeleted; + + /** + * 构造函数 + * 初始化默认值： + * - GID为null + * - 名称为空字符串 + * - 最后修改时间为0 + * - 未删除状态 + */ + public Node() { + mGid = null; + mName = ""; + mLastModified = 0; + mDeleted = false; + } + /** + * 抽象方法：获取创建动作的JSON数据 + * @param actionId 动作ID + * @return 包含创建动作数据的JSON对象 + */ + public abstract JSONObject getCreateAction(int actionId); + + /** + * 抽象方法：获取更新动作的JSON数据 + * @param actionId 动作ID + * @return 包含更新动作数据的JSON对象 + */ + public abstract JSONObject getUpdateAction(int actionId); + /** + * 抽象方法：从远程JSON数据设置内容 + * @param js 包含远程数据的JSON对象 + */ + public abstract void setContentByRemoteJSON(JSONObject js); + /** + * 抽象方法：从本地JSON数据设置内容 + * @param js 包含本地数据的JSON对象 + */ + public abstract void setContentByLocalJSON(JSONObject js); + /** + * 抽象方法：从内容生成本地JSON数据 + * @return 包含本地数据的JSON对象 + */ + public abstract JSONObject getLocalJSONFromContent(); + /** + * 抽象方法：获取同步动作类型 + * @param c 数据库Cursor对象 + * @return 同步动作常量（SYNC_ACTION_*） + */ + public abstract int getSyncAction(Cursor c); + /** + * 设置Google任务ID + * @param gid 全局唯一标识 + */ + public void setGid(String gid) { + this.mGid = gid; + } + /** + * 设置节点名称 + * @param name 显示名称 + */ + public void setName(String name) { + this.mName = name; + } + /** + * 设置最后修改时间 + * @param lastModified 时间戳（毫秒） + */ + public void setLastModified(long lastModified) { + this.mLastModified = lastModified; + } + /** + * 设置删除标记 + * @param deleted 是否已删除 + */ + public void setDeleted(boolean deleted) { + this.mDeleted = deleted; + } + /** + * 获取Google任务ID + * @return 全局唯一标识（可能为null） + */ + public String getGid() { + return this.mGid; + } + /** + * 获取节点名称 + * @return 显示名称 + */ + public String getName() { + return this.mName; + } + /** + * 获取最后修改时间 + * @return 时间戳（毫秒） + */ + public long getLastModified() { + return this.mLastModified; + } + /** + * 获取删除状态 + * @return 是否已删除 + */ + public boolean getDeleted() { + return this.mDeleted; + } +} \ No newline at end of file diff --git a/src/Date/SqlData.java b/src/Date/SqlData.java new file mode 100644 index 0000000..aa230c3 --- /dev/null +++ b/src/Date/SqlData.java @@ -0,0 +1,258 @@ +/* + * 版权所有 (c) 2010-2011，MiCode 开源社区 (www.micode.net) + * 根据 Apache 许可证 2.0 版本（"许可证"）授权； + * 除非符合许可证的规定，否则不得使用本文件。 + * 您可以从以下网址获取许可证副本： + * http://www.apache.org/licenses/LICENSE-2.0 + * 除非适用法律要求或书面同意，本软件按"原样"分发， + * 没有任何明示或暗示的保证或条件。 + * 详见许可证中规定的权限和限制。 + * （注：这是一份标准的Apache许可证2.0版本的开源声明） + */ + +// 定义当前类所在的包路径 +package net.micode.notes.gtask.data; + +// 导入Android内容提供者相关类 +import android.content.ContentResolver; // 内容解析器，用于访问ContentProvider +import android.content.ContentUris; // 用于构建带有ID的URI +import android.content.ContentValues; // 键值对存储，用于数据库操作 +import android.content.Context; // 应用上下文 +import android.database.Cursor; // 数据库查询结果集 +import android.net.Uri; // 通用资源标识符 +import android.os.Build; // 获取Android版本信息 +import android.util.Log; // 日志工具 + +// 导入AndroidX注解（版本检查） +import androidx.annotation.RequiresApi; + +// 导入笔记应用数据相关常量 +import net.micode.notes.data.Notes; // 笔记数据常量 +import net.micode.notes.data.Notes.DataColumns; // 数据列名常量 +import net.micode.notes.data.Notes.DataConstants; // 数据相关常量 +import net.micode.notes.data.Notes.NoteColumns; // 笔记列名常量 +import net.micode.notes.data.NotesDatabaseHelper.TABLE; // 数据库表名 +// 导入同步异常类 +import net.micode.notes.gtask.exception.ActionFailureException; + +// 导入JSON处理相关类 +import org.json.JSONException; // JSON异常 +import org.json.JSONObject; // JSON对象 + +// 导入Java工具类 +import java.util.Objects; // 对象工具类 + +/** + * SqlData类 - 处理笔记数据的SQLite数据库操作 + * 功能： + * 1. 封装笔记数据的增删改查操作 + * 2. 管理本地数据与JSON格式的相互转换 + * 3. 处理数据版本控制 + */ +public class SqlData { + // 日志标签 + private static final String TAG = SqlData.class.getSimpleName(); + + // 无效ID常量 + private static final int INVALID_ID = -99999; + + // 数据查询的列投影（指定需要查询的列） + public static final String[] PROJECTION_DATA = new String[] { + DataColumns.ID, // 数据ID + DataColumns.MIME_TYPE, // MIME类型 + DataColumns.CONTENT, // 内容 + DataColumns.DATA1, // 扩展数据1 + DataColumns.DATA3 // 扩展数据3 + }; + + // 列索引常量 + public static final int DATA_ID_COLUMN = 0; // ID列索引 + public static final int DATA_MIME_TYPE_COLUMN = 1; // MIME类型列索引 + public static final int DATA_CONTENT_COLUMN = 2; // 内容列索引 + public static final int DATA_CONTENT_DATA_1_COLUMN = 3; // 扩展数据1列索引 + public static final int DATA_CONTENT_DATA_3_COLUMN = 4; // 扩展数据3列索引 + + // 内容解析器实例 + private final ContentResolver mContentResolver; + + // 是否为新创建数据的标志 + private boolean mIsCreate; + + // 数据字段 + private long mDataId; // 数据ID + private String mDataMimeType; // MIME类型 + private String mDataContent; // 内容 + private long mDataContentData1; // 扩展数据1（长整型） + private String mDataContentData3; // 扩展数据3（字符串） + + // 存储有变动的数据值（用于增量更新） + private final ContentValues mDiffDataValues; + + /** + * 构造函数（用于创建新数据） + * @param context 应用上下文 + */ + public SqlData(Context context) { + mContentResolver = context.getContentResolver(); + mIsCreate = true; // 标记为新创建 + mDataId = INVALID_ID; // 初始化无效ID + mDataMimeType = DataConstants.NOTE; // 默认MIME类型 + mDataContent = ""; // 空内容 + mDataContentData1 = 0; // 默认扩展数据1 + mDataContentData3 = ""; // 空扩展数据3 + mDiffDataValues = new ContentValues(); // 初始化变更集合 + } + + /** + * 构造函数（基于Cursor加载已有数据） + * @param context 应用上下文 + * @param c 数据库Cursor对象 + */ + public SqlData(Context context, Cursor c) { + mContentResolver = context.getContentResolver(); + mIsCreate = false; // 标记为已存在数据 + loadFromCursor(c); // 从Cursor加载数据 + mDiffDataValues = new ContentValues(); // 初始化变更集合 + } + + /** + * 从Cursor加载数据 + * @param c 数据库Cursor对象 + */ + private void loadFromCursor(Cursor c) { + mDataId = c.getLong(DATA_ID_COLUMN); + mDataMimeType = c.getString(DATA_MIME_TYPE_COLUMN); + mDataContent = c.getString(DATA_CONTENT_COLUMN); + mDataContentData1 = c.getLong(DATA_CONTENT_DATA_1_COLUMN); + mDataContentData3 = c.getString(DATA_CONTENT_DATA_3_COLUMN); + } + + /** + * 设置内容（从JSON对象） + * @param js 包含数据的JSON对象 + * @throws JSONException JSON解析异常 + */ + public void setContent(JSONObject js) throws JSONException { + // 处理数据ID + long dataId = js.has(DataColumns.ID) ? js.getLong(DataColumns.ID) : INVALID_ID; + if (mIsCreate || mDataId != dataId) { + mDiffDataValues.put(DataColumns.ID, dataId); + } + mDataId = dataId; + + // 处理MIME类型 + String dataMimeType = js.has(DataColumns.MIME_TYPE) ? js.getString(DataColumns.MIME_TYPE) + : DataConstants.NOTE; + if (mIsCreate || !mDataMimeType.equals(dataMimeType)) { + mDiffDataValues.put(DataColumns.MIME_TYPE, dataMimeType); + } + mDataMimeType = dataMimeType; + + // 处理内容 + String dataContent = js.has(DataColumns.CONTENT) ? js.getString(DataColumns.CONTENT) : ""; + if (mIsCreate || !mDataContent.equals(dataContent)) { + mDiffDataValues.put(DataColumns.CONTENT, dataContent); + } + mDataContent = dataContent; + + // 处理扩展数据1 + long dataContentData1 = js.has(DataColumns.DATA1) ? js.getLong(DataColumns.DATA1) : 0; + if (mIsCreate || mDataContentData1 != dataContentData1) { + mDiffDataValues.put(DataColumns.DATA1, dataContentData1); + } + mDataContentData1 = dataContentData1; + + // 处理扩展数据3 + String dataContentData3 = js.has(DataColumns.DATA3) ? js.getString(DataColumns.DATA3) : ""; + if (mIsCreate || !mDataContentData3.equals(dataContentData3)) { + mDiffDataValues.put(DataColumns.DATA3, dataContentData3); + } + mDataContentData3 = dataContentData3; + } + + /** + * 获取内容（转换为JSON对象） + * @return 包含数据的JSON对象 + * @throws JSONException JSON构造异常 + */ + public JSONObject getContent() throws JSONException { + if (mIsCreate) { + Log.e(TAG, "it seems that we haven't created this in database yet"); + return null; + } + // 构建JSON对象 + JSONObject js = new JSONObject(); + js.put(DataColumns.ID, mDataId); + js.put(DataColumns.MIME_TYPE, mDataMimeType); + js.put(DataColumns.CONTENT, mDataContent); + js.put(DataColumns.DATA1, mDataContentData1); + js.put(DataColumns.DATA3, mDataContentData3); + return js; + } + + /** + * 提交数据到数据库 + * @param noteId 关联的笔记ID + * @param validateVersion 是否验证版本 + * @param version 版本号（当validateVersion为true时使用） + */ + @RequiresApi(api = Build.VERSION_CODES.R) + public void commit(long noteId, boolean validateVersion, long version) { + // 处理新建数据的情况 + if (mIsCreate) { + // 如果ID无效且有ID变更，移除无效ID + if (mDataId == INVALID_ID && mDiffDataValues.containsKey(DataColumns.ID)) { + mDiffDataValues.remove(DataColumns.ID); + } + + // 设置关联笔记ID + mDiffDataValues.put(DataColumns.NOTE_ID, noteId); + // 插入新数据 + Uri uri = mContentResolver.insert(Notes.CONTENT_DATA_URI, mDiffDataValues); + try { + // 从返回的URI中解析出新数据的ID + mDataId = Long.parseLong(Objects.requireNonNull(uri).getPathSegments().get(1)); + } catch (NumberFormatException e) { + Log.e(TAG, "Get note id error :" + e); + throw new ActionFailureException("create note failed"); + } + } else { + // 处理更新已有数据的情况 + if (!mDiffDataValues.isEmpty()) { + int result; + if (!validateVersion) { + // 不验证版本的普通更新 + result = mContentResolver.update( + ContentUris.withAppendedId(Notes.CONTENT_DATA_URI, mDataId), + mDiffDataValues, + null, + null + ); + } else { + // 带版本验证的更新 + result = mContentResolver.update( + ContentUris.withAppendedId(Notes.CONTENT_DATA_URI, mDataId), + mDiffDataValues, + " ? in (SELECT " + NoteColumns.ID + " FROM " + TABLE.NOTE + + " WHERE " + NoteColumns.VERSION + "=?)", + new String[] { String.valueOf(noteId), String.valueOf(version) } + ); + } + if (result == 0) { + Log.w(TAG, "there is no update. maybe user updates note when syncing"); + } + } + } + + // 重置状态 + mDiffDataValues.clear(); + mIsCreate = false; + } + /** + * 获取数据ID + * @return 数据ID + */ + public long getId() { + return mDataId; + } +} diff --git a/src/Date/SqlNote.java b/src/Date/SqlNote.java new file mode 100644 index 0000000..9fd6a29 --- /dev/null +++ b/src/Date/SqlNote.java @@ -0,0 +1,628 @@ +/* + * 版权所有 (c) 2010-2011，MiCode 开源社区 (www.micode.net) + * 根据 Apache 许可证 2.0 版本（"许可证"）授权； + * 除非符合许可证的规定，否则不得使用本文件。 + * 您可以从以下网址获取许可证副本： + * http://www.apache.org/licenses/LICENSE-2.0 + * 除非适用法律要求或书面同意，本软件按"原样"分发， + * 没有任何明示或暗示的保证或条件。 + * 详见许可证中规定的权限和限制。 + * （注：这是一份标准的Apache许可证2.0版本的开源声明） + */ + +// 定义当前类所在的包路径 +package net.micode.notes.gtask.data; +// Android Widget相关类 +import android.appwidget.AppWidgetManager; // 管理应用小部件 +// Android内容提供者相关类 +import android.content.ContentResolver; // 内容解析器，用于访问ContentProvider +import android.content.ContentValues; // 键值对存储，用于数据库操作 +import android.content.Context; // 应用上下文 +// Android数据库相关类 +import android.database.Cursor; // 数据库查询结果集 +// Android网络相关类 +import android.net.Uri; // 通用资源标识符 +// Android系统相关类 +import android.os.Build; // 获取Android版本信息 +import android.util.Log; // 日志工具 +// AndroidX注解支持 +import androidx.annotation.RequiresApi; // 版本要求注解 +// 笔记应用数据相关类 +import net.micode.notes.data.Notes; // 笔记数据常量 +import net.micode.notes.data.Notes.DataColumns; // 数据表列名常量 +import net.micode.notes.data.Notes.NoteColumns; // 笔记表列名常量 +// 异常处理类 +import net.micode.notes.gtask.exception.ActionFailureException; // 同步操作失败异常 +// 工具类 +import net.micode.notes.tool.GTaskStringUtils; // Google Task字符串工具 +import net.micode.notes.tool.ResourceParser; // 资源解析工具 +// JSON处理相关类 +import org.json.JSONArray; // JSON数组处理 +import org.json.JSONException; // JSON异常 +import org.json.JSONObject; // JSON对象处理 +// Java集合类 +import java.util.ArrayList; // 动态数组 +import java.util.Objects; // 对象工具类 + +// 定义SqlNote类，用于管理笔记数据的数据库操作 +public class SqlNote { + // 日志标签 + private static final String TAG = SqlNote.class.getSimpleName(); + + // 无效ID常量 + private static final int INVALID_ID = -99999; + + // 笔记数据查询投影列（指定需要查询的字段） + public static final String[] PROJECTION_NOTE = new String[] { + NoteColumns.ID, // 笔记ID + NoteColumns.ALERTED_DATE, // 提醒日期 + NoteColumns.BG_COLOR_ID, // 背景颜色ID + NoteColumns.CREATED_DATE, // 创建日期 + NoteColumns.HAS_ATTACHMENT, // 是否有附件 + NoteColumns.MODIFIED_DATE, // 修改日期 + NoteColumns.NOTES_COUNT, // 子笔记数量 + NoteColumns.PARENT_ID, // 父笔记ID + NoteColumns.SNIPPET, // 内容摘要 + NoteColumns.TYPE, // 笔记类型 + NoteColumns.WIDGET_ID, // 小部件ID + NoteColumns.WIDGET_TYPE, // 小部件类型 + NoteColumns.SYNC_ID, // 同步ID + NoteColumns.LOCAL_MODIFIED, // 本地修改标记 + NoteColumns.ORIGIN_PARENT_ID, // 原始父笔记ID + NoteColumns.GTASK_ID, // Google任务ID + NoteColumns.VERSION // 数据版本 + }; + + // 列索引常量定义 + public static final int ID_COLUMN = 0; // ID列索引 + public static final int ALERTED_DATE_COLUMN = 1; // 提醒日期列索引 + public static final int BG_COLOR_ID_COLUMN = 2; // 背景颜色列索引 + public static final int CREATED_DATE_COLUMN = 3; // 创建日期列索引 + public static final int HAS_ATTACHMENT_COLUMN = 4; // 附件标记列索引 + public static final int MODIFIED_DATE_COLUMN = 5; // 修改日期列索引 + public static final int NOTES_COUNT_COLUMN = 6; // 子笔记数列索引 + public static final int PARENT_ID_COLUMN = 7; // 父笔记ID列索引 + public static final int SNIPPET_COLUMN = 8; // 摘要列索引 + public static final int TYPE_COLUMN = 9; // 类型列索引 + public static final int WIDGET_ID_COLUMN = 10; // 小部件ID列索引 + public static final int WIDGET_TYPE_COLUMN = 11; // 小部件类型列索引 + public static final int SYNC_ID_COLUMN = 12; // 同步ID列索引 + public static final int LOCAL_MODIFIED_COLUMN = 13; // 本地修改列索引 + public static final int ORIGIN_PARENT_ID_COLUMN = 14; // 原始父笔记ID列索引 + public static final int GTASK_ID_COLUMN = 15; // Google任务ID列索引 + public static final int VERSION_COLUMN = 16; // 版本列索引 + + // 上下文对象 + private final Context mContext; + // 内容解析器 + private final ContentResolver mContentResolver; + // 是否为新建笔记标记 + private boolean mIsCreate; + + // 笔记字段 + private long mId; // 笔记ID + private long mAlertDate; // 提醒时间 + private int mBgColorId; // 背景颜色ID + private long mCreatedDate; // 创建时间 + private int mHasAttachment; // 是否有附件(0/1) + private long mModifiedDate; // 最后修改时间 + private long mParentId; // 父笔记ID + private String mSnippet; // 内容摘要 + private int mType; // 笔记类型 + private int mWidgetId; // 关联小部件ID + private int mWidgetType; // 小部件类型 + private long mOriginParent; // 原始父笔记ID + private long mVersion; // 数据版本 + + // 存储变动的笔记值 + private final ContentValues mDiffNoteValues; + // 笔记关联的数据列表 + private final ArrayList mDataList; + + /** + * 构造函数（用于创建新笔记） + * @param context 应用上下文 + */ + public SqlNote(Context context) { + mContext = context; + mContentResolver = context.getContentResolver(); + mIsCreate = true; // 标记为新创建 + // 初始化默认值 + mId = INVALID_ID; + mAlertDate = 0; + mBgColorId = ResourceParser.getDefaultBgId(context); // 获取默认背景 + mCreatedDate = System.currentTimeMillis(); // 当前时间为创建时间 + mHasAttachment = 0; + mModifiedDate = System.currentTimeMillis(); // 当前时间为修改时间 + mParentId = 0; + mSnippet = ""; + mType = Notes.TYPE_NOTE; // 默认为普通笔记类型 + mWidgetId = AppWidgetManager.INVALID_APPWIDGET_ID; // 无效小部件ID + mWidgetType = Notes.TYPE_WIDGET_INVALIDE; // 无效小部件类型 + mOriginParent = 0; + mVersion = 0; + mDiffNoteValues = new ContentValues(); // 初始化变更值容器 + mDataList = new ArrayList<>(); // 初始化数据列表 + } + + /** + * 构造函数（基于Cursor加载已有笔记） + * @param context 应用上下文 + * @param c 数据库Cursor + */ + public SqlNote(Context context, Cursor c) { + mContext = context; + mContentResolver = context.getContentResolver(); + mIsCreate = false; // 标记为已有笔记 + loadFromCursor(c); // 从Cursor加载数据 + mDataList = new ArrayList<>(); + // 如果是普通笔记类型，加载关联数据 + if (mType == Notes.TYPE_NOTE) + loadDataContent(); + mDiffNoteValues = new ContentValues(); + } + + /** + * 构造函数（基于笔记ID加载） + * @param context 应用上下文 + * @param id 笔记ID + */ + public SqlNote(Context context, long id) { + mContext = context; + mContentResolver = context.getContentResolver(); + mIsCreate = false; // 标记为已有笔记 + loadFromCursor(id); // 通过ID加载笔记 + mDataList = new ArrayList<>(); + // 如果是普通笔记类型，加载关联数据 + if (mType == Notes.TYPE_NOTE) + loadDataContent(); + mDiffNoteValues = new ContentValues(); + } + + /** + * 通过笔记ID从数据库加载数据 + * @param id 笔记ID + */ + private void loadFromCursor(long id) { + // 使用try-with-resources确保Cursor自动关闭 + try (Cursor c = mContentResolver.query( + Notes.CONTENT_NOTE_URI, // 笔记内容URI + PROJECTION_NOTE, // 查询列 + "(_id=?)", // 查询条件 + new String[]{ String.valueOf(id) }, // 参数 + null)) { // 排序 + if (c != null) { + c.moveToNext(); // 移动到第一行 + loadFromCursor(c); // 从Cursor加载数据 + } else { + Log.w(TAG, "loadFromCursor: cursor = null"); + } + } + } + + /** + * 从Cursor加载笔记数据 + * @param c 数据库Cursor + */ + private void loadFromCursor(Cursor c) { + mId = c.getLong(ID_COLUMN); + mAlertDate = c.getLong(ALERTED_DATE_COLUMN); + mBgColorId = c.getInt(BG_COLOR_ID_COLUMN); + mCreatedDate = c.getLong(CREATED_DATE_COLUMN); + mHasAttachment = c.getInt(HAS_ATTACHMENT_COLUMN); + mModifiedDate = c.getLong(MODIFIED_DATE_COLUMN); + mParentId = c.getLong(PARENT_ID_COLUMN); + mSnippet = c.getString(SNIPPET_COLUMN); + mType = c.getInt(TYPE_COLUMN); + mWidgetId = c.getInt(WIDGET_ID_COLUMN); + mWidgetType = c.getInt(WIDGET_TYPE_COLUMN); + mVersion = c.getLong(VERSION_COLUMN); + } + + /** + * 加载笔记关联的数据内容 + */ + private void loadDataContent() { + mDataList.clear(); // 清空现有数据 + // 查询关联数据 + try (Cursor c = mContentResolver.query( + Notes.CONTENT_DATA_URI, // 数据内容URI + SqlData.PROJECTION_DATA, // 数据表查询列 + "(note_id=?)", // 查询条件 + new String[]{ String.valueOf(mId) }, // 参数 + null)) { // 排序 + if (c != null) { + if (c.getCount() == 0) { + Log.w(TAG, "it seems that the note has not data"); + return; + } + // 遍历所有数据行 + while (c.moveToNext()) { + SqlData data = new SqlData(mContext, c); // 创建数据对象 + mDataList.add(data); // 添加到列表 + } + } else { + Log.w(TAG, "loadDataContent: cursor = null"); + } + } + } + + /** + * 从JSON设置笔记内容 + * @param js 包含笔记数据的JSON对象 + * @return 是否设置成功 + */ + public boolean setContent(JSONObject js) { + try { + // 获取笔记数据 + JSONObject note = js.getJSONObject(GTaskStringUtils.META_HEAD_NOTE); + + // 检查笔记类型 + if (note.getInt(NoteColumns.TYPE) == Notes.TYPE_SYSTEM) { + Log.w(TAG, "cannot set system folder"); + } + // 处理文件夹类型 + else if (note.getInt(NoteColumns.TYPE) == Notes.TYPE_FOLDER) { + // 只能更新摘要和类型 + String snippet = note.has(NoteColumns.SNIPPET) ? + note.getString(NoteColumns.SNIPPET) : ""; + if (mIsCreate || !mSnippet.equals(snippet)) { + mDiffNoteValues.put(NoteColumns.SNIPPET, snippet); + } + mSnippet = snippet; + + int type = note.has(NoteColumns.TYPE) ? + note.getInt(NoteColumns.TYPE) : Notes.TYPE_NOTE; + if (mIsCreate || mType != type) { + mDiffNoteValues.put(NoteColumns.TYPE, type); + } + mType = type; + } + // 处理普通笔记类型 + else if (note.getInt(NoteColumns.TYPE) == Notes.TYPE_NOTE) { + // 获取关联数据数组 + JSONArray dataArray = js.getJSONArray(GTaskStringUtils.META_HEAD_DATA); + + // 处理笔记ID + long id = note.has(NoteColumns.ID) ? note.getLong(NoteColumns.ID) : INVALID_ID; + if (mIsCreate || mId != id) { + mDiffNoteValues.put(NoteColumns.ID, id); + } + mId = id; + + // 处理提醒日期 + long alertDate = note.has(NoteColumns.ALERTED_DATE) ? + note.getLong(NoteColumns.ALERTED_DATE) : 0; + if (mIsCreate || mAlertDate != alertDate) { + mDiffNoteValues.put(NoteColumns.ALERTED_DATE, alertDate); + } + mAlertDate = alertDate; + + // 处理背景颜色 + int bgColorId = note.has(NoteColumns.BG_COLOR_ID) ? + note.getInt(NoteColumns.BG_COLOR_ID) : ResourceParser.getDefaultBgId(mContext); + if (mIsCreate || mBgColorId != bgColorId) { + mDiffNoteValues.put(NoteColumns.BG_COLOR_ID, bgColorId); + } + mBgColorId = bgColorId; + + // 处理创建日期 + long createDate = note.has(NoteColumns.CREATED_DATE) ? + note.getLong(NoteColumns.CREATED_DATE) : System.currentTimeMillis(); + if (mIsCreate || mCreatedDate != createDate) { + mDiffNoteValues.put(NoteColumns.CREATED_DATE, createDate); + } + mCreatedDate = createDate; + + // 处理附件标记 + int hasAttachment = note.has(NoteColumns.HAS_ATTACHMENT) ? + note.getInt(NoteColumns.HAS_ATTACHMENT) : 0; + if (mIsCreate || mHasAttachment != hasAttachment) { + mDiffNoteValues.put(NoteColumns.HAS_ATTACHMENT, hasAttachment); + } + mHasAttachment = hasAttachment; + + // 处理修改日期 + long modifiedDate = note.has(NoteColumns.MODIFIED_DATE) ? + note.getLong(NoteColumns.MODIFIED_DATE) : System.currentTimeMillis(); + if (mIsCreate || mModifiedDate != modifiedDate) { + mDiffNoteValues.put(NoteColumns.MODIFIED_DATE, modifiedDate); + } + mModifiedDate = modifiedDate; + + // 处理父笔记ID + long parentId = note.has(NoteColumns.PARENT_ID) ? + note.getLong(NoteColumns.PARENT_ID) : 0; + if (mIsCreate || mParentId != parentId) { + mDiffNoteValues.put(NoteColumns.PARENT_ID, parentId); + } + mParentId = parentId; + + // 处理内容摘要 + String snippet = note.has(NoteColumns.SNIPPET) ? + note.getString(NoteColumns.SNIPPET) : ""; + if (mIsCreate || !mSnippet.equals(snippet)) { + mDiffNoteValues.put(NoteColumns.SNIPPET, snippet); + } + mSnippet = snippet; + + // 处理笔记类型 + int type = note.has(NoteColumns.TYPE) ? + note.getInt(NoteColumns.TYPE) : Notes.TYPE_NOTE; + if (mIsCreate || mType != type) { + mDiffNoteValues.put(NoteColumns.TYPE, type); + } + mType = type; + + // 处理小部件ID + int widgetId = note.has(NoteColumns.WIDGET_ID) ? + note.getInt(NoteColumns.WIDGET_ID) : AppWidgetManager.INVALID_APPWIDGET_ID; + if (mIsCreate || mWidgetId != widgetId) { + mDiffNoteValues.put(NoteColumns.WIDGET_ID, widgetId); + } + mWidgetId = widgetId; + + // 处理小部件类型 + int widgetType = note.has(NoteColumns.WIDGET_TYPE) ? + note.getInt(NoteColumns.WIDGET_TYPE) : Notes.TYPE_WIDGET_INVALIDE; + if (mIsCreate || mWidgetType != widgetType) { + mDiffNoteValues.put(NoteColumns.WIDGET_TYPE, widgetType); + } + mWidgetType = widgetType; + + // 处理原始父笔记ID + long originParent = note.has(NoteColumns.ORIGIN_PARENT_ID) ? + note.getLong(NoteColumns.ORIGIN_PARENT_ID) : 0; + if (mIsCreate || mOriginParent != originParent) { + mDiffNoteValues.put(NoteColumns.ORIGIN_PARENT_ID, originParent); + } + mOriginParent = originParent; + + // 处理关联数据 + for (int i = 0; i < dataArray.length(); i++) { + JSONObject data = dataArray.getJSONObject(i); + SqlData sqlData = null; + + // 查找已有数据 + if (data.has(DataColumns.ID)) { + long dataId = data.getLong(DataColumns.ID); + for (SqlData temp : mDataList) { + if (dataId == temp.getId()) { + sqlData = temp; + break; + } + } + } + + // 如果不存在则创建新数据 + if (sqlData == null) { + sqlData = new SqlData(mContext); + mDataList.add(sqlData); + } + + // 设置数据内容 + sqlData.setContent(data); + } + } + } catch (JSONException e) { + Log.e(TAG, e.toString()); + e.printStackTrace(); + return false; + } + return true; + } + + /** + * 获取笔记内容的JSON表示 + * @return JSON对象，包含笔记数据 + */ + public JSONObject getContent() { + try { + JSONObject js = new JSONObject(); + + // 检查是否已创建 + if (mIsCreate) { + Log.e(TAG, "it seems that we haven't created this in database yet"); + return null; + } + + JSONObject note = new JSONObject(); + // 处理普通笔记类型 + if (mType == Notes.TYPE_NOTE) { + // 添加所有笔记字段 + note.put(NoteColumns.ID, mId); + note.put(NoteColumns.ALERTED_DATE, mAlertDate); + note.put(NoteColumns.BG_COLOR_ID, mBgColorId); + note.put(NoteColumns.CREATED_DATE, mCreatedDate); + note.put(NoteColumns.HAS_ATTACHMENT, mHasAttachment); + note.put(NoteColumns.MODIFIED_DATE, mModifiedDate); + note.put(NoteColumns.PARENT_ID, mParentId); + note.put(NoteColumns.SNIPPET, mSnippet); + note.put(NoteColumns.TYPE, mType); + note.put(NoteColumns.WIDGET_ID, mWidgetId); + note.put(NoteColumns.WIDGET_TYPE, mWidgetType); + note.put(NoteColumns.ORIGIN_PARENT_ID, mOriginParent); + js.put(GTaskStringUtils.META_HEAD_NOTE, note); + + // 处理关联数据 + JSONArray dataArray = new JSONArray(); + for (SqlData sqlData : mDataList) { + JSONObject data = sqlData.getContent(); + if (data != null) { + dataArray.put(data); + } + } + js.put(GTaskStringUtils.META_HEAD_DATA, dataArray); + } + // 处理文件夹和系统类型 + else if (mType == Notes.TYPE_FOLDER || mType == Notes.TYPE_SYSTEM) { + // 只包含必要字段 + note.put(NoteColumns.ID, mId); + note.put(NoteColumns.TYPE, mType); + note.put(NoteColumns.SNIPPET, mSnippet); + js.put(GTaskStringUtils.META_HEAD_NOTE, note); + } + + return js; + } catch (JSONException e) { + Log.e(TAG, e.toString()); + e.printStackTrace(); + } + return null; + } + + /** + * 设置父笔记ID + * @param id 父笔记ID + */ + public void setParentId(long id) { + mParentId = id; + mDiffNoteValues.put(NoteColumns.PARENT_ID, id); + } + + /** + * 设置Google任务ID + * @param gid Google任务ID + */ + public void setGtaskId(String gid) { + mDiffNoteValues.put(NoteColumns.GTASK_ID, gid); + } + + /** + * 设置同步ID + * @param syncId 同步ID + */ + public void setSyncId(long syncId) { + mDiffNoteValues.put(NoteColumns.SYNC_ID, syncId); + } + + /** + * 重置本地修改标记 + */ + public void resetLocalModified() { + mDiffNoteValues.put(NoteColumns.LOCAL_MODIFIED, 0); + } + + /** + * 获取笔记ID + * @return 笔记ID + */ + public long getId() { + return mId; + } + + /** + * 获取父笔记ID + * @return 父笔记ID + */ + public long getParentId() { + return mParentId; + } + + /** + * 获取内容摘要 + * @return 内容摘要 + */ + public String getSnippet() { + return mSnippet; + } + + /** + * 检查是否为普通笔记类型 + * @return 如果是普通笔记返回true + */ + public boolean isNoteType() { + return mType == Notes.TYPE_NOTE; + } + + /** + * 提交笔记数据到数据库 + * @param validateVersion 是否验证版本 + */ + @RequiresApi(api = Build.VERSION_CODES.R) + public void commit(boolean validateVersion) { + // 处理新建笔记 + if (mIsCreate) { + // 如果ID无效且有ID变更，移除无效ID + if (mId == INVALID_ID && mDiffNoteValues.containsKey(NoteColumns.ID)) { + mDiffNoteValues.remove(NoteColumns.ID); + } + + // 插入新笔记 + Uri uri = mContentResolver.insert(Notes.CONTENT_NOTE_URI, mDiffNoteValues); + try { + // 从返回的URI中解析出新笔记ID + mId = Long.parseLong(Objects.requireNonNull(uri).getPathSegments().get(1)); + } catch (NumberFormatException e) { + Log.e(TAG, "Get note id error :" + e.toString()); + throw new ActionFailureException("create note failed"); + } + + // 检查是否创建成功 + if (mId == 0) { + throw new IllegalStateException("Create thread id failed"); + } + + // 如果是普通笔记，提交关联数据 + if (mType == Notes.TYPE_NOTE) { + for (SqlData sqlData : mDataList) { + sqlData.commit(mId, false, -1); + } + } + } + // 处理已有笔记更新 + else { + // 检查笔记ID有效性 + if (mId <= 0 && mId != Notes.ID_ROOT_FOLDER && mId != Notes.ID_CALL_RECORD_FOLDER) { + Log.e(TAG, "No such note"); + throw new IllegalStateException("Try to update note with invalid id"); + } + + // 如果有变更值 + if (!mDiffNoteValues.isEmpty()) { + mVersion++; // 版本号递增 + int result = 0; + + // 根据是否验证版本执行不同的更新 + if (!validateVersion) { + // 普通更新 + result = mContentResolver.update( + Notes.CONTENT_NOTE_URI, + mDiffNoteValues, + "(" + NoteColumns.ID + "=?)", + new String[]{ String.valueOf(mId) } + ); + } else { + // 带版本验证的更新 + result = mContentResolver.update( + Notes.CONTENT_NOTE_URI, + mDiffNoteValues, + "(" + NoteColumns.ID + "=?) AND (" + NoteColumns.VERSION + "<=?)", + new String[]{ String.valueOf(mId), String.valueOf(mVersion) } + ); + } + + // 检查更新结果 + if (result == 0) { + Log.w(TAG, "there is no update. maybe user updates note when syncing"); + } + } + + // 如果是普通笔记，提交关联数据 + if (mType == Notes.TYPE_NOTE) { + for (SqlData sqlData : mDataList) { + sqlData.commit(mId, validateVersion, mVersion); + } + } + } + + // 刷新本地数据 + loadFromCursor(mId); + if (mType == Notes.TYPE_NOTE) + loadDataContent(); + + // 重置状态 + mDiffNoteValues.clear(); + mIsCreate = false; + } +} diff --git a/src/Date/Task.java b/src/Date/Task.java new file mode 100644 index 0000000..80afb90 --- /dev/null +++ b/src/Date/Task.java @@ -0,0 +1,454 @@ +/* + * 版权所有 (c) 2010-2011，MiCode 开源社区 (www.micode.net) + * 根据 Apache 许可证 2.0 版本（"许可证"）授权； + * 除非符合许可证的规定，否则不得使用本文件。 + * 您可以从以下网址获取许可证副本： + * http://www.apache.org/licenses/LICENSE-2.0 + * 除非适用法律要求或书面同意，本软件按"原样"分发， + * 没有任何明示或暗示的保证或条件。 + * 详见许可证中规定的权限和限制。 + * （注：这是一份标准的Apache许可证2.0版本的开源声明） + */ + +// 定义当前类所在的包路径 +package net.micode.notes.gtask.data; + +// Android数据库相关类 +import android.database.Cursor; // 数据库查询结果集 +// Android文本处理工具 +import android.text.TextUtils; // 字符串处理工具类 +// Android日志工具 +import android.util.Log; // 日志记录工具 + +// 笔记应用数据相关常量 +import androidx.annotation.NonNull; + +import net.micode.notes.data.Notes; // 笔记核心数据类 +import net.micode.notes.data.Notes.DataColumns; // 数据表列名常量 +import net.micode.notes.data.Notes.DataConstants; // 数据相关常量 +import net.micode.notes.data.Notes.NoteColumns; // 笔记表列名常量 + +// 异常处理类 +import net.micode.notes.gtask.exception.ActionFailureException; // 同步操作失败异常 + +// Google Task工具类 +import net.micode.notes.tool.GTaskStringUtils; // Google Task字符串工具 + +// JSON处理相关类 +import org.json.JSONArray; // JSON数组处理 +import org.json.JSONException; // JSON异常处理 +import org.json.JSONObject; // JSON对象处理 + +// Java工具类 +import java.util.Objects; // 对象工具类 +// Task类继承自Node基类，表示Google Task中的一个任务项 +public class Task extends Node { + // 日志标签 + private static final String TAG = Task.class.getSimpleName(); + + // 任务状态字段 + private boolean mCompleted; // 任务是否已完成 + private String mNotes; // 任务备注/描述信息 + private JSONObject mMetaInfo; // 存储元信息的JSON对象 + + // 任务关系字段 + private Task mPriorSibling; // 前一个兄弟任务（用于排序） + private TaskList mParent; // 所属任务列表 + + // 默认构造函数 + public Task() { + super(); // 调用父类构造函数 + mCompleted = false; // 默认未完成 + mNotes = null; // 默认无备注 + mPriorSibling = null; // 默认无前驱任务 + mParent = null; // 默认无父列表 + mMetaInfo = null; // 默认无元信息 + } + + /** + * 生成创建任务的JSON动作 + * @param actionId 动作ID + * @return 包含创建任务数据的JSON对象 + */ + public JSONObject getCreateAction(int actionId) { + JSONObject js = new JSONObject(); + + try { + // 设置动作类型为创建 + js.put(GTaskStringUtils.GTASK_JSON_ACTION_TYPE, + GTaskStringUtils.GTASK_JSON_ACTION_TYPE_CREATE); + + // 设置动作ID + js.put(GTaskStringUtils.GTASK_JSON_ACTION_ID, actionId); + + // 设置任务索引位置 + js.put(GTaskStringUtils.GTASK_JSON_INDEX, mParent.getChildTaskIndex(this)); + + // 构建任务实体数据 + JSONObject entity = new JSONObject(); + entity.put(GTaskStringUtils.GTASK_JSON_NAME, getName()); // 任务名称 + entity.put(GTaskStringUtils.GTASK_JSON_CREATOR_ID, "null"); // 创建者ID + entity.put(GTaskStringUtils.GTASK_JSON_ENTITY_TYPE, + GTaskStringUtils.GTASK_JSON_TYPE_TASK); // 实体类型设为任务 + // 如果有备注则添加 + if (getNotes() != null) { + entity.put(GTaskStringUtils.GTASK_JSON_NOTES, getNotes()); + } + js.put(GTaskStringUtils.GTASK_JSON_ENTITY_DELTA, entity); // 添加实体数据 + + // 设置父任务列表ID + js.put(GTaskStringUtils.GTASK_JSON_PARENT_ID, mParent.getGid()); + + // 设置目标父类型为组 + js.put(GTaskStringUtils.GTASK_JSON_DEST_PARENT_TYPE, + GTaskStringUtils.GTASK_JSON_TYPE_GROUP); + + // 设置列表ID + js.put(GTaskStringUtils.GTASK_JSON_LIST_ID, mParent.getGid()); + + // 如果有前驱任务则设置其ID + if (mPriorSibling != null) { + js.put(GTaskStringUtils.GTASK_JSON_PRIOR_SIBLING_ID, mPriorSibling.getGid()); + } + + } catch (JSONException e) { + Log.e(TAG, e.toString()); + e.printStackTrace(); + throw new ActionFailureException("生成任务创建JSON对象失败"); + } + + return js; + } + + /** + * 生成更新任务的JSON动作 + * @param actionId 动作ID + * @return 包含更新数据的JSON对象 + */ + public JSONObject getUpdateAction(int actionId) { + JSONObject js = new JSONObject(); + + try { + // 设置动作类型为更新 + js.put(GTaskStringUtils.GTASK_JSON_ACTION_TYPE, + GTaskStringUtils.GTASK_JSON_ACTION_TYPE_UPDATE); + + // 设置动作ID + js.put(GTaskStringUtils.GTASK_JSON_ACTION_ID, actionId); + + // 设置任务全局ID + js.put(GTaskStringUtils.GTASK_JSON_ID, getGid()); + + // 构建更新数据 + JSONObject entity = new JSONObject(); + entity.put(GTaskStringUtils.GTASK_JSON_NAME, getName()); // 更新名称 + // 如果有备注则更新 + if (getNotes() != null) { + entity.put(GTaskStringUtils.GTASK_JSON_NOTES, getNotes()); + } + // 设置删除状态 + entity.put(GTaskStringUtils.GTASK_JSON_DELETED, getDeleted()); + js.put(GTaskStringUtils.GTASK_JSON_ENTITY_DELTA, entity); // 添加更新数据 + + } catch (JSONException e) { + Log.e(TAG, e.toString()); + e.printStackTrace(); + throw new ActionFailureException("生成任务更新JSON对象失败"); + } + + return js; + } + + /** + * 从远程JSON数据设置任务内容 + * @param js 包含远程数据的JSON对象 + */ + public void setContentByRemoteJSON(JSONObject js) { + if (js != null) { + try { + // 设置任务ID + if (js.has(GTaskStringUtils.GTASK_JSON_ID)) { + setGid(js.getString(GTaskStringUtils.GTASK_JSON_ID)); + } + + // 设置最后修改时间 + if (js.has(GTaskStringUtils.GTASK_JSON_LAST_MODIFIED)) { + setLastModified(js.getLong(GTaskStringUtils.GTASK_JSON_LAST_MODIFIED)); + } + + // 设置任务名称 + if (js.has(GTaskStringUtils.GTASK_JSON_NAME)) { + setName(js.getString(GTaskStringUtils.GTASK_JSON_NAME)); + } + + // 设置任务备注 + if (js.has(GTaskStringUtils.GTASK_JSON_NOTES)) { + setNotes(js.getString(GTaskStringUtils.GTASK_JSON_NOTES)); + } + + // 设置删除状态 + if (js.has(GTaskStringUtils.GTASK_JSON_DELETED)) { + setDeleted(js.getBoolean(GTaskStringUtils.GTASK_JSON_DELETED)); + } + + // 设置完成状态 + if (js.has(GTaskStringUtils.GTASK_JSON_COMPLETED)) { + setCompleted(js.getBoolean(GTaskStringUtils.GTASK_JSON_COMPLETED)); + } + } catch (JSONException e) { + Log.e(TAG, e.toString()); + e.printStackTrace(); + throw new ActionFailureException("从JSON获取任务内容失败"); + } + } + } + + /** + * 从本地JSON数据设置任务内容 + * @param js 包含本地数据的JSON对象 + */ + public void setContentByLocalJSON(JSONObject js) { + // 检查数据有效性 + if (js == null || !js.has(GTaskStringUtils.META_HEAD_NOTE) + || !js.has(GTaskStringUtils.META_HEAD_DATA)) { + Log.w(TAG, "setContentByLocalJSON: 无可用数据"); + } + + try { + JSONObject note = Objects.requireNonNull(js).getJSONObject(GTaskStringUtils.META_HEAD_NOTE); + JSONArray dataArray = js.getJSONArray(GTaskStringUtils.META_HEAD_DATA); + + // 验证类型是否为普通笔记 + if (note.getInt(NoteColumns.TYPE) != Notes.TYPE_NOTE) { + Log.e(TAG, "无效的类型"); + return; + } + + // 从数据数组中查找笔记内容 + for (int i = 0; i < dataArray.length(); i++) { + JSONObject data = dataArray.getJSONObject(i); + if (TextUtils.equals(data.getString(DataColumns.MIME_TYPE), DataConstants.NOTE)) { + setName(data.getString(DataColumns.CONTENT)); // 设置任务名称 + break; + } + } + + } catch (JSONException e) { + Log.e(TAG, e.toString()); + e.printStackTrace(); + } + } + + /** + * 从任务内容生成本地JSON格式 + * @return 包含任务数据的JSON对象 + */ + public JSONObject getLocalJSONFromContent() { + String name = getName(); + try { + if (mMetaInfo == null) { + // 从网页端创建的新任务 + if (name == null) { + Log.w(TAG, "笔记内容为空"); + return null; + } + + // 构建新的JSON结构 + return getJsonObject(name); + } else { + // 已同步的任务 + JSONObject note = mMetaInfo.getJSONObject(GTaskStringUtils.META_HEAD_NOTE); + JSONArray dataArray = mMetaInfo.getJSONArray(GTaskStringUtils.META_HEAD_DATA); + + // 更新笔记内容 + for (int i = 0; i < dataArray.length(); i++) { + JSONObject data = dataArray.getJSONObject(i); + if (TextUtils.equals(data.getString(DataColumns.MIME_TYPE), DataConstants.NOTE)) { + data.put(DataColumns.CONTENT, getName()); + break; + } + } + + note.put(NoteColumns.TYPE, Notes.TYPE_NOTE); // 确保类型正确 + return mMetaInfo; // 返回修改后的元信息 + } + } catch (JSONException e) { + Log.e(TAG, e.toString()); + e.printStackTrace(); + return null; + } + } + + @NonNull + private static JSONObject getJsonObject(String name) throws JSONException { + JSONObject js = new JSONObject(); + JSONObject note = new JSONObject(); + JSONArray dataArray = new JSONArray(); + JSONObject data = new JSONObject(); + data.put(DataColumns.CONTENT, name); // 设置内容 + dataArray.put(data); + js.put(GTaskStringUtils.META_HEAD_DATA, dataArray); // 添加数据数组 + note.put(NoteColumns.TYPE, Notes.TYPE_NOTE); // 设置类型 + js.put(GTaskStringUtils.META_HEAD_NOTE, note); // 添加笔记头 + return js; + } + + /** + * 设置任务元信息 + * @param metaData 元数据对象 + */ + public void setMetaInfo(MetaData metaData) { + if (metaData != null && metaData.getNotes() != null) { + try { + // 将元数据中的notes字符串转换为JSON对象 + mMetaInfo = new JSONObject(metaData.getNotes()); + } catch (JSONException e) { + Log.w(TAG, e.toString()); + mMetaInfo = null; + } + } + } + + /** + * 获取同步动作类型 + * @param c 数据库Cursor + * @return 同步动作常量 + */ + public int getSyncAction(Cursor c) { + try { + JSONObject noteInfo = null; + // 检查元信息中是否有笔记头 + if (mMetaInfo != null && mMetaInfo.has(GTaskStringUtils.META_HEAD_NOTE)) { + noteInfo = mMetaInfo.getJSONObject(GTaskStringUtils.META_HEAD_NOTE); + } + + if (noteInfo == null) { + Log.w(TAG, "笔记元信息似乎已被删除"); + return SYNC_ACTION_UPDATE_REMOTE; // 需要从远程更新 + } + + if (!noteInfo.has(NoteColumns.ID)) { + Log.w(TAG, "远程笔记ID似乎已被删除"); + return SYNC_ACTION_UPDATE_LOCAL; // 需要更新本地 + } + + // 验证笔记ID是否匹配 + if (c.getLong(SqlNote.ID_COLUMN) != noteInfo.getLong(NoteColumns.ID)) { + Log.w(TAG, "笔记ID不匹配"); + return SYNC_ACTION_UPDATE_LOCAL; + } + + if (c.getInt(SqlNote.LOCAL_MODIFIED_COLUMN) == 0) { + // 本地无修改 + if (c.getLong(SqlNote.SYNC_ID_COLUMN) == getLastModified()) { + // 双方都无更新 + return SYNC_ACTION_NONE; + } else { + // 应用远程修改到本地 + return SYNC_ACTION_UPDATE_LOCAL; + } + } else { + // 验证任务ID是否匹配 + if (!c.getString(SqlNote.GTASK_ID_COLUMN).equals(getGid())) { + Log.e(TAG, "任务ID不匹配"); + return SYNC_ACTION_ERROR; + } + if (c.getLong(SqlNote.SYNC_ID_COLUMN) == getLastModified()) { + // 仅本地有修改 + return SYNC_ACTION_UPDATE_REMOTE; + } else { + // 存在冲突 + return SYNC_ACTION_UPDATE_CONFLICT; + } + } + } catch (Exception e) { + Log.e(TAG, e.toString()); + e.printStackTrace(); + } + + return SYNC_ACTION_ERROR; // 默认返回错误 + } + + /* + * 检查任务是否值得保存 + * @return 如果有有效数据返回true + */ + /** + * 检查当前任务对象是否包含有效数据，值得保存 + * 满足以下任一条件即认为值得保存： + * 1. 存在元信息数据 或 + * 2. 任务名称非空且不为纯空格 或 + * 3. 任务备注非空且不为纯空格 + * + * @return 如果包含有效数据返回true，否则false + */ + public boolean isWorthSaving() { + return mMetaInfo != null || // 存在元信息 + (getName() != null && !getName().trim().isEmpty()) || // 有有效名称 + (getNotes() != null && !getNotes().trim().isEmpty()); // 有有效备注 + } + + /** + * 设置任务完成状态 + * @param completed true表示任务已完成，false表示未完成 + */ + public void setCompleted(boolean completed) { + this.mCompleted = completed; // 更新完成状态字段 + } + + /** + * 设置任务备注内容 + * @param notes 要设置的备注文本，可为null表示清空备注 + */ + public void setNotes(String notes) { + this.mNotes = notes; // 更新备注字段 + } + + /** + * 设置前驱任务（用于任务排序） + * @param priorSibling 前一个任务节点，可为null表示没有前驱 + */ + public void setPriorSibling(Task priorSibling) { + this.mPriorSibling = priorSibling; // 更新前驱任务引用 + } + + /** + * 设置所属任务列表 + * @param parent 父任务列表对象，不可为null + */ + public void setParent(TaskList parent) { + this.mParent = parent; // 更新父列表引用 + } + + /** + * 获取任务完成状态 + * @return true表示任务已完成，false表示未完成 + */ + public boolean getCompleted() { + return this.mCompleted; // 返回当前完成状态 + } + + /** + * 获取任务备注内容 + * @return 备注文本，可能为null表示无备注 + */ + public String getNotes() { + return this.mNotes; // 返回当前备注内容 + } + + /** + * 获取前驱任务（用于任务排序） + * @return 前一个任务节点，可能为null表示没有前驱 + */ + public Task getPriorSibling() { + return this.mPriorSibling; // 返回前驱任务引用 + } + + /** + * 获取所属任务列表 + * @return 父任务列表对象 + */ + public TaskList getParent() { + return this.mParent; // 返回父列表引用 + } +} \ No newline at end of file diff --git a/src/Date/TaskList.java b/src/Date/TaskList.java new file mode 100644 index 0000000..27db52b --- /dev/null +++ b/src/Date/TaskList.java @@ -0,0 +1,435 @@ +/* + * 版权所有 (c) 2010-2011，MiCode 开源社区 (www.micode.net) + * 根据 Apache 许可证 2.0 版本（"许可证"）授权； + * 除非符合许可证的规定，否则不得使用本文件。 + * 您可以从以下网址获取许可证副本： + * http://www.apache.org/licenses/LICENSE-2.0 + * 除非适用法律要求或书面同意，本软件按"原样"分发， + * 没有任何明示或暗示的保证或条件。 + * 详见许可证中规定的权限和限制。 + * （注：这是一份标准的Apache许可证2.0版本的开源声明） + */ +// 声明当前类所在的包路径，属于笔记应用的Google任务数据模块 +package net.micode.notes.gtask.data; +// 导入Android数据库相关类 +import android.database.Cursor; // 用于操作和遍历数据库查询结果集 +import android.util.Log; // Android日志工具类 +// 导入笔记应用的核心数据类 +import net.micode.notes.data.Notes; // 笔记数据常量类 +import net.micode.notes.data.Notes.NoteColumns; // 笔记表列名常量 +// 导入异常处理类 +import net.micode.notes.gtask.exception.ActionFailureException; +// 当Google任务操作失败时抛出的自定义异常 +// 导入Google任务字符串处理工具类 +import net.micode.notes.tool.GTaskStringUtils; +// 包含Google任务API使用的JSON键名常量 +// 导入JSON处理相关类 +import org.json.JSONException; // JSON解析异常类 +import org.json.JSONObject; // JSON对象操作类 +// 导入Java工具类 +import java.util.ArrayList; // 动态数组集合 +import java.util.Objects; // 对象操作工具类（判空等） +// 继承自Node基类，表示Google Tasks中的任务列表 +public class TaskList extends Node { + // 日志标签，使用类名作为标识 + private static final String TAG = TaskList.class.getSimpleName(); + // 任务列表的排序索引 + private int mIndex; + // 存储子任务的动态数组 + private final ArrayList mChildren; + // 构造函数 + public TaskList() { + super(); // 调用父类Node的构造函数 + mChildren = new ArrayList<>(); // 初始化子任务列表 + mIndex = 1; // 默认索引从1开始 + } + /** + * 生成创建任务列表的JSON动作 + * @param actionId 动作ID（用于标识操作序列） + * @return 包含创建命令的JSON对象 + * @throws ActionFailureException 当JSON操作失败时抛出 + */ + public JSONObject getCreateAction(int actionId) { + JSONObject js = new JSONObject(); + + try { + // 设置动作类型为"create" + js.put(GTaskStringUtils.GTASK_JSON_ACTION_TYPE, + GTaskStringUtils.GTASK_JSON_ACTION_TYPE_CREATE); + + // 设置动作ID + js.put(GTaskStringUtils.GTASK_JSON_ACTION_ID, actionId); + + // 设置任务列表索引 + js.put(GTaskStringUtils.GTASK_JSON_INDEX, mIndex); + + // 构建实体数据对象 + JSONObject entity = new JSONObject(); + entity.put(GTaskStringUtils.GTASK_JSON_NAME, getName()); // 列表名称 + entity.put(GTaskStringUtils.GTASK_JSON_CREATOR_ID, "null"); // 创建者ID + entity.put(GTaskStringUtils.GTASK_JSON_ENTITY_TYPE, + GTaskStringUtils.GTASK_JSON_TYPE_GROUP); // 实体类型设为"group" + js.put(GTaskStringUtils.GTASK_JSON_ENTITY_DELTA, entity); // 添加实体数据 + + } catch (JSONException e) { + Log.e(TAG, e.toString()); + e.printStackTrace(); + throw new ActionFailureException("生成任务列表创建JSON失败"); + } + + return js; + } + + /** + * 生成更新任务列表的JSON动作 + * @param actionId 动作ID + * @return 包含更新命令的JSON对象 + */ + public JSONObject getUpdateAction(int actionId) { + JSONObject js = new JSONObject(); + + try { + // 设置动作类型为"update" + js.put(GTaskStringUtils.GTASK_JSON_ACTION_TYPE, + GTaskStringUtils.GTASK_JSON_ACTION_TYPE_UPDATE); + + // 设置动作ID + js.put(GTaskStringUtils.GTASK_JSON_ACTION_ID, actionId); + + // 设置任务列表全局ID + js.put(GTaskStringUtils.GTASK_JSON_ID, getGid()); + + // 构建更新数据对象 + JSONObject entity = new JSONObject(); + entity.put(GTaskStringUtils.GTASK_JSON_NAME, getName()); // 更新名称 + entity.put(GTaskStringUtils.GTASK_JSON_DELETED, getDeleted()); // 删除状态 + js.put(GTaskStringUtils.GTASK_JSON_ENTITY_DELTA, entity); // 添加更新数据 + + } catch (JSONException e) { + Log.e(TAG, e.toString()); + e.printStackTrace(); + throw new ActionFailureException("生成任务列表更新JSON失败"); + } + + return js; + } + + /** + * 从远程JSON数据设置任务列表内容 + * @param js 包含远程数据的JSON对象 + * @throws ActionFailureException 当JSON解析失败时抛出 + */ + public void setContentByRemoteJSON(JSONObject js) { + if (js != null) { + try { + // 设置任务列表ID + if (js.has(GTaskStringUtils.GTASK_JSON_ID)) { + setGid(js.getString(GTaskStringUtils.GTASK_JSON_ID)); + } + + // 设置最后修改时间戳 + if (js.has(GTaskStringUtils.GTASK_JSON_LAST_MODIFIED)) { + setLastModified(js.getLong(GTaskStringUtils.GTASK_JSON_LAST_MODIFIED)); + } + + // 设置任务列表名称 + if (js.has(GTaskStringUtils.GTASK_JSON_NAME)) { + setName(js.getString(GTaskStringUtils.GTASK_JSON_NAME)); + } + + } catch (JSONException e) { + Log.e(TAG, e.toString()); + e.printStackTrace(); + throw new ActionFailureException("从JSON解析任务列表内容失败"); + } + } + } + + /** + * 从本地JSON数据设置任务列表内容 + * @param js 包含本地数据的JSON对象 + */ + public void setContentByLocalJSON(JSONObject js) { + // 检查数据有效性 + if (js == null || !js.has(GTaskStringUtils.META_HEAD_NOTE)) { + Log.w(TAG, "setContentByLocalJSON: 无可用数据"); + return; + } + + try { + JSONObject folder = Objects.requireNonNull(js).getJSONObject(GTaskStringUtils.META_HEAD_NOTE); + + // 处理文件夹类型 + if (folder.getInt(NoteColumns.TYPE) == Notes.TYPE_FOLDER) { + String name = folder.getString(NoteColumns.SNIPPET); + setName(GTaskStringUtils.MIUI_FOLDER_PREFFIX + name); // 添加MIUI前缀 + } + // 处理系统文件夹类型 + else if (folder.getInt(NoteColumns.TYPE) == Notes.TYPE_SYSTEM) { + if (folder.getLong(NoteColumns.ID) == Notes.ID_ROOT_FOLDER) { + setName(GTaskStringUtils.MIUI_FOLDER_PREFFIX + GTaskStringUtils.FOLDER_DEFAULT); + } else if (folder.getLong(NoteColumns.ID) == Notes.ID_CALL_RECORD_FOLDER) { + setName(GTaskStringUtils.MIUI_FOLDER_PREFFIX + GTaskStringUtils.FOLDER_CALL_NOTE); + } else { + Log.e(TAG, "无效的系统文件夹"); + } + } else { + Log.e(TAG, "错误的类型"); + } + } catch (JSONException e) { + Log.e(TAG, e.toString()); + e.printStackTrace(); + } + } + + /** + * 从任务列表内容生成本地JSON格式 + * @return 包含任务列表数据的JSON对象，失败返回null + */ + public JSONObject getLocalJSONFromContent() { + try { + JSONObject js = new JSONObject(); + JSONObject folder = new JSONObject(); + + // 处理文件夹名称（移除MIUI前缀） + String folderName = getName(); + if (getName().startsWith(GTaskStringUtils.MIUI_FOLDER_PREFFIX)) { + folderName = folderName.substring(GTaskStringUtils.MIUI_FOLDER_PREFFIX.length()); + } + + // 设置文件夹基本属性 + folder.put(NoteColumns.SNIPPET, folderName); + + // 设置文件夹类型 + if (folderName.equals(GTaskStringUtils.FOLDER_DEFAULT) || + folderName.equals(GTaskStringUtils.FOLDER_CALL_NOTE)) { + folder.put(NoteColumns.TYPE, Notes.TYPE_SYSTEM); // 系统文件夹 + } else { + folder.put(NoteColumns.TYPE, Notes.TYPE_FOLDER); // 普通文件夹 + } + + js.put(GTaskStringUtils.META_HEAD_NOTE, folder); + return js; + + } catch (JSONException e) { + Log.e(TAG, e.toString()); + e.printStackTrace(); + return null; + } + } + + /** + * 获取同步动作类型 + * @param c 数据库Cursor对象，包含本地数据 + * @return 同步动作常量（SYNC_ACTION_*） + */ + public int getSyncAction(Cursor c) { + try { + // 检查本地是否有修改 + if (c.getInt(SqlNote.LOCAL_MODIFIED_COLUMN) == 0) { + // 无本地修改时 + if (c.getLong(SqlNote.SYNC_ID_COLUMN) == getLastModified()) { + return SYNC_ACTION_NONE; // 双方数据一致 + } else { + return SYNC_ACTION_UPDATE_LOCAL; // 需要更新本地 + } + } else { + // 有本地修改时验证任务ID + if (!c.getString(SqlNote.GTASK_ID_COLUMN).equals(getGid())) { + Log.e(TAG, "任务ID不匹配"); + return SYNC_ACTION_ERROR; + } + return SYNC_ACTION_UPDATE_REMOTE; // 需要更新远程 + } + } catch (Exception e) { + Log.e(TAG, e.toString()); + e.printStackTrace(); + } + return SYNC_ACTION_ERROR; // 默认返回错误 + } + + // 以下是子任务管理方法 + + /** + * 获取子任务数量 + * @return 当前子任务总数 + */ + public int getChildTaskCount() { + return mChildren.size(); + } + + /** + * 添加子任务到列表末尾 + * @param task 要添加的子任务 + * @return 是否添加成功 + */ + public boolean addChildTask(Task task) { + boolean ret = false; + if (task != null && !mChildren.contains(task)) { + ret = mChildren.add(task); + if (ret) { + // 设置前驱任务和父列表 + task.setPriorSibling(mChildren.get(mChildren.size() - 1)); + task.setParent(this); + } + } + return ret; + } + + /** + * 在指定位置添加子任务 + * @param task 要添加的子任务 + * @param index 插入位置 + * @return 是否添加成功 + */ + public boolean addChildTask(Task task, int index) { + // 检查索引有效性 + if (index < 0 || index > mChildren.size()) { + Log.e(TAG, "添加子任务：无效的索引"); + return false; + } + + // 检查任务是否已存在 + int pos = mChildren.indexOf(task); + if (task != null && pos == -1) { + mChildren.add(index, task); + + // 更新任务链关系 + Task preTask = (index != 0) ? mChildren.get(index - 1) : null; + Task afterTask = (index != mChildren.size() - 1) ? mChildren.get(index + 1) : null; + + task.setPriorSibling(preTask); + if (afterTask != null) { + afterTask.setPriorSibling(task); + } + } + + return true; + } + + /** + * 移除指定子任务 + * @param task 要移除的子任务 + * @return 是否移除成功 + */ + public boolean removeChildTask(Task task) { + boolean ret = false; + int index = mChildren.indexOf(task); + if (index != -1) { + ret = mChildren.remove(task); + + if (ret) { + // 重置被移除任务的关系 + task.setPriorSibling(null); + task.setParent(null); + + // 更新剩余任务的关系 + if (index < mChildren.size()) { + mChildren.get(index).setPriorSibling( + (index == 0) ? null : mChildren.get(index - 1)); + } + } + } + return ret; + } + + /** + * 移动子任务到新位置 + * @param task 要移动的子任务 + * @param index 目标位置 + * @return 是否移动成功 + */ + public boolean moveChildTask(Task task, int index) { + // 检查索引有效性 + if (index < 0 || index >= mChildren.size()) { + Log.e(TAG, "移动子任务：无效的索引"); + return false; + } + + int pos = mChildren.indexOf(task); + if (pos == -1) { + Log.e(TAG, "移动子任务：任务不在列表中"); + return false; + } + + if (pos == index) { + return true; // 位置未改变 + } + + // 先移除再添加实现移动 + return (removeChildTask(task) && addChildTask(task, index)); + } + + // 以下是查询方法 + + /** + * 通过GID查找子任务 + * @param gid 要查找的任务全局ID + * @return 找到的任务对象，未找到返回null + */ + public Task findChildTaskByGid(String gid) { + for (Task t : mChildren) { + if (t.getGid().equals(gid)) { + return t; + } + } + return null; + } + + /** + * 获取子任务索引 + * @param task 要查询的子任务 + * @return 索引位置，不存在返回-1 + */ + public int getChildTaskIndex(Task task) { + return mChildren.indexOf(task); + } + + /** + * 通过索引获取子任务 + * @param index 要获取的索引 + * @return 子任务对象，索引无效返回null + */ + public Task getChildTaskByIndex(int index) { + if (index < 0 || index >= mChildren.size()) { + Log.e(TAG, "getTaskByIndex: 无效的索引"); + return null; + } + return mChildren.get(index); + } + + /** + * 通过GID获取子任务（别名方法） + * @param gid 要查找的任务全局ID + * @return 找到的任务对象，未找到返回null + */ + public Task getChilTaskByGid(String gid) { + return findChildTaskByGid(gid); + } + + /** + * 获取所有子任务列表 + * @return 子任务ArrayList（注意：返回的是引用） + */ + public ArrayList getChildTaskList() { + return this.mChildren; + } + + // 以下是索引属性的getter/setter + + /** + * 设置任务列表索引 + * @param index 新的索引值 + */ + public void setIndex(int index) { + this.mIndex = index; + } + + /** + * 获取当前索引 + * @return 当前索引值 + */ + public int getIndex() { + return this.mIndex; + } +} diff --git a/src/model/Note.java b/src/model/Note.java new file mode 100644 index 0000000..a6571bc --- /dev/null +++ b/src/model/Note.java @@ -0,0 +1,268 @@ +/* + * 便签数据模型类，处理便签的创建、更新及数据同步到数据库的操作 + */ +package net.micode.notes.model; + +import android.content.ContentProviderOperation; +import android.content.ContentProviderResult; +import android.content.ContentUris; +import android.content.ContentValues; +import android.content.Context; +import android.content.OperationApplicationException; +import android.net.Uri; +import android.os.RemoteException; +import android.util.Log; + +import net.micode.notes.data.Notes; +import net.micode.notes.data.Notes.CallNote; +import net.micode.notes.data.Notes.DataColumns; +import net.micode.notes.data.Notes.NoteColumns; +import net.micode.notes.data.Notes.TextNote; + +import java.util.ArrayList; + +public class Note { + // 存储便签元数据变化的键值对（如修改时间、父目录等） + private ContentValues mNoteDiffValues; + // 处理便签具体数据内容（文本、通话记录等） + private NoteData mNoteData; + // 日志标签 + private static final String TAG = "Note"; + + /** + * 在指定文件夹下创建新便签并返回其ID + * @param context 上下文对象 + * @param folderId 父文件夹ID + * @return 新创建的便签ID（大于0） + * @throws IllegalStateException 若插入失败返回-1时抛出 + */ + public static synchronized long getNewNoteId(Context context, long folderId) { + ContentValues values = new ContentValues(); + long createdTime = System.currentTimeMillis(); + // 设置基本属性 + values.put(NoteColumns.CREATED_DATE, createdTime); + values.put(NoteColumns.MODIFIED_DATE, createdTime); + values.put(NoteColumns.TYPE, Notes.TYPE_NOTE); + values.put(NoteColumns.LOCAL_MODIFIED, 1); // 标记为本地已修改 + values.put(NoteColumns.PARENT_ID, folderId); + + // 插入新便签到数据库 + Uri uri = context.getContentResolver().insert(Notes.CONTENT_NOTE_URI, values); + + // 解析返回的URI获取便签ID + long noteId = 0; + try { + noteId = Long.parseLong(uri.getPathSegments().get(1)); + } catch (NumberFormatException e) { + Log.e(TAG, "解析便签ID异常: " + e); + noteId = 0; + } + if (noteId == -1) { + throw new IllegalStateException("无效的便签ID: " + noteId); + } + return noteId; + } + + /** + * 构造函数，初始化数据存储对象 + */ + public Note() { + mNoteDiffValues = new ContentValues(); + mNoteData = new NoteData(); + } + + /** + * 设置便签元数据字段值 + * @param key 字段名（NoteColumns中的常量） + * @param value 要设置的值 + */ + public void setNoteValue(String key, String value) { + mNoteDiffValues.put(key, value); + // 标记为已修改并更新修改时间 + mNoteDiffValues.put(NoteColumns.LOCAL_MODIFIED, 1); + mNoteDiffValues.put(NoteColumns.MODIFIED_DATE, System.currentTimeMillis()); + } + + // 文本数据相关方法组 + public void setTextData(String key, String value) { + mNoteData.setTextData(key, value); + } + public void setTextDataId(long id) { + mNoteData.setTextDataId(id); + } + public long getTextDataId() { + return mNoteData.mTextDataId; + } + + // 通话数据相关方法组 + public void setCallDataId(long id) { + mNoteData.setCallDataId(id); + } + public void setCallData(String key, String value) { + mNoteData.setCallData(key, value); + } + + /** + * 检查便签是否有本地修改 + * @return true表示存在未同步的修改 + */ + public boolean isLocalModified() { + return mNoteDiffValues.size() > 0 || mNoteData.isLocalModified(); + } + + /** + * 将便签修改同步到数据库 + * @param context 上下文对象 + * @param noteId 要同步的便签ID + * @return true表示同步成功 + * @throws IllegalArgumentException 如果noteId不合法 + */ + public boolean syncNote(Context context, long noteId) { + if (noteId <= 0) { + throw new IllegalArgumentException("无效便签ID: " + noteId); + } + + if (!isLocalModified()) { + return true; // 无修改直接返回成功 + } + + // 先更新便签元数据 + if (context.getContentResolver().update( + ContentUris.withAppendedId(Notes.CONTENT_NOTE_URI, noteId), + mNoteDiffValues, null, null) == 0) { + Log.e(TAG, "便签元数据更新失败"); + } + mNoteDiffValues.clear(); + + // 再同步具体数据内容 + if (mNoteData.isLocalModified() && + (mNoteData.pushIntoContentResolver(context, noteId) == null)) { + return false; + } + + return true; + } + + /** + * 内部类，处理便签具体数据（文本/通话记录）的存储 + */ + private class NoteData { + private long mTextDataId; // 文本数据项ID + private ContentValues mTextDataValues; // 文本数据修改 + private long mCallDataId; // 通话数据项ID + private ContentValues mCallDataValues; // 通话数据修改 + private static final String TAG = "NoteData"; + + public NoteData() { + mTextDataValues = new ContentValues(); + mCallDataValues = new ContentValues(); + mTextDataId = 0; + mCallDataId = 0; + } + + /** + * 检查数据是否有本地修改 + */ + boolean isLocalModified() { + return mTextDataValues.size() > 0 || mCallDataValues.size() > 0; + } + + // 文本数据设置方法组 + void setTextDataId(long id) { + if (id <= 0) throw new IllegalArgumentException("文本数据ID必须大于0"); + mTextDataId = id; + } + void setTextData(String key, String value) { + mTextDataValues.put(key, value); + // 触发便签元数据修改标记 + mNoteDiffValues.put(NoteColumns.LOCAL_MODIFIED, 1); + mNoteDiffValues.put(NoteColumns.MODIFIED_DATE, System.currentTimeMillis()); + } + + // 通话数据设置方法组 + void setCallDataId(long id) { + if (id <= 0) throw new IllegalArgumentException("通话数据ID必须大于0"); + mCallDataId = id; + } + void setCallData(String key, String value) { + mCallDataValues.put(key, value); + // 触发便签元数据修改标记 + mNoteDiffValues.put(NoteColumns.LOCAL_MODIFIED, 1); + mNoteDiffValues.put(NoteColumns.MODIFIED_DATE, System.currentTimeMillis()); + } + + /** + * 将数据修改推送到数据库 + * @param context 上下文对象 + * @param noteId 所属便签ID + * @return 操作结果的URI，失败返回null + */ + Uri pushIntoContentResolver(Context context, long noteId) { + if (noteId <= 0) throw new IllegalArgumentException("无效便签ID: " + noteId); + + ArrayList operationList = new ArrayList<>(); + + // 处理文本数据 + if (mTextDataValues.size() > 0) { + mTextDataValues.put(DataColumns.NOTE_ID, noteId); + if (mTextDataId == 0) { // 新数据：插入 + mTextDataValues.put(DataColumns.MIME_TYPE, TextNote.CONTENT_ITEM_TYPE); + Uri uri = context.getContentResolver().insert( + Notes.CONTENT_DATA_URI, mTextDataValues); + try { + setTextDataId(Long.parseLong(uri.getPathSegments().get(1))); + } catch (NumberFormatException e) { + Log.e(TAG, "插入文本数据失败，便签ID：" + noteId); + mTextDataValues.clear(); + return null; + } + } else { // 现有数据：更新 + ContentProviderOperation.Builder builder = ContentProviderOperation + .newUpdate(ContentUris.withAppendedId( + Notes.CONTENT_DATA_URI, mTextDataId)) + .withValues(mTextDataValues); + operationList.add(builder.build()); + } + mTextDataValues.clear(); + } + + // 处理通话数据（逻辑同上） + if (mCallDataValues.size() > 0) { + mCallDataValues.put(DataColumns.NOTE_ID, noteId); + if (mCallDataId == 0) { + mCallDataValues.put(DataColumns.MIME_TYPE, CallNote.CONTENT_ITEM_TYPE); + Uri uri = context.getContentResolver().insert( + Notes.CONTENT_DATA_URI, mCallDataValues); + try { + setCallDataId(Long.parseLong(uri.getPathSegments().get(1))); + } catch (NumberFormatException e) { + Log.e(TAG, "插入通话数据失败，便签ID：" + noteId); + mCallDataValues.clear(); + return null; + } + } else { + ContentProviderOperation.Builder builder = ContentProviderOperation + .newUpdate(ContentUris.withAppendedId( + Notes.CONTENT_DATA_URI, mCallDataId)) + .withValues(mCallDataValues); + operationList.add(builder.build()); + } + mCallDataValues.clear(); + } + + // 执行批量操作 + if (!operationList.isEmpty()) { + try { + ContentProviderResult[] results = context.getContentResolver() + .applyBatch(Notes.AUTHORITY, operationList); + return (results != null && results.length > 0) ? + ContentUris.withAppendedId(Notes.CONTENT_NOTE_URI, noteId) : null; + } catch (RemoteException | OperationApplicationException e) { + Log.e(TAG, "批量操作异常: " + e.getMessage()); + return null; + } + } + return null; + } + } +} \ No newline at end of file diff --git a/src/model/WorkingNote.java b/src/model/WorkingNote.java new file mode 100644 index 0000000..1133faf --- /dev/null +++ b/src/model/WorkingNote.java @@ -0,0 +1,132 @@ +/** + * WorkingNote 类 - 笔记核心业务逻辑处理模块 + * + * 功能概述： + * 本类负责处理笔记的创建、加载、保存及属性管理，作为笔记数据与UI组件间的桥梁。 + * 支持文本笔记、通话记录笔记两种类型，集成小部件关联和提醒功能。 + */ + +public class WorkingNote { + // 核心成员变量说明 + private Note mNote; // 数据库实体对象，处理CRUD操作 + private long mNoteId; // 当前笔记在数据库中的唯一标识 + private String mContent; // 笔记正文内容（Markdown或纯文本） + private int mMode; // 笔记模式 0-普通模式 1-清单模式 + private long mAlertDate; // 提醒时间戳（毫秒级） + private int mBgColorId; // 背景颜色资源索引（关联NoteBgResources） + private int mWidgetId; // 关联的小部件ID（AppWidgetManager分配） + private int mWidgetType; // 小部件类型（见Notes.TYPE_WIDGET_*） + private Context mContext; // 应用上下文（用于访问ContentResolver） + + /** + * 数据表查询投影（处理笔记元数据） + * 字段顺序对应NOTE_PARENT_ID_COLUMN等索引常量 + */ + public static final String[] NOTE_PROJECTION = new String[] { + NoteColumns.PARENT_ID, // 所属文件夹ID + NoteColumns.ALERTED_DATE, // 激活的提醒时间 + NoteColumns.BG_COLOR_ID, // 背景色标识 + NoteColumns.WIDGET_ID, // 绑定的小部件ID + NoteColumns.WIDGET_TYPE, // 小部件类型 + NoteColumns.MODIFIED_DATE // 最后修改时间 + }; + + /** + * 私有构造函数 - 新建笔记初始化 + * @param context 应用上下文 + * @param folderId 所属文件夹ID（见Notes.ID_*常量） + */ + private WorkingNote(Context context, long folderId) { + // 初始化时间相关字段 + mModifiedDate = System.currentTimeMillis(); // 设置创建时间为当前系统时间 + // 设置默认值 + mWidgetType = Notes.TYPE_WIDGET_INVALIDE; // 初始化为无效小部件类型 + } + + /** + * 核心保存逻辑 + * @return 保存成功返回true，否则false + * + * 执行流程： + * 1. 有效性检测（通过isWorthSaving） + * 2. 新笔记生成数据库ID + * 3. 通过Note对象同步数据到数据库 + * 4. 触发小部件更新（若关联有效小部件） + */ + public synchronized boolean saveNote() { + if (!isWorthSaving()) return false; + + // 生成新笔记ID（仅当不存在数据库时） + if (!existInDatabase()) { + mNoteId = Note.getNewNoteId(mContext, mFolderId); + } + + // 数据同步到数据库 + mNote.syncNote(mContext, mNoteId); + + // 小部件更新回调 + if (isValidWidget()) { + mNoteSettingStatusListener.onWidgetChanged(); + } + return true; + } + + /** + * 设置提醒时间（带监听回调） + * @param date 时间戳（单位毫秒） + * @param set 是否激活提醒（true-设置/false-取消） + */ + public void setAlertDate(long date, boolean set) { + if (date != mAlertDate) { + mNote.setNoteValue(NoteColumns.ALERTED_DATE, String.valueOf(date)); + } + // 触发UI更新 + if (mNoteSettingStatusListener != null) { + mNoteSettingStatusListener.onClockAlertChanged(date, set); + } + } + + /** + * 转换笔记为通话记录类型 + * @param phoneNumber 通话号码（需符合E.164格式） + * @param callDate 通话时间戳（单位毫秒） + * + * 实现逻辑： + * 1. 设置通话元数据（时间、号码） + * 2. 变更父文件夹到通话记录专用目录 + */ + public void convertToCallNote(String phoneNumber, long callDate) { + mNote.setCallData(CallNote.CALL_DATE, String.valueOf(callDate)); + mNote.setCallData(CallNote.PHONE_NUMBER, phoneNumber); + mNote.setNoteValue(NoteColumns.PARENT_ID, + String.valueOf(Notes.ID_CALL_RECORD_FOLDER)); + } + + //--------------- 工具方法 --------------- + /** 判断是否需要保存（防止无效存储） */ + private boolean isWorthSaving() { + return !mIsDeleted + && (existInDatabase() ? mNote.isLocalModified() : !TextUtils.isEmpty(mContent)); + } + + /** 验证小部件关联有效性 */ + private boolean isValidWidget() { + return mWidgetId != AppWidgetManager.INVALID_APPWIDGET_ID + && mWidgetType != Notes.TYPE_WIDGET_INVALIDE; + } + + /** + * 笔记设置变更监听接口 + * 功能：桥接业务逻辑层与UI层的双向通信 + */ + public interface NoteSettingChangedListener { + /** 背景色变更时触发（需要更新预览） */ + void onBackgroundColorChanged(); + + /** 清单模式切换时触发（需要重渲染编辑器） */ + void onCheckListModeChanged(int oldMode, int newMode); + + /** 小部件内容更新时触发（需刷新小部件视图） */ + void onWidgetChanged(); + } +} \ No newline at end of file