From 4227a8ff28dadce7d648b6b3a0ad2216283c510c Mon Sep 17 00:00:00 2001 From: pgwuqvec3 <2191035995@qq.com> Date: Sun, 20 Oct 2024 19:20:05 +0800 Subject: [PATCH 1/9] Initial commit --- README.md | 2 ++ 1 file changed, 2 insertions(+) create mode 100644 README.md diff --git a/README.md b/README.md new file mode 100644 index 0000000..a6ed909 --- /dev/null +++ b/README.md @@ -0,0 +1,2 @@ +# note + -- 2.34.1 From 31c46799de516137790fbf8e8c2e5d2f9caaf08d Mon Sep 17 00:00:00 2001 From: yj <2191035995@qq.com> Date: Sun, 20 Oct 2024 19:25:30 +0800 Subject: [PATCH 2/9] 1 --- Contact.java | 91 ++++++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 91 insertions(+) create mode 100644 Contact.java diff --git a/Contact.java b/Contact.java new file mode 100644 index 0000000..119de7a --- /dev/null +++ b/Contact.java @@ -0,0 +1,91 @@ +/* + * 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. + */ + +package net.micode.notes.data; + +import android.content.Context; +import android.database.Cursor; +import android.provider.ContactsContract.CommonDataKinds.Phone; +import android.provider.ContactsContract.Data; +import android.telephony.PhoneNumberUtils; +import android.util.Log; + +import java.util.HashMap; + +public class Contact { + // 静态缓存，用于存储已查询过的电话号码对应的联系人姓名 + private static HashMap sContactCache; + // 用于日志记录的标签 + private static final String TAG = "Contact"; + + // 查询条件，用于根据电话号码查询联系人姓名 + private static final String CALLER_ID_SELECTION = "PHONE_NUMBERS_EQUAL(" + Phone.NUMBER + + ",?) AND " + Data.MIMETYPE + "='" + Phone.CONTENT_ITEM_TYPE + "'" + + " AND " + Data.RAW_CONTACT_ID + " IN " + + "(SELECT raw_contact_id " + + " FROM phone_lookup" + + " WHERE min_match = '+')"; + + /** + * 获取电话号码对应的联系人姓名 + * @param context 应用程序的上下文 + * @param phoneNumber 要查询的电话号码 + * @return 返回电话号码对应的联系人姓名，如果找不到则返回null + */ + public static String getContact(Context context, String phoneNumber) { + // 初始化缓存 + if(sContactCache == null) { + sContactCache = new HashMap(); + } + + // 如果缓存中已经有该电话号码的联系人信息，直接返回 + if(sContactCache.containsKey(phoneNumber)) { + return sContactCache.get(phoneNumber); + } + + // 使用电话号码生成查询条件 + String selection = CALLER_ID_SELECTION.replace("+", + PhoneNumberUtils.toCallerIDMinMatch(phoneNumber)); + + // 查询联系人信息 + Cursor cursor = context.getContentResolver().query( + Data.CONTENT_URI, + new String [] { Phone.DISPLAY_NAME }, // 需要获取的字段，这里是联系人姓名 + selection, // 查询条件 + new String[] { phoneNumber }, // 查询参数，填充到查询条件中 + null); // 排序方式，null表示不排序 + + // 检查查询结果并返回联系人姓名 + if (cursor != null && cursor.moveToFirst()) { + try { + String name = cursor.getString(0); // 获取查询到的联系人姓名 + sContactCache.put(phoneNumber, name); // 将结果缓存起来 + return name; // 返回联系人姓名 + } catch (IndexOutOfBoundsException e) { + // 捕捉异常并记录错误日志 + Log.e(TAG, " Cursor get string error " + e.toString()); + return null; + } finally { + // 关闭游标，释放资源 + cursor.close(); + } + } else { + // 如果没有匹配的联系人，记录日志并返回null + Log.d(TAG, "No contact matched with number:" + phoneNumber); + return null; + } + } +} -- 2.34.1 From 295d5323cd096b05cce4a969d140274a8dfcb7d1 Mon Sep 17 00:00:00 2001 From: yj <2191035995@qq.com> Date: Sun, 20 Oct 2024 19:25:30 +0800 Subject: [PATCH 3/9] 1 --- Contact.java | 91 ++++++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 91 insertions(+) create mode 100644 Contact.java diff --git a/Contact.java b/Contact.java new file mode 100644 index 0000000..119de7a --- /dev/null +++ b/Contact.java @@ -0,0 +1,91 @@ +/* + * 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. + */ + +package net.micode.notes.data; + +import android.content.Context; +import android.database.Cursor; +import android.provider.ContactsContract.CommonDataKinds.Phone; +import android.provider.ContactsContract.Data; +import android.telephony.PhoneNumberUtils; +import android.util.Log; + +import java.util.HashMap; + +public class Contact { + // 静态缓存，用于存储已查询过的电话号码对应的联系人姓名 + private static HashMap sContactCache; + // 用于日志记录的标签 + private static final String TAG = "Contact"; + + // 查询条件，用于根据电话号码查询联系人姓名 + private static final String CALLER_ID_SELECTION = "PHONE_NUMBERS_EQUAL(" + Phone.NUMBER + + ",?) AND " + Data.MIMETYPE + "='" + Phone.CONTENT_ITEM_TYPE + "'" + + " AND " + Data.RAW_CONTACT_ID + " IN " + + "(SELECT raw_contact_id " + + " FROM phone_lookup" + + " WHERE min_match = '+')"; + + /** + * 获取电话号码对应的联系人姓名 + * @param context 应用程序的上下文 + * @param phoneNumber 要查询的电话号码 + * @return 返回电话号码对应的联系人姓名，如果找不到则返回null + */ + public static String getContact(Context context, String phoneNumber) { + // 初始化缓存 + if(sContactCache == null) { + sContactCache = new HashMap(); + } + + // 如果缓存中已经有该电话号码的联系人信息，直接返回 + if(sContactCache.containsKey(phoneNumber)) { + return sContactCache.get(phoneNumber); + } + + // 使用电话号码生成查询条件 + String selection = CALLER_ID_SELECTION.replace("+", + PhoneNumberUtils.toCallerIDMinMatch(phoneNumber)); + + // 查询联系人信息 + Cursor cursor = context.getContentResolver().query( + Data.CONTENT_URI, + new String [] { Phone.DISPLAY_NAME }, // 需要获取的字段，这里是联系人姓名 + selection, // 查询条件 + new String[] { phoneNumber }, // 查询参数，填充到查询条件中 + null); // 排序方式，null表示不排序 + + // 检查查询结果并返回联系人姓名 + if (cursor != null && cursor.moveToFirst()) { + try { + String name = cursor.getString(0); // 获取查询到的联系人姓名 + sContactCache.put(phoneNumber, name); // 将结果缓存起来 + return name; // 返回联系人姓名 + } catch (IndexOutOfBoundsException e) { + // 捕捉异常并记录错误日志 + Log.e(TAG, " Cursor get string error " + e.toString()); + return null; + } finally { + // 关闭游标，释放资源 + cursor.close(); + } + } else { + // 如果没有匹配的联系人，记录日志并返回null + Log.d(TAG, "No contact matched with number:" + phoneNumber); + return null; + } + } +} -- 2.34.1 From 2411f75cb7f0730e2e6c13458cff080e1c17ee4a Mon Sep 17 00:00:00 2001 From: yj <2191035995@qq.com> Date: Thu, 24 Oct 2024 14:02:06 +0800 Subject: [PATCH 4/9] =?UTF-8?q?=E6=B3=A8=E9=87=8A?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- src/Notes.java | 206 ++++++++++++++++++++ src/NotesDatabaseHelper.java | 283 ++++++++++++++++++++++++++++ src/NotesProvider.java | 354 +++++++++++++++++++++++++++++++++++ 3 files changed, 843 insertions(+) create mode 100644 src/Notes.java create mode 100644 src/NotesDatabaseHelper.java create mode 100644 src/NotesProvider.java diff --git a/src/Notes.java b/src/Notes.java new file mode 100644 index 0000000..62dbfac --- /dev/null +++ b/src/Notes.java @@ -0,0 +1,206 @@ +/* + * 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. + */ + +package net.micode.notes.data; + +import android.net.Uri; + +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; + + /** + * 以下ID是系统文件夹的标识符 + * {@link Notes#ID_ROOT_FOLDER} 表示默认文件夹 + * {@link Notes#ID_TEMPARAY_FOLDER} 表示临时文件夹 + * {@link Notes#ID_CALL_RECORD_FOLDER} 表示用于存储通话记录的文件夹 + */ + 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; + + // Intent 额外数据的键，用于传递提醒日期、背景颜色、Widget ID、文件夹ID等信息 + 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"; + public static final String INTENT_EXTRA_WIDGET_ID = "net.micode.notes.widget_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"; + public static final String INTENT_EXTRA_CALL_DATE = "net.micode.notes.call_date"; + + // Widget 类型常量 + public static final int TYPE_WIDGET_INVALIDE = -1; + public static final int TYPE_WIDGET_2X = 0; + public static final int TYPE_WIDGET_4X = 1; + + public static class DataConstants { + // 文本便签的 MIME 类型 + public static final String NOTE = TextNote.CONTENT_ITEM_TYPE; + // 通话记录便签的 MIME 类型 + 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"); + + /** + * NoteColumns 接口定义了便签和文件夹表中的列 + */ + public interface NoteColumns { + // 唯一标识符 + 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"; + + // 便签对应的 Widget ID + public static final String WIDGET_ID = "widget_id"; + + // 便签对应的 Widget 类型 + public static final String WIDGET_TYPE = "widget_type"; + + // 便签的背景颜色 ID + public static final String BG_COLOR_ID = "bg_color_id"; + + // 是否有附件，1 表示有，0 表示无 + 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 + public static final String GTASK_ID = "gtask_id"; + + // 版本号 + public static final String VERSION = "version"; + } + + /** + * DataColumns 接口定义了数据表中的列 + */ + public interface DataColumns { + // 唯一标识符 + 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"; + + // 通用数据列，用于存储整数类型数据 + public static final String DATA1 = "data1"; + + // 通用数据列，用于存储整数类型数据 + public static final String DATA2 = "data2"; + + // 通用数据列，用于存储文本类型数据 + public static final String DATA3 = "data3"; + + // 通用数据列，用于存储文本类型数据 + public static final String DATA4 = "data4"; + + // 通用数据列，用于存储文本类型数据 + public static final String DATA5 = "data5"; + } + + /** + * TextNote 类继承自 DataColumns，专门处理文本便签相关的数据 + */ + public static final class TextNote implements DataColumns { + // 模式，表示便签是否处于检查列表模式，1 为检查列表模式，0 为普通模式 + public static final String MODE = 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"); + } + + /** + * CallNote 类继承自 DataColumns，专门处理通话记录便签相关的数据 + */ + public static final class CallNote implements DataColumns { + // 通话日期 + public static final String CALL_DATE = DATA1; + + // 通话的电话号码 + public static final String PHONE_NUMBER = 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"); + } +} diff --git a/src/NotesDatabaseHelper.java b/src/NotesDatabaseHelper.java new file mode 100644 index 0000000..fa468e0 --- /dev/null +++ b/src/NotesDatabaseHelper.java @@ -0,0 +1,283 @@ +/* + * 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. + */ + +package net.micode.notes.data; + +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; + + // 创建note表的SQL语句 + private static final String CREATE_NOTE_TABLE_SQL = + "CREATE TABLE " + TABLE.NOTE + "(" + + 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" + + ")"; + + // 创建data表的SQL语句 + private static final String CREATE_DATA_TABLE_SQL = + "CREATE TABLE " + TABLE.DATA + "(" + + 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 ''" + + ")"; + + // 创建data表中NOTE_ID的索引 + private static final String CREATE_DATA_NOTE_ID_INDEX_SQL = + "CREATE INDEX IF NOT EXISTS note_id_index ON " + + TABLE.DATA + "(" + DataColumns.NOTE_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"; + + /** + * 减少文件夹中的笔记数，当笔记从该文件夹中移除时 + */ + 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"; + + /** + * 减少文件夹中的笔记数，当从该文件夹删除笔记时 + */ + private static final String NOTE_DECREASE_FOLDER_COUNT_ON_DELETE_TRIGGER = + "CREATE TRIGGER decrease_folder_count_on_delete " + + " AFTER DELETE 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"; + + /** + * 当插入类型为NOTE的数据时更新笔记内容 + */ + private static final String DATA_UPDATE_NOTE_CONTENT_ON_INSERT_TRIGGER = + "CREATE TRIGGER update_note_content_on_insert " + + " AFTER INSERT ON " + TABLE.DATA + + " WHEN new." + DataColumns.MIME_TYPE + "='" + DataConstants.NOTE + "'" + + " BEGIN" + + " UPDATE " + TABLE.NOTE + + " SET " + NoteColumns.SNIPPET + "=new." + DataColumns.CONTENT + + " WHERE " + NoteColumns.ID + "=new." + DataColumns.NOTE_ID + ";" + + " END"; + + /** + * 当类型为NOTE的数据更新时，更新笔记内容 + */ + private static final String DATA_UPDATE_NOTE_CONTENT_ON_UPDATE_TRIGGER = + "CREATE TRIGGER update_note_content_on_update " + + " AFTER UPDATE ON " + TABLE.DATA + + " WHEN old." + DataColumns.MIME_TYPE + "='" + DataConstants.NOTE + "'" + + " BEGIN" + + " UPDATE " + TABLE.NOTE + + " SET " + NoteColumns.SNIPPET + "=new." + DataColumns.CONTENT + + " WHERE " + NoteColumns.ID + "=new." + DataColumns.NOTE_ID + ";" + + " END"; + + /** + * 当类型为NOTE的数据删除时，更新笔记内容 + */ + private static final String DATA_UPDATE_NOTE_CONTENT_ON_DELETE_TRIGGER = + "CREATE TRIGGER update_note_content_on_delete " + + " AFTER delete ON " + TABLE.DATA + + " WHEN old." + DataColumns.MIME_TYPE + "='" + DataConstants.NOTE + "'" + + " BEGIN" + + " UPDATE " + TABLE.NOTE + + " SET " + NoteColumns.SNIPPET + "=''" + + " WHERE " + NoteColumns.ID + "=old." + DataColumns.NOTE_ID + ";" + + " END"; + + /** + * 当笔记被删除时，删除相关数据 + */ + private static final String NOTE_DELETE_DATA_ON_DELETE_TRIGGER = + "CREATE TRIGGER delete_data_on_delete " + + " AFTER DELETE ON " + TABLE.NOTE + + " BEGIN" + + " DELETE FROM " + TABLE.DATA + + " WHERE " + DataColumns.NOTE_ID + "=old." + NoteColumns.ID + ";" + + " END"; + + /** + * 当文件夹被删除时，删除该文件夹中的笔记 + */ + private static final String FOLDER_DELETE_NOTES_ON_DELETE_TRIGGER = + "CREATE TRIGGER folder_delete_notes_on_delete " + + " AFTER DELETE ON " + TABLE.NOTE + + " BEGIN " + + " DELETE FROM " + TABLE.NOTE + + " WHERE " + NoteColumns.PARENT_ID + "=old." + NoteColumns.ID + ";" + + " END"; + + /** + * 获取数据库实例，确保数据库只有一个实例 + * + * @param context 应用上下文 + * @return 数据库实例 + */ + public static synchronized NotesDatabaseHelper getInstance(Context context) { + if (mInstance == null) { + mInstance = new NotesDatabaseHelper(context); + } + return mInstance; + } + + /** + * 构造函数，初始化数据库 + * + * @param context 应用上下文 + */ + private NotesDatabaseHelper(Context context) { + super(context, DB_NAME, null, DB_VERSION); + } + + /** + * 创建数据库，初始化数据表 + * + * @param db SQLite数据库实例 + */ + @Override + public void onCreate(SQLiteDatabase db) { + Log.d(TAG, "onCreate"); + db.execSQL(CREATE_NOTE_TABLE_SQL); + db.execSQL(CREATE_DATA_TABLE_SQL); + db.execSQL(CREATE_DATA_NOTE_ID_INDEX_SQL); + + db.execSQL(NOTE_INCREASE_FOLDER_COUNT_ON_UPDATE_TRIGGER); + db.execSQL(NOTE_DECREASE_FOLDER_COUNT_ON_UPDATE_TRIGGER); + db.execSQL(NOTE_INCREASE_FOLDER_COUNT_ON_INSERT_TRIGGER); + db.execSQL(NOTE_DECREASE_FOLDER_COUNT_ON_DELETE_TRIGGER); + + 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); + + db.execSQL(NOTE_DELETE_DATA_ON_DELETE_TRIGGER); + db.execSQL(FOLDER_DELETE_NOTES_ON_DELETE_TRIGGER); + + // 初始化默认文件夹 + initDefaultFolder(db); + } + + /** + * 更新数据库，处理数据库版本升级 + * + * @param db SQLite数据库实例 + * @param oldVersion 旧版本号 + * @param newVersion 新版本号 + */ + @Override + public void onUpgrade(SQLiteDatabase db, int oldVersion, int newVersion) { + Log.d(TAG, "onUpgrade"); + // 这里可以根据不同版本号处理升级逻辑，当前暂时删除旧表并重新创建 + if (oldVersion != newVersion) { + db.execSQL("DROP TABLE IF EXISTS " + TABLE.NOTE); + db.execSQL("DROP TABLE IF EXISTS " + TABLE.DATA); + onCreate(db); + } + } + + /** + * 初始化默认文件夹，在第一次创建数据库时调用 + * + * @param db SQLite数据库实例 + */ + private void initDefaultFolder(SQLiteDatabase db) { + ContentValues values = new ContentValues(); + values.put(NoteColumns.ID, Notes.ID_ROOT_FOLDER); + values.put(NoteColumns.SNIPPET, "ROOT"); + values.put(NoteColumns.TYPE, Notes.TYPE_FOLDER); + db.insert(TABLE.NOTE, null, values); + } +} diff --git a/src/NotesProvider.java b/src/NotesProvider.java new file mode 100644 index 0000000..fc946d1 --- /dev/null +++ b/src/NotesProvider.java @@ -0,0 +1,354 @@ +/* + * 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. + */ + +package net.micode.notes.data; + +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是内容提供者类，负责提供与笔记数据的增删改查功能。 + * 它通过SQLite数据库进行数据存储，并使用UriMatcher来解析URI请求。 + */ +public class NotesProvider extends ContentProvider { + + // 定义UriMatcher对象，用于匹配不同类型的URI + private static final UriMatcher mMatcher; + + // Notes数据库帮助类，用于操作数据库 + private NotesDatabaseHelper mHelper; + + // 日志TAG + 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); // 匹配笔记URI + mMatcher.addURI(Notes.AUTHORITY, "note/#", URI_NOTE_ITEM); // 匹配具体的笔记 + mMatcher.addURI(Notes.AUTHORITY, "data", URI_DATA); // 匹配数据URI + 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); + } + + /** + * SQL查询片段，用于从笔记中搜索，删除换行符并裁剪空格，以显示更多信息。 + */ + 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; + + /** + * 创建ContentProvider实例时调用。 + * 主要用于初始化数据库帮助类实例。 + */ + @Override + public boolean onCreate() { + mHelper = NotesDatabaseHelper.getInstance(getContext()); + return true; + } + + /** + * 处理查询请求。 + * + * @param uri 查询的URI + * @param projection 查询的列 + * @param selection 查询的条件 + * @param selectionArgs 查询条件的参数 + * @param sortOrder 排序方式 + * @return 返回Cursor，表示查询结果 + */ + @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); + c = db.query(TABLE.NOTE, projection, NoteColumns.ID + "=" + id + parseSelection(selection), selectionArgs, null, null, sortOrder); + 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); + c = db.query(TABLE.DATA, projection, DataColumns.ID + "=" + id + parseSelection(selection), selectionArgs, null, null, sortOrder); + 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"); + } + 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类型 + } + + // 如果Cursor不为空，设置通知URI，监听数据变化 + if (c != null) { + c.setNotificationUri(getContext().getContentResolver(), uri); + } + return c; + } + + /** + * 处理插入请求。 + * + * @param uri 插入的URI + * @param values 要插入的数据 + * @return 返回新插入记录的URI + */ + @Override + public Uri insert(Uri uri, ContentValues values) { + SQLiteDatabase db = mHelper.getWritableDatabase(); + long dataId = 0, noteId = 0, insertedId = 0; + + // 根据URI匹配码执行不同的插入操作 + switch (mMatcher.match(uri)) { + case URI_NOTE: // 插入一条笔记 + insertedId = noteId = db.insert(TABLE.NOTE, null, values); + break; + case URI_DATA: // 插入一条数据 + if (values.containsKey(DataColumns.NOTE_ID)) { + noteId = values.getAsLong(DataColumns.NOTE_ID); + } else { + Log.d(TAG, "Wrong data format without note id:" + values.toString()); + } + insertedId = dataId = db.insert(TABLE.DATA, null, values); + break; + default: + throw new IllegalArgumentException("Unknown URI " + uri); // 未知的URI类型 + } + + // 通知数据改变 + if (noteId > 0) { + getContext().getContentResolver().notifyChange(ContentUris.withAppendedId(Notes.CONTENT_NOTE_URI, noteId), null); + } + if (dataId > 0) { + getContext().getContentResolver().notifyChange(ContentUris.withAppendedId(Notes.CONTENT_DATA_URI, dataId), null); + } + return ContentUris.withAppendedId(uri, insertedId); // 返回新记录的URI + } + + /** + * 处理删除请求。 + * + * @param uri 删除的URI + * @param selection 删除的条件 + * @param selectionArgs 删除条件的参数 + * @return 返回删除的记录数 + */ + @Override + public int delete(Uri uri, String selection, String[] selectionArgs) { + int count = 0; + String id = null; + SQLiteDatabase db = mHelper.getWritableDatabase(); + boolean deleteData = false; + + // 根据URI匹配码执行不同的删除操作 + switch (mMatcher.match(uri)) { + case URI_NOTE: // 删除笔记 + selection = "(" + selection + ") AND " + NoteColumns.ID + ">0 "; + count = db.delete(TABLE.NOTE, selection, selectionArgs); + break; + case URI_NOTE_ITEM: // 删除单个笔记 + id = uri.getPathSegments().get(1); + long noteId = Long.valueOf(id); + if (noteId <= 0) { // 如果笔记ID小于等于0，不允许删除 + break; + } + count = db.delete(TABLE.NOTE, NoteColumns.ID + "=" + id + parseSelection(selection), selectionArgs); + break; + case URI_DATA: // 删除数据 + count = db.delete(TABLE.DATA, selection, selectionArgs); + deleteData = true; + break; + case URI_DATA_ITEM: // 删除单个数据 + id = uri.getPathSegments().get(1); + count = db.delete(TABLE.DATA, DataColumns.ID + "=" + id + parseSelection(selection), selectionArgs); + deleteData = true; + break; + default: + throw new IllegalArgumentException("Unknown URI " + uri); // 未知的URI类型 + } + + // 如果删除成功，通知数据变化 + if (count > 0) { + if (deleteData) { + getContext().getContentResolver().notifyChange(Notes.CONTENT_NOTE_URI, null); + } + getContext().getContentResolver().notifyChange(uri, null); + } + return count; + } + + /** + * 处理更新请求。 + * + * @param uri 更新的URI + * @param values 更新的内容 + * @param selection 更新的条件 + * @param selectionArgs 更新条件的参数 + * @return 返回更新的记录数 + */ + @Override + public int update(Uri uri, ContentValues values, String selection, String[] selectionArgs) { + int count = 0; + String id = null; + SQLiteDatabase db = mHelper.getWritableDatabase(); + boolean updateData = false; + + // 根据URI匹配码执行不同的更新操作 + switch (mMatcher.match(uri)) { + case URI_NOTE: // 更新笔记 + increaseNoteVersion(-1, selection, selectionArgs); // 更新笔记版本 + count = db.update(TABLE.NOTE, values, selection, selectionArgs); + break; + case URI_NOTE_ITEM: // 更新单个笔记 + id = uri.getPathSegments().get(1); + increaseNoteVersion(Long.valueOf(id), selection, selectionArgs); // 更新指定笔记版本 + count = db.update(TABLE.NOTE, values, NoteColumns.ID + "=" + id + parseSelection(selection), selectionArgs); + break; + case URI_DATA: // 更新数据 + count = db.update(TABLE.DATA, values, selection, selectionArgs); + updateData = true; + break; + case URI_DATA_ITEM: // 更新单个数据 + id = uri.getPathSegments().get(1); + count = db.update(TABLE.DATA, values, DataColumns.ID + "=" + id + parseSelection(selection), selectionArgs); + updateData = true; + break; + default: + throw new IllegalArgumentException("Unknown URI " + uri); // 未知的URI类型 + } + + // 如果更新成功，通知数据变化 + if (count > 0) { + if (updateData) { + getContext().getContentResolver().notifyChange(Notes.CONTENT_NOTE_URI, null); + } + getContext().getContentResolver().notifyChange(uri, null); + } + return count; + } + + /** + * 辅助方法，解析选择条件。 + * + * @param selection 选择条件 + * @return 返回解析后的选择条件 + */ + private String parseSelection(String selection) { + return (!TextUtils.isEmpty(selection) ? " AND (" + selection + ')' : ""); + } + + /** + * 更新笔记的版本号。 + * + * @param id 笔记ID + * @param selection 选择条件 + * @param selectionArgs 选择条件参数 + */ + private void increaseNoteVersion(long id, String selection, String[] selectionArgs) { + StringBuilder sql = new StringBuilder(120); + sql.append("UPDATE "); + sql.append(TABLE.NOTE); + sql.append(" SET "); + sql.append(NoteColumns.VERSION); + sql.append("=" + NoteColumns.VERSION + "+1 "); + + 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); + } + + // 执行SQL更新版本 + mHelper.getWritableDatabase().execSQL(sql.toString()); + } + + @Override + public String getType(Uri uri) { + // TODO Auto-generated method stub + return null; + } +} -- 2.34.1 From 23a1d838b90ee5c567509b4147a494ad114c366a Mon Sep 17 00:00:00 2001 From: yj <2191035995@qq.com> Date: Thu, 24 Oct 2024 14:05:39 +0800 Subject: [PATCH 5/9] =?UTF-8?q?=E6=B3=A8=E9=87=8A?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- src/Contact.java | 91 ++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 91 insertions(+) create mode 100644 src/Contact.java diff --git a/src/Contact.java b/src/Contact.java new file mode 100644 index 0000000..119de7a --- /dev/null +++ b/src/Contact.java @@ -0,0 +1,91 @@ +/* + * 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. + */ + +package net.micode.notes.data; + +import android.content.Context; +import android.database.Cursor; +import android.provider.ContactsContract.CommonDataKinds.Phone; +import android.provider.ContactsContract.Data; +import android.telephony.PhoneNumberUtils; +import android.util.Log; + +import java.util.HashMap; + +public class Contact { + // 静态缓存，用于存储已查询过的电话号码对应的联系人姓名 + private static HashMap sContactCache; + // 用于日志记录的标签 + private static final String TAG = "Contact"; + + // 查询条件，用于根据电话号码查询联系人姓名 + private static final String CALLER_ID_SELECTION = "PHONE_NUMBERS_EQUAL(" + Phone.NUMBER + + ",?) AND " + Data.MIMETYPE + "='" + Phone.CONTENT_ITEM_TYPE + "'" + + " AND " + Data.RAW_CONTACT_ID + " IN " + + "(SELECT raw_contact_id " + + " FROM phone_lookup" + + " WHERE min_match = '+')"; + + /** + * 获取电话号码对应的联系人姓名 + * @param context 应用程序的上下文 + * @param phoneNumber 要查询的电话号码 + * @return 返回电话号码对应的联系人姓名，如果找不到则返回null + */ + public static String getContact(Context context, String phoneNumber) { + // 初始化缓存 + if(sContactCache == null) { + sContactCache = new HashMap(); + } + + // 如果缓存中已经有该电话号码的联系人信息，直接返回 + if(sContactCache.containsKey(phoneNumber)) { + return sContactCache.get(phoneNumber); + } + + // 使用电话号码生成查询条件 + String selection = CALLER_ID_SELECTION.replace("+", + PhoneNumberUtils.toCallerIDMinMatch(phoneNumber)); + + // 查询联系人信息 + Cursor cursor = context.getContentResolver().query( + Data.CONTENT_URI, + new String [] { Phone.DISPLAY_NAME }, // 需要获取的字段，这里是联系人姓名 + selection, // 查询条件 + new String[] { phoneNumber }, // 查询参数，填充到查询条件中 + null); // 排序方式，null表示不排序 + + // 检查查询结果并返回联系人姓名 + if (cursor != null && cursor.moveToFirst()) { + try { + String name = cursor.getString(0); // 获取查询到的联系人姓名 + sContactCache.put(phoneNumber, name); // 将结果缓存起来 + return name; // 返回联系人姓名 + } catch (IndexOutOfBoundsException e) { + // 捕捉异常并记录错误日志 + Log.e(TAG, " Cursor get string error " + e.toString()); + return null; + } finally { + // 关闭游标，释放资源 + cursor.close(); + } + } else { + // 如果没有匹配的联系人，记录日志并返回null + Log.d(TAG, "No contact matched with number:" + phoneNumber); + return null; + } + } +} -- 2.34.1 From c557a521a339f42234e6982d5d74bcef25c5965c Mon Sep 17 00:00:00 2001 From: pgwuqvec3 <2191035995@qq.com> Date: Sun, 27 Oct 2024 11:37:51 +0800 Subject: [PATCH 6/9] Delete 'Contact.java' --- Contact.java | 91 ---------------------------------------------------- 1 file changed, 91 deletions(-) delete mode 100644 Contact.java diff --git a/Contact.java b/Contact.java deleted file mode 100644 index 119de7a..0000000 --- a/Contact.java +++ /dev/null @@ -1,91 +0,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. - */ - -package net.micode.notes.data; - -import android.content.Context; -import android.database.Cursor; -import android.provider.ContactsContract.CommonDataKinds.Phone; -import android.provider.ContactsContract.Data; -import android.telephony.PhoneNumberUtils; -import android.util.Log; - -import java.util.HashMap; - -public class Contact { - // 静态缓存，用于存储已查询过的电话号码对应的联系人姓名 - private static HashMap sContactCache; - // 用于日志记录的标签 - private static final String TAG = "Contact"; - - // 查询条件，用于根据电话号码查询联系人姓名 - private static final String CALLER_ID_SELECTION = "PHONE_NUMBERS_EQUAL(" + Phone.NUMBER - + ",?) AND " + Data.MIMETYPE + "='" + Phone.CONTENT_ITEM_TYPE + "'" - + " AND " + Data.RAW_CONTACT_ID + " IN " - + "(SELECT raw_contact_id " - + " FROM phone_lookup" - + " WHERE min_match = '+')"; - - /** - * 获取电话号码对应的联系人姓名 - * @param context 应用程序的上下文 - * @param phoneNumber 要查询的电话号码 - * @return 返回电话号码对应的联系人姓名，如果找不到则返回null - */ - public static String getContact(Context context, String phoneNumber) { - // 初始化缓存 - if(sContactCache == null) { - sContactCache = new HashMap(); - } - - // 如果缓存中已经有该电话号码的联系人信息，直接返回 - if(sContactCache.containsKey(phoneNumber)) { - return sContactCache.get(phoneNumber); - } - - // 使用电话号码生成查询条件 - String selection = CALLER_ID_SELECTION.replace("+", - PhoneNumberUtils.toCallerIDMinMatch(phoneNumber)); - - // 查询联系人信息 - Cursor cursor = context.getContentResolver().query( - Data.CONTENT_URI, - new String [] { Phone.DISPLAY_NAME }, // 需要获取的字段，这里是联系人姓名 - selection, // 查询条件 - new String[] { phoneNumber }, // 查询参数，填充到查询条件中 - null); // 排序方式，null表示不排序 - - // 检查查询结果并返回联系人姓名 - if (cursor != null && cursor.moveToFirst()) { - try { - String name = cursor.getString(0); // 获取查询到的联系人姓名 - sContactCache.put(phoneNumber, name); // 将结果缓存起来 - return name; // 返回联系人姓名 - } catch (IndexOutOfBoundsException e) { - // 捕捉异常并记录错误日志 - Log.e(TAG, " Cursor get string error " + e.toString()); - return null; - } finally { - // 关闭游标，释放资源 - cursor.close(); - } - } else { - // 如果没有匹配的联系人，记录日志并返回null - Log.d(TAG, "No contact matched with number:" + phoneNumber); - return null; - } - } -} -- 2.34.1 From b6f39b02fe6e8a3ad74f7abbe418aaeffbfbaa2d Mon Sep 17 00:00:00 2001 From: yj <2191035995@qq.com> Date: Thu, 24 Oct 2024 14:48:25 +0800 Subject: [PATCH 7/9] =?UTF-8?q?=E6=B3=A8=E9=87=8A?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- src/MetaData.java | 90 +++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 90 insertions(+) create mode 100644 src/MetaData.java diff --git a/src/MetaData.java b/src/MetaData.java new file mode 100644 index 0000000..8a56662 --- /dev/null +++ b/src/MetaData.java @@ -0,0 +1,90 @@ +/* + * 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. + */ + +package net.micode.notes.gtask.data; + +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(); // 用于日志记录的TAG + + private String mRelatedGid = null; // 存储相关任务的ID + + // 设置元数据，包括任务ID和相关的元信息 + public void setMeta(String gid, JSONObject metaInfo) { + try { + // 将任务ID放入元信息JSON对象中 + metaInfo.put(GTaskStringUtils.META_HEAD_GTASK_ID, gid); + } catch (JSONException e) { + Log.e(TAG, "failed to put related gid"); // 记录错误 + } + setNotes(metaInfo.toString()); // 设置笔记内容为元信息的字符串表示 + setName(GTaskStringUtils.META_NOTE_NAME); // 设置名称 + } + + // 获取相关任务的ID + public String getRelatedGid() { + return mRelatedGid; + } + + // 检查当前对象是否值得保存 + @Override + public boolean isWorthSaving() { + return getNotes() != null; // 如果笔记内容不为空，则值得保存 + } + + // 从远程JSON对象设置内容 + @Override + public void setContentByRemoteJSON(JSONObject js) { + super.setContentByRemoteJSON(js); // 调用父类方法 + if (getNotes() != null) { + try { + // 将笔记内容转换为JSON对象 + JSONObject metaInfo = new JSONObject(getNotes().trim()); + // 获取相关任务的ID + mRelatedGid = metaInfo.getString(GTaskStringUtils.META_HEAD_GTASK_ID); + } catch (JSONException e) { + Log.w(TAG, "failed to get related gid"); // 记录警告 + mRelatedGid = null; // 设置为null以表示失败 + } + } + } + + // 此方法不应被调用，抛出异常 + @Override + public void setContentByLocalJSON(JSONObject js) { + throw new IllegalAccessError("MetaData:setContentByLocalJSON should not be called"); + } + + // 此方法不应被调用，抛出异常 + @Override + public JSONObject getLocalJSONFromContent() { + throw new IllegalAccessError("MetaData:getLocalJSONFromContent should not be called"); + } + + // 此方法不应被调用，抛出异常 + @Override + public int getSyncAction(Cursor c) { + throw new IllegalAccessError("MetaData:getSyncAction should not be called"); + } +} -- 2.34.1 From f9aa4bb8fd0fca67211da11b50a585d406c968b8 Mon Sep 17 00:00:00 2001 From: yj <2191035995@qq.com> Date: Sun, 27 Oct 2024 11:36:57 +0800 Subject: [PATCH 8/9] =?UTF-8?q?=E6=B3=A8=E9=87=8A?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- src/Node.java | 108 ++++++++++ src/SqlData.java | 194 ++++++++++++++++++ src/SqlNote.java | 505 +++++++++++++++++++++++++++++++++++++++++++++++ 3 files changed, 807 insertions(+) create mode 100644 src/Node.java create mode 100644 src/SqlData.java create mode 100644 src/SqlNote.java diff --git a/src/Node.java b/src/Node.java new file mode 100644 index 0000000..1ce7b51 --- /dev/null +++ b/src/Node.java @@ -0,0 +1,108 @@ +/* + * 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. + */ + +package net.micode.notes.gtask.data; + +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; // 初始化 Gid 为 null + mName = ""; // 初始化名称为空字符串 + mLastModified = 0; // 初始化最后修改时间为 0 + mDeleted = false; // 初始化删除状态为 false + } + + // 抽象方法：获取创建操作的 JSON 对象 + public abstract JSONObject getCreateAction(int actionId); + + // 抽象方法：获取更新操作的 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); + + // 设置 Gid + 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; + } + + // 获取 Gid + public String getGid() { + return this.mGid; + } + + // 获取名称 + public String getName() { + return this.mName; + } + + // 获取最后修改时间 + public long getLastModified() { + return this.mLastModified; + } + + // 获取删除状态 + public boolean getDeleted() { + return this.mDeleted; + } +} diff --git a/src/SqlData.java b/src/SqlData.java new file mode 100644 index 0000000..0447243 --- /dev/null +++ b/src/SqlData.java @@ -0,0 +1,194 @@ +/* + * 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. + */ + +package net.micode.notes.gtask.data; + +import android.content.ContentResolver; +import android.content.ContentUris; +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.DataConstants; +import net.micode.notes.data.Notes.NoteColumns; +import net.micode.notes.data.NotesDatabaseHelper.TABLE; +import net.micode.notes.gtask.exception.ActionFailureException; + +import org.json.JSONException; +import org.json.JSONObject; + +/** + * SqlData类用于处理与数据库交互的笔记数据，包括创建、读取和更新操作。 + */ +public class SqlData { + private static final String TAG = SqlData.class.getSimpleName(); // 日志标签 + + private static final int INVALID_ID = -99999; // 无效 ID 常量 + + // 定义用于查询的数据列 + public static final String[] PROJECTION_DATA = new String[] { + DataColumns.ID, DataColumns.MIME_TYPE, DataColumns.CONTENT, DataColumns.DATA1, + DataColumns.DATA3 + }; + + // 数据列索引 + 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; // 存储待更新的内容值 + + // 构造函数，初始化 SqlData 实例（用于创建新数据） + 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(); // 初始化待更新内容值 + } + + // 构造函数，初始化 SqlData 实例（从游标加载数据） + public SqlData(Context context, Cursor c) { + mContentResolver = context.getContentResolver(); // 获取内容解析器 + mIsCreate = false; // 设置为非创建状态 + loadFromCursor(c); // 从游标加载数据 + mDiffDataValues = new ContentValues(); // 初始化待更新内容值 + } + + // 从游标加载数据 + private void loadFromCursor(Cursor c) { + mDataId = c.getLong(DATA_ID_COLUMN); // 获取数据 ID + mDataMimeType = c.getString(DATA_MIME_TYPE_COLUMN); // 获取 MIME 类型 + mDataContent = c.getString(DATA_CONTENT_COLUMN); // 获取内容 + mDataContentData1 = c.getLong(DATA_CONTENT_DATA_1_COLUMN); // 获取附加信息 1 + mDataContentData3 = c.getString(DATA_CONTENT_DATA_3_COLUMN); // 获取附加信息 3 + } + + // 设置内容，从 JSON 对象加载数据 + public void setContent(JSONObject js) throws JSONException { + long dataId = js.has(DataColumns.ID) ? js.getLong(DataColumns.ID) : INVALID_ID; // 获取 ID + if (mIsCreate || mDataId != dataId) { + mDiffDataValues.put(DataColumns.ID, dataId); // 更新 ID + } + mDataId = dataId; // 设置 ID + + String dataMimeType = js.has(DataColumns.MIME_TYPE) ? js.getString(DataColumns.MIME_TYPE) + : DataConstants.NOTE; // 获取 MIME 类型 + if (mIsCreate || !mDataMimeType.equals(dataMimeType)) { + mDiffDataValues.put(DataColumns.MIME_TYPE, dataMimeType); // 更新 MIME 类型 + } + mDataMimeType = dataMimeType; // 设置 MIME 类型 + + String dataContent = js.has(DataColumns.CONTENT) ? js.getString(DataColumns.CONTENT) : ""; // 获取内容 + if (mIsCreate || !mDataContent.equals(dataContent)) { + mDiffDataValues.put(DataColumns.CONTENT, dataContent); // 更新内容 + } + mDataContent = dataContent; // 设置内容 + + long dataContentData1 = js.has(DataColumns.DATA1) ? js.getLong(DataColumns.DATA1) : 0; // 获取附加信息 1 + if (mIsCreate || mDataContentData1 != dataContentData1) { + mDiffDataValues.put(DataColumns.DATA1, dataContentData1); // 更新附加信息 1 + } + mDataContentData1 = dataContentData1; // 设置附加信息 1 + + String dataContentData3 = js.has(DataColumns.DATA3) ? js.getString(DataColumns.DATA3) : ""; // 获取附加信息 3 + if (mIsCreate || !mDataContentData3.equals(dataContentData3)) { + mDiffDataValues.put(DataColumns.DATA3, dataContentData3); // 更新附加信息 3 + } + mDataContentData3 = dataContentData3; // 设置附加信息 3 + } + + // 获取内容，返回 JSON 对象 + public JSONObject getContent() throws JSONException { + if (mIsCreate) { + Log.e(TAG, "it seems that we haven't created this in database yet"); // 日志警告 + return null; // 尚未创建，返回 null + } + JSONObject js = new JSONObject(); // 创建 JSON 对象 + js.put(DataColumns.ID, mDataId); // 设置 ID + js.put(DataColumns.MIME_TYPE, mDataMimeType); // 设置 MIME 类型 + js.put(DataColumns.CONTENT, mDataContent); // 设置内容 + js.put(DataColumns.DATA1, mDataContentData1); // 设置附加信息 1 + js.put(DataColumns.DATA3, mDataContentData3); // 设置附加信息 3 + return js; // 返回 JSON 对象 + } + + // 提交数据到数据库 + public void commit(long noteId, boolean validateVersion, long version) { + // 处理创建新数据的情况 + if (mIsCreate) { + if (mDataId == INVALID_ID && mDiffDataValues.containsKey(DataColumns.ID)) { + mDiffDataValues.remove(DataColumns.ID); // 移除无效 ID + } + + mDiffDataValues.put(DataColumns.NOTE_ID, noteId); // 设置笔记 ID + Uri uri = mContentResolver.insert(Notes.CONTENT_DATA_URI, mDiffDataValues); // 插入数据 + try { + mDataId = Long.valueOf(uri.getPathSegments().get(1)); // 获取新创建的 ID + } 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) + }); + } + 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; // 返回数据 ID + } +} diff --git a/src/SqlNote.java b/src/SqlNote.java new file mode 100644 index 0000000..79a4095 --- /dev/null +++ b/src/SqlNote.java @@ -0,0 +1,505 @@ +/* + * 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. + */ + +package net.micode.notes.gtask.data; + +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; + + +public class SqlNote { + private static final String TAG = SqlNote.class.getSimpleName(); + + private static final int INVALID_ID = -99999; + + 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 + }; + + public static final int ID_COLUMN = 0; + + 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; + + public static final int SNIPPET_COLUMN = 8; + + public static final int TYPE_COLUMN = 9; + + public static final int WIDGET_ID_COLUMN = 10; + + public static final int WIDGET_TYPE_COLUMN = 11; + + public static final int SYNC_ID_COLUMN = 12; + + public static final int LOCAL_MODIFIED_COLUMN = 13; + + public static final int ORIGIN_PARENT_ID_COLUMN = 14; + + public static final int GTASK_ID_COLUMN = 15; + + public static final int VERSION_COLUMN = 16; + + private Context mContext; + + private ContentResolver mContentResolver; + + private boolean mIsCreate; + + private long mId; + + private long mAlertDate; + + private int mBgColorId; + + private long mCreatedDate; + + private int mHasAttachment; + + private long mModifiedDate; + + private long mParentId; + + private String mSnippet; + + private int mType; + + private int mWidgetId; + + private int mWidgetType; + + private long mOriginParent; + + private long mVersion; + + private ContentValues mDiffNoteValues; + + private ArrayList mDataList; + + 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; + mWidgetType = Notes.TYPE_WIDGET_INVALIDE; + mOriginParent = 0; + mVersion = 0; + mDiffNoteValues = new ContentValues(); + mDataList = new ArrayList(); + } + + public SqlNote(Context context, Cursor c) { + mContext = context; + mContentResolver = context.getContentResolver(); + mIsCreate = false; + loadFromCursor(c); + mDataList = new ArrayList(); + if (mType == Notes.TYPE_NOTE) + loadDataContent(); + mDiffNoteValues = new ContentValues(); + } + + public SqlNote(Context context, long id) { + mContext = context; + mContentResolver = context.getContentResolver(); + mIsCreate = false; + loadFromCursor(id); + mDataList = new ArrayList(); + if (mType == Notes.TYPE_NOTE) + loadDataContent(); + mDiffNoteValues = new ContentValues(); + + } + + private void loadFromCursor(long id) { + Cursor c = null; + try { + c = mContentResolver.query(Notes.CONTENT_NOTE_URI, PROJECTION_NOTE, "(_id=?)", + new String[] { + String.valueOf(id) + }, null); + if (c != null) { + c.moveToNext(); + loadFromCursor(c); + } else { + Log.w(TAG, "loadFromCursor: cursor = null"); + } + } finally { + if (c != null) + c.close(); + } + } + + 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() { + Cursor c = null; + mDataList.clear(); + try { + 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()) { + SqlData data = new SqlData(mContext, c); + mDataList.add(data); + } + } else { + Log.w(TAG, "loadDataContent: cursor = null"); + } + } finally { + if (c != null) + c.close(); + } + } + + 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) { + // for folder we can only update the snnipet and 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); + 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; + + 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; + + 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; + + 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; + } + } + } + + 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; + } + + 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; + } + + public void setParentId(long id) { + mParentId = id; + mDiffNoteValues.put(NoteColumns.PARENT_ID, id); + } + + public void setGtaskId(String gid) { + mDiffNoteValues.put(NoteColumns.GTASK_ID, gid); + } + + public void setSyncId(long syncId) { + mDiffNoteValues.put(NoteColumns.SYNC_ID, syncId); + } + + public void resetLocalModified() { + mDiffNoteValues.put(NoteColumns.LOCAL_MODIFIED, 0); + } + + public long getId() { + return mId; + } + + 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) { + if (mId == INVALID_ID && mDiffNoteValues.containsKey(NoteColumns.ID)) { + mDiffNoteValues.remove(NoteColumns.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"); + } + 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 { + 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); + } + } + } + + // refresh local info + loadFromCursor(mId); + if (mType == Notes.TYPE_NOTE) + loadDataContent(); + + mDiffNoteValues.clear(); + mIsCreate = false; + } +} -- 2.34.1 From 6d926cbd66552c89061dad2c7b975ffc713441ac Mon Sep 17 00:00:00 2001 From: yj <2191035995@qq.com> Date: Thu, 14 Nov 2024 14:04:20 +0800 Subject: [PATCH 9/9] =?UTF-8?q?=E6=B3=A8=E9=87=8A?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- src/Task.java | 334 +++++++++++++++++++++++++++++++++++++++++++ src/TaskList.java | 351 ++++++++++++++++++++++++++++++++++++++++++++++ 2 files changed, 685 insertions(+) create mode 100644 src/Task.java create mode 100644 src/TaskList.java diff --git a/src/Task.java b/src/Task.java new file mode 100644 index 0000000..d51d834 --- /dev/null +++ b/src/Task.java @@ -0,0 +1,334 @@ +/* + * 版权所有 (c) 2010-2011, MiCode 开源社区 (www.micode.net) + * + * 根据 Apache License, Version 2.0 (以下简称“许可协议”) 授权; + * 除非遵守许可协议，否则不得使用此文件。 + * 您可以在以下网址获取许可协议的副本： + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * 除非适用法律要求或书面同意，根据许可协议分发的软件按“原样”提供， + * 不提供任何明示或暗示的担保或条件。 + * 请参阅许可协议了解许可权限及限制。 + */ + +package net.micode.notes.gtask.data; + +import android.database.Cursor; +import android.text.TextUtils; +import android.util.Log; + +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; +import net.micode.notes.tool.GTaskStringUtils; + +import org.json.JSONArray; +import org.json.JSONException; +import org.json.JSONObject; + +// 任务类，继承自节点类 +public class Task extends Node { + private static final String TAG = Task.class.getSimpleName(); // 日志标签 + private boolean mCompleted; // 任务完成标记 + private String mNotes; // 任务的备注 + private JSONObject mMetaInfo; // 任务的元信息 + private Task mPriorSibling; // 前一个兄弟任务 + private TaskList mParent; // 任务的父任务列表 + + // 构造方法，初始化任务属性 + public Task() { + super(); + mCompleted = false; + mNotes = null; + mPriorSibling = null; + mParent = null; + mMetaInfo = null; + } + + // 创建任务的 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"); + 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 对象 + public JSONObject getUpdateAction(int actionId) { + JSONObject js = new JSONObject(); + + try { + js.put(GTaskStringUtils.GTASK_JSON_ACTION_TYPE, + GTaskStringUtils.GTASK_JSON_ACTION_TYPE_UPDATE); + js.put(GTaskStringUtils.GTASK_JSON_ACTION_ID, actionId); + 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 设置任务内容 + public void setContentByRemoteJSON(JSONObject js) { + if (js != null) { + try { + 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 设置任务内容 + 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 = 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 内容 + public JSONObject getLocalJSONFromContent() { + String name = getName(); + try { + if (mMetaInfo == null) { + if (name == null) { + Log.w(TAG, "笔记为空"); + return null; + } + 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; + } 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; + } + } + + // 设置元信息 + public void setMetaInfo(MetaData metaData) { + if (metaData != null && metaData.getNotes() != null) { + try { + mMetaInfo = new JSONObject(metaData.getNotes()); + } catch (JSONException e) { + Log.w(TAG, e.toString()); + mMetaInfo = null; + } + } + } + + // 获取同步操作 + 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; + } + + 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 { + if (!c.getString(SqlNote.GTASK_ID_COLUMN).equals(getGid())) { + Log.e(TAG, "gtask 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; + } + + // 检查任务是否值得保存 + 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; + } +} diff --git a/src/TaskList.java b/src/TaskList.java new file mode 100644 index 0000000..814b349 --- /dev/null +++ b/src/TaskList.java @@ -0,0 +1,351 @@ +/* + * 版权所有 (c) 2010-2011, MiCode 开源社区 (www.micode.net) + * + * 根据 Apache 许可证 2.0 版授权 ("许可证"); + * 只有在符合许可证的情况下，您才能使用此文件。 + * 您可以在以下位置获取许可证副本： + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * 除非适用法律要求或书面同意，按“原样”分发的许可证软件， + * 无任何明示或暗示的担保或条件。 + * 请参阅许可证以获取许可下的具体语言和限制。 + */ + +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; + +/** + * 任务列表类，继承自节点类 + */ +public class TaskList extends Node { + private static final String TAG = TaskList.class.getSimpleName(); // 日志标签 + + private int mIndex; // 索引号 + + private ArrayList mChildren; // 子任务列表 + + // 构造函数 + public TaskList() { + super(); + mChildren = new ArrayList(); + mIndex = 1; + } + + /** + * 创建任务列表的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); // 动作类型 + js.put(GTaskStringUtils.GTASK_JSON_ACTION_ID, actionId); // 动作ID + 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); // 实体类型 + 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 { + js.put(GTaskStringUtils.GTASK_JSON_ACTION_TYPE, GTaskStringUtils.GTASK_JSON_ACTION_TYPE_UPDATE); // 动作类型 + js.put(GTaskStringUtils.GTASK_JSON_ACTION_ID, actionId); // 动作ID + js.put(GTaskStringUtils.GTASK_JSON_ID, getGid()); // 任务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); + + } catch (JSONException e) { + Log.e(TAG, e.toString()); + e.printStackTrace(); + throw new ActionFailureException("生成任务列表更新JSON对象失败"); + } + return js; + } + + /** + * 从远程JSON设置任务列表内容 + */ + public void setContentByRemoteJSON(JSONObject js) { + if (js != null) { + try { + 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("从JSON对象获取任务列表内容失败"); + } + } + } + + /** + * 从本地JSON设置任务列表内容 + */ + public void setContentByLocalJSON(JSONObject js) { + if (js == null || !js.has(GTaskStringUtils.META_HEAD_NOTE)) { + Log.w(TAG, "setContentByLocalJSON: 无可用内容"); + return; + } + + try { + JSONObject folder = 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); + } 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对象 + */ + public JSONObject getLocalJSONFromContent() { + try { + JSONObject js = new JSONObject(); + JSONObject folder = new JSONObject(); + String folderName = getName(); + + // 处理文件夹名称 + if (getName().startsWith(GTaskStringUtils.MIUI_FOLDER_PREFFIX)) { + folderName = folderName.substring(GTaskStringUtils.MIUI_FOLDER_PREFFIX.length()); + } + + folder.put(NoteColumns.SNIPPET, folderName); + folder.put(NoteColumns.TYPE, folderName.equals(GTaskStringUtils.FOLDER_DEFAULT) + || folderName.equals(GTaskStringUtils.FOLDER_CALL_NOTE) + ? Notes.TYPE_SYSTEM : Notes.TYPE_FOLDER); + + js.put(GTaskStringUtils.META_HEAD_NOTE, folder); + + return js; + } catch (JSONException e) { + Log.e(TAG, e.toString()); + e.printStackTrace(); + return null; + } + } + + /** + * 根据游标信息获取同步操作类型 + */ + public int getSyncAction(Cursor c) { + try { + if (c.getInt(SqlNote.LOCAL_MODIFIED_COLUMN) == 0) { + // 没有本地更新 + return c.getLong(SqlNote.SYNC_ID_COLUMN) == getLastModified() ? SYNC_ACTION_NONE : SYNC_ACTION_UPDATE_LOCAL; + } else { + // 验证任务ID + if (!c.getString(SqlNote.GTASK_ID_COLUMN).equals(getGid())) { + Log.e(TAG, "任务ID不匹配"); + return SYNC_ACTION_ERROR; + } + return c.getLong(SqlNote.SYNC_ID_COLUMN) == getLastModified() ? SYNC_ACTION_UPDATE_REMOTE : 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) { + if (task != null && !mChildren.contains(task)) { + boolean ret = mChildren.add(task); + if (ret) { + task.setPriorSibling(mChildren.isEmpty() ? null : mChildren.get(mChildren.size() - 1)); + task.setParent(this); + } + return ret; + } + return false; + } + + /** + * 添加子任务到指定位置 + */ + public boolean addChildTask(Task task, int index) { + if (index < 0 || index > mChildren.size()) { + Log.e(TAG, "添加子任务：无效索引"); + return false; + } + if (task != null && mChildren.indexOf(task) == -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; + } + + /** + * 从任务列表中删除子任务 + */ + public boolean removeChildTask(Task task) { + int index = mChildren.indexOf(task); + if (index != -1) { + boolean 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; + } + return false; + } + + /** + * 移动子任务到指定位置 + */ + 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; + } + return pos == index || (removeChildTask(task) && addChildTask(task, index)); + } + + /** + * 通过GID查找子任务 + */ + public Task findChildTaskByGid(String gid) { + for (Task t : mChildren) { + if (t.getGid().equals(gid)) { + return t; + } + } + return 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: 无效索引"); + return null; + } + return mChildren.get(index); + } + + /** + * 通过GID获取子任务 + */ + public Task getChilTaskByGid(String gid) { + for (Task task : mChildren) { + if (task.getGid().equals(gid)) { + return task; + } + } + return null; + } + + /** + * 获取子任务列表 + */ + public ArrayList getChildTaskList() { + return this.mChildren; + } + + /** + * 设置索引 + */ + public void setIndex(int index) { + this.mIndex = index; + } + + /** + * 获取索引 + */ + public int getIndex() { + return this.mIndex; + } +} -- 2.34.1