From 8fd5888b11e2bf3b4dab45f9a8296a740db74330 Mon Sep 17 00:00:00 2001 From: lj <2689605330@qq.com> Date: Sat, 21 Dec 2024 14:31:36 +0800 Subject: [PATCH] =?UTF-8?q?=E4=BB=A3=E7=A0=81=E6=B3=A8=E9=87=8A?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- 作业10.txt | 354 ++++++++++++++++++++++++++++++++++ 作业11.txt | 36 ++++ 作业12txt.txt | 36 ++++ 作业2.txt | 171 +++++++++++++++++ 作业3.txt | 324 +++++++++++++++++++++++++++++++ 作业4.txt | 221 ++++++++++++++++++++++ 作业5.txt | 86 +++++++++ 作业6.txt | 109 +++++++++++ 作业7.txt | 179 ++++++++++++++++++ 作业8.txt | 493 ++++++++++++++++++++++++++++++++++++++++++++++++ 作业9.txt | 345 +++++++++++++++++++++++++++++++++ 11 files changed, 2354 insertions(+) create mode 100644 作业10.txt create mode 100644 作业11.txt create mode 100644 作业12txt.txt create mode 100644 作业2.txt create mode 100644 作业3.txt create mode 100644 作业4.txt create mode 100644 作业5.txt create mode 100644 作业6.txt create mode 100644 作业7.txt create mode 100644 作业8.txt create mode 100644 作业9.txt diff --git a/作业10.txt b/作业10.txt new file mode 100644 index 0000000..9489e40 --- /dev/null +++ b/作业10.txt @@ -0,0 +1,354 @@ +// 导入必要的包和类 +package net.micode.notes.gtask.data; + +import android.database.Cursor; +import android.util.Log; + +import net.micode.notes.data.Notes; +import net.micode.notes.data.Notes.NoteColumns; +import net.micode.notes.gtask.exception.ActionFailureException; +import net.micode.notes.tool.GTaskStringUtils; + +import org.json.JSONException; +import org.json.JSONObject; + +import java.util.ArrayList; + +// 定义TaskList类，继承自Node类 +public class TaskList extends Node { + // 定义日志标签 + private static final String TAG = TaskList.class.getSimpleName(); + + // 定义一个整型变量mIndex，用于存储索引 + private int mIndex; + + // 定义一个ArrayList类型的变量mChildren，用于存储子任务 + private ArrayList mChildren; + + // TaskList的构造函数 + public TaskList() { + super(); // 调用父类的构造函数 + mChildren = new ArrayList(); // 初始化mChildren为新的ArrayList + mIndex = 1; // 初始化索引为1 + } + + // 创建一个用于创建任务列表的动作的JSON对象 + public JSONObject getCreateAction(int actionId) { + JSONObject js = new JSONObject(); // 创建一个新的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, mIndex); + + // 创建实体增量对象 + JSONObject entity = new JSONObject(); + entity.put(GTaskStringUtils.GTASK_JSON_NAME, getName()); // 设置实体名称为当前任务列表的名称 + entity.put(GTaskStringUtils.GTASK_JSON_CREATOR_ID, "null"); // 设置创建者ID为null + entity.put(GTaskStringUtils.GTASK_JSON_ENTITY_TYPE, + GTaskStringUtils.GTASK_JSON_TYPE_GROUP); // 设置实体类型为组 + js.put(GTaskStringUtils.GTASK_JSON_ENTITY_DELTA, entity); // 将实体增量对象添加到动作JSON中 + + } catch (JSONException e) { + Log.e(TAG, e.toString()); // 打印错误日志 + e.printStackTrace(); // 打印错误堆栈信息 + throw new ActionFailureException("fail to generate tasklist-create jsonobject"); // 抛出异常 + } + + return js; // 返回创建的JSON对象 + } + + // 创建一个用于更新任务列表的动作的JSON对象 + public JSONObject getUpdateAction(int actionId) { + JSONObject js = new JSONObject(); // 创建一个新的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()); // 设置ID为当前任务列表的全局ID + + // 创建实体增量对象 + 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); // 将实体增量对象添加到动作JSON中 + + } catch (JSONException e) { + Log.e(TAG, e.toString()); // 打印错误日志 + e.printStackTrace(); // 打印错误堆栈信息 + throw new ActionFailureException("fail to generate tasklist-update jsonobject"); // 抛出异常 + } + + return js; // 返回创建的JSON对象 + } + + // 从远程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)); // 设置全局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("fail to get tasklist content from jsonobject"); // 抛出异常 + } + } + } + + // 从本地JSON对象中设置内容 + public void setContentByLocalJSON(JSONObject js) { + if (js == null || !js.has(GTaskStringUtils.META_HEAD_NOTE)) { + Log.w(TAG, "setContentByLocalJSON: nothing is avaiable"); // 打印警告日志 + } + + try { + JSONObject folder = js.getJSONObject(GTaskStringUtils.META_HEAD_NOTE); // 获取本地JSON对象中的笔记头部信息 + + // 根据笔记类型设置任务列表名称 + 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) { + // 根据系统文件夹ID设置默认或通话记录文件夹名称 + 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, "invalid system folder"); // 打印错误日志 + } else { + Log.e(TAG, "error type"); // 打印错误日志 + } + } catch (JSONException e) { + Log.e(TAG, e.toString()); // 打印错误日志 + e.printStackTrace(); // 打印错误堆栈信息 + } + } + + // 从当前内容生成本地JSON对象 + public JSONObject getLocalJSONFromContent() { + try { + JSONObject js = new JSONObject(); // 创建一个新的JSONObject + JSONObject folder = new JSONObject(); // 创建一个新的JSONObject用于存储文件夹信息 + + String folderName = getName(); // 获取当前任务列表名称 + // 如果任务列表名称以MIUI前缀开始，则去除前缀 + if (getName().startsWith(GTaskStringUtils.MIUI_FOLDER_PREFFIX)) + folderName = folderName.substring(GTaskStringUtils.MIUI_FOLDER_PREFFIX.length(), + folderName.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); // 将文件夹信息添加到本地JSON对象中 + + return js; // 返回创建的本地JSON对象 + } catch (JSONException e) { + Log.e(TAG, e.toString()); // 打印错误日志 + e.printStackTrace(); // 打印错误堆栈信息 + return null; // 返回null + } + } +// 定义一个方法，用于根据Cursor对象确定同步操作 +public int getSyncAction(Cursor c) { + try { + // 检查本地是否有修改（假设SqlNote.LOCAL_MODIFIED_COLUMN是标记本地修改的列索引） + if (c.getInt(SqlNote.LOCAL_MODIFIED_COLUMN) == 0) { + // 本地没有修改 + // 检查同步ID（假设SqlNote.SYNC_ID_COLUMN是记录同步ID的列索引）是否与最后修改时间匹配（假设getLastModified()方法返回最后修改时间） + if (c.getLong(SqlNote.SYNC_ID_COLUMN) == getLastModified()) { + // 两边都没有更新 + return SYNC_ACTION_NONE; // 返回无需同步的动作 + } else { + // 远程有更新，需要应用到本地 + return SYNC_ACTION_UPDATE_LOCAL; // 返回更新本地的动作 + } + } else { + // 本地有修改 + // 验证GTASK ID（假设SqlNote.GTASK_ID_COLUMN是记录GTASK ID的列索引）是否与当前ID匹配（假设getGid()方法返回当前ID） + if (!c.getString(SqlNote.GTASK_ID_COLUMN).equals(getGid())) { + Log.e(TAG, "gtask id doesn't match"); // 记录错误日志 + return SYNC_ACTION_ERROR; // 返回错误动作 + } + // 检查同步ID是否与最后修改时间匹配 + if (c.getLong(SqlNote.SYNC_ID_COLUMN) == getLastModified()) { + // 只有本地有修改 + return SYNC_ACTION_UPDATE_REMOTE; // 返回更新远程的动作 + } else { + // 文件夹冲突，仅应用本地修改 + return SYNC_ACTION_UPDATE_REMOTE; // 这里可能需要根据实际情况调整逻辑 + } + } + } catch (Exception e) { + Log.e(TAG, e.toString()); // 记录异常日志 + e.printStackTrace(); // 打印异常堆栈 + } + + return SYNC_ACTION_ERROR; // 默认情况下返回错误动作 +} + +// 获取子任务数量 +public int getChildTaskCount() { + return mChildren.size(); // 返回子任务列表的大小 +} + +// 添加一个子任务到列表末尾 +public boolean addChildTask(Task task) { + boolean ret = false; // 初始化返回值为false + if (task != null && !mChildren.contains(task)) { // 检查任务不为空且不在列表中 + ret = mChildren.add(task); // 添加任务到列表 + if (ret) { + // 设置前一个兄弟任务和父任务 + task.setPriorSibling(mChildren.isEmpty() ? null : mChildren.get(mChildren.size() - 1)); + task.setParent(this); + } + } + return ret; // 返回添加结果 +} + +// 在指定位置添加子任务 +public boolean addChildTask(Task task, int index) { + if (index < 0 || index > mChildren.size()) { // 检查索引是否有效 + Log.e(TAG, "add child task: invalid index"); // 记录错误日志 + return false; + } + + int pos = mChildren.indexOf(task); // 检查任务是否已存在 + if (task != null && pos == -1) { // 任务不为空且不在列表中 + mChildren.add(index, task); // 在指定位置添加任务 + + // 更新任务列表中的前一个兄弟任务和后一个兄弟任务 + Task preTask = null; + Task afterTask = null; + if (index != 0) + preTask = mChildren.get(index - 1); + if (index != mChildren.size() - 1) + afterTask = mChildren.get(index + 1); + + task.setPriorSibling(preTask); + if (afterTask != null) + afterTask.setPriorSibling(task); + } + + return true; // 返回添加结果（这里可能应该返回添加是否成功的布尔值，但代码始终返回true） +} + +// 从列表中移除一个子任务 +public boolean removeChildTask(Task task) { + boolean ret = false; // 初始化返回值为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; // 返回移除结果 +} + +// 移动子任务到指定位置 +public boolean moveChildTask(Task task, int index) { + if (index < 0 || index >= mChildren.size()) { // 检查索引是否有效 + Log.e(TAG, "move child task: invalid index"); // 记录错误日志 + return false; + } + + int pos = mChildren.indexOf(task); // 获取任务当前位置 + if (pos == -1) { // 如果任务不在列表中 + Log.e(TAG, "move child task: the task should in the list"); // 记录错误日志 + return false; + } + + if (pos == index) + return true; // 如果当前位置就是目标位置，直接返回true + return (removeChildTask(task) && addChildTask(task, index)); // 先移除再添加，返回结果 +} + +// 通过GTASK ID查找子任务 +public Task findChildTaskByGid(String gid) { + for (int i = 0; i < mChildren.size(); i++) { + Task t = mChildren.get(i); + if (t.getGid().equals(gid)) { // 如果找到匹配的GTASK ID + return t; // 返回任务 + } + } + return null; // 如果没有找到，返回null +} + +// 获取子任务在列表中的索引 +public int getChildTaskIndex(Task task) { + return mChildren.indexOf(task); // 返回任务在列表中的索引 +} + +// 通过索引获取子任务 +public Task getChildTaskByIndex(int index) { + if (index < 0 || index >= mChildren.size()) { // 检查索引是否有效 + Log.e(TAG, "getTaskByIndex: invalid index"); // 记录错误日志 + return null; // 返回null + } + return mChildren.get(index); // 返回指定索引处的任务 +} + +// 通过GTASK ID查找子任务（与findChildTaskByGid方法重复） +public Task getChilTaskByGid(String gid) { + for (Task task : mChildren) { + if (task.getGid().equals(gid)) // 如果找到匹配的GTASK ID + return task; // 返回任务 + } + return null; // 如果没有找到，返回null +} + +// 获取子任务列表 +public ArrayList getChildTaskList() { + return this.mChildren; // 返回子任务列表 +} + +// 设置索引值 +public void setIndex(int index) { + this.mIndex = index; // 设置索引值 +} + +// 获取索引值 +public int getIndex() { + return this.mIndex; // 返回索引值 +} +} \ No newline at end of file diff --git a/作业11.txt b/作业11.txt new file mode 100644 index 0000000..3f3135d --- /dev/null +++ b/作业11.txt @@ -0,0 +1,36 @@ +/* + * Copyright (c) 2010-2011, The MiCode Open Source Community (www.micode.net) + * + * 这段注释声明了版权信息，指出了这段代码是由MiCode开源社区在2010-2011年间创作的。 + */ + +package net.micode.notes.gtask.exception; + +// 这行指定了当前类所在的包名，用于Java的命名空间管理，避免类名冲突。 + +public class ActionFailureException extends RuntimeException { + // 声明了一个名为ActionFailureException的类，它继承自Java标准库中的RuntimeException类。 + // 这意味着ActionFailureException是一个未检查异常（unchecked exception），不需要强制捕获或声明抛出。 + + private static final long serialVersionUID = 4425249765923293627L; + // serialVersionUID是用于Java序列化机制的一个唯一标识符，确保反序列化时的版本一致性。 + // 当对象被序列化时，这个值会被写入到序列化文件中，反序列化时会检查这个版本号是否匹配。 + + public ActionFailureException() { + super(); + } + // 这是ActionFailureException的无参构造函数，它调用了父类RuntimeException的无参构造函数。 + // 当创建ActionFailureException实例而不传递任何信息时，会使用这个构造函数。 + + public ActionFailureException(String paramString) { + super(paramString); + } + // 这是带有一个String参数的构造函数，用于传递异常的具体信息。 + // 它将传递给构造函数的String参数传递给父类RuntimeException的构造函数，以便在异常抛出时能够显示这段信息。 + + public ActionFailureException(String paramString, Throwable paramThrowable) { + super(paramString, paramThrowable); + } + // 这是带有String和Throwable参数的构造函数，用于传递异常的具体信息和导致异常的原因（即另一个异常）。 + // 它将这两个参数传递给父类RuntimeException的构造函数，这样既可以显示异常信息，又可以保留异常链，便于追踪异常的根本原因。 +} \ No newline at end of file diff --git a/作业12txt.txt b/作业12txt.txt new file mode 100644 index 0000000..9250e93 --- /dev/null +++ b/作业12txt.txt @@ -0,0 +1,36 @@ +/* + * Copyright (c) 2010-2011, The MiCode Open Source Community (www.micode.net) + * + * 这段注释声明了代码的版权信息，表明这段代码是由MiCode开源社区在2010年至2011年期间创作的。 + */ + +package net.micode.notes.gtask.exception; + +// 这行代码指定了当前类所在的包路径。包是Java中用于组织类的一种方式，有助于避免命名冲突。 + +public class NetworkFailureException extends Exception { + // 这行代码定义了一个名为NetworkFailureException的类，它继承自Java标准库中的Exception类。 + // 这意味着NetworkFailureException是一个已检查异常（checked exception），需要在方法签名中显式地声明抛出，或者在方法内部捕获。 + + private static final long serialVersionUID = 2107610287180234136L; + // serialVersionUID是一个用于Java序列化机制的唯一标识符。当对象被序列化时，这个值会被写入到序列化文件中。 + // 在反序列化过程中，JVM会检查这个版本号是否匹配，以确保序列化和反序列化过程中类的版本一致性。 + + public NetworkFailureException() { + super(); + } + // 这是NetworkFailureException的无参构造函数，它调用了父类Exception的无参构造函数。 + // 当创建NetworkFailureException实例而不传递任何信息时，会使用这个构造函数。 + + public NetworkFailureException(String paramString) { + super(paramString); + } + // 这是带有一个String参数的构造函数，用于传递异常的具体信息。 + // 它将传递给构造函数的String参数传递给父类Exception的构造函数，以便在异常抛出时能够显示这段信息。 + + public NetworkFailureException(String paramString, Throwable paramThrowable) { + super(paramString, paramThrowable); + } + // 这是带有String和Throwable参数的构造函数，用于传递异常的具体信息和导致异常的根本原因（即另一个异常）。 + // 它将这两个参数传递给父类Exception的构造函数，这样既可以显示异常信息，又可以保留异常链，便于追踪异常的根本原因。 +} \ No newline at end of file diff --git a/作业2.txt b/作业2.txt new file mode 100644 index 0000000..1bea902 --- /dev/null +++ b/作业2.txt @@ -0,0 +1,171 @@ +// 导入Uri类，用于处理URI（统一资源标识符） +import android.net.Uri; + +// 定义Notes类，用于管理笔记应用的数据结构和常量 +public class Notes { + // 定义内容提供者的权限名 + public static final String AUTHORITY = "micode_notes"; + // 定义日志标签，用于调试 + public static final String TAG = "Notes"; + // 定义笔记类型常量 + public static final int TYPE_NOTE = 0; // 笔记类型 + public static final int TYPE_FOLDER = 1; // 文件夹类型 + public static final int TYPE_SYSTEM = 2; // 系统类型 + + // 定义系统文件夹的标识符 + public static final int ID_ROOT_FOLDER = 0; // 默认文件夹 + public static final int ID_TEMPARAY_FOLDER = -1; // 无归属文件夹（临时文件夹） + public static final int ID_CALL_RECORD_FOLDER = -2; // 通话记录文件夹 + public static final int ID_TRASH_FOLER = -3; // 垃圾文件夹（注意拼写错误，应为ID_TRASH_FOLDER） + + // 定义Intent的额外数据键 + public static final String INTENT_EXTRA_ALERT_DATE = "net.micode.notes.alert_date"; // 提醒日期 + public static final String INTENT_EXTRA_BACKGROUND_ID = "net.micode.notes.background_color_id"; // 背景颜色ID + public static final String INTENT_EXTRA_WIDGET_ID = "net.micode.notes.widget_id"; // 小部件ID + public static final String INTENT_EXTRA_WIDGET_TYPE = "net.micode.notes.widget_type"; // 小部件类型 + public static final String INTENT_EXTRA_FOLDER_ID = "net.micode.notes.folder_id"; // 文件夹ID + public static final String INTENT_EXTRA_CALL_DATE = "net.micode.notes.call_date"; // 通话日期 + + // 定义小部件类型常量 + public static final int TYPE_WIDGET_INVALIDE = -1; // 无效的小部件类型 + public static final int TYPE_WIDGET_2X = 0; // 2x大小的小部件 + public static final int TYPE_WIDGET_4X = 1; // 4x大小的小部件 + + // 定义数据常量类，用于区分不同类型的笔记 + public static class DataConstants { + public static final String NOTE = TextNote.CONTENT_ITEM_TYPE; // 文本笔记类型 + public static final String CALL_NOTE = CallNote.CONTENT_ITEM_TYPE; // 通话笔记类型 + } + + // 定义用于查询所有笔记和文件夹的Uri + public static final Uri CONTENT_NOTE_URI = Uri.parse("content://" + AUTHORITY + "/note"); + + // 定义用于查询数据的Uri + public static final Uri CONTENT_DATA_URI = Uri.parse("content://" + AUTHORITY + "/data"); + + // 定义笔记列接口，用于访问笔记数据库的列名 + public interface NoteColumns { + // 行的唯一ID + public static final String ID = "_id"; + + // 笔记或文件夹的父ID + public static final String PARENT_ID = "parent_id"; + + // 创建日期 + public static final String CREATED_DATE = "created_date"; + + // 最后修改日期 + public static final String MODIFIED_DATE = "modified_date"; + + // 提醒日期 + public static final String ALERTED_DATE = "alert_date"; + + // 文件夹名称或笔记的文本内容 + public static final String SNIPPET = "snippet"; + + // 笔记的小部件ID + public static final String WIDGET_ID = "widget_id"; + + // 笔记的小部件类型 + public static final String WIDGET_TYPE = "widget_type"; + + // 笔记背景颜色的ID + public static final String BG_COLOR_ID = "bg_color_id"; + + // 是否有附件（对于文本笔记，没有附件；对于多媒体笔记，至少有一个附件） + public static final String HAS_ATTACHMENT = "has_attachment"; + + // 文件夹中的笔记数量 + public static final String NOTES_COUNT = "notes_count"; + + // 文件类型：文件夹或笔记 + public static final String TYPE = "type"; + + // 最后同步ID + public static final String SYNC_ID = "sync_id"; + + // 指示是否本地修改的标志 + public static final String LOCAL_MODIFIED = "local_modified"; + + // 移动到临时文件夹前的原始父ID + public static final String ORIGIN_PARENT_ID = "origin_parent_id"; + + // GTask ID（可能是与Google Tasks集成的ID） + public static final String GTASK_ID = "gtask_id"; + + // 版本代码 + public static final String VERSION = "version"; + } +// 定义一个接口DataColumns，包含了一系列用于数据表的列名常量 +public interface DataColumns { + // 行的唯一ID + public static final String ID = "_id"; + + // 项目代表的MIME类型 + public static final String MIME_TYPE = "mime_type"; + + // 这个数据所属的笔记的引用ID + public static final String NOTE_ID = "note_id"; + + // 笔记或文件夹的创建日期 + public static final String CREATED_DATE = "created_date"; + + // 最新修改日期 + public static final String MODIFIED_DATE = "modified_date"; + + // 数据的内容 + public static final String CONTENT = "content"; + + // 通用数据列，意义取决于MIME_TYPE，用于整数数据类型 + public static final String DATA1 = "data1"; + + // 通用数据列，意义取决于MIME_TYPE，用于整数数据类型 + public static final String DATA2 = "data2"; + + // 通用数据列，意义取决于MIME_TYPE，用于文本数据类型 + public static final String DATA3 = "data3"; + + // 通用数据列，意义取决于MIME_TYPE，用于文本数据类型 + public static final String DATA4 = "data4"; + + // 通用数据列，意义取决于MIME_TYPE，用于文本数据类型 + public static final String DATA5 = "data5"; +} + +// 定义一个静态内部类TextNote，实现了DataColumns接口，用于文本笔记 +public static final class TextNote implements DataColumns { + // 表示文本是否为检查列表模式的标志 + public static final String MODE = DATA1; // 使用DataColumns中的DATA1作为模式字段 + + // 检查列表模式的常量值 + public static final int MODE_CHECK_LIST = 1; + + // 文本笔记的内容类型MIME字符串 + public static final String CONTENT_TYPE = "vnd.android.cursor.dir/text_note"; + + // 单个文本笔记的内容类型MIME字符串 + public static final String CONTENT_ITEM_TYPE = "vnd.android.cursor.item/text_note"; + + // 文本笔记的内容URI + public static final Uri CONTENT_URI = Uri.parse("content://" + AUTHORITY + "/text_note"); + // 注意：AUTHORITY应在此代码段外部定义，通常是一个字符串常量，表示内容提供者的权威名称 +} + +// 定义一个静态内部类CallNote，实现了DataColumns接口，用于电话笔记 +public static final class CallNote implements DataColumns { + // 这个记录的呼叫日期 + public static final String CALL_DATE = DATA1; // 使用DataColumns中的DATA1作为呼叫日期字段 + + // 这个记录的电话号码 + public static final String PHONE_NUMBER = DATA3; // 使用DataColumns中的DATA3作为电话号码字段 + + // 电话笔记的内容类型MIME字符串 + public static final String CONTENT_TYPE = "vnd.android.cursor.dir/call_note"; + + // 单个电话笔记的内容类型MIME字符串 + public static final String CONTENT_ITEM_TYPE = "vnd.android.cursor.item/call_note"; + + // 电话笔记的内容URI + public static final Uri CONTENT_URI = Uri.parse("content://" + AUTHORITY + "/call_note"); + // 注意：同样，AUTHORITY应在此代码段外部定义 +} \ No newline at end of file diff --git a/作业3.txt b/作业3.txt new file mode 100644 index 0000000..21d1c3f --- /dev/null +++ b/作业3.txt @@ -0,0 +1,324 @@ +// 导入必要的包 +import android.content.ContentValues; +import android.content.Context; +import android.database.sqlite.SQLiteDatabase; +import android.database.sqlite.SQLiteOpenHelper; +import android.util.Log; + +// 导入项目内其他包 +import net.micode.notes.data.Notes.DataColumns; +import net.micode.notes.data.Notes.DataConstants; +import net.micode.notes.data.Notes.NoteColumns; + +// 定义NotesDatabaseHelper类，继承自SQLiteOpenHelper +public class NotesDatabaseHelper extends SQLiteOpenHelper { + // 定义数据库名称 + private static final String DB_NAME = "note.db"; + + // 定义数据库版本 + private static final int DB_VERSION = 4; + + // 定义数据库表名的接口 + public interface TABLE { + // 笔记表名 + public static final String NOTE = "note"; + + // 数据表名 + public static final String DATA = "data"; + } + + // 定义日志标签 + private static final String TAG = "NotesDatabaseHelper"; + + // 定义单例变量 + private static NotesDatabaseHelper mInstance; + + // 定义创建笔记表的SQL语句 + private static final String CREATE_NOTE_TABLE_SQL = + "CREATE TABLE " + TABLE.NOTE + "(" + + // 定义列，包括ID、父ID、提醒日期等 + NoteColumns.ID + " INTEGER PRIMARY KEY," + + NoteColumns.PARENT_ID + " INTEGER NOT NULL DEFAULT 0," + + NoteColumns.ALERTED_DATE + " INTEGER NOT NULL DEFAULT 0," + + NoteColumns.BG_COLOR_ID + " INTEGER NOT NULL DEFAULT 0," + + NoteColumns.CREATED_DATE + " INTEGER NOT NULL DEFAULT (strftime('%s','now') * 1000)," + + NoteColumns.HAS_ATTACHMENT + " INTEGER NOT NULL DEFAULT 0," + + NoteColumns.MODIFIED_DATE + " INTEGER NOT NULL DEFAULT (strftime('%s','now') * 1000)," + + NoteColumns.NOTES_COUNT + " INTEGER NOT NULL DEFAULT 0," + + NoteColumns.SNIPPET + " TEXT NOT NULL DEFAULT ''," + + NoteColumns.TYPE + " INTEGER NOT NULL DEFAULT 0," + + NoteColumns.WIDGET_ID + " INTEGER NOT NULL DEFAULT 0," + + NoteColumns.WIDGET_TYPE + " INTEGER NOT NULL DEFAULT -1," + + NoteColumns.SYNC_ID + " INTEGER NOT NULL DEFAULT 0," + + NoteColumns.LOCAL_MODIFIED + " INTEGER NOT NULL DEFAULT 0," + + NoteColumns.ORIGIN_PARENT_ID + " INTEGER NOT NULL DEFAULT 0," + + NoteColumns.GTASK_ID + " TEXT NOT NULL DEFAULT ''," + + NoteColumns.VERSION + " INTEGER NOT NULL DEFAULT 0" + + ")"; + + // 定义创建数据表的SQL语句 + private static final String CREATE_DATA_TABLE_SQL = + "CREATE TABLE " + TABLE.DATA + "(" + + // 定义列，包括ID、MIME类型、笔记ID等 + DataColumns.ID + " INTEGER PRIMARY KEY," + + DataColumns.MIME_TYPE + " TEXT NOT NULL," + + DataColumns.NOTE_ID + " INTEGER NOT NULL DEFAULT 0," + + NoteColumns.CREATED_DATE + " INTEGER NOT NULL DEFAULT (strftime('%s','now') * 1000)," + + NoteColumns.MODIFIED_DATE + " INTEGER NOT NULL DEFAULT (strftime('%s','now') * 1000)," + + DataColumns.CONTENT + " TEXT NOT NULL DEFAULT ''," + + DataColumns.DATA1 + " INTEGER," + + DataColumns.DATA2 + " INTEGER," + + DataColumns.DATA3 + " TEXT NOT NULL DEFAULT ''," + + DataColumns.DATA4 + " TEXT NOT NULL DEFAULT ''," + + DataColumns.DATA5 + " TEXT NOT NULL DEFAULT ''" + + ")"; + + // 定义创建数据表索引的SQL语句，以提高查询效率 + private static final String CREATE_DATA_NOTE_ID_INDEX_SQL = + "CREATE INDEX IF NOT EXISTS note_id_index ON " + + TABLE.DATA + "(" + DataColumns.NOTE_ID + ");"; + + // 定义触发器，当笔记的父ID更新时，增加目标文件夹的笔记数量 + private static final String NOTE_INCREASE_FOLDER_COUNT_ON_UPDATE_TRIGGER = + "CREATE TRIGGER increase_folder_count_on_update "+ + " AFTER UPDATE OF " + NoteColumns.PARENT_ID + " ON " + TABLE.NOTE + + " BEGIN " + + " UPDATE " + TABLE.NOTE + + " SET " + NoteColumns.NOTES_COUNT + "=" + NoteColumns.NOTES_COUNT + " + 1" + + " WHERE " + NoteColumns.ID + "=new." + NoteColumns.PARENT_ID + ";" + + " END"; + + // 定义触发器，当笔记的父ID更新时，减少原文件夹的笔记数量（如果原数量大于0） + private static final String NOTE_DECREASE_FOLDER_COUNT_ON_UPDATE_TRIGGER = + "CREATE TRIGGER decrease_folder_count_on_update " + + " AFTER UPDATE OF " + NoteColumns.PARENT_ID + " ON " + TABLE.NOTE + + " BEGIN " + + " UPDATE " + TABLE.NOTE + + " SET " + NoteColumns.NOTES_COUNT + "=" + NoteColumns.NOTES_COUNT + "-1" + + " WHERE " + NoteColumns.ID + "=old." + NoteColumns.PARENT_ID + + " AND " + NoteColumns.NOTES_COUNT + ">0" + ";" + + " END"; + + // 定义触发器，当插入新笔记时，增加目标文件夹的笔记数量 + private static final String NOTE_INCREASE_FOLDER_COUNT_ON_INSERT_TRIGGER = + "CREATE TRIGGER increase_folder_count_on_insert " + + " AFTER INSERT ON " + TABLE.NOTE + + " BEGIN " + + " UPDATE " + TABLE.NOTE + + " SET " + NoteColumns.NOTES_COUNT + "=" + NoteColumns.NOTES_COUNT + " + 1" + + " WHERE " + NoteColumns.ID + "=new." + NoteColumns.PARENT_ID + ";" + + " END"; +// 定义一个常量字符串，表示当从文件夹中删除笔记时，减少文件夹的笔记数量的触发器SQL语句 +private static final String NOTE_DECREASE_FOLDER_COUNT_ON_DELETE_TRIGGER = + "CREATE TRIGGER decrease_folder_count_on_delete " + // 创建一个名为decrease_folder_count_on_delete的触发器 + " AFTER DELETE ON " + TABLE.NOTE + // 在NOTE表上执行删除操作之后触发 + " BEGIN " + + " UPDATE " + TABLE.NOTE + // 更新NOTE表 + " SET " + NoteColumns.NOTES_COUNT + "=" + NoteColumns.NOTES_COUNT + "-1" + // 将该文件夹的笔记数量减1 + " WHERE " + NoteColumns.ID + "=old." + NoteColumns.PARENT_ID + // 查找被删除笔记的父文件夹ID + " AND " + NoteColumns.NOTES_COUNT + ">0;" + // 并且确保该文件夹的笔记数量大于0 + " END"; + +// 定义一个常量字符串，表示当插入类型为NOTE的数据时，更新笔记内容的触发器SQL语句 +private static final String DATA_UPDATE_NOTE_CONTENT_ON_INSERT_TRIGGER = + "CREATE TRIGGER update_note_content_on_insert " + // 创建一个名为update_note_content_on_insert的触发器 + " AFTER INSERT ON " + TABLE.DATA + // 在DATA表上执行插入操作之后触发 + " WHEN new." + DataColumns.MIME_TYPE + "='" + DataConstants.NOTE + "'" + // 当新插入的数据的MIME类型为NOTE时 + " BEGIN" + + " UPDATE " + TABLE.NOTE + // 更新NOTE表 + " SET " + NoteColumns.SNIPPET + "=new." + DataColumns.CONTENT + // 将对应笔记的摘要更新为新插入的数据内容 + " WHERE " + NoteColumns.ID + "=new." + DataColumns.NOTE_ID + ";" + // 查找对应ID的笔记 + " END"; + +// 定义一个常量字符串，表示当类型为NOTE的数据更新时，更新笔记内容的触发器SQL语句 +private static final String DATA_UPDATE_NOTE_CONTENT_ON_UPDATE_TRIGGER = + // 类似于上面的插入触发器，但这里是在数据更新时触发 + +// 定义一个常量字符串，表示当类型为NOTE的数据删除时，更新笔记内容的触发器SQL语句 +private static final String DATA_UPDATE_NOTE_CONTENT_ON_DELETE_TRIGGER = + // 类似于上面的插入触发器，但这里是在数据删除时触发，将笔记摘要设置为空字符串 + +// 定义一个常量字符串，表示当删除笔记时，删除属于该笔记的数据的触发器SQL语句 +private static final String NOTE_DELETE_DATA_ON_DELETE_TRIGGER = + "CREATE TRIGGER delete_data_on_delete " + // 创建一个名为delete_data_on_delete的触发器 + " AFTER DELETE ON " + TABLE.NOTE + // 在NOTE表上执行删除操作之后触发 + " BEGIN" + + " DELETE FROM " + TABLE.DATA + // 从DATA表中删除数据 + " WHERE " + DataColumns.NOTE_ID + "=old." + NoteColumns.ID + ";" + // 查找对应ID的笔记的数据 + " END"; + +// 定义一个常量字符串，表示当删除文件夹时，删除属于该文件夹的笔记的触发器SQL语句 +private static final String FOLDER_DELETE_NOTES_ON_DELETE_TRIGGER = + // 这里的逻辑有误，因为它试图从NOTE表中删除属于被删除笔记的笔记，这实际上应该是删除属于被删除文件夹的笔记 + // 正确的逻辑应该是查找PARENT_ID等于被删除文件夹ID的笔记 + +// 定义一个常量字符串，表示当文件夹移动到回收站时，移动属于该文件夹的笔记到回收站的触发器SQL语句 +private static final String FOLDER_MOVE_NOTES_ON_TRASH_TRIGGER = + "CREATE TRIGGER folder_move_notes_on_trash " + // 创建一个名为folder_move_notes_on_trash的触发器 + " AFTER UPDATE ON " + TABLE.NOTE + // 在NOTE表上执行更新操作之后触发 + " WHEN new." + NoteColumns.PARENT_ID + "=" + Notes.ID_TRASH_FOLER + // 当更新后的父ID等于回收站ID时 + " BEGIN" + + " UPDATE " + TABLE.NOTE + // 更新NOTE表 + " SET " + NoteColumns.PARENT_ID + "=" + Notes.ID_TRASH_FOLER + // 将这些笔记的父ID也设置为回收站ID + " WHERE " + NoteColumns.PARENT_ID + "=old." + NoteColumns.ID + ";" + // 查找原来属于被更新笔记（实际上是文件夹）的笔记 + " END"; + +// NotesDatabaseHelper类的构造函数，初始化数据库帮助类 +public NotesDatabaseHelper(Context context) { + super(context, DB_NAME, null, DB_VERSION); +} + +// 创建一个用于存储笔记的表 +public void createNoteTable(SQLiteDatabase db) { + db.execSQL(CREATE_NOTE_TABLE_SQL); // 执行创建表的SQL语句 + reCreateNoteTableTriggers(db); // 重新创建触发器（确保触发器是最新的） + createSystemFolder(db); // 创建一个系统文件夹（未在代码段中给出） + Log.d(TAG, "note table has been created"); // 打印日志，表示表已创建 +} + +// 重新创建（先删除后创建）与笔记表相关的触发器 +private void reCreateNoteTableTriggers(SQLiteDatabase db) { + // 依次删除旧触发器（如果存在） + // ... + // 然后依次创建新的触发器 + // ... +} +// 定义一个私有方法，用于在数据库中创建系统文件夹记录 +private void createSystemFolder(SQLiteDatabase db) { + ContentValues values = new ContentValues(); // 创建一个ContentValues对象，用于存储要插入数据库的值 + + // 插入通话记录文件夹记录 + values.put(NoteColumns.ID, Notes.ID_CALL_RECORD_FOLDER); // 设置ID为通话记录文件夹的ID + values.put(NoteColumns.TYPE, Notes.TYPE_SYSTEM); // 设置类型为系统文件夹 + db.insert(TABLE.NOTE, null, values); // 将这些值插入到数据库的NOTE表中 + + // 清除ContentValues对象，以便重用 + values.clear(); + + // 插入根文件夹记录 + values.put(NoteColumns.ID, Notes.ID_ROOT_FOLDER); // 设置ID为根文件夹的ID + values.put(NoteColumns.TYPE, Notes.TYPE_SYSTEM); // 设置类型为系统文件夹 + db.insert(TABLE.NOTE, null, values); // 将这些值插入到数据库的NOTE表中 + + // 清除ContentValues对象，以便重用 + values.clear(); + + // 插入临时文件夹记录 + values.put(NoteColumns.ID, Notes.ID_TEMPARAY_FOLDER); // 设置ID为临时文件夹的ID + values.put(NoteColumns.TYPE, Notes.TYPE_SYSTEM); // 设置类型为系统文件夹 + db.insert(TABLE.NOTE, null, values); // 将这些值插入到数据库的NOTE表中 + + // 清除ContentValues对象，以便重用 + values.clear(); + + // 插入垃圾箱文件夹记录 + values.put(NoteColumns.ID, Notes.ID_TRASH_FOLER); // 注意这里可能是拼写错误，应为TRASH_FOLDER + values.put(NoteColumns.TYPE, Notes.TYPE_SYSTEM); // 设置类型为系统文件夹 + db.insert(TABLE.NOTE, null, values); // 将这些值插入到数据库的NOTE表中 +} + +// 定义一个公有方法，用于创建数据表 +public void createDataTable(SQLiteDatabase db) { + db.execSQL(CREATE_DATA_TABLE_SQL); // 执行创建数据表的SQL语句 + reCreateDataTableTriggers(db); // 重新创建数据表的触发器 + db.execSQL(CREATE_DATA_NOTE_ID_INDEX_SQL); // 执行创建数据表索引的SQL语句 + Log.d(TAG, "data table has been created"); // 打印日志，表示数据表已创建 +} + +// 定义一个私有方法，用于重新创建数据表的触发器 +private void reCreateDataTableTriggers(SQLiteDatabase db) { + // 删除已存在的触发器，如果存在的话 + db.execSQL("DROP TRIGGER IF EXISTS update_note_content_on_insert"); + db.execSQL("DROP TRIGGER IF EXISTS update_note_content_on_update"); + db.execSQL("DROP TRIGGER IF EXISTS update_note_content_on_delete"); + + // 重新创建触发器 + db.execSQL(DATA_UPDATE_NOTE_CONTENT_ON_INSERT_TRIGGER); + db.execSQL(DATA_UPDATE_NOTE_CONTENT_ON_UPDATE_TRIGGER); + db.execSQL(DATA_UPDATE_NOTE_CONTENT_ON_DELETE_TRIGGER); +} + +// 获取数据库帮助类的实例，采用单例模式 +static synchronized NotesDatabaseHelper getInstance(Context context) { + if (mInstance == null) { + mInstance = new NotesDatabaseHelper(context); + } + return mInstance; +} + +// 当数据库首次创建时调用此方法 +@Override +public void onCreate(SQLiteDatabase db) { + createNoteTable(db); // 创建笔记表 + createDataTable(db); // 创建数据表 +} + +// 当数据库版本升级时调用此方法 +@Override +public void onUpgrade(SQLiteDatabase db, int oldVersion, int newVersion) { + boolean reCreateTriggers = false; // 是否需要重新创建触发器 + boolean skipV2 = false; // 是否跳过V2版本的升级逻辑 + + // 根据旧版本执行相应的升级逻辑 + if (oldVersion == 1) { + upgradeToV2(db); // 升级到V2版本 + skipV2 = true; // 跳过V2到V3的升级逻辑，因为已经在V2的升级中处理了 + oldVersion++; // 更新旧版本号为2 + } + + if (oldVersion == 2 && !skipV2) { + upgradeToV3(db); // 升级到V3版本 + reCreateTriggers = true; // 标记需要重新创建触发器 + oldVersion++; // 更新旧版本号为3 + } + + if (oldVersion == 3) { + upgradeToV4(db); // 升级到V4版本 + oldVersion++; // 更新旧版本号为4 + } + + if (reCreateTriggers) { + reCreateNoteTableTriggers(db); // 重新创建笔记表的触发器 + reCreateDataTableTriggers(db); // 重新创建数据表的触发器 + } + + // 如果旧版本和新版本不一致，抛出异常 + if (oldVersion != newVersion) { + throw new IllegalStateException("Upgrade notes database to version " + newVersion + + "fails"); + } +} + +// 升级到V2版本的方法 +private void upgradeToV2(SQLiteDatabase db) { + // 删除已存在的表和触发器 + db.execSQL("DROP TABLE IF EXISTS " + TABLE.NOTE); + db.execSQL("DROP TABLE IF EXISTS " + TABLE.DATA); + // 重新创建表和触发器 + createNoteTable(db); + createDataTable(db); +} + +// 升级到V3版本的方法 +private void upgradeToV3(SQLiteDatabase db) { + // 删除已存在的触发器 + db.execSQL("DROP TRIGGER IF EXISTS update_note_modified_date_on_insert"); + db.execSQL("DROP TRIGGER IF EXISTS update_note_modified_date_on_delete"); + db.execSQL("DROP TRIGGER IF EXISTS update_note_modified_date_on_update"); + // 添加新列 + db.execSQL("ALTER TABLE " + TABLE.NOTE + " ADD COLUMN " + NoteColumns.GTASK_ID + + " TEXT NOT NULL DEFAULT ''"); + // 添加垃圾箱文件夹记录（注意：这里在V2版本升级中应该已经添加过了，可能是V3版本的一个额外操作或遗漏） + ContentValues values = new ContentValues(); + values.put(NoteColumns.ID, Notes.ID_TRASH_FOLER); // 注意拼写错误 + values.put(NoteColumns.TYPE, Notes.TYPE_SYSTEM); + db.insert(TABLE.NOTE, null, values); +} + +// 升级到V4版本的方法 +private void upgradeToV4(SQLiteDatabase db) { + // 添加新列 + db.execSQL("ALTER TABLE " + TABLE.NOTE + " ADD COLUMN " + NoteColumns.VERSION + + " INTEGER NOT NULL DEFAULT 0"); +} +} \ No newline at end of file diff --git a/作业4.txt b/作业4.txt new file mode 100644 index 0000000..0bf9a9a --- /dev/null +++ b/作业4.txt @@ -0,0 +1,221 @@ +// 导入必要的包和类 +import android.app.SearchManager; +import android.content.ContentProvider; +import android.content.ContentUris; +import android.content.ContentValues; +import android.content.Intent; +import android.content.UriMatcher; +import android.database.Cursor; +import android.database.sqlite.SQLiteDatabase; +import android.net.Uri; +import android.text.TextUtils; +import android.util.Log; + +import net.micode.notes.R; +import net.micode.notes.data.Notes.DataColumns; +import net.micode.notes.data.Notes.NoteColumns; +import net.micode.notes.data.NotesDatabaseHelper.TABLE; + +// 定义NotesProvider类，它继承自ContentProvider +public class NotesProvider extends ContentProvider { + // 使用UriMatcher来匹配不同的URI + private static final UriMatcher mMatcher; + + // 数据库帮助类，用于管理数据库的创建和版本管理 + private NotesDatabaseHelper mHelper; + + // 用于日志记录的标签 + private static final String TAG = "NotesProvider"; + + // 定义不同的URI类型 + private static final int URI_NOTE = 1; + private static final int URI_NOTE_ITEM = 2; + private static final int URI_DATA = 3; + private static final int URI_DATA_ITEM = 4; + private static final int URI_SEARCH = 5; + private static final int URI_SEARCH_SUGGEST = 6; + + // 静态代码块，用于初始化UriMatcher + static { + mMatcher = new UriMatcher(UriMatcher.NO_MATCH); + mMatcher.addURI(Notes.AUTHORITY, "note", URI_NOTE); + mMatcher.addURI(Notes.AUTHORITY, "note/#", URI_NOTE_ITEM); + mMatcher.addURI(Notes.AUTHORITY, "data", URI_DATA); + mMatcher.addURI(Notes.AUTHORITY, "data/#", URI_DATA_ITEM); + mMatcher.addURI(Notes.AUTHORITY, "search", URI_SEARCH); + mMatcher.addURI(Notes.AUTHORITY, SearchManager.SUGGEST_URI_PATH_QUERY, URI_SEARCH_SUGGEST); + mMatcher.addURI(Notes.AUTHORITY, SearchManager.SUGGEST_URI_PATH_QUERY + "/*", URI_SEARCH_SUGGEST); + } + + // 定义搜索结果的投影，用于搜索建议 + private static final String NOTES_SEARCH_PROJECTION = NoteColumns.ID + "," + + NoteColumns.ID + " AS " + SearchManager.SUGGEST_COLUMN_INTENT_EXTRA_DATA + "," + + "TRIM(REPLACE(" + NoteColumns.SNIPPET + ", x'0A','')) AS " + SearchManager.SUGGEST_COLUMN_TEXT_1 + "," + + "TRIM(REPLACE(" + NoteColumns.SNIPPET + ", x'0A','')) AS " + SearchManager.SUGGEST_COLUMN_TEXT_2 + "," + + R.drawable.search_result + " AS " + SearchManager.SUGGEST_COLUMN_ICON_1 + "," + + "'" + Intent.ACTION_VIEW + "' AS " + SearchManager.SUGGEST_COLUMN_INTENT_ACTION + "," + + "'" + Notes.TextNote.CONTENT_TYPE + "' AS " + SearchManager.SUGGEST_COLUMN_INTENT_DATA; + + // 定义搜索查询的SQL语句 + private static String NOTES_SNIPPET_SEARCH_QUERY = "SELECT " + NOTES_SEARCH_PROJECTION + + " FROM " + TABLE.NOTE + + " WHERE " + NoteColumns.SNIPPET + " LIKE ?" + + " AND " + NoteColumns.PARENT_ID + "<>" + Notes.ID_TRASH_FOLER + + " AND " + NoteColumns.TYPE + "=" + Notes.TYPE_NOTE; + + // 当内容提供者被创建时调用 + @Override + public boolean onCreate() { + mHelper = NotesDatabaseHelper.getInstance(getContext()); // 获取数据库帮助类的实例 + return true; // 返回true表示内容提供者创建成功 + } + + // 查询方法，根据URI和其他参数返回数据 + @Override + public Cursor query(Uri uri, String[] projection, String selection, String[] selectionArgs, + String sortOrder) { + Cursor c = null; + SQLiteDatabase db = mHelper.getReadableDatabase(); // 获取可读数据库实例 + String id = null; + // 根据URI匹配到的类型执行不同的查询操作 + switch (mMatcher.match(uri)) { + case URI_NOTE: + c = db.query(TABLE.NOTE, projection, selection, selectionArgs, null, null, + sortOrder); // 查询所有笔记 + break; + case URI_NOTE_ITEM: + id = uri.getPathSegments().get(1); // 获取URI中的ID部分 + c = db.query(TABLE.NOTE, projection, NoteColumns.ID + "=" + id + + parseSelection(selection), selectionArgs, null, null, sortOrder); // 查询特定ID的笔记 + break; + case URI_DATA: + c = db.query(TABLE.DATA, projection, selection, selectionArgs, null, null, + sortOrder); // 查询所有笔记数据 + break; + case URI_DATA_ITEM: + id = uri.getPathSegments().get(1); // 获取URI中的ID部分 + c = db.query(TABLE.DATA, projection, DataColumns.ID + "=" + id + + parseSelection(selection), selectionArgs, null, null, sortOrder); // 查询特定ID的笔记数据 + break; + case URI_SEARCH: + case URI_SEARCH_SUGGEST: + // 对于搜索和搜索建议，不允许指定排序、选择条件等 + if (sortOrder != null || projection != null) { + throw new IllegalArgumentException( + "do not specify sortOrder, selection, selectionArgs, or projection" + "with this query"); + } + + // 获取搜索字符串 + String searchString = null; + if (mMatcher.match(uri) == URI_SEARCH_SUGGEST) { + if (uri.getPathSegments().size() > 1) { + searchString = uri.getPathSegments().get(1); + } + } else { + searchString = uri.getQueryParameter("pattern"); + } + + // 如果搜索字符串为空，则返回null + if (TextUtils.isEmpty(searchString)) { + return null; + } + + try { + // 格式化搜索字符串并执行搜索查询 + searchString = String.format("%%%s%%", searchString); + c = db.rawQuery(NOTES_SNIPPET_SEARCH_QUERY, + new String[] { searchString }); + } catch (IllegalStateException ex) { + Log.e(TAG, "got exception: " + ex.toString()); // 记录异常日志 + } + break; + default: + throw new IllegalArgumentException("Unknown URI " + uri); // 如果URI未知，则抛出异常 + } + if (c != null) { + c.setNotificationUri(getContext().getContentResolver(), uri); // 设置通知URI，以便数据变化时通知客户端 + } + return c; // 返回查询结果 + } +// 重写insert方法，用于向数据库插入数据 +@Override +public Uri insert(Uri uri, ContentValues values) { + SQLiteDatabase db = mHelper.getWritableDatabase(); // 获取可写的数据库实例 + long dataId = 0, noteId = 0, insertedId = 0; // 初始化数据ID、笔记ID和插入ID + switch (mMatcher.match(uri)) { // 根据URI匹配器匹配URI + case URI_NOTE: // 如果是笔记URI + insertedId = noteId = db.insert(TABLE.NOTE, null, values); // 插入笔记数据，返回ID + break; + case URI_DATA: // 如果是笔记数据URI + if (values.containsKey(DataColumns.NOTE_ID)) { // 如果数据包含笔记ID + noteId = values.getAsLong(DataColumns.NOTE_ID); // 获取笔记ID + } else { + Log.d(TAG, "Wrong data format without note id:" + values.toString()); // 如果没有笔记ID，记录日志 + } + insertedId = dataId = db.insert(TABLE.DATA, null, values); // 插入笔记数据，返回ID + break; + default: + throw new IllegalArgumentException("Unknown URI " + uri); // 如果URI未知，抛出异常 + } + // 如果插入了笔记，通知笔记URI的更改 + if (noteId > 0) { + getContext().getContentResolver().notifyChange( + ContentUris.withAppendedId(Notes.CONTENT_NOTE_URI, noteId), null); + } + + // 如果插入了笔记数据，通知数据URI的更改 + if (dataId > 0) { + getContext().getContentResolver().notifyChange( + ContentUris.withAppendedId(Notes.CONTENT_DATA_URI, dataId), null); + } + + return ContentUris.withAppendedId(uri, insertedId); // 返回插入数据的URI +} + +// 重写delete方法，用于从数据库删除数据 +@Override +public int delete(Uri uri, String selection, String[] selectionArgs) { + // ... (省略了部分代码，逻辑与insert类似，但执行删除操作) +} + +// 重写update方法，用于更新数据库中的数据 +@Override +public int update(Uri uri, ContentValues values, String selection, String[] selectionArgs) { + // ... (省略了部分代码，逻辑与insert类似，但执行更新操作) +} + +// 解析选择条件字符串，如果非空，则添加AND和括号 +private String parseSelection(String selection) { + return (!TextUtils.isEmpty(selection) ? " AND (" + selection + ')' : ""); +} + +// 增加笔记的版本号 +private void increaseNoteVersion(long id, String selection, String[] selectionArgs) { + StringBuilder sql = new StringBuilder(120); // 创建SQL语句构建器 + // 构建更新笔记版本号的SQL语句 + sql.append("UPDATE ").append(TABLE.NOTE).append(" SET ").append(NoteColumns.VERSION).append("=").append(NoteColumns.VERSION).append("+1 "); + // 根据ID或选择条件添加WHERE子句 + if (id > 0 || !TextUtils.isEmpty(selection)) { + sql.append(" WHERE "); + } + if (id > 0) { + sql.append(NoteColumns.ID + "=" + String.valueOf(id)); + } + if (!TextUtils.isEmpty(selection)) { + String selectString = id > 0 ? parseSelection(selection) : selection; + for (String args : selectionArgs) { + selectString = selectString.replaceFirst("\\?", args); // 替换选择条件中的占位符 + } + sql.append(selectString); + } + + mHelper.getWritableDatabase().execSQL(sql.toString()); // 执行SQL语句 +} + +// 重写getType方法，用于获取URI的类型（此处未实现） +@Override +public String getType(Uri uri) { + // TODO Auto-generated method stub + return null; +} +} \ No newline at end of file diff --git a/作业5.txt b/作业5.txt new file mode 100644 index 0000000..6343d4f --- /dev/null +++ b/作业5.txt @@ -0,0 +1,86 @@ +// 导入必要的包 +import android.database.Cursor; +import android.util.Log; + +import net.micode.notes.tool.GTaskStringUtils; + +import org.json.JSONException; +import org.json.JSONObject; + +// 声明MetaData类，它继承自Task类 +public class MetaData extends Task { + // 定义日志标签 + private final static String TAG = MetaData.class.getSimpleName(); + + // 定义一个私有成员变量，用于存储相关的gid + private String mRelatedGid = null; + + // 定义一个方法，用于设置元数据 + public void setMeta(String gid, JSONObject metaInfo) { + try { + // 将gid添加到metaInfo JSON对象中 + metaInfo.put(GTaskStringUtils.META_HEAD_GTASK_ID, gid); + } catch (JSONException e) { + // 如果添加gid时发生JSON异常，记录错误日志 + Log.e(TAG, "failed to put related gid"); + } + // 将metaInfo转换为字符串并设置为任务的笔记内容 + setNotes(metaInfo.toString()); + // 设置任务的名称为特定的元数据名称 + setName(GTaskStringUtils.META_NOTE_NAME); + } + + // 定义一个方法，用于获取相关的gid + public String getRelatedGid() { + return mRelatedGid; + } + + // 重写isWorthSaving方法，判断该元数据是否值得保存 + @Override + public boolean isWorthSaving() { + // 如果笔记内容不为空，则认为值得保存 + return getNotes() != null; + } + + // 重写setContentByRemoteJSON方法，用于从远程JSON对象设置内容 + @Override + public void setContentByRemoteJSON(JSONObject js) { + // 调用父类的setContentByRemoteJSON方法 + super.setContentByRemoteJSON(js); + // 如果笔记内容不为空 + if (getNotes() != null) { + try { + // 将笔记内容转换为JSONObject + JSONObject metaInfo = new JSONObject(getNotes().trim()); + // 从metaInfo中获取gid并赋值给mRelatedGid + mRelatedGid = metaInfo.getString(GTaskStringUtils.META_HEAD_GTASK_ID); + } catch (JSONException e) { + // 如果获取gid时发生JSON异常，记录警告日志 + Log.w(TAG, "failed to get related gid"); + // 将mRelatedGid设置为null + mRelatedGid = null; + } + } + } + + // 重写setContentByLocalJSON方法，但该方法在此类中不应被调用 + @Override + public void setContentByLocalJSON(JSONObject js) { + // 抛出异常，表示该方法不应被调用 + throw new IllegalAccessError("MetaData:setContentByLocalJSON should not be called"); + } + + // 重写getLocalJSONFromContent方法，但该方法在此类中不应被调用 + @Override + public JSONObject getLocalJSONFromContent() { + // 抛出异常，表示该方法不应被调用 + throw new IllegalAccessError("MetaData:getLocalJSONFromContent should not be called"); + } + + // 重写getSyncAction方法，但该方法在此类中不应被调用 + @Override + public int getSyncAction(Cursor c) { + // 抛出异常，表示该方法不应被调用 + throw new IllegalAccessError("MetaData:getSyncAction should not be called"); + } +} \ No newline at end of file diff --git a/作业6.txt b/作业6.txt new file mode 100644 index 0000000..5db192f --- /dev/null +++ b/作业6.txt @@ -0,0 +1,109 @@ +// 声明版权信息，指出这个代码属于MiCode开源社区，并遵循Apache License 2.0 +/* + * Copyright (c) 2010-2011, The MiCode Open Source Community (www.micode.net) + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +// 声明包名，这个类属于net.micode.notes.gtask.data包 +package net.micode.notes.gtask.data; + +// 导入所需的Android和Java类 +import android.database.Cursor; +import org.json.JSONObject; + +// 声明一个抽象类Node，它代表了一个节点，可能是一个任务、笔记等 +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; // 错误 + + // 定义节点的基本属性 + private String mGid; // 全局唯一标识符 + private String mName; // 名称 + private long mLastModified; // 最后修改时间 + private boolean mDeleted; // 是否被删除 + + // 构造方法，初始化节点的基本属性 + public Node() { + mGid = null; + mName = ""; + mLastModified = 0; + mDeleted = false; + } + + // 抽象方法，根据同步动作ID生成创建动作的JSON对象 + public abstract JSONObject getCreateAction(int actionId); + + // 抽象方法，根据同步动作ID生成更新动作的JSON对象 + public abstract JSONObject getUpdateAction(int actionId); + + // 抽象方法，使用远程JSON对象设置节点内容 + public abstract void setContentByRemoteJSON(JSONObject js); + + // 抽象方法，使用本地JSON对象设置节点内容 + public abstract void setContentByLocalJSON(JSONObject js); + + // 抽象方法，从节点内容生成本地JSON对象 + public abstract JSONObject getLocalJSONFromContent(); + + // 抽象方法，根据Cursor对象确定同步动作 + public abstract int getSyncAction(Cursor c); + + // 设置全局唯一标识符 + public void setGid(String gid) { + this.mGid = gid; + } + + // 设置名称 + public void setName(String name) { + this.mName = name; + } + + // 设置最后修改时间 + public void setLastModified(long lastModified) { + this.mLastModified = lastModified; + } + + // 设置是否删除标志 + public void setDeleted(boolean deleted) { + this.mDeleted = deleted; + } + + // 获取全局唯一标识符 + public String getGid() { + return this.mGid; + } + + // 获取名称 + public String getName() { + return this.mName; + } + + // 获取最后修改时间 + public long getLastModified() { + return this.mLastModified; + } + + // 获取是否删除标志 + public boolean getDeleted() { + return this.mDeleted; + } +} \ No newline at end of file diff --git a/作业7.txt b/作业7.txt new file mode 100644 index 0000000..ace11f5 --- /dev/null +++ b/作业7.txt @@ -0,0 +1,179 @@ +// 定义SqlData类 +public class SqlData { + // 定义一个TAG用于日志输出 + 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, DataColumns.MIME_TYPE, DataColumns.CONTENT, DataColumns.DATA1, + DataColumns.DATA3 + }; + + // 定义列索引常量，用于从Cursor中获取数据时快速定位到相应的列 + public static final int DATA_ID_COLUMN = 0; + public static final int DATA_MIME_TYPE_COLUMN = 1; + public static final int DATA_CONTENT_COLUMN = 2; + public static final int DATA_CONTENT_DATA_1_COLUMN = 3; + public static final int DATA_CONTENT_DATA_3_COLUMN = 4; + + // 成员变量 + private 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 ContentValues mDiffDataValues; // 用于存储要更新的数据差异 + + // 构造函数，用于新创建对象时初始化 + public SqlData(Context context) { + mContentResolver = context.getContentResolver(); // 初始化内容解析器 + mIsCreate = true; // 标记为新创建 + mDataId = INVALID_ID; // 初始化ID为无效值 + mDataMimeType = DataConstants.NOTE; // 设置MIME类型为笔记 + mDataContent = ""; // 初始化内容为空字符串 + mDataContentData1 = 0; // 初始化附加数据1为0 + mDataContentData3 = ""; // 初始化附加数据3为空字符串 + mDiffDataValues = new ContentValues(); // 初始化数据差异存储对象 + } + + // 构造函数，用于从Cursor中加载现有数据 + public SqlData(Context context, Cursor c) { + mContentResolver = context.getContentResolver(); // 初始化内容解析器 + mIsCreate = false; // 标记为非新创建 + loadFromCursor(c); // 从Cursor加载数据 + mDiffDataValues = new ContentValues(); // 初始化数据差异存储对象 + } + + // 私有方法，用于从Cursor加载数据到成员变量 + private void loadFromCursor(Cursor c) { + mDataId = c.getLong(DATA_ID_COLUMN); // 从Cursor获取数据ID + mDataMimeType = c.getString(DATA_MIME_TYPE_COLUMN); // 从Cursor获取MIME类型 + mDataContent = c.getString(DATA_CONTENT_COLUMN); // 从Cursor获取内容 + mDataContentData1 = c.getLong(DATA_CONTENT_DATA_1_COLUMN); // 从Cursor获取附加数据1 + mDataContentData3 = c.getString(DATA_CONTENT_DATA_3_COLUMN); // 从Cursor获取附加数据3 + } +} +// 定义一个方法，用于设置内容，接收一个JSONObject参数，并抛出JSONException异常 +public void setContent(JSONObject js) throws JSONException { + // 尝试从JSONObject中获取ID，如果不存在则使用INVALID_ID + long dataId = js.has(DataColumns.ID) ? js.getLong(DataColumns.ID) : INVALID_ID; + // 如果是创建新数据或当前数据ID与传入的数据ID不同，则更新差异数据集合 + if (mIsCreate || mDataId != dataId) { + mDiffDataValues.put(DataColumns.ID, dataId); + } + // 更新当前数据ID + mDataId = dataId; + + // 尝试从JSONObject中获取MIME类型，如果不存在则使用默认的NOTE类型 + String dataMimeType = js.has(DataColumns.MIME_TYPE) ? js.getString(DataColumns.MIME_TYPE) + : DataConstants.NOTE; + // 如果是创建新数据或当前MIME类型与传入的MIME类型不同，则更新差异数据集合 + if (mIsCreate || !mDataMimeType.equals(dataMimeType)) { + mDiffDataValues.put(DataColumns.MIME_TYPE, dataMimeType); + } + // 更新当前MIME类型 + mDataMimeType = dataMimeType; + + // 尝试从JSONObject中获取内容，如果不存在则使用空字符串 + String dataContent = js.has(DataColumns.CONTENT) ? js.getString(DataColumns.CONTENT) : ""; + // 如果是创建新数据或当前内容与传入的内容不同，则更新差异数据集合 + if (mIsCreate || !mDataContent.equals(dataContent)) { + mDiffDataValues.put(DataColumns.CONTENT, dataContent); + } + // 更新当前内容 + mDataContent = dataContent; + + // 尝试从JSONObject中获取DATA1，如果不存在则使用0 + long dataContentData1 = js.has(DataColumns.DATA1) ? js.getLong(DataColumns.DATA1) : 0; + // 如果是创建新数据或当前DATA1与传入的DATA1不同，则更新差异数据集合 + if (mIsCreate || mDataContentData1 != dataContentData1) { + mDiffDataValues.put(DataColumns.DATA1, dataContentData1); + } + // 更新当前DATA1 + mDataContentData1 = dataContentData1; + + // 尝试从JSONObject中获取DATA3，如果不存在则使用空字符串 + String dataContentData3 = js.has(DataColumns.DATA3) ? js.getString(DataColumns.DATA3) : ""; + // 如果是创建新数据或当前DATA3与传入的DATA3不同，则更新差异数据集合 + if (mIsCreate || !mDataContentData3.equals(dataContentData3)) { + mDiffDataValues.put(DataColumns.DATA3, dataContentData3); + } + // 更新当前DATA3 + mDataContentData3 = dataContentData3; +} + +// 定义一个方法，用于获取当前设置的内容，返回一个JSONObject +public JSONObject getContent() throws JSONException { + // 如果是创建新数据，则记录错误日志并返回null + if (mIsCreate) { + Log.e(TAG, "it seems that we haven't created this in database yet"); + return null; + } + // 创建一个新的JSONObject并填充数据 + 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; +} + +// 定义一个方法，用于提交数据到数据库 +public void commit(long noteId, boolean validateVersion, long version) { + // 如果是创建新数据 + if (mIsCreate) { + // 如果当前数据ID是INVALID_ID且差异数据集合中包含ID，则移除ID + if (mDataId == INVALID_ID && mDiffDataValues.containsKey(DataColumns.ID)) { + mDiffDataValues.remove(DataColumns.ID); + } + // 添加笔记ID到差异数据集合 + mDiffDataValues.put(DataColumns.NOTE_ID, noteId); + // 插入数据到数据库，并获取返回的Uri + Uri uri = mContentResolver.insert(Notes.CONTENT_DATA_URI, mDiffDataValues); + try { + // 从Uri中提取数据ID + mDataId = Long.valueOf(uri.getPathSegments().get(1)); + } catch (NumberFormatException e) { + // 如果提取失败，记录错误日志并抛出异常 + Log.e(TAG, "Get note id error :" + e.toString()); + throw new ActionFailureException("create note failed"); + } + } else { + // 如果不是创建新数据，且差异数据集合不为空 + if (mDiffDataValues.size() > 0) { + int result = 0; + // 根据是否验证版本，执行不同的更新操作 + 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) + }); + } + // 如果更新结果为0，记录警告日志 + if (result == 0) { + Log.w(TAG, "there is no update. maybe user updates note when syncing"); + } + } + } + // 清空差异数据集合 + mDiffDataValues.clear(); + // 标记为非创建状态 + mIsCreate = false; +} + +// 定义一个方法，用于获取当前数据ID +public long getId() { + return mDataId; +} +} \ No newline at end of file diff --git a/作业8.txt b/作业8.txt new file mode 100644 index 0000000..98d2a57 --- /dev/null +++ b/作业8.txt @@ -0,0 +1,493 @@ +// 导入所需的类和接口 +import android.appwidget.AppWidgetManager; +import android.content.ContentResolver; +import android.content.ContentValues; +import android.content.Context; +import android.database.Cursor; +import android.net.Uri; +import android.util.Log; + +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; +import net.micode.notes.tool.ResourceParser; + +import org.json.JSONArray; +import org.json.JSONException; +import org.json.JSONObject; + +import java.util.ArrayList; + +// 声明SqlNote类 +public class SqlNote { + // 定义日志标签 + private static final String TAG = SqlNote.class.getSimpleName(); + + // 定义无效ID常量 + private static final int INVALID_ID = -99999; + + // 定义从数据库查询Note时需要的列 + public static final String[] PROJECTION_NOTE = new String[] { + NoteColumns.ID, NoteColumns.ALERTED_DATE, NoteColumns.BG_COLOR_ID, + NoteColumns.CREATED_DATE, NoteColumns.HAS_ATTACHMENT, NoteColumns.MODIFIED_DATE, + NoteColumns.NOTES_COUNT, NoteColumns.PARENT_ID, NoteColumns.SNIPPET, NoteColumns.TYPE, + NoteColumns.WIDGET_ID, NoteColumns.WIDGET_TYPE, NoteColumns.SYNC_ID, + NoteColumns.LOCAL_MODIFIED, NoteColumns.ORIGIN_PARENT_ID, NoteColumns.GTASK_ID, + NoteColumns.VERSION + }; + + // 定义各列在PROJECTION_NOTE数组中的索引 + public static final int ID_COLUMN = 0; + // ... 其他列的索引定义 + + // 类的成员变量 + private Context mContext; // 应用上下文 + private ContentResolver mContentResolver; // 内容解析器，用于访问内容提供者 + private boolean mIsCreate; // 标记是否是新建 + private long mId; // 笔记ID + // ... 其他成员变量定义 + + // 构造函数 + public SqlNote(Context context) { + mContext = context; // 初始化上下文 + mContentResolver = context.getContentResolver(); // 初始化内容解析器 + mIsCreate = true; // 标记为新建 + mId = INVALID_ID; // 初始化ID为无效ID + mAlertDate = 0; // 初始化提醒日期 + mBgColorId = ResourceParser.getDefaultBgId(context); // 初始化背景颜色ID + mCreatedDate = System.currentTimeMillis(); // 初始化创建日期为当前时间 + mHasAttachment = 0; // 初始化是否有附件标记 + mModifiedDate = System.currentTimeMillis(); // 初始化修改日期为当前时间 + mParentId = 0; // 初始化父ID + mSnippet = ""; // 初始化摘要 + mType = Notes.TYPE_NOTE; // 初始化类型 + mWidgetId = AppWidgetManager.INVALID_APPWIDGET_ID; // 初始化小部件ID为无效ID + mWidgetType = Notes.TYPE_WIDGET_INVALIDE; // 初始化小部件类型 + mOriginParent = 0; // 初始化原始父ID + mVersion = 0; // 初始化版本 + mDiffNoteValues = new ContentValues(); // 初始化差异值存储 + mDataList = new ArrayList(); // 初始化数据列表 + } +// 构造函数，通过上下文和Cursor对象来初始化SqlNote对象 +public SqlNote(Context context, Cursor c) { + mContext = context; // 保存上下文引用 + mContentResolver = context.getContentResolver(); // 获取内容解析器实例，用于与Content Providers交互 + mIsCreate = false; // 标记这个对象不是新创建的（即不是通过插入操作创建的） + loadFromCursor(c); // 从传入的Cursor加载数据 + mDataList = new ArrayList(); // 初始化数据存储列表，用于存储笔记的附加数据 + if (mType == Notes.TYPE_NOTE) // 如果笔记类型是普通笔记 + loadDataContent(); // 加载笔记的详细内容 + mDiffNoteValues = new ContentValues(); // 初始化ContentValues对象，用于存储笔记的更改（可能用于更新操作） +} + +// 构造函数，通过上下文和笔记ID来初始化SqlNote对象 +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(); // 初始化ContentValues对象 +} + +// 私有方法，根据传入的笔记ID加载数据 +private void loadFromCursor(long id) { + Cursor c = null; // 声明Cursor对象 + try { + // 使用内容解析器查询数据库，获取指定ID的笔记数据 + c = mContentResolver.query(Notes.CONTENT_NOTE_URI, PROJECTION_NOTE, "(_id=?)", + new String[] { String.valueOf(id) }, null); + if (c != null) { + c.moveToNext(); // 移动到Cursor的第一行（如果存在） + loadFromCursor(c); // 从Cursor加载数据 + } else { + Log.w(TAG, "loadFromCursor: cursor = null"); // 如果Cursor为空，记录警告日志 + } + } finally { + if (c != null) + c.close(); // 关闭Cursor + } +} + +// 私有方法，从传入的Cursor加载数据到SqlNote对象的属性中 +private void loadFromCursor(Cursor c) { + mId = c.getLong(ID_COLUMN); // 加载笔记ID + mAlertDate = c.getLong(ALERTED_DATE_COLUMN); // 加载提醒日期 + mBgColorId = c.getInt(BG_COLOR_ID_COLUMN); // 加载背景颜色ID + mCreatedDate = c.getLong(CREATED_DATE_COLUMN); // 加载创建日期 + mHasAttachment = c.getInt(HAS_ATTACHMENT_COLUMN); // 加载是否有附件的标记 + mModifiedDate = c.getLong(MODIFIED_DATE_COLUMN); // 加载修改日期 + mParentId = c.getLong(PARENT_ID_COLUMN); // 加载父笔记ID + mSnippet = c.getString(SNIPPET_COLUMN); // 加载摘要文本 + mType = c.getInt(TYPE_COLUMN); // 加载笔记类型 + mWidgetId = c.getInt(WIDGET_ID_COLUMN); // 加载小部件ID + mWidgetType = c.getInt(WIDGET_TYPE_COLUMN); // 加载小部件类型 + mVersion = c.getLong(VERSION_COLUMN); // 加载版本号 +} + +// 私有方法，加载笔记的详细内容（如附加的数据项） +private void loadDataContent() { + Cursor c = null; // 声明Cursor对象 + mDataList.clear(); // 清空数据列表，准备加载新数据 + try { + // 使用内容解析器查询数据库，获取指定笔记ID的所有数据项 + c = mContentResolver.query(Notes.CONTENT_DATA_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()) { // 遍历Cursor，为每一个数据项创建一个SqlData对象并添加到列表中 + SqlData data = new SqlData(mContext, c); + mDataList.add(data); + } + } else { + Log.w(TAG, "loadDataContent: cursor = null"); // 如果Cursor为空，记录警告日志 + } + } finally { + if (c != null) + c.close(); // 关闭Cursor + } +} +// 定义一个方法，接收一个JSONObject参数，返回一个布尔值 +public boolean setContent(JSONObject js) { + try { + // 从传入的JSONObject中获取名为GTaskStringUtils.META_HEAD_NOTE的JSONObject + 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) { + // 更新snippet和type属性，如果它们是新的或者发生了变化 + 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; + + // 更新alertDate属性 + 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; + + // 更新bgColorId属性 + 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; + + // 更新createDate属性 + 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; + + // 更新hasAttachment属性 + 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; + + // 更新modifiedDate属性 + 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; + + // 更新parentId属性 + 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; + + // 更新snippet属性（对于普通笔记再次处理，可能是因为前面处理文件夹时也用了这个名字的变量） + String snippet = note.has(NoteColumns.SNIPPET) ? note.getString(NoteColumns.SNIPPET) : ""; + if (mIsCreate || !mSnippet.equals(snippet)) { + mDiffNoteValues.put(NoteColumns.SNIPPET, snippet); + } + mSnippet = snippet; + + // 更新type属性（对于普通笔记再次处理） + int type = note.has(NoteColumns.TYPE) ? note.getInt(NoteColumns.TYPE) : Notes.TYPE_NOTE; + if (mIsCreate || mType != type) { + mDiffNoteValues.put(NoteColumns.TYPE, type); + } + mType = type; + + // 更新widgetId属性 + 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; + + // 更新widgetType属性 + 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; + + // 更新originParent属性 + 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; + + // 遍历数据数组，为每个数据项创建或更新SqlData对象 + for (int i = 0; i < dataArray.length(); i++) { + JSONObject data = dataArray.getJSONObject(i); + SqlData sqlData = null; + // 如果数据项有ID，则尝试在已有数据中查找匹配的SqlData对象 + if (data.has(DataColumns.ID)) { + long dataId = data.getLong(DataColumns.ID); + for (SqlData temp : mDataList) { + if (dataId == temp.getId()) { + sqlData = temp; + } + } + } + + // 如果没有找到匹配的SqlData对象，则创建一个新的 + if (sqlData == null) { + sqlData = new SqlData(mContext); + mDataList.add(sqlData); + } + + // 更新SqlData对象的内容 + sqlData.setContent(data); + } + } + } catch (JSONException e) { + // 捕获JSON异常，打印错误日志 + Log.e(TAG, e.toString()); + e.printStackTrace(); + // 返回false表示处理失败 + return false; + } + // 如果没有异常发生，返回true表示处理成功 + return true; +} +// 定义一个方法，用于获取当前对象的JSON表示 +public JSONObject getContent() { + try { + // 创建一个空的JSONObject用于存储将要返回的数据 + JSONObject js = new JSONObject(); + + // 如果标记为已创建（但数据库中没有记录），则记录日志并返回null + if (mIsCreate) { + Log.e(TAG, "it seems that we haven't created this in database yet"); + return null; + } + + // 创建一个新的JSONObject用于存储笔记信息 + JSONObject note = new JSONObject(); + + // 如果当前对象是笔记类型 + if (mType == Notes.TYPE_NOTE) { + // 向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); + // 将note对象添加到js对象中，使用特定的键 + js.put(GTaskStringUtils.META_HEAD_NOTE, note); + + // 创建一个JSONArray用于存储数据列表 + JSONArray dataArray = new JSONArray(); + // 遍历数据列表，将每个数据项的JSON表示添加到dataArray中 + for (SqlData sqlData : mDataList) { + JSONObject data = sqlData.getContent(); + if (data != null) { + dataArray.put(data); + } + } + // 将dataArray添加到js对象中，使用特定的键 + js.put(GTaskStringUtils.META_HEAD_DATA, dataArray); + } + // 如果当前对象是文件夹或系统类型 + else if (mType == Notes.TYPE_FOLDER || mType == Notes.TYPE_SYSTEM) { + // 向note对象中添加ID、类型和摘要信息 + note.put(NoteColumns.ID, mId); + note.put(NoteColumns.TYPE, mType); + note.put(NoteColumns.SNIPPET, mSnippet); + // 将note对象添加到js对象中，使用特定的键 + js.put(GTaskStringUtils.META_HEAD_NOTE, note); + } + + // 返回构建的JSONObject + return js; + } catch (JSONException e) { + // 捕获JSON异常并记录错误日志 + Log.e(TAG, e.toString()); + e.printStackTrace(); + } + // 如果发生异常，返回null + return null; +} + +// 设置父ID的方法 +public void setParentId(long id) { + mParentId = id; + // 将更改记录到差异映射中，以便稍后提交 + mDiffNoteValues.put(NoteColumns.PARENT_ID, id); +} + +// 设置Gtask ID的方法 +public void setGtaskId(String gid) { + // 将Gtask ID记录到差异映射中 + mDiffNoteValues.put(NoteColumns.GTASK_ID, gid); +} + +// 设置同步ID的方法 +public void setSyncId(long syncId) { + // 将同步ID记录到差异映射中 + mDiffNoteValues.put(NoteColumns.SYNC_ID, syncId); +} + +// 重置本地修改标记的方法 +public void resetLocalModified() { + // 将本地修改标记设置为0，表示未修改 + mDiffNoteValues.put(NoteColumns.LOCAL_MODIFIED, 0); +} + +// 获取ID的方法 +public long getId() { + return mId; +} + +// 获取父ID的方法 +public long getParentId() { + return mParentId; +} + +// 获取摘要信息的方法 +public String getSnippet() { + return mSnippet; +} + +// 判断当前对象是否为笔记类型的方法 +public boolean isNoteType() { + return mType == Notes.TYPE_NOTE; +} + +// 提交更改的方法，包括创建和更新操作 +public void commit(boolean validateVersion) { + // 如果是创建操作 + if (mIsCreate) { + // 如果ID无效但差异映射中包含ID，则移除ID + if (mId == INVALID_ID && mDiffNoteValues.containsKey(NoteColumns.ID)) { + mDiffNoteValues.remove(NoteColumns.ID); + } + + // 插入新记录到内容提供者，并获取新记录的ID + Uri uri = mContentResolver.insert(Notes.CONTENT_NOTE_URI, mDiffNoteValues); + try { + mId = Long.valueOf(uri.getPathSegments().get(1)); + } catch (NumberFormatException e) { + // 捕获数字格式异常并记录错误日志 + Log.e(TAG, "Get note id error :" + e.toString()); + throw new ActionFailureException("create note failed"); + } + // 如果ID无效，则抛出异常 + 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.size() > 0) { + 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; +} \ No newline at end of file diff --git a/作业9.txt b/作业9.txt new file mode 100644 index 0000000..83b37e7 --- /dev/null +++ b/作业9.txt @@ -0,0 +1,345 @@ +// 声明Task类的开始，继承自Node类 +public class Task extends Node { + // 定义一个静态常量TAG用于日志记录 + private static final String TAG = Task.class.getSimpleName(); + + // 定义一个布尔变量来表示任务是否完成 + private boolean mCompleted; + + // 定义一个字符串变量来存储与任务相关的笔记 + private String mNotes; + + // 定义一个JSONObject变量来存储任务的元数据 + private JSONObject mMetaInfo; + + // 定义一个Task变量来表示任务的前一个同级任务 + private Task mPriorSibling; + + // 定义一个TaskList变量来表示任务所属的父任务列表 + private TaskList mParent; + + // Task类的构造函数，初始化所有成员变量 + public Task() { + super(); + mCompleted = false; // 任务初始化为未完成状态 + mNotes = null; // 笔记初始化为null + mPriorSibling = null; // 前一个同级任务初始化为null + mParent = null; // 父任务列表初始化为null + mMetaInfo = null; // 元数据初始化为null + } + + // 获取创建任务的JSON对象的方法 + public JSONObject getCreateAction(int actionId) { + JSONObject js = new JSONObject(); // 创建一个新的JSONObject对象 + + try { + // 设置action_type为创建任务 + js.put(GTaskStringUtils.GTASK_JSON_ACTION_TYPE, + GTaskStringUtils.GTASK_JSON_ACTION_TYPE_CREATE); + + // 设置action_id + js.put(GTaskStringUtils.GTASK_JSON_ACTION_ID, actionId); + + // 设置任务在其父列表中的索引位置 + js.put(GTaskStringUtils.GTASK_JSON_INDEX, mParent.getChildTaskIndex(this)); + + // 创建一个新的JSONObject对象来表示任务的实体信息 + JSONObject entity = new JSONObject(); + entity.put(GTaskStringUtils.GTASK_JSON_NAME, getName()); // 设置任务名称 + entity.put(GTaskStringUtils.GTASK_JSON_CREATOR_ID, "null"); // 设置创建者ID为null + 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); // 将实体信息添加到JSON对象中 + + // 设置父任务的ID + js.put(GTaskStringUtils.GTASK_JSON_PARENT_ID, mParent.getGid()); + + // 设置目标父类型（此处为组类型） + js.put(GTaskStringUtils.GTASK_JSON_DEST_PARENT_TYPE, + GTaskStringUtils.GTASK_JSON_TYPE_GROUP); + + // 设置列表ID（与父任务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("fail to generate task-create jsonobject"); // 抛出自定义异常 + } + + return js; // 返回创建的JSON对象 + } + + // 获取更新任务的JSON对象的方法 + public JSONObject getUpdateAction(int actionId) { + JSONObject js = new JSONObject(); // 创建一个新的JSONObject对象 + + try { + // 设置action_type为更新任务 + js.put(GTaskStringUtils.GTASK_JSON_ACTION_TYPE, + GTaskStringUtils.GTASK_JSON_ACTION_TYPE_UPDATE); + + // 设置action_id + js.put(GTaskStringUtils.GTASK_JSON_ACTION_ID, actionId); + + // 设置任务的ID + js.put(GTaskStringUtils.GTASK_JSON_ID, getGid()); + + // 创建一个新的JSONObject对象来表示任务的实体信息 + 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); // 将实体信息添加到JSON对象中 + + } catch (JSONException e) { + Log.e(TAG, e.toString()); // 记录异常日志 + e.printStackTrace(); // 打印异常堆栈信息 + throw new ActionFailureException("fail to generate task-update jsonobject"); // 抛出自定义异常 + } + + return js; // 返回创建的JSON对象 + } +} + // 从远程JSON对象中设置内容 +public void setContentByRemoteJSON(JSONObject js) { + if (js != null) { // 检查JSON对象是否为null + try { + // id + if (js.has(GTaskStringUtils.GTASK_JSON_ID)) { // 检查JSON中是否有id字段 + setGid(js.getString(GTaskStringUtils.GTASK_JSON_ID)); // 获取id并设置 + } + + // last_modified + if (js.has(GTaskStringUtils.GTASK_JSON_LAST_MODIFIED)) { // 检查是否有最后修改时间字段 + setLastModified(js.getLong(GTaskStringUtils.GTASK_JSON_LAST_MODIFIED)); // 获取并设置最后修改时间 + } + + // name + if (js.has(GTaskStringUtils.GTASK_JSON_NAME)) { // 检查是否有名称字段 + setName(js.getString(GTaskStringUtils.GTASK_JSON_NAME)); // 获取并设置名称 + } + + // notes + if (js.has(GTaskStringUtils.GTASK_JSON_NOTES)) { // 检查是否有笔记字段 + setNotes(js.getString(GTaskStringUtils.GTASK_JSON_NOTES)); // 获取并设置笔记 + } + + // deleted + if (js.has(GTaskStringUtils.GTASK_JSON_DELETED)) { // 检查是否有删除标记字段 + setDeleted(js.getBoolean(GTaskStringUtils.GTASK_JSON_DELETED)); // 获取并设置删除标记 + } + + // completed + if (js.has(GTaskStringUtils.GTASK_JSON_COMPLETED)) { // 检查是否有完成标记字段 + setCompleted(js.getBoolean(GTaskStringUtils.GTASK_JSON_COMPLETED)); // 获取并设置完成标记 + } + } catch (JSONException e) { // 捕获JSON解析异常 + Log.e(TAG, e.toString()); // 打印错误日志 + e.printStackTrace(); // 打印堆栈跟踪 + throw new ActionFailureException("fail to get task content from jsonobject"); // 抛出自定义异常 + } + } +} + +// 从本地JSON对象中设置内容 +public void setContentByLocalJSON(JSONObject js) { + if (js == null || !js.has(GTaskStringUtils.META_HEAD_NOTE) || !js.has(GTaskStringUtils.META_HEAD_DATA)) { // 检查JSON对象是否为null或缺少必要的字段 + Log.w(TAG, "setContentByLocalJSON: nothing is avaiable"); // 打印警告日志 + } + + try { + JSONObject note = 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, "invalid type"); // 打印错误日志 + return; // 退出方法 + } + + for (int i = 0; i < dataArray.length(); i++) { // 遍历数据数组 + JSONObject data = dataArray.getJSONObject(i); // 获取数据对象 + if (TextUtils.equals(data.getString(DataColumns.MIME_TYPE), DataConstants.NOTE)) { // 检查MIME类型是否为笔记 + setName(data.getString(DataColumns.CONTENT)); // 设置名称 + break; // 找到后退出循环 + } + } + + } catch (JSONException e) { // 捕获JSON解析异常 + Log.e(TAG, e.toString()); // 打印错误日志 + e.printStackTrace(); // 打印堆栈跟踪 + } +} + +// 从内容获取本地JSON对象 +public JSONObject getLocalJSONFromContent() { + String name = getName(); // 获取名称 + try { + if (mMetaInfo == null) { // 检查元数据是否为null + // new task created from web + if (name == null) { // 检查名称是否为null + Log.w(TAG, "the note seems to be an empty one"); // 打印警告日志 + return null; // 返回null + } + + JSONObject js = new JSONObject(); // 创建新的JSON对象 + 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); // 将数据数组添加到JSON对象 + note.put(NoteColumns.TYPE, Notes.TYPE_NOTE); // 设置笔记类型 + js.put(GTaskStringUtils.META_HEAD_NOTE, note); // 将笔记对象添加到JSON对象 + return js; // 返回JSON对象 + } else { + // synced task + 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)) { // 检查MIME类型是否为笔记 + data.put(DataColumns.CONTENT, getName()); // 设置名称 + break; // 找到后退出循环 + } + } + + note.put(NoteColumns.TYPE, Notes.TYPE_NOTE); // 设置笔记类型（这里看起来有些冗余，因为前面已经设置过了） + return mMetaInfo; // 返回元数据 + } + } catch (JSONException e) { // 捕获JSON解析异常 + Log.e(TAG, e.toString()); // 打印错误日志 + e.printStackTrace(); // 打印堆栈跟踪 + return null; // 返回null + } +} + +// 设置元数据 +public void setMetaInfo(MetaData metaData) { + if (metaData != null && metaData.getNotes() != null) { // 检查MetaData对象和Notes字段是否为null + try { + mMetaInfo = new JSONObject(metaData.getNotes()); // 将Notes字段转换为JSON对象 + } catch (JSONException e) { // 捕获JSON解析异常 + Log.w(TAG, e.toString()); // 打印警告日志 + mMetaInfo = null; // 将元数据设置为null + } + } +} +// 定义一个方法，用于从Cursor中获取同步操作类型 +public int getSyncAction(Cursor c) { + try { + // 初始化一个JSONObject用于存储笔记信息 + JSONObject noteInfo = null; + // 检查是否存在元数据，并且元数据中包含笔记头部信息 + if (mMetaInfo != null && mMetaInfo.has(GTaskStringUtils.META_HEAD_NOTE)) { + noteInfo = mMetaInfo.getJSONObject(GTaskStringUtils.META_HEAD_NOTE); + } + + // 如果noteInfo为空，表示笔记元数据已被删除 + if (noteInfo == null) { + Log.w(TAG, "it seems that note meta has been deleted"); + return SYNC_ACTION_UPDATE_REMOTE; // 返回更新远程的操作 + } + + // 检查noteInfo中是否包含笔记ID + if (!noteInfo.has(NoteColumns.ID)) { + Log.w(TAG, "remote note id seems to be deleted"); + return SYNC_ACTION_UPDATE_LOCAL; // 返回更新本地的操作 + } + + // 验证笔记ID是否匹配 + if (c.getLong(SqlNote.ID_COLUMN) != noteInfo.getLong(NoteColumns.ID)) { + Log.w(TAG, "note id doesn't match"); + return SYNC_ACTION_UPDATE_LOCAL; // ID不匹配，返回更新本地的操作 + } + + // 检查本地是否有修改 + 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 { + // 如果有本地修改，验证gtask ID + if (!c.getString(SqlNote.GTASK_ID_COLUMN).equals(getGid())) { + Log.e(TAG, "gtask id doesn't match"); + return SYNC_ACTION_ERROR; // gtask ID不匹配，返回错误 + } + 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; +} + +// 判断该对象是否值得保存 +public boolean isWorthSaving() { + return mMetaInfo != null || (getName() != null && getName().trim().length() > 0) + || (getNotes() != null && getNotes().trim().length() > 0); +} + +// 设置任务是否完成 +public void setCompleted(boolean completed) { + this.mCompleted = completed; +} + +// 设置笔记内容 +public void setNotes(String notes) { + this.mNotes = notes; +} + +// 设置前置兄弟任务 +public void setPriorSibling(Task priorSibling) { + this.mPriorSibling = priorSibling; +} + +// 设置父任务列表 +public void setParent(TaskList parent) { + this.mParent = parent; +} + +// 获取任务是否完成 +public boolean getCompleted() { + return this.mCompleted; +} + +// 获取笔记内容 +public String getNotes() { + return this.mNotes; +} + +// 获取前置兄弟任务 +public Task getPriorSibling() { + return this.mPriorSibling; +} + +// 获取父任务列表 +public TaskList getParent() { + return this.mParent; +} +} \ No newline at end of file