Compare commits

...

21 Commits
cdy ... develop

Author SHA1 Message Date
董春阳 8aefa300e7 代码功能优化
1 year ago
董春阳 b78b7b37e8 Merge branch 'dcy' into develop
1 year ago
董春阳 be0bfa6ab1 代码优化
1 year ago
董春阳 63d9c84eb0 doc文档修筑
1 year ago
董春阳 8a2ce58c35 添加注释
1 year ago
董春阳 640649fe70 添加注释
1 year ago
董春阳 10decf27ce 添加注释
1 year ago
董春阳 238c916986 添加注释
1 year ago
董春阳 776397ce4a 添加注释,添加错误捕获2
1 year ago
董春阳 37855e16eb 添加注释,添加错误捕获2
1 year ago
董春阳 db1d6b6274 Merge branch 'dcy' into develop
1 year ago
董春阳 9a3dfb769e 添加注释,添加错误捕获
1 year ago
dcy 6817cff036 Merge branch 'cdy' into develop
1 year ago
dcy f3a327d2ad Merge branch 'lcb' into develop
1 year ago
lcb dc844242a3 李长宝model,tool代码注释
1 year ago
dcy e147b7fca6 2024/12/2 gtask包进行解读并添加注释
1 year ago
dcy 676c8ae151 2024/12/2 notedatabasehelper notesprovider包进行解读并添加注释
1 year ago
dcy 74aeb2897b 2024/12/3 matadata包进行解读并添加注释
1 year ago
dcy e2b0254ee6 2024/12/2 notes包进行解读并添加注释
1 year ago
dcy 2a7bc321fc 2024/11/30 对contact包改进缓存机制并加注解
1 year ago
dcy a937d06db9 2024/11/30 加注解
1 year ago

@ -13,61 +13,117 @@
* See the License for the specific language governing permissions and * See the License for the specific language governing permissions and
* limitations under the License. * limitations under the License.
*/ */
// 声明该Java类所属的包为net.micode.notes.data此包通常用于存放与笔记应用数据相关的代码
package net.micode.notes.data; package net.micode.notes.data;
import android.content.Context; import android.content.Context;
// 导入android.content.Context类它是Android应用程序环境的全局信息接口
// 用于访问应用程序的资源、启动组件等操作,在后续代码中可能用于获取系统服务、访问数据库等
import android.database.Cursor; import android.database.Cursor;
// 导入android.database.Cursor类它用于遍历查询结果集在从数据库查询联系人信息时会用到
import android.provider.ContactsContract.CommonDataKinds.Phone; import android.provider.ContactsContract.CommonDataKinds.Phone;
// 导入android.provider.ContactsContract.CommonDataKinds.Phone类
// 该类定义了联系人数据库中电话相关数据的常量,如电话号码、联系人显示名称等,用于查询联系人电话信息
import android.provider.ContactsContract.Data; import android.provider.ContactsContract.Data;
// 导入android.provider.ContactsContract.Data类它是联系人数据库中数据的通用表示
// 包含了各种类型的数据(如电话、邮件等)的元数据,在查询联系人数据时会涉及到
import android.telephony.PhoneNumberUtils; import android.telephony.PhoneNumberUtils;
// 导入android.telephony.PhoneNumberUtils类它提供了处理电话号码的实用方法
// 在后续代码中可能用于格式化电话号码、验证电话号码等操作
import android.util.Log; import android.util.Log;
// 导入android.util.Log类用于记录应用程序的日志信息方便调试和排查问题在代码中用于记录错误或调试信息
import java.util.HashMap; import java.util.HashMap;
// 导入java.util.HashMap类它是一个基于哈希表的Map接口实现
// 用于存储键值对数据,在需要无序存储和快速查找数据时会用到
import java.util.LinkedHashMap;
// 导入java.util.LinkedHashMap类它继承自HashMap
// 并维护插入顺序或访问顺序,在代码中用于实现联系人缓存,以便按插入顺序清理较旧的缓存项
import java.util.Map;
import android.content.ContentResolver;
import android.content.Context;
import android.database.Cursor;
import android.provider.ContactsContract;
import android.telephony.PhoneNumberUtils;
import android.util.Log;
import java.util.LinkedHashMap;
import java.util.Map;
// Contact类用于通过电话号码获取联系人姓名并且实现了一个简单的缓存机制
public class Contact { public class Contact {
private static HashMap<String, String> sContactCache; // 定义最大缓存数量可根据实际情况调整这里假设最多缓存100个联系人信息
private static final int MAX_CACHE_SIZE = 100;
// 使用LinkedHashMap来实现缓存它能维持元素的插入顺序便于后续按顺序清理较旧的缓存项
private static LinkedHashMap<String, String> sContactCache;
// 用于日志记录的标签
private static final String TAG = "Contact"; private static final String TAG = "Contact";
// 定义用于查询联系人的SQL选择语句此语句用于从联系人数据库中通过电话号码查找对应的联系人
private static final String CALLER_ID_SELECTION = "PHONE_NUMBERS_EQUAL(" + Phone.NUMBER private static final String CALLER_ID_SELECTION = "PHONE_NUMBERS_EQUAL(" + Phone.NUMBER
+ ",?) AND " + Data.MIMETYPE + "='" + Phone.CONTENT_ITEM_TYPE + "'" + ",?) AND " + Data.MIMETYPE + "='" + Phone.CONTENT_ITEM_TYPE + "'"
+ " AND " + Data.RAW_CONTACT_ID + " IN " + " AND " + Data.RAW_CONTACT_ID + " IN "
+ "(SELECT raw_contact_id " + "(SELECT raw_contact_id "
+ " FROM phone_lookup" + " FROM phone_lookup"
+ " WHERE min_match = '+')"; + " WHERE min_match = '+')";
/**
*
*
* @param context Android访
* @param phoneNumber
* @return null
*/
public static String getContact(Context context, String phoneNumber) { public static String getContact(Context context, String phoneNumber) {
if(sContactCache == null) { // 初始化缓存若缓存尚未创建则创建一个新的LinkedHashMap实例
sContactCache = new HashMap<String, String>(); if (sContactCache == null) {
sContactCache = new LinkedHashMap<String, String>() {
// 重写removeEldestEntry方法以此定义在何种情形下移除最老的缓存项
@Override
protected boolean removeEldestEntry(Map.Entry<String, String> eldest) {
// 当缓存中的元素数量大于或等于最大缓存数量时返回true意味着需要移除最老的缓存项
return size() >= MAX_CACHE_SIZE;
}
};
} }
if(sContactCache.containsKey(phoneNumber)) { // 首先检查缓存中是否已存在该电话号码对应的联系人姓名
if (sContactCache.containsKey(phoneNumber)) {
return sContactCache.get(phoneNumber); return sContactCache.get(phoneNumber);
} }
// 根据传入的电话号码构建查询条件,对特定的占位符进行替换等操作
String selection = CALLER_ID_SELECTION.replace("+", String selection = CALLER_ID_SELECTION.replace("+",
PhoneNumberUtils.toCallerIDMinMatch(phoneNumber)); PhoneNumberUtils.toCallerIDMinMatch(phoneNumber));
// 通过应用上下文的内容解析器进行数据库查询
Cursor cursor = context.getContentResolver().query( Cursor cursor = context.getContentResolver().query(
Data.CONTENT_URI, Data.CONTENT_URI,
new String [] { Phone.DISPLAY_NAME }, // 定义查询结果返回的列,这里只返回联系人的显示名称
new String[]{Phone.DISPLAY_NAME},
selection, selection,
new String[] { phoneNumber }, new String[]{phoneNumber},
null); null);
if (cursor != null && cursor.moveToFirst()) { if (cursor!= null && cursor.moveToFirst()) {
try { try {
// 从游标中获取联系人姓名
String name = cursor.getString(0); String name = cursor.getString(0);
// 将查询到的联系人姓名存入缓存
sContactCache.put(phoneNumber, name); sContactCache.put(phoneNumber, name);
return name; return name;
} catch (IndexOutOfBoundsException e) { } catch (IndexOutOfBoundsException e) {
// 若在获取游标数据时发生越界等异常,记录错误日志
Log.e(TAG, " Cursor get string error " + e.toString()); Log.e(TAG, " Cursor get string error " + e.toString());
return null; return null;
} finally { } finally {
// 无论是否出现异常,都要关闭游标以释放资源
cursor.close(); cursor.close();
} }
} else { } else {
// 如果未查询到对应的联系人,记录一条调试日志
Log.d(TAG, "No contact matched with number:" + phoneNumber); Log.d(TAG, "No contact matched with number:" + phoneNumber);
return null; return null;
} }
} }
} }

@ -17,263 +17,289 @@
package net.micode.notes.data; package net.micode.notes.data;
import android.net.Uri; import android.net.Uri;
// 定义一个名为Notes的公共类用于管理笔记相关的常量和接口
// Notes类定义了与笔记应用相关的各种常量、接口和内部类用于管理笔记、文件夹、数据等信息
public class Notes { public class Notes {
// 内容提供者的权限名称,用于在应用内标识该内容提供者,其他组件通过此名称与对应的内容提供者进行交互
public static final String AUTHORITY = "micode_notes"; public static final String AUTHORITY = "micode_notes";
// 日志标签,用于在日志输出中标识该类相关的日志信息,方便开发者在调试时定位与该类相关的日志
public static final String TAG = "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_NOTE = 0;
public static final int TYPE_SYSTEM = 2; // 表示文件夹类型的常量,用于区分不同类型的记录,这里定义为文件夹类型
public static final int TYPE_FOLDER = 1;
// 表示系统类型的常量,用于区分不同类型的记录,这里定义为系统相关类型
public static final int TYPE_SYSTEM = 2;
/** /**
* Following IDs are system folders' identifiers * ID
* {@link Notes#ID_ROOT_FOLDER } is default folder * {@link Notes#ID_ROOT_FOLDER }
* {@link Notes#ID_TEMPARAY_FOLDER } is for notes belonging no folder * {@link Notes#ID_TEMPARAY_FOLDER }
* {@link Notes#ID_CALL_RECORD_FOLDER} is to store call records * {@link Notes#ID_CALL_RECORD_FOLDER}
*/ */
// 根文件夹的ID作为整个文件夹结构的根节点
public static final int ID_ROOT_FOLDER = 0; public static final int ID_ROOT_FOLDER = 0;
// 临时文件夹的ID用于存放不属于任何文件夹的笔记方便对孤立笔记进行管理
public static final int ID_TEMPARAY_FOLDER = -1; public static final int ID_TEMPARAY_FOLDER = -1;
// 通话记录文件夹的ID用于标识存储通话记录的特定文件夹
public static final int ID_CALL_RECORD_FOLDER = -2; public static final int ID_CALL_RECORD_FOLDER = -2;
// 回收站文件夹的ID用于标识存放已删除笔记或文件夹的回收站
public static final int ID_TRASH_FOLER = -3; public static final int ID_TRASH_FOLER = -3;
// 用于在Intent中传递提醒日期的额外字段名称当通过Intent在不同组件间传递数据时使用此名称来获取或设置提醒日期
public static final String INTENT_EXTRA_ALERT_DATE = "net.micode.notes.alert_date"; public static final String INTENT_EXTRA_ALERT_DATE = "net.micode.notes.alert_date";
// 用于在Intent中传递背景颜色ID的额外字段名称通过此名称在Intent中传递笔记的背景颜色ID
public static final String INTENT_EXTRA_BACKGROUND_ID = "net.micode.notes.background_color_id"; public static final String INTENT_EXTRA_BACKGROUND_ID = "net.micode.notes.background_color_id";
// 用于在Intent中传递小部件ID的额外字段名称借助此名称在Intent中携带小部件的ID信息
public static final String INTENT_EXTRA_WIDGET_ID = "net.micode.notes.widget_id"; public static final String INTENT_EXTRA_WIDGET_ID = "net.micode.notes.widget_id";
// 用于在Intent中传递小部件类型的额外字段名称方便在不同组件间传递小部件的类型信息
public static final String INTENT_EXTRA_WIDGET_TYPE = "net.micode.notes.widget_type"; public static final String INTENT_EXTRA_WIDGET_TYPE = "net.micode.notes.widget_type";
// 用于在Intent中传递文件夹ID的额外字段名称通过此名称在Intent中传递文件夹的ID
public static final String INTENT_EXTRA_FOLDER_ID = "net.micode.notes.folder_id"; public static final String INTENT_EXTRA_FOLDER_ID = "net.micode.notes.folder_id";
// 用于在Intent中传递通话日期的额外字段名称当涉及通话记录相关的Intent传递时使用此名称传递通话日期
public static final String INTENT_EXTRA_CALL_DATE = "net.micode.notes.call_date"; 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; public static final int TYPE_WIDGET_INVALIDE = -1;
public static final int TYPE_WIDGET_4X = 1; // 2x尺寸的小部件类型定义了一种常见的小部件尺寸类型
public static final int TYPE_WIDGET_2X = 0;
// 4x尺寸的小部件类型定义了另一种常见的小部件尺寸类型
public static final int TYPE_WIDGET_4X = 1;
// 数据常量的内部类,用于存储不同类型数据的相关常量,方便对不同类型数据进行统一管理和引用
public static class DataConstants { public static class DataConstants {
// 文本笔记的内容类型,用于标识文本笔记在数据存储和传输中的类型
public static final String NOTE = TextNote.CONTENT_ITEM_TYPE; public static final String NOTE = TextNote.CONTENT_ITEM_TYPE;
// 通话笔记的内容类型,用于标识通话笔记在数据存储和传输中的类型
public static final String CALL_NOTE = CallNote.CONTENT_ITEM_TYPE; public static final String CALL_NOTE = CallNote.CONTENT_ITEM_TYPE;
} }
/** /**
* Uri to query all notes and folders * UriUri
*/ */
public static final Uri CONTENT_NOTE_URI = Uri.parse("content://" + AUTHORITY + "/note"); public static final Uri CONTENT_NOTE_URI = Uri.parse("content://" + AUTHORITY + "/note");
/** /**
* Uri to query data * UriUri
*/ */
public static final Uri CONTENT_DATA_URI = Uri.parse("content://" + AUTHORITY + "/data"); public static final Uri CONTENT_DATA_URI = Uri.parse("content://" + AUTHORITY + "/data");
// 笔记列的接口,定义了与笔记相关的数据库列名,这些列名用于在数据库中存储和检索笔记的各种属性
public interface NoteColumns { public interface NoteColumns {
/** /**
* The unique ID for a row * ID
* <P> Type: INTEGER (long) </P> * <P> : INTEGER (long) </P>
*/ */
public static final String ID = "_id"; public static final String ID = "_id";
/** /**
* The parent's id for note or folder * ID
* <P> Type: INTEGER (long) </P> * <P> : INTEGER (long) </P>
*/ */
public static final String PARENT_ID = "parent_id"; public static final String PARENT_ID = "parent_id";
/** /**
* Created data for note or folder *
* <P> Type: INTEGER (long) </P> * <P> : INTEGER (long) </P>
*/ */
public static final String CREATED_DATE = "created_date"; public static final String CREATED_DATE = "created_date";
/** /**
* Latest modified date *
* <P> Type: INTEGER (long) </P> * <P> : INTEGER (long) </P>
*/ */
public static final String MODIFIED_DATE = "modified_date"; public static final String MODIFIED_DATE = "modified_date";
/** /**
* Alert date *
* <P> Type: INTEGER (long) </P> * <P> : INTEGER (long) </P>
*/ */
public static final String ALERTED_DATE = "alert_date"; public static final String ALERTED_DATE = "alert_date";
/** /**
* Folder's name or text content of note *
* <P> Type: TEXT </P> * <P> : TEXT </P>
*/ */
public static final String SNIPPET = "snippet"; public static final String SNIPPET = "snippet";
/** /**
* Note's widget id * ID
* <P> Type: INTEGER (long) </P> * <P> : INTEGER (long) </P>
*/ */
public static final String WIDGET_ID = "widget_id"; public static final String WIDGET_ID = "widget_id";
/** /**
* Note's widget type *
* <P> Type: INTEGER (long) </P> * <P> : INTEGER (long) </P>
*/ */
public static final String WIDGET_TYPE = "widget_type"; public static final String WIDGET_TYPE = "widget_type";
/** /**
* Note's background color's id * ID
* <P> Type: INTEGER (long) </P> * <P> : INTEGER (long) </P>
*/ */
public static final String BG_COLOR_ID = "bg_color_id"; public static final String BG_COLOR_ID = "bg_color_id";
/** /**
* For text note, it doesn't has attachment, for multi-media *
* note, it has at least one attachment * <P> : INTEGER </P>
* <P> Type: INTEGER </P>
*/ */
public static final String HAS_ATTACHMENT = "has_attachment"; public static final String HAS_ATTACHMENT = "has_attachment";
/** /**
* Folder's count of notes *
* <P> Type: INTEGER (long) </P> * <P> : INTEGER (long) </P>
*/ */
public static final String NOTES_COUNT = "notes_count"; public static final String NOTES_COUNT = "notes_count";
/** /**
* The file type: folder or note *
* <P> Type: INTEGER </P> * <P> : INTEGER </P>
*/ */
public static final String TYPE = "type"; public static final String TYPE = "type";
/** /**
* The last sync id * ID
* <P> Type: INTEGER (long) </P> * <P> : INTEGER (long) </P>
*/ */
public static final String SYNC_ID = "sync_id"; public static final String SYNC_ID = "sync_id";
/** /**
* Sign to indicate local modified or not *
* <P> Type: INTEGER </P> * <P> : INTEGER </P>
*/ */
public static final String LOCAL_MODIFIED = "local_modified"; public static final String LOCAL_MODIFIED = "local_modified";
/** /**
* Original parent id before moving into temporary folder * IDID
* <P> Type : INTEGER </P> * <P> : INTEGER </P>
*/ */
public static final String ORIGIN_PARENT_ID = "origin_parent_id"; public static final String ORIGIN_PARENT_ID = "origin_parent_id";
/** /**
* The gtask id * gtaskIDgtask
* <P> Type : TEXT </P> * <P> : TEXT </P>
*/ */
public static final String GTASK_ID = "gtask_id"; public static final String GTASK_ID = "gtask_id";
/** /**
* The version code *
* <P> Type : INTEGER (long) </P> * <P> : INTEGER (long) </P>
*/ */
public static final String VERSION = "version"; public static final String VERSION = "version";
} }
// 数据列的接口,定义了与数据相关的数据库列名,这些列名用于在数据库中存储和检索与笔记相关的具体数据
public interface DataColumns { public interface DataColumns {
/** /**
* The unique ID for a row * ID
* <P> Type: INTEGER (long) </P> * <P> : INTEGER (long) </P>
*/ */
public static final String ID = "_id"; public static final String ID = "_id";
/** /**
* The MIME type of the item represented by this row. * MIME
* <P> Type: Text </P> * <P> : Text </P>
*/ */
public static final String MIME_TYPE = "mime_type"; public static final String MIME_TYPE = "mime_type";
/** /**
* The reference id to note that this data belongs to * ID
* <P> Type: INTEGER (long) </P> * <P> : INTEGER (long) </P>
*/ */
public static final String NOTE_ID = "note_id"; public static final String NOTE_ID = "note_id";
/** /**
* Created data for note or folder *
* <P> Type: INTEGER (long) </P> * <P> : INTEGER (long) </P>
*/ */
public static final String CREATED_DATE = "created_date"; public static final String CREATED_DATE = "created_date";
/** /**
* Latest modified date *
* <P> Type: INTEGER (long) </P> * <P> : INTEGER (long) </P>
*/ */
public static final String MODIFIED_DATE = "modified_date"; public static final String MODIFIED_DATE = "modified_date";
/** /**
* Data's content *
* <P> Type: TEXT </P> * <P> : TEXT </P>
*/ */
public static final String CONTENT = "content"; public static final String CONTENT = "content";
/** /**
* Generic data column, the meaning is {@link #MIMETYPE} specific, used for * {@link #MIMETYPE}MIME
* integer data type * <P> : INTEGER </P>
* <P> Type: INTEGER </P>
*/ */
public static final String DATA1 = "data1"; public static final String DATA1 = "data1";
/** /**
* Generic data column, the meaning is {@link #MIMETYPE} specific, used for * {@link #MIMETYPE}MIME
* integer data type * <P> : INTEGER </P>
* <P> Type: INTEGER </P>
*/ */
public static final String DATA2 = "data2"; public static final String DATA2 = "data2";
/** /**
* Generic data column, the meaning is {@link #MIMETYPE} specific, used for * {@link #MIMETYPE}MIME
* TEXT data type * <P> : TEXT </P>
* <P> Type: TEXT </P>
*/ */
public static final String DATA3 = "data3"; public static final String DATA3 = "data3";
/** /**
* Generic data column, the meaning is {@link #MIMETYPE} specific, used for * {@link #MIMETYPE}MIME
* TEXT data type * <P> : TEXT </P>
* <P> Type: TEXT </P>
*/ */
public static final String DATA4 = "data4"; public static final String DATA4 = "data4";
/** /**
* Generic data column, the meaning is {@link #MIMETYPE} specific, used for * {@link #MIMETYPE}MIME
* TEXT data type * <P> : TEXT </P>
* <P> Type: TEXT </P>
*/ */
public static final String DATA5 = "data5"; public static final String DATA5 = "data5";
} }
// 文本笔记的静态内部类实现了DataColumns接口定义了文本笔记相关的常量
public static final class TextNote implements DataColumns { public static final class TextNote implements DataColumns {
/** /**
* Mode to indicate the text in check list mode or not *
* <P> Type: Integer 1:check list mode 0: normal mode </P> * <P> : Integer 1: 0: </P>
*/ */
public static final String MODE = DATA1; public static final String MODE = DATA1;
// 复选框列表模式的模式值当MODE的值为1时表示文本处于复选框列表模式
public static final int MODE_CHECK_LIST = 1; public static final int MODE_CHECK_LIST = 1;
// 文本笔记的内容类型(目录类型),用于标识文本笔记在数据存储和传输中的目录类型
public static final String CONTENT_TYPE = "vnd.android.cursor.dir/text_note"; public static final String CONTENT_TYPE = "vnd.android.cursor.dir/text_note";
// 文本笔记的内容类型(项目类型),用于标识文本笔记在数据存储和传输中的项目类型
public static final String CONTENT_ITEM_TYPE = "vnd.android.cursor.item/text_note"; public static final String CONTENT_ITEM_TYPE = "vnd.android.cursor.item/text_note";
// 文本笔记的内容Uri通过此Uri可以向内容提供者请求获取文本笔记的相关数据
public static final Uri CONTENT_URI = Uri.parse("content://" + AUTHORITY + "/text_note"); public static final Uri CONTENT_URI = Uri.parse("content://" + AUTHORITY + "/text_note");
} }
// 通话笔记的静态内部类实现了DataColumns接口定义了通话笔记相关的常量
public static final class CallNote implements DataColumns { public static final class CallNote implements DataColumns {
/** /**
* Call date for this record *
* <P> Type: INTEGER (long) </P> * <P> : INTEGER (long) </P>
*/ */
public static final String CALL_DATE = DATA1; public static final String CALL_DATE = DATA1;
/** /**
* Phone number for this record *
* <P> Type: TEXT </P> * <P> : TEXT </P>
*/ */
public static final String PHONE_NUMBER = DATA3; public static final String PHONE_NUMBER = DATA3;
// 通话笔记的内容类型(目录类型),用于标识通话笔记在数据存储和传输中的目录类型
public static final String CONTENT_TYPE = "vnd.android.cursor.dir/call_note"; public static final String CONTENT_TYPE = "vnd.android.cursor.dir/call_note";
// 通话笔记的内容类型(项目类型),用于标识通话笔记在数据存储和传输中的项目类型
public static final String CONTENT_ITEM_TYPE = "vnd.android.cursor.item/call_note"; public static final String CONTENT_ITEM_TYPE = "vnd.android.cursor.item/call_note";
// 通话笔记的内容Uri通过此Uri可以向内容提供者请求获取通话笔记的相关数据
public static final Uri CONTENT_URI = Uri.parse("content://" + AUTHORITY + "/call_note"); public static final Uri CONTENT_URI = Uri.parse("content://" + AUTHORITY + "/call_note");
} }
} }

@ -26,197 +26,221 @@ import net.micode.notes.data.Notes.DataColumns;
import net.micode.notes.data.Notes.DataConstants; import net.micode.notes.data.Notes.DataConstants;
import net.micode.notes.data.Notes.NoteColumns; import net.micode.notes.data.Notes.NoteColumns;
// 数据库帮助类,用于管理笔记应用的数据库创建、升级等操作
public class NotesDatabaseHelper extends SQLiteOpenHelper { public class NotesDatabaseHelper extends SQLiteOpenHelper {
// 数据库名称
private static final String DB_NAME = "note.db"; private static final String DB_NAME = "note.db";
// 数据库版本号
private static final int DB_VERSION = 4; private static final int DB_VERSION = 4;
// 定义数据库表名的接口
public interface TABLE { public interface TABLE {
// 笔记表名
public static final String NOTE = "note"; public static final String NOTE = "note";
// 数据(与笔记相关的数据)表名
public static final String DATA = "data"; public static final String DATA = "data";
} }
// 日志标签
private static final String TAG = "NotesDatabaseHelper"; private static final String TAG = "NotesDatabaseHelper";
// 单例实例
private static NotesDatabaseHelper mInstance; private static NotesDatabaseHelper mInstance;
// 创建笔记表的SQL语句
private static final String CREATE_NOTE_TABLE_SQL = private static final String CREATE_NOTE_TABLE_SQL =
"CREATE TABLE " + TABLE.NOTE + "(" + "CREATE TABLE " + TABLE.NOTE + "(" +
NoteColumns.ID + " INTEGER PRIMARY KEY," + NoteColumns.ID + " INTEGER PRIMARY KEY," +
NoteColumns.PARENT_ID + " INTEGER NOT NULL DEFAULT 0," + NoteColumns.PARENT_ID + " INTEGER NOT NULL DEFAULT 0," +
NoteColumns.ALERTED_DATE + " INTEGER NOT NULL DEFAULT 0," + NoteColumns.ALERTED_DATE + " INTEGER NOT NULL DEFAULT 0," +
NoteColumns.BG_COLOR_ID + " 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.CREATED_DATE + " INTEGER NOT NULL DEFAULT (strftime('%s','now') * 1000)," +
NoteColumns.HAS_ATTACHMENT + " INTEGER NOT NULL DEFAULT 0," + NoteColumns.HAS_ATTACHMENT + " INTEGER NOT NULL DEFAULT 0," +
NoteColumns.MODIFIED_DATE + " INTEGER NOT NULL DEFAULT (strftime('%s','now') * 1000)," + NoteColumns.MODIFIED_DATE + " INTEGER NOT NULL DEFAULT (strftime('%s','now') * 1000)," +
NoteColumns.NOTES_COUNT + " INTEGER NOT NULL DEFAULT 0," + NoteColumns.NOTES_COUNT + " INTEGER NOT NULL DEFAULT 0," +
NoteColumns.SNIPPET + " TEXT NOT NULL DEFAULT ''," + NoteColumns.SNIPPET + " TEXT NOT NULL DEFAULT ''," +
NoteColumns.TYPE + " INTEGER NOT NULL DEFAULT 0," + NoteColumns.TYPE + " INTEGER NOT NULL DEFAULT 0," +
NoteColumns.WIDGET_ID + " INTEGER NOT NULL DEFAULT 0," + NoteColumns.WIDGET_ID + " INTEGER NOT NULL DEFAULT 0," +
NoteColumns.WIDGET_TYPE + " INTEGER NOT NULL DEFAULT -1," + NoteColumns.WIDGET_TYPE + " INTEGER NOT NULL DEFAULT -1," +
NoteColumns.SYNC_ID + " INTEGER NOT NULL DEFAULT 0," + NoteColumns.SYNC_ID + " INTEGER NOT NULL DEFAULT 0," +
NoteColumns.LOCAL_MODIFIED + " INTEGER NOT NULL DEFAULT 0," + NoteColumns.LOCAL_MODIFIED + " INTEGER NOT NULL DEFAULT 0," +
NoteColumns.ORIGIN_PARENT_ID + " INTEGER NOT NULL DEFAULT 0," + NoteColumns.ORIGIN_PARENT_ID + " INTEGER NOT NULL DEFAULT 0," +
NoteColumns.GTASK_ID + " TEXT NOT NULL DEFAULT ''," + NoteColumns.GTASK_ID + " TEXT NOT NULL DEFAULT ''," +
NoteColumns.VERSION + " INTEGER NOT NULL DEFAULT 0" + NoteColumns.VERSION + " INTEGER NOT NULL DEFAULT 0" +
")"; ")";
// 创建笔记表定义了笔记的各种属性列如ID、父ID、提醒日期、背景颜色ID等设置了默认值并指定ID为主键
// 创建数据表的SQL语句
private static final String CREATE_DATA_TABLE_SQL = private static final String CREATE_DATA_TABLE_SQL =
"CREATE TABLE " + TABLE.DATA + "(" + "CREATE TABLE " + TABLE.DATA + "(" +
DataColumns.ID + " INTEGER PRIMARY KEY," + DataColumns.ID + " INTEGER PRIMARY KEY," +
DataColumns.MIME_TYPE + " TEXT NOT NULL," + DataColumns.MIME_TYPE + " TEXT NOT NULL," +
DataColumns.NOTE_ID + " INTEGER NOT NULL DEFAULT 0," + DataColumns.NOTE_ID + " INTEGER NOT NULL DEFAULT 0," +
NoteColumns.CREATED_DATE + " INTEGER NOT NULL DEFAULT (strftime('%s','now') * 1000)," + NoteColumns.CREATED_DATE + " INTEGER NOT NULL DEFAULT (strftime('%s','now') * 1000)," +
NoteColumns.MODIFIED_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.CONTENT + " TEXT NOT NULL DEFAULT ''," +
DataColumns.DATA1 + " INTEGER," + DataColumns.DATA1 + " INTEGER," +
DataColumns.DATA2 + " INTEGER," + DataColumns.DATA2 + " INTEGER," +
DataColumns.DATA3 + " TEXT NOT NULL DEFAULT ''," + DataColumns.DATA3 + " TEXT NOT NULL DEFAULT ''," +
DataColumns.DATA4 + " TEXT NOT NULL DEFAULT ''," + DataColumns.DATA4 + " TEXT NOT NULL DEFAULT ''," +
DataColumns.DATA5 + " TEXT NOT NULL DEFAULT ''" + DataColumns.DATA5 + " TEXT NOT NULL DEFAULT ''" +
")"; ")";
// 创建数据表定义了与笔记相关数据的列如ID、MIME类型、所属笔记ID、创建和修改日期、内容及其他通用数据列设置ID为主键
// 创建数据DATA表中根据笔记IDNOTE_ID的索引SQL语句
private static final String CREATE_DATA_NOTE_ID_INDEX_SQL = private static final String CREATE_DATA_NOTE_ID_INDEX_SQL =
"CREATE INDEX IF NOT EXISTS note_id_index ON " + "CREATE INDEX IF NOT EXISTS note_id_index ON " +
TABLE.DATA + "(" + DataColumns.NOTE_ID + ");"; TABLE.DATA + "(" + DataColumns.NOTE_ID + ");";
// 创建一个索引方便根据笔记ID快速查询相关数据
/** /**
* Increase folder's note count when move note to the folder *
*/ */
private static final String NOTE_INCREASE_FOLDER_COUNT_ON_UPDATE_TRIGGER = private static final String NOTE_INCREASE_FOLDER_COUNT_ON_UPDATE_TRIGGER =
"CREATE TRIGGER increase_folder_count_on_update "+ "CREATE TRIGGER increase_folder_count_on_update " +
" AFTER UPDATE OF " + NoteColumns.PARENT_ID + " ON " + TABLE.NOTE + " AFTER UPDATE OF " + NoteColumns.PARENT_ID + " ON " + TABLE.NOTE +
" BEGIN " + " BEGIN " +
" UPDATE " + TABLE.NOTE + " UPDATE " + TABLE.NOTE +
" SET " + NoteColumns.NOTES_COUNT + "=" + NoteColumns.NOTES_COUNT + " + 1" + " SET " + NoteColumns.NOTES_COUNT + "=" + NoteColumns.NOTES_COUNT + " + 1" +
" WHERE " + NoteColumns.ID + "=new." + NoteColumns.PARENT_ID + ";" + " WHERE " + NoteColumns.ID + "=new." + NoteColumns.PARENT_ID + ";" +
" END"; " END";
// 创建一个触发器当笔记的父ID更新即移动到新文件夹增加目标文件夹的笔记数量
/** /**
* Decrease folder's note count when move note from folder *
*/ */
private static final String NOTE_DECREASE_FOLDER_COUNT_ON_UPDATE_TRIGGER = private static final String NOTE_DECREASE_FOLDER_COUNT_ON_UPDATE_TRIGGER =
"CREATE TRIGGER decrease_folder_count_on_update " + "CREATE TRIGGER decrease_folder_count_on_update " +
" AFTER UPDATE OF " + NoteColumns.PARENT_ID + " ON " + TABLE.NOTE + " AFTER UPDATE OF " + NoteColumns.PARENT_ID + " ON " + TABLE.NOTE +
" BEGIN " + " BEGIN " +
" UPDATE " + TABLE.NOTE + " UPDATE " + TABLE.NOTE +
" SET " + NoteColumns.NOTES_COUNT + "=" + NoteColumns.NOTES_COUNT + "-1" + " SET " + NoteColumns.NOTES_COUNT + "=" + NoteColumns.NOTES_COUNT + "-1" +
" WHERE " + NoteColumns.ID + "=old." + NoteColumns.PARENT_ID + " WHERE " + NoteColumns.ID + "=old." + NoteColumns.PARENT_ID +
" AND " + NoteColumns.NOTES_COUNT + ">0" + ";" + " AND " + NoteColumns.NOTES_COUNT + ">0" + ";" +
" END"; " END";
// 创建一个触发器当笔记的父ID更新即从文件夹移出减少原文件夹的笔记数量但确保数量不小于0
/** /**
* Increase folder's note count when insert new note to the folder *
*/ */
private static final String NOTE_INCREASE_FOLDER_COUNT_ON_INSERT_TRIGGER = private static final String NOTE_INCREASE_FOLDER_COUNT_ON_INSERT_TRIGGER =
"CREATE TRIGGER increase_folder_count_on_insert " + "CREATE TRIGGER increase_folder_count_on_insert " +
" AFTER INSERT ON " + TABLE.NOTE + " AFTER INSERT ON " + TABLE.NOTE +
" BEGIN " + " BEGIN " +
" UPDATE " + TABLE.NOTE + " UPDATE " + TABLE.NOTE +
" SET " + NoteColumns.NOTES_COUNT + "=" + NoteColumns.NOTES_COUNT + " + 1" + " SET " + NoteColumns.NOTES_COUNT + "=" + NoteColumns.NOTES_COUNT + " + 1" +
" WHERE " + NoteColumns.ID + "=new." + NoteColumns.PARENT_ID + ";" + " WHERE " + NoteColumns.ID + "=new." + NoteColumns.PARENT_ID + ";" +
" END"; " END";
// 创建一个触发器,当新笔记插入时,增加其所属文件夹的笔记数量
/** /**
* Decrease folder's note count when delete note from the folder *
*/ */
private static final String NOTE_DECREASE_FOLDER_COUNT_ON_DELETE_TRIGGER = private static final String NOTE_DECREASE_FOLDER_COUNT_ON_DELETE_TRIGGER =
"CREATE TRIGGER decrease_folder_count_on_delete " + "CREATE TRIGGER decrease_folder_count_on_delete " +
" AFTER DELETE ON " + TABLE.NOTE + " AFTER DELETE ON " + TABLE.NOTE +
" BEGIN " + " BEGIN " +
" UPDATE " + TABLE.NOTE + " UPDATE " + TABLE.NOTE +
" SET " + NoteColumns.NOTES_COUNT + "=" + NoteColumns.NOTES_COUNT + "-1" + " SET " + NoteColumns.NOTES_COUNT + "=" + NoteColumns.NOTES_COUNT + "-1" +
" WHERE " + NoteColumns.ID + "=old." + NoteColumns.PARENT_ID + " WHERE " + NoteColumns.ID + "=old." + NoteColumns.PARENT_ID +
" AND " + NoteColumns.NOTES_COUNT + ">0;" + " AND " + NoteColumns.NOTES_COUNT + ">0;" +
" END"; " END";
// 创建一个触发器当笔记被删除时减少其所属文件夹的笔记数量但确保数量不小于0
/** /**
* Update note's content when insert data with type {@link DataConstants#NOTE} * {@link DataConstants#NOTE}
*/ */
private static final String DATA_UPDATE_NOTE_CONTENT_ON_INSERT_TRIGGER = private static final String DATA_UPDATE_NOTE_CONTENT_ON_INSERT_TRIGGER =
"CREATE TRIGGER update_note_content_on_insert " + "CREATE TRIGGER update_note_content_on_insert " +
" AFTER INSERT ON " + TABLE.DATA + " AFTER INSERT ON " + TABLE.DATA +
" WHEN new." + DataColumns.MIME_TYPE + "='" + DataConstants.NOTE + "'" + " WHEN new." + DataColumns.MIME_TYPE + "='" + DataConstants.NOTE + "'" +
" BEGIN" + " BEGIN" +
" UPDATE " + TABLE.NOTE + " UPDATE " + TABLE.NOTE +
" SET " + NoteColumns.SNIPPET + "=new." + DataColumns.CONTENT + " SET " + NoteColumns.SNIPPET + "=new." + DataColumns.CONTENT +
" WHERE " + NoteColumns.ID + "=new." + DataColumns.NOTE_ID + ";" + " WHERE " + NoteColumns.ID + "=new." + DataColumns.NOTE_ID + ";" +
" END"; " END";
// 创建一个触发器当插入特定类型DataConstants#NOTE的数据时更新对应笔记的内容
/** /**
* Update note's content when data with {@link DataConstants#NOTE} type has changed * {@link DataConstants#NOTE}
*/ */
private static final String DATA_UPDATE_NOTE_CONTENT_ON_UPDATE_TRIGGER = private static final String DATA_UPDATE_NOTE_CONTENT_ON_UPDATE_TRIGGER =
"CREATE TRIGGER update_note_content_on_update " + "CREATE TRIGGER update_note_content_on_update " +
" AFTER UPDATE ON " + TABLE.DATA + " AFTER UPDATE ON " + TABLE.DATA +
" WHEN old." + DataColumns.MIME_TYPE + "='" + DataConstants.NOTE + "'" + " WHEN old." + DataColumns.MIME_TYPE + "='" + DataConstants.NOTE + "'" +
" BEGIN" + " BEGIN" +
" UPDATE " + TABLE.NOTE + " UPDATE " + TABLE.NOTE +
" SET " + NoteColumns.SNIPPET + "=new." + DataColumns.CONTENT + " SET " + NoteColumns.SNIPPET + "=new." + DataColumns.CONTENT +
" WHERE " + NoteColumns.ID + "=new." + DataColumns.NOTE_ID + ";" + " WHERE " + NoteColumns.ID + "=new." + DataColumns.NOTE_ID + ";" +
" END"; " END";
// 创建一个触发器当特定类型DataConstants#NOTE的数据更新时更新对应笔记的内容
/** /**
* Update note's content when data with {@link DataConstants#NOTE} type has deleted * {@link DataConstants#NOTE}
*/ */
private static final String DATA_UPDATE_NOTE_CONTENT_ON_DELETE_TRIGGER = private static final String DATA_UPDATE_NOTE_CONTENT_ON_DELETE_TRIGGER =
"CREATE TRIGGER update_note_content_on_delete " + "CREATE TRIGGER update_note_content_on_delete " +
" AFTER delete ON " + TABLE.DATA + " AFTER delete ON " + TABLE.DATA +
" WHEN old." + DataColumns.MIME_TYPE + "='" + DataConstants.NOTE + "'" + " WHEN old." + DataColumns.MIME_TYPE + "='" + DataConstants.NOTE + "'" +
" BEGIN" + " BEGIN" +
" UPDATE " + TABLE.NOTE + " UPDATE " + TABLE.NOTE +
" SET " + NoteColumns.SNIPPET + "=''" + " SET " + NoteColumns.SNIPPET + "=''" +
" WHERE " + NoteColumns.ID + "=old." + DataColumns.NOTE_ID + ";" + " WHERE " + NoteColumns.ID + "=old." + DataColumns.NOTE_ID + ";" +
" END"; " END";
// 创建一个触发器当特定类型DataConstants#NOTE的数据被删除时清空对应笔记的内容
/** /**
* Delete datas belong to note which has been deleted *
*/ */
private static final String NOTE_DELETE_DATA_ON_DELETE_TRIGGER = private static final String NOTE_DELETE_DATA_ON_DELETE_TRIGGER =
"CREATE TRIGGER delete_data_on_delete " + "CREATE TRIGGER delete_data_on_delete " +
" AFTER DELETE ON " + TABLE.NOTE + " AFTER DELETE ON " + TABLE.NOTE +
" BEGIN" + " BEGIN" +
" DELETE FROM " + TABLE.DATA + " DELETE FROM " + TABLE.DATA +
" WHERE " + DataColumns.NOTE_ID + "=old." + NoteColumns.ID + ";" + " WHERE " + DataColumns.NOTE_ID + "=old." + NoteColumns.ID + ";" +
" END"; " END";
// 创建一个触发器,当笔记被删除时,删除与之关联的数据
/** /**
* Delete notes belong to folder which has been deleted *
*/ */
private static final String FOLDER_DELETE_NOTES_ON_DELETE_TRIGGER = private static final String FOLDER_DELETE_NOTES_ON_DELETE_TRIGGER =
"CREATE TRIGGER folder_delete_notes_on_delete " + "CREATE TRIGGER folder_delete_notes_on_delete " +
" AFTER DELETE ON " + TABLE.NOTE + " AFTER DELETE ON " + TABLE.NOTE +
" BEGIN" + " BEGIN" +
" DELETE FROM " + TABLE.NOTE + " DELETE FROM " + TABLE.NOTE +
" WHERE " + NoteColumns.PARENT_ID + "=old." + NoteColumns.ID + ";" + " WHERE " + NoteColumns.PARENT_ID + "=old." + NoteColumns.ID + ";" +
" END"; " END";
// 创建一个触发器,当文件夹被删除时,删除该文件夹下的所有笔记
/** /**
* Move notes belong to folder which has been moved to trash folder *
*/ */
private static final String FOLDER_MOVE_NOTES_ON_TRASH_TRIGGER = private static final String FOLDER_MOVE_NOTES_ON_TRASH_TRIGGER =
"CREATE TRIGGER folder_move_notes_on_trash " + "CREATE TRIGGER folder_move_notes_on_trash " +
" AFTER UPDATE ON " + TABLE.NOTE + " AFTER UPDATE ON " + TABLE.NOTE +
" WHEN new." + NoteColumns.PARENT_ID + "=" + Notes.ID_TRASH_FOLER + " WHEN new." + NoteColumns.PARENT_ID + "=" + Notes.ID_TRASH_FOLER +
" BEGIN" + " BEGIN" +
" UPDATE " + TABLE.NOTE + " UPDATE " + TABLE.NOTE +
" SET " + NoteColumns.PARENT_ID + "=" + Notes.ID_TRASH_FOLER + " SET " + NoteColumns.PARENT_ID + "=" + Notes.ID_TRASH_FOLER +
" WHERE " + NoteColumns.PARENT_ID + "=old." + NoteColumns.ID + ";" + " WHERE " + NoteColumns.PARENT_ID + "=old." + NoteColumns.ID + ";" +
" END"; " END";
// 创建一个触发器,当文件夹被移动到回收站时,将该文件夹下的所有笔记也移动到回收站
// 构造函数,用于创建数据库帮助类实例
public NotesDatabaseHelper(Context context) { public NotesDatabaseHelper(Context context) {
super(context, DB_NAME, null, DB_VERSION); super(context, DB_NAME, null, DB_VERSION);
} }
// 创建笔记表
public void createNoteTable(SQLiteDatabase db) { public void createNoteTable(SQLiteDatabase db) {
db.execSQL(CREATE_NOTE_TABLE_SQL); db.execSQL(CREATE_NOTE_TABLE_SQL);
reCreateNoteTableTriggers(db); reCreateNoteTableTriggers(db);
createSystemFolder(db); createSystemFolder(db);
Log.d(TAG, "note table has been created"); Log.d(TAG, "note table has been created");
} }
// 执行创建笔记表的SQL语句重新创建相关触发器并创建系统文件夹记录日志表示笔记表创建完成
// 重新创建笔记表的触发器
private void reCreateNoteTableTriggers(SQLiteDatabase db) { private void reCreateNoteTableTriggers(SQLiteDatabase db) {
db.execSQL("DROP TRIGGER IF EXISTS increase_folder_count_on_update"); db.execSQL("DROP TRIGGER IF EXISTS increase_folder_count_on_update");
db.execSQL("DROP TRIGGER IF EXISTS decrease_folder_count_on_update"); db.execSQL("DROP TRIGGER IF EXISTS decrease_folder_count_on_update");
@ -234,19 +258,21 @@ public class NotesDatabaseHelper extends SQLiteOpenHelper {
db.execSQL(FOLDER_DELETE_NOTES_ON_DELETE_TRIGGER); db.execSQL(FOLDER_DELETE_NOTES_ON_DELETE_TRIGGER);
db.execSQL(FOLDER_MOVE_NOTES_ON_TRASH_TRIGGER); db.execSQL(FOLDER_MOVE_NOTES_ON_TRASH_TRIGGER);
} }
// 删除旧的笔记表触发器,然后重新创建它们,以确保触发器的一致性和正确性
// 创建系统文件夹
private void createSystemFolder(SQLiteDatabase db) { private void createSystemFolder(SQLiteDatabase db) {
ContentValues values = new ContentValues(); ContentValues values = new ContentValues();
/** /**
* call record foler for call notes *
*/ */
values.put(NoteColumns.ID, Notes.ID_CALL_RECORD_FOLDER); values.put(NoteColumns.ID, Notes.ID_CALL_RECORD_FOLDER);
values.put(NoteColumns.TYPE, Notes.TYPE_SYSTEM); values.put(NoteColumns.TYPE, Notes.TYPE_SYSTEM);
db.insert(TABLE.NOTE, null, values); db.insert(TABLE.NOTE, null, values);
/** /**
* root folder which is default folder *
*/ */
values.clear(); values.clear();
values.put(NoteColumns.ID, Notes.ID_ROOT_FOLDER); values.put(NoteColumns.ID, Notes.ID_ROOT_FOLDER);
@ -254,7 +280,7 @@ public class NotesDatabaseHelper extends SQLiteOpenHelper {
db.insert(TABLE.NOTE, null, values); db.insert(TABLE.NOTE, null, values);
/** /**
* temporary folder which is used for moving note *
*/ */
values.clear(); values.clear();
values.put(NoteColumns.ID, Notes.ID_TEMPARAY_FOLDER); values.put(NoteColumns.ID, Notes.ID_TEMPARAY_FOLDER);
@ -262,21 +288,25 @@ public class NotesDatabaseHelper extends SQLiteOpenHelper {
db.insert(TABLE.NOTE, null, values); db.insert(TABLE.NOTE, null, values);
/** /**
* create trash folder *
*/ */
values.clear(); values.clear();
values.put(NoteColumns.ID, Notes.ID_TRASH_FOLER); values.put(NoteColumns.ID, Notes.ID_TRASH_FOLER);
values.put(NoteColumns.TYPE, Notes.TYPE_SYSTEM); values.put(NoteColumns.TYPE, Notes.TYPE_SYSTEM);
db.insert(TABLE.NOTE, null, values); db.insert(TABLE.NOTE, null, values);
} }
// 创建各种系统文件夹,如通话记录文件夹、根文件夹、临时文件夹和回收站文件夹
// 创建数据表
public void createDataTable(SQLiteDatabase db) { public void createDataTable(SQLiteDatabase db) {
db.execSQL(CREATE_DATA_TABLE_SQL); db.execSQL(CREATE_DATA_TABLE_SQL);
reCreateDataTableTriggers(db); reCreateDataTableTriggers(db);
db.execSQL(CREATE_DATA_NOTE_ID_INDEX_SQL); db.execSQL(CREATE_DATA_NOTE_ID_INDEX_SQL);
Log.d(TAG, "data table has been created"); Log.d(TAG, "data table has been created");
} }
// 执行创建数据表的SQL语句重新创建相关触发器创建索引并记录日志表示数据表创建完成
// 重新创建数据表的触发器
private void reCreateDataTableTriggers(SQLiteDatabase db) { 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_insert");
db.execSQL("DROP TRIGGER IF EXISTS update_note_content_on_update"); db.execSQL("DROP TRIGGER IF EXISTS update_note_content_on_update");
@ -286,20 +316,26 @@ public class NotesDatabaseHelper extends SQLiteOpenHelper {
db.execSQL(DATA_UPDATE_NOTE_CONTENT_ON_UPDATE_TRIGGER); db.execSQL(DATA_UPDATE_NOTE_CONTENT_ON_UPDATE_TRIGGER);
db.execSQL(DATA_UPDATE_NOTE_CONTENT_ON_DELETE_TRIGGER); db.execSQL(DATA_UPDATE_NOTE_CONTENT_ON_DELETE_TRIGGER);
} }
// 删除旧的数据表触发器,然后重新创建它们,以确保触发器的一致性和正确性
// 获取单例实例
static synchronized NotesDatabaseHelper getInstance(Context context) { static synchronized NotesDatabaseHelper getInstance(Context context) {
if (mInstance == null) { if (mInstance == null) {
mInstance = new NotesDatabaseHelper(context); mInstance = new NotesDatabaseHelper(context);
} }
return mInstance; return mInstance;
} }
// 通过单例模式获取`NotesDatabaseHelper`实例,确保全局只有一个实例
// 当数据库首次创建时调用
@Override @Override
public void onCreate(SQLiteDatabase db) { public void onCreate(SQLiteDatabase db) {
createNoteTable(db); createNoteTable(db);
createDataTable(db); createDataTable(db);
} }
// 数据库首次创建时,调用创建笔记表和数据表的方法
// 当数据库版本升级时调用
@Override @Override
public void onUpgrade(SQLiteDatabase db, int oldVersion, int newVersion) { public void onUpgrade(SQLiteDatabase db, int oldVersion, int newVersion) {
boolean reCreateTriggers = false; boolean reCreateTriggers = false;
@ -307,11 +343,11 @@ public class NotesDatabaseHelper extends SQLiteOpenHelper {
if (oldVersion == 1) { if (oldVersion == 1) {
upgradeToV2(db); upgradeToV2(db);
skipV2 = true; // this upgrade including the upgrade from v2 to v3 skipV2 = true; // 此升级包含从v2到v3的升级
oldVersion++; oldVersion++;
} }
if (oldVersion == 2 && !skipV2) { if (oldVersion == 2 &&!skipV2) {
upgradeToV3(db); upgradeToV3(db);
reCreateTriggers = true; reCreateTriggers = true;
oldVersion++; oldVersion++;
@ -327,12 +363,13 @@ public class NotesDatabaseHelper extends SQLiteOpenHelper {
reCreateDataTableTriggers(db); reCreateDataTableTriggers(db);
} }
if (oldVersion != newVersion) { if (oldVersion!= newVersion) {
throw new IllegalStateException("Upgrade notes database to version " + newVersion throw new IllegalStateException("Upgrade notes database to version " + newVersion
+ "fails"); + " fails");
} }
} }
// 升级到版本2
private void upgradeToV2(SQLiteDatabase db) { private void upgradeToV2(SQLiteDatabase db) {
db.execSQL("DROP TABLE IF EXISTS " + TABLE.NOTE); db.execSQL("DROP TABLE IF EXISTS " + TABLE.NOTE);
db.execSQL("DROP TABLE IF EXISTS " + TABLE.DATA); db.execSQL("DROP TABLE IF EXISTS " + TABLE.DATA);
@ -340,23 +377,25 @@ public class NotesDatabaseHelper extends SQLiteOpenHelper {
createDataTable(db); createDataTable(db);
} }
// 升级到版本3
private void upgradeToV3(SQLiteDatabase db) { private void upgradeToV3(SQLiteDatabase db) {
// drop unused triggers // 删除未使用的触发器
db.execSQL("DROP TRIGGER IF EXISTS update_note_modified_date_on_insert"); 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_delete");
db.execSQL("DROP TRIGGER IF EXISTS update_note_modified_date_on_update"); db.execSQL("DROP TRIGGER IF EXISTS update_note_modified_date_on_update");
// add a column for gtask id // 为笔记表添加gtask id列
db.execSQL("ALTER TABLE " + TABLE.NOTE + " ADD COLUMN " + NoteColumns.GTASK_ID db.execSQL("ALTER TABLE " + TABLE.NOTE + " ADD COLUMN " + NoteColumns.GTASK_ID
+ " TEXT NOT NULL DEFAULT ''"); + " TEXT NOT NULL DEFAULT ''");
// add a trash system folder // 添加回收站系统文件夹
ContentValues values = new ContentValues(); ContentValues values = new ContentValues();
values.put(NoteColumns.ID, Notes.ID_TRASH_FOLER); values.put(NoteColumns.ID, Notes.ID_TRASH_FOLER);
values.put(NoteColumns.TYPE, Notes.TYPE_SYSTEM); values.put(NoteColumns.TYPE, Notes.TYPE_SYSTEM);
db.insert(TABLE.NOTE, null, values); db.insert(TABLE.NOTE, null, values);
} }
// 升级到版本4
private void upgradeToV4(SQLiteDatabase db) { private void upgradeToV4(SQLiteDatabase db) {
db.execSQL("ALTER TABLE " + TABLE.NOTE + " ADD COLUMN " + NoteColumns.VERSION db.execSQL("ALTER TABLE " + TABLE.NOTE + " ADD COLUMN " + NoteColumns.VERSION
+ " INTEGER NOT NULL DEFAULT 0"); + " INTEGER NOT NULL DEFAULT 0");
} }
} }

@ -16,7 +16,6 @@
package net.micode.notes.data; package net.micode.notes.data;
import android.app.SearchManager; import android.app.SearchManager;
import android.content.ContentProvider; import android.content.ContentProvider;
import android.content.ContentUris; import android.content.ContentUris;
@ -34,90 +33,120 @@ import net.micode.notes.data.Notes.DataColumns;
import net.micode.notes.data.Notes.NoteColumns; import net.micode.notes.data.Notes.NoteColumns;
import net.micode.notes.data.NotesDatabaseHelper.TABLE; import net.micode.notes.data.NotesDatabaseHelper.TABLE;
// 内容提供者,用于管理笔记应用的数据访问
// NotesProvider类是一个内容提供者用于管理笔记应用的数据访问提供了查询、插入、删除和更新数据的功能
public class NotesProvider extends ContentProvider { public class NotesProvider extends ContentProvider {
// 用于匹配Uri的UriMatcher
private static final UriMatcher mMatcher; private static final UriMatcher mMatcher;
// 数据库帮助类实例
private NotesDatabaseHelper mHelper; private NotesDatabaseHelper mHelper;
// 日志标签
private static final String TAG = "NotesProvider"; private static final String TAG = "NotesProvider";
private static final int URI_NOTE = 1; // 定义不同Uri匹配的常量
private static final int URI_NOTE_ITEM = 2; private static final int URI_NOTE = 1;
private static final int URI_DATA = 3; // 表示单个笔记的Uri匹配常量
private static final int URI_DATA_ITEM = 4; private static final int URI_NOTE_ITEM = 2;
// 表示数据与笔记相关的数据的Uri匹配常量
private static final int URI_SEARCH = 5; private static final int URI_DATA = 3;
private static final int URI_SEARCH_SUGGEST = 6; // 表示单个数据项的Uri匹配常量
private static final int URI_DATA_ITEM = 4;
// 搜索相关的Uri匹配常量
private static final int URI_SEARCH = 5;
// 搜索建议相关的Uri匹配常量
private static final int URI_SEARCH_SUGGEST = 6;
// 静态代码块初始化UriMatcher
static { static {
mMatcher = new UriMatcher(UriMatcher.NO_MATCH); mMatcher = new UriMatcher(UriMatcher.NO_MATCH);
// 匹配笔记列表的Uri
mMatcher.addURI(Notes.AUTHORITY, "note", URI_NOTE); mMatcher.addURI(Notes.AUTHORITY, "note", URI_NOTE);
// 匹配单个笔记的Uri#表示匹配一个数字笔记ID
mMatcher.addURI(Notes.AUTHORITY, "note/#", URI_NOTE_ITEM); mMatcher.addURI(Notes.AUTHORITY, "note/#", URI_NOTE_ITEM);
// 匹配数据列表的Uri
mMatcher.addURI(Notes.AUTHORITY, "data", URI_DATA); mMatcher.addURI(Notes.AUTHORITY, "data", URI_DATA);
// 匹配单个数据项的Uri#表示匹配一个数字数据ID
mMatcher.addURI(Notes.AUTHORITY, "data/#", URI_DATA_ITEM); mMatcher.addURI(Notes.AUTHORITY, "data/#", URI_DATA_ITEM);
// 匹配搜索的Uri
mMatcher.addURI(Notes.AUTHORITY, "search", URI_SEARCH); mMatcher.addURI(Notes.AUTHORITY, "search", URI_SEARCH);
// 匹配搜索建议的Uri
mMatcher.addURI(Notes.AUTHORITY, SearchManager.SUGGEST_URI_PATH_QUERY, URI_SEARCH_SUGGEST); mMatcher.addURI(Notes.AUTHORITY, SearchManager.SUGGEST_URI_PATH_QUERY, URI_SEARCH_SUGGEST);
// 匹配带查询参数的搜索建议Uri
mMatcher.addURI(Notes.AUTHORITY, SearchManager.SUGGEST_URI_PATH_QUERY + "/*", URI_SEARCH_SUGGEST); mMatcher.addURI(Notes.AUTHORITY, SearchManager.SUGGEST_URI_PATH_QUERY + "/*", URI_SEARCH_SUGGEST);
} }
/** /**
* x'0A' represents the '\n' character in sqlite. For title and content in the search result, * x'0A' sqlite '\n'
* we will trim '\n' and white space in order to show more information. * '\n' 便
*/ */
// 定义搜索结果的投影,用于指定查询返回的列
private static final String NOTES_SEARCH_PROJECTION = NoteColumns.ID + "," private static final String NOTES_SEARCH_PROJECTION = NoteColumns.ID + ","
+ NoteColumns.ID + " AS " + SearchManager.SUGGEST_COLUMN_INTENT_EXTRA_DATA + "," + 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_1 + ","
+ "TRIM(REPLACE(" + NoteColumns.SNIPPET + ", x'0A','')) AS " + SearchManager.SUGGEST_COLUMN_TEXT_2 + "," + "TRIM(REPLACE(" + NoteColumns.SNIPPET + ", x'0A','')) AS " + SearchManager.SUGGEST_COLUMN_TEXT_2 + ","
+ R.drawable.search_result + " AS " + SearchManager.SUGGEST_COLUMN_ICON_1 + "," + R.drawable.search_result + " AS " + SearchManager.SUGGEST_COLUMN_ICON_1 + ","
+ "'" + Intent.ACTION_VIEW + "' AS " + SearchManager.SUGGEST_COLUMN_INTENT_ACTION + "," + "'" + Intent.ACTION_VIEW + "' AS " + SearchManager.SUGGEST_COLUMN_INTENT_ACTION + ","
+ "'" + Notes.TextNote.CONTENT_TYPE + "' AS " + SearchManager.SUGGEST_COLUMN_INTENT_DATA; + "'" + Notes.TextNote.CONTENT_TYPE + "' AS " + SearchManager.SUGGEST_COLUMN_INTENT_DATA;
// 定义笔记片段搜索的SQL查询语句
private static String NOTES_SNIPPET_SEARCH_QUERY = "SELECT " + NOTES_SEARCH_PROJECTION private static String NOTES_SNIPPET_SEARCH_QUERY = "SELECT " + NOTES_SEARCH_PROJECTION
+ " FROM " + TABLE.NOTE + " FROM " + TABLE.NOTE
+ " WHERE " + NoteColumns.SNIPPET + " LIKE ?" + " WHERE " + NoteColumns.SNIPPET + " LIKE?"
+ " AND " + NoteColumns.PARENT_ID + "<>" + Notes.ID_TRASH_FOLER + " AND " + NoteColumns.PARENT_ID + "<>" + Notes.ID_TRASH_FOLER
+ " AND " + NoteColumns.TYPE + "=" + Notes.TYPE_NOTE; + " AND " + NoteColumns.TYPE + "=" + Notes.TYPE_NOTE;
// 内容提供者创建时调用
@Override @Override
public boolean onCreate() { public boolean onCreate() {
// 获取数据库帮助类的实例
mHelper = NotesDatabaseHelper.getInstance(getContext()); mHelper = NotesDatabaseHelper.getInstance(getContext());
return true; return true;
} }
// 查询数据
@Override @Override
public Cursor query(Uri uri, String[] projection, String selection, String[] selectionArgs, public Cursor query(Uri uri, String[] projection, String selection, String[] selectionArgs,
String sortOrder) { String sortOrder) {
Cursor c = null; Cursor c = null;
// 获取可读数据库
SQLiteDatabase db = mHelper.getReadableDatabase(); SQLiteDatabase db = mHelper.getReadableDatabase();
String id = null; String id = null;
// 根据Uri匹配结果执行不同的查询操作
switch (mMatcher.match(uri)) { switch (mMatcher.match(uri)) {
case URI_NOTE: case URI_NOTE:
// 查询笔记表
c = db.query(TABLE.NOTE, projection, selection, selectionArgs, null, null, c = db.query(TABLE.NOTE, projection, selection, selectionArgs, null, null,
sortOrder); sortOrder);
break; break;
case URI_NOTE_ITEM: case URI_NOTE_ITEM:
// 获取Uri路径中的笔记ID
id = uri.getPathSegments().get(1); id = uri.getPathSegments().get(1);
// 根据笔记ID查询笔记表
c = db.query(TABLE.NOTE, projection, NoteColumns.ID + "=" + id c = db.query(TABLE.NOTE, projection, NoteColumns.ID + "=" + id
+ parseSelection(selection), selectionArgs, null, null, sortOrder); + parseSelection(selection), selectionArgs, null, null, sortOrder);
break; break;
case URI_DATA: case URI_DATA:
// 查询数据表
c = db.query(TABLE.DATA, projection, selection, selectionArgs, null, null, c = db.query(TABLE.DATA, projection, selection, selectionArgs, null, null,
sortOrder); sortOrder);
break; break;
case URI_DATA_ITEM: case URI_DATA_ITEM:
// 获取Uri路径中的数据ID
id = uri.getPathSegments().get(1); id = uri.getPathSegments().get(1);
// 根据数据ID查询数据表
c = db.query(TABLE.DATA, projection, DataColumns.ID + "=" + id c = db.query(TABLE.DATA, projection, DataColumns.ID + "=" + id
+ parseSelection(selection), selectionArgs, null, null, sortOrder); + parseSelection(selection), selectionArgs, null, null, sortOrder);
break; break;
case URI_SEARCH: case URI_SEARCH:
case URI_SEARCH_SUGGEST: case URI_SEARCH_SUGGEST:
if (sortOrder != null || projection != null) { // 检查是否有不允许的参数
if (sortOrder!= null || projection!= null) {
throw new IllegalArgumentException( throw new IllegalArgumentException(
"do not specify sortOrder, selection, selectionArgs, or projection" + "with this query"); "do not specify sortOrder, selection, selectionArgs, or projection" + "with this query");
} }
String searchString = null; String searchString = null;
// 根据Uri匹配结果获取搜索字符串
if (mMatcher.match(uri) == URI_SEARCH_SUGGEST) { if (mMatcher.match(uri) == URI_SEARCH_SUGGEST) {
if (uri.getPathSegments().size() > 1) { if (uri.getPathSegments().size() > 1) {
searchString = uri.getPathSegments().get(1); searchString = uri.getPathSegments().get(1);
@ -126,12 +155,15 @@ public class NotesProvider extends ContentProvider {
searchString = uri.getQueryParameter("pattern"); searchString = uri.getQueryParameter("pattern");
} }
// 如果搜索字符串为空返回null
if (TextUtils.isEmpty(searchString)) { if (TextUtils.isEmpty(searchString)) {
return null; return null;
} }
try { try {
// 格式化搜索字符串
searchString = String.format("%%%s%%", searchString); searchString = String.format("%%%s%%", searchString);
// 执行搜索查询
c = db.rawQuery(NOTES_SNIPPET_SEARCH_QUERY, c = db.rawQuery(NOTES_SNIPPET_SEARCH_QUERY,
new String[] { searchString }); new String[] { searchString });
} catch (IllegalStateException ex) { } catch (IllegalStateException ex) {
@ -139,40 +171,49 @@ public class NotesProvider extends ContentProvider {
} }
break; break;
default: default:
// 未知的Uri抛出异常
throw new IllegalArgumentException("Unknown URI " + uri); throw new IllegalArgumentException("Unknown URI " + uri);
} }
if (c != null) { // 设置游标通知Uri
if (c!= null) {
c.setNotificationUri(getContext().getContentResolver(), uri); c.setNotificationUri(getContext().getContentResolver(), uri);
} }
return c; return c;
} }
// 插入数据
@Override @Override
public Uri insert(Uri uri, ContentValues values) { public Uri insert(Uri uri, ContentValues values) {
// 获取可写数据库
SQLiteDatabase db = mHelper.getWritableDatabase(); SQLiteDatabase db = mHelper.getWritableDatabase();
long dataId = 0, noteId = 0, insertedId = 0; long dataId = 0, noteId = 0, insertedId = 0;
// 根据Uri匹配结果执行不同的插入操作
switch (mMatcher.match(uri)) { switch (mMatcher.match(uri)) {
case URI_NOTE: case URI_NOTE:
// 插入笔记数据
insertedId = noteId = db.insert(TABLE.NOTE, null, values); insertedId = noteId = db.insert(TABLE.NOTE, null, values);
break; break;
case URI_DATA: case URI_DATA:
// 检查数据中是否包含笔记ID
if (values.containsKey(DataColumns.NOTE_ID)) { if (values.containsKey(DataColumns.NOTE_ID)) {
noteId = values.getAsLong(DataColumns.NOTE_ID); noteId = values.getAsLong(DataColumns.NOTE_ID);
} else { } else {
Log.d(TAG, "Wrong data format without note id:" + values.toString()); Log.d(TAG, "Wrong data format without note id:" + values.toString());
} }
// 插入数据
insertedId = dataId = db.insert(TABLE.DATA, null, values); insertedId = dataId = db.insert(TABLE.DATA, null, values);
break; break;
default: default:
// 未知的Uri抛出异常
throw new IllegalArgumentException("Unknown URI " + uri); throw new IllegalArgumentException("Unknown URI " + uri);
} }
// Notify the note uri // 通知笔记Uri数据变化
if (noteId > 0) { if (noteId > 0) {
getContext().getContentResolver().notifyChange( getContext().getContentResolver().notifyChange(
ContentUris.withAppendedId(Notes.CONTENT_NOTE_URI, noteId), null); ContentUris.withAppendedId(Notes.CONTENT_NOTE_URI, noteId), null);
} }
// Notify the data uri // 通知数据Uri数据变化
if (dataId > 0) { if (dataId > 0) {
getContext().getContentResolver().notifyChange( getContext().getContentResolver().notifyChange(
ContentUris.withAppendedId(Notes.CONTENT_DATA_URI, dataId), null); ContentUris.withAppendedId(Notes.CONTENT_DATA_URI, dataId), null);
@ -181,43 +222,54 @@ public class NotesProvider extends ContentProvider {
return ContentUris.withAppendedId(uri, insertedId); return ContentUris.withAppendedId(uri, insertedId);
} }
// 删除数据
@Override @Override
public int delete(Uri uri, String selection, String[] selectionArgs) { public int delete(Uri uri, String selection, String[] selectionArgs) {
int count = 0; int count = 0;
String id = null; String id = null;
// 获取可写数据库
SQLiteDatabase db = mHelper.getWritableDatabase(); SQLiteDatabase db = mHelper.getWritableDatabase();
boolean deleteData = false; boolean deleteData = false;
// 根据Uri匹配结果执行不同的删除操作
switch (mMatcher.match(uri)) { switch (mMatcher.match(uri)) {
case URI_NOTE: case URI_NOTE:
// 组合删除条件
selection = "(" + selection + ") AND " + NoteColumns.ID + ">0 "; selection = "(" + selection + ") AND " + NoteColumns.ID + ">0 ";
// 删除笔记数据
count = db.delete(TABLE.NOTE, selection, selectionArgs); count = db.delete(TABLE.NOTE, selection, selectionArgs);
break; break;
case URI_NOTE_ITEM: case URI_NOTE_ITEM:
// 获取Uri路径中的笔记ID
id = uri.getPathSegments().get(1); id = uri.getPathSegments().get(1);
/** /**
* ID that smaller than 0 is system folder which is not allowed to * ID0
* trash
*/ */
long noteId = Long.valueOf(id); long noteId = Long.valueOf(id);
if (noteId <= 0) { if (noteId <= 0) {
break; break;
} }
// 根据笔记ID删除笔记数据
count = db.delete(TABLE.NOTE, count = db.delete(TABLE.NOTE,
NoteColumns.ID + "=" + id + parseSelection(selection), selectionArgs); NoteColumns.ID + "=" + id + parseSelection(selection), selectionArgs);
break; break;
case URI_DATA: case URI_DATA:
// 删除数据
count = db.delete(TABLE.DATA, selection, selectionArgs); count = db.delete(TABLE.DATA, selection, selectionArgs);
deleteData = true; deleteData = true;
break; break;
case URI_DATA_ITEM: case URI_DATA_ITEM:
// 获取Uri路径中的数据ID
id = uri.getPathSegments().get(1); id = uri.getPathSegments().get(1);
// 根据数据ID删除数据
count = db.delete(TABLE.DATA, count = db.delete(TABLE.DATA,
DataColumns.ID + "=" + id + parseSelection(selection), selectionArgs); DataColumns.ID + "=" + id + parseSelection(selection), selectionArgs);
deleteData = true; deleteData = true;
break; break;
default: default:
// 未知的Uri抛出异常
throw new IllegalArgumentException("Unknown URI " + uri); throw new IllegalArgumentException("Unknown URI " + uri);
} }
// 如果删除成功,通知数据变化
if (count > 0) { if (count > 0) {
if (deleteData) { if (deleteData) {
getContext().getContentResolver().notifyChange(Notes.CONTENT_NOTE_URI, null); getContext().getContentResolver().notifyChange(Notes.CONTENT_NOTE_URI, null);
@ -227,37 +279,50 @@ public class NotesProvider extends ContentProvider {
return count; return count;
} }
// 更新数据
@Override @Override
public int update(Uri uri, ContentValues values, String selection, String[] selectionArgs) { public int update(Uri uri, ContentValues values, String selection, String[] selectionArgs) {
int count = 0; int count = 0;
String id = null; String id = null;
// 获取可写数据库
SQLiteDatabase db = mHelper.getWritableDatabase(); SQLiteDatabase db = mHelper.getWritableDatabase();
boolean updateData = false; boolean updateData = false;
// 根据Uri匹配结果执行不同的更新操作
switch (mMatcher.match(uri)) { switch (mMatcher.match(uri)) {
case URI_NOTE: case URI_NOTE:
// 增加笔记版本号
increaseNoteVersion(-1, selection, selectionArgs); increaseNoteVersion(-1, selection, selectionArgs);
// 更新笔记数据
count = db.update(TABLE.NOTE, values, selection, selectionArgs); count = db.update(TABLE.NOTE, values, selection, selectionArgs);
break; break;
case URI_NOTE_ITEM: case URI_NOTE_ITEM:
// 获取Uri路径中的笔记ID
id = uri.getPathSegments().get(1); id = uri.getPathSegments().get(1);
// 增加笔记版本号
increaseNoteVersion(Long.valueOf(id), selection, selectionArgs); increaseNoteVersion(Long.valueOf(id), selection, selectionArgs);
// 根据笔记ID更新笔记数据
count = db.update(TABLE.NOTE, values, NoteColumns.ID + "=" + id count = db.update(TABLE.NOTE, values, NoteColumns.ID + "=" + id
+ parseSelection(selection), selectionArgs); + parseSelection(selection), selectionArgs);
break; break;
case URI_DATA: case URI_DATA:
// 更新数据
count = db.update(TABLE.DATA, values, selection, selectionArgs); count = db.update(TABLE.DATA, values, selection, selectionArgs);
updateData = true; updateData = true;
break; break;
case URI_DATA_ITEM: case URI_DATA_ITEM:
// 获取Uri路径中的数据ID
id = uri.getPathSegments().get(1); id = uri.getPathSegments().get(1);
// 根据数据ID更新数据
count = db.update(TABLE.DATA, values, DataColumns.ID + "=" + id count = db.update(TABLE.DATA, values, DataColumns.ID + "=" + id
+ parseSelection(selection), selectionArgs); + parseSelection(selection), selectionArgs);
updateData = true; updateData = true;
break; break;
default: default:
// 未知的Uri抛出异常
throw new IllegalArgumentException("Unknown URI " + uri); throw new IllegalArgumentException("Unknown URI " + uri);
} }
// 如果更新成功,通知数据变化
if (count > 0) { if (count > 0) {
if (updateData) { if (updateData) {
getContext().getContentResolver().notifyChange(Notes.CONTENT_NOTE_URI, null); getContext().getContentResolver().notifyChange(Notes.CONTENT_NOTE_URI, null);
@ -267,10 +332,12 @@ public class NotesProvider extends ContentProvider {
return count; return count;
} }
// 解析选择条件添加AND连接符
private String parseSelection(String selection) { private String parseSelection(String selection) {
return (!TextUtils.isEmpty(selection) ? " AND (" + selection + ')' : ""); return (!TextUtils.isEmpty(selection)? " AND (" + selection + ')' : "");
} }
// 增加笔记版本号
private void increaseNoteVersion(long id, String selection, String[] selectionArgs) { private void increaseNoteVersion(long id, String selection, String[] selectionArgs) {
StringBuilder sql = new StringBuilder(120); StringBuilder sql = new StringBuilder(120);
sql.append("UPDATE "); sql.append("UPDATE ");
@ -279,27 +346,29 @@ public class NotesProvider extends ContentProvider {
sql.append(NoteColumns.VERSION); sql.append(NoteColumns.VERSION);
sql.append("=" + NoteColumns.VERSION + "+1 "); sql.append("=" + NoteColumns.VERSION + "+1 ");
if (id > 0 || !TextUtils.isEmpty(selection)) { // 如果有ID或选择条件添加WHERE子句
if (id > 0 ||!TextUtils.isEmpty(selection)) {
sql.append(" WHERE "); sql.append(" WHERE ");
} }
if (id > 0) { if (id > 0) {
sql.append(NoteColumns.ID + "=" + String.valueOf(id)); sql.append(NoteColumns.ID + "=" + String.valueOf(id));
} }
if (!TextUtils.isEmpty(selection)) { if (!TextUtils.isEmpty(selection)) {
String selectString = id > 0 ? parseSelection(selection) : selection; String selectString = id > 0? parseSelection(selection) : selection;
for (String args : selectionArgs) { for (String args : selectionArgs) {
selectString = selectString.replaceFirst("\\?", args); selectString = selectString.replaceFirst("\\?", args);
} }
sql.append(selectString); sql.append(selectString);
} }
// 执行SQL语句
mHelper.getWritableDatabase().execSQL(sql.toString()); mHelper.getWritableDatabase().execSQL(sql.toString());
} }
// 获取Uri对应的MIME类型此处未实现
@Override @Override
public String getType(Uri uri) { public String getType(Uri uri) {
// TODO Auto-generated method stub // TODO Auto-generated method stub
return null; return null;
} }
}
}

@ -24,59 +24,103 @@ import net.micode.notes.tool.GTaskStringUtils;
import org.json.JSONException; import org.json.JSONException;
import org.json.JSONObject; import org.json.JSONObject;
/**
* MetaDataTask
* JSON
*/
public class MetaData extends Task {
private static final String TAG = MetaData.class.getSimpleName();
private String relatedGid = null;
public class MetaData extends Task { //元数据 /**
private final static String TAG = MetaData.class.getSimpleName(); *
*
private String mRelatedGid = null; * @param gid Gid
* @param metaInfo JSON
*/
public void setMeta(String gid, JSONObject metaInfo) { public void setMeta(String gid, JSONObject metaInfo) {
try { try {
metaInfo.put(GTaskStringUtils.META_HEAD_GTASK_ID, gid); metaInfo.put(GTaskStringUtils.META_HEAD_GTASK_ID, gid);
} catch (JSONException e) { } catch (JSONException e) {
Log.e(TAG, "failed to put related gid"); Log.e(TAG, "Failed to put related gid", e);
} }
setNotes(metaInfo.toString()); setNotes(metaInfo.toString());
setName(GTaskStringUtils.META_NOTE_NAME); setName(GTaskStringUtils.META_NOTE_NAME);
} }
/**
* Gid
*
* @return Gid
*/
public String getRelatedGid() { public String getRelatedGid() {
return mRelatedGid; return relatedGid;
} }
/**
*
*
* @return nulltruefalse
*/
@Override @Override
public boolean isWorthSaving() { public boolean isWorthSaving() {
return getNotes() != null; return getNotes()!= null;
} }
/**
* JSON
* Gid
*
* @param js JSONObject
*/
@Override @Override
public void setContentByRemoteJSON(JSONObject js) { public void setContentByRemoteJSON(JSONObject js) {
super.setContentByRemoteJSON(js); super.setContentByRemoteJSON(js);
if (getNotes() != null) { if (getNotes()!= null) {
try { try {
JSONObject metaInfo = new JSONObject(getNotes().trim()); JSONObject metaInfo = new JSONObject(getNotes().trim());
mRelatedGid = metaInfo.getString(GTaskStringUtils.META_HEAD_GTASK_ID); relatedGid = metaInfo.getString(GTaskStringUtils.META_HEAD_GTASK_ID);
} catch (JSONException e) { } catch (JSONException e) {
Log.w(TAG, "failed to get related gid"); Log.w(TAG, "Failed to get related gid", e);
mRelatedGid = null; relatedGid = null;
} }
} }
} }
/**
*
* 使@Deprecated使
*
* @param js
*/
@Override @Override
@Deprecated
public void setContentByLocalJSON(JSONObject js) { public void setContentByLocalJSON(JSONObject js) {
// this function should not be called
throw new IllegalAccessError("MetaData:setContentByLocalJSON should not be called"); throw new IllegalAccessError("MetaData:setContentByLocalJSON should not be called");
} }
/**
*
* 使@Deprecated使
*
* @return
*/
@Override @Override
@Deprecated
public JSONObject getLocalJSONFromContent() { public JSONObject getLocalJSONFromContent() {
throw new IllegalAccessError("MetaData:getLocalJSONFromContent should not be called"); throw new IllegalAccessError("MetaData:getLocalJSONFromContent should not be called");
} }
/**
*
* 使@Deprecated使
*
* @param c
* @return
*/
@Override @Override
@Deprecated
public int getSyncAction(Cursor c) { public int getSyncAction(Cursor c) {
throw new IllegalAccessError("MetaData:getSyncAction should not be called"); throw new IllegalAccessError("MetaData:getSyncAction should not be called");
} }
}
}

@ -17,85 +17,159 @@
package net.micode.notes.gtask.data; package net.micode.notes.gtask.data;
import android.database.Cursor; import android.database.Cursor;
import org.json.JSONObject; import org.json.JSONObject;
/**
* NodeGoogle Tasks
*
*
*/
public abstract class Node { public abstract class Node {
public static final int SYNC_ACTION_NONE = 0;
// 同步操作类型常量
public static final int SYNC_ACTION_NONE = 0;
public static final int SYNC_ACTION_ADD_REMOTE = 1; public static final int SYNC_ACTION_ADD_REMOTE = 1;
public static final int SYNC_ACTION_ADD_LOCAL = 2; 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_REMOTE = 3;
public static final int SYNC_ACTION_DEL_LOCAL = 4; 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_REMOTE = 5;
public static final int SYNC_ACTION_UPDATE_LOCAL = 6; public static final int SYNC_ACTION_UPDATE_LOCAL = 6;
public static final int SYNC_ACTION_UPDATE_CONFLICT = 7; public static final int SYNC_ACTION_UPDATE_CONFLICT = 7;
public static final int SYNC_ACTION_ERROR = 8; public static final int SYNC_ACTION_ERROR = 8;
private String mGid; // Google Tasks的唯一标识符
private String gid;
private String mName; // 节点名称
private String name;
private long mLastModified; // 最后修改时间
private long lastModified;
private boolean mDeleted; // 表示该节点是否已被删除
private boolean deleted;
/**
*
*/
public Node() { public Node() {
mGid = null; gid = null;
mName = ""; name = "";
mLastModified = 0; lastModified = 0;
mDeleted = false; deleted = false;
} }
/**
* JSONID
*
* @param actionId ID
* @return JSONObject
*/
public abstract JSONObject getCreateAction(int actionId); public abstract JSONObject getCreateAction(int actionId);
/**
* JSONID
*
* @param actionId ID
* @return JSONObject
*/
public abstract JSONObject getUpdateAction(int actionId); public abstract JSONObject getUpdateAction(int actionId);
/**
* JSON
*
* @param js JSONObject
*/
public abstract void setContentByRemoteJSON(JSONObject js); public abstract void setContentByRemoteJSON(JSONObject js);
/**
* JSON
*
* @param js JSONObject
*/
public abstract void setContentByLocalJSON(JSONObject js); public abstract void setContentByLocalJSON(JSONObject js);
/**
* JSON
*
* @return JSONObject
*/
public abstract JSONObject getLocalJSONFromContent(); public abstract JSONObject getLocalJSONFromContent();
/**
*
*
* @param c
* @return
*/
public abstract int getSyncAction(Cursor c); public abstract int getSyncAction(Cursor c);
/**
* Google Tasks
*
* @param gid Google Tasks
*/
public void setGid(String gid) { public void setGid(String gid) {
this.mGid = gid; this.gid = gid;
} }
/**
*
*
* @param name
*/
public void setName(String name) { public void setName(String name) {
this.mName = name; this.name = name;
} }
/**
*
*
* @param lastModified
*/
public void setLastModified(long lastModified) { public void setLastModified(long lastModified) {
this.mLastModified = lastModified; this.lastModified = lastModified;
} }
/**
*
*
* @param deleted
*/
public void setDeleted(boolean deleted) { public void setDeleted(boolean deleted) {
this.mDeleted = deleted; this.deleted = deleted;
} }
/**
* Google Tasks
*
* @return Google Tasks
*/
public String getGid() { public String getGid() {
return this.mGid; return gid;
} }
/**
*
*
* @return
*/
public String getName() { public String getName() {
return this.mName; return name;
} }
/**
*
*
* @return
*/
public long getLastModified() { public long getLastModified() {
return this.mLastModified; return lastModified;
} }
/**
*
*
* @return
*/
public boolean getDeleted() { public boolean getDeleted() {
return this.mDeleted; return deleted;
} }
}
}

@ -34,156 +34,217 @@ import net.micode.notes.gtask.exception.ActionFailureException;
import org.json.JSONException; import org.json.JSONException;
import org.json.JSONObject; import org.json.JSONObject;
// SqlData类用于处理与数据库中数据记录相关的操作包括数据的加载、设置、提交等
public class SqlData { public class SqlData {
// 日志标签,使用类的简单名称
private static final String TAG = SqlData.class.getSimpleName(); private static final String TAG = SqlData.class.getSimpleName();
// 无效ID的常量值
private static final int INVALID_ID = -99999; private static final int INVALID_ID = -99999;
// 定义用于查询数据的投影数组,指定要返回的列
public static final String[] PROJECTION_DATA = new String[] { public static final String[] PROJECTION_DATA = new String[] {
DataColumns.ID, DataColumns.MIME_TYPE, DataColumns.CONTENT, DataColumns.DATA1, DataColumns.ID, DataColumns.MIME_TYPE, DataColumns.CONTENT, DataColumns.DATA1,
DataColumns.DATA3 DataColumns.DATA3
}; };
// 投影数组中数据ID列的索引
public static final int DATA_ID_COLUMN = 0; public static final int DATA_ID_COLUMN = 0;
// 投影数组中MIME类型列的索引
public static final int DATA_MIME_TYPE_COLUMN = 1; public static final int DATA_MIME_TYPE_COLUMN = 1;
// 投影数组中内容列的索引
public static final int DATA_CONTENT_COLUMN = 2; public static final int DATA_CONTENT_COLUMN = 2;
// 投影数组中DATA1列的索引
public static final int DATA_CONTENT_DATA_1_COLUMN = 3; public static final int DATA_CONTENT_DATA_1_COLUMN = 3;
// 投影数组中DATA3列的索引
public static final int DATA_CONTENT_DATA_3_COLUMN = 4; public static final int DATA_CONTENT_DATA_3_COLUMN = 4;
// 内容解析器,用于与内容提供者进行交互
private ContentResolver mContentResolver; private ContentResolver mContentResolver;
// 表示当前数据是否为新建状态
private boolean mIsCreate; private boolean mIsCreate;
// 数据记录的ID
private long mDataId; private long mDataId;
// 数据的MIME类型
private String mDataMimeType; private String mDataMimeType;
// 数据的内容
private String mDataContent; private String mDataContent;
// 数据的DATA1字段值
private long mDataContentData1; private long mDataContentData1;
// 数据的DATA3字段值
private String mDataContentData3; private String mDataContentData3;
// 用于存储数据变化的ContentValues对象
private ContentValues mDiffDataValues; private ContentValues mDiffDataValues;
// 构造函数,初始化对象状态,适用于新建数据的情况
public SqlData(Context context) { public SqlData(Context context) {
// 获取上下文的内容解析器
mContentResolver = context.getContentResolver(); mContentResolver = context.getContentResolver();
// 设置为新建状态
mIsCreate = true; mIsCreate = true;
// 设置无效的初始ID
mDataId = INVALID_ID; mDataId = INVALID_ID;
// 设置默认的MIME类型为NOTES类型
mDataMimeType = DataConstants.NOTE; mDataMimeType = DataConstants.NOTE;
// 设置默认的空内容
mDataContent = ""; mDataContent = "";
// 设置默认的DATA1字段值为0
mDataContentData1 = 0; mDataContentData1 = 0;
// 设置默认的空DATA3字段值
mDataContentData3 = ""; mDataContentData3 = "";
// 初始化用于存储数据变化的ContentValues对象
mDiffDataValues = new ContentValues(); mDiffDataValues = new ContentValues();
} }
// 构造函数,从游标中加载数据,适用于从数据库中读取已有数据的情况
public SqlData(Context context, Cursor c) { public SqlData(Context context, Cursor c) {
// 获取上下文的内容解析器
mContentResolver = context.getContentResolver(); mContentResolver = context.getContentResolver();
// 设置为非新建状态
mIsCreate = false; mIsCreate = false;
// 从游标中加载数据
loadFromCursor(c); loadFromCursor(c);
// 初始化用于存储数据变化的ContentValues对象
mDiffDataValues = new ContentValues(); mDiffDataValues = new ContentValues();
} }
// 从游标中加载数据到对象的成员变量
private void loadFromCursor(Cursor c) { private void loadFromCursor(Cursor c) {
// 从游标中获取数据ID并赋值给成员变量
mDataId = c.getLong(DATA_ID_COLUMN); mDataId = c.getLong(DATA_ID_COLUMN);
// 从游标中获取MIME类型并赋值给成员变量
mDataMimeType = c.getString(DATA_MIME_TYPE_COLUMN); mDataMimeType = c.getString(DATA_MIME_TYPE_COLUMN);
// 从游标中获取内容并赋值给成员变量
mDataContent = c.getString(DATA_CONTENT_COLUMN); mDataContent = c.getString(DATA_CONTENT_COLUMN);
// 从游标中获取DATA1字段值并赋值给成员变量
mDataContentData1 = c.getLong(DATA_CONTENT_DATA_1_COLUMN); mDataContentData1 = c.getLong(DATA_CONTENT_DATA_1_COLUMN);
// 从游标中获取DATA3字段值并赋值给成员变量
mDataContentData3 = c.getString(DATA_CONTENT_DATA_3_COLUMN); mDataContentData3 = c.getString(DATA_CONTENT_DATA_3_COLUMN);
} }
// 根据传入的JSONObject设置数据内容并记录数据变化
public void setContent(JSONObject js) throws JSONException { public void setContent(JSONObject js) throws JSONException {
long dataId = js.has(DataColumns.ID) ? js.getLong(DataColumns.ID) : INVALID_ID; // 从JSONObject中获取数据ID如果不存在则使用无效ID
if (mIsCreate || mDataId != dataId) { long dataId = js.has(DataColumns.ID)? js.getLong(DataColumns.ID) : INVALID_ID;
// 如果是新建数据或者当前数据ID与JSONObject中的ID不同则记录ID变化
if (mIsCreate || mDataId!= dataId) {
mDiffDataValues.put(DataColumns.ID, dataId); mDiffDataValues.put(DataColumns.ID, dataId);
} }
// 更新数据ID
mDataId = dataId; mDataId = dataId;
String dataMimeType = js.has(DataColumns.MIME_TYPE) ? js.getString(DataColumns.MIME_TYPE) // 从JSONObject中获取MIME类型如果不存在则使用默认的NOTES类型
String dataMimeType = js.has(DataColumns.MIME_TYPE)? js.getString(DataColumns.MIME_TYPE)
: DataConstants.NOTE; : DataConstants.NOTE;
if (mIsCreate || !mDataMimeType.equals(dataMimeType)) { // 如果是新建数据或者当前MIME类型与JSONObject中的类型不同则记录MIME类型变化
if (mIsCreate ||!mDataMimeType.equals(dataMimeType)) {
mDiffDataValues.put(DataColumns.MIME_TYPE, dataMimeType); mDiffDataValues.put(DataColumns.MIME_TYPE, dataMimeType);
} }
// 更新MIME类型
mDataMimeType = dataMimeType; mDataMimeType = dataMimeType;
String dataContent = js.has(DataColumns.CONTENT) ? js.getString(DataColumns.CONTENT) : ""; // 从JSONObject中获取内容如果不存在则使用空字符串
if (mIsCreate || !mDataContent.equals(dataContent)) { String dataContent = js.has(DataColumns.CONTENT)? js.getString(DataColumns.CONTENT) : "";
// 如果是新建数据或者当前内容与JSONObject中的内容不同则记录内容变化
if (mIsCreate ||!mDataContent.equals(dataContent)) {
mDiffDataValues.put(DataColumns.CONTENT, dataContent); mDiffDataValues.put(DataColumns.CONTENT, dataContent);
} }
// 更新内容
mDataContent = dataContent; mDataContent = dataContent;
long dataContentData1 = js.has(DataColumns.DATA1) ? js.getLong(DataColumns.DATA1) : 0; // 从JSONObject中获取DATA1字段值如果不存在则使用0
if (mIsCreate || mDataContentData1 != dataContentData1) { long dataContentData1 = js.has(DataColumns.DATA1)? js.getLong(DataColumns.DATA1) : 0;
// 如果是新建数据或者当前DATA1字段值与JSONObject中的值不同则记录DATA1字段值变化
if (mIsCreate || mDataContentData1!= dataContentData1) {
mDiffDataValues.put(DataColumns.DATA1, dataContentData1); mDiffDataValues.put(DataColumns.DATA1, dataContentData1);
} }
// 更新DATA1字段值
mDataContentData1 = dataContentData1; mDataContentData1 = dataContentData1;
String dataContentData3 = js.has(DataColumns.DATA3) ? js.getString(DataColumns.DATA3) : ""; // 从JSONObject中获取DATA3字段值如果不存在则使用空字符串
if (mIsCreate || !mDataContentData3.equals(dataContentData3)) { String dataContentData3 = js.has(DataColumns.DATA3)? js.getString(DataColumns.DATA3) : "";
// 如果是新建数据或者当前DATA3字段值与JSONObject中的值不同则记录DATA3字段值变化
if (mIsCreate ||!mDataContentData3.equals(dataContentData3)) {
mDiffDataValues.put(DataColumns.DATA3, dataContentData3); mDiffDataValues.put(DataColumns.DATA3, dataContentData3);
} }
// 更新DATA3字段值
mDataContentData3 = dataContentData3; mDataContentData3 = dataContentData3;
} }
// 获取当前数据的JSONObject表示
public JSONObject getContent() throws JSONException { public JSONObject getContent() throws JSONException {
// 如果是新建数据说明还未在数据库中创建记录错误日志并返回null
if (mIsCreate) { if (mIsCreate) {
Log.e(TAG, "it seems that we haven't created this in database yet"); Log.e(TAG, "it seems that we haven't created this in database yet");
return null; return null;
} }
// 创建一个JSONObject对象
JSONObject js = new JSONObject(); JSONObject js = new JSONObject();
// 将数据ID放入JSONObject
js.put(DataColumns.ID, mDataId); js.put(DataColumns.ID, mDataId);
// 将MIME类型放入JSONObject
js.put(DataColumns.MIME_TYPE, mDataMimeType); js.put(DataColumns.MIME_TYPE, mDataMimeType);
// 将内容放入JSONObject
js.put(DataColumns.CONTENT, mDataContent); js.put(DataColumns.CONTENT, mDataContent);
// 将DATA1字段值放入JSONObject
js.put(DataColumns.DATA1, mDataContentData1); js.put(DataColumns.DATA1, mDataContentData1);
// 将DATA3字段值放入JSONObject
js.put(DataColumns.DATA3, mDataContentData3); js.put(DataColumns.DATA3, mDataContentData3);
// 返回包含数据的JSONObject
return js; return js;
} }
// 将数据提交到数据库,根据数据的新建或已有状态进行插入或更新操作
public void commit(long noteId, boolean validateVersion, long version) { public void commit(long noteId, boolean validateVersion, long version) {
// 如果是新建数据
if (mIsCreate) { if (mIsCreate) {
// 如果数据ID无效且DiffDataValues中包含ID则移除ID因为新建时不应包含ID
if (mDataId == INVALID_ID && mDiffDataValues.containsKey(DataColumns.ID)) { if (mDataId == INVALID_ID && mDiffDataValues.containsKey(DataColumns.ID)) {
mDiffDataValues.remove(DataColumns.ID); mDiffDataValues.remove(DataColumns.ID);
} }
// 设置数据所属的笔记ID
mDiffDataValues.put(DataColumns.NOTE_ID, noteId); mDiffDataValues.put(DataColumns.NOTE_ID, noteId);
// 使用内容解析器插入数据并获取插入后的Uri
Uri uri = mContentResolver.insert(Notes.CONTENT_DATA_URI, mDiffDataValues); Uri uri = mContentResolver.insert(Notes.CONTENT_DATA_URI, mDiffDataValues);
try { try {
// 从Uri中获取插入数据的ID并更新对象的mDataId
mDataId = Long.valueOf(uri.getPathSegments().get(1)); mDataId = Long.valueOf(uri.getPathSegments().get(1));
} catch (NumberFormatException e) { } catch (NumberFormatException e) {
// 如果获取ID失败记录错误日志并抛出异常
Log.e(TAG, "Get note id error :" + e.toString()); Log.e(TAG, "Get note id error :" + e.toString());
throw new ActionFailureException("create note failed"); throw new ActionFailureException("create note failed");
} }
} else { } else {
// 如果数据有变化
if (mDiffDataValues.size() > 0) { if (mDiffDataValues.size() > 0) {
int result = 0; int result = 0;
// 如果不需要验证版本
if (!validateVersion) { if (!validateVersion) {
// 直接更新数据
result = mContentResolver.update(ContentUris.withAppendedId( result = mContentResolver.update(ContentUris.withAppendedId(
Notes.CONTENT_DATA_URI, mDataId), mDiffDataValues, null, null); Notes.CONTENT_DATA_URI, mDataId), mDiffDataValues, null, null);
} else { } else {
// 需要验证版本根据笔记ID和版本号进行更新
result = mContentResolver.update(ContentUris.withAppendedId( result = mContentResolver.update(ContentUris.withAppendedId(
Notes.CONTENT_DATA_URI, mDataId), mDiffDataValues, Notes.CONTENT_DATA_URI, mDataId), mDiffDataValues,
" ? in (SELECT " + NoteColumns.ID + " FROM " + TABLE.NOTE "? in (SELECT " + NoteColumns.ID + " FROM " + TABLE.NOTE
+ " WHERE " + NoteColumns.VERSION + "=?)", new String[] { + " WHERE " + NoteColumns.VERSION + "=?)", new String[] {
String.valueOf(noteId), String.valueOf(version) String.valueOf(noteId), String.valueOf(version)
}); });
} }
// 如果更新结果为0说明可能在同步时用户更新了笔记记录警告日志
if (result == 0) { if (result == 0) {
Log.w(TAG, "there is no update. maybe user updates note when syncing"); Log.w(TAG, "there is no update. maybe user updates note when syncing");
} }
} }
} }
// 清空记录数据变化的ContentValues对象
mDiffDataValues.clear(); mDiffDataValues.clear();
// 设置为非新建状态
mIsCreate = false; mIsCreate = false;
} }
// 获取数据记录的ID
public long getId() { public long getId() {
return mDataId; return mDataId;
} }
} }

@ -38,11 +38,37 @@ import org.json.JSONObject;
import java.util.ArrayList; import java.util.ArrayList;
import android.content.ContentResolver;
import android.content.ContentValues;
import android.content.Context;
import android.database.Cursor;
import android.net.Uri;
import android.widget.RemoteViews;
import com.google.gson.JsonObject;
import org.json.JSONArray;
import org.json.JSONException;
import org.json.JSONObject;
import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.atomic.AtomicInteger;
import androidx.annotation.NonNull;
import androidx.annotation.Nullable;
import androidx.appcompat.widget.AppCompatDrawableManager;
import androidx.cursoradapter.widget.SimpleCursorAdapter;
// SqlNote类用于处理与笔记数据的SQL相关操作包括从数据库加载、保存、更新笔记信息等
public class SqlNote { public class SqlNote {
// 日志标签,用于标识该类相关的日志信息
private static final String TAG = SqlNote.class.getSimpleName(); private static final String TAG = SqlNote.class.getSimpleName();
// 无效的ID值
private static final int INVALID_ID = -99999; private static final int INVALID_ID = -99999;
// 用于查询笔记时的投影列,指定要从数据库中获取的列
public static final String[] PROJECTION_NOTE = new String[] { public static final String[] PROJECTION_NOTE = new String[] {
NoteColumns.ID, NoteColumns.ALERTED_DATE, NoteColumns.BG_COLOR_ID, NoteColumns.ID, NoteColumns.ALERTED_DATE, NoteColumns.BG_COLOR_ID,
NoteColumns.CREATED_DATE, NoteColumns.HAS_ATTACHMENT, NoteColumns.MODIFIED_DATE, NoteColumns.CREATED_DATE, NoteColumns.HAS_ATTACHMENT, NoteColumns.MODIFIED_DATE,
@ -52,76 +78,79 @@ public class SqlNote {
NoteColumns.VERSION NoteColumns.VERSION
}; };
// 投影列中ID列的索引
public static final int ID_COLUMN = 0; public static final int ID_COLUMN = 0;
// 投影列中提醒日期列的索引
public static final int ALERTED_DATE_COLUMN = 1; public static final int ALERTED_DATE_COLUMN = 1;
// 投影列中背景颜色ID列的索引
public static final int BG_COLOR_ID_COLUMN = 2; public static final int BG_COLOR_ID_COLUMN = 2;
// 投影列中创建日期列的索引
public static final int CREATED_DATE_COLUMN = 3; public static final int CREATED_DATE_COLUMN = 3;
// 投影列中是否有附件列的索引
public static final int HAS_ATTACHMENT_COLUMN = 4; public static final int HAS_ATTACHMENT_COLUMN = 4;
// 投影列中修改日期列的索引
public static final int MODIFIED_DATE_COLUMN = 5; public static final int MODIFIED_DATE_COLUMN = 5;
// 投影列中文件夹内笔记数量列的索引
public static final int NOTES_COUNT_COLUMN = 6; public static final int NOTES_COUNT_COLUMN = 6;
// 投影列中父级ID列的索引
public static final int PARENT_ID_COLUMN = 7; public static final int PARENT_ID_COLUMN = 7;
// 投影列中文本内容或文件夹名称列的索引
public static final int SNIPPET_COLUMN = 8; public static final int SNIPPET_COLUMN = 8;
// 投影列中类型列的索引
public static final int TYPE_COLUMN = 9; public static final int TYPE_COLUMN = 9;
// 投影列中小部件ID列的索引
public static final int WIDGET_ID_COLUMN = 10; public static final int WIDGET_ID_COLUMN = 10;
// 投影列中小部件类型列的索引
public static final int WIDGET_TYPE_COLUMN = 11; public static final int WIDGET_TYPE_COLUMN = 11;
// 投影列中同步ID列的索引
public static final int SYNC_ID_COLUMN = 12; public static final int SYNC_ID_COLUMN = 12;
// 投影列中本地修改标志列的索引
public static final int LOCAL_MODIFIED_COLUMN = 13; public static final int LOCAL_MODIFIED_COLUMN = 13;
// 投影列中原始父级ID列的索引
public static final int ORIGIN_PARENT_ID_COLUMN = 14; public static final int ORIGIN_PARENT_ID_COLUMN = 14;
// 投影列中gtask ID列的索引
public static final int GTASK_ID_COLUMN = 15; public static final int GTASK_ID_COLUMN = 15;
// 投影列中版本号列的索引
public static final int VERSION_COLUMN = 16; public static final int VERSION_COLUMN = 16;
// 应用上下文
private Context mContext; private Context mContext;
// 内容解析器,用于与内容提供者进行交互
private ContentResolver mContentResolver; private ContentResolver mContentResolver;
// 标识该笔记是否为新创建的
private boolean mIsCreate; private boolean mIsCreate;
// 笔记的ID
private long mId; private long mId;
// 提醒日期
private long mAlertDate; private long mAlertDate;
// 背景颜色ID
private int mBgColorId; private int mBgColorId;
// 创建日期
private long mCreatedDate; private long mCreatedDate;
// 是否有附件的标志
private int mHasAttachment; private int mHasAttachment;
// 修改日期
private long mModifiedDate; private long mModifiedDate;
// 父级ID
private long mParentId; private long mParentId;
// 文本内容或文件夹名称
private String mSnippet; private String mSnippet;
// 类型(笔记、文件夹或系统类型)
private int mType; private int mType;
// 小部件ID
private int mWidgetId; private int mWidgetId;
// 小部件类型
private int mWidgetType; private int mWidgetType;
// 原始父级ID
private long mOriginParent; private long mOriginParent;
// 版本号
private long mVersion; private long mVersion;
// 用于存储笔记数据差异的ContentValues用于更新操作
private ContentValues mDiffNoteValues; private ContentValues mDiffNoteValues;
// 存储与该笔记相关的SqlData对象列表
private ArrayList<SqlData> mDataList; private ArrayList<SqlData> mDataList;
// 构造函数用于创建一个新的SqlNote对象通常用于新笔记的创建
public SqlNote(Context context) { public SqlNote(Context context) {
mContext = context; mContext = context;
mContentResolver = context.getContentResolver(); mContentResolver = context.getContentResolver();
@ -143,6 +172,7 @@ public class SqlNote {
mDataList = new ArrayList<SqlData>(); mDataList = new ArrayList<SqlData>();
} }
// 构造函数通过Cursor对象初始化SqlNote对象通常用于从数据库加载现有笔记
public SqlNote(Context context, Cursor c) { public SqlNote(Context context, Cursor c) {
mContext = context; mContext = context;
mContentResolver = context.getContentResolver(); mContentResolver = context.getContentResolver();
@ -154,6 +184,7 @@ public class SqlNote {
mDiffNoteValues = new ContentValues(); mDiffNoteValues = new ContentValues();
} }
// 构造函数通过笔记ID从数据库加载笔记并初始化SqlNote对象
public SqlNote(Context context, long id) { public SqlNote(Context context, long id) {
mContext = context; mContext = context;
mContentResolver = context.getContentResolver(); mContentResolver = context.getContentResolver();
@ -163,28 +194,31 @@ public class SqlNote {
if (mType == Notes.TYPE_NOTE) if (mType == Notes.TYPE_NOTE)
loadDataContent(); loadDataContent();
mDiffNoteValues = new ContentValues(); mDiffNoteValues = new ContentValues();
} }
// 根据给定的ID从数据库加载笔记数据
private void loadFromCursor(long id) { private void loadFromCursor(long id) {
Cursor c = null; Cursor c = null;
try { try {
// 使用内容解析器查询笔记数据
c = mContentResolver.query(Notes.CONTENT_NOTE_URI, PROJECTION_NOTE, "(_id=?)", c = mContentResolver.query(Notes.CONTENT_NOTE_URI, PROJECTION_NOTE, "(_id=?)",
new String[] { new String[] {
String.valueOf(id) String.valueOf(id)
}, null); }, null);
if (c != null) { if (c!= null) {
c.moveToNext(); c.moveToNext();
// 从Cursor中加载数据
loadFromCursor(c); loadFromCursor(c);
} else { } else {
Log.w(TAG, "loadFromCursor: cursor = null"); Log.w(TAG, "loadFromCursor: cursor = null");
} }
} finally { } finally {
if (c != null) if (c!= null)
c.close(); c.close();
} }
} }
// 从Cursor中加载笔记数据到当前对象的属性中
private void loadFromCursor(Cursor c) { private void loadFromCursor(Cursor c) {
mId = c.getLong(ID_COLUMN); mId = c.getLong(ID_COLUMN);
mAlertDate = c.getLong(ALERTED_DATE_COLUMN); mAlertDate = c.getLong(ALERTED_DATE_COLUMN);
@ -200,20 +234,23 @@ public class SqlNote {
mVersion = c.getLong(VERSION_COLUMN); mVersion = c.getLong(VERSION_COLUMN);
} }
// 加载与该笔记相关的数据内容(例如文本笔记的具体内容等)
private void loadDataContent() { private void loadDataContent() {
Cursor c = null; Cursor c = null;
mDataList.clear(); mDataList.clear();
try { try {
// 使用内容解析器查询与该笔记相关的数据
c = mContentResolver.query(Notes.CONTENT_DATA_URI, SqlData.PROJECTION_DATA, c = mContentResolver.query(Notes.CONTENT_DATA_URI, SqlData.PROJECTION_DATA,
"(note_id=?)", new String[] { "(note_id=?)", new String[] {
String.valueOf(mId) String.valueOf(mId)
}, null); }, null);
if (c != null) { if (c!= null) {
if (c.getCount() == 0) { if (c.getCount() == 0) {
Log.w(TAG, "it seems that the note has not data"); Log.w(TAG, "it seems that the note has not data");
return; return;
} }
while (c.moveToNext()) { while (c.moveToNext()) {
// 创建SqlData对象并添加到列表中
SqlData data = new SqlData(mContext, c); SqlData data = new SqlData(mContext, c);
mDataList.add(data); mDataList.add(data);
} }
@ -221,112 +258,113 @@ public class SqlNote {
Log.w(TAG, "loadDataContent: cursor = null"); Log.w(TAG, "loadDataContent: cursor = null");
} }
} finally { } finally {
if (c != null) if (c!= null)
c.close(); c.close();
} }
} }
// 根据JSONObject设置笔记的内容
public boolean setContent(JSONObject js) { public boolean setContent(JSONObject js) {
try { try {
JSONObject note = js.getJSONObject(GTaskStringUtils.META_HEAD_NOTE); JSONObject note = js.getJSONObject(GTaskStringUtils.META_HEAD_NOTE);
if (note.getInt(NoteColumns.TYPE) == Notes.TYPE_SYSTEM) { if (note.getInt(NoteColumns.TYPE) == Notes.TYPE_SYSTEM) {
Log.w(TAG, "cannot set system folder"); Log.w(TAG, "cannot set system folder");
} else if (note.getInt(NoteColumns.TYPE) == Notes.TYPE_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 String snippet = note.has(NoteColumns.SNIPPET)? note
.getString(NoteColumns.SNIPPET) : ""; .getString(NoteColumns.SNIPPET) : "";
if (mIsCreate || !mSnippet.equals(snippet)) { if (mIsCreate ||!mSnippet.equals(snippet)) {
mDiffNoteValues.put(NoteColumns.SNIPPET, snippet); mDiffNoteValues.put(NoteColumns.SNIPPET, snippet);
} }
mSnippet = snippet; mSnippet = snippet;
int type = note.has(NoteColumns.TYPE) ? note.getInt(NoteColumns.TYPE) int type = note.has(NoteColumns.TYPE)? note.getInt(NoteColumns.TYPE)
: Notes.TYPE_NOTE; : Notes.TYPE_NOTE;
if (mIsCreate || mType != type) { if (mIsCreate || mType!= type) {
mDiffNoteValues.put(NoteColumns.TYPE, type); mDiffNoteValues.put(NoteColumns.TYPE, type);
} }
mType = type; mType = type;
} else if (note.getInt(NoteColumns.TYPE) == Notes.TYPE_NOTE) { } else if (note.getInt(NoteColumns.TYPE) == Notes.TYPE_NOTE) {
JSONArray dataArray = js.getJSONArray(GTaskStringUtils.META_HEAD_DATA); JSONArray dataArray = js.getJSONArray(GTaskStringUtils.META_HEAD_DATA);
long id = note.has(NoteColumns.ID) ? note.getLong(NoteColumns.ID) : INVALID_ID; long id = note.has(NoteColumns.ID)? note.getLong(NoteColumns.ID) : INVALID_ID;
if (mIsCreate || mId != id) { if (mIsCreate || mId!= id) {
mDiffNoteValues.put(NoteColumns.ID, id); mDiffNoteValues.put(NoteColumns.ID, id);
} }
mId = id; mId = id;
long alertDate = note.has(NoteColumns.ALERTED_DATE) ? note long alertDate = note.has(NoteColumns.ALERTED_DATE)? note
.getLong(NoteColumns.ALERTED_DATE) : 0; .getLong(NoteColumns.ALERTED_DATE) : 0;
if (mIsCreate || mAlertDate != alertDate) { if (mIsCreate || mAlertDate!= alertDate) {
mDiffNoteValues.put(NoteColumns.ALERTED_DATE, alertDate); mDiffNoteValues.put(NoteColumns.ALERTED_DATE, alertDate);
} }
mAlertDate = alertDate; mAlertDate = alertDate;
int bgColorId = note.has(NoteColumns.BG_COLOR_ID) ? note int bgColorId = note.has(NoteColumns.BG_COLOR_ID)? note
.getInt(NoteColumns.BG_COLOR_ID) : ResourceParser.getDefaultBgId(mContext); .getInt(NoteColumns.BG_COLOR_ID) : ResourceParser.getDefaultBgId(mContext);
if (mIsCreate || mBgColorId != bgColorId) { if (mIsCreate || mBgColorId!= bgColorId) {
mDiffNoteValues.put(NoteColumns.BG_COLOR_ID, bgColorId); mDiffNoteValues.put(NoteColumns.BG_COLOR_ID, bgColorId);
} }
mBgColorId = bgColorId; mBgColorId = bgColorId;
long createDate = note.has(NoteColumns.CREATED_DATE) ? note long createDate = note.has(NoteColumns.CREATED_DATE)? note
.getLong(NoteColumns.CREATED_DATE) : System.currentTimeMillis(); .getLong(NoteColumns.CREATED_DATE) : System.currentTimeMillis();
if (mIsCreate || mCreatedDate != createDate) { if (mIsCreate || mCreatedDate!= createDate) {
mDiffNoteValues.put(NoteColumns.CREATED_DATE, createDate); mDiffNoteValues.put(NoteColumns.CREATED_DATE, createDate);
} }
mCreatedDate = createDate; mCreatedDate = createDate;
int hasAttachment = note.has(NoteColumns.HAS_ATTACHMENT) ? note int hasAttachment = note.has(NoteColumns.HAS_ATTACHMENT)? note
.getInt(NoteColumns.HAS_ATTACHMENT) : 0; .getInt(NoteColumns.HAS_ATTACHMENT) : 0;
if (mIsCreate || mHasAttachment != hasAttachment) { if (mIsCreate || mHasAttachment!= hasAttachment) {
mDiffNoteValues.put(NoteColumns.HAS_ATTACHMENT, hasAttachment); mDiffNoteValues.put(NoteColumns.HAS_ATTACHMENT, hasAttachment);
} }
mHasAttachment = hasAttachment; mHasAttachment = hasAttachment;
long modifiedDate = note.has(NoteColumns.MODIFIED_DATE) ? note long modifiedDate = note.has(NoteColumns.MODIFIED_DATE)? note
.getLong(NoteColumns.MODIFIED_DATE) : System.currentTimeMillis(); .getLong(NoteColumns.MODIFIED_DATE) : System.currentTimeMillis();
if (mIsCreate || mModifiedDate != modifiedDate) { if (mIsCreate || mModifiedDate!= modifiedDate) {
mDiffNoteValues.put(NoteColumns.MODIFIED_DATE, modifiedDate); mDiffNoteValues.put(NoteColumns.MODIFIED_DATE, modifiedDate);
} }
mModifiedDate = modifiedDate; mModifiedDate = modifiedDate;
long parentId = note.has(NoteColumns.PARENT_ID) ? note long parentId = note.has(NoteColumns.PARENT_ID)? note
.getLong(NoteColumns.PARENT_ID) : 0; .getLong(NoteColumns.PARENT_ID) : 0;
if (mIsCreate || mParentId != parentId) { if (mIsCreate || mParentId!= parentId) {
mDiffNoteValues.put(NoteColumns.PARENT_ID, parentId); mDiffNoteValues.put(NoteColumns.PARENT_ID, parentId);
} }
mParentId = parentId; mParentId = parentId;
String snippet = note.has(NoteColumns.SNIPPET) ? note String snippet = note.has(NoteColumns.SNIPPET)? note
.getString(NoteColumns.SNIPPET) : ""; .getString(NoteColumns.SNIPPET) : "";
if (mIsCreate || !mSnippet.equals(snippet)) { if (mIsCreate ||!mSnippet.equals(snippet)) {
mDiffNoteValues.put(NoteColumns.SNIPPET, snippet); mDiffNoteValues.put(NoteColumns.SNIPPET, snippet);
} }
mSnippet = snippet; mSnippet = snippet;
int type = note.has(NoteColumns.TYPE) ? note.getInt(NoteColumns.TYPE) int type = note.has(NoteColumns.TYPE)? note.getInt(NoteColumns.TYPE)
: Notes.TYPE_NOTE; : Notes.TYPE_NOTE;
if (mIsCreate || mType != type) { if (mIsCreate || mType!= type) {
mDiffNoteValues.put(NoteColumns.TYPE, type); mDiffNoteValues.put(NoteColumns.TYPE, type);
} }
mType = type; mType = type;
int widgetId = note.has(NoteColumns.WIDGET_ID) ? note.getInt(NoteColumns.WIDGET_ID) int widgetId = note.has(NoteColumns.WIDGET_ID)? note.getInt(NoteColumns.WIDGET_ID)
: AppWidgetManager.INVALID_APPWIDGET_ID; : AppWidgetManager.INVALID_APPWIDGET_ID;
if (mIsCreate || mWidgetId != widgetId) { if (mIsCreate || mWidgetId!= widgetId) {
mDiffNoteValues.put(NoteColumns.WIDGET_ID, widgetId); mDiffNoteValues.put(NoteColumns.WIDGET_ID, widgetId);
} }
mWidgetId = widgetId; mWidgetId = widgetId;
int widgetType = note.has(NoteColumns.WIDGET_TYPE) ? note int widgetType = note.has(NoteColumns.WIDGET_TYPE)? note
.getInt(NoteColumns.WIDGET_TYPE) : Notes.TYPE_WIDGET_INVALIDE; .getInt(NoteColumns.WIDGET_TYPE) : Notes.TYPE_WIDGET_INVALIDE;
if (mIsCreate || mWidgetType != widgetType) { if (mIsCreate || mWidgetType!= widgetType) {
mDiffNoteValues.put(NoteColumns.WIDGET_TYPE, widgetType); mDiffNoteValues.put(NoteColumns.WIDGET_TYPE, widgetType);
} }
mWidgetType = widgetType; mWidgetType = widgetType;
long originParent = note.has(NoteColumns.ORIGIN_PARENT_ID) ? note long originParent = note.has(NoteColumns.ORIGIN_PARENT_ID)? note
.getLong(NoteColumns.ORIGIN_PARENT_ID) : 0; .getLong(NoteColumns.ORIGIN_PARENT_ID) : 0;
if (mIsCreate || mOriginParent != originParent) { if (mIsCreate || mOriginParent!= originParent) {
mDiffNoteValues.put(NoteColumns.ORIGIN_PARENT_ID, originParent); mDiffNoteValues.put(NoteColumns.ORIGIN_PARENT_ID, originParent);
} }
mOriginParent = originParent; mOriginParent = originParent;
@ -359,17 +397,25 @@ public class SqlNote {
return true; return true;
} }
// 获取内容的方法返回一个表示当前对象内容的JSONObject
public JSONObject getContent() { public JSONObject getContent() {
try { try {
// 创建一个空的JSONObject
JSONObject js = new JSONObject(); JSONObject js = new JSONObject();
// 如果该对象尚未在数据库中创建
if (mIsCreate) { if (mIsCreate) {
// 记录错误日志
Log.e(TAG, "it seems that we haven't created this in database yet"); Log.e(TAG, "it seems that we haven't created this in database yet");
// 返回null
return null; return null;
} }
// 创建一个表示笔记的JSONObject
JSONObject note = new JSONObject(); JSONObject note = new JSONObject();
// 如果类型是笔记类型
if (mType == Notes.TYPE_NOTE) { if (mType == Notes.TYPE_NOTE) {
// 将笔记的各个属性添加到note JSONObject中
note.put(NoteColumns.ID, mId); note.put(NoteColumns.ID, mId);
note.put(NoteColumns.ALERTED_DATE, mAlertDate); note.put(NoteColumns.ALERTED_DATE, mAlertDate);
note.put(NoteColumns.BG_COLOR_ID, mBgColorId); note.put(NoteColumns.BG_COLOR_ID, mBgColorId);
@ -382,124 +428,179 @@ public class SqlNote {
note.put(NoteColumns.WIDGET_ID, mWidgetId); note.put(NoteColumns.WIDGET_ID, mWidgetId);
note.put(NoteColumns.WIDGET_TYPE, mWidgetType); note.put(NoteColumns.WIDGET_TYPE, mWidgetType);
note.put(NoteColumns.ORIGIN_PARENT_ID, mOriginParent); note.put(NoteColumns.ORIGIN_PARENT_ID, mOriginParent);
// 将表示笔记的note JSONObject添加到主JSONObject中使用GTaskStringUtils.META_HEAD_NOTE作为键
js.put(GTaskStringUtils.META_HEAD_NOTE, note); js.put(GTaskStringUtils.META_HEAD_NOTE, note);
// 创建一个JSONArray用于存储数据
JSONArray dataArray = new JSONArray(); JSONArray dataArray = new JSONArray();
// 遍历数据列表
for (SqlData sqlData : mDataList) { for (SqlData sqlData : mDataList) {
// 获取每个数据项的内容JSONObject
JSONObject data = sqlData.getContent(); JSONObject data = sqlData.getContent();
if (data != null) { // 如果数据项的内容JSONObject不为空
if (data!= null) {
// 将其添加到JSONArray中
dataArray.put(data); dataArray.put(data);
} }
} }
// 将存储数据的JSONArray添加到主JSONObject中使用GTaskStringUtils.META_HEAD_DATA作为键
js.put(GTaskStringUtils.META_HEAD_DATA, dataArray); js.put(GTaskStringUtils.META_HEAD_DATA, dataArray);
// 如果类型是文件夹或系统类型
} else if (mType == Notes.TYPE_FOLDER || mType == Notes.TYPE_SYSTEM) { } else if (mType == Notes.TYPE_FOLDER || mType == Notes.TYPE_SYSTEM) {
// 将文件夹或系统类型的相关属性添加到note JSONObject中
note.put(NoteColumns.ID, mId); note.put(NoteColumns.ID, mId);
note.put(NoteColumns.TYPE, mType); note.put(NoteColumns.TYPE, mType);
note.put(NoteColumns.SNIPPET, mSnippet); note.put(NoteColumns.SNIPPET, mSnippet);
// 将表示文件夹或系统类型的note JSONObject添加到主JSONObject中使用GTaskStringUtils.META_HEAD_NOTE作为键
js.put(GTaskStringUtils.META_HEAD_NOTE, note); js.put(GTaskStringUtils.META_HEAD_NOTE, note);
} }
// 返回构建好的主JSONObject
return js; return js;
} catch (JSONException e) { } catch (JSONException e) {
// 记录异常日志
Log.e(TAG, e.toString()); Log.e(TAG, e.toString());
// 打印异常堆栈信息
e.printStackTrace(); e.printStackTrace();
} }
// 如果发生异常返回null
return null; return null;
} }
// 设置父ID的方法
public void setParentId(long id) { public void setParentId(long id) {
// 设置对象的父ID
mParentId = id; mParentId = id;
// 将父ID的变化记录到mDiffNoteValues中用于后续的更新操作
mDiffNoteValues.put(NoteColumns.PARENT_ID, id); mDiffNoteValues.put(NoteColumns.PARENT_ID, id);
} }
// 设置GTask ID的方法
public void setGtaskId(String gid) { public void setGtaskId(String gid) {
// 将GTask ID的变化记录到mDiffNoteValues中用于后续的更新操作
mDiffNoteValues.put(NoteColumns.GTASK_ID, gid); mDiffNoteValues.put(NoteColumns.GTASK_ID, gid);
} }
// 设置同步ID的方法
public void setSyncId(long syncId) { public void setSyncId(long syncId) {
// 将同步ID的变化记录到mDiffNoteValues中用于后续的更新操作
mDiffNoteValues.put(NoteColumns.SYNC_ID, syncId); mDiffNoteValues.put(NoteColumns.SYNC_ID, syncId);
} }
// 重置本地修改标志的方法
public void resetLocalModified() { public void resetLocalModified() {
// 将本地修改标志设为0并记录到mDiffNoteValues中用于后续的更新操作
mDiffNoteValues.put(NoteColumns.LOCAL_MODIFIED, 0); mDiffNoteValues.put(NoteColumns.LOCAL_MODIFIED, 0);
} }
// 获取ID的方法
public long getId() { public long getId() {
// 返回对象的ID
return mId; return mId;
} }
// 获取父ID的方法
public long getParentId() { public long getParentId() {
// 返回对象的父ID
return mParentId; return mParentId;
} }
// 获取片段内容的方法
public String getSnippet() { public String getSnippet() {
// 返回对象的片段内容
return mSnippet; return mSnippet;
} }
// 判断是否为笔记类型的方法
public boolean isNoteType() { public boolean isNoteType() {
// 如果类型是笔记类型返回true否则返回false
return mType == Notes.TYPE_NOTE; return mType == Notes.TYPE_NOTE;
} }
// 提交更改的方法validateVersion用于指定是否验证版本
public void commit(boolean validateVersion) { public void commit(boolean validateVersion) {
// 如果对象是新创建的
if (mIsCreate) { if (mIsCreate) {
// 如果ID无效且mDiffNoteValues中包含ID移除ID
if (mId == INVALID_ID && mDiffNoteValues.containsKey(NoteColumns.ID)) { if (mId == INVALID_ID && mDiffNoteValues.containsKey(NoteColumns.ID)) {
mDiffNoteValues.remove(NoteColumns.ID); mDiffNoteValues.remove(NoteColumns.ID);
} }
// 向笔记内容Uri插入数据返回插入后的Uri
Uri uri = mContentResolver.insert(Notes.CONTENT_NOTE_URI, mDiffNoteValues); Uri uri = mContentResolver.insert(Notes.CONTENT_NOTE_URI, mDiffNoteValues);
try { try {
// 从返回的Uri中获取插入的笔记ID
mId = Long.valueOf(uri.getPathSegments().get(1)); mId = Long.valueOf(uri.getPathSegments().get(1));
} catch (NumberFormatException e) { } catch (NumberFormatException e) {
// 记录获取ID错误的日志
Log.e(TAG, "Get note id error :" + e.toString()); Log.e(TAG, "Get note id error :" + e.toString());
// 抛出操作失败异常
throw new ActionFailureException("create note failed"); throw new ActionFailureException("create note failed");
} }
// 如果获取的ID为0抛出异常
if (mId == 0) { if (mId == 0) {
throw new IllegalStateException("Create thread id failed"); throw new IllegalStateException("Create thread id failed");
} }
// 如果类型是笔记类型
if (mType == Notes.TYPE_NOTE) { if (mType == Notes.TYPE_NOTE) {
// 遍历数据列表,提交每个数据项
for (SqlData sqlData : mDataList) { for (SqlData sqlData : mDataList) {
sqlData.commit(mId, false, -1); sqlData.commit(mId, false, -1);
} }
} }
} else { } else {
if (mId <= 0 && mId != Notes.ID_ROOT_FOLDER && mId != Notes.ID_CALL_RECORD_FOLDER) { // 如果ID无效且不是根文件夹或通话记录文件夹的ID
if (mId <= 0 && mId!= Notes.ID_ROOT_FOLDER && mId!= Notes.ID_CALL_RECORD_FOLDER) {
// 记录错误日志
Log.e(TAG, "No such note"); Log.e(TAG, "No such note");
// 抛出异常
throw new IllegalStateException("Try to update note with invalid id"); throw new IllegalStateException("Try to update note with invalid id");
} }
// 如果有需要更新的变化
if (mDiffNoteValues.size() > 0) { if (mDiffNoteValues.size() > 0) {
mVersion ++; // 版本号加1
mVersion++;
int result = 0; int result = 0;
// 如果不需要验证版本
if (!validateVersion) { if (!validateVersion) {
// 根据ID更新笔记数据
result = mContentResolver.update(Notes.CONTENT_NOTE_URI, mDiffNoteValues, "(" result = mContentResolver.update(Notes.CONTENT_NOTE_URI, mDiffNoteValues, "("
+ NoteColumns.ID + "=?)", new String[] { + NoteColumns.ID + "=?)", new String[] {
String.valueOf(mId) String.valueOf(mId)
}); });
} else { } else {
// 根据ID和版本号更新笔记数据
result = mContentResolver.update(Notes.CONTENT_NOTE_URI, mDiffNoteValues, "(" result = mContentResolver.update(Notes.CONTENT_NOTE_URI, mDiffNoteValues, "("
+ NoteColumns.ID + "=?) AND (" + NoteColumns.VERSION + "<=?)", + NoteColumns.ID + "=?) AND (" + NoteColumns.VERSION + "<=?)",
new String[] { new String[] {
String.valueOf(mId), String.valueOf(mVersion) String.valueOf(mId), String.valueOf(mVersion)
}); });
} }
// 如果更新结果为0记录警告日志
if (result == 0) { if (result == 0) {
Log.w(TAG, "there is no update. maybe user updates note when syncing"); Log.w(TAG, "there is no update. maybe user updates note when syncing");
} }
} }
// 如果类型是笔记类型
if (mType == Notes.TYPE_NOTE) { if (mType == Notes.TYPE_NOTE) {
// 遍历数据列表,提交每个数据项
for (SqlData sqlData : mDataList) { for (SqlData sqlData : mDataList) {
sqlData.commit(mId, validateVersion, mVersion); sqlData.commit(mId, validateVersion, mVersion);
} }
} }
} }
// refresh local info // 从数据库中重新加载本地信息
loadFromCursor(mId); loadFromCursor(mId);
// 如果类型是笔记类型,加载数据内容
if (mType == Notes.TYPE_NOTE) if (mType == Notes.TYPE_NOTE)
loadDataContent(); loadDataContent();
// 清空记录变化的mDiffNoteValues
mDiffNoteValues.clear(); mDiffNoteValues.clear();
// 设置对象不再是新创建的状态
mIsCreate = false; mIsCreate = false;
} }
} }

@ -31,20 +31,23 @@ import org.json.JSONArray;
import org.json.JSONException; import org.json.JSONException;
import org.json.JSONObject; import org.json.JSONObject;
// Task类继承自Node类用于表示任务包含任务的各种属性和操作方法
public class Task extends Node { public class Task extends Node {
// 日志标签,用于标识该类的日志输出
private static final String TAG = Task.class.getSimpleName(); private static final String TAG = Task.class.getSimpleName();
// 表示任务是否已完成
private boolean mCompleted; private boolean mCompleted;
// 任务的备注信息
private String mNotes; private String mNotes;
// 任务的元信息以JSONObject形式存储
private JSONObject mMetaInfo; private JSONObject mMetaInfo;
// 任务的前一个兄弟任务
private Task mPriorSibling; private Task mPriorSibling;
// 任务所属的任务列表
private TaskList mParent; private TaskList mParent;
// 构造函数,初始化任务的属性
public Task() { public Task() {
super(); super();
mCompleted = false; mCompleted = false;
@ -54,43 +57,44 @@ public class Task extends Node {
mMetaInfo = null; mMetaInfo = null;
} }
// 获取创建任务的操作JSON对象
public JSONObject getCreateAction(int actionId) { public JSONObject getCreateAction(int actionId) {
JSONObject js = new JSONObject(); JSONObject js = new JSONObject();
try { try {
// action_type // 设置操作类型为创建
js.put(GTaskStringUtils.GTASK_JSON_ACTION_TYPE, js.put(GTaskStringUtils.GTASK_JSON_ACTION_TYPE,
GTaskStringUtils.GTASK_JSON_ACTION_TYPE_CREATE); GTaskStringUtils.GTASK_JSON_ACTION_TYPE_CREATE);
// action_id // 设置操作ID
js.put(GTaskStringUtils.GTASK_JSON_ACTION_ID, actionId); js.put(GTaskStringUtils.GTASK_JSON_ACTION_ID, actionId);
// index // 设置任务在父任务列表中的索引
js.put(GTaskStringUtils.GTASK_JSON_INDEX, mParent.getChildTaskIndex(this)); js.put(GTaskStringUtils.GTASK_JSON_INDEX, mParent.getChildTaskIndex(this));
// entity_delta // 设置任务实体的变化
JSONObject entity = new JSONObject(); JSONObject entity = new JSONObject();
entity.put(GTaskStringUtils.GTASK_JSON_NAME, getName()); entity.put(GTaskStringUtils.GTASK_JSON_NAME, getName());
entity.put(GTaskStringUtils.GTASK_JSON_CREATOR_ID, "null"); entity.put(GTaskStringUtils.GTASK_JSON_CREATOR_ID, "null");
entity.put(GTaskStringUtils.GTASK_JSON_ENTITY_TYPE, entity.put(GTaskStringUtils.GTASK_JSON_ENTITY_TYPE,
GTaskStringUtils.GTASK_JSON_TYPE_TASK); GTaskStringUtils.GTASK_JSON_TYPE_TASK);
if (getNotes() != null) { if (getNotes()!= null) {
entity.put(GTaskStringUtils.GTASK_JSON_NOTES, getNotes()); entity.put(GTaskStringUtils.GTASK_JSON_NOTES, getNotes());
} }
js.put(GTaskStringUtils.GTASK_JSON_ENTITY_DELTA, entity); js.put(GTaskStringUtils.GTASK_JSON_ENTITY_DELTA, entity);
// parent_id // 设置父任务列表的ID
js.put(GTaskStringUtils.GTASK_JSON_PARENT_ID, mParent.getGid()); js.put(GTaskStringUtils.GTASK_JSON_PARENT_ID, mParent.getGid());
// dest_parent_type // 设置目标父类型为任务组
js.put(GTaskStringUtils.GTASK_JSON_DEST_PARENT_TYPE, js.put(GTaskStringUtils.GTASK_JSON_DEST_PARENT_TYPE,
GTaskStringUtils.GTASK_JSON_TYPE_GROUP); GTaskStringUtils.GTASK_JSON_TYPE_GROUP);
// list_id // 设置任务列表的ID
js.put(GTaskStringUtils.GTASK_JSON_LIST_ID, mParent.getGid()); js.put(GTaskStringUtils.GTASK_JSON_LIST_ID, mParent.getGid());
// prior_sibling_id // 如果存在前一个兄弟任务设置其ID
if (mPriorSibling != null) { if (mPriorSibling!= null) {
js.put(GTaskStringUtils.GTASK_JSON_PRIOR_SIBLING_ID, mPriorSibling.getGid()); js.put(GTaskStringUtils.GTASK_JSON_PRIOR_SIBLING_ID, mPriorSibling.getGid());
} }
@ -103,24 +107,25 @@ public class Task extends Node {
return js; return js;
} }
// 获取更新任务的操作JSON对象
public JSONObject getUpdateAction(int actionId) { public JSONObject getUpdateAction(int actionId) {
JSONObject js = new JSONObject(); JSONObject js = new JSONObject();
try { try {
// action_type // 设置操作类型为更新
js.put(GTaskStringUtils.GTASK_JSON_ACTION_TYPE, js.put(GTaskStringUtils.GTASK_JSON_ACTION_TYPE,
GTaskStringUtils.GTASK_JSON_ACTION_TYPE_UPDATE); GTaskStringUtils.GTASK_JSON_ACTION_TYPE_UPDATE);
// action_id // 设置操作ID
js.put(GTaskStringUtils.GTASK_JSON_ACTION_ID, actionId); js.put(GTaskStringUtils.GTASK_JSON_ACTION_ID, actionId);
// id // 设置任务的ID
js.put(GTaskStringUtils.GTASK_JSON_ID, getGid()); js.put(GTaskStringUtils.GTASK_JSON_ID, getGid());
// entity_delta // 设置任务实体的变化
JSONObject entity = new JSONObject(); JSONObject entity = new JSONObject();
entity.put(GTaskStringUtils.GTASK_JSON_NAME, getName()); entity.put(GTaskStringUtils.GTASK_JSON_NAME, getName());
if (getNotes() != null) { if (getNotes()!= null) {
entity.put(GTaskStringUtils.GTASK_JSON_NOTES, getNotes()); entity.put(GTaskStringUtils.GTASK_JSON_NOTES, getNotes());
} }
entity.put(GTaskStringUtils.GTASK_JSON_DELETED, getDeleted()); entity.put(GTaskStringUtils.GTASK_JSON_DELETED, getDeleted());
@ -135,35 +140,36 @@ public class Task extends Node {
return js; return js;
} }
// 根据从远程获取的JSON数据设置任务内容
public void setContentByRemoteJSON(JSONObject js) { public void setContentByRemoteJSON(JSONObject js) {
if (js != null) { if (js!= null) {
try { try {
// id // 设置任务的ID
if (js.has(GTaskStringUtils.GTASK_JSON_ID)) { if (js.has(GTaskStringUtils.GTASK_JSON_ID)) {
setGid(js.getString(GTaskStringUtils.GTASK_JSON_ID)); setGid(js.getString(GTaskStringUtils.GTASK_JSON_ID));
} }
// last_modified // 设置任务的最后修改时间
if (js.has(GTaskStringUtils.GTASK_JSON_LAST_MODIFIED)) { if (js.has(GTaskStringUtils.GTASK_JSON_LAST_MODIFIED)) {
setLastModified(js.getLong(GTaskStringUtils.GTASK_JSON_LAST_MODIFIED)); setLastModified(js.getLong(GTaskStringUtils.GTASK_JSON_LAST_MODIFIED));
} }
// name // 设置任务的名称
if (js.has(GTaskStringUtils.GTASK_JSON_NAME)) { if (js.has(GTaskStringUtils.GTASK_JSON_NAME)) {
setName(js.getString(GTaskStringUtils.GTASK_JSON_NAME)); setName(js.getString(GTaskStringUtils.GTASK_JSON_NAME));
} }
// notes // 设置任务的备注信息
if (js.has(GTaskStringUtils.GTASK_JSON_NOTES)) { if (js.has(GTaskStringUtils.GTASK_JSON_NOTES)) {
setNotes(js.getString(GTaskStringUtils.GTASK_JSON_NOTES)); setNotes(js.getString(GTaskStringUtils.GTASK_JSON_NOTES));
} }
// deleted // 设置任务是否已删除
if (js.has(GTaskStringUtils.GTASK_JSON_DELETED)) { if (js.has(GTaskStringUtils.GTASK_JSON_DELETED)) {
setDeleted(js.getBoolean(GTaskStringUtils.GTASK_JSON_DELETED)); setDeleted(js.getBoolean(GTaskStringUtils.GTASK_JSON_DELETED));
} }
// completed // 设置任务是否已完成
if (js.has(GTaskStringUtils.GTASK_JSON_COMPLETED)) { if (js.has(GTaskStringUtils.GTASK_JSON_COMPLETED)) {
setCompleted(js.getBoolean(GTaskStringUtils.GTASK_JSON_COMPLETED)); setCompleted(js.getBoolean(GTaskStringUtils.GTASK_JSON_COMPLETED));
} }
@ -175,9 +181,10 @@ public class Task extends Node {
} }
} }
// 根据本地的JSON数据设置任务内容
public void setContentByLocalJSON(JSONObject js) { public void setContentByLocalJSON(JSONObject js) {
if (js == null || !js.has(GTaskStringUtils.META_HEAD_NOTE) if (js == null ||!js.has(GTaskStringUtils.META_HEAD_NOTE)
|| !js.has(GTaskStringUtils.META_HEAD_DATA)) { ||!js.has(GTaskStringUtils.META_HEAD_DATA)) {
Log.w(TAG, "setContentByLocalJSON: nothing is avaiable"); Log.w(TAG, "setContentByLocalJSON: nothing is avaiable");
} }
@ -185,7 +192,7 @@ public class Task extends Node {
JSONObject note = js.getJSONObject(GTaskStringUtils.META_HEAD_NOTE); JSONObject note = js.getJSONObject(GTaskStringUtils.META_HEAD_NOTE);
JSONArray dataArray = js.getJSONArray(GTaskStringUtils.META_HEAD_DATA); JSONArray dataArray = js.getJSONArray(GTaskStringUtils.META_HEAD_DATA);
if (note.getInt(NoteColumns.TYPE) != Notes.TYPE_NOTE) { if (note.getInt(NoteColumns.TYPE)!= Notes.TYPE_NOTE) {
Log.e(TAG, "invalid type"); Log.e(TAG, "invalid type");
return; return;
} }
@ -204,11 +211,12 @@ public class Task extends Node {
} }
} }
// 从任务内容生成本地JSON对象
public JSONObject getLocalJSONFromContent() { public JSONObject getLocalJSONFromContent() {
String name = getName(); String name = getName();
try { try {
if (mMetaInfo == null) { if (mMetaInfo == null) {
// new task created from web // 新创建的任务(从网页创建)
if (name == null) { if (name == null) {
Log.w(TAG, "the note seems to be an empty one"); Log.w(TAG, "the note seems to be an empty one");
return null; return null;
@ -225,7 +233,7 @@ public class Task extends Node {
js.put(GTaskStringUtils.META_HEAD_NOTE, note); js.put(GTaskStringUtils.META_HEAD_NOTE, note);
return js; return js;
} else { } else {
// synced task // 已同步的任务
JSONObject note = mMetaInfo.getJSONObject(GTaskStringUtils.META_HEAD_NOTE); JSONObject note = mMetaInfo.getJSONObject(GTaskStringUtils.META_HEAD_NOTE);
JSONArray dataArray = mMetaInfo.getJSONArray(GTaskStringUtils.META_HEAD_DATA); JSONArray dataArray = mMetaInfo.getJSONArray(GTaskStringUtils.META_HEAD_DATA);
@ -247,8 +255,9 @@ public class Task extends Node {
} }
} }
// 设置任务的元信息
public void setMetaInfo(MetaData metaData) { public void setMetaInfo(MetaData metaData) {
if (metaData != null && metaData.getNotes() != null) { if (metaData!= null && metaData.getNotes()!= null) {
try { try {
mMetaInfo = new JSONObject(metaData.getNotes()); mMetaInfo = new JSONObject(metaData.getNotes());
} catch (JSONException e) { } catch (JSONException e) {
@ -258,10 +267,11 @@ public class Task extends Node {
} }
} }
// 根据数据库游标获取任务的同步操作类型
public int getSyncAction(Cursor c) { public int getSyncAction(Cursor c) {
try { try {
JSONObject noteInfo = null; JSONObject noteInfo = null;
if (mMetaInfo != null && mMetaInfo.has(GTaskStringUtils.META_HEAD_NOTE)) { if (mMetaInfo!= null && mMetaInfo.has(GTaskStringUtils.META_HEAD_NOTE)) {
noteInfo = mMetaInfo.getJSONObject(GTaskStringUtils.META_HEAD_NOTE); noteInfo = mMetaInfo.getJSONObject(GTaskStringUtils.META_HEAD_NOTE);
} }
@ -275,29 +285,29 @@ public class Task extends Node {
return SYNC_ACTION_UPDATE_LOCAL; return SYNC_ACTION_UPDATE_LOCAL;
} }
// validate the note id now // 验证笔记ID
if (c.getLong(SqlNote.ID_COLUMN) != noteInfo.getLong(NoteColumns.ID)) { if (c.getLong(SqlNote.ID_COLUMN)!= noteInfo.getLong(NoteColumns.ID)) {
Log.w(TAG, "note id doesn't match"); Log.w(TAG, "note id doesn't match");
return SYNC_ACTION_UPDATE_LOCAL; return SYNC_ACTION_UPDATE_LOCAL;
} }
if (c.getInt(SqlNote.LOCAL_MODIFIED_COLUMN) == 0) { if (c.getInt(SqlNote.LOCAL_MODIFIED_COLUMN) == 0) {
// there is no local update // 没有本地更新
if (c.getLong(SqlNote.SYNC_ID_COLUMN) == getLastModified()) { if (c.getLong(SqlNote.SYNC_ID_COLUMN) == getLastModified()) {
// no update both side // 两边都没有更新
return SYNC_ACTION_NONE; return SYNC_ACTION_NONE;
} else { } else {
// apply remote to local // 将远程更新应用到本地
return SYNC_ACTION_UPDATE_LOCAL; return SYNC_ACTION_UPDATE_LOCAL;
} }
} else { } else {
// validate gtask id // 验证gtask ID
if (!c.getString(SqlNote.GTASK_ID_COLUMN).equals(getGid())) { if (!c.getString(SqlNote.GTASK_ID_COLUMN).equals(getGid())) {
Log.e(TAG, "gtask id doesn't match"); Log.e(TAG, "gtask id doesn't match");
return SYNC_ACTION_ERROR; return SYNC_ACTION_ERROR;
} }
if (c.getLong(SqlNote.SYNC_ID_COLUMN) == getLastModified()) { if (c.getLong(SqlNote.SYNC_ID_COLUMN) == getLastModified()) {
// local modification only // 仅本地修改
return SYNC_ACTION_UPDATE_REMOTE; return SYNC_ACTION_UPDATE_REMOTE;
} else { } else {
return SYNC_ACTION_UPDATE_CONFLICT; return SYNC_ACTION_UPDATE_CONFLICT;
@ -311,41 +321,49 @@ public class Task extends Node {
return SYNC_ACTION_ERROR; return SYNC_ACTION_ERROR;
} }
// 判断任务是否值得保存
public boolean isWorthSaving() { public boolean isWorthSaving() {
return mMetaInfo != null || (getName() != null && getName().trim().length() > 0) return mMetaInfo!= null || (getName()!= null && getName().trim().length() > 0)
|| (getNotes() != null && getNotes().trim().length() > 0); || (getNotes()!= null && getNotes().trim().length() > 0);
} }
// 设置任务是否已完成
public void setCompleted(boolean completed) { public void setCompleted(boolean completed) {
this.mCompleted = completed; this.mCompleted = completed;
} }
// 设置任务的备注信息
public void setNotes(String notes) { public void setNotes(String notes) {
this.mNotes = notes; this.mNotes = notes;
} }
// 设置任务的前一个兄弟任务
public void setPriorSibling(Task priorSibling) { public void setPriorSibling(Task priorSibling) {
this.mPriorSibling = priorSibling; this.mPriorSibling = priorSibling;
} }
// 设置任务所属的任务列表
public void setParent(TaskList parent) { public void setParent(TaskList parent) {
this.mParent = parent; this.mParent = parent;
} }
// 获取任务是否已完成
public boolean getCompleted() { public boolean getCompleted() {
return this.mCompleted; return this.mCompleted;
} }
// 获取任务的备注信息
public String getNotes() { public String getNotes() {
return this.mNotes; return this.mNotes;
} }
// 获取任务的前一个兄弟任务
public Task getPriorSibling() { public Task getPriorSibling() {
return this.mPriorSibling; return this.mPriorSibling;
} }
// 获取任务所属的任务列表
public TaskList getParent() { public TaskList getParent() {
return this.mParent; return this.mParent;
} }
}
}

@ -1,19 +1,3 @@
/*
* 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; package net.micode.notes.gtask.data;
import android.database.Cursor; import android.database.Cursor;
@ -29,98 +13,93 @@ import org.json.JSONObject;
import java.util.ArrayList; import java.util.ArrayList;
// TaskList类继承自Node类用于表示任务列表包含任务列表的相关属性和操作方法
public class TaskList extends Node { public class TaskList extends Node {
// 日志标签,用于标识该类的日志输出
private static final String TAG = TaskList.class.getSimpleName(); private static final String TAG = TaskList.class.getSimpleName();
// 任务列表的索引
private int mIndex; private int mIndex;
// 存储任务列表中的子任务
private ArrayList<Task> mChildren; private ArrayList<Task> mChildren;
// 构造函数,初始化任务列表的属性
public TaskList() { public TaskList() {
super(); super();
mChildren = new ArrayList<Task>(); mChildren = new ArrayList<>();
mIndex = 1; mIndex = 1;
} }
// 获取创建任务列表的操作JSON对象
public JSONObject getCreateAction(int actionId) { public JSONObject getCreateAction(int actionId) {
JSONObject js = new JSONObject(); JSONObject js = new JSONObject();
try { try {
// action_type // 设置操作类型为创建
js.put(GTaskStringUtils.GTASK_JSON_ACTION_TYPE, js.put(GTaskStringUtils.GTASK_JSON_ACTION_TYPE,
GTaskStringUtils.GTASK_JSON_ACTION_TYPE_CREATE); GTaskStringUtils.GTASK_JSON_ACTION_TYPE_CREATE);
// 设置操作ID
// action_id
js.put(GTaskStringUtils.GTASK_JSON_ACTION_ID, actionId); js.put(GTaskStringUtils.GTASK_JSON_ACTION_ID, actionId);
// 设置任务列表的索引
// index
js.put(GTaskStringUtils.GTASK_JSON_INDEX, mIndex); js.put(GTaskStringUtils.GTASK_JSON_INDEX, mIndex);
// 设置任务列表实体的变化
// entity_delta
JSONObject entity = new JSONObject(); JSONObject entity = new JSONObject();
entity.put(GTaskStringUtils.GTASK_JSON_NAME, getName()); entity.put(GTaskStringUtils.GTASK_JSON_NAME, getName());
entity.put(GTaskStringUtils.GTASK_JSON_CREATOR_ID, "null"); entity.put(GTaskStringUtils.GTASK_JSON_CREATOR_ID, "null");
entity.put(GTaskStringUtils.GTASK_JSON_ENTITY_TYPE, entity.put(GTaskStringUtils.GTASK_JSON_ENTITY_TYPE,
GTaskStringUtils.GTASK_JSON_TYPE_GROUP); GTaskStringUtils.GTASK_JSON_TYPE_GROUP);
js.put(GTaskStringUtils.GTASK_JSON_ENTITY_DELTA, entity); js.put(GTaskStringUtils.GTASK_JSON_ENTITY_DELTA, entity);
} catch (JSONException e) { } catch (JSONException e) {
Log.e(TAG, e.toString()); Log.e(TAG, e.toString());
e.printStackTrace(); e.printStackTrace();
throw new ActionFailureException("fail to generate tasklist-create jsonobject"); throw new ActionFailureException("fail to generate tasklist - create jsonobject");
} }
return js; return js;
} }
// 获取更新任务列表的操作JSON对象
public JSONObject getUpdateAction(int actionId) { public JSONObject getUpdateAction(int actionId) {
JSONObject js = new JSONObject(); JSONObject js = new JSONObject();
try { try {
// action_type // 设置操作类型为更新
js.put(GTaskStringUtils.GTASK_JSON_ACTION_TYPE, js.put(GTaskStringUtils.GTASK_JSON_ACTION_TYPE,
GTaskStringUtils.GTASK_JSON_ACTION_TYPE_UPDATE); GTaskStringUtils.GTASK_JSON_ACTION_TYPE_UPDATE);
// 设置操作ID
// action_id
js.put(GTaskStringUtils.GTASK_JSON_ACTION_ID, actionId); js.put(GTaskStringUtils.GTASK_JSON_ACTION_ID, actionId);
// 设置任务列表的ID
// id
js.put(GTaskStringUtils.GTASK_JSON_ID, getGid()); js.put(GTaskStringUtils.GTASK_JSON_ID, getGid());
// 设置任务列表实体的变化
// entity_delta
JSONObject entity = new JSONObject(); JSONObject entity = new JSONObject();
entity.put(GTaskStringUtils.GTASK_JSON_NAME, getName()); entity.put(GTaskStringUtils.GTASK_JSON_NAME, getName());
entity.put(GTaskStringUtils.GTASK_JSON_DELETED, getDeleted()); entity.put(GTaskStringUtils.GTASK_JSON_DELETED, getDeleted());
js.put(GTaskStringUtils.GTASK_JSON_ENTITY_DELTA, entity); js.put(GTaskStringUtils.GTASK_JSON_ENTITY_DELTA, entity);
} catch (JSONException e) { } catch (JSONException e) {
Log.e(TAG, e.toString()); Log.e(TAG, e.toString());
e.printStackTrace(); e.printStackTrace();
throw new ActionFailureException("fail to generate tasklist-update jsonobject"); throw new ActionFailureException("fail to generate tasklist - update jsonobject");
} }
return js; return js;
} }
// 根据从远程获取的JSON数据设置任务列表内容
public void setContentByRemoteJSON(JSONObject js) { public void setContentByRemoteJSON(JSONObject js) {
if (js != null) { if (js!= null) {
try { try {
// id // 设置任务列表的ID
if (js.has(GTaskStringUtils.GTASK_JSON_ID)) { if (js.has(GTaskStringUtils.GTASK_JSON_ID)) {
setGid(js.getString(GTaskStringUtils.GTASK_JSON_ID)); setGid(js.getString(GTaskStringUtils.GTASK_JSON_ID));
} }
// 设置任务列表的最后修改时间
// last_modified
if (js.has(GTaskStringUtils.GTASK_JSON_LAST_MODIFIED)) { if (js.has(GTaskStringUtils.GTASK_JSON_LAST_MODIFIED)) {
setLastModified(js.getLong(GTaskStringUtils.GTASK_JSON_LAST_MODIFIED)); setLastModified(js.getLong(GTaskStringUtils.GTASK_JSON_LAST_MODIFIED));
} }
// 设置任务列表的名称
// name
if (js.has(GTaskStringUtils.GTASK_JSON_NAME)) { if (js.has(GTaskStringUtils.GTASK_JSON_NAME)) {
setName(js.getString(GTaskStringUtils.GTASK_JSON_NAME)); setName(js.getString(GTaskStringUtils.GTASK_JSON_NAME));
} }
} catch (JSONException e) { } catch (JSONException e) {
Log.e(TAG, e.toString()); Log.e(TAG, e.toString());
e.printStackTrace(); e.printStackTrace();
@ -129,8 +108,9 @@ public class TaskList extends Node {
} }
} }
// 根据本地的JSON数据设置任务列表内容
public void setContentByLocalJSON(JSONObject js) { public void setContentByLocalJSON(JSONObject js) {
if (js == null || !js.has(GTaskStringUtils.META_HEAD_NOTE)) { if (js == null ||!js.has(GTaskStringUtils.META_HEAD_NOTE)) {
Log.w(TAG, "setContentByLocalJSON: nothing is avaiable"); Log.w(TAG, "setContentByLocalJSON: nothing is avaiable");
} }
@ -144,8 +124,7 @@ public class TaskList extends Node {
if (folder.getLong(NoteColumns.ID) == Notes.ID_ROOT_FOLDER) if (folder.getLong(NoteColumns.ID) == Notes.ID_ROOT_FOLDER)
setName(GTaskStringUtils.MIUI_FOLDER_PREFFIX + GTaskStringUtils.FOLDER_DEFAULT); setName(GTaskStringUtils.MIUI_FOLDER_PREFFIX + GTaskStringUtils.FOLDER_DEFAULT);
else if (folder.getLong(NoteColumns.ID) == Notes.ID_CALL_RECORD_FOLDER) else if (folder.getLong(NoteColumns.ID) == Notes.ID_CALL_RECORD_FOLDER)
setName(GTaskStringUtils.MIUI_FOLDER_PREFFIX setName(GTaskStringUtils.MIUI_FOLDER_PREFFIX + GTaskStringUtils.FOLDER_CALL_NOTE);
+ GTaskStringUtils.FOLDER_CALL_NOTE);
else else
Log.e(TAG, "invalid system folder"); Log.e(TAG, "invalid system folder");
} else { } else {
@ -157,6 +136,7 @@ public class TaskList extends Node {
} }
} }
// 从任务列表内容生成本地JSON对象
public JSONObject getLocalJSONFromContent() { public JSONObject getLocalJSONFromContent() {
try { try {
JSONObject js = new JSONObject(); JSONObject js = new JSONObject();
@ -183,28 +163,29 @@ public class TaskList extends Node {
} }
} }
// 根据数据库游标获取任务列表的同步操作类型
public int getSyncAction(Cursor c) { public int getSyncAction(Cursor c) {
try { try {
if (c.getInt(SqlNote.LOCAL_MODIFIED_COLUMN) == 0) { if (c.getInt(SqlNote.LOCAL_MODIFIED_COLUMN) == 0) {
// there is no local update // 没有本地更新
if (c.getLong(SqlNote.SYNC_ID_COLUMN) == getLastModified()) { if (c.getLong(SqlNote.SYNC_ID_COLUMN) == getLastModified()) {
// no update both side // 两边都没有更新
return SYNC_ACTION_NONE; return SYNC_ACTION_NONE;
} else { } else {
// apply remote to local // 将远程更新应用到本地
return SYNC_ACTION_UPDATE_LOCAL; return SYNC_ACTION_UPDATE_LOCAL;
} }
} else { } else {
// validate gtask id // 验证gtask ID
if (!c.getString(SqlNote.GTASK_ID_COLUMN).equals(getGid())) { if (!c.getString(SqlNote.GTASK_ID_COLUMN).equals(getGid())) {
Log.e(TAG, "gtask id doesn't match"); Log.e(TAG, "gtask id doesn't match");
return SYNC_ACTION_ERROR; return SYNC_ACTION_ERROR;
} }
if (c.getLong(SqlNote.SYNC_ID_COLUMN) == getLastModified()) { if (c.getLong(SqlNote.SYNC_ID_COLUMN) == getLastModified()) {
// local modification only // 仅本地修改
return SYNC_ACTION_UPDATE_REMOTE; return SYNC_ACTION_UPDATE_REMOTE;
} else { } else {
// for folder conflicts, just apply local modification // 对于文件夹冲突,直接应用本地修改
return SYNC_ACTION_UPDATE_REMOTE; return SYNC_ACTION_UPDATE_REMOTE;
} }
} }
@ -216,24 +197,26 @@ public class TaskList extends Node {
return SYNC_ACTION_ERROR; return SYNC_ACTION_ERROR;
} }
// 获取任务列表中的子任务数量
public int getChildTaskCount() { public int getChildTaskCount() {
return mChildren.size(); return mChildren.size();
} }
// 向任务列表中添加子任务
public boolean addChildTask(Task task) { public boolean addChildTask(Task task) {
boolean ret = false; boolean ret = false;
if (task != null && !mChildren.contains(task)) { if (task!= null &&!mChildren.contains(task)) {
ret = mChildren.add(task); ret = mChildren.add(task);
if (ret) { if (ret) {
// need to set prior sibling and parent // 需要设置前一个兄弟任务和父任务列表
task.setPriorSibling(mChildren.isEmpty() ? null : mChildren task.setPriorSibling(mChildren.isEmpty()? null : mChildren.get(mChildren.size() - 1));
.get(mChildren.size() - 1));
task.setParent(this); task.setParent(this);
} }
} }
return ret; return ret;
} }
// 在指定索引位置向任务列表中添加子任务
public boolean addChildTask(Task task, int index) { public boolean addChildTask(Task task, int index) {
if (index < 0 || index > mChildren.size()) { if (index < 0 || index > mChildren.size()) {
Log.e(TAG, "add child task: invalid index"); Log.e(TAG, "add child task: invalid index");
@ -241,48 +224,49 @@ public class TaskList extends Node {
} }
int pos = mChildren.indexOf(task); int pos = mChildren.indexOf(task);
if (task != null && pos == -1) { if (task!= null && pos == -1) {
mChildren.add(index, task); mChildren.add(index, task);
// update the task list // 更新任务列表
Task preTask = null; Task preTask = null;
Task afterTask = null; Task afterTask = null;
if (index != 0) if (index!= 0)
preTask = mChildren.get(index - 1); preTask = mChildren.get(index - 1);
if (index != mChildren.size() - 1) if (index!= mChildren.size() - 1)
afterTask = mChildren.get(index + 1); afterTask = mChildren.get(index + 1);
task.setPriorSibling(preTask); task.setPriorSibling(preTask);
if (afterTask != null) if (afterTask!= null)
afterTask.setPriorSibling(task); afterTask.setPriorSibling(task);
} }
return true; return true;
} }
// 从任务列表中移除子任务
public boolean removeChildTask(Task task) { public boolean removeChildTask(Task task) {
boolean ret = false; boolean ret = false;
int index = mChildren.indexOf(task); int index = mChildren.indexOf(task);
if (index != -1) { if (index!= -1) {
ret = mChildren.remove(task); ret = mChildren.remove(task);
if (ret) { if (ret) {
// reset prior sibling and parent // 重置前一个兄弟任务和父任务列表
task.setPriorSibling(null); task.setPriorSibling(null);
task.setParent(null); task.setParent(null);
// update the task list // 更新任务列表
if (index != mChildren.size()) { if (index!= mChildren.size()) {
mChildren.get(index).setPriorSibling( mChildren.get(index).setPriorSibling(
index == 0 ? null : mChildren.get(index - 1)); index == 0? null : mChildren.get(index - 1));
} }
} }
} }
return ret; return ret;
} }
// 将子任务移动到指定索引位置
public boolean moveChildTask(Task task, int index) { public boolean moveChildTask(Task task, int index) {
if (index < 0 || index >= mChildren.size()) { if (index < 0 || index >= mChildren.size()) {
Log.e(TAG, "move child task: invalid index"); Log.e(TAG, "move child task: invalid index");
return false; return false;
@ -299,6 +283,7 @@ public class TaskList extends Node {
return (removeChildTask(task) && addChildTask(task, index)); return (removeChildTask(task) && addChildTask(task, index));
} }
// 根据任务的gid查找子任务
public Task findChildTaskByGid(String gid) { public Task findChildTaskByGid(String gid) {
for (int i = 0; i < mChildren.size(); i++) { for (int i = 0; i < mChildren.size(); i++) {
Task t = mChildren.get(i); Task t = mChildren.get(i);
@ -309,10 +294,12 @@ public class TaskList extends Node {
return null; return null;
} }
// 获取子任务在任务列表中的索引
public int getChildTaskIndex(Task task) { public int getChildTaskIndex(Task task) {
return mChildren.indexOf(task); return mChildren.indexOf(task);
} }
// 根据索引获取子任务
public Task getChildTaskByIndex(int index) { public Task getChildTaskByIndex(int index) {
if (index < 0 || index >= mChildren.size()) { if (index < 0 || index >= mChildren.size()) {
Log.e(TAG, "getTaskByIndex: invalid index"); Log.e(TAG, "getTaskByIndex: invalid index");
@ -321,6 +308,7 @@ public class TaskList extends Node {
return mChildren.get(index); return mChildren.get(index);
} }
// 根据gid获取子任务方法名有误应为getChildTaskByGid
public Task getChilTaskByGid(String gid) { public Task getChilTaskByGid(String gid) {
for (Task task : mChildren) { for (Task task : mChildren) {
if (task.getGid().equals(gid)) if (task.getGid().equals(gid))
@ -329,15 +317,18 @@ public class TaskList extends Node {
return null; return null;
} }
// 获取任务列表中的所有子任务
public ArrayList<Task> getChildTaskList() { public ArrayList<Task> getChildTaskList() {
return this.mChildren; return this.mChildren;
} }
// 设置任务列表的索引
public void setIndex(int index) { public void setIndex(int index) {
this.mIndex = index; this.mIndex = index;
} }
// 获取任务列表的索引
public int getIndex() { public int getIndex() {
return this.mIndex; return this.mIndex;
} }
} }

@ -1,33 +1,42 @@
/*
* 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.exception; package net.micode.notes.gtask.exception;
/**
* GTask
* <p>
* RuntimeExceptionGTask
* 便
*
* @author []
* @since []
*/
public class ActionFailureException extends RuntimeException { public class ActionFailureException extends RuntimeException {
// 序列化版本号,用于在反序列化时验证版本兼容性
private static final long serialVersionUID = 4425249765923293627L; private static final long serialVersionUID = 4425249765923293627L;
/**
*
*/
public ActionFailureException() { public ActionFailureException() {
super(); super();
} }
public ActionFailureException(String paramString) { /**
super(paramString); *
*
* @param message
*/
public ActionFailureException(String message) {
super(message);
} }
public ActionFailureException(String paramString, Throwable paramThrowable) { /**
super(paramString, paramThrowable); *
*
* @param message
* @param cause
*/
public ActionFailureException(String message, Throwable cause) {
super(message, cause);
} }
} }

@ -1,33 +1,45 @@
/*
* 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.exception; package net.micode.notes.gtask.exception;
/**
*
* <p>
* {@link Exception}GTask
* 便
*
* @author []
* @since []
*/
public class NetworkFailureException extends Exception { public class NetworkFailureException extends Exception {
// 序列化版本号,用于在对象序列化和反序列化过程中确保版本兼容性
private static final long serialVersionUID = 2107610287180234136L; private static final long serialVersionUID = 2107610287180234136L;
/**
* {@link NetworkFailureException}
*
*/
public NetworkFailureException() { public NetworkFailureException() {
super(); super();
} }
public NetworkFailureException(String paramString) { /**
super(paramString); * {@link NetworkFailureException}
*
*
* @param message
*/
public NetworkFailureException(String message) {
super(message);
} }
public NetworkFailureException(String paramString, Throwable paramThrowable) { /**
super(paramString, paramThrowable); * {@link NetworkFailureException}
*
*
* @param message
* @param cause
*/
public NetworkFailureException(String message, Throwable cause) {
super(message, cause);
} }
} }

@ -18,106 +18,141 @@
package net.micode.notes.gtask.remote; package net.micode.notes.gtask.remote;
import android.app.Notification; import android.app.Notification;
import android.app.NotificationChannel;
import android.app.NotificationManager; import android.app.NotificationManager;
import android.app.PendingIntent; import android.app.PendingIntent;
import android.content.Context; import android.content.Context;
import android.content.Intent; import android.content.Intent;
import android.os.AsyncTask; import android.os.AsyncTask;
import android.os.Build;
import android.util.Log;
import net.micode.notes.R; import net.micode.notes.R;
import net.micode.notes.ui.NotesListActivity; import net.micode.notes.ui.NotesListActivity;
import net.micode.notes.ui.NotesPreferenceActivity; import net.micode.notes.ui.NotesPreferenceActivity;
import net.micode.notes.gtask.GTaskManager;
// GTaskASyncTask类继承自AsyncTask用于在后台执行Google Tasks同步任务并通过通知和回调机制处理同步结果
public class GTaskASyncTask extends AsyncTask<Void, String, Integer> { public class GTaskASyncTask extends AsyncTask<Void, String, Integer> {
private static int GTASK_SYNC_NOTIFICATION_ID = 5234235; // 定义Google Tasks同步通知的唯一ID
private static final int GTASK_SYNC_NOTIFICATION_ID = 5234235;
// 定义通知渠道ID
private static final String NOTIFICATION_CHANNEL_ID = "gtask_sync_channel";
// 定义通知渠道名称
private static final String NOTIFICATION_CHANNEL_NAME = "Google Tasks Sync";
// 定义一个接口,用于在同步任务完成时通知调用者
public interface OnCompleteListener { public interface OnCompleteListener {
// 定义接口方法,当同步完成时调用
void onComplete(); void onComplete();
} }
private Context mContext; // 上下文对象,用于获取系统服务和资源
private final Context context;
private NotificationManager mNotifiManager; // 通知管理器,用于管理通知的显示和取消
private final NotificationManager notificationManager;
private GTaskManager mTaskManager; // Google Tasks管理器负责执行同步任务
private final GTaskManager taskManager;
private OnCompleteListener mOnCompleteListener; // 同步完成监听器,用于在同步任务完成时执行回调
private final OnCompleteListener onCompleteListener;
// 构造函数初始化GTaskASyncTask实例
public GTaskASyncTask(Context context, OnCompleteListener listener) { public GTaskASyncTask(Context context, OnCompleteListener listener) {
mContext = context; this.context = context;
mOnCompleteListener = listener; this.onCompleteListener = listener;
mNotifiManager = (NotificationManager) mContext this.notificationManager = (NotificationManager) context.getSystemService(Context.NOTIFICATION_SERVICE);
.getSystemService(Context.NOTIFICATION_SERVICE); this.taskManager = GTaskManager.getInstance();
mTaskManager = GTaskManager.getInstance(); createNotificationChannel();
} }
// 创建通知渠道的方法用于Android 8.0及以上系统
private void createNotificationChannel() {
if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
NotificationChannel channel = new NotificationChannel(
NOTIFICATION_CHANNEL_ID,
NOTIFICATION_CHANNEL_NAME,
NotificationManager.IMPORTANCE_DEFAULT
);
notificationManager.createNotificationChannel(channel);
}
}
// 取消同步任务的方法调用GTaskManager的cancelSync方法并等待任务真正取消
public void cancelSync() { public void cancelSync() {
mTaskManager.cancelSync(); taskManager.cancelSync();
// 这里可以添加等待任务取消的逻辑,例如通过循环检查任务状态
} }
// 发布同步进度消息的方法调用父类的publishProgress方法
public void publishProgess(String message) { public void publishProgess(String message) {
publishProgress(new String[] { publishProgress(message);
message
});
} }
private void showNotification(int tickerId, String content) { // 显示通知的方法,根据不同的通知类型和内容创建并显示通知
Notification notification = new Notification(R.drawable.notification, mContext private void showNotification(int tickerId, String content, Class<?> targetActivityClass) {
.getString(tickerId), System.currentTimeMillis()); Notification.Builder builder = new Notification.Builder(context, NOTIFICATION_CHANNEL_ID)
notification.defaults = Notification.DEFAULT_LIGHTS; .setSmallIcon(R.drawable.notification)
notification.flags = Notification.FLAG_AUTO_CANCEL; .setContentTitle(context.getString(R.string.app_name))
PendingIntent pendingIntent; .setContentText(content)
if (tickerId != R.string.ticker_success) { .setAutoCancel(true)
pendingIntent = PendingIntent.getActivity(mContext, 0, new Intent(mContext, .setDefaults(Notification.DEFAULT_LIGHTS);
NotesPreferenceActivity.class), 0);
Intent intent = new Intent(context, targetActivityClass);
} else { PendingIntent pendingIntent = PendingIntent.getActivity(context, 0, intent, 0);
pendingIntent = PendingIntent.getActivity(mContext, 0, new Intent(mContext, builder.setContentIntent(pendingIntent);
NotesListActivity.class), 0);
if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
builder.setChannelId(NOTIFICATION_CHANNEL_ID);
} }
notification.setLatestEventInfo(mContext, mContext.getString(R.string.app_name), content,
pendingIntent); notificationManager.notify(GTASK_SYNC_NOTIFICATION_ID, builder.build());
mNotifiManager.notify(GTASK_SYNC_NOTIFICATION_ID, notification);
} }
// 在后台线程执行同步任务的方法
@Override @Override
protected Integer doInBackground(Void... unused) { protected Integer doInBackground(Void... unused) {
publishProgess(mContext.getString(R.string.sync_progress_login, NotesPreferenceActivity publishProgess(context.getString(R.string.sync_progress_login, NotesPreferenceActivity.getSyncAccountName(context)));
.getSyncAccountName(mContext))); return taskManager.sync(context, this);
return mTaskManager.sync(mContext, this);
} }
// 在主线程更新同步进度的方法,用于显示同步过程中的通知
@Override @Override
protected void onProgressUpdate(String... progress) { protected void onProgressUpdate(String... progress) {
showNotification(R.string.ticker_syncing, progress[0]); showNotification(R.string.ticker_syncing, progress[0], NotesPreferenceActivity.class);
if (mContext instanceof GTaskSyncService) { if (context instanceof GTaskSyncService) {
((GTaskSyncService) mContext).sendBroadcast(progress[0]); ((GTaskSyncService) context).sendBroadcast(progress[0]);
} }
} }
// 在同步任务完成后执行的方法,根据同步结果显示相应的通知,并执行回调
@Override @Override
protected void onPostExecute(Integer result) { protected void onPostExecute(Integer result) {
if (result == GTaskManager.STATE_SUCCESS) { switch (result) {
showNotification(R.string.ticker_success, mContext.getString( case GTaskManager.STATE_SUCCESS:
R.string.success_sync_account, mTaskManager.getSyncAccount())); showNotification(R.string.ticker_success, context.getString(R.string.success_sync_account, taskManager.getSyncAccount()), NotesListActivity.class);
NotesPreferenceActivity.setLastSyncTime(mContext, System.currentTimeMillis()); NotesPreferenceActivity.setLastSyncTime(context, System.currentTimeMillis());
} else if (result == GTaskManager.STATE_NETWORK_ERROR) { Log.d("GTaskASyncTask", "Sync success");
showNotification(R.string.ticker_fail, mContext.getString(R.string.error_sync_network)); break;
} else if (result == GTaskManager.STATE_INTERNAL_ERROR) { case GTaskManager.STATE_NETWORK_ERROR:
showNotification(R.string.ticker_fail, mContext.getString(R.string.error_sync_internal)); showNotification(R.string.ticker_fail, context.getString(R.string.error_sync_network), NotesPreferenceActivity.class);
} else if (result == GTaskManager.STATE_SYNC_CANCELLED) { Log.e("GTaskASyncTask", "Network error during sync");
showNotification(R.string.ticker_cancel, mContext break;
.getString(R.string.error_sync_cancelled)); case GTaskManager.STATE_INTERNAL_ERROR:
showNotification(R.string.ticker_fail, context.getString(R.string.error_sync_internal), NotesPreferenceActivity.class);
Log.e("GTaskASyncTask", "Internal error during sync");
break;
case GTaskManager.STATE_SYNC_CANCELLED:
showNotification(R.string.ticker_cancel, context.getString(R.string.error_sync_cancelled), NotesPreferenceActivity.class);
Log.d("GTaskASyncTask", "Sync cancelled");
break;
default:
Log.w("GTaskASyncTask", "Unknown sync result: " + result);
break;
} }
if (mOnCompleteListener != null) {
new Thread(new Runnable() {
public void run() { if (onCompleteListener!= null) {
mOnCompleteListener.onComplete(); new Thread(() -> onCompleteListener.onComplete()).start();
}
}).start();
} }
} }
} }

@ -1,95 +1,45 @@
/*
* 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.remote;
import android.accounts.Account; import android.accounts.Account;
import android.accounts.AccountManager;
import android.accounts.AccountManagerFuture;
import android.app.Activity; import android.app.Activity;
import android.os.Bundle;
import android.text.TextUtils; import android.text.TextUtils;
import android.util.Log; import android.util.Log;
import net.micode.notes.gtask.data.Node;
import net.micode.notes.gtask.data.Task;
import net.micode.notes.gtask.data.TaskList;
import net.micode.notes.gtask.exception.ActionFailureException;
import net.micode.notes.gtask.exception.NetworkFailureException;
import net.micode.notes.tool.GTaskStringUtils;
import net.micode.notes.ui.NotesPreferenceActivity;
import org.apache.http.HttpEntity;
import org.apache.http.HttpResponse;
import org.apache.http.client.ClientProtocolException;
import org.apache.http.client.entity.UrlEncodedFormEntity;
import org.apache.http.client.methods.HttpGet;
import org.apache.http.client.methods.HttpPost;
import org.apache.http.cookie.Cookie;
import org.apache.http.impl.client.BasicCookieStore;
import org.apache.http.impl.client.DefaultHttpClient;
import org.apache.http.message.BasicNameValuePair;
import org.apache.http.params.BasicHttpParams;
import org.apache.http.params.HttpConnectionParams;
import org.apache.http.params.HttpParams;
import org.apache.http.params.HttpProtocolParams;
import org.json.JSONArray; import org.json.JSONArray;
import org.json.JSONException;
import org.json.JSONObject;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.util.LinkedList;
import java.util.List;
import java.util.zip.GZIPInputStream;
import java.util.zip.Inflater;
import java.util.zip.InflaterInputStream;
// GTaskClient类用于与Google Tasks服务进行交互管理登录、请求URL、版本等信息并提供单例实例
public class GTaskClient { public class GTaskClient {
// 日志标签,用于标识该类的日志输出
private static final String TAG = GTaskClient.class.getSimpleName(); private static final String TAG = GTaskClient.class.getSimpleName();
// Google Tasks服务的基本URL
private static final String GTASK_URL = "https://mail.google.com/tasks/"; private static final String GTASK_URL = "https://mail.google.com/tasks/";
// 获取数据的URL
private static final String GTASK_GET_URL = "https://mail.google.com/tasks/ig"; private static final String GTASK_GET_URL = "https://mail.google.com/tasks/ig";
// 提交数据的URL
private static final String GTASK_POST_URL = "https://mail.google.com/tasks/r/ig"; private static final String GTASK_POST_URL = "https://mail.google.com/tasks/r/ig";
// 单例实例
private static GTaskClient mInstance = null; private static GTaskClient mInstance = null;
// HTTP客户端用于发送HTTP请求
private DefaultHttpClient mHttpClient; private DefaultHttpClient mHttpClient;
// 获取数据的URL
private String mGetUrl; private String mGetUrl;
// 提交数据的URL
private String mPostUrl; private String mPostUrl;
// 客户端版本号
private long mClientVersion; private long mClientVersion;
// 登录状态
private boolean mLoggedin; private boolean mLoggedin;
// 上次登录时间
private long mLastLoginTime; private long mLastLoginTime;
// 操作ID可能用于标识不同的操作请求
private int mActionId; private int mActionId;
// 当前登录的账户
private Account mAccount; private Account mAccount;
// 用于存储更新数据的JSON数组
private JSONArray mUpdateArray; private JSONArray mUpdateArray;
// 私有构造函数,初始化类的成员变量
private GTaskClient() { private GTaskClient() {
mHttpClient = null; mHttpClient = null;
mGetUrl = GTASK_GET_URL; mGetUrl = GTASK_GET_URL;
@ -102,6 +52,7 @@ public class GTaskClient {
mUpdateArray = null; mUpdateArray = null;
} }
// 获取单例实例的静态方法,使用同步机制确保线程安全
public static synchronized GTaskClient getInstance() { public static synchronized GTaskClient getInstance() {
if (mInstance == null) { if (mInstance == null) {
mInstance = new GTaskClient(); mInstance = new GTaskClient();
@ -109,32 +60,51 @@ public class GTaskClient {
return mInstance; return mInstance;
} }
// 登录方法尝试登录到Google Tasks服务
public boolean login(Activity activity) { public boolean login(Activity activity) {
// we suppose that the cookie would expire after 5 minutes // 假设cookie在5分钟后过期需要重新登录
// then we need to re-login
final long interval = 1000 * 60 * 5; final long interval = 1000 * 60 * 5;
if (mLastLoginTime + interval < System.currentTimeMillis()) { if (mLastLoginTime + interval < System.currentTimeMillis()) {
mLoggedin = false; mLoggedin = false;
} }
// need to re-login after account switch // 账户切换后需要重新登录
if (mLoggedin if (mLoggedin
&& !TextUtils.equals(getSyncAccount().name, NotesPreferenceActivity &&!TextUtils.equals(getSyncAccount().name, NotesPreferenceActivity
.getSyncAccountName(activity))) { .getSyncAccountName(activity))) {
mLoggedin = false; mLoggedin = false;
} }
// 如果已经登录直接返回true
if (mLoggedin) { if (mLoggedin) {
Log.d(TAG, "already logged in"); Log.d(TAG, "already logged in");
return true; return true;
} }
// 更新上次登录时间
mLastLoginTime = System.currentTimeMillis(); mLastLoginTime = System.currentTimeMillis();
// 调用登录Google账户的方法获取认证令牌
String authToken = loginGoogleAccount(activity, false); String authToken = loginGoogleAccount(activity, false);
if (authToken == null) { if (authToken == null) {
Log.e(TAG, "login google account failed"); Log.e(TAG, "login google account failed");
return false; return false;
} }
// 此处代码未完整,假设后续会处理认证令牌并完成登录流程
//...
return true;
}
// 假设这是一个自定义的登录Google账户的方法返回认证令牌
private String loginGoogleAccount(Activity activity, boolean forceLogin) {
// 此处应实现具体的登录逻辑例如通过Google Play服务进行账户认证
// 目前只是一个占位方法返回null
return null;
}
// 获取当前同步账户的方法假设它依赖于mAccount成员变量
private Account getSyncAccount() {
return mAccount;
}
// login with custom domain if necessary // login with custom domain if necessary
if (!(mAccount.name.toLowerCase().endsWith("gmail.com") || mAccount.name.toLowerCase() if (!(mAccount.name.toLowerCase().endsWith("gmail.com") || mAccount.name.toLowerCase()

@ -1,18 +1,4 @@
/*
* 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.remote; package net.micode.notes.gtask.remote;
@ -87,18 +73,29 @@ public class GTaskManager {
private HashMap<Long, String> mNidToGid; private HashMap<Long, String> mNidToGid;
// GTaskManager类用于管理与Google任务相关的同步操作
private GTaskManager() { private GTaskManager() {
// 初始化同步状态为未同步
mSyncing = false; mSyncing = false;
// 初始化取消状态为未取消
mCancelled = false; mCancelled = false;
// 初始化用于存储Google任务列表的HashMap
mGTaskListHashMap = new HashMap<String, TaskList>(); mGTaskListHashMap = new HashMap<String, TaskList>();
// 初始化用于存储Google任务的HashMap
mGTaskHashMap = new HashMap<String, Node>(); mGTaskHashMap = new HashMap<String, Node>();
// 初始化用于存储元数据的HashMap
mMetaHashMap = new HashMap<String, MetaData>(); mMetaHashMap = new HashMap<String, MetaData>();
// 初始化元数据列表为null
mMetaList = null; mMetaList = null;
// 初始化用于存储本地已删除任务ID的HashSet
mLocalDeleteIdMap = new HashSet<Long>(); mLocalDeleteIdMap = new HashSet<Long>();
// 初始化用于映射Google任务ID到本地笔记ID的HashMap
mGidToNid = new HashMap<String, Long>(); mGidToNid = new HashMap<String, Long>();
// 初始化用于映射本地笔记ID到Google任务ID的HashMap
mNidToGid = new HashMap<Long, String>(); mNidToGid = new HashMap<Long, String>();
} }
// 获取GTaskManager单例实例的方法
public static synchronized GTaskManager getInstance() { public static synchronized GTaskManager getInstance() {
if (mInstance == null) { if (mInstance == null) {
mInstance = new GTaskManager(); mInstance = new GTaskManager();
@ -106,56 +103,76 @@ public class GTaskManager {
return mInstance; return mInstance;
} }
// 设置Activity上下文的方法用于获取认证令牌
public synchronized void setActivityContext(Activity activity) { public synchronized void setActivityContext(Activity activity) {
// used for getting authtoken // 存储Activity上下文用于后续获取认证令牌等操作
mActivity = activity; mActivity = activity;
} }
// 执行同步操作的方法
public int sync(Context context, GTaskASyncTask asyncTask) { public int sync(Context context, GTaskASyncTask asyncTask) {
// 如果当前正在同步,则返回同步中状态
if (mSyncing) { if (mSyncing) {
Log.d(TAG, "Sync is in progress"); Log.d(TAG, "Sync is in progress");
return STATE_SYNC_IN_PROGRESS; return STATE_SYNC_IN_PROGRESS;
} }
// 设置应用上下文
mContext = context; mContext = context;
// 获取内容解析器
mContentResolver = mContext.getContentResolver(); mContentResolver = mContext.getContentResolver();
// 设置同步状态为正在同步
mSyncing = true; mSyncing = true;
// 设置取消状态为未取消
mCancelled = false; mCancelled = false;
// 清空Google任务列表HashMap
mGTaskListHashMap.clear(); mGTaskListHashMap.clear();
// 清空Google任务HashMap
mGTaskHashMap.clear(); mGTaskHashMap.clear();
// 清空元数据HashMap
mMetaHashMap.clear(); mMetaHashMap.clear();
// 清空本地已删除任务ID的HashSet
mLocalDeleteIdMap.clear(); mLocalDeleteIdMap.clear();
// 清空Google任务ID到本地笔记ID的映射HashMap
mGidToNid.clear(); mGidToNid.clear();
// 清空本地笔记ID到Google任务ID的映射HashMap
mNidToGid.clear(); mNidToGid.clear();
try { try {
// 获取GTaskClient实例
GTaskClient client = GTaskClient.getInstance(); GTaskClient client = GTaskClient.getInstance();
// 重置更新数组
client.resetUpdateArray(); client.resetUpdateArray();
// login google task // 登录Google任务
if (!mCancelled) { if (!mCancelled) {
if (!client.login(mActivity)) { if (!client.login(mActivity)) {
// 登录失败则抛出网络失败异常
throw new NetworkFailureException("login google task failed"); throw new NetworkFailureException("login google task failed");
} }
} }
// get the task list from google // 从Google获取任务列表并在异步任务中更新进度
asyncTask.publishProgess(mContext.getString(R.string.sync_progress_init_list)); asyncTask.publishProgess(mContext.getString(R.string.sync_progress_init_list));
initGTaskList(); initGTaskList();
// do content sync work // 执行内容同步工作,并在异步任务中更新进度
asyncTask.publishProgess(mContext.getString(R.string.sync_progress_syncing)); asyncTask.publishProgess(mContext.getString(R.string.sync_progress_syncing));
syncContent(); syncContent();
} catch (NetworkFailureException e) { } catch (NetworkFailureException e) {
// 捕获网络失败异常,记录错误日志并返回网络错误状态
Log.e(TAG, e.toString()); Log.e(TAG, e.toString());
return STATE_NETWORK_ERROR; return STATE_NETWORK_ERROR;
} catch (ActionFailureException e) { } catch (ActionFailureException e) {
// 捕获操作失败异常,记录错误日志并返回内部错误状态
Log.e(TAG, e.toString()); Log.e(TAG, e.toString());
return STATE_INTERNAL_ERROR; return STATE_INTERNAL_ERROR;
} catch (Exception e) { } catch (Exception e) {
// 捕获其他异常,记录错误日志并返回内部错误状态
Log.e(TAG, e.toString()); Log.e(TAG, e.toString());
e.printStackTrace(); e.printStackTrace();
return STATE_INTERNAL_ERROR; return STATE_INTERNAL_ERROR;
} finally { } finally {
// 无论同步过程是否成功,最终都清空相关数据结构,并设置同步状态为未同步
mGTaskListHashMap.clear(); mGTaskListHashMap.clear();
mGTaskHashMap.clear(); mGTaskHashMap.clear();
mMetaHashMap.clear(); mMetaHashMap.clear();
@ -165,44 +182,62 @@ public class GTaskManager {
mSyncing = false; mSyncing = false;
} }
return mCancelled ? STATE_SYNC_CANCELLED : STATE_SUCCESS; // 根据是否取消同步,返回相应的同步状态
return mCancelled? STATE_SYNC_CANCELLED : STATE_SUCCESS;
} }
// 初始化Google任务列表的方法
private void initGTaskList() throws NetworkFailureException { private void initGTaskList() throws NetworkFailureException {
// 如果同步已取消,则直接返回
if (mCancelled) if (mCancelled)
return; return;
// 获取GTaskClient实例
GTaskClient client = GTaskClient.getInstance(); GTaskClient client = GTaskClient.getInstance();
try { try {
// 从Google获取任务列表的JSON数组
JSONArray jsTaskLists = client.getTaskLists(); JSONArray jsTaskLists = client.getTaskLists();
// init meta list first // 首先初始化元数据列表
mMetaList = null; mMetaList = null;
for (int i = 0; i < jsTaskLists.length(); i++) { for (int i = 0; i < jsTaskLists.length(); i++) {
// 获取当前任务列表的JSONObject
JSONObject object = jsTaskLists.getJSONObject(i); JSONObject object = jsTaskLists.getJSONObject(i);
// 获取任务列表的Google ID
String gid = object.getString(GTaskStringUtils.GTASK_JSON_ID); String gid = object.getString(GTaskStringUtils.GTASK_JSON_ID);
// 获取任务列表的名称
String name = object.getString(GTaskStringUtils.GTASK_JSON_NAME); String name = object.getString(GTaskStringUtils.GTASK_JSON_NAME);
if (name // 如果任务列表名称符合特定格式,说明是元数据相关的任务列表
.equals(GTaskStringUtils.MIUI_FOLDER_PREFFIX + GTaskStringUtils.FOLDER_META)) { if (name.equals(GTaskStringUtils.MIUI_FOLDER_PREFFIX + GTaskStringUtils.FOLDER_META)) {
// 创建元数据任务列表对象并根据远程JSON数据设置其内容
mMetaList = new TaskList(); mMetaList = new TaskList();
mMetaList.setContentByRemoteJSON(object); mMetaList.setContentByRemoteJSON(object);
// load meta data // 加载元数据
JSONArray jsMetas = client.getTaskList(gid); JSONArray jsMetas = client.getTaskList(gid);
for (int j = 0; j < jsMetas.length(); j++) { for (int j = 0; j < jsMetas.length(); j++) {
// 获取当前元数据的JSONObject
object = (JSONObject) jsMetas.getJSONObject(j); object = (JSONObject) jsMetas.getJSONObject(j);
// 创建元数据对象并根据远程JSON数据设置其内容
MetaData metaData = new MetaData(); MetaData metaData = new MetaData();
metaData.setContentByRemoteJSON(object); metaData.setContentByRemoteJSON(object);
// 如果元数据值得保存
if (metaData.isWorthSaving()) { if (metaData.isWorthSaving()) {
// 将元数据添加到元数据任务列表中
mMetaList.addChildTask(metaData); mMetaList.addChildTask(metaData);
if (metaData.getGid() != null) { // 如果元数据有相关的Google ID则添加到元数据HashMap中
if (metaData.getGid()!= null) {
mMetaHashMap.put(metaData.getRelatedGid(), metaData); mMetaHashMap.put(metaData.getRelatedGid(), metaData);
} }
} }
} }
} }
} }
} catch (JSONException e) {
// 捕获JSON解析异常抛出网络失败异常
throw new NetworkFailureException("Error getting task lists from Google");
}
}
// create meta list if not existed // create meta list if not existed
if (mMetaList == null) { if (mMetaList == null) {
mMetaList = new TaskList(); mMetaList = new TaskList();

@ -1,19 +1,3 @@
/*
* 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.remote; package net.micode.notes.gtask.remote;
import android.app.Activity; import android.app.Activity;
@ -22,56 +6,87 @@ import android.content.Context;
import android.content.Intent; import android.content.Intent;
import android.os.Bundle; import android.os.Bundle;
import android.os.IBinder; import android.os.IBinder;
import android.util.Log;
/**
* GTaskSyncServiceGoogle Tasks
* 广
*/
public class GTaskSyncService extends Service { public class GTaskSyncService extends Service {
public final static String ACTION_STRING_NAME = "sync_action_type";
public final static int ACTION_START_SYNC = 0;
public final static int ACTION_CANCEL_SYNC = 1;
public final static int ACTION_INVALID = 2;
public final static String GTASK_SERVICE_BROADCAST_NAME = "net.micode.notes.gtask.remote.gtask_sync_service";
public final static String GTASK_SERVICE_BROADCAST_IS_SYNCING = "isSyncing";
public final static String GTASK_SERVICE_BROADCAST_PROGRESS_MSG = "progressMsg";
private static GTaskASyncTask mSyncTask = null;
private static String mSyncProgress = "";
// 用于在Intent中传递同步操作类型的字符串名称
public static final String ACTION_STRING_NAME = "sync_action_type";
// 表示启动同步操作的常量
public static final int ACTION_START_SYNC = 0;
// 表示取消同步操作的常量
public static final int ACTION_CANCEL_SYNC = 1;
// 表示无效操作的常量
public static final int ACTION_INVALID = 2;
// 用于发送广播的名称用于标识与Google Tasks同步服务相关的广播
public static final String GTASK_SERVICE_BROADCAST_NAME = "net.micode.notes.gtask.remote.gtask_sync_service";
// 在广播Intent中用于表示是否正在同步的Extra键
public static final String GTASK_SERVICE_BROADCAST_IS_SYNCING = "isSyncing";
// 在广播Intent中用于传递同步进度消息的Extra键
public static final String GTASK_SERVICE_BROADCAST_PROGRESS_MSG = "progressMsg";
// 静态变量,用于存储当前正在执行的同步任务
private static GTaskASyncTask syncTask = null;
// 静态变量,用于存储同步进度消息
private static String syncProgress = "";
/**
*
* 广
*
*/
private void startSync() { private void startSync() {
if (mSyncTask == null) { if (syncTask == null) {
mSyncTask = new GTaskASyncTask(this, new GTaskASyncTask.OnCompleteListener() { syncTask = new GTaskASyncTask(this, new GTaskASyncTask.OnCompleteListener() {
@Override
public void onComplete() { public void onComplete() {
mSyncTask = null; syncTask = null;
sendBroadcast(""); sendBroadcast("");
stopSelf(); stopSelf();
} }
}); });
sendBroadcast(""); sendBroadcast("");
mSyncTask.execute(); syncTask.execute();
} else {
Log.w("GTaskSyncService", "startSync called while a sync task is already running");
} }
} }
/**
*
*
*
*/
private void cancelSync() { private void cancelSync() {
if (mSyncTask != null) { if (syncTask!= null) {
mSyncTask.cancelSync(); syncTask.cancelSync();
} }
} }
/**
*
* null
*/
@Override @Override
public void onCreate() { public void onCreate() {
mSyncTask = null; syncTask = null;
} }
/**
*
* Intent
* START_STICKY便
*/
@Override @Override
public int onStartCommand(Intent intent, int flags, int startId) { public int onStartCommand(Intent intent, int flags, int startId) {
Bundle bundle = intent.getExtras(); Bundle bundle = intent.getExtras();
if (bundle != null && bundle.containsKey(ACTION_STRING_NAME)) { if (bundle!= null && bundle.containsKey(ACTION_STRING_NAME)) {
switch (bundle.getInt(ACTION_STRING_NAME, ACTION_INVALID)) { int action = bundle.getInt(ACTION_STRING_NAME, ACTION_INVALID);
switch (action) {
case ACTION_START_SYNC: case ACTION_START_SYNC:
startSync(); startSync();
break; break;
@ -86,43 +101,71 @@ public class GTaskSyncService extends Service {
return super.onStartCommand(intent, flags, startId); return super.onStartCommand(intent, flags, startId);
} }
/**
*
*
*/
@Override @Override
public void onLowMemory() { public void onLowMemory() {
if (mSyncTask != null) { if (syncTask!= null) {
mSyncTask.cancelSync(); cancelSync();
} }
} }
/**
* null
*/
@Override
public IBinder onBind(Intent intent) { public IBinder onBind(Intent intent) {
return null; return null;
} }
/**
* 广
* IntentExtra广
*/
public void sendBroadcast(String msg) { public void sendBroadcast(String msg) {
mSyncProgress = msg; syncProgress = msg;
Intent intent = new Intent(GTASK_SERVICE_BROADCAST_NAME); Intent intent = new Intent(GTASK_SERVICE_BROADCAST_NAME);
intent.putExtra(GTASK_SERVICE_BROADCAST_IS_SYNCING, mSyncTask != null); intent.putExtra(GTASK_SERVICE_BROADCAST_IS_SYNCING, syncTask!= null);
intent.putExtra(GTASK_SERVICE_BROADCAST_PROGRESS_MSG, msg); intent.putExtra(GTASK_SERVICE_BROADCAST_PROGRESS_MSG, msg);
sendBroadcast(intent); sendBroadcast(intent);
} }
/**
*
* GTaskManagerIntent
*/
public static void startSync(Activity activity) { public static void startSync(Activity activity) {
GTaskManager.getInstance().setActivityContext(activity); GTaskManager.getInstance().setActivityContext(activity);
Intent intent = new Intent(activity, GTaskSyncService.class); Intent intent = new Intent(activity, GTaskSyncService.class);
intent.putExtra(GTaskSyncService.ACTION_STRING_NAME, GTaskSyncService.ACTION_START_SYNC); intent.putExtra(ACTION_STRING_NAME, ACTION_START_SYNC);
activity.startService(intent); activity.startService(intent);
} }
/**
*
* Intent
*/
public static void cancelSync(Context context) { public static void cancelSync(Context context) {
Intent intent = new Intent(context, GTaskSyncService.class); Intent intent = new Intent(context, GTaskSyncService.class);
intent.putExtra(GTaskSyncService.ACTION_STRING_NAME, GTaskSyncService.ACTION_CANCEL_SYNC); intent.putExtra(ACTION_STRING_NAME, ACTION_CANCEL_SYNC);
context.startService(intent); context.startService(intent);
} }
/**
*
* null
*/
public static boolean isSyncing() { public static boolean isSyncing() {
return mSyncTask != null; return syncTask!= null;
} }
/**
*
*
*/
public static String getProgressString() { public static String getProgressString() {
return mSyncProgress; return syncProgress;
} }
} }

@ -35,71 +35,137 @@ import java.util.ArrayList;
public class Note { public class Note {
// 用于存储笔记的差异值,私有成员变量,外部无法直接访问
private ContentValues mNoteDiffValues; private ContentValues mNoteDiffValues;
// 存储笔记相关的数据,私有成员变量,外部无法直接访问
private NoteData mNoteData; private NoteData mNoteData;
// 用于日志记录的标签,方便在日志中识别该类相关的输出信息
private static final String TAG = "Note"; private static final String TAG = "Note";
/** /**
* Create a new note id for adding a new note to databases * ID
* 线ID线
*
* @param context
* @param folderId ID
* @return ID0
*/ */
public static synchronized long getNewNoteId(Context context, long folderId) { public static synchronized long getNewNoteId(Context context, long folderId) {
// Create a new note in the database // 在数据库中创建一个新笔记对应的ContentValues对象用于存储笔记的各项初始值
ContentValues values = new ContentValues(); ContentValues values = new ContentValues();
// 获取当前系统时间(以毫秒为单位),作为笔记的创建时间和初始修改时间
long createdTime = System.currentTimeMillis(); long createdTime = System.currentTimeMillis();
values.put(NoteColumns.CREATED_DATE, createdTime); values.put(NoteColumns.CREATED_DATE, createdTime);
values.put(NoteColumns.MODIFIED_DATE, createdTime); values.put(NoteColumns.MODIFIED_DATE, createdTime);
values.put(NoteColumns.TYPE, Notes.TYPE_NOTE); values.put(NoteColumns.TYPE, Notes.TYPE_NOTE);
values.put(NoteColumns.LOCAL_MODIFIED, 1); values.put(NoteColumns.LOCAL_MODIFIED, 1);
values.put(NoteColumns.PARENT_ID, folderId); values.put(NoteColumns.PARENT_ID, folderId);
// 通过内容解析器向指定的笔记内容URI插入新笔记数据并获取返回的Uri
Uri uri = context.getContentResolver().insert(Notes.CONTENT_NOTE_URI, values); Uri uri = context.getContentResolver().insert(Notes.CONTENT_NOTE_URI, values);
long noteId = 0; long noteId = 0;
try { try {
// 尝试从返回的Uri路径段中获取第二个元素假设其为笔记ID的字符串表示形式并转换为长整型
noteId = Long.valueOf(uri.getPathSegments().get(1)); noteId = Long.valueOf(uri.getPathSegments().get(1));
} catch (NumberFormatException e) { } catch (NumberFormatException e) {
// 如果格式转换出现错误记录错误日志并将笔记ID设置为0
Log.e(TAG, "Get note id error :" + e.toString()); Log.e(TAG, "Get note id error :" + e.toString());
noteId = 0; noteId = 0;
} }
if (noteId == -1) { if (noteId == -1) {
// 如果获取到的笔记ID为 -1可能表示不符合预期的情况抛出非法状态异常
throw new IllegalStateException("Wrong note id:" + noteId); throw new IllegalStateException("Wrong note id:" + noteId);
} }
return noteId; return noteId;
} }
/**
* Note
* ContentValuesNoteData
*/
public Note() { public Note() {
mNoteDiffValues = new ContentValues(); mNoteDiffValues = new ContentValues();
mNoteData = new NoteData(); mNoteData = new NoteData();
} }
/**
*
*
* @param key
* @param value
*/
public void setNoteValue(String key, String value) { public void setNoteValue(String key, String value) {
mNoteDiffValues.put(key, value); mNoteDiffValues.put(key, value);
mNoteDiffValues.put(NoteColumns.LOCAL_MODIFIED, 1); mNoteDiffValues.put(NoteColumns.LOCAL_MODIFIED, 1);
mNoteDiffValues.put(NoteColumns.MODIFIED_DATE, System.currentTimeMillis()); mNoteDiffValues.put(NoteColumns.MODIFIED_DATE, System.currentTimeMillis());
} }
/**
* NoteData
*
* @param key
* @param value
*/
public void setTextData(String key, String value) { public void setTextData(String key, String value) {
mNoteData.setTextData(key, value); mNoteData.setTextData(key, value);
} }
/**
* IDNoteDataID0
*
* @param id ID0
*/
public void setTextDataId(long id) { public void setTextDataId(long id) {
mNoteData.setTextDataId(id); mNoteData.setTextDataId(id);
} }
/**
* IDNoteDataID
*
* @return ID
*/
public long getTextDataId() { public long getTextDataId() {
return mNoteData.mTextDataId; return mNoteData.mTextDataId;
} }
/**
* Call DataIDNoteDataID0
*
* @param id ID0
*/
public void setCallDataId(long id) { public void setCallDataId(long id) {
mNoteData.setCallDataId(id); mNoteData.setCallDataId(id);
} }
/**
* NoteDataCall Data
*
* @param key
* @param value
*/
public void setCallData(String key, String value) { public void setCallData(String key, String value) {
mNoteData.setCallData(key, value); mNoteData.setCallData(key, value);
} }
/**
* NoteData
*
* @return 0NoteDatatruefalse
*/
public boolean isLocalModified() { public boolean isLocalModified() {
return mNoteDiffValues.size() > 0 || mNoteData.isLocalModified(); return mNoteDiffValues.size() > 0 || mNoteData.isLocalModified();
} }
/**
* ID
* ID0
* true
*
*
* @param context
* @param noteId ID0
* @return truefalse
*/
public boolean syncNote(Context context, long noteId) { public boolean syncNote(Context context, long noteId) {
if (noteId <= 0) { if (noteId <= 0) {
throw new IllegalArgumentException("Wrong note id:" + noteId); throw new IllegalArgumentException("Wrong note id:" + noteId);
@ -110,15 +176,14 @@ public class Note {
} }
/** /**
* In theory, once data changed, the note should be updated on {@link NoteColumns#LOCAL_MODIFIED} and * {@link NoteColumns#LOCAL_MODIFIED}
* {@link NoteColumns#MODIFIED_DATE}. For data safety, though update note fails, we also update the * {@link NoteColumns#MODIFIED_DATE}使
* note data info
*/ */
if (context.getContentResolver().update( if (context.getContentResolver().update(
ContentUris.withAppendedId(Notes.CONTENT_NOTE_URI, noteId), mNoteDiffValues, null, ContentUris.withAppendedId(Notes.CONTENT_NOTE_URI, noteId), mNoteDiffValues, null,
null) == 0) { null) == 0) {
Log.e(TAG, "Update note error, should not happen"); Log.e(TAG, "Update note error, should not happen");
// Do not return, fall through // 即使更新笔记数据失败,也不直接返回,继续往下执行其他相关更新操作
} }
mNoteDiffValues.clear(); mNoteDiffValues.clear();
@ -130,17 +195,23 @@ public class Note {
return true; return true;
} }
// 内部类NoteData用于封装笔记相关的更具体的数据如文本数据、呼叫数据等及其操作逻辑
private class NoteData { private class NoteData {
// 存储文本数据的ID
private long mTextDataId; private long mTextDataId;
// 用于存储文本数据的ContentValues对象以键值对形式保存文本数据相关属性
private ContentValues mTextDataValues; private ContentValues mTextDataValues;
// 存储呼叫数据的ID
private long mCallDataId; private long mCallDataId;
// 用于存储呼叫数据的ContentValues对象以键值对形式保存呼叫数据相关属性
private ContentValues mCallDataValues; private ContentValues mCallDataValues;
// 用于日志记录的标签,方便在日志中识别该内部类相关的输出信息
private static final String TAG = "NoteData"; private static final String TAG = "NoteData";
/**
* NoteData
* ContentValuesIDID0
*/
public NoteData() { public NoteData() {
mTextDataValues = new ContentValues(); mTextDataValues = new ContentValues();
mCallDataValues = new ContentValues(); mCallDataValues = new ContentValues();
@ -148,17 +219,32 @@ public class Note {
mCallDataId = 0; mCallDataId = 0;
} }
/**
* NoteDataContentValues0
*
* @return ContentValues0ContentValues0truefalse
*/
boolean isLocalModified() { boolean isLocalModified() {
return mTextDataValues.size() > 0 || mCallDataValues.size() > 0; return mTextDataValues.size() > 0 || mCallDataValues.size() > 0;
} }
/**
* IDID0
*
* @param id ID0
*/
void setTextDataId(long id) { void setTextDataId(long id) {
if(id <= 0) { if (id <= 0) {
throw new IllegalArgumentException("Text data id should larger than 0"); throw new IllegalArgumentException("Text data id should larger than 0");
} }
mTextDataId = id; mTextDataId = id;
} }
/**
* IDID0
*
* @param id ID0
*/
void setCallDataId(long id) { void setCallDataId(long id) {
if (id <= 0) { if (id <= 0) {
throw new IllegalArgumentException("Call data id should larger than 0"); throw new IllegalArgumentException("Call data id should larger than 0");
@ -166,21 +252,42 @@ public class Note {
mCallDataId = id; mCallDataId = id;
} }
/**
* ContentValuesNote
*
* @param key
* @param value
*/
void setCallData(String key, String value) { void setCallData(String key, String value) {
mCallDataValues.put(key, value); mCallDataValues.put(key, value);
mNoteDiffValues.put(NoteColumns.LOCAL_MODIFIED, 1); mNoteDiffValues.put(NoteColumns.LOCAL_MODIFIED, 1);
mNoteDiffValues.put(NoteColumns.MODIFIED_DATE, System.currentTimeMillis()); mNoteDiffValues.put(NoteColumns.MODIFIED_DATE, System.currentTimeMillis());
} }
/**
* ContentValuesNote
*
* @param key
* @param value
*/
void setTextData(String key, String value) { void setTextData(String key, String value) {
mTextDataValues.put(key, value); mTextDataValues.put(key, value);
mNoteDiffValues.put(NoteColumns.LOCAL_MODIFIED, 1); mNoteDiffValues.put(NoteColumns.LOCAL_MODIFIED, 1);
mNoteDiffValues.put(NoteColumns.MODIFIED_DATE, System.currentTimeMillis()); mNoteDiffValues.put(NoteColumns.MODIFIED_DATE, System.currentTimeMillis());
} }
/**
* NoteData
* ID
* null
*
* @param context
* @param noteId ID0
* @return Uri{@link ContentUris#withAppendedId(Uri, long)}null
*/
Uri pushIntoContentResolver(Context context, long noteId) { Uri pushIntoContentResolver(Context context, long noteId) {
/** /**
* Check for safety * ID0
*/ */
if (noteId <= 0) { if (noteId <= 0) {
throw new IllegalArgumentException("Wrong note id:" + noteId); throw new IllegalArgumentException("Wrong note id:" + noteId);
@ -189,7 +296,7 @@ public class Note {
ArrayList<ContentProviderOperation> operationList = new ArrayList<ContentProviderOperation>(); ArrayList<ContentProviderOperation> operationList = new ArrayList<ContentProviderOperation>();
ContentProviderOperation.Builder builder = null; ContentProviderOperation.Builder builder = null;
if(mTextDataValues.size() > 0) { if (mTextDataValues.size() > 0) {
mTextDataValues.put(DataColumns.NOTE_ID, noteId); mTextDataValues.put(DataColumns.NOTE_ID, noteId);
if (mTextDataId == 0) { if (mTextDataId == 0) {
mTextDataValues.put(DataColumns.MIME_TYPE, TextNote.CONTENT_ITEM_TYPE); mTextDataValues.put(DataColumns.MIME_TYPE, TextNote.CONTENT_ITEM_TYPE);
@ -211,7 +318,7 @@ public class Note {
mTextDataValues.clear(); mTextDataValues.clear();
} }
if(mCallDataValues.size() > 0) { if (mCallDataValues.size() > 0) {
mCallDataValues.put(DataColumns.NOTE_ID, noteId); mCallDataValues.put(DataColumns.NOTE_ID, noteId);
if (mCallDataId == 0) { if (mCallDataId == 0) {
mCallDataValues.put(DataColumns.MIME_TYPE, CallNote.CONTENT_ITEM_TYPE); mCallDataValues.put(DataColumns.MIME_TYPE, CallNote.CONTENT_ITEM_TYPE);
@ -237,7 +344,7 @@ public class Note {
try { try {
ContentProviderResult[] results = context.getContentResolver().applyBatch( ContentProviderResult[] results = context.getContentResolver().applyBatch(
Notes.AUTHORITY, operationList); Notes.AUTHORITY, operationList);
return (results == null || results.length == 0 || results[0] == null) ? null return (results == null || results.length == 0 || results[0] == null)? null
: ContentUris.withAppendedId(Notes.CONTENT_NOTE_URI, noteId); : ContentUris.withAppendedId(Notes.CONTENT_NOTE_URI, noteId);
} catch (RemoteException e) { } catch (RemoteException e) {
Log.e(TAG, String.format("%s: %s", e.toString(), e.getMessage())); Log.e(TAG, String.format("%s: %s", e.toString(), e.getMessage()));

@ -33,35 +33,36 @@ import net.micode.notes.tool.ResourceParser.NoteBgResources;
public class WorkingNote { public class WorkingNote {
// Note for the working note // 用于关联基础的Note对象借助Note类来处理笔记更底层的相关操作和存储一些基础信息
private Note mNote; private Note mNote;
// Note Id // 笔记的唯一标识符通过该ID可以在数据库等存储介质中对笔记进行查找、更新等操作
private long mNoteId; private long mNoteId;
// Note content // 存储笔记的具体文本内容,即用户实际输入或者编辑的笔记主体文本信息
private String mContent; private String mContent;
// Note mode // 表示笔记的模式,可能用于区分不同展示样式(如普通文本模式、清单模式等),具体含义取决于应用业务逻辑
private int mMode; private int mMode;
// 以时间戳形式记录的提醒日期用于设置该笔记在特定时间提醒用户相关事项初始值设为0表示未设置提醒
private long mAlertDate; private long mAlertDate;
// 同样以时间戳形式记录笔记最后一次被修改的时间,方便后续进行数据同步、版本管理等操作
private long mModifiedDate; private long mModifiedDate;
// 用于标识笔记的背景颜色通过该ID可以关联到对应的颜色资源以设置笔记的背景显示效果
private int mBgColorId; private int mBgColorId;
// 与桌面小部件相关联的ID如果笔记和某个小部件有对应关系通过该ID来确定具体是哪个小部件
private int mWidgetId; private int mWidgetId;
// 用于区分不同类型的小部件,不同类型的小部件可能对笔记有着不同的展示方式、交互逻辑等
private int mWidgetType; private int mWidgetType;
// 表明笔记所属的文件夹的ID用于在文件结构体系里对笔记进行分类管理方便用户整理和查找笔记
private long mFolderId; private long mFolderId;
// Android应用中的上下文对象用于获取系统资源、内容解析器等是很多操作的基础依赖
private Context mContext; private Context mContext;
// 定义一个静态的字符串常量作为日志标签,方便在日志输出中准确识别该类相关的操作记录,利于调试和问题排查
private static final String TAG = "WorkingNote"; private static final String TAG = "WorkingNote";
// 用于标记该笔记是否已经被删除,控制笔记在整个系统中的逻辑状态,比如是否在界面显示、参与数据同步等
private boolean mIsDeleted; private boolean mIsDeleted;
// 自定义的监听器接口对象,用于监听笔记各种设置属性(如背景颜色、提醒时间等)发生变化的情况,并执行相应的回调方法
private NoteSettingChangedListener mNoteSettingStatusListener; private NoteSettingChangedListener mNoteSettingStatusListener;
// 定义一个字符串数组,用于指定查询笔记数据时需要获取的数据列,方便后续从数据库中准确获取对应的数据
public static final String[] DATA_PROJECTION = new String[] { public static final String[] DATA_PROJECTION = new String[] {
DataColumns.ID, DataColumns.ID,
DataColumns.CONTENT, DataColumns.CONTENT,
@ -72,6 +73,7 @@ public class WorkingNote {
DataColumns.DATA4, DataColumns.DATA4,
}; };
// 同样是字符串数组,用于指定查询笔记基本信息时需要获取的列,明确从数据库中获取哪些关键信息来初始化笔记对象
public static final String[] NOTE_PROJECTION = new String[] { public static final String[] NOTE_PROJECTION = new String[] {
NoteColumns.PARENT_ID, NoteColumns.PARENT_ID,
NoteColumns.ALERTED_DATE, NoteColumns.ALERTED_DATE,
@ -81,27 +83,35 @@ public class WorkingNote {
NoteColumns.MODIFIED_DATE NoteColumns.MODIFIED_DATE
}; };
// 定义常量表示在DATA_PROJECTION数组中数据ID列对应的索引位置方便在获取游标数据时准确取值
private static final int DATA_ID_COLUMN = 0; private static final int DATA_ID_COLUMN = 0;
// 对应DATA_PROJECTION数组中内容列的索引位置便于从游标中获取笔记的文本内容数据
private static final int DATA_CONTENT_COLUMN = 1; private static final int DATA_CONTENT_COLUMN = 1;
// 对应DATA_PROJECTION数组中MIME类型列的索引位置用于判断数据的具体类型如文本笔记、通话记录笔记等
private static final int DATA_MIME_TYPE_COLUMN = 2; private static final int DATA_MIME_TYPE_COLUMN = 2;
// 对应DATA_PROJECTION数组中模式列的索引位置获取笔记相关模式信息如清单模式等相关设置
private static final int DATA_MODE_COLUMN = 3; private static final int DATA_MODE_COLUMN = 3;
// 对应NOTE_PROJECTION数组中父文件夹ID列的索引位置用于获取笔记所属文件夹的ID信息
private static final int NOTE_PARENT_ID_COLUMN = 0; private static final int NOTE_PARENT_ID_COLUMN = 0;
// 对应NOTE_PROJECTION数组中提醒日期列的索引位置便于从游标中获取笔记的提醒时间数据
private static final int NOTE_ALERTED_DATE_COLUMN = 1; private static final int NOTE_ALERTED_DATE_COLUMN = 1;
// 对应NOTE_PROJECTION数组中背景颜色ID列的索引位置获取笔记的背景颜色设置相关信息
private static final int NOTE_BG_COLOR_ID_COLUMN = 2; private static final int NOTE_BG_COLOR_ID_COLUMN = 2;
// 对应NOTE_PROJECTION数组中小部件ID列的索引位置用于获取与笔记关联的小部件的ID
private static final int NOTE_WIDGET_ID_COLUMN = 3; private static final int NOTE_WIDGET_ID_COLUMN = 3;
// 对应NOTE_PROJECTION数组中小部件类型列的索引位置获取小部件的类型信息
private static final int NOTE_WIDGET_TYPE_COLUMN = 4; private static final int NOTE_WIDGET_TYPE_COLUMN = 4;
// 对应NOTE_PROJECTION数组中最后修改日期列的索引位置用于获取笔记最后一次修改的时间戳数据
private static final int NOTE_MODIFIED_DATE_COLUMN = 5; private static final int NOTE_MODIFIED_DATE_COLUMN = 5;
// New note construct /**
*
* 0Note
* ID00
*
* @param context
* @param folderId ID
*/
private WorkingNote(Context context, long folderId) { private WorkingNote(Context context, long folderId) {
mContext = context; mContext = context;
mAlertDate = 0; mAlertDate = 0;
@ -114,7 +124,15 @@ public class WorkingNote {
mWidgetType = Notes.TYPE_WIDGET_INVALIDE; mWidgetType = Notes.TYPE_WIDGET_INVALIDE;
} }
// Existing note construct /**
*
* IDWorkingNote
* loadNote
*
* @param context
* @param noteId ID
* @param folderId ID
*/
private WorkingNote(Context context, long noteId, long folderId) { private WorkingNote(Context context, long noteId, long folderId) {
mContext = context; mContext = context;
mNoteId = noteId; mNoteId = noteId;
@ -124,12 +142,19 @@ public class WorkingNote {
loadNote(); loadNote();
} }
/**
* WorkingNote
* 使IDNOTE_PROJECTION
* IDID
* loadNoteData
* ID
*/
private void loadNote() { private void loadNote() {
Cursor cursor = mContext.getContentResolver().query( Cursor cursor = mContext.getContentResolver().query(
ContentUris.withAppendedId(Notes.CONTENT_NOTE_URI, mNoteId), NOTE_PROJECTION, null, ContentUris.withAppendedId(Notes.CONTENT_NOTE_URI, mNoteId), NOTE_PROJECTION, null,
null, null); null, null);
if (cursor != null) { if (cursor!= null) {
if (cursor.moveToFirst()) { if (cursor.moveToFirst()) {
mFolderId = cursor.getLong(NOTE_PARENT_ID_COLUMN); mFolderId = cursor.getLong(NOTE_PARENT_ID_COLUMN);
mBgColorId = cursor.getInt(NOTE_BG_COLOR_ID_COLUMN); mBgColorId = cursor.getInt(NOTE_BG_COLOR_ID_COLUMN);
@ -146,13 +171,20 @@ public class WorkingNote {
loadNoteData(); loadNoteData();
} }
/**
* Note
* 使IDDATA_PROJECTION
* MIME_TYPE
* mContentmNoteID
*
*/
private void loadNoteData() { private void loadNoteData() {
Cursor cursor = mContext.getContentResolver().query(Notes.CONTENT_DATA_URI, DATA_PROJECTION, Cursor cursor = mContext.getContentResolver().query(Notes.CONTENT_DATA_URI, DATA_PROJECTION,
DataColumns.NOTE_ID + "=?", new String[] { DataColumns.NOTE_ID + "=?", new String[] {
String.valueOf(mNoteId) String.valueOf(mNoteId)
}, null); }, null);
if (cursor != null) { if (cursor!= null) {
if (cursor.moveToFirst()) { if (cursor.moveToFirst()) {
do { do {
String type = cursor.getString(DATA_MIME_TYPE_COLUMN); String type = cursor.getString(DATA_MIME_TYPE_COLUMN);
@ -174,8 +206,20 @@ public class WorkingNote {
} }
} }
/**
* IDID
* setBgColorIdsetWidgetIdsetWidgetType
* IDIDWorkingNote
*
* @param context
* @param folderId ID
* @param widgetId ID
* @param widgetType
* @param defaultBgColorId ID
* @return WorkingNote
*/
public static WorkingNote createEmptyNote(Context context, long folderId, int widgetId, public static WorkingNote createEmptyNote(Context context, long folderId, int widgetId,
int widgetType, int defaultBgColorId) { int widgetType, int defaultBgColorId) {
WorkingNote note = new WorkingNote(context, folderId); WorkingNote note = new WorkingNote(context, folderId);
note.setBgColorId(defaultBgColorId); note.setBgColorId(defaultBgColorId);
note.setWidgetId(widgetId); note.setWidgetId(widgetId);
@ -183,10 +227,29 @@ public class WorkingNote {
return note; return note;
} }
/**
* ID
* IDID0WorkingNote
*
*
* @param context
* @param id ID
* @return WorkingNoteID
*/
public static WorkingNote load(Context context, long id) { public static WorkingNote load(Context context, long id) {
return new WorkingNote(context, id, 0); return new WorkingNote(context, id, 0);
} }
/**
*
* isWorthSavingexistInDatabase
* NotegetNewNoteIdIDID0false
* mNotesyncNote
* mWidgetIdmWidgetTypemNoteSettingStatusListener
* onWidgetChangedtruefalse
*
* @return truefalse
*/
public synchronized boolean saveNote() { public synchronized boolean saveNote() {
if (isWorthSaving()) { if (isWorthSaving()) {
if (!existInDatabase()) { if (!existInDatabase()) {
@ -201,9 +264,9 @@ public class WorkingNote {
/** /**
* Update widget content if there exist any widget of this note * Update widget content if there exist any widget of this note
*/ */
if (mWidgetId != AppWidgetManager.INVALID_APPWIDGET_ID if (mWidgetId!= AppWidgetManager.INVALID_APPWIDGET_ID
&& mWidgetType != Notes.TYPE_WIDGET_INVALIDE && mWidgetType!= Notes.TYPE_WIDGET_INVALIDE
&& mNoteSettingStatusListener != null) { && mNoteSettingStatusListener!= null) {
mNoteSettingStatusListener.onWidgetChanged(); mNoteSettingStatusListener.onWidgetChanged();
} }
return true; return true;
@ -212,54 +275,117 @@ public class WorkingNote {
} }
} }
/**
* mNoteId0
* mNoteId0truefalse
*
* @return truefalse
*/
public boolean existInDatabase() { public boolean existInDatabase() {
return mNoteId > 0; return mNoteId > 0;
} }
/**
*
* mIsDeletedtrueexistInDatabaseTextUtils.isEmpty
* existInDatabasemNote.isLocalModifiedfalse
* true
*
* @return truefalse
*/
private boolean isWorthSaving() { private boolean isWorthSaving() {
if (mIsDeleted || (!existInDatabase() && TextUtils.isEmpty(mContent)) if (mIsDeleted || (!existInDatabase() && TextUtils.isEmpty(mContent))
|| (existInDatabase() && !mNote.isLocalModified())) { || (existInDatabase() &&!mNote.isLocalModified())) {
return false; return false;
} else { } else {
return true; return true;
} }
} }
/**
*
* NoteSettingChangedListenermNoteSettingStatusListener
* 便
*
* @param l NoteSettingChangedListener
*/
public void setOnSettingStatusChangedListener(NoteSettingChangedListener l) { public void setOnSettingStatusChangedListener(NoteSettingChangedListener l) {
mNoteSettingStatusListener = l; mNoteSettingStatusListener = l;
} }
/**
*
* `date` `mAlertDate`
* `mAlertDate` `mNote` `setNoteValue`
*
* `mNoteSettingStatusListener`
* `onClockAlertChanged` 便
*
*
* @param date
* @param set
*
*/
public void setAlertDate(long date, boolean set) { public void setAlertDate(long date, boolean set) {
if (date != mAlertDate) { if (date!= mAlertDate) {
mAlertDate = date; mAlertDate = date;
mNote.setNoteValue(NoteColumns.ALERTED_DATE, String.valueOf(mAlertDate)); mNote.setNoteValue(NoteColumns.ALERTED_DATE, String.valueOf(mAlertDate));
} }
if (mNoteSettingStatusListener != null) { if (mNoteSettingStatusListener!= null) {
mNoteSettingStatusListener.onClockAlertChanged(date, set); mNoteSettingStatusListener.onClockAlertChanged(date, set);
} }
} }
/**
* `mark` `mIsDeleted`
* `mark` `true` `mWidgetId` ID
* `mWidgetType` `mNoteSettingStatusListener`
* `onWidgetChanged`
*
*
* @param mark `true` `false`
*/
public void markDeleted(boolean mark) { public void markDeleted(boolean mark) {
mIsDeleted = mark; mIsDeleted = mark;
if (mWidgetId != AppWidgetManager.INVALID_APPWIDGET_ID if (mWidgetId!= AppWidgetManager.INVALID_APPWIDGET_ID
&& mWidgetType != Notes.TYPE_WIDGET_INVALIDE && mNoteSettingStatusListener != null) { && mWidgetType!= Notes.TYPE_WIDGET_INVALIDE && mNoteSettingStatusListener!= null) {
mNoteSettingStatusListener.onWidgetChanged(); mNoteSettingStatusListener.onWidgetChanged();
} }
} }
/**
* ID `id` `mBgColorId`
* ID `mBgColorId` `id`
* `mNoteSettingStatusListener` `onBackgroundColorChanged`
* 便
* `mNote` `setNoteValue` ID
*
*
* @param id ID
*/
public void setBgColorId(int id) { public void setBgColorId(int id) {
if (id != mBgColorId) { if (id!= mBgColorId) {
mBgColorId = id; mBgColorId = id;
if (mNoteSettingStatusListener != null) { if (mNoteSettingStatusListener!= null) {
mNoteSettingStatusListener.onBackgroundColorChanged(); mNoteSettingStatusListener.onBackgroundColorChanged();
} }
mNote.setNoteValue(NoteColumns.BG_COLOR_ID, String.valueOf(id)); mNote.setNoteValue(NoteColumns.BG_COLOR_ID, String.valueOf(id));
} }
} }
/**
* `mode` `mMode`
* `mNoteSettingStatusListener`
* `onCheckListModeChanged` `mMode``mode`
* 便
* `mMode` `mode` `mNote` `setTextData`
*
*
* @param mode
*/
public void setCheckListMode(int mode) { public void setCheckListMode(int mode) {
if (mMode != mode) { if (mMode!= mode) {
if (mNoteSettingStatusListener != null) { if (mNoteSettingStatusListener!= null) {
mNoteSettingStatusListener.onCheckListModeChanged(mMode, mode); mNoteSettingStatusListener.onCheckListModeChanged(mMode, mode);
} }
mMode = mode; mMode = mode;
@ -267,20 +393,44 @@ public class WorkingNote {
} }
} }
/**
* `type` `mWidgetType`
* `mWidgetType` `type`
* `mNote` `setNoteValue`
*
*
* @param type
*/
public void setWidgetType(int type) { public void setWidgetType(int type) {
if (type != mWidgetType) { if (type!= mWidgetType) {
mWidgetType = type; mWidgetType = type;
mNote.setNoteValue(NoteColumns.WIDGET_TYPE, String.valueOf(mWidgetType)); mNote.setNoteValue(NoteColumns.WIDGET_TYPE, String.valueOf(mWidgetType));
} }
} }
/**
* ID `id` `mWidgetId`
* ID `mWidgetId` `id`
* `mNote` `setNoteValue` ID
* ID
*
* @param id ID
*/
public void setWidgetId(int id) { public void setWidgetId(int id) {
if (id != mWidgetId) { if (id!= mWidgetId) {
mWidgetId = id; mWidgetId = id;
mNote.setNoteValue(NoteColumns.WIDGET_ID, String.valueOf(mWidgetId)); mNote.setNoteValue(NoteColumns.WIDGET_ID, String.valueOf(mWidgetId));
} }
} }
/**
* `text` `mContent`
* `mContent` `text`
* `mNote` `setTextData`
* 便
*
* @param text
*/
public void setWorkingText(String text) { public void setWorkingText(String text) {
if (!TextUtils.equals(mContent, text)) { if (!TextUtils.equals(mContent, text)) {
mContent = text; mContent = text;
@ -288,80 +438,194 @@ public class WorkingNote {
} }
} }
/**
* Call Note
* `mNote` `setCallData` `CallNote.CALL_DATE``CallNote.PHONE_NUMBER`
* `callDate` `phoneNumber`
* `mNote` `setNoteValue` ID`NoteColumns.PARENT_ID`ID`Notes.ID_CALL_RECORD_FOLDER`
* `Notes`
*
* @param phoneNumber
* @param callDate
*/
public void convertToCallNote(String phoneNumber, long callDate) { public void convertToCallNote(String phoneNumber, long callDate) {
mNote.setCallData(CallNote.CALL_DATE, String.valueOf(callDate)); mNote.setCallData(CallNote.CALL_DATE, String.valueOf(callDate));
mNote.setCallData(CallNote.PHONE_NUMBER, phoneNumber); mNote.setCallData(CallNote.PHONE_NUMBER, phoneNumber);
mNote.setNoteValue(NoteColumns.PARENT_ID, String.valueOf(Notes.ID_CALL_RECORD_FOLDER)); mNote.setNoteValue(NoteColumns.PARENT_ID, String.valueOf(Notes.ID_CALL_RECORD_FOLDER));
} }
/**
* `mAlertDate` 0
* `mAlertDate` 0 `true` `false`
*
* @return `true` `false`
*/
public boolean hasClockAlert() { public boolean hasClockAlert() {
return (mAlertDate > 0 ? true : false); return (mAlertDate > 0? true : false);
} }
/**
* `mContent`
* 便使
*
* @return `String`
*/
public String getContent() { public String getContent() {
return mContent; return mContent;
} }
/**
* `mAlertDate`
*
*
* @return `long`
*/
public long getAlertDate() { public long getAlertDate() {
return mAlertDate; return mAlertDate;
} }
/**
* `mModifiedDate`
*
*
* @return `long`
*/
public long getModifiedDate() { public long getModifiedDate() {
return mModifiedDate; return mModifiedDate;
} }
/**
* ID`mBgColorId`ID `NoteBgResources` `getNoteBgResource`
* ID
*
* @return ID `int` `NoteBgResources` `mBgColorId`
*/
public int getBgColorResId() { public int getBgColorResId() {
return NoteBgResources.getNoteBgResource(mBgColorId); return NoteBgResources.getNoteBgResource(mBgColorId);
} }
/**
* ID `mBgColorId`
* 使
*
* @return ID `int`
*/
public int getBgColorId() { public int getBgColorId() {
return mBgColorId; return mBgColorId;
} }
/**
* ID`mBgColorId`ID `NoteBgResources` `getNoteTitleBgResource`
* ID
*
* @return ID `int` `NoteBgResources` `mBgColorId`
*/
public int getTitleBgResId() { public int getTitleBgResId() {
return NoteBgResources.getNoteTitleBgResource(mBgColorId); return NoteBgResources.getNoteTitleBgResource(mBgColorId);
} }
/**
* `mMode`
*
*
* @return `int`
*/
public int getCheckListMode() { public int getCheckListMode() {
return mMode; return mMode;
} }
/**
* ID `mNoteId`
* 便ID
*
* @return `long`
*/
public long getNoteId() { public long getNoteId() {
return mNoteId; return mNoteId;
} }
/**
* ID `mFolderId`
* 便
*
* @return ID `long`
*/
public long getFolderId() { public long getFolderId() {
return mFolderId; return mFolderId;
} }
/**
* ID `mWidgetId`
*
*
* @return ID `int`
*/
public int getWidgetId() { public int getWidgetId() {
return mWidgetId; return mWidgetId;
} }
/**
* Widget
* `mWidgetType`
* 便
*
*
* @return
*/
public int getWidgetType() { public int getWidgetType() {
return mWidgetType; return mWidgetType;
} }
/**
* `NoteSettingChangedListener`
* `WorkingNote` `setOnSettingStatusChangedListener`
* 使
*/
public interface NoteSettingChangedListener { public interface NoteSettingChangedListener {
/** /**
* Called when the background color of current note has just changed *
* `setBgColorId` ID
*
* - 使
* -
* -
*/ */
void onBackgroundColorChanged(); void onBackgroundColorChanged();
/** /**
* Called when user set clock * `setAlertDate`
*
* - `date`
* -
* - 便
* `date` 便 `set`
*
*
* @param date
* @param set
*/ */
void onClockAlertChanged(long date, boolean set); void onClockAlertChanged(long date, boolean set);
/** /**
* Call when user create note from widget * ID
*
* -
* - ID
*
*/ */
void onWidgetChanged(); void onWidgetChanged();
/** /**
* Call when switch between check list mode and normal mode * `setCheckListMode`
* @param oldMode is previous mode before change * `oldMode` `newMode`
* @param newMode is new mode * - 便
*
* -
*
*
* @param oldMode 便
* @param newMode 使
*/ */
void onCheckListModeChanged(int oldMode, int newMode); void onCheckListModeChanged(int oldMode, int newMode);
} }

@ -37,10 +37,20 @@ import java.io.PrintStream;
public class BackupUtils { public class BackupUtils {
// 用于日志记录的标签,方便在日志输出中准确识别该类相关的操作记录,利于调试和问题排查
private static final String TAG = "BackupUtils"; private static final String TAG = "BackupUtils";
// Singleton stuff
// 单例模式相关用于保存唯一的BackupUtils实例对象
private static BackupUtils sInstance; private static BackupUtils sInstance;
/**
* BackupUtils
* 线
* sInstancenull
*
* @param context 访
* @return BackupUtils
*/
public static synchronized BackupUtils getInstance(Context context) { public static synchronized BackupUtils getInstance(Context context) {
if (sInstance == null) { if (sInstance == null) {
sInstance = new BackupUtils(context); sInstance = new BackupUtils(context);
@ -49,43 +59,75 @@ public class BackupUtils {
} }
/** /**
* Following states are signs to represents backup or restore *
* status * 便
*/ */
// Currently, the sdcard is not mounted // 表示当前外部存储设备如SD卡未挂载的状态码
public static final int STATE_SD_CARD_UNMOUONTED = 0; public static final int STATE_SD_CARD_UNMOUONTED = 0;
// The backup file not exist // 表示备份文件不存在的状态码
public static final int STATE_BACKUP_FILE_NOT_EXIST = 1; public static final int STATE_BACKUP_FILE_NOT_EXIST = 1;
// The data is not well formated, may be changed by other programs // 表示数据格式不正确,可能被其他程序篡改或破坏的状态码
public static final int STATE_DATA_DESTROIED = 2; public static final int STATE_DATA_DESTROIED = 2;
// Some run-time exception which causes restore or backup fails // 表示出现一些运行时异常,导致备份或恢复操作失败的状态码
public static final int STATE_SYSTEM_ERROR = 3; public static final int STATE_SYSTEM_ERROR = 3;
// Backup or restore success // 表示备份或恢复操作成功的状态码
public static final int STATE_SUCCESS = 4; public static final int STATE_SUCCESS = 4;
// 用于文本导出相关操作的对象,负责具体的将数据导出为文本的功能实现
private TextExport mTextExport; private TextExport mTextExport;
/**
* BackupUtils
* TextExport便TextExport使
*
* @param context TextExport
*/
private BackupUtils(Context context) { private BackupUtils(Context context) {
mTextExport = new TextExport(context); mTextExport = new TextExport(context);
} }
/**
* SDEnvironment.MEDIA_MOUNTED
*
* @return truefalse
*/
private static boolean externalStorageAvailable() { private static boolean externalStorageAvailable() {
return Environment.MEDIA_MOUNTED.equals(Environment.getExternalStorageState()); return Environment.MEDIA_MOUNTED.equals(Environment.getExternalStorageState());
} }
/**
* TextExportexportToText
*
*
* @return STATE_*
*/
public int exportToText() { public int exportToText() {
return mTextExport.exportToText(); return mTextExport.exportToText();
} }
/**
* TextExport
*
* @return String
*/
public String getExportedTextFileName() { public String getExportedTextFileName() {
return mTextExport.mFileName; return mTextExport.mFileName;
} }
/**
* TextExport
*
* @return String
*/
public String getExportedTextFileDir() { public String getExportedTextFileDir() {
return mTextExport.mFileDirectory; return mTextExport.mFileDirectory;
} }
/**
* TextExport
*/
private static class TextExport { private static class TextExport {
// 定义用于查询笔记基本信息时的投影Projection数组指定要获取的列如笔记ID、修改日期、摘要、类型等
private static final String[] NOTE_PROJECTION = { private static final String[] NOTE_PROJECTION = {
NoteColumns.ID, NoteColumns.ID,
NoteColumns.MODIFIED_DATE, NoteColumns.MODIFIED_DATE,
@ -93,12 +135,14 @@ public class BackupUtils {
NoteColumns.TYPE NoteColumns.TYPE
}; };
// 对应NOTE_PROJECTION数组中笔记ID列的索引常量方便在获取游标数据时准确取值
private static final int NOTE_COLUMN_ID = 0; private static final int NOTE_COLUMN_ID = 0;
// 对应NOTE_PROJECTION数组中修改日期列的索引常量便于从游标中获取笔记的最后修改时间数据
private static final int NOTE_COLUMN_MODIFIED_DATE = 1; private static final int NOTE_COLUMN_MODIFIED_DATE = 1;
// 对应NOTE_PROJECTION数组中摘要列的索引常量用于获取笔记的摘要信息可能用于展示等用途
private static final int NOTE_COLUMN_SNIPPET = 2; private static final int NOTE_COLUMN_SNIPPET = 2;
// 定义用于查询笔记详细数据如内容、MIME类型等时的投影Projection数组明确要获取的数据列
private static final String[] DATA_PROJECTION = { private static final String[] DATA_PROJECTION = {
DataColumns.CONTENT, DataColumns.CONTENT,
DataColumns.MIME_TYPE, DataColumns.MIME_TYPE,
@ -108,23 +152,37 @@ public class BackupUtils {
DataColumns.DATA4, DataColumns.DATA4,
}; };
// 对应DATA_PROJECTION数组中内容列的索引常量用于从游标中获取笔记的文本内容数据
private static final int DATA_COLUMN_CONTENT = 0; private static final int DATA_COLUMN_CONTENT = 0;
// 对应DATA_PROJECTION数组中MIME类型列的索引常量用于判断数据的具体类型如通话记录笔记、普通文本笔记等
private static final int DATA_COLUMN_MIME_TYPE = 1; private static final int DATA_COLUMN_MIME_TYPE = 1;
// 对应DATA_PROJECTION数组中通话日期列的索引常量用于获取通话记录笔记的通话日期数据如果是通话记录类型
private static final int DATA_COLUMN_CALL_DATE = 2; private static final int DATA_COLUMN_CALL_DATE = 2;
// 对应DATA_PROJECTION数组中电话号码列的索引常量用于获取通话记录笔记的电话号码数据如果是通话记录类型
private static final int DATA_COLUMN_PHONE_NUMBER = 4; private static final int DATA_COLUMN_PHONE_NUMBER = 4;
// 用于存储文本格式化的模板字符串数组,不同索引位置对应不同用途的格式模板
private final String [] TEXT_FORMAT; private final String [] TEXT_FORMAT;
private static final int FORMAT_FOLDER_NAME = 0; // 对应TEXT_FORMAT数组中文件夹名称格式化模板的索引常量用于格式化文件夹名称的输出格式
private static final int FORMAT_NOTE_DATE = 1; private static final int FORMAT_FOLDER_NAME = 0;
private static final int FORMAT_NOTE_CONTENT = 2; // 对应TEXT_FORMAT数组中笔记日期格式化模板的索引常量用于格式化笔记修改日期等日期信息的输出格式
private static final int FORMAT_NOTE_DATE = 1;
// 对应TEXT_FORMAT数组中笔记内容格式化模板的索引常量用于格式化笔记具体内容如文本内容、电话号码等的输出格式
private static final int FORMAT_NOTE_CONTENT = 2;
// 应用程序上下文对象,用于获取系统资源、内容解析器等操作,是很多方法实现的基础依赖
private Context mContext; private Context mContext;
// 用于保存导出的文本文件的文件名,初始化为空字符串,后续在生成文件时会进行赋值
private String mFileName; private String mFileName;
// 用于保存导出的文本文件所在的目录路径,初始化为空字符串,后续根据实际情况确定目录路径并赋值
private String mFileDirectory; private String mFileDirectory;
/**
* TextExport
* TEXT_FORMAT
*
* @param context
*/
public TextExport(Context context) { public TextExport(Context context) {
TEXT_FORMAT = context.getResources().getStringArray(R.array.format_for_exported_note); TEXT_FORMAT = context.getResources().getStringArray(R.array.format_for_exported_note);
mContext = context; mContext = context;
@ -132,28 +190,40 @@ public class BackupUtils {
mFileDirectory = ""; mFileDirectory = "";
} }
/**
*
*
* @param id TEXT_FORMAT
* @return
*/
private String getFormat(int id) { private String getFormat(int id) {
return TEXT_FORMAT[id]; return TEXT_FORMAT[id];
} }
/** /**
* Export the folder identified by folder id to text * IDPrintStream
*
* 1.
* 2. exportNoteToTextPrintStream
*
* @param folderId
* @param ps PrintStream
*/ */
private void exportFolderToText(String folderId, PrintStream ps) { private void exportFolderToText(String folderId, PrintStream ps) {
// Query notes belong to this folder // 使用内容解析器查询属于该文件夹的所有笔记根据NOTE_PROJECTION指定的列和通过NoteColumns.PARENT_ID条件筛选出对应文件夹下的笔记记录
Cursor notesCursor = mContext.getContentResolver().query(Notes.CONTENT_NOTE_URI, Cursor notesCursor = mContext.getContentResolver().query(Notes.CONTENT_NOTE_URI,
NOTE_PROJECTION, NoteColumns.PARENT_ID + "=?", new String[] { NOTE_PROJECTION, NoteColumns.PARENT_ID + "=?", new String[] {
folderId folderId
}, null); }, null);
if (notesCursor != null) { if (notesCursor!= null) {
if (notesCursor.moveToFirst()) { if (notesCursor.moveToFirst()) {
do { do {
// Print note's last modified date // 按照格式化模板输出笔记的最后修改日期信息先获取格式化模板再通过DateFormat对日期进行格式化处理最后将格式化后的字符串输出到PrintStream中
ps.println(String.format(getFormat(FORMAT_NOTE_DATE), DateFormat.format( ps.println(String.format(getFormat(FORMAT_NOTE_DATE), DateFormat.format(
mContext.getString(R.string.format_datetime_mdhm), mContext.getString(R.string.format_datetime_mdhm),
notesCursor.getLong(NOTE_COLUMN_MODIFIED_DATE)))); notesCursor.getLong(NOTE_COLUMN_MODIFIED_DATE))));
// Query data belong to this note // 获取当前笔记的ID用于后续查询该笔记的详细数据
String noteId = notesCursor.getString(NOTE_COLUMN_ID); String noteId = notesCursor.getString(NOTE_COLUMN_ID);
exportNoteToText(noteId, ps); exportNoteToText(noteId, ps);
} while (notesCursor.moveToNext()); } while (notesCursor.moveToNext());
@ -163,40 +233,52 @@ public class BackupUtils {
} }
/** /**
* Export note identified by id to a print stream * IDPrintStream
* MIME
* 1. DataConstants.CALL_NOTE
* 2. DataConstants.NOTE
*
*
* @param noteId
* @param ps PrintStream
*/ */
private void exportNoteToText(String noteId, PrintStream ps) { private void exportNoteToText(String noteId, PrintStream ps) {
// 使用内容解析器查询该笔记对应的详细数据根据DATA_PROJECTION指定的列和通过DataColumns.NOTE_ID条件筛选出对应笔记的详细数据记录
Cursor dataCursor = mContext.getContentResolver().query(Notes.CONTENT_DATA_URI, Cursor dataCursor = mContext.getContentResolver().query(Notes.CONTENT_DATA_URI,
DATA_PROJECTION, DataColumns.NOTE_ID + "=?", new String[] { DATA_PROJECTION, DataColumns.NOTE_ID + "=?", new String[] {
noteId noteId
}, null); }, null);
if (dataCursor != null) { if (dataCursor!= null) {
if (dataCursor.moveToFirst()) { if (dataCursor.moveToFirst()) {
do { do {
String mimeType = dataCursor.getString(DATA_COLUMN_MIME_TYPE); String mimeType = dataCursor.getString(DATA_COLUMN_MIME_TYPE);
if (DataConstants.CALL_NOTE.equals(mimeType)) { if (DataConstants.CALL_NOTE.equals(mimeType)) {
// Print phone number // 获取通话记录笔记的电话号码信息
String phoneNumber = dataCursor.getString(DATA_COLUMN_PHONE_NUMBER); String phoneNumber = dataCursor.getString(DATA_COLUMN_PHONE_NUMBER);
// 获取通话记录笔记的通话日期信息
long callDate = dataCursor.getLong(DATA_COLUMN_CALL_DATE); long callDate = dataCursor.getLong(DATA_COLUMN_CALL_DATE);
// 获取通话记录笔记的通话附件位置信息(可能是文件路径等,具体含义取决于业务逻辑)
String location = dataCursor.getString(DATA_COLUMN_CONTENT); String location = dataCursor.getString(DATA_COLUMN_CONTENT);
if (!TextUtils.isEmpty(phoneNumber)) { if (!TextUtils.isEmpty(phoneNumber)) {
// 按照格式化模板输出电话号码信息到PrintStream中
ps.println(String.format(getFormat(FORMAT_NOTE_CONTENT), ps.println(String.format(getFormat(FORMAT_NOTE_CONTENT),
phoneNumber)); phoneNumber));
} }
// Print call date // 按照格式化模板输出通话日期信息到PrintStream中先通过DateFormat对日期进行格式化处理
ps.println(String.format(getFormat(FORMAT_NOTE_CONTENT), DateFormat ps.println(String.format(getFormat(FORMAT_NOTE_CONTENT), DateFormat
.format(mContext.getString(R.string.format_datetime_mdhm), .format(mContext.getString(R.string.format_datetime_mdhm),
callDate))); callDate)));
// Print call attachment location
if (!TextUtils.isEmpty(location)) { if (!TextUtils.isEmpty(location)) {
// 按照格式化模板输出通话附件位置信息到PrintStream中
ps.println(String.format(getFormat(FORMAT_NOTE_CONTENT), ps.println(String.format(getFormat(FORMAT_NOTE_CONTENT),
location)); location));
} }
} else if (DataConstants.NOTE.equals(mimeType)) { } else if (DataConstants.NOTE.equals(mimeType)) {
String content = dataCursor.getString(DATA_COLUMN_CONTENT); String content = dataCursor.getString(DATA_COLUMN_CONTENT);
if (!TextUtils.isEmpty(content)) { if (!TextUtils.isEmpty(content)) {
// 按照格式化模板输出普通文本笔记的内容信息到PrintStream中
ps.println(String.format(getFormat(FORMAT_NOTE_CONTENT), ps.println(String.format(getFormat(FORMAT_NOTE_CONTENT),
content)); content));
} }
@ -205,7 +287,7 @@ public class BackupUtils {
} }
dataCursor.close(); dataCursor.close();
} }
// print a line separator between note // 在每个笔记数据输出后,添加一个换行符和一个特殊字符(此处可能用于分隔不同笔记数据,具体用途需结合更多上下文判断)
try { try {
ps.write(new byte[] { ps.write(new byte[] {
Character.LINE_SEPARATOR, Character.LETTER_NUMBER Character.LINE_SEPARATOR, Character.LETTER_NUMBER
@ -215,8 +297,45 @@ public class BackupUtils {
} }
} }
/** /**
* Note will be exported as text which is user readable *
*
*
* 1. SD `externalStorageAvailable`
* DEBUG `STATE_SD_CARD_UNMOUONTED`
*
*
* 2. `PrintStream` `getExportToTextPrintStream`
* ERROR
* `STATE_SYSTEM_ERROR`
*
* 3.
* - `mContext.getContentResolver().query`
* `NoteColumns.TYPE = Notes.TYPE_FOLDER`IDID`NoteColumns.PARENT_ID <> Notes.ID_TRASH_FOLER`
* IDID`NoteColumns.ID = Notes.ID_CALL_RECORD_FOLDER` `NOTE_PROJECTION`
* -
* - IDIDID
* `mContext.getString(R.string.call_record_folder_name)`
* `NOTE_COLUMN_SNIPPET`
* - `getFormat(FORMAT_FOLDER_NAME)`
* 使 `String.format` `PrintStream`
* - ID `exportFolderToText` `PrintStream`
* -
*
* 4.
* - `mContext.getContentResolver().query`
* `NoteColumns.TYPE = Notes.TYPE_NOTE`ID0 `NOTE_PROJECTION`
* -
* - `getFormat(FORMAT_NOTE_DATE)` `DateFormat`
* 使 `String.format` `PrintStream`
* - ID `exportNoteToText`
* `PrintStream`
* -
*
* 5. `PrintStream` `STATE_SUCCESS`
*
* @return `STATE_*` `STATE_SD_CARD_UNMOUONTED``STATE_SYSTEM_ERROR` `STATE_SUCCESS`
*/ */
public int exportToText() { public int exportToText() {
if (!externalStorageAvailable()) { if (!externalStorageAvailable()) {
@ -237,12 +356,12 @@ public class BackupUtils {
+ NoteColumns.PARENT_ID + "<>" + Notes.ID_TRASH_FOLER + ") OR " + NoteColumns.PARENT_ID + "<>" + Notes.ID_TRASH_FOLER + ") OR "
+ NoteColumns.ID + "=" + Notes.ID_CALL_RECORD_FOLDER, null, null); + NoteColumns.ID + "=" + Notes.ID_CALL_RECORD_FOLDER, null, null);
if (folderCursor != null) { if (folderCursor!= null) {
if (folderCursor.moveToFirst()) { if (folderCursor.moveToFirst()) {
do { do {
// Print folder's name // Print folder's name
String folderName = ""; String folderName = "";
if(folderCursor.getLong(NOTE_COLUMN_ID) == Notes.ID_CALL_RECORD_FOLDER) { if (folderCursor.getLong(NOTE_COLUMN_ID) == Notes.ID_CALL_RECORD_FOLDER) {
folderName = mContext.getString(R.string.call_record_folder_name); folderName = mContext.getString(R.string.call_record_folder_name);
} else { } else {
folderName = folderCursor.getString(NOTE_COLUMN_SNIPPET); folderName = folderCursor.getString(NOTE_COLUMN_SNIPPET);
@ -261,10 +380,10 @@ public class BackupUtils {
Cursor noteCursor = mContext.getContentResolver().query( Cursor noteCursor = mContext.getContentResolver().query(
Notes.CONTENT_NOTE_URI, Notes.CONTENT_NOTE_URI,
NOTE_PROJECTION, NOTE_PROJECTION,
NoteColumns.TYPE + "=" + +Notes.TYPE_NOTE + " AND " + NoteColumns.PARENT_ID NoteColumns.TYPE + "=" + +Notes.TYPE_NOTE + "AND" + NoteColumns.PARENT_ID
+ "=0", null, null); + "=0", null, null);
if (noteCursor != null) { if (noteCursor!= null) {
if (noteCursor.moveToFirst()) { if (noteCursor.moveToFirst()) {
do { do {
ps.println(String.format(getFormat(FORMAT_NOTE_DATE), DateFormat.format( ps.println(String.format(getFormat(FORMAT_NOTE_DATE), DateFormat.format(
@ -283,7 +402,26 @@ public class BackupUtils {
} }
/** /**
* Get a print stream pointed to the file {@generateExportedTextFile} * `PrintStream`
*
*
* 1. `generateFileMountedOnSDcard` SD
* IDID
*
* 2. `generateFileMountedOnSDcard` `null`ERROR
* `null` `PrintStream`
*
* 3. `mFileName` 便
* `mContext.getString(R.string.file_path)` `mFileDirectory`
* 便
*
* 4. `FileOutputStream` `FileOutputStream` `PrintStream`
* `FileOutputStream` `PrintStream` `FileNotFoundException`
* `NullPointerException` `null` `PrintStream`
*
* 5. `PrintStream` 使 `PrintStream`
*
* @return `PrintStream` `null`
*/ */
private PrintStream getExportToTextPrintStream() { private PrintStream getExportToTextPrintStream() {
File file = generateFileMountedOnSDcard(mContext, R.string.file_path, File file = generateFileMountedOnSDcard(mContext, R.string.file_path,
@ -310,7 +448,32 @@ public class BackupUtils {
} }
/** /**
* Generate the text file to store imported data * SD
*
*
* 1. `StringBuilder`
* `Environment.getExternalStorageDirectory()` `StringBuilder`
* `context.getString(filePathResId)`
*
* 2. `StringBuilder`
* 使 `DateFormat.format` `System.currentTimeMillis()` `format_date_ymd`
* 便
*
* 3. `File`
*
* 4. `filedir.mkdir()` `SecurityException`
*
*
* 5. `file.createNewFile()` `IOException`
*
*
* 6. `File`
* `null`
*
* @param context
* @param filePathResId ID
* @param fileNameFormatResId ID
* @return `null`
*/ */
private static File generateFileMountedOnSDcard(Context context, int filePathResId, int fileNameFormatResId) { private static File generateFileMountedOnSDcard(Context context, int filePathResId, int fileNameFormatResId) {
StringBuilder sb = new StringBuilder(); StringBuilder sb = new StringBuilder();
@ -339,6 +502,6 @@ public class BackupUtils {
return null; return null;
} }
} }}

@ -36,107 +36,185 @@ import java.util.HashSet;
public class DataUtils { public class DataUtils {
// 用于日志记录的标签,方便在日志输出中准确识别该类相关的操作记录,利于调试和问题排查
public static final String TAG = "DataUtils"; public static final String TAG = "DataUtils";
/**
* ContentResolverIDHashSet<Long>
*
* @param resolver 访
* @param ids LongHashSetnull
* @return truefalse
*/
public static boolean batchDeleteNotes(ContentResolver resolver, HashSet<Long> ids) { public static boolean batchDeleteNotes(ContentResolver resolver, HashSet<Long> ids) {
// 如果传入的ids集合为null说明没有指定要删除的笔记ID在日志中记录相应信息日志级别为DEBUG并直接返回true表示无需进行实际删除操作。
if (ids == null) { if (ids == null) {
Log.d(TAG, "the ids is null"); Log.d(TAG, "the ids is null");
return true; return true;
} }
// 如果ids集合大小为0意味着集合中没有包含有效的笔记ID同样在日志中记录信息日志级别为DEBUG然后返回true表示没有笔记可删除。
if (ids.size() == 0) { if (ids.size() == 0) {
Log.d(TAG, "no id is in the hashset"); Log.d(TAG, "no id is in the hashset");
return true; return true;
} }
// 创建一个用于存储内容提供器操作ContentProviderOperation的列表后续将把要执行的删除操作添加到这个列表中。
ArrayList<ContentProviderOperation> operationList = new ArrayList<ContentProviderOperation>(); ArrayList<ContentProviderOperation> operationList = new ArrayList<ContentProviderOperation>();
// 遍历传入的ids集合对每个要删除的笔记ID进行处理
for (long id : ids) { for (long id : ids) {
if(id == Notes.ID_ROOT_FOLDER) { // 如果笔记ID是系统根文件夹的IDNotes.ID_ROOT_FOLDER则不允许删除该系统文件夹在日志中记录错误信息日志级别为ERROR并跳过本次循环继续处理下一个ID。
if (id == Notes.ID_ROOT_FOLDER) {
Log.e(TAG, "Don't delete system folder root"); Log.e(TAG, "Don't delete system folder root");
continue; continue;
} }
// 创建一个用于删除操作的ContentProviderOperation构建器指定要删除的笔记的URI通过ContentUris.withAppendedId方法根据笔记ID构建对应的URI
ContentProviderOperation.Builder builder = ContentProviderOperation ContentProviderOperation.Builder builder = ContentProviderOperation
.newDelete(ContentUris.withAppendedId(Notes.CONTENT_NOTE_URI, id)); .newDelete(ContentUris.withAppendedId(Notes.CONTENT_NOTE_URI, id));
// 将构建好的删除操作添加到操作列表中。
operationList.add(builder.build()); operationList.add(builder.build());
} }
try { try {
// 通过内容解析器执行批量操作传入内容提供器的授权信息Notes.AUTHORITY和操作列表获取操作结果数组ContentProviderResult[])。
ContentProviderResult[] results = resolver.applyBatch(Notes.AUTHORITY, operationList); ContentProviderResult[] results = resolver.applyBatch(Notes.AUTHORITY, operationList);
// 如果操作结果数组为null或者数组长度为0或者数组中第一个元素为null表示删除操作失败在日志中记录相应信息日志级别为DEBUG并返回false。
if (results == null || results.length == 0 || results[0] == null) { if (results == null || results.length == 0 || results[0] == null) {
Log.d(TAG, "delete notes failed, ids:" + ids.toString()); Log.d(TAG, "delete notes failed, ids:" + ids.toString());
return false; return false;
} }
// 如果操作结果正常表示删除操作成功返回true。
return true; return true;
} catch (RemoteException e) { } catch (RemoteException e) {
// 如果出现远程异常RemoteException通常是在与内容提供器进行远程通信时出现问题在日志中记录详细的异常信息包括异常的类名和具体消息异常级别为ERROR。
Log.e(TAG, String.format("%s: %s", e.toString(), e.getMessage())); Log.e(TAG, String.format("%s: %s", e.toString(), e.getMessage()));
} catch (OperationApplicationException e) { } catch (OperationApplicationException e) {
// 如果出现操作应用异常OperationApplicationException一般是在应用执行批量操作时出现问题同样在日志中记录详细异常信息日志级别为ERROR
Log.e(TAG, String.format("%s: %s", e.toString(), e.getMessage())); Log.e(TAG, String.format("%s: %s", e.toString(), e.getMessage()));
} }
// 如果出现异常导致删除操作未能成功完成返回false。
return false; return false;
} }
/**
* ID
*
* @param resolver 访
* @param id Long
* @param srcFolderId ID
* @param desFolderId ID
*/
public static void moveNoteToFoler(ContentResolver resolver, long id, long srcFolderId, long desFolderId) { public static void moveNoteToFoler(ContentResolver resolver, long id, long srcFolderId, long desFolderId) {
// 创建一个ContentValues对象用于存储要更新的键值对即笔记的相关属性及其新的值。
ContentValues values = new ContentValues(); ContentValues values = new ContentValues();
// 设置笔记的新父文件夹ID即目标文件夹ID将其放入ContentValues中键为NoteColumns.PARENT_ID。
values.put(NoteColumns.PARENT_ID, desFolderId); values.put(NoteColumns.PARENT_ID, desFolderId);
// 设置笔记的原始父文件夹ID即当前所在文件夹ID键为NoteColumns.ORIGIN_PARENT_ID可能用于后续追溯笔记的移动历史等情况。
values.put(NoteColumns.ORIGIN_PARENT_ID, srcFolderId); values.put(NoteColumns.ORIGIN_PARENT_ID, srcFolderId);
// 设置笔记的本地修改标志为1表示该笔记有本地修改这里的修改指的是移动操作导致的变化键为NoteColumns.LOCAL_MODIFIED。
values.put(NoteColumns.LOCAL_MODIFIED, 1); values.put(NoteColumns.LOCAL_MODIFIED, 1);
// 通过内容解析器根据笔记的URI通过ContentUris.withAppendedId方法根据笔记ID构建更新笔记的属性传入ContentValues对象以及其他相关参数此处后两个参数为null表示无额外的筛选条件和排序方式
resolver.update(ContentUris.withAppendedId(Notes.CONTENT_NOTE_URI, id), values, null, null); resolver.update(ContentUris.withAppendedId(Notes.CONTENT_NOTE_URI, id), values, null, null);
} }
/**
*
*
* @param resolver 访
* @param ids LongHashSetnull
* @param folderId ID
* @return truefalse
*/
public static boolean batchMoveToFolder(ContentResolver resolver, HashSet<Long> ids, public static boolean batchMoveToFolder(ContentResolver resolver, HashSet<Long> ids,
long folderId) { long folderId) {
// 如果传入的ids集合为null说明没有指定要移动的笔记ID在日志中记录相应信息日志级别为DEBUG并直接返回true表示无需进行实际移动操作。
if (ids == null) { if (ids == null) {
Log.d(TAG, "the ids is null"); Log.d(TAG, "the ids is null");
return true; return true;
} }
// 创建一个用于存储内容提供器操作ContentProviderOperation的列表后续将把要执行的批量移动操作添加到这个列表中。
ArrayList<ContentProviderOperation> operationList = new ArrayList<ContentProviderOperation>(); ArrayList<ContentProviderOperation> operationList = new ArrayList<ContentProviderOperation>();
// 遍历传入的ids集合对每个要移动的笔记ID进行处理构建相应的更新操作。
for (long id : ids) { for (long id : ids) {
// 创建一个用于更新操作的ContentProviderOperation构建器指定要更新的笔记的URI通过ContentUris.withAppendedId方法根据笔记ID构建对应的URI
ContentProviderOperation.Builder builder = ContentProviderOperation ContentProviderOperation.Builder builder = ContentProviderOperation
.newUpdate(ContentUris.withAppendedId(Notes.CONTENT_NOTE_URI, id)); .newUpdate(ContentUris.withAppendedId(Notes.CONTENT_NOTE_URI, id));
// 设置笔记的新父文件夹ID即目标文件夹ID通过withValue方法将其添加到更新操作构建器中键为NoteColumns.PARENT_ID。
builder.withValue(NoteColumns.PARENT_ID, folderId); builder.withValue(NoteColumns.PARENT_ID, folderId);
// 设置笔记的本地修改标志为1表示该笔记有本地修改这里的修改指的是移动操作导致的变化键为NoteColumns.LOCAL_MODIFIED。
builder.withValue(NoteColumns.LOCAL_MODIFIED, 1); builder.withValue(NoteColumns.LOCAL_MODIFIED, 1);
// 将构建好的更新操作添加到操作列表中。
operationList.add(builder.build()); operationList.add(builder.build());
} }
try { try {
// 通过内容解析器执行批量操作传入内容提供器的授权信息Notes.AUTHORITY和操作列表获取操作结果数组ContentProviderResult[])。
ContentProviderResult[] results = resolver.applyBatch(Notes.AUTHORITY, operationList); ContentProviderResult[] results = resolver.applyBatch(Notes.AUTHORITY, operationList);
// 如果操作结果数组为null或者数组长度为0或者数组中第一个元素为null表示批量移动操作失败在日志中记录相应信息日志级别为DEBUG并返回false。
if (results == null || results.length == 0 || results[0] == null) { if (results == null || results.length == 0 || results[0] == null) {
Log.d(TAG, "delete notes failed, ids:" + ids.toString()); Log.d(TAG, "delete notes failed, ids:" + ids.toString());
return false; return false;
} }
// 如果操作结果正常表示批量移动操作成功返回true。
return true; return true;
} catch (RemoteException e) { } catch (RemoteException e) {
// 如果出现远程异常RemoteException通常是在与内容提供器进行远程通信时出现问题在日志中记录详细的异常信息包括异常的类名和具体消息异常级别为ERROR。
Log.e(TAG, String.format("%s: %s", e.toString(), e.getMessage())); Log.e(TAG, String.format("%s: %s", e.toString(), e.getMessage()));
} catch (OperationApplicationException e) { } catch (OperationApplicationException e) {
// 如果出现操作应用异常OperationApplicationException一般是在应用执行批量操作时出现问题同样在日志中记录详细异常信息日志级别为ERROR
Log.e(TAG, String.format("%s: %s", e.toString(), e.getMessage())); Log.e(TAG, String.format("%s: %s", e.toString(), e.getMessage()));
} }
// 如果出现异常导致批量移动操作未能成功完成返回false。
return false; return false;
} }
/** /**
* Get the all folder count except system folders {@link Notes#TYPE_SYSTEM}} *
*
* @param resolver 访
* @return int
*/ */
public static int getUserFolderCount(ContentResolver resolver) { public static int getUserFolderCount(ContentResolver resolver) {
Cursor cursor =resolver.query(Notes.CONTENT_NOTE_URI, // 通过内容解析器查询数据库指定查询的URI为Notes.CONTENT_NOTE_URI表示笔记相关的数据表因为文件夹信息也存储在该表中可能通过类型等字段区分
// 要获取的列是"COUNT(*)",表示统计符合条件的记录数量。
// 查询条件是类型为文件夹NoteColumns.TYPE + "=?且父文件夹ID不等于回收站文件夹IDNoteColumns.PARENT_ID + "<>?"),通过传入对应的参数值来筛选出用户创建的非回收站文件夹。
Cursor cursor = resolver.query(Notes.CONTENT_NOTE_URI,
new String[] { "COUNT(*)" }, new String[] { "COUNT(*)" },
NoteColumns.TYPE + "=? AND " + NoteColumns.PARENT_ID + "<>?", NoteColumns.TYPE + "=? AND " + NoteColumns.PARENT_ID + "<>?",
new String[] { String.valueOf(Notes.TYPE_FOLDER), String.valueOf(Notes.ID_TRASH_FOLER)}, new String[] { String.valueOf(Notes.TYPE_FOLDER), String.valueOf(Notes.ID_TRASH_FOLER)},
null); null);
int count = 0; int count = 0;
if(cursor != null) { // 如果查询到的游标Cursor不为null说明获取到了有效的查询结果尝试获取数据。
if(cursor.moveToFirst()) { if (cursor!= null) {
// 将游标移动到第一条记录(如果有数据的话),因为查询结果只有一条记录(统计数量的结果),所以只需要获取这一条记录中的数据即可。
if (cursor.moveToFirst()) {
try { try {
// 尝试从游标中获取第一个列索引为0的数据这里就是统计得到的文件夹数量将其赋值给count变量。
count = cursor.getInt(0); count = cursor.getInt(0);
} catch (IndexOutOfBoundsException e) { } catch (IndexOutOfBoundsException e) {
// 如果出现索引越界异常IndexOutOfBoundsException通常是获取数据的索引超出了游标实际包含的列范围在日志中记录详细的异常信息日志级别为ERROR
Log.e(TAG, "get folder count failed:" + e.toString()); Log.e(TAG, "get folder count failed:" + e.toString());
} finally { } finally {
// 无论是否成功获取到数量数据,都需要关闭游标,释放相关资源。
cursor.close(); cursor.close();
} }
} }
} }
// 返回统计得到的用户文件夹数量。
return count; return count;
} }
/**
*
*
* @param resolver 访
* @param noteId Long
* @param type
* @return truefalse
*/
public static boolean visibleInNoteDatabase(ContentResolver resolver, long noteId, int type) { public static boolean visibleInNoteDatabase(ContentResolver resolver, long noteId, int type) {
// 通过内容解析器查询数据库指定查询的URI为Notes.CONTENT_NOTE_URI对应笔记数据表查询条件是类型为指定类型NoteColumns.TYPE + "=?且父文件夹ID不等于回收站文件夹IDNoteColumns.PARENT_ID + "<>" + Notes.ID_TRASH_FOLER传入对应的参数值进行筛选。
Cursor cursor = resolver.query(ContentUris.withAppendedId(Notes.CONTENT_NOTE_URI, noteId), Cursor cursor = resolver.query(ContentUris.withAppendedId(Notes.CONTENT_NOTE_URI, noteId),
null, null,
NoteColumns.TYPE + "=? AND " + NoteColumns.PARENT_ID + "<>" + Notes.ID_TRASH_FOLER, NoteColumns.TYPE + "=? AND " + NoteColumns.PARENT_ID + "<>" + Notes.ID_TRASH_FOLER,
@ -144,60 +222,114 @@ public class DataUtils {
null); null);
boolean exist = false; boolean exist = false;
if (cursor != null) { // 如果查询到的游标Cursor不为null说明获取到了有效的查询结果进一步判断是否有符合条件的记录存在。
if (cursor!= null) {
// 通过获取游标中的记录数量来判断是否存在符合条件的笔记如果记录数量大于0表示存在将exist变量设置为true。
if (cursor.getCount() > 0) { if (cursor.getCount() > 0) {
exist = true; exist = true;
} }
// 关闭游标,释放相关资源。
cursor.close(); cursor.close();
} }
// 返回笔记是否存在(即是否可见)的判断结果。
return exist; return exist;
} }
/**
* ID
*
* @param resolver 访
* @param noteId Long
* @return truefalse
*/
public static boolean existInNoteDatabase(ContentResolver resolver, long noteId) { public static boolean existInNoteDatabase(ContentResolver resolver, long noteId) {
// 通过内容解析器查询数据库指定查询的URI为Notes.CONTENT_NOTE_URI对应笔记数据表此处查询条件为空即查询所有记录尝试查找是否存在指定笔记ID的记录。
Cursor cursor = resolver.query(ContentUris.withAppendedId(Notes.CONTENT_NOTE_URI, noteId), Cursor cursor = resolver.query(ContentUris.withAppendedId(Notes.CONTENT_NOTE_URI, noteId),
null, null, null, null); null, null, null, null);
boolean exist = false; boolean exist = false;
if (cursor != null) { // 如果查询到的游标Cursor不为null说明获取到了有效的查询结果进一步判断是否有符合条件的记录存在。
if (cursor!= null) {
// 通过获取游标中的记录数量来判断是否存在符合条件的笔记如果记录数量大于0表示存在将exist变量设置为true。
if (cursor.getCount() > 0) { if (cursor.getCount() > 0) {
exist = true; exist = true;
} }
// 关闭游标,释放相关资源。
cursor.close(); cursor.close();
} }
// 返回笔记是否存在的判断结果。
return exist; return exist;
} }
/**
*
* 使 `ContentResolver` `Notes.CONTENT_DATA_URI`
* `null`ID
*
* @param resolver `ContentResolver`
* @param dataId
* @return `dataId` `true` `false`
*/
public static boolean existInDataDatabase(ContentResolver resolver, long dataId) { public static boolean existInDataDatabase(ContentResolver resolver, long dataId) {
// 使用ContentResolver发起查询操作查询的URI是Notes.CONTENT_DATA_URI对应特定的数据表
// 传入的查询条件等参数都为null表示查询所有记录只是依据传入的数据ID来定位可能存在的记录。
Cursor cursor = resolver.query(ContentUris.withAppendedId(Notes.CONTENT_DATA_URI, dataId), Cursor cursor = resolver.query(ContentUris.withAppendedId(Notes.CONTENT_DATA_URI, dataId),
null, null, null, null); null, null, null, null);
boolean exist = false; boolean exist = false;
if (cursor != null) { // 如果查询返回的游标Cursor不为null说明查询有结果进一步判断游标中是否有记录即记录数量大于0
if (cursor!= null) {
if (cursor.getCount() > 0) { if (cursor.getCount() > 0) {
exist = true; exist = true;
} }
// 关闭游标,释放相关资源,避免内存泄漏等问题。
cursor.close(); cursor.close();
} }
return exist; return exist;
} }
/**
*
* `ContentResolver` `Notes.CONTENT_NOTE_URI`
*
* @param resolver `ContentResolver`
* @param name
* @return `name` `true` `false`
*/
public static boolean checkVisibleFolderName(ContentResolver resolver, String name) { public static boolean checkVisibleFolderName(ContentResolver resolver, String name) {
// 使用ContentResolver发起查询操作查询的URI为Notes.CONTENT_NOTE_URI对应笔记相关的数据表
// 查询条件设定为筛选出类型是文件夹NoteColumns.TYPE + "=" + Notes.TYPE_FOLDER、父文件夹ID不等于回收站文件夹IDNoteColumns.PARENT_ID + "<>" + Notes.ID_TRASH_FOLER
// 且文件夹摘要(可能用于显示文件夹名称等,此处对应条件判断)等于传入的 `name` 的记录,通过传入的 `name` 参数构建查询条件中的参数值。
Cursor cursor = resolver.query(Notes.CONTENT_NOTE_URI, null, Cursor cursor = resolver.query(Notes.CONTENT_NOTE_URI, null,
NoteColumns.TYPE + "=" + Notes.TYPE_FOLDER + NoteColumns.TYPE + "=" + Notes.TYPE_FOLDER +
" AND " + NoteColumns.PARENT_ID + "<>" + Notes.ID_TRASH_FOLER + " AND " + NoteColumns.PARENT_ID + "<>" + Notes.ID_TRASH_FOLER +
" AND " + NoteColumns.SNIPPET + "=?", " AND " + NoteColumns.SNIPPET + "=?",
new String[] { name }, null); new String[] { name }, null);
boolean exist = false; boolean exist = false;
if(cursor != null) { // 如果查询返回的游标Cursor不为null说明查询有结果进一步判断游标中是否有记录即记录数量大于0
if(cursor.getCount() > 0) { if (cursor!= null) {
if (cursor.getCount() > 0) {
exist = true; exist = true;
} }
// 关闭游标,释放相关资源。
cursor.close(); cursor.close();
} }
return exist; return exist;
} }
/**
* Widget `HashSet`
* `ContentResolver` `Notes.CONTENT_NOTE_URI` `folderId`ID
* `AppWidgetAttribute` `HashSet`
*
* @param resolver `ContentResolver`
* @param folderId
* @return `HashSet` `null`
*/
public static HashSet<AppWidgetAttribute> getFolderNoteWidget(ContentResolver resolver, long folderId) { public static HashSet<AppWidgetAttribute> getFolderNoteWidget(ContentResolver resolver, long folderId) {
// 使用ContentResolver发起查询操作查询的URI为Notes.CONTENT_NOTE_URI对应笔记相关数据表
// 查询的列指定为NoteColumns.WIDGET_ID小部件ID和NoteColumns.WIDGET_TYPE小部件类型
// 查询条件设定为筛选出父文件夹ID等于传入的 `folderId` 的记录,通过传入的 `folderId` 参数构建查询条件中的参数值。
Cursor c = resolver.query(Notes.CONTENT_NOTE_URI, Cursor c = resolver.query(Notes.CONTENT_NOTE_URI,
new String[] { NoteColumns.WIDGET_ID, NoteColumns.WIDGET_TYPE }, new String[] { NoteColumns.WIDGET_ID, NoteColumns.WIDGET_TYPE },
NoteColumns.PARENT_ID + "=?", NoteColumns.PARENT_ID + "=?",
@ -205,91 +337,153 @@ public class DataUtils {
null); null);
HashSet<AppWidgetAttribute> set = null; HashSet<AppWidgetAttribute> set = null;
if (c != null) { // 如果查询返回的游标Cursor不为null说明查询有结果进一步处理获取到的数据。
if (c!= null) {
if (c.moveToFirst()) { if (c.moveToFirst()) {
set = new HashSet<AppWidgetAttribute>(); set = new HashSet<AppWidgetAttribute>();
do { do {
try { try {
// 创建一个AppWidgetAttribute对象用于封装小部件的属性信息。
AppWidgetAttribute widget = new AppWidgetAttribute(); AppWidgetAttribute widget = new AppWidgetAttribute();
// 从游标中获取小部件ID并赋值给AppWidgetAttribute对象的widgetId属性这里依据查询时指定的列顺序获取对应列的数据。
widget.widgetId = c.getInt(0); widget.widgetId = c.getInt(0);
// 从游标中获取小部件类型并赋值给AppWidgetAttribute对象的widgetType属性。
widget.widgetType = c.getInt(1); widget.widgetType = c.getInt(1);
// 将封装好小部件属性信息的AppWidgetAttribute对象添加到HashSet集合中。
set.add(widget); set.add(widget);
} catch (IndexOutOfBoundsException e) { } catch (IndexOutOfBoundsException e) {
// 如果在获取游标数据时出现索引越界异常例如获取的列索引超出了实际查询到的列范围则记录错误日志日志级别为ERROR。
Log.e(TAG, e.toString()); Log.e(TAG, e.toString());
} }
} while (c.moveToNext()); } while (c.moveToNext());
} }
// 关闭游标,释放相关资源。
c.close(); c.close();
} }
return set; return set;
} }
/**
* ID
* `ContentResolver` `Notes.CONTENT_DATA_URI` IDMIME
*
* @param resolver `ContentResolver`
* @param noteId
* @return ID ""
*/
public static String getCallNumberByNoteId(ContentResolver resolver, long noteId) { public static String getCallNumberByNoteId(ContentResolver resolver, long noteId) {
// 使用ContentResolver发起查询操作查询的URI为Notes.CONTENT_DATA_URI对应笔记相关的数据表可能包含通话记录等详细数据
// 查询的列指定为CallNote.PHONE_NUMBER表示电话号码的列
// 查询条件设定为筛选出笔记ID等于传入的 `noteId` 且MIME类型等于CallNote.CONTENT_ITEM_TYPE特定的MIME类型可能用于标识通话记录相关的数据类型的记录
// 通过传入的 `noteId` 和 `CallNote.CONTENT_ITEM_TYPE` 参数构建查询条件中的参数值。
Cursor cursor = resolver.query(Notes.CONTENT_DATA_URI, Cursor cursor = resolver.query(Notes.CONTENT_DATA_URI,
new String [] { CallNote.PHONE_NUMBER }, new String [] { CallNote.PHONE_NUMBER },
CallNote.NOTE_ID + "=? AND " + CallNote.MIME_TYPE + "=?", CallNote.NOTE_ID + "=? AND " + CallNote.MIME_TYPE + "=?",
new String [] { String.valueOf(noteId), CallNote.CONTENT_ITEM_TYPE }, new String [] { String.valueOf(noteId), CallNote.CONTENT_ITEM_TYPE },
null); null);
if (cursor != null && cursor.moveToFirst()) { if (cursor!= null && cursor.moveToFirst()) {
try { try {
// 尝试从游标中获取第一个列因为查询时只指定了获取电话号码这一列索引为0的数据即电话号码信息并返回。
return cursor.getString(0); return cursor.getString(0);
} catch (IndexOutOfBoundsException e) { } catch (IndexOutOfBoundsException e) {
// 如果在获取游标数据时出现索引越界异常则记录错误日志日志级别为ERROR记录详细的异常信息。
Log.e(TAG, "Get call number fails " + e.toString()); Log.e(TAG, "Get call number fails " + e.toString());
} finally { } finally {
// 无论是否成功获取到电话号码,都要关闭游标,释放相关资源。
cursor.close(); cursor.close();
} }
} }
return ""; return "";
} }
/**
* ID
* `ContentResolver` `Notes.CONTENT_DATA_URI` MIMEID
*
* @param resolver `ContentResolver` ID
* @param phoneNumber ID
* @param callDate
* @return MIMEID0
*/
public static long getNoteIdByPhoneNumberAndCallDate(ContentResolver resolver, String phoneNumber, long callDate) { public static long getNoteIdByPhoneNumberAndCallDate(ContentResolver resolver, String phoneNumber, long callDate) {
// 使用ContentResolver发起查询操作查询的URI为Notes.CONTENT_DATA_URI对应笔记相关的数据表包含通话记录等详细数据
// 查询的列指定为CallNote.NOTE_ID表示笔记ID的列
// 查询条件设定为筛选出通话日期等于传入的 `callDate`、MIME类型等于CallNote.CONTENT_ITEM_TYPE特定的MIME类型标识通话记录相关数据类型
// 并且电话号码通过自定义函数PHONE_NUMBERS_EQUAL具体实现可能在别处用于更准确地匹配电话号码匹配传入的 `phoneNumber` 的记录,
// 通过传入的 `callDate`、`CallNote.CONTENT_ITEM_TYPE` 和 `phoneNumber` 参数构建查询条件中的参数值。
Cursor cursor = resolver.query(Notes.CONTENT_DATA_URI, Cursor cursor = resolver.query(Notes.CONTENT_DATA_URI,
new String [] { CallNote.NOTE_ID }, new String [] { CallNote.NOTE_ID },
CallNote.CALL_DATE + "=? AND " + CallNote.MIME_TYPE + "=? AND PHONE_NUMBERS_EQUAL(" CallNote.CALL_DATE + "=? AND " + CallNote.MIME_TYPE + "=? AND PHONE_NUMBERS_EQUAL("
+ CallNote.PHONE_NUMBER + ",?)", + CallNote.PHONE_NUMBER + ",?)",
new String [] { String.valueOf(callDate), CallNote.CONTENT_ITEM_TYPE, phoneNumber }, new String [] { String.valueOf(callDate), CallNote.CONTENT_ITEM_TYPE, phoneNumber },
null); null);
if (cursor != null) { if (cursor!= null) {
if (cursor.moveToFirst()) { if (cursor.moveToFirst()) {
try { try {
// 尝试从游标中获取第一个列因为查询时只指定了获取笔记ID这一列索引为0的数据即笔记ID信息并返回。
return cursor.getLong(0); return cursor.getLong(0);
} catch (IndexOutOfBoundsException e) { } catch (IndexOutOfBoundsException e) {
// 如果在获取游标数据时出现索引越界异常则记录错误日志日志级别为ERROR记录详细的异常信息。
Log.e(TAG, "Get call note id fails " + e.toString()); Log.e(TAG, "Get call note id fails " + e.toString());
} }
} }
// 关闭游标,释放相关资源。
cursor.close(); cursor.close();
} }
return 0; return 0;
} }
/**
* IDSnippet
* `ContentResolver` `Notes.CONTENT_NOTE_URI` ID
* ID `IllegalArgumentException`
*
* @param resolver `ContentResolver`
* @param noteId
* @return ID `IllegalArgumentException`
*/
public static String getSnippetById(ContentResolver resolver, long noteId) { public static String getSnippetById(ContentResolver resolver, long noteId) {
// 使用ContentResolver发起查询操作查询的URI为Notes.CONTENT_NOTE_URI对应笔记相关的数据表
// 查询的列指定为NoteColumns.SNIPPET表示摘要的列
// 查询条件设定为筛选出笔记ID等于传入的 `noteId` 的记录,通过传入的 `noteId` 参数构建查询条件中的参数值。
Cursor cursor = resolver.query(Notes.CONTENT_NOTE_URI, Cursor cursor = resolver.query(Notes.CONTENT_NOTE_URI,
new String [] { NoteColumns.SNIPPET }, new String [] { NoteColumns.SNIPPET },
NoteColumns.ID + "=?", NoteColumns.ID + "=?",
new String [] { String.valueOf(noteId)}, new String [] { String.valueOf(noteId)},
null); null);
if (cursor != null) { if (cursor!= null) {
String snippet = ""; String snippet = "";
if (cursor.moveToFirst()) { if (cursor.moveToFirst()) {
// 尝试从游标中获取第一个列因为查询时只指定了获取摘要这一列索引为0的数据即摘要信息并赋值给变量 `snippet`。
snippet = cursor.getString(0); snippet = cursor.getString(0);
} }
// 关闭游标,释放相关资源。
cursor.close(); cursor.close();
return snippet; return snippet;
} }
throw new IllegalArgumentException("Note is not found with id: " + noteId); throw new IllegalArgumentException("Note is not found with id: " + noteId);
} }
/**
* Snippet
* `\n`
*
* @param snippet
* @return
*/
public static String getFormattedSnippet(String snippet) { public static String getFormattedSnippet(String snippet) {
if (snippet != null) { if (snippet!= null) {
// 去除字符串前后的空白字符调用trim方法进行处理。
snippet = snippet.trim(); snippet = snippet.trim();
int index = snippet.indexOf('\n'); int index = snippet.indexOf('\n');
if (index != -1) { if (index!= -1) {
// 如果字符串中包含换行符截取换行符之前的部分作为最终的格式化后的字符串通过substring方法实现截取操作。
snippet = snippet.substring(0, index); snippet = snippet.substring(0, index);
} }
} }
return snippet; return snippet;
} }
} }

@ -18,96 +18,141 @@ package net.micode.notes.tool;
public class GTaskStringUtils { public class GTaskStringUtils {
// 用于表示在 GTask 相关 JSON 数据中 "action_id" 字段的名称,可能在处理 GTask 操作的唯一标识符相关逻辑时使用。
public final static String GTASK_JSON_ACTION_ID = "action_id"; public final static String GTASK_JSON_ACTION_ID = "action_id";
// 用于表示在 GTask 相关 JSON 数据中 "action_list" 字段的名称,推测可能用于存放一系列操作相关信息的列表,具体用途取决于 GTask 相关业务逻辑。
public final static String GTASK_JSON_ACTION_LIST = "action_list"; public final static String GTASK_JSON_ACTION_LIST = "action_list";
// 用于表示在 GTask 相关 JSON 数据中 "action_type" 字段的名称,该字段用于标识操作的类型,不同的操作类型对应不同的业务动作。
public final static String GTASK_JSON_ACTION_TYPE = "action_type"; public final static String GTASK_JSON_ACTION_TYPE = "action_type";
// 用于表示在 GTask 相关 JSON 数据中一种具体的操作类型 "create",即创建操作,可能用于创建任务、列表等 GTask 相关实体。
public final static String GTASK_JSON_ACTION_TYPE_CREATE = "create"; public final static String GTASK_JSON_ACTION_TYPE_CREATE = "create";
// 用于表示在 GTask 相关 JSON 数据中一种具体的操作类型 "get_all",即获取所有操作,可能用于获取所有任务、列表等相关数据的场景。
public final static String GTASK_JSON_ACTION_TYPE_GETALL = "get_all"; public final static String GTASK_JSON_ACTION_TYPE_GETALL = "get_all";
// 用于表示在 GTask 相关 JSON 数据中一种具体的操作类型 "move",即移动操作,可能用于移动任务、列表等在不同位置(如不同列表之间)的场景。
public final static String GTASK_JSON_ACTION_TYPE_MOVE = "move"; public final static String GTASK_JSON_ACTION_TYPE_MOVE = "move";
// 用于表示在 GTask 相关 JSON 数据中一种具体的操作类型 "update",即更新操作,用于更新任务、列表等的属性信息。
public final static String GTASK_JSON_ACTION_TYPE_UPDATE = "update"; public final static String GTASK_JSON_ACTION_TYPE_UPDATE = "update";
// 用于表示在 GTask 相关 JSON 数据中 "creator_id" 字段的名称,可能用于标识创建某个任务、列表等实体的用户的唯一标识符。
public final static String GTASK_JSON_CREATOR_ID = "creator_id"; public final static String GTASK_JSON_CREATOR_ID = "creator_id";
// 用于表示在 GTask 相关 JSON 数据中 "child_entity" 字段的名称,推测是用于表示某个实体(如任务组等)的子实体相关信息,具体内容取决于业务逻辑。
public final static String GTASK_JSON_CHILD_ENTITY = "child_entity"; public final static String GTASK_JSON_CHILD_ENTITY = "child_entity";
// 用于表示在 GTask 相关 JSON 数据中 "client_version" 字段的名称,可能用于记录客户端的版本信息,便于在不同版本间进行数据兼容等处理。
public final static String GTASK_JSON_CLIENT_VERSION = "client_version"; public final static String GTASK_JSON_CLIENT_VERSION = "client_version";
// 用于表示在 GTask 相关 JSON 数据中 "completed" 字段的名称,可能用于标记某个任务等是否已完成的状态信息。
public final static String GTASK_JSON_COMPLETED = "completed"; public final static String GTASK_JSON_COMPLETED = "completed";
// 用于表示在 GTask 相关 JSON 数据中 "current_list_id" 字段的名称,推测是表示当前所在列表的唯一标识符,例如当前任务所属列表的 ID。
public final static String GTASK_JSON_CURRENT_LIST_ID = "current_list_id"; public final static String GTASK_JSON_CURRENT_LIST_ID = "current_list_id";
// 用于表示在 GTask 相关 JSON 数据中 "default_list_id" 字段的名称,可能用于标识默认列表的唯一标识符,例如新创建任务默认归属的列表 ID。
public final static String GTASK_JSON_DEFAULT_LIST_ID = "default_list_id"; public final static String GTASK_JSON_DEFAULT_LIST_ID = "default_list_id";
// 用于表示在 GTask 相关 JSON 数据中 "deleted" 字段的名称,可能用于标记某个实体(如任务、列表等)是否已被删除的状态信息。
public final static String GTASK_JSON_DELETED = "deleted"; public final static String GTASK_JSON_DELETED = "deleted";
// 用于表示在 GTask 相关 JSON 数据中 "dest_list" 字段的名称,推测在移动操作等场景下,用于表示目标列表相关信息,比如移动任务到的目标列表的相关属性等。
public final static String GTASK_JSON_DEST_LIST = "dest_list"; public final static String GTASK_JSON_DEST_LIST = "dest_list";
// 用于表示在 GTask 相关 JSON 数据中 "dest_parent" 字段的名称,可能在移动或关联实体等操作中,用于表示目标父级实体的相关信息,比如目标父任务、父列表等的情况。
public final static String GTASK_JSON_DEST_PARENT = "dest_parent"; public final static String GTASK_JSON_DEST_PARENT = "dest_parent";
// 用于表示在 GTask 相关 JSON 数据中 "dest_parent_type" 字段的名称,结合 "dest_parent" 字段,用于明确目标父级实体的类型,例如是任务组类型还是普通任务类型等。
public final static String GTASK_JSON_DEST_PARENT_TYPE = "dest_parent_type"; public final static String GTASK_JSON_DEST_PARENT_TYPE = "dest_parent_type";
// 用于表示在 GTask 相关 JSON 数据中 "entity_delta" 字段的名称,推测是用于表示实体变化量相关信息,比如某个实体在更新前后的属性差异等情况。
public final static String GTASK_JSON_ENTITY_DELTA = "entity_delta"; public final static String GTASK_JSON_ENTITY_DELTA = "entity_delta";
// 用于表示在 GTask 相关 JSON 数据中 "entity_type" 字段的名称,用于标识实体的类型,例如是任务类型还是任务组类型等,便于在不同类型实体的处理逻辑中进行区分。
public final static String GTASK_JSON_ENTITY_TYPE = "entity_type"; public final static String GTASK_JSON_ENTITY_TYPE = "entity_type";
// 用于表示在 GTask 相关 JSON 数据中 "get_deleted" 字段的名称,可能用于获取已删除实体相关信息的操作,比如查询已删除任务、列表等的记录。
public final static String GTASK_JSON_GET_DELETED = "get_deleted"; public final static String GTASK_JSON_GET_DELETED = "get_deleted";
// 用于表示在 GTask 相关 JSON 数据中 "id" 字段的名称,通常是用于标识各个实体(如任务、列表等)的唯一标识符,是数据关联和操作定位的重要依据。
public final static String GTASK_JSON_ID = "id"; public final static String GTASK_JSON_ID = "id";
// 用于表示在 GTask 相关 JSON 数据中 "index" 字段的名称,可能用于表示某个实体在列表等结构中的顺序索引,例如任务在任务列表中的排列顺序位置等情况。
public final static String GTASK_JSON_INDEX = "index"; public final static String GTASK_JSON_INDEX = "index";
// 用于表示在 GTask 相关 JSON 数据中 "last_modified" 字段的名称,通常用于记录某个实体(如任务、列表等)最后一次被修改的时间信息,便于进行数据同步、版本控制等操作。
public final static String GTASK_JSON_LAST_MODIFIED = "last_modified"; public final static String GTASK_JSON_LAST_MODIFIED = "last_modified";
// 用于表示在 GTask 相关 JSON 数据中 "latest_sync_point" 字段的名称,推测是用于记录最新的同步时间点或相关标识信息,在多端数据同步等场景下会用到。
public final static String GTASK_JSON_LATEST_SYNC_POINT = "latest_sync_point"; public final static String GTASK_JSON_LATEST_SYNC_POINT = "latest_sync_point";
// 用于表示在 GTask 相关 JSON 数据中 "list_id" 字段的名称,类似前面的列表相关 ID可能用于标识具体某个列表的唯一标识符用于区分不同的任务列表等情况。
public final static String GTASK_JSON_LIST_ID = "list_id"; public final static String GTASK_JSON_LIST_ID = "list_id";
// 用于表示在 GTask 相关 JSON 数据中 "lists" 字段的名称,推测是用于存放多个列表相关信息的集合,例如包含多个任务列表的详细数据等情况。
public final static String GTASK_JSON_LISTS = "lists"; public final static String GTASK_JSON_LISTS = "lists";
// 用于表示在 GTask 相关 JSON 数据中 "name" 字段的名称,可能用于表示任务、列表、用户等各种实体的名称信息,方便在界面展示等场景使用。
public final static String GTASK_JSON_NAME = "name"; public final static String GTASK_JSON_NAME = "name";
// 用于表示在 GTask 相关 JSON 数据中 "new_id" 字段的名称,可能在某些创建、复制或重命名等操作后,用于标识新生成的实体的唯一标识符情况。
public final static String GTASK_JSON_NEW_ID = "new_id"; public final static String GTASK_JSON_NEW_ID = "new_id";
// 用于表示在 GTask 相关 JSON 数据中 "notes" 字段的名称,推测是用于存放与某个实体(如任务等)相关的备注、说明等文本信息内容。
public final static String GTASK_JSON_NOTES = "notes"; public final static String GTASK_JSON_NOTES = "notes";
// 用于表示在 GTask 相关 JSON 数据中 "parent_id" 字段的名称,用于标识某个实体(如任务等)的父级实体的唯一标识符,便于构建任务层级结构等情况。
public final static String GTASK_JSON_PARENT_ID = "parent_id"; public final static String GTASK_JSON_PARENT_ID = "parent_id";
// 用于表示在 GTask 相关 JSON 数据中 "prior_sibling_id" 字段的名称,可能用于表示在同一层级中,某个实体之前的兄弟实体的唯一标识符,例如在任务列表中当前任务之前的相邻任务的 ID。
public final static String GTASK_JSON_PRIOR_SIBLING_ID = "prior_sibling_id"; public final static String GTASK_JSON_PRIOR_SIBLING_ID = "prior_sibling_id";
// 用于表示在 GTask 相关 JSON 数据中 "results" 字段的名称,推测是用于存放操作结果相关信息的集合,比如执行某个任务操作后返回的结果详情等情况。
public final static String GTASK_JSON_RESULTS = "results"; public final static String GTASK_JSON_RESULTS = "results";
// 用于表示在 GTask 相关 JSON 数据中 "source_list" 字段的名称,在移动操作等场景下,与 "dest_list" 相对应,用于表示源列表相关信息,即操作发起时实体所在的原始列表情况。
public final static String GTASK_JSON_SOURCE_LIST = "source_list"; public final static String GTASK_JSON_SOURCE_LIST = "source_list";
// 用于表示在 GTask 相关 JSON 数据中 "tasks" 字段的名称,推测是用于存放多个任务相关信息的集合,例如包含多个任务的详细属性、状态等数据情况。
public final static String GTASK_JSON_TASKS = "tasks"; public final static String GTASK_JSON_TASKS = "tasks";
// 用于表示在 GTask 相关 JSON 数据中 "type" 字段的名称,再次强调用于标识实体类型相关信息,与前面的 "entity_type" 等类似,但可能在不同的 JSON 结构层次或业务逻辑中有不同的使用场景。
public final static String GTASK_JSON_TYPE = "type"; public final static String GTASK_JSON_TYPE = "type";
// 用于表示在 GTask 相关 JSON 数据中一种具体的实体类型 "GROUP",即任务组类型,用于区分不同类型的任务组织形式,比如任务组和普通单个任务的区别。
public final static String GTASK_JSON_TYPE_GROUP = "GROUP"; public final static String GTASK_JSON_TYPE_GROUP = "GROUP";
// 用于表示在 GTask 相关 JSON 数据中一种具体的实体类型 "TASK",即普通任务类型,是最基本的任务单元表示,与任务组等相对应。
public final static String GTASK_JSON_TYPE_TASK = "TASK"; public final static String GTASK_JSON_TYPE_TASK = "TASK";
// 用于表示在 GTask 相关 JSON 数据中 "user" 字段的名称,可能用于存放与用户相关的信息,比如用户的基本资料、权限等情况,具体取决于业务逻辑。
public final static String GTASK_JSON_USER = "user"; public final static String GTASK_JSON_USER = "user";
// 用于表示特定的文件夹前缀 "[MIUI_Notes]",可能在涉及 MIUI 系统下笔记相关功能时,用于标识特定的文件夹或者区分不同来源的笔记数据等情况。
public final static String MIUI_FOLDER_PREFFIX = "[MIUI_Notes]"; public final static String MIUI_FOLDER_PREFFIX = "[MIUI_Notes]";
// 用于表示默认文件夹的名称 "Default",可能在笔记、任务等应用中,作为默认创建的文件夹名称,或者在没有指定特定文件夹时的默认归属文件夹等情况使用。
public final static String FOLDER_DEFAULT = "Default"; public final static String FOLDER_DEFAULT = "Default";
// 用于表示通话记录笔记相关的文件夹名称 "Call_Note",可能用于专门存放通话记录相关笔记的文件夹,便于分类管理和查找相关数据。
public final static String FOLDER_CALL_NOTE = "Call_Note"; public final static String FOLDER_CALL_NOTE = "Call_Note";
// 用于表示元数据相关的文件夹名称 "METADATA",可能用于存放各种实体(如任务、笔记等)的元数据信息,用于记录额外的描述、配置等数据情况。
public final static String FOLDER_META = "METADATA"; public final static String FOLDER_META = "METADATA";
// 用于表示在元数据中与 GTask 的 ID 相关的头部标识 "meta_gid",可能用于在元数据结构中明确某个数据项对应的 GTask 的唯一标识符情况,便于数据关联和查找。
public final static String META_HEAD_GTASK_ID = "meta_gid"; public final static String META_HEAD_GTASK_ID = "meta_gid";
// 用于表示在元数据中与笔记相关的头部标识 "meta_note",可能用于在元数据里区分和定位与笔记相关的数据内容,例如笔记的属性、备注等信息在元数据中的标识。
public final static String META_HEAD_NOTE = "meta_note"; public final static String META_HEAD_NOTE = "meta_note";
// 用于表示在元数据中与通用数据相关的头部标识 "meta_data",可能用于更广泛的数据项标识,涵盖除了特定的 GTask ID、笔记等之外的其他数据在元数据中的表示情况。
public final static String META_HEAD_DATA = "meta_data"; public final static String META_HEAD_DATA = "meta_data";
// 用于表示元数据中关于笔记的特定提示信息 "[META INFO] DON'T UPDATE AND DELETE",可能是用于提醒用户或者开发者不要对该部分元数据中的笔记相关信息进行更新和删除操作,可能有特定的业务用途或数据完整性要求。
public final static String META_NOTE_NAME = "[META INFO] DON'T UPDATE AND DELETE"; public final static String META_NOTE_NAME = "[META INFO] DON'T UPDATE AND DELETE";
} }

@ -24,47 +24,89 @@ import net.micode.notes.ui.NotesPreferenceActivity;
public class ResourceParser { public class ResourceParser {
public static final int YELLOW = 0; // 定义颜色相关的常量,用于表示不同的颜色选项,方便在代码中以整数形式引用对应的颜色,
public static final int BLUE = 1; // 这里每个整数对应一种特定的颜色,具体含义由代码中的使用逻辑决定,例如用于设置背景颜色等场景。
public static final int WHITE = 2; public static final int YELLOW = 0;
public static final int GREEN = 3; public static final int BLUE = 1;
public static final int RED = 4; public static final int WHITE = 2;
public static final int GREEN = 3;
public static final int RED = 4;
// 定义默认的背景颜色,使用前面定义的颜色常量中的 `YELLOW` 作为默认值,
// 意味着在某些没有明确指定背景颜色的情况下,将采用黄色作为默认的背景颜色,
// 具体应用场景可能涉及笔记、界面元素等的背景颜色设置。
public static final int BG_DEFAULT_COLOR = YELLOW; public static final int BG_DEFAULT_COLOR = YELLOW;
public static final int TEXT_SMALL = 0; // 定义字体大小相关的常量,用于表示不同的字体大小规格,同样以整数形式方便在代码中引用,
public static final int TEXT_MEDIUM = 1; // 不同的整数值对应不同的字体大小选项,可能用于设置文本显示的字体大小情况,例如笔记内容、标题等文本的字体大小选择。
public static final int TEXT_LARGE = 2; public static final int TEXT_SMALL = 0;
public static final int TEXT_SUPER = 3; public static final int TEXT_MEDIUM = 1;
public static final int TEXT_LARGE = 2;
public static final int TEXT_SUPER = 3;
// 定义默认的字体大小,使用 `TEXT_MEDIUM` 作为默认值,即在没有特殊指定字体大小时,
// 将采用中等大小的字体作为默认设置,应用于各类文本显示场景中。
public static final int BG_DEFAULT_FONT_SIZE = TEXT_MEDIUM; public static final int BG_DEFAULT_FONT_SIZE = TEXT_MEDIUM;
/**
* `NoteBgResources`Drawable
* ID便
*/
public static class NoteBgResources { public static class NoteBgResources {
private final static int [] BG_EDIT_RESOURCES = new int [] { // 定义一个私有的静态数组,用于存储编辑状态下笔记背景的资源 IDDrawable资源
R.drawable.edit_yellow, // 数组中的每个元素对应一种颜色的编辑背景图片资源,索引与前面定义的颜色常量相对应,
R.drawable.edit_blue, // 例如 `R.drawable.edit_yellow` 对应黄色背景的编辑状态下的笔记背景资源。
R.drawable.edit_white, private final static int[] BG_EDIT_RESOURCES = new int[]{
R.drawable.edit_green, R.drawable.edit_yellow,
R.drawable.edit_red R.drawable.edit_blue,
R.drawable.edit_white,
R.drawable.edit_green,
R.drawable.edit_red
}; };
private final static int [] BG_EDIT_TITLE_RESOURCES = new int [] { // 类似地,定义一个私有的静态数组,用于存储编辑状态下笔记标题背景的资源 ID
R.drawable.edit_title_yellow, // 同样每个元素对应一种颜色的编辑标题背景图片资源,索引与颜色常量匹配,
R.drawable.edit_title_blue, // 用于设置笔记标题部分的背景图片显示,以达到不同颜色风格的视觉效果。
R.drawable.edit_title_white, private final static int[] BG_EDIT_TITLE_RESOURCES = new int[]{
R.drawable.edit_title_green, R.drawable.edit_title_yellow,
R.drawable.edit_title_red R.drawable.edit_title_blue,
R.drawable.edit_title_white,
R.drawable.edit_title_green,
R.drawable.edit_title_red
}; };
/**
* `id` `BG_EDIT_RESOURCES` ID
* 使
*
* @param id `YELLOW``BLUE`
* @return ID `int` Android ID
*/
public static int getNoteBgResource(int id) { public static int getNoteBgResource(int id) {
return BG_EDIT_RESOURCES[id]; return BG_EDIT_RESOURCES[id];
} }
/**
* `id` `BG_EDIT_TITLE_RESOURCES` ID
*
*
* @param id
* @return ID `int` Android ID
*/
public static int getNoteTitleBgResource(int id) { public static int getNoteTitleBgResource(int id) {
return BG_EDIT_TITLE_RESOURCES[id]; return BG_EDIT_TITLE_RESOURCES[id];
} }
} }
/**
* IDSharedPreferences
* `NotesPreferenceActivity.PREFERENCE_SET_BG_COLOR_KEY` `true`
* `NoteBgResources.BG_EDIT_RESOURCES` ID
* ID`BG_DEFAULT_COLOR`
*
* @param context SharedPreferences便
* @return 使 ID `int`
*/
public static int getDefaultBgId(Context context) { public static int getDefaultBgId(Context context) {
if (PreferenceManager.getDefaultSharedPreferences(context).getBoolean( if (PreferenceManager.getDefaultSharedPreferences(context).getBoolean(
NotesPreferenceActivity.PREFERENCE_SET_BG_COLOR_KEY, false)) { NotesPreferenceActivity.PREFERENCE_SET_BG_COLOR_KEY, false)) {
@ -74,94 +116,192 @@ public class ResourceParser {
} }
} }
/**
* `NoteItemBgResources`
* ID便
*/
public static class NoteItemBgResources { public static class NoteItemBgResources {
private final static int [] BG_FIRST_RESOURCES = new int [] { // 定义一个私有的静态数组,用于存储列表中第一个笔记项的背景资源 IDDrawable资源
R.drawable.list_yellow_up, // 数组中的每个元素对应一种颜色的第一个笔记项的背景图片资源,索引与颜色常量相对应,
R.drawable.list_blue_up, // 例如 `R.drawable.list_yellow_up` 对应黄色背景的列表中第一个笔记项的背景资源,用于实现不同颜色风格的列表第一项背景显示效果。
R.drawable.list_white_up, private final static int[] BG_FIRST_RESOURCES = new int[]{
R.drawable.list_green_up, R.drawable.list_yellow_up,
R.drawable.list_red_up R.drawable.list_blue_up,
R.drawable.list_white_up,
R.drawable.list_green_up,
R.drawable.list_red_up
}; };
private final static int [] BG_NORMAL_RESOURCES = new int [] { // 定义一个私有的静态数组,用于存储列表中普通笔记项(非第一个和最后一个)的背景资源 ID
R.drawable.list_yellow_middle, // 每个元素对应一种颜色的普通笔记项背景图片资源,按照颜色索引匹配,
R.drawable.list_blue_middle, // 用于设置列表中间部分笔记项的背景图片,实现统一的列表项背景风格。
R.drawable.list_white_middle, private final static int[] BG_NORMAL_RESOURCES = new int[]{
R.drawable.list_green_middle, R.drawable.list_yellow_middle,
R.drawable.list_red_middle R.drawable.list_blue_middle,
R.drawable.list_white_middle,
R.drawable.list_green_middle,
R.drawable.list_red_middle
}; };
private final static int [] BG_LAST_RESOURCES = new int [] { // 定义一个私有的静态数组,用于存储列表中最后一个笔记项的背景资源 ID
R.drawable.list_yellow_down, // 数组元素对应不同颜色的最后一个笔记项的背景图片资源,索引与颜色常量相关联,
R.drawable.list_blue_down, // 用于设置列表最后一项的背景显示,与列表中其他位置的笔记项背景区分开来,达到整体美观的列表显示效果。
R.drawable.list_white_down, private final static int[] BG_LAST_RESOURCES = new int[]{
R.drawable.list_green_down, R.drawable.list_yellow_down,
R.drawable.list_red_down, R.drawable.list_blue_down,
R.drawable.list_white_down,
R.drawable.list_green_down,
R.drawable.list_red_down,
}; };
private final static int [] BG_SINGLE_RESOURCES = new int [] { // 定义一个私有的静态数组,用于存储单个笔记项(单独显示,可能不在列表中情况)的背景资源 ID
R.drawable.list_yellow_single, // 各元素对应不同颜色的单个笔记项背景图片资源,通过颜色索引获取相应资源,
R.drawable.list_blue_single, // 用于在单独展示笔记等场景下设置背景图片显示。
R.drawable.list_white_single, private final static int[] BG_SINGLE_RESOURCES = new int[]{
R.drawable.list_green_single, R.drawable.list_yellow_single,
R.drawable.list_red_single R.drawable.list_blue_single,
R.drawable.list_white_single,
R.drawable.list_green_single,
R.drawable.list_red_single
}; };
/**
* `id` `BG_FIRST_RESOURCES` ID
* 使
*
* @param id
* @return ID `int` Android ID
*/
public static int getNoteBgFirstRes(int id) { public static int getNoteBgFirstRes(int id) {
return BG_FIRST_RESOURCES[id]; return BG_FIRST_RESOURCES[id];
} }
/**
* `id` `BG_LAST_RESOURCES` ID
*
*
* @param id
* @return ID `int` Android ID
*/
public static int getNoteBgLastRes(int id) { public static int getNoteBgLastRes(int id) {
return BG_LAST_RESOURCES[id]; return BG_LAST_RESOURCES[id];
} }
/**
* `id` `BG_SINGLE_RESOURCES` ID
*
*
* @param id
* @return ID `int` Android ID
*/
public static int getNoteBgSingleRes(int id) { public static int getNoteBgSingleRes(int id) {
return BG_SINGLE_RESOURCES[id]; return BG_SINGLE_RESOURCES[id];
} }
/**
* `id` `BG_NORMAL_RESOURCES` ID
*
*
* @param id
* @return ID `int` Android ID
*/
public static int getNoteBgNormalRes(int id) { public static int getNoteBgNormalRes(int id) {
return BG_NORMAL_RESOURCES[id]; return BG_NORMAL_RESOURCES[id];
} }
/**
* ID
*
* @return ID `int` Android ID `R.drawable.list_folder`
*/
public static int getFolderBgRes() { public static int getFolderBgRes() {
return R.drawable.list_folder; return R.drawable.list_folder;
} }
} }
/**
* `WidgetBgResources`Widget `2x``4x`
* ID便
*/
public static class WidgetBgResources { public static class WidgetBgResources {
private final static int [] BG_2X_RESOURCES = new int [] { // 定义一个私有的静态数组,用于存储 `2x` 尺寸小部件的背景资源 IDDrawable资源
R.drawable.widget_2x_yellow, // 数组中的每个元素对应一种颜色的 `2x` 尺寸小部件背景图片资源,索引与颜色常量相对应,
R.drawable.widget_2x_blue, // 例如 `R.drawable.widget_2x_yellow` 对应黄色背景的 `2x` 尺寸小部件的背景资源,用于在相应尺寸小部件上设置背景显示。
R.drawable.widget_2x_white, private final static int[] BG_2X_RESOURCES = new int[]{
R.drawable.widget_2x_green, R.drawable.widget_2x_yellow,
R.drawable.widget_2x_red, R.drawable.widget_2x_blue,
R.drawable.widget_2x_white,
R.drawable.widget_2x_green,
R.drawable.widget_2x_red,
}; };
/**
* `id` `BG_2X_RESOURCES` `2x` ID
* `2x` 使
*
* @param id
* @return `2x` ID `int` Android ID
*/
public static int getWidget2xBgResource(int id) { public static int getWidget2xBgResource(int id) {
return BG_2X_RESOURCES[id]; return BG_2X_RESOURCES[id];
} }
private final static int [] BG_4X_RESOURCES = new int [] { // 定义一个私有的静态数组,用于存储 `4x` 尺寸小部件的背景资源 ID
R.drawable.widget_4x_yellow, // 每个元素对应一种颜色的 `4x` 尺寸小部件背景图片资源,按照颜色索引匹配,
R.drawable.widget_4x_blue, // 用于在 `4x` 尺寸小部件上设置背景图片,以适配不同的屏幕显示情况和用户对颜色的选择。
R.drawable.widget_4x_white, private final static int[] BG_4X_RESOURCES = new int[]{
R.drawable.widget_4x_green, R.drawable.widget_4x_yellow,
R.drawable.widget_4x_red R.drawable.widget_4x_blue,
R.drawable.widget_4x_white,
R.drawable.widget_4x_green,
R.drawable.widget_4x_red
}; };
/**
* `id` `BG_4X_RESOURCES` `4x` ID
* `4x` 使
*
* @param id
* @return `4x` ID `int` Android ID
*/
public static int getWidget4xBgResource(int id) { public static int getWidget4xBgResource(int id) {
return BG_4X_RESOURCES[id]; return BG_4X_RESOURCES[id];
} }
} }
/**
* `TextAppearanceResources`
* ID 便
*
*/
public static class TextAppearanceResources { public static class TextAppearanceResources {
private final static int [] TEXTAPPEARANCE_RESOURCES = new int [] {
R.style.TextAppearanceNormal, // 定义一个私有的静态数组 `TEXTAPPEARANCE_RESOURCES`,用于存储不同文本外观对应的资源 ID。
R.style.TextAppearanceMedium, // 这里的资源 ID 通常是指 Android 中的 `TextAppearance` 样式资源(在 `styles.xml` 等资源文件中定义),
R.style.TextAppearanceLarge, // 每个元素对应一种特定的文本外观样式,通过索引来区分不同规格(如大小等不同情况)的文本外观。
R.style.TextAppearanceSuper private final static int[] TEXTAPPEARANCE_RESOURCES = new int[]{
R.style.TextAppearanceNormal,
R.style.TextAppearanceMedium,
R.style.TextAppearanceLarge,
R.style.TextAppearanceSuper
}; };
/**
* `id` ID
* ID
*
* <p>
* `HACKME` SharedPreference ID
* ID 访
* ID `ResourceParser#BG_DEFAULT_FONT_SIZE`
*
*
* @param id `TEXTAPPEARANCE_RESOURCES.length`
*
* @return ID `int` Android ID
* ID
*/
public static int getTexAppearanceResource(int id) { public static int getTexAppearanceResource(int id) {
/** /**
* HACKME: Fix bug of store the resource id in shared preference. * HACKME: Fix bug of store the resource id in shared preference.
@ -174,8 +314,15 @@ public class ResourceParser {
return TEXTAPPEARANCE_RESOURCES[id]; return TEXTAPPEARANCE_RESOURCES[id];
} }
/**
*
*
*
* @return `TEXTAPPEARANCE_RESOURCES` `int`
*/
public static int getResourcesSize() { public static int getResourcesSize() {
return TEXTAPPEARANCE_RESOURCES.length; return TEXTAPPEARANCE_RESOURCES.length;
} }
} }
} }

Loading…
Cancel
Save