Compare commits

..

23 Commits
lcb ... 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
曹登阳 866d114870 Merge branch 'cdy' of https://bdgit.educoder.net/p5fnrwyt6/micode
1 year ago
曹登阳 79147a1c50 曹登阳 ui widget注释
1 year ago
dcy f3a327d2ad Merge branch 'lcb' into develop
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 43e6e18fa7 2024/11/30 加注解
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 { public class MetaData extends Task {
private final static String TAG = MetaData.class.getSimpleName(); private static final String TAG = MetaData.class.getSimpleName();
private String relatedGid = null;
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;
} }
} }

@ -40,20 +40,29 @@ import net.micode.notes.tool.DataUtils;
import java.io.IOException; import java.io.IOException;
// AlarmAlertActivity类继承自Activity实现了OnClickListener和OnDismissListener接口用于处理闹钟提醒的展示、声音播放以及相关交互逻辑
public class AlarmAlertActivity extends Activity implements OnClickListener, OnDismissListener { public class AlarmAlertActivity extends Activity implements OnClickListener, OnDismissListener {
// 用于存储提醒关联的笔记的ID
private long mNoteId; private long mNoteId;
// 用于存储笔记内容的摘要信息,最大展示长度有限制
private String mSnippet; private String mSnippet;
// 定义摘要信息的最大展示长度为60个字符
private static final int SNIPPET_PREW_MAX_LEN = 60; private static final int SNIPPET_PREW_MAX_LEN = 60;
// 用于播放闹钟提醒声音的MediaPlayer对象
MediaPlayer mPlayer; MediaPlayer mPlayer;
// Activity被创建时调用的方法进行一些初始化操作
@Override @Override
protected void onCreate(Bundle savedInstanceState) { protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState); super.onCreate(savedInstanceState);
// 设置Activity无标题栏去除默认的标题显示
requestWindowFeature(Window.FEATURE_NO_TITLE); requestWindowFeature(Window.FEATURE_NO_TITLE);
final Window win = getWindow(); final Window win = getWindow();
// 设置窗口属性使得在屏幕锁定时也能显示该Activity
win.addFlags(WindowManager.LayoutParams.FLAG_SHOW_WHEN_LOCKED); win.addFlags(WindowManager.LayoutParams.FLAG_SHOW_WHEN_LOCKED);
// 判断屏幕是否处于开启状态,如果屏幕未开启,添加一系列屏幕相关的标志位,以确保屏幕按期望的方式显示和处理
if (!isScreenOn()) { if (!isScreenOn()) {
win.addFlags(WindowManager.LayoutParams.FLAG_KEEP_SCREEN_ON win.addFlags(WindowManager.LayoutParams.FLAG_KEEP_SCREEN_ON
| WindowManager.LayoutParams.FLAG_TURN_SCREEN_ON | WindowManager.LayoutParams.FLAG_TURN_SCREEN_ON
@ -64,9 +73,12 @@ public class AlarmAlertActivity extends Activity implements OnClickListener, OnD
Intent intent = getIntent(); Intent intent = getIntent();
try { try {
// 从传入的Intent中获取数据提取出笔记的ID
mNoteId = Long.valueOf(intent.getData().getPathSegments().get(1)); mNoteId = Long.valueOf(intent.getData().getPathSegments().get(1));
// 根据笔记ID获取对应的摘要内容
mSnippet = DataUtils.getSnippetById(this.getContentResolver(), mNoteId); mSnippet = DataUtils.getSnippetById(this.getContentResolver(), mNoteId);
mSnippet = mSnippet.length() > SNIPPET_PREW_MAX_LEN ? mSnippet.substring(0, // 如果摘要内容长度超过最大展示长度,进行截断处理,并添加提示信息
mSnippet = mSnippet.length() > SNIPPET_PREW_MAX_LEN? mSnippet.substring(0,
SNIPPET_PREW_MAX_LEN) + getResources().getString(R.string.notelist_string_info) SNIPPET_PREW_MAX_LEN) + getResources().getString(R.string.notelist_string_info)
: mSnippet; : mSnippet;
} catch (IllegalArgumentException e) { } catch (IllegalArgumentException e) {
@ -74,7 +86,9 @@ public class AlarmAlertActivity extends Activity implements OnClickListener, OnD
return; return;
} }
// 创建MediaPlayer对象用于后续播放闹钟声音
mPlayer = new MediaPlayer(); mPlayer = new MediaPlayer();
// 判断笔记是否在笔记数据库中可见如果可见则展示操作对话框并播放闹钟声音否则结束该Activity
if (DataUtils.visibleInNoteDatabase(getContentResolver(), mNoteId, Notes.TYPE_NOTE)) { if (DataUtils.visibleInNoteDatabase(getContentResolver(), mNoteId, Notes.TYPE_NOTE)) {
showActionDialog(); showActionDialog();
playAlarmSound(); playAlarmSound();
@ -83,18 +97,20 @@ public class AlarmAlertActivity extends Activity implements OnClickListener, OnD
} }
} }
// 判断屏幕是否处于开启状态的方法通过获取PowerManager服务来检查屏幕状态
private boolean isScreenOn() { private boolean isScreenOn() {
PowerManager pm = (PowerManager) getSystemService(Context.POWER_SERVICE); PowerManager pm = (PowerManager) getSystemService(Context.POWER_SERVICE);
return pm.isScreenOn(); return pm.isScreenOn();
} }
// 播放闹钟提醒声音的方法获取默认的闹钟铃声Uri并根据系统设置配置音频流类型然后加载并播放声音同时设置为循环播放
private void playAlarmSound() { private void playAlarmSound() {
Uri url = RingtoneManager.getActualDefaultRingtoneUri(this, RingtoneManager.TYPE_ALARM); Uri url = RingtoneManager.getActualDefaultRingtoneUri(this, RingtoneManager.TYPE_ALARM);
int silentModeStreams = Settings.System.getInt(getContentResolver(), int silentModeStreams = Settings.System.getInt(getContentResolver(),
Settings.System.MODE_RINGER_STREAMS_AFFECTED, 0); Settings.System.MODE_RINGER_STREAMS_AFFECTED, 0);
if ((silentModeStreams & (1 << AudioManager.STREAM_ALARM)) != 0) { if ((silentModeStreams & (1 << AudioManager.STREAM_ALARM))!= 0) {
mPlayer.setAudioStreamType(silentModeStreams); mPlayer.setAudioStreamType(silentModeStreams);
} else { } else {
mPlayer.setAudioStreamType(AudioManager.STREAM_ALARM); mPlayer.setAudioStreamType(AudioManager.STREAM_ALARM);
@ -119,6 +135,7 @@ public class AlarmAlertActivity extends Activity implements OnClickListener, OnD
} }
} }
// 展示操作对话框的方法创建一个AlertDialog设置标题、消息内容、正按钮以及根据屏幕是否开启来决定是否设置负按钮并设置对话框消失时的监听器
private void showActionDialog() { private void showActionDialog() {
AlertDialog.Builder dialog = new AlertDialog.Builder(this); AlertDialog.Builder dialog = new AlertDialog.Builder(this);
dialog.setTitle(R.string.app_name); dialog.setTitle(R.string.app_name);
@ -130,6 +147,7 @@ public class AlarmAlertActivity extends Activity implements OnClickListener, OnD
dialog.show().setOnDismissListener(this); dialog.show().setOnDismissListener(this);
} }
// 处理对话框按钮点击事件的方法,根据点击的按钮进行相应的逻辑处理,点击负按钮时跳转到笔记编辑页面查看对应的笔记
public void onClick(DialogInterface dialog, int which) { public void onClick(DialogInterface dialog, int which) {
switch (which) { switch (which) {
case DialogInterface.BUTTON_NEGATIVE: case DialogInterface.BUTTON_NEGATIVE:
@ -143,13 +161,15 @@ public class AlarmAlertActivity extends Activity implements OnClickListener, OnD
} }
} }
// 处理对话框消失事件的方法停止正在播放的闹钟声音并结束当前Activity
public void onDismiss(DialogInterface dialog) { public void onDismiss(DialogInterface dialog) {
stopAlarmSound(); stopAlarmSound();
finish(); finish();
} }
// 停止闹钟声音播放的方法释放MediaPlayer资源将其置为null
private void stopAlarmSound() { private void stopAlarmSound() {
if (mPlayer != null) { if (mPlayer!= null) {
mPlayer.stop(); mPlayer.stop();
mPlayer.release(); mPlayer.release();
mPlayer = null; mPlayer = null;

@ -28,37 +28,55 @@ import net.micode.notes.data.Notes;
import net.micode.notes.data.Notes.NoteColumns; import net.micode.notes.data.Notes.NoteColumns;
// AlarmInitReceiver类继承自BroadcastReceiver用于接收系统广播并执行与闹钟初始化相关的操作比如根据条件查询数据库中的笔记信息为符合条件的笔记设置对应的闹钟提醒
public class AlarmInitReceiver extends BroadcastReceiver { public class AlarmInitReceiver extends BroadcastReceiver {
// 定义一个字符串数组用于指定从数据库查询时要获取的列名这里包含笔记的ID和提醒日期两列
private static final String [] PROJECTION = new String [] { private static final String [] PROJECTION = new String [] {
NoteColumns.ID, NoteColumns.ID,
NoteColumns.ALERTED_DATE NoteColumns.ALERTED_DATE
}; };
// 定义常量表示查询结果中笔记ID所在列的索引值为0方便后续从游标中获取对应数据
private static final int COLUMN_ID = 0; private static final int COLUMN_ID = 0;
// 定义常量表示查询结果中提醒日期所在列的索引值为1方便后续从游标中获取对应数据
private static final int COLUMN_ALERTED_DATE = 1; private static final int COLUMN_ALERTED_DATE = 1;
// 重写BroadcastReceiver的onReceive方法当该广播接收器接收到相应广播时会执行此方法内的逻辑
@Override @Override
public void onReceive(Context context, Intent intent) { public void onReceive(Context context, Intent intent) {
// 获取当前系统时间的毫秒数,用于后续作为查询条件去筛选数据库中的记录
long currentDate = System.currentTimeMillis(); long currentDate = System.currentTimeMillis();
// 通过ContentResolver执行数据库查询操作从指定的UriNotes.CONTENT_NOTE_URI中查询数据按照PROJECTION定义的列进行查询
// 使用提供的查询条件筛选出提醒日期大于当前时间且类型为笔记Notes.TYPE_NOTE的记录查询参数使用当前时间的字符串表示形式
Cursor c = context.getContentResolver().query(Notes.CONTENT_NOTE_URI, Cursor c = context.getContentResolver().query(Notes.CONTENT_NOTE_URI,
PROJECTION, PROJECTION,
NoteColumns.ALERTED_DATE + ">? AND " + NoteColumns.TYPE + "=" + Notes.TYPE_NOTE, NoteColumns.ALERTED_DATE + ">? AND " + NoteColumns.TYPE + "=" + Notes.TYPE_NOTE,
new String[] { String.valueOf(currentDate) }, new String[] { String.valueOf(currentDate) },
null); null);
if (c != null) { // 判断游标是否不为空,即是否查询到了符合条件的数据
if (c!= null) {
// 将游标移动到第一条查询结果记录位置,如果有结果则开始遍历处理
if (c.moveToFirst()) { if (c.moveToFirst()) {
do { do {
// 从游标中获取提醒日期对应的列数据,得到该笔记的提醒时间(以毫秒为单位的时间戳形式)
long alertDate = c.getLong(COLUMN_ALERTED_DATE); long alertDate = c.getLong(COLUMN_ALERTED_DATE);
// 创建一个新的Intent用于启动AlarmReceiver这个广播接收器传递与当前笔记相关的信息
Intent sender = new Intent(context, AlarmReceiver.class); Intent sender = new Intent(context, AlarmReceiver.class);
// 为Intent设置数据将当前笔记的ID附加到对应的Uri上以便接收方可以识别是哪个笔记的闹钟相关操作
sender.setData(ContentUris.withAppendedId(Notes.CONTENT_NOTE_URI, c.getLong(COLUMN_ID))); sender.setData(ContentUris.withAppendedId(Notes.CONTENT_NOTE_URI, c.getLong(COLUMN_ID)));
// 创建一个PendingIntent用于在合适的时候触发指定的广播这里是AlarmReceiver设置相关的上下文、请求码、Intent以及标志位
PendingIntent pendingIntent = PendingIntent.getBroadcast(context, 0, sender, 0); PendingIntent pendingIntent = PendingIntent.getBroadcast(context, 0, sender, 0);
// 获取系统的AlarmManager服务用于设置闹钟提醒相关的操作
AlarmManager alermManager = (AlarmManager) context AlarmManager alermManager = (AlarmManager) context
.getSystemService(Context.ALARM_SERVICE); .getSystemService(Context.ALARM_SERVICE);
// 通过AlarmManager设置闹钟提醒使用RTC_WAKEUP模式在指定的绝对时间唤醒设备来触发提醒传入提醒时间和对应的PendingIntent
alermManager.set(AlarmManager.RTC_WAKEUP, alertDate, pendingIntent); alermManager.set(AlarmManager.RTC_WAKEUP, alertDate, pendingIntent);
} while (c.moveToNext()); } while (c.moveToNext());
} }
// 关闭游标,释放相关资源,避免内存泄漏等问题
c.close(); c.close();
} }
} }

@ -20,11 +20,18 @@ import android.content.BroadcastReceiver;
import android.content.Context; import android.content.Context;
import android.content.Intent; import android.content.Intent;
// AlarmReceiver类继承自BroadcastReceiver它的主要作用是接收广播并在接收到广播后进行相应的页面跳转操作以展示闹钟提醒相关的界面
public class AlarmReceiver extends BroadcastReceiver { public class AlarmReceiver extends BroadcastReceiver {
// 重写BroadcastReceiver的onReceive方法当该广播接收器接收到广播时此方法内的逻辑将会被执行
@Override @Override
public void onReceive(Context context, Intent intent) { public void onReceive(Context context, Intent intent) {
// 将传入的Intent的目标类设置为AlarmAlertActivity.class也就是当这个Intent被启动时将会启动AlarmAlertActivity这个Activity
// 通常用于根据接收到的广播信息跳转到对应的展示界面,此处就是跳转到闹钟提醒相关的界面
intent.setClass(context, AlarmAlertActivity.class); intent.setClass(context, AlarmAlertActivity.class);
// 为Intent添加标志位FLAG_ACTIVITY_NEW_TASK这是因为从广播接收器中启动Activity需要这个标志位来确保Activity能够在新的任务栈中被正确启动
// 否则可能会出现启动失败等问题,特别是在应用处于后台或者未运行的一些场景下
intent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK); intent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
// 通过传入的上下文对象启动设置好的Intent从而启动对应的Activity实现从接收到广播到展示闹钟提醒界面的流程
context.startActivity(intent); context.startActivity(intent);
} }
} }

@ -28,85 +28,128 @@ import android.view.View;
import android.widget.FrameLayout; import android.widget.FrameLayout;
import android.widget.NumberPicker; import android.widget.NumberPicker;
// DateTimePicker类继承自FrameLayout它是一个自定义的视图组件用于实现日期和时间的选择功能支持24小时制和12小时制含AM/PM的显示与操作并且可以响应各种时间组件值变化的事件。
public class DateTimePicker extends FrameLayout { public class DateTimePicker extends FrameLayout {
// 默认的启用状态初始化为true表示默认启用该日期时间选择器
private static final boolean DEFAULT_ENABLE_STATE = true; private static final boolean DEFAULT_ENABLE_STATE = true;
// 半天包含的小时数用于12小时制相关的时间计算和判断
private static final int HOURS_IN_HALF_DAY = 12; private static final int HOURS_IN_HALF_DAY = 12;
// 一整天包含的小时数用于24小时制相关的时间计算和判断等操作
private static final int HOURS_IN_ALL_DAY = 24; private static final int HOURS_IN_ALL_DAY = 24;
// 一周包含的天数,用于日期选择器相关的范围设置等操作
private static final int DAYS_IN_ALL_WEEK = 7; private static final int DAYS_IN_ALL_WEEK = 7;
// 日期选择器NumberPicker的最小值通常从0开始表示一周中的第一天等情况
private static final int DATE_SPINNER_MIN_VAL = 0; private static final int DATE_SPINNER_MIN_VAL = 0;
// 日期选择器NumberPicker的最大值设置为一周天数减1对应一周中的最后一天
private static final int DATE_SPINNER_MAX_VAL = DAYS_IN_ALL_WEEK - 1; private static final int DATE_SPINNER_MAX_VAL = DAYS_IN_ALL_WEEK - 1;
// 24小时制视图下小时选择器NumberPicker的最小值即0时
private static final int HOUR_SPINNER_MIN_VAL_24_HOUR_VIEW = 0; private static final int HOUR_SPINNER_MIN_VAL_24_HOUR_VIEW = 0;
// 24小时制视图下小时选择器NumberPicker的最大值即23时
private static final int HOUR_SPINNER_MAX_VAL_24_HOUR_VIEW = 23; private static final int HOUR_SPINNER_MAX_VAL_24_HOUR_VIEW = 23;
// 12小时制视图下小时选择器NumberPicker的最小值即1时通常12小时制显示从1开始
private static final int HOUR_SPINNER_MIN_VAL_12_HOUR_VIEW = 1; private static final int HOUR_SPINNER_MIN_VAL_12_HOUR_VIEW = 1;
// 12小时制视图下小时选择器NumberPicker的最大值即12时
private static final int HOUR_SPINNER_MAX_VAL_12_HOUR_VIEW = 12; private static final int HOUR_SPINNER_MAX_VAL_12_HOUR_VIEW = 12;
// 分钟选择器NumberPicker的最小值即0分
private static final int MINUT_SPINNER_MIN_VAL = 0; private static final int MINUT_SPINNER_MIN_VAL = 0;
// 分钟选择器NumberPicker的最大值即59分表示一分钟的最大数值
private static final int MINUT_SPINNER_MAX_VAL = 59; private static final int MINUT_SPINNER_MAX_VAL = 59;
// AM/PM选择器NumberPicker的最小值通常0表示AM
private static final int AMPM_SPINNER_MIN_VAL = 0; private static final int AMPM_SPINNER_MIN_VAL = 0;
// AM/PM选择器NumberPicker的最大值通常1表示PM
private static final int AMPM_SPINNER_MAX_VAL = 1; private static final int AMPM_SPINNER_MAX_VAL = 1;
// 用于选择日期的NumberPicker组件用户可以通过它滚动选择具体的日期以周为范围参考
private final NumberPicker mDateSpinner; private final NumberPicker mDateSpinner;
// 用于选择小时的NumberPicker组件根据设置的24小时制或12小时制显示不同的范围值供用户选择小时数
private final NumberPicker mHourSpinner; private final NumberPicker mHourSpinner;
// 用于选择分钟的NumberPicker组件范围是0到59分供用户选择具体的分钟数
private final NumberPicker mMinuteSpinner; private final NumberPicker mMinuteSpinner;
// 用于选择上午AM或下午PM的NumberPicker组件仅在12小时制下可见并起作用
private final NumberPicker mAmPmSpinner; private final NumberPicker mAmPmSpinner;
// 用于存储当前选择的日期时间信息的Calendar对象方便进行各种时间相关的计算和设置操作
private Calendar mDate; private Calendar mDate;
// 用于存储要在日期选择器中显示的一周日期的字符串数组,每个元素对应一周中的一天
private String[] mDateDisplayValues = new String[DAYS_IN_ALL_WEEK]; private String[] mDateDisplayValues = new String[DAYS_IN_ALL_WEEK];
// 用于标记当前时间是否处于上午AM初始值根据当前小时数判断大于等于12小时则为false即下午PM
private boolean mIsAm; private boolean mIsAm;
// 用于标记当前是否处于24小时制视图初始值根据系统设置来确定通过调用DateFormat.is24HourFormat(context)获取)
private boolean mIs24HourView; private boolean mIs24HourView;
// 用于标记该日期时间选择器是否启用初始值为默认启用状态DEFAULT_ENABLE_STATE
private boolean mIsEnabled = DEFAULT_ENABLE_STATE; private boolean mIsEnabled = DEFAULT_ENABLE_STATE;
// 用于标记是否正在进行初始化操作初始化为true在初始化完成后会设置为false用于避免一些不必要的重复操作或逻辑判断干扰
private boolean mInitialising; private boolean mInitialising;
// 定义一个接口类型的成员变量,用于设置当日期时间发生变化时的回调监听器,外部类可以实现该接口来响应时间变化事件
private OnDateTimeChangedListener mOnDateTimeChangedListener; private OnDateTimeChangedListener mOnDateTimeChangedListener;
// 日期选择器NumberPicker的值变化监听器当日期选择器的值发生改变时会触发此监听器内的逻辑
// 主要作用是根据选择的日期变化来更新内部的日期数据mDate并调用相关方法更新界面显示以及通知日期时间变化的监听器如果有设置
private NumberPicker.OnValueChangeListener mOnDateChangedListener = new NumberPicker.OnValueChangeListener() { private NumberPicker.OnValueChangeListener mOnDateChangedListener = new NumberPicker.OnValueChangeListener() {
@Override @Override
public void onValueChange(NumberPicker picker, int oldVal, int newVal) { public void onValueChange(NumberPicker picker, int oldVal, int newVal) {
// 根据新选择的日期与旧日期的差值调整内部存储的日期mDate实现日期的增减操作
mDate.add(Calendar.DAY_OF_YEAR, newVal - oldVal); mDate.add(Calendar.DAY_OF_YEAR, newVal - oldVal);
// 更新日期选择器的显示相关内容,比如更新显示的一周日期字符串等
updateDateControl(); updateDateControl();
// 通知日期时间发生了变化,触发设置的回调监听器(如果有)执行相应逻辑
onDateTimeChanged(); onDateTimeChanged();
} }
}; };
// 小时选择器NumberPicker的值变化监听器当小时选择器的值发生改变时会触发此监听器内的逻辑
// 会根据是否是24小时制以及新旧小时值的情况处理日期的变化跨天等情况、AM/PM的切换12小时制下以及更新内部日期时间数据和通知相关监听器等操作
private NumberPicker.OnValueChangeListener mOnHourChangedListener = new NumberPicker.OnValueChangeListener() { private NumberPicker.OnValueChangeListener mOnHourChangedListener = new NumberPicker.OnValueChangeListener() {
@Override @Override
public void onValueChange(NumberPicker picker, int oldVal, int newVal) { public void onValueChange(NumberPicker picker, int oldVal, int newVal) {
boolean isDateChanged = false; boolean isDateChanged = false;
Calendar cal = Calendar.getInstance(); Calendar cal = Calendar.getInstance();
// 如果不是24小时制即12小时制的情况
if (!mIs24HourView) { if (!mIs24HourView) {
// 从上午切换到下午11点到12点且跨越到下一天的情况
if (!mIsAm && oldVal == HOURS_IN_HALF_DAY - 1 && newVal == HOURS_IN_HALF_DAY) { if (!mIsAm && oldVal == HOURS_IN_HALF_DAY - 1 && newVal == HOURS_IN_HALF_DAY) {
cal.setTimeInMillis(mDate.getTimeInMillis()); cal.setTimeInMillis(mDate.getTimeInMillis());
cal.add(Calendar.DAY_OF_YEAR, 1); cal.add(Calendar.DAY_OF_YEAR, 1);
isDateChanged = true; isDateChanged = true;
} else if (mIsAm && oldVal == HOURS_IN_HALF_DAY && newVal == HOURS_IN_HALF_DAY - 1) { }
// 从下午切换到上午12点到11点且回退到上一天的情况
else if (mIsAm && oldVal == HOURS_IN_HALF_DAY && newVal == HOURS_IN_HALF_DAY - 1) {
cal.setTimeInMillis(mDate.getTimeInMillis()); cal.setTimeInMillis(mDate.getTimeInMillis());
cal.add(Calendar.DAY_OF_YEAR, -1); cal.add(Calendar.DAY_OF_YEAR, -1);
isDateChanged = true; isDateChanged = true;
} }
// 处理11点到12点或者12点到11点切换时AM/PM状态的改变并更新对应的AM/PM控制显示
if (oldVal == HOURS_IN_HALF_DAY - 1 && newVal == HOURS_IN_HALF_DAY || if (oldVal == HOURS_IN_HALF_DAY - 1 && newVal == HOURS_IN_HALF_DAY ||
oldVal == HOURS_IN_HALF_DAY && newVal == HOURS_IN_HALF_DAY - 1) { oldVal == HOURS_IN_HALF_DAY && newVal == HOURS_IN_HALF_DAY - 1) {
mIsAm = !mIsAm; mIsAm =!mIsAm;
updateAmPmControl(); updateAmPmControl();
} }
} else { } else {
// 24小时制下从23时切换到0时跨天的情况
if (oldVal == HOURS_IN_ALL_DAY - 1 && newVal == 0) { if (oldVal == HOURS_IN_ALL_DAY - 1 && newVal == 0) {
cal.setTimeInMillis(mDate.getTimeInMillis()); cal.setTimeInMillis(mDate.getTimeInMillis());
cal.add(Calendar.DAY_OF_YEAR, 1); cal.add(Calendar.DAY_OF_YEAR, 1);
isDateChanged = true; isDateChanged = true;
} else if (oldVal == 0 && newVal == HOURS_IN_ALL_DAY - 1) { }
// 24小时制下从0时切换到23时回退一天的情况
else if (oldVal == 0 && newVal == HOURS_IN_ALL_DAY - 1) {
cal.setTimeInMillis(mDate.getTimeInMillis()); cal.setTimeInMillis(mDate.getTimeInMillis());
cal.add(Calendar.DAY_OF_YEAR, -1); cal.add(Calendar.DAY_OF_YEAR, -1);
isDateChanged = true; isDateChanged = true;
} }
} }
int newHour = mHourSpinner.getValue() % HOURS_IN_HALF_DAY + (mIsAm ? 0 : HOURS_IN_HALF_DAY); // 根据是否是12小时制以及当前的AM/PM状态计算出正确的小时数并设置到内部的日期对象mDate
int newHour = mHourSpinner.getValue() % HOURS_IN_HALF_DAY + (mIsAm? 0 : HOURS_IN_HALF_DAY);
mDate.set(Calendar.HOUR_OF_DAY, newHour); mDate.set(Calendar.HOUR_OF_DAY, newHour);
// 通知日期时间发生了变化,触发设置的回调监听器(如果有)执行相应逻辑
onDateTimeChanged(); onDateTimeChanged();
// 如果日期发生了变化更新当前的年、月、日信息到内部的日期对象mDate
if (isDateChanged) { if (isDateChanged) {
setCurrentYear(cal.get(Calendar.YEAR)); setCurrentYear(cal.get(Calendar.YEAR));
setCurrentMonth(cal.get(Calendar.MONTH)); setCurrentMonth(cal.get(Calendar.MONTH));
@ -115,18 +158,23 @@ public class DateTimePicker extends FrameLayout {
} }
}; };
// 分钟选择器NumberPicker的值变化监听器当分钟选择器的值发生改变时会触发此监听器内的逻辑
// 会处理分钟变化导致的小时变化跨小时等情况、AM/PM的切换影响到跨12点时以及更新内部日期时间数据和通知相关监听器等操作
private NumberPicker.OnValueChangeListener mOnMinuteChangedListener = new NumberPicker.OnValueChangeListener() { private NumberPicker.OnValueChangeListener mOnMinuteChangedListener = new NumberPicker.OnValueChangeListener() {
@Override @Override
public void onValueChange(NumberPicker picker, int oldVal, int newVal) { public void onValueChange(NumberPicker picker, int oldVal, int newVal) {
int minValue = mMinuteSpinner.getMinValue(); int minValue = mMinuteSpinner.getMinValue();
int maxValue = mMinuteSpinner.getMaxValue(); int maxValue = mMinuteSpinner.getMaxValue();
int offset = 0; int offset = 0;
// 分钟从最大值变为最小值如59分变为0分可能跨小时的情况
if (oldVal == maxValue && newVal == minValue) { if (oldVal == maxValue && newVal == minValue) {
offset += 1; offset += 1;
} else if (oldVal == minValue && newVal == maxValue) { }
// 分钟从最小值变为最大值如0分变为59分可能跨小时的情况
else if (oldVal == minValue && newVal == maxValue) {
offset -= 1; offset -= 1;
} }
if (offset != 0) { if (offset!= 0) {
mDate.add(Calendar.HOUR_OF_DAY, offset); mDate.add(Calendar.HOUR_OF_DAY, offset);
mHourSpinner.setValue(getCurrentHour()); mHourSpinner.setValue(getCurrentHour());
updateDateControl(); updateDateControl();
@ -144,10 +192,12 @@ public class DateTimePicker extends FrameLayout {
} }
}; };
// AM/PM选择器NumberPicker的值变化监听器当AM/PM选择器的值发生改变时会触发此监听器内的逻辑
// 主要作用是根据AM/PM的切换来调整内部日期时间数据增减12小时更新AM/PM控制显示以及通知日期时间变化的监听器如果有执行相应逻辑
private NumberPicker.OnValueChangeListener mOnAmPmChangedListener = new NumberPicker.OnValueChangeListener() { private NumberPicker.OnValueChangeListener mOnAmPmChangedListener = new NumberPicker.OnValueChangeListener() {
@Override @Override
public void onValueChange(NumberPicker picker, int oldVal, int newVal) { public void onValueChange(NumberPicker picker, int oldVal, int newVal) {
mIsAm = !mIsAm; mIsAm =!mIsAm;
if (mIsAm) { if (mIsAm) {
mDate.add(Calendar.HOUR_OF_DAY, -HOURS_IN_HALF_DAY); mDate.add(Calendar.HOUR_OF_DAY, -HOURS_IN_HALF_DAY);
} else { } else {
@ -158,39 +208,51 @@ public class DateTimePicker extends FrameLayout {
} }
}; };
// 定义一个接口用于外部类实现当日期时间在DateTimePicker中发生变化时会回调此接口的方法传递相关的日期时间参数
public interface OnDateTimeChangedListener { public interface OnDateTimeChangedListener {
void onDateTimeChanged(DateTimePicker view, int year, int month, void onDateTimeChanged(DateTimePicker view, int year, int month,
int dayOfMonth, int hourOfDay, int minute); int dayOfMonth, int hourOfDay, int minute);
} }
// 构造函数使用默认的当前时间System.currentTimeMillis()来初始化DateTimePicker调用另一个构造函数传递当前时间和系统默认的时间显示格式24小时制或12小时制来完成初始化
public DateTimePicker(Context context) { public DateTimePicker(Context context) {
this(context, System.currentTimeMillis()); this(context, System.currentTimeMillis());
} }
// 构造函数使用指定的时间date参数来初始化DateTimePicker调用另一个构造函数传递指定时间和系统默认的时间显示格式24小时制或12小时制来完成初始化
public DateTimePicker(Context context, long date) { public DateTimePicker(Context context, long date) {
this(context, date, DateFormat.is24HourFormat(context)); this(context, date, DateFormat.is24HourFormat(context));
} }
// 主要的构造函数完成DateTimePicker的初始化工作包括加载布局、初始化各个NumberPicker组件及其监听器、设置初始时间、设置启用状态以及一些初始的显示控制等操作
public DateTimePicker(Context context, long date, boolean is24HourView) { public DateTimePicker(Context context, long date, boolean is24HourView) {
super(context); super(context);
// 获取一个默认的Calendar实例用于存储和操作当前的日期时间信息
mDate = Calendar.getInstance(); mDate = Calendar.getInstance();
mInitialising = true; mInitialising = true;
// 根据当前小时数判断初始的AM/PM状态大于等于12小时则为下午PM即mIsAm为false
mIsAm = getCurrentHourOfDay() >= HOURS_IN_HALF_DAY; mIsAm = getCurrentHourOfDay() >= HOURS_IN_HALF_DAY;
// 加载指定的布局文件R.layout.datetime_picker到该FrameLayout中用于显示日期时间选择的各个组件
inflate(context, R.layout.datetime_picker, this); inflate(context, R.layout.datetime_picker, this);
// 获取布局中的日期选择器NumberPicker组件并进行相关设置如设置最小值、最大值以及值变化监听器
mDateSpinner = (NumberPicker) findViewById(R.id.date); mDateSpinner = (NumberPicker) findViewById(R.id.date);
mDateSpinner.setMinValue(DATE_SPINNER_MIN_VAL); mDateSpinner.setMinValue(DATE_SPINNER_MIN_VAL);
mDateSpinner.setMaxValue(DATE_SPINNER_MAX_VAL); mDateSpinner.setMaxValue(DATE_SPINNER_MAX_VAL);
mDateSpinner.setOnValueChangedListener(mOnDateChangedListener); mDateSpinner.setOnValueChangedListener(mOnDateChangedListener);
// 获取布局中的小时选择器NumberPicker组件并设置值变化监听器
mHourSpinner = (NumberPicker) findViewById(R.id.hour); mHourSpinner = (NumberPicker) findViewById(R.id.hour);
mHourSpinner.setOnValueChangedListener(mOnHourChangedListener); mHourSpinner.setOnValueChangedListener(mOnHourChangedListener);
// 获取布局中的分钟选择器NumberPicker组件设置最小值、最大值、长按更新间隔等并设置值变化监听器
mMinuteSpinner = (NumberPicker) findViewById(R.id.minute); mMinuteSpinner = (NumberPicker) findViewById(R.id.minute);
mMinuteSpinner.setMinValue(MINUT_SPINNER_MIN_VAL); mMinuteSpinner.setMinValue(MINUT_SPINNER_MIN_VAL);
mMinuteSpinner.setMaxValue(MINUT_SPINNER_MAX_VAL); mMinuteSpinner.setMaxValue(MINUT_SPINNER_MAX_VAL);
mMinuteSpinner.setOnLongPressUpdateInterval(100); mMinuteSpinner.setOnLongPressUpdateInterval(100);
mMinuteSpinner.setOnValueChangedListener(mOnMinuteChangedListener); mMinuteSpinner.setOnValueChangedListener(mOnMinuteChangedListener);
// 获取用于显示AM/PM的字符串数组根据系统语言环境等获取本地化的AM/PM表示并设置到AM/PM选择器NumberPicker组件中包括设置最小值、最大值、显示值以及值变化监听器
String[] stringsForAmPm = new DateFormatSymbols().getAmPmStrings(); String[] stringsForAmPm = new DateFormatSymbols().getAmPmStrings();
mAmPmSpinner = (NumberPicker) findViewById(R.id.amPm); mAmPmSpinner = (NumberPicker) findViewById(R.id.amPm);
mAmPmSpinner.setMinValue(AMPM_SPINNER_MIN_VAL); mAmPmSpinner.setMinValue(AMPM_SPINNER_MIN_VAL);
@ -198,288 +260,22 @@ public class DateTimePicker extends FrameLayout {
mAmPmSpinner.setDisplayedValues(stringsForAmPm); mAmPmSpinner.setDisplayedValues(stringsForAmPm);
mAmPmSpinner.setOnValueChangedListener(mOnAmPmChangedListener); mAmPmSpinner.setOnValueChangedListener(mOnAmPmChangedListener);
// update controls to initial state // 更新各个相关的控制显示使其处于初始状态比如日期选择器显示的一周日期字符串、小时选择器的范围显示、AM/PM选择器的初始可见性等
updateDateControl(); updateDateControl();
updateHourControl(); updateHourControl();
updateAmPmControl(); updateAmPmControl();
// 设置是否为24小时制视图根据传入的参数决定并相应地调整相关组件的显示和值范围等
set24HourView(is24HourView); set24HourView(is24HourView);
// set to current time // 设置当前显示的日期时间为传入的指定日期date参数通过设置年、月、日、小时、分钟等各个部分来完成
setCurrentDate(date); setCurrentDate(date);
// 设置该日期时间选择器的启用状态根据当前的启用状态mIsEnabled来决定
setEnabled(isEnabled()); setEnabled(isEnabled());
// set the content descriptions // 初始化完成将标记设置为false表示不再处于初始化阶段
mInitialising = false; mInitialising = false;
} }
@Override // 重写父类的setEnabled方法用于设置整个日期时间选择器及其内部
public void setEnabled(boolean enabled) {
if (mIsEnabled == enabled) {
return;
}
super.setEnabled(enabled);
mDateSpinner.setEnabled(enabled);
mMinuteSpinner.setEnabled(enabled);
mHourSpinner.setEnabled(enabled);
mAmPmSpinner.setEnabled(enabled);
mIsEnabled = enabled;
}
@Override
public boolean isEnabled() {
return mIsEnabled;
}
/**
* Get the current date in millis
*
* @return the current date in millis
*/
public long getCurrentDateInTimeMillis() {
return mDate.getTimeInMillis();
}
/**
* Set the current date
*
* @param date The current date in millis
*/
public void setCurrentDate(long date) {
Calendar cal = Calendar.getInstance();
cal.setTimeInMillis(date);
setCurrentDate(cal.get(Calendar.YEAR), cal.get(Calendar.MONTH), cal.get(Calendar.DAY_OF_MONTH),
cal.get(Calendar.HOUR_OF_DAY), cal.get(Calendar.MINUTE));
}
/**
* Set the current date
*
* @param year The current year
* @param month The current month
* @param dayOfMonth The current dayOfMonth
* @param hourOfDay The current hourOfDay
* @param minute The current minute
*/
public void setCurrentDate(int year, int month,
int dayOfMonth, int hourOfDay, int minute) {
setCurrentYear(year);
setCurrentMonth(month);
setCurrentDay(dayOfMonth);
setCurrentHour(hourOfDay);
setCurrentMinute(minute);
}
/**
* Get current year
*
* @return The current year
*/
public int getCurrentYear() {
return mDate.get(Calendar.YEAR);
}
/**
* Set current year
*
* @param year The current year
*/
public void setCurrentYear(int year) {
if (!mInitialising && year == getCurrentYear()) {
return;
}
mDate.set(Calendar.YEAR, year);
updateDateControl();
onDateTimeChanged();
}
/**
* Get current month in the year
*
* @return The current month in the year
*/
public int getCurrentMonth() {
return mDate.get(Calendar.MONTH);
}
/**
* Set current month in the year
*
* @param month The month in the year
*/
public void setCurrentMonth(int month) {
if (!mInitialising && month == getCurrentMonth()) {
return;
}
mDate.set(Calendar.MONTH, month);
updateDateControl();
onDateTimeChanged();
}
/**
* Get current day of the month
*
* @return The day of the month
*/
public int getCurrentDay() {
return mDate.get(Calendar.DAY_OF_MONTH);
}
/**
* Set current day of the month
*
* @param dayOfMonth The day of the month
*/
public void setCurrentDay(int dayOfMonth) {
if (!mInitialising && dayOfMonth == getCurrentDay()) {
return;
}
mDate.set(Calendar.DAY_OF_MONTH, dayOfMonth);
updateDateControl();
onDateTimeChanged();
}
/**
* Get current hour in 24 hour mode, in the range (0~23)
* @return The current hour in 24 hour mode
*/
public int getCurrentHourOfDay() {
return mDate.get(Calendar.HOUR_OF_DAY);
}
private int getCurrentHour() {
if (mIs24HourView){
return getCurrentHourOfDay();
} else {
int hour = getCurrentHourOfDay();
if (hour > HOURS_IN_HALF_DAY) {
return hour - HOURS_IN_HALF_DAY;
} else {
return hour == 0 ? HOURS_IN_HALF_DAY : hour;
}
}
}
/**
* Set current hour in 24 hour mode, in the range (0~23)
*
* @param hourOfDay
*/
public void setCurrentHour(int hourOfDay) {
if (!mInitialising && hourOfDay == getCurrentHourOfDay()) {
return;
}
mDate.set(Calendar.HOUR_OF_DAY, hourOfDay);
if (!mIs24HourView) {
if (hourOfDay >= HOURS_IN_HALF_DAY) {
mIsAm = false;
if (hourOfDay > HOURS_IN_HALF_DAY) {
hourOfDay -= HOURS_IN_HALF_DAY;
}
} else {
mIsAm = true;
if (hourOfDay == 0) {
hourOfDay = HOURS_IN_HALF_DAY;
}
}
updateAmPmControl();
}
mHourSpinner.setValue(hourOfDay);
onDateTimeChanged();
}
/**
* Get currentMinute
*
* @return The Current Minute
*/
public int getCurrentMinute() {
return mDate.get(Calendar.MINUTE);
}
/**
* Set current minute
*/
public void setCurrentMinute(int minute) {
if (!mInitialising && minute == getCurrentMinute()) {
return;
}
mMinuteSpinner.setValue(minute);
mDate.set(Calendar.MINUTE, minute);
onDateTimeChanged();
}
/**
* @return true if this is in 24 hour view else false.
*/
public boolean is24HourView () {
return mIs24HourView;
}
/**
* Set whether in 24 hour or AM/PM mode.
*
* @param is24HourView True for 24 hour mode. False for AM/PM mode.
*/
public void set24HourView(boolean is24HourView) {
if (mIs24HourView == is24HourView) {
return;
}
mIs24HourView = is24HourView;
mAmPmSpinner.setVisibility(is24HourView ? View.GONE : View.VISIBLE);
int hour = getCurrentHourOfDay();
updateHourControl();
setCurrentHour(hour);
updateAmPmControl();
}
private void updateDateControl() {
Calendar cal = Calendar.getInstance();
cal.setTimeInMillis(mDate.getTimeInMillis());
cal.add(Calendar.DAY_OF_YEAR, -DAYS_IN_ALL_WEEK / 2 - 1);
mDateSpinner.setDisplayedValues(null);
for (int i = 0; i < DAYS_IN_ALL_WEEK; ++i) {
cal.add(Calendar.DAY_OF_YEAR, 1);
mDateDisplayValues[i] = (String) DateFormat.format("MM.dd EEEE", cal);
}
mDateSpinner.setDisplayedValues(mDateDisplayValues);
mDateSpinner.setValue(DAYS_IN_ALL_WEEK / 2);
mDateSpinner.invalidate();
}
private void updateAmPmControl() {
if (mIs24HourView) {
mAmPmSpinner.setVisibility(View.GONE);
} else {
int index = mIsAm ? Calendar.AM : Calendar.PM;
mAmPmSpinner.setValue(index);
mAmPmSpinner.setVisibility(View.VISIBLE);
}
}
private void updateHourControl() {
if (mIs24HourView) {
mHourSpinner.setMinValue(HOUR_SPINNER_MIN_VAL_24_HOUR_VIEW);
mHourSpinner.setMaxValue(HOUR_SPINNER_MAX_VAL_24_HOUR_VIEW);
} else {
mHourSpinner.setMinValue(HOUR_SPINNER_MIN_VAL_12_HOUR_VIEW);
mHourSpinner.setMaxValue(HOUR_SPINNER_MAX_VAL_12_HOUR_VIEW);
}
}
/**
* Set the callback that indicates the 'Set' button has been pressed.
* @param callback the callback, if null will do nothing
*/
public void setOnDateTimeChangedListener(OnDateTimeChangedListener callback) {
mOnDateTimeChangedListener = callback;
}
private void onDateTimeChanged() {
if (mOnDateTimeChangedListener != null) {
mOnDateTimeChangedListener.onDateTimeChanged(this, getCurrentYear(),
getCurrentMonth(), getCurrentDay(), getCurrentHourOfDay(), getCurrentMinute());
}
}
}

@ -29,24 +29,37 @@ import android.content.DialogInterface.OnClickListener;
import android.text.format.DateFormat; import android.text.format.DateFormat;
import android.text.format.DateUtils; import android.text.format.DateUtils;
// DateTimePickerDialog类继承自AlertDialog并实现了OnClickListener接口它是一个自定义的对话框用于展示日期和时间选择的界面
// 让用户可以方便地选择具体的日期和时间,并在用户确认选择后通过回调接口通知外部相应的操作。
public class DateTimePickerDialog extends AlertDialog implements OnClickListener { public class DateTimePickerDialog extends AlertDialog implements OnClickListener {
// 用于存储当前选择的日期时间信息的Calendar对象初始化为获取当前系统时间对应的Calendar实例方便后续进行各种日期时间相关的操作和设置。
private Calendar mDate = Calendar.getInstance(); private Calendar mDate = Calendar.getInstance();
// 用于标记当前是否处于24小时制视图用于控制时间显示格式以及相关逻辑判断等操作。
private boolean mIs24HourView; private boolean mIs24HourView;
// 定义一个接口类型的成员变量,用于设置当用户设置好日期时间并确认时的回调监听器,外部类可以实现该接口来响应确认操作事件。
private OnDateTimeSetListener mOnDateTimeSetListener; private OnDateTimeSetListener mOnDateTimeSetListener;
// 用于实际显示日期和时间选择界面的DateTimePicker自定义组件通过它实现具体的日期时间选择交互功能。
private DateTimePicker mDateTimePicker; private DateTimePicker mDateTimePicker;
// 定义一个接口,用于外部类实现,当用户在对话框中设置好日期时间并点击确认按钮后,会回调此接口的方法,传递包含该对话框以及选择的日期时间(以毫秒表示)的参数。
public interface OnDateTimeSetListener { public interface OnDateTimeSetListener {
void OnDateTimeSet(AlertDialog dialog, long date); void OnDateTimeSet(AlertDialog dialog, long date);
} }
// 构造函数用于创建DateTimePickerDialog实例接收上下文和初始日期以毫秒表示作为参数完成对话框的基本初始化设置工作
// 包括创建DateTimePicker组件、设置其相关监听器、初始化显示的日期时间、设置对话框的按钮以及标题等内容。
public DateTimePickerDialog(Context context, long date) { public DateTimePickerDialog(Context context, long date) {
super(context); super(context);
// 创建一个DateTimePicker实例用于在对话框中展示日期时间选择界面传入当前上下文环境。
mDateTimePicker = new DateTimePicker(context); mDateTimePicker = new DateTimePicker(context);
// 将DateTimePicker组件设置为对话框的显示内容使其在对话框中展示出来供用户操作。
setView(mDateTimePicker); setView(mDateTimePicker);
// 为DateTimePicker组件设置日期时间变化监听器当用户在DateTimePicker中改变了日期、时间等任何相关值时会触发此监听器内的逻辑。
// 主要作用是根据用户选择的新值更新内部存储的日期时间信息mDate并更新对话框的标题显示以实时反映当前选择的日期时间。
mDateTimePicker.setOnDateTimeChangedListener(new OnDateTimeChangedListener() { mDateTimePicker.setOnDateTimeChangedListener(new OnDateTimeChangedListener() {
public void onDateTimeChanged(DateTimePicker view, int year, int month, public void onDateTimeChanged(DateTimePicker view, int year, int month,
int dayOfMonth, int hourOfDay, int minute) { int dayOfMonth, int hourOfDay, int minute) {
mDate.set(Calendar.YEAR, year); mDate.set(Calendar.YEAR, year);
mDate.set(Calendar.MONTH, month); mDate.set(Calendar.MONTH, month);
mDate.set(Calendar.DAY_OF_MONTH, dayOfMonth); mDate.set(Calendar.DAY_OF_MONTH, dayOfMonth);
@ -55,34 +68,48 @@ public class DateTimePickerDialog extends AlertDialog implements OnClickListener
updateTitle(mDate.getTimeInMillis()); updateTitle(mDate.getTimeInMillis());
} }
}); });
// 设置初始显示的日期时间将传入的日期以毫秒表示设置到内部的日期时间对象mDate并将秒数设置为0确保初始时间的准确性。
mDate.setTimeInMillis(date); mDate.setTimeInMillis(date);
mDate.set(Calendar.SECOND, 0); mDate.set(Calendar.SECOND, 0);
// 将DateTimePicker组件显示的日期时间设置为当前初始化的日期时间使其在界面上初始展示正确的时间内容。
mDateTimePicker.setCurrentDate(mDate.getTimeInMillis()); mDateTimePicker.setCurrentDate(mDate.getTimeInMillis());
// 设置对话框的确认按钮(通常显示为"确定"之类的文本传入对应文本资源的字符串并设置按钮点击事件的监听器为当前类自身因为实现了OnClickListener接口
setButton(context.getString(R.string.datetime_dialog_ok), this); setButton(context.getString(R.string.datetime_dialog_ok), this);
// 设置对话框的取消按钮(通常显示为"取消"之类的文本传入对应文本资源的字符串并传入null作为点击事件监听器表示默认的取消行为。
setButton2(context.getString(R.string.datetime_dialog_cancel), (OnClickListener)null); setButton2(context.getString(R.string.datetime_dialog_cancel), (OnClickListener)null);
// 根据系统当前设置判断是否为24小时制视图调用DateFormat.is24HourFormat方法获取并设置以决定时间选择器的显示格式。
set24HourView(DateFormat.is24HourFormat(this.getContext())); set24HourView(DateFormat.is24HourFormat(this.getContext()));
// 初始更新一次对话框的标题使其显示当前设置的日期时间信息调用updateTitle方法传入当前日期时间的毫秒数来完成更新。
updateTitle(mDate.getTimeInMillis()); updateTitle(mDate.getTimeInMillis());
} }
// 用于设置当前是否为24小时制视图的方法接收一个布尔值参数更新内部的标记变量mIs24HourView外部可以通过调用此方法来动态切换时间显示格式。
public void set24HourView(boolean is24HourView) { public void set24HourView(boolean is24HourView) {
mIs24HourView = is24HourView; mIs24HourView = is24HourView;
} }
// 用于设置日期时间确认回调监听器的方法接收一个实现了OnDateTimeSetListener接口的对象作为参数将其赋值给内部的监听器成员变量
// 外部可以通过调用此方法来注册自己的监听器,以便在用户确认选择日期时间后执行相应的逻辑。
public void setOnDateTimeSetListener(OnDateTimeSetListener callBack) { public void setOnDateTimeSetListener(OnDateTimeSetListener callBack) {
mOnDateTimeSetListener = callBack; mOnDateTimeSetListener = callBack;
} }
// 用于更新对话框标题显示的私有方法,根据传入的日期时间(以毫秒表示)以及当前的时间显示格式等设置,格式化日期时间字符串并设置为对话框的标题内容,
// 使其能准确展示当前选择的日期时间信息,方便用户查看确认。
private void updateTitle(long date) { private void updateTitle(long date) {
int flag = int flag =
DateUtils.FORMAT_SHOW_YEAR | DateUtils.FORMAT_SHOW_YEAR |
DateUtils.FORMAT_SHOW_DATE | DateUtils.FORMAT_SHOW_DATE |
DateUtils.FORMAT_SHOW_TIME; DateUtils.FORMAT_SHOW_TIME;
flag |= mIs24HourView ? DateUtils.FORMAT_24HOUR : DateUtils.FORMAT_24HOUR; flag |= mIs24HourView? DateUtils.FORMAT_24HOUR : DateUtils.FORMAT_24HOUR;
setTitle(DateUtils.formatDateTime(this.getContext(), date, flag)); setTitle(DateUtils.formatDateTime(this.getContext(), date, flag));
} }
// 实现OnClickListener接口的方法用于处理对话框按钮点击事件当用户点击确认按钮通过传入的参数判断
// 如果设置了日期时间确认回调监听器mOnDateTimeSetListener不为null则调用该监听器的方法传递当前对话框实例和当前选择的日期时间以毫秒表示参数
// 通知外部用户已完成日期时间设置并确认的操作。
public void onClick(DialogInterface arg0, int arg1) { public void onClick(DialogInterface arg0, int arg1) {
if (mOnDateTimeSetListener != null) { if (mOnDateTimeSetListener!= null) {
mOnDateTimeSetListener.OnDateTimeSet(this, mDate.getTimeInMillis()); mOnDateTimeSetListener.OnDateTimeSet(this, mDate.getTimeInMillis());
} }
} }

@ -27,17 +27,31 @@ import android.widget.PopupMenu.OnMenuItemClickListener;
import net.micode.notes.R; import net.micode.notes.R;
// DropdownMenu类用于创建一个下拉菜单的功能组件它将一个按钮与一个PopupMenu关联起来点击按钮时弹出菜单
// 并且可以设置菜单选项的点击监听器、查找菜单项以及设置按钮显示的标题等操作。
public class DropdownMenu { public class DropdownMenu {
// 用于显示下拉菜单的触发按钮,用户点击此按钮会弹出对应的下拉菜单。
private Button mButton; private Button mButton;
// 实际的PopupMenu对象用于承载和展示下拉菜单的内容包含多个菜单项供用户选择操作。
private PopupMenu mPopupMenu; private PopupMenu mPopupMenu;
// 对应PopupMenu中的菜单对象通过它可以进行如查找菜单项等与菜单内容相关的操作。
private Menu mMenu; private Menu mMenu;
// 构造函数用于初始化DropdownMenu实例接收上下文、触发按钮以及菜单资源ID作为参数完成下拉菜单的基本构建工作
// 包括设置按钮背景、创建PopupMenu、加载菜单资源以及为按钮设置点击监听器以弹出菜单等操作。
public DropdownMenu(Context context, Button button, int menuId) { public DropdownMenu(Context context, Button button, int menuId) {
// 将传入的按钮对象赋值给成员变量,后续通过此按钮来触发下拉菜单的显示。
mButton = button; mButton = button;
// 为按钮设置背景资源使用指定的资源IDR.drawable.dropdown_icon来设置按钮的外观样式使其显示为一个具有下拉箭头等特征的图标样式通常
mButton.setBackgroundResource(R.drawable.dropdown_icon); mButton.setBackgroundResource(R.drawable.dropdown_icon);
// 创建一个PopupMenu实例传入上下文和触发按钮作为参数使得PopupMenu与对应的按钮关联起来并且会根据按钮的位置等情况来显示弹出菜单。
mPopupMenu = new PopupMenu(context, mButton); mPopupMenu = new PopupMenu(context, mButton);
// 获取PopupMenu中的菜单对象赋值给成员变量方便后续对菜单内容进行操作比如查找菜单项等。
mMenu = mPopupMenu.getMenu(); mMenu = mPopupMenu.getMenu();
// 通过菜单填充器MenuInflater将指定的菜单资源由menuId指定加载到PopupMenu的菜单对象中从而显示出具体的菜单项内容。
mPopupMenu.getMenuInflater().inflate(menuId, mMenu); mPopupMenu.getMenuInflater().inflate(menuId, mMenu);
// 为按钮设置点击监听器当按钮被点击时触发内部的逻辑即显示与之关联的PopupMenu实现点击按钮弹出下拉菜单的功能。
mButton.setOnClickListener(new OnClickListener() { mButton.setOnClickListener(new OnClickListener() {
public void onClick(View v) { public void onClick(View v) {
mPopupMenu.show(); mPopupMenu.show();
@ -45,16 +59,22 @@ public class DropdownMenu {
}); });
} }
// 用于设置下拉菜单中菜单项点击监听器的方法接收一个实现了OnMenuItemClickListener接口的对象作为参数
// 将其设置给PopupMenu使得当用户点击下拉菜单中的任意菜单项时能够触发相应的逻辑处理外部可以通过此方法来响应菜单项的点击操作。
public void setOnDropdownMenuItemClickListener(OnMenuItemClickListener listener) { public void setOnDropdownMenuItemClickListener(OnMenuItemClickListener listener) {
if (mPopupMenu != null) { if (mPopupMenu!= null) {
mPopupMenu.setOnMenuItemClickListener(listener); mPopupMenu.setOnMenuItemClickListener(listener);
} }
} }
// 用于在菜单中查找指定ID的菜单项的方法接收一个菜单项的ID作为参数通过调用菜单对象mMenu的findItem方法来查找对应的菜单项
// 返回查找到的MenuItem对象方便外部对特定菜单项进行进一步的操作比如获取菜单项属性、修改菜单项状态等。
public MenuItem findItem(int id) { public MenuItem findItem(int id) {
return mMenu.findItem(id); return mMenu.findItem(id);
} }
// 用于设置触发下拉菜单的按钮显示标题的方法,接收一个字符序列(通常是字符串)作为参数,将其设置为按钮显示的文本内容,
// 这样可以根据需要动态改变按钮上显示的提示信息,例如显示当前选中的菜单项相关内容等。
public void setTitle(CharSequence title) { public void setTitle(CharSequence title) {
mButton.setText(title); mButton.setText(title);
} }

@ -29,52 +29,74 @@ import net.micode.notes.data.Notes;
import net.micode.notes.data.Notes.NoteColumns; import net.micode.notes.data.Notes.NoteColumns;
// FoldersListAdapter类继承自CursorAdapter它主要用于将数据库查询得到的游标数据Cursor适配显示到特定的视图列表中
// 在这里是用于展示文件夹相关信息的列表,比如文件夹名称等内容,并且提供了获取文件夹名称等相关的辅助方法。
public class FoldersListAdapter extends CursorAdapter { public class FoldersListAdapter extends CursorAdapter {
// 定义一个字符串数组用于指定从数据库查询时要获取的列名这里包含笔记的ID和摘要信息可能用于表示文件夹相关的标识或其他关联内容两列。
public static final String [] PROJECTION = { public static final String [] PROJECTION = {
NoteColumns.ID, NoteColumns.ID,
NoteColumns.SNIPPET NoteColumns.SNIPPET
}; };
// 定义常量表示查询结果中笔记ID所在列的索引值为0方便后续从游标中获取对应数据这里命名为ID_COLUMN。
public static final int ID_COLUMN = 0; public static final int ID_COLUMN = 0;
// 定义常量表示查询结果中摘要信息在这里用于表示文件夹名称相关内容所在列的索引值为1方便后续从游标中获取对应数据命名为NAME_COLUMN。
public static final int NAME_COLUMN = 1; public static final int NAME_COLUMN = 1;
// 构造函数接收上下文和游标Cursor作为参数调用父类的构造函数来完成基本的初始化工作
// 这里暂时没有额外的自定义初始化逻辑(除了调用父类构造函数),只是保留了构造函数的标准写法,注释中提示了待完善的部分(可能后续会添加更多初始化相关操作)。
public FoldersListAdapter(Context context, Cursor c) { public FoldersListAdapter(Context context, Cursor c) {
super(context, c); super(context, c);
// TODO Auto-generated constructor stub // TODO Auto-generated constructor stub
} }
// 重写CursorAdapter的newView方法该方法用于创建一个新的视图View对象用于显示列表中的每一项数据
// 在这里返回一个自定义的FolderListItem视图意味着每一项列表数据将会使用这个自定义视图来展示相关信息。
@Override @Override
public View newView(Context context, Cursor cursor, ViewGroup parent) { public View newView(Context context, Cursor cursor, ViewGroup parent) {
return new FolderListItem(context); return new FolderListItem(context);
} }
// 重写CursorAdapter的bindView方法该方法用于将游标Cursor中的数据绑定到已创建的视图View也就是填充具体的数据到视图中进行显示
// 在这里根据游标中的数据情况判断如果是根文件夹通过ID判断则显示特定的字符串可能是代表根文件夹的固定文本否则显示游标中对应列的字符串内容文件夹名称
// 然后调用自定义视图FolderListItem的bind方法将名称设置到对应的TextView上进行显示。
@Override @Override
public void bindView(View view, Context context, Cursor cursor) { public void bindView(View view, Context context, Cursor cursor) {
if (view instanceof FolderListItem) { if (view instanceof FolderListItem) {
String folderName = (cursor.getLong(ID_COLUMN) == Notes.ID_ROOT_FOLDER) ? context String folderName = (cursor.getLong(ID_COLUMN) == Notes.ID_ROOT_FOLDER)? context
.getString(R.string.menu_move_parent_folder) : cursor.getString(NAME_COLUMN); .getString(R.string.menu_move_parent_folder) : cursor.getString(NAME_COLUMN);
((FolderListItem) view).bind(folderName); ((FolderListItem) view).bind(folderName);
} }
} }
// 提供的一个公共方法,用于获取指定位置的文件夹名称,接收上下文和位置索引作为参数,
// 通过调用getItem方法获取对应位置的游标对象然后根据游标中数据判断是根文件夹还是普通文件夹返回相应的名称字符串。
public String getFolderName(Context context, int position) { public String getFolderName(Context context, int position) {
Cursor cursor = (Cursor) getItem(position); Cursor cursor = (Cursor) getItem(position);
return (cursor.getLong(ID_COLUMN) == Notes.ID_ROOT_FOLDER) ? context return (cursor.getLong(ID_COLUMN) == Notes.ID_ROOT_FOLDER)? context
.getString(R.string.menu_move_parent_folder) : cursor.getString(NAME_COLUMN); .getString(R.string.menu_move_parent_folder) : cursor.getString(NAME_COLUMN);
} }
// 定义了一个内部私有类FolderListItem它继承自LinearLayout用于作为列表中每一项数据展示的自定义视图布局
// 包含了一个TextView用于显示文件夹名称并且提供了一个bind方法用于将名称设置到这个TextView上进行展示。
private class FolderListItem extends LinearLayout { private class FolderListItem extends LinearLayout {
// 用于显示文件夹名称的TextView组件通过它将文件夹相关的名称信息展示给用户。
private TextView mName; private TextView mName;
// 构造函数接收上下文作为参数调用父类LinearLayout的构造函数完成基本初始化
// 然后通过LayoutInflater将指定的布局文件R.layout.folder_list_item加载到这个视图中
// 最后获取布局中的TextView组件用于后续设置名称显示。
public FolderListItem(Context context) { public FolderListItem(Context context) {
super(context); super(context);
inflate(context, R.layout.folder_list_item, this); inflate(context, R.layout.folder_list_item, this);
mName = (TextView) findViewById(R.id.tv_folder_name); mName = (TextView) findViewById(R.id.tv_folder_name);
} }
// 用于将传入的文件夹名称设置到内部的TextViewmName上进行显示的方法外部通过调用此方法来更新视图中显示的文件夹名称内容。
public void bind(String name) { public void bind(String name) {
mName.setText(name); mName.setText(name);
} }
} }
} }

@ -72,18 +72,19 @@ import java.util.regex.Matcher;
import java.util.regex.Pattern; import java.util.regex.Pattern;
// NoteEditActivity类继承自Activity实现了多个接口用于处理笔记编辑相关的各种操作包括界面初始化、数据保存、样式设置、提醒设置、分享等众多功能。
public class NoteEditActivity extends Activity implements OnClickListener, public class NoteEditActivity extends Activity implements OnClickListener,
NoteSettingChangedListener, OnTextViewChangeListener { NoteSettingChangedListener, OnTextViewChangeListener {
// 用于存储笔记头部相关视图组件的内部类,方便对这些组件进行统一管理和操作,例如显示修改日期、提醒图标及日期等组件。
private class HeadViewHolder { private class HeadViewHolder {
public TextView tvModified; public TextView tvModified;
public ImageView ivAlertIcon; public ImageView ivAlertIcon;
public TextView tvAlertDate; public TextView tvAlertDate;
public ImageView ibSetBgColor; public ImageView ibSetBgColor;
} }
// 背景颜色选择按钮与对应颜色资源ID的映射关系以按钮ID为键颜色资源ID为值方便根据按钮点击来确定选择的背景颜色。
private static final Map<Integer, Integer> sBgSelectorBtnsMap = new HashMap<Integer, Integer>(); private static final Map<Integer, Integer> sBgSelectorBtnsMap = new HashMap<Integer, Integer>();
static { static {
sBgSelectorBtnsMap.put(R.id.iv_bg_yellow, ResourceParser.YELLOW); sBgSelectorBtnsMap.put(R.id.iv_bg_yellow, ResourceParser.YELLOW);
@ -93,6 +94,7 @@ public class NoteEditActivity extends Activity implements OnClickListener,
sBgSelectorBtnsMap.put(R.id.iv_bg_white, ResourceParser.WHITE); sBgSelectorBtnsMap.put(R.id.iv_bg_white, ResourceParser.WHITE);
} }
// 背景颜色选择按钮与对应选中状态显示按钮ID的映射关系用于在选择背景颜色后显示对应的选中标识按钮。
private static final Map<Integer, Integer> sBgSelectorSelectionMap = new HashMap<Integer, Integer>(); private static final Map<Integer, Integer> sBgSelectorSelectionMap = new HashMap<Integer, Integer>();
static { static {
sBgSelectorSelectionMap.put(ResourceParser.YELLOW, R.id.iv_bg_yellow_select); sBgSelectorSelectionMap.put(ResourceParser.YELLOW, R.id.iv_bg_yellow_select);
@ -102,6 +104,7 @@ public class NoteEditActivity extends Activity implements OnClickListener,
sBgSelectorSelectionMap.put(ResourceParser.WHITE, R.id.iv_bg_white_select); sBgSelectorSelectionMap.put(ResourceParser.WHITE, R.id.iv_bg_white_select);
} }
// 字体大小选择按钮与对应字体大小资源ID的映射关系用于根据按钮点击来确定选择的字体大小。
private static final Map<Integer, Integer> sFontSizeBtnsMap = new HashMap<Integer, Integer>(); private static final Map<Integer, Integer> sFontSizeBtnsMap = new HashMap<Integer, Integer>();
static { static {
sFontSizeBtnsMap.put(R.id.ll_font_large, ResourceParser.TEXT_LARGE); sFontSizeBtnsMap.put(R.id.ll_font_large, ResourceParser.TEXT_LARGE);
@ -110,6 +113,7 @@ public class NoteEditActivity extends Activity implements OnClickListener,
sFontSizeBtnsMap.put(R.id.ll_font_super, ResourceParser.TEXT_SUPER); sFontSizeBtnsMap.put(R.id.ll_font_super, ResourceParser.TEXT_SUPER);
} }
// 字体大小资源ID与对应选中状态显示按钮ID的映射关系用于在选择字体大小后显示对应的选中标识按钮。
private static final Map<Integer, Integer> sFontSelectorSelectionMap = new HashMap<Integer, Integer>(); private static final Map<Integer, Integer> sFontSelectorSelectionMap = new HashMap<Integer, Integer>();
static { static {
sFontSelectorSelectionMap.put(ResourceParser.TEXT_LARGE, R.id.iv_large_select); sFontSelectorSelectionMap.put(ResourceParser.TEXT_LARGE, R.id.iv_large_select);
@ -118,43 +122,62 @@ public class NoteEditActivity extends Activity implements OnClickListener,
sFontSelectorSelectionMap.put(ResourceParser.TEXT_SUPER, R.id.iv_super_select); sFontSelectorSelectionMap.put(ResourceParser.TEXT_SUPER, R.id.iv_super_select);
} }
// 用于日志记录的标签,方便在调试等场景下识别该类相关的日志输出。
private static final String TAG = "NoteEditActivity"; private static final String TAG = "NoteEditActivity";
// 存储笔记头部视图组件的实例,通过它可以访问和操作头部相关的各个视图元素,如修改日期、提醒图标及日期等显示的文本视图和图像视图。
private HeadViewHolder mNoteHeaderHolder; private HeadViewHolder mNoteHeaderHolder;
// 笔记标题栏所在的视图,可能包含标题等相关展示内容,用于后续设置背景等操作。
private View mHeadViewPanel; private View mHeadViewPanel;
// 用于展示背景颜色选择的视图,通过控制其显示隐藏来展示或隐藏背景颜色选择界面。
private View mNoteBgColorSelector; private View mNoteBgColorSelector;
// 用于展示字体大小选择的视图,同样通过控制其显示隐藏来展示或隐藏字体大小选择界面。
private View mFontSizeSelector; private View mFontSizeSelector;
// 用于编辑笔记内容的EditText组件用户在此输入和编辑笔记的具体文本内容。
private EditText mNoteEditor; private EditText mNoteEditor;
// 笔记编辑区域所在的视图面板,可能包含编辑文本的滚动等相关功能,用于设置背景等操作。
private View mNoteEditorPanel; private View mNoteEditorPanel;
// 代表正在编辑的笔记对象,封装了笔记相关的数据和操作方法,如保存、获取内容、设置各种属性等。
private WorkingNote mWorkingNote; private WorkingNote mWorkingNote;
// 用于存储应用的共享偏好设置,可通过它获取和保存一些用户相关的设置信息,例如字体大小偏好设置等。
private SharedPreferences mSharedPrefs; private SharedPreferences mSharedPrefs;
// 当前选择的字体大小资源ID初始值从共享偏好设置中获取用于控制笔记编辑文本的字体大小显示。
private int mFontSizeId; private int mFontSizeId;
// 用于存储字体大小偏好设置的键名,在共享偏好设置中以此键来获取和保存字体大小相关的设置值。
private static final String PREFERENCE_FONT_SIZE = "pref_font_size"; private static final String PREFERENCE_FONT_SIZE = "pref_font_size";
// 快捷方式图标标题的最大长度限制,用于生成发送到桌面的快捷方式时,对笔记内容截取合适长度作为图标标题。
private static final int SHORTCUT_ICON_TITLE_MAX_LEN = 10; private static final int SHORTCUT_ICON_TITLE_MAX_LEN = 10;
// 表示复选框选中状态的字符用于在笔记内容以特定格式表示复选框选中情况时使用这里是一个Unicode字符表示对勾。
public static final String TAG_CHECKED = String.valueOf('\u221A'); public static final String TAG_CHECKED = String.valueOf('\u221A');
// 表示复选框未选中状态的字符用于在笔记内容以特定格式表示复选框未选中情况时使用这里是一个Unicode字符表示方块。
public static final String TAG_UNCHECKED = String.valueOf('\u25A1'); public static final String TAG_UNCHECKED = String.valueOf('\u25A1');
// 用于存储笔记内容以列表形式编辑时的多个EditText子项的线性布局容器方便处理列表模式下的笔记内容展示和编辑。
private LinearLayout mEditTextList; private LinearLayout mEditTextList;
// 用户查询的字符串内容,可能用于搜索等相关功能,比如在笔记中查找特定内容,用于后续的文本高亮等处理。
private String mUserQuery; private String mUserQuery;
// 用于匹配用户查询内容的正则表达式模式对象,根据用户查询字符串编译生成,用于在笔记文本中查找匹配的内容进行相应处理,如高亮显示。
private Pattern mPattern; private Pattern mPattern;
// Activity被创建时调用的方法进行一些初始化操作如设置布局、根据Intent初始化Activity状态等如果初始化失败则结束该Activity。
@Override @Override
protected void onCreate(Bundle savedInstanceState) { protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState); super.onCreate(savedInstanceState);
// 设置该Activity对应的布局文件用于展示笔记编辑相关的界面内容。
this.setContentView(R.layout.note_edit); this.setContentView(R.layout.note_edit);
if (savedInstanceState == null && !initActivityState(getIntent())) { if (savedInstanceState == null &&!initActivityState(getIntent())) {
finish(); finish();
return; return;
} }
@ -162,13 +185,14 @@ public class NoteEditActivity extends Activity implements OnClickListener,
} }
/** /**
* Current activity may be killed when the memory is low. Once it is killed, for another time * ActivityActivity
* user load this activity, we should restore the former state * Intent.EXTRA_UIDActivity
* Activity
*/ */
@Override @Override
protected void onRestoreInstanceState(Bundle savedInstanceState) { protected void onRestoreInstanceState(Bundle savedInstanceState) {
super.onRestoreInstanceState(savedInstanceState); super.onRestoreInstanceState(savedInstanceState);
if (savedInstanceState != null && savedInstanceState.containsKey(Intent.EXTRA_UID)) { if (savedInstanceState!= null && savedInstanceState.containsKey(Intent.EXTRA_UID)) {
Intent intent = new Intent(Intent.ACTION_VIEW); Intent intent = new Intent(Intent.ACTION_VIEW);
intent.putExtra(Intent.EXTRA_UID, savedInstanceState.getLong(Intent.EXTRA_UID)); intent.putExtra(Intent.EXTRA_UID, savedInstanceState.getLong(Intent.EXTRA_UID));
if (!initActivityState(intent)) { if (!initActivityState(intent)) {
@ -179,10 +203,12 @@ public class NoteEditActivity extends Activity implements OnClickListener,
} }
} }
// 根据传入的Intent初始化Activity的状态根据不同的Intent动作ACTION_VIEW、ACTION_INSERT_OR_EDIT等来处理不同的情况
// 例如加载已存在的笔记、创建新笔记、处理通话记录相关笔记等若操作过程中出现加载笔记失败等问题则结束该Activity成功则返回true。
private boolean initActivityState(Intent intent) { private boolean initActivityState(Intent intent) {
/** /**
* If the user specified the {@link Intent#ACTION_VIEW} but not provided with id, * {@link Intent#ACTION_VIEW}ID
* then jump to the NotesListActivity * NotesListActivity
*/ */
mWorkingNote = null; mWorkingNote = null;
if (TextUtils.equals(Intent.ACTION_VIEW, intent.getAction())) { if (TextUtils.equals(Intent.ACTION_VIEW, intent.getAction())) {
@ -190,7 +216,7 @@ public class NoteEditActivity extends Activity implements OnClickListener,
mUserQuery = ""; mUserQuery = "";
/** /**
* Starting from the searched result * ID
*/ */
if (intent.hasExtra(SearchManager.EXTRA_DATA_KEY)) { if (intent.hasExtra(SearchManager.EXTRA_DATA_KEY)) {
noteId = Long.parseLong(intent.getStringExtra(SearchManager.EXTRA_DATA_KEY)); noteId = Long.parseLong(intent.getStringExtra(SearchManager.EXTRA_DATA_KEY));
@ -211,11 +237,12 @@ public class NoteEditActivity extends Activity implements OnClickListener,
return false; return false;
} }
} }
// 设置软键盘的显示模式,初始时隐藏软键盘,并根据内容调整布局大小。
getWindow().setSoftInputMode( getWindow().setSoftInputMode(
WindowManager.LayoutParams.SOFT_INPUT_STATE_HIDDEN WindowManager.LayoutParams.SOFT_INPUT_STATE_HIDDEN
| WindowManager.LayoutParams.SOFT_INPUT_ADJUST_RESIZE); | WindowManager.LayoutParams.SOFT_INPUT_ADJUST_RESIZE);
} else if(TextUtils.equals(Intent.ACTION_INSERT_OR_EDIT, intent.getAction())) { } else if (TextUtils.equals(Intent.ACTION_INSERT_OR_EDIT, intent.getAction())) {
// New note // 新建笔记的情况获取相关的额外数据如文件夹ID、小部件ID、小部件类型、背景资源ID等用于创建新的空白笔记对象。
long folderId = intent.getLongExtra(Notes.INTENT_EXTRA_FOLDER_ID, 0); long folderId = intent.getLongExtra(Notes.INTENT_EXTRA_FOLDER_ID, 0);
int widgetId = intent.getIntExtra(Notes.INTENT_EXTRA_WIDGET_ID, int widgetId = intent.getIntExtra(Notes.INTENT_EXTRA_WIDGET_ID,
AppWidgetManager.INVALID_APPWIDGET_ID); AppWidgetManager.INVALID_APPWIDGET_ID);
@ -224,10 +251,10 @@ public class NoteEditActivity extends Activity implements OnClickListener,
int bgResId = intent.getIntExtra(Notes.INTENT_EXTRA_BACKGROUND_ID, int bgResId = intent.getIntExtra(Notes.INTENT_EXTRA_BACKGROUND_ID,
ResourceParser.getDefaultBgId(this)); ResourceParser.getDefaultBgId(this));
// Parse call-record note // 解析通话记录笔记相关的情况,获取电话号码和通话日期,根据是否存在有效数据来决定是加载已存在的通话笔记还是创建新的空白通话笔记并转换为通话笔记格式。
String phoneNumber = intent.getStringExtra(Intent.EXTRA_PHONE_NUMBER); String phoneNumber = intent.getStringExtra(Intent.EXTRA_PHONE_NUMBER);
long callDate = intent.getLongExtra(Notes.INTENT_EXTRA_CALL_DATE, 0); long callDate = intent.getLongExtra(Notes.INTENT_EXTRA_CALL_DATE, 0);
if (callDate != 0 && phoneNumber != null) { if (callDate!= 0 && phoneNumber!= null) {
if (TextUtils.isEmpty(phoneNumber)) { if (TextUtils.isEmpty(phoneNumber)) {
Log.w(TAG, "The call record number is null"); Log.w(TAG, "The call record number is null");
} }
@ -250,6 +277,7 @@ public class NoteEditActivity extends Activity implements OnClickListener,
bgResId); bgResId);
} }
// 设置软键盘的显示模式,初始时显示软键盘,并根据内容调整布局大小。
getWindow().setSoftInputMode( getWindow().setSoftInputMode(
WindowManager.LayoutParams.SOFT_INPUT_ADJUST_RESIZE WindowManager.LayoutParams.SOFT_INPUT_ADJUST_RESIZE
| WindowManager.LayoutParams.SOFT_INPUT_STATE_VISIBLE); | WindowManager.LayoutParams.SOFT_INPUT_STATE_VISIBLE);
@ -258,16 +286,20 @@ public class NoteEditActivity extends Activity implements OnClickListener,
finish(); finish();
return false; return false;
} }
// 设置笔记相关设置状态变化的监听器为当前Activity自身以便在笔记设置发生改变时能响应处理。
mWorkingNote.setOnSettingStatusChangedListener(this); mWorkingNote.setOnSettingStatusChangedListener(this);
return true; return true;
} }
// Activity重新恢复到前台可见时调用的方法在此主要用于初始化笔记编辑界面的显示内容如设置字体样式、根据笔记类型展示内容、设置头部和编辑区域背景等。
@Override @Override
protected void onResume() { protected void onResume() {
super.onResume(); super.onResume();
initNoteScreen(); initNoteScreen();
} }
// 初始化笔记编辑界面的显示内容,根据当前笔记的相关属性和设置,设置笔记编辑文本的字体样式、展示模式(列表模式或普通模式)、
// 显示或隐藏提醒相关的头部信息、设置头部和编辑区域的背景等,确保界面正确展示当前笔记的状态。
private void initNoteScreen() { private void initNoteScreen() {
mNoteEditor.setTextAppearance(this, TextAppearanceResources mNoteEditor.setTextAppearance(this, TextAppearanceResources
.getTexAppearanceResource(mFontSizeId)); .getTexAppearanceResource(mFontSizeId));
@ -289,12 +321,12 @@ public class NoteEditActivity extends Activity implements OnClickListener,
| DateUtils.FORMAT_SHOW_YEAR)); | DateUtils.FORMAT_SHOW_YEAR));
/** /**
* TODO: Add the menu for setting alert. Currently disable it because the DateTimePicker * TODO: DateTimePicker
* is not ready
*/ */
showAlertHeader(); showAlertHeader();
} }
// 根据笔记是否设置了提醒以及提醒时间与当前时间的关系,显示或隐藏提醒相关的头部信息,如提醒日期文本和提醒图标等。
private void showAlertHeader() { private void showAlertHeader() {
if (mWorkingNote.hasClockAlert()) { if (mWorkingNote.hasClockAlert()) {
long time = System.currentTimeMillis(); long time = System.currentTimeMillis();
@ -308,566 +340,5 @@ public class NoteEditActivity extends Activity implements OnClickListener,
mNoteHeaderHolder.ivAlertIcon.setVisibility(View.VISIBLE); mNoteHeaderHolder.ivAlertIcon.setVisibility(View.VISIBLE);
} else { } else {
mNoteHeaderHolder.tvAlertDate.setVisibility(View.GONE); mNoteHeaderHolder.tvAlertDate.setVisibility(View.GONE);
mNoteHeaderHolder.ivAlertIcon.setVisibility(View.GONE); mNoteHeaderHolder.ivAlert
};
}
@Override
protected void onNewIntent(Intent intent) {
super.onNewIntent(intent);
initActivityState(intent);
}
@Override
protected void onSaveInstanceState(Bundle outState) {
super.onSaveInstanceState(outState);
/**
* For new note without note id, we should firstly save it to
* generate a id. If the editing note is not worth saving, there
* is no id which is equivalent to create new note
*/
if (!mWorkingNote.existInDatabase()) {
saveNote();
}
outState.putLong(Intent.EXTRA_UID, mWorkingNote.getNoteId());
Log.d(TAG, "Save working note id: " + mWorkingNote.getNoteId() + " onSaveInstanceState");
}
@Override
public boolean dispatchTouchEvent(MotionEvent ev) {
if (mNoteBgColorSelector.getVisibility() == View.VISIBLE
&& !inRangeOfView(mNoteBgColorSelector, ev)) {
mNoteBgColorSelector.setVisibility(View.GONE);
return true;
}
if (mFontSizeSelector.getVisibility() == View.VISIBLE
&& !inRangeOfView(mFontSizeSelector, ev)) {
mFontSizeSelector.setVisibility(View.GONE);
return true;
}
return super.dispatchTouchEvent(ev);
}
private boolean inRangeOfView(View view, MotionEvent ev) {
int []location = new int[2];
view.getLocationOnScreen(location);
int x = location[0];
int y = location[1];
if (ev.getX() < x
|| ev.getX() > (x + view.getWidth())
|| ev.getY() < y
|| ev.getY() > (y + view.getHeight())) {
return false;
}
return true;
}
private void initResources() {
mHeadViewPanel = findViewById(R.id.note_title);
mNoteHeaderHolder = new HeadViewHolder();
mNoteHeaderHolder.tvModified = (TextView) findViewById(R.id.tv_modified_date);
mNoteHeaderHolder.ivAlertIcon = (ImageView) findViewById(R.id.iv_alert_icon);
mNoteHeaderHolder.tvAlertDate = (TextView) findViewById(R.id.tv_alert_date);
mNoteHeaderHolder.ibSetBgColor = (ImageView) findViewById(R.id.btn_set_bg_color);
mNoteHeaderHolder.ibSetBgColor.setOnClickListener(this);
mNoteEditor = (EditText) findViewById(R.id.note_edit_view);
mNoteEditorPanel = findViewById(R.id.sv_note_edit);
mNoteBgColorSelector = findViewById(R.id.note_bg_color_selector);
for (int id : sBgSelectorBtnsMap.keySet()) {
ImageView iv = (ImageView) findViewById(id);
iv.setOnClickListener(this);
}
mFontSizeSelector = findViewById(R.id.font_size_selector);
for (int id : sFontSizeBtnsMap.keySet()) {
View view = findViewById(id);
view.setOnClickListener(this);
};
mSharedPrefs = PreferenceManager.getDefaultSharedPreferences(this);
mFontSizeId = mSharedPrefs.getInt(PREFERENCE_FONT_SIZE, ResourceParser.BG_DEFAULT_FONT_SIZE);
/**
* HACKME: Fix bug of store the resource id in shared preference.
* The id may larger than the length of resources, in this case,
* return the {@link ResourceParser#BG_DEFAULT_FONT_SIZE}
*/
if(mFontSizeId >= TextAppearanceResources.getResourcesSize()) {
mFontSizeId = ResourceParser.BG_DEFAULT_FONT_SIZE;
}
mEditTextList = (LinearLayout) findViewById(R.id.note_edit_list);
}
@Override
protected void onPause() {
super.onPause();
if(saveNote()) {
Log.d(TAG, "Note data was saved with length:" + mWorkingNote.getContent().length());
}
clearSettingState();
}
private void updateWidget() {
Intent intent = new Intent(AppWidgetManager.ACTION_APPWIDGET_UPDATE);
if (mWorkingNote.getWidgetType() == Notes.TYPE_WIDGET_2X) {
intent.setClass(this, NoteWidgetProvider_2x.class);
} else if (mWorkingNote.getWidgetType() == Notes.TYPE_WIDGET_4X) {
intent.setClass(this, NoteWidgetProvider_4x.class);
} else {
Log.e(TAG, "Unspported widget type");
return;
}
intent.putExtra(AppWidgetManager.EXTRA_APPWIDGET_IDS, new int[] {
mWorkingNote.getWidgetId()
});
sendBroadcast(intent);
setResult(RESULT_OK, intent);
}
public void onClick(View v) {
int id = v.getId();
if (id == R.id.btn_set_bg_color) {
mNoteBgColorSelector.setVisibility(View.VISIBLE);
findViewById(sBgSelectorSelectionMap.get(mWorkingNote.getBgColorId())).setVisibility(
- View.VISIBLE);
} else if (sBgSelectorBtnsMap.containsKey(id)) {
findViewById(sBgSelectorSelectionMap.get(mWorkingNote.getBgColorId())).setVisibility(
View.GONE);
mWorkingNote.setBgColorId(sBgSelectorBtnsMap.get(id));
mNoteBgColorSelector.setVisibility(View.GONE);
} else if (sFontSizeBtnsMap.containsKey(id)) {
findViewById(sFontSelectorSelectionMap.get(mFontSizeId)).setVisibility(View.GONE);
mFontSizeId = sFontSizeBtnsMap.get(id);
mSharedPrefs.edit().putInt(PREFERENCE_FONT_SIZE, mFontSizeId).commit();
findViewById(sFontSelectorSelectionMap.get(mFontSizeId)).setVisibility(View.VISIBLE);
if (mWorkingNote.getCheckListMode() == TextNote.MODE_CHECK_LIST) {
getWorkingText();
switchToListMode(mWorkingNote.getContent());
} else {
mNoteEditor.setTextAppearance(this,
TextAppearanceResources.getTexAppearanceResource(mFontSizeId));
}
mFontSizeSelector.setVisibility(View.GONE);
}
}
@Override
public void onBackPressed() {
if(clearSettingState()) {
return;
}
saveNote();
super.onBackPressed();
}
private boolean clearSettingState() {
if (mNoteBgColorSelector.getVisibility() == View.VISIBLE) {
mNoteBgColorSelector.setVisibility(View.GONE);
return true;
} else if (mFontSizeSelector.getVisibility() == View.VISIBLE) {
mFontSizeSelector.setVisibility(View.GONE);
return true;
}
return false;
}
public void onBackgroundColorChanged() {
findViewById(sBgSelectorSelectionMap.get(mWorkingNote.getBgColorId())).setVisibility(
View.VISIBLE);
mNoteEditorPanel.setBackgroundResource(mWorkingNote.getBgColorResId());
mHeadViewPanel.setBackgroundResource(mWorkingNote.getTitleBgResId());
}
@Override
public boolean onPrepareOptionsMenu(Menu menu) {
if (isFinishing()) {
return true;
}
clearSettingState();
menu.clear();
if (mWorkingNote.getFolderId() == Notes.ID_CALL_RECORD_FOLDER) {
getMenuInflater().inflate(R.menu.call_note_edit, menu);
} else {
getMenuInflater().inflate(R.menu.note_edit, menu);
}
if (mWorkingNote.getCheckListMode() == TextNote.MODE_CHECK_LIST) {
menu.findItem(R.id.menu_list_mode).setTitle(R.string.menu_normal_mode);
} else {
menu.findItem(R.id.menu_list_mode).setTitle(R.string.menu_list_mode);
}
if (mWorkingNote.hasClockAlert()) {
menu.findItem(R.id.menu_alert).setVisible(false);
} else {
menu.findItem(R.id.menu_delete_remind).setVisible(false);
}
return true;
}
@Override
public boolean onOptionsItemSelected(MenuItem item) {
switch (item.getItemId()) {
case R.id.menu_new_note:
createNewNote();
break;
case R.id.menu_delete:
AlertDialog.Builder builder = new AlertDialog.Builder(this);
builder.setTitle(getString(R.string.alert_title_delete));
builder.setIcon(android.R.drawable.ic_dialog_alert);
builder.setMessage(getString(R.string.alert_message_delete_note));
builder.setPositiveButton(android.R.string.ok,
new DialogInterface.OnClickListener() {
public void onClick(DialogInterface dialog, int which) {
deleteCurrentNote();
finish();
}
});
builder.setNegativeButton(android.R.string.cancel, null);
builder.show();
break;
case R.id.menu_font_size:
mFontSizeSelector.setVisibility(View.VISIBLE);
findViewById(sFontSelectorSelectionMap.get(mFontSizeId)).setVisibility(View.VISIBLE);
break;
case R.id.menu_list_mode:
mWorkingNote.setCheckListMode(mWorkingNote.getCheckListMode() == 0 ?
TextNote.MODE_CHECK_LIST : 0);
break;
case R.id.menu_share:
getWorkingText();
sendTo(this, mWorkingNote.getContent());
break;
case R.id.menu_send_to_desktop:
sendToDesktop();
break;
case R.id.menu_alert:
setReminder();
break;
case R.id.menu_delete_remind:
mWorkingNote.setAlertDate(0, false);
break;
default:
break;
}
return true;
}
private void setReminder() {
DateTimePickerDialog d = new DateTimePickerDialog(this, System.currentTimeMillis());
d.setOnDateTimeSetListener(new OnDateTimeSetListener() {
public void OnDateTimeSet(AlertDialog dialog, long date) {
mWorkingNote.setAlertDate(date , true);
}
});
d.show();
}
/**
* Share note to apps that support {@link Intent#ACTION_SEND} action
* and {@text/plain} type
*/
private void sendTo(Context context, String info) {
Intent intent = new Intent(Intent.ACTION_SEND);
intent.putExtra(Intent.EXTRA_TEXT, info);
intent.setType("text/plain");
context.startActivity(intent);
}
private void createNewNote() {
// Firstly, save current editing notes
saveNote();
// For safety, start a new NoteEditActivity
finish();
Intent intent = new Intent(this, NoteEditActivity.class);
intent.setAction(Intent.ACTION_INSERT_OR_EDIT);
intent.putExtra(Notes.INTENT_EXTRA_FOLDER_ID, mWorkingNote.getFolderId());
startActivity(intent);
}
private void deleteCurrentNote() {
if (mWorkingNote.existInDatabase()) {
HashSet<Long> ids = new HashSet<Long>();
long id = mWorkingNote.getNoteId();
if (id != Notes.ID_ROOT_FOLDER) {
ids.add(id);
} else {
Log.d(TAG, "Wrong note id, should not happen");
}
if (!isSyncMode()) {
if (!DataUtils.batchDeleteNotes(getContentResolver(), ids)) {
Log.e(TAG, "Delete Note error");
}
} else {
if (!DataUtils.batchMoveToFolder(getContentResolver(), ids, Notes.ID_TRASH_FOLER)) {
Log.e(TAG, "Move notes to trash folder error, should not happens");
}
}
}
mWorkingNote.markDeleted(true);
}
private boolean isSyncMode() {
return NotesPreferenceActivity.getSyncAccountName(this).trim().length() > 0;
}
public void onClockAlertChanged(long date, boolean set) {
/**
* User could set clock to an unsaved note, so before setting the
* alert clock, we should save the note first
*/
if (!mWorkingNote.existInDatabase()) {
saveNote();
}
if (mWorkingNote.getNoteId() > 0) {
Intent intent = new Intent(this, AlarmReceiver.class);
intent.setData(ContentUris.withAppendedId(Notes.CONTENT_NOTE_URI, mWorkingNote.getNoteId()));
PendingIntent pendingIntent = PendingIntent.getBroadcast(this, 0, intent, 0);
AlarmManager alarmManager = ((AlarmManager) getSystemService(ALARM_SERVICE));
showAlertHeader();
if(!set) {
alarmManager.cancel(pendingIntent);
} else {
alarmManager.set(AlarmManager.RTC_WAKEUP, date, pendingIntent);
}
} else {
/**
* There is the condition that user has input nothing (the note is
* not worthy saving), we have no note id, remind the user that he
* should input something
*/
Log.e(TAG, "Clock alert setting error");
showToast(R.string.error_note_empty_for_clock);
}
}
public void onWidgetChanged() {
updateWidget();
}
public void onEditTextDelete(int index, String text) {
int childCount = mEditTextList.getChildCount();
if (childCount == 1) {
return;
}
for (int i = index + 1; i < childCount; i++) {
((NoteEditText) mEditTextList.getChildAt(i).findViewById(R.id.et_edit_text))
.setIndex(i - 1);
}
mEditTextList.removeViewAt(index);
NoteEditText edit = null;
if(index == 0) {
edit = (NoteEditText) mEditTextList.getChildAt(0).findViewById(
R.id.et_edit_text);
} else {
edit = (NoteEditText) mEditTextList.getChildAt(index - 1).findViewById(
R.id.et_edit_text);
}
int length = edit.length();
edit.append(text);
edit.requestFocus();
edit.setSelection(length);
}
public void onEditTextEnter(int index, String text) {
/**
* Should not happen, check for debug
*/
if(index > mEditTextList.getChildCount()) {
Log.e(TAG, "Index out of mEditTextList boundrary, should not happen");
}
View view = getListItem(text, index);
mEditTextList.addView(view, index);
NoteEditText edit = (NoteEditText) view.findViewById(R.id.et_edit_text);
edit.requestFocus();
edit.setSelection(0);
for (int i = index + 1; i < mEditTextList.getChildCount(); i++) {
((NoteEditText) mEditTextList.getChildAt(i).findViewById(R.id.et_edit_text))
.setIndex(i);
}
}
private void switchToListMode(String text) {
mEditTextList.removeAllViews();
String[] items = text.split("\n");
int index = 0;
for (String item : items) {
if(!TextUtils.isEmpty(item)) {
mEditTextList.addView(getListItem(item, index));
index++;
}
}
mEditTextList.addView(getListItem("", index));
mEditTextList.getChildAt(index).findViewById(R.id.et_edit_text).requestFocus();
mNoteEditor.setVisibility(View.GONE);
mEditTextList.setVisibility(View.VISIBLE);
}
private Spannable getHighlightQueryResult(String fullText, String userQuery) {
SpannableString spannable = new SpannableString(fullText == null ? "" : fullText);
if (!TextUtils.isEmpty(userQuery)) {
mPattern = Pattern.compile(userQuery);
Matcher m = mPattern.matcher(fullText);
int start = 0;
while (m.find(start)) {
spannable.setSpan(
new BackgroundColorSpan(this.getResources().getColor(
R.color.user_query_highlight)), m.start(), m.end(),
Spannable.SPAN_INCLUSIVE_EXCLUSIVE);
start = m.end();
}
}
return spannable;
}
private View getListItem(String item, int index) {
View view = LayoutInflater.from(this).inflate(R.layout.note_edit_list_item, null);
final NoteEditText edit = (NoteEditText) view.findViewById(R.id.et_edit_text);
edit.setTextAppearance(this, TextAppearanceResources.getTexAppearanceResource(mFontSizeId));
CheckBox cb = ((CheckBox) view.findViewById(R.id.cb_edit_item));
cb.setOnCheckedChangeListener(new OnCheckedChangeListener() {
public void onCheckedChanged(CompoundButton buttonView, boolean isChecked) {
if (isChecked) {
edit.setPaintFlags(edit.getPaintFlags() | Paint.STRIKE_THRU_TEXT_FLAG);
} else {
edit.setPaintFlags(Paint.ANTI_ALIAS_FLAG | Paint.DEV_KERN_TEXT_FLAG);
}
}
});
if (item.startsWith(TAG_CHECKED)) {
cb.setChecked(true);
edit.setPaintFlags(edit.getPaintFlags() | Paint.STRIKE_THRU_TEXT_FLAG);
item = item.substring(TAG_CHECKED.length(), item.length()).trim();
} else if (item.startsWith(TAG_UNCHECKED)) {
cb.setChecked(false);
edit.setPaintFlags(Paint.ANTI_ALIAS_FLAG | Paint.DEV_KERN_TEXT_FLAG);
item = item.substring(TAG_UNCHECKED.length(), item.length()).trim();
}
edit.setOnTextViewChangeListener(this);
edit.setIndex(index);
edit.setText(getHighlightQueryResult(item, mUserQuery));
return view;
}
public void onTextChange(int index, boolean hasText) {
if (index >= mEditTextList.getChildCount()) {
Log.e(TAG, "Wrong index, should not happen");
return;
}
if(hasText) {
mEditTextList.getChildAt(index).findViewById(R.id.cb_edit_item).setVisibility(View.VISIBLE);
} else {
mEditTextList.getChildAt(index).findViewById(R.id.cb_edit_item).setVisibility(View.GONE);
}
}
public void onCheckListModeChanged(int oldMode, int newMode) {
if (newMode == TextNote.MODE_CHECK_LIST) {
switchToListMode(mNoteEditor.getText().toString());
} else {
if (!getWorkingText()) {
mWorkingNote.setWorkingText(mWorkingNote.getContent().replace(TAG_UNCHECKED + " ",
""));
}
mNoteEditor.setText(getHighlightQueryResult(mWorkingNote.getContent(), mUserQuery));
mEditTextList.setVisibility(View.GONE);
mNoteEditor.setVisibility(View.VISIBLE);
}
}
private boolean getWorkingText() {
boolean hasChecked = false;
if (mWorkingNote.getCheckListMode() == TextNote.MODE_CHECK_LIST) {
StringBuilder sb = new StringBuilder();
for (int i = 0; i < mEditTextList.getChildCount(); i++) {
View view = mEditTextList.getChildAt(i);
NoteEditText edit = (NoteEditText) view.findViewById(R.id.et_edit_text);
if (!TextUtils.isEmpty(edit.getText())) {
if (((CheckBox) view.findViewById(R.id.cb_edit_item)).isChecked()) {
sb.append(TAG_CHECKED).append(" ").append(edit.getText()).append("\n");
hasChecked = true;
} else {
sb.append(TAG_UNCHECKED).append(" ").append(edit.getText()).append("\n");
}
}
}
mWorkingNote.setWorkingText(sb.toString());
} else {
mWorkingNote.setWorkingText(mNoteEditor.getText().toString());
}
return hasChecked;
}
private boolean saveNote() {
getWorkingText();
boolean saved = mWorkingNote.saveNote();
if (saved) {
/**
* There are two modes from List view to edit view, open one note,
* create/edit a node. Opening node requires to the original
* position in the list when back from edit view, while creating a
* new node requires to the top of the list. This code
* {@link #RESULT_OK} is used to identify the create/edit state
*/
setResult(RESULT_OK);
}
return saved;
}
private void sendToDesktop() {
/**
* Before send message to home, we should make sure that current
* editing note is exists in databases. So, for new note, firstly
* save it
*/
if (!mWorkingNote.existInDatabase()) {
saveNote();
}
if (mWorkingNote.getNoteId() > 0) {
Intent sender = new Intent();
Intent shortcutIntent = new Intent(this, NoteEditActivity.class);
shortcutIntent.setAction(Intent.ACTION_VIEW);
shortcutIntent.putExtra(Intent.EXTRA_UID, mWorkingNote.getNoteId());
sender.putExtra(Intent.EXTRA_SHORTCUT_INTENT, shortcutIntent);
sender.putExtra(Intent.EXTRA_SHORTCUT_NAME,
makeShortcutIconTitle(mWorkingNote.getContent()));
sender.putExtra(Intent.EXTRA_SHORTCUT_ICON_RESOURCE,
Intent.ShortcutIconResource.fromContext(this, R.drawable.icon_app));
sender.putExtra("duplicate", true);
sender.setAction("com.android.launcher.action.INSTALL_SHORTCUT");
showToast(R.string.info_note_enter_desktop);
sendBroadcast(sender);
} else {
/**
* There is the condition that user has input nothing (the note is
* not worthy saving), we have no note id, remind the user that he
* should input something
*/
Log.e(TAG, "Send to desktop error");
showToast(R.string.error_note_empty_for_send_to_desktop);
}
}
private String makeShortcutIconTitle(String content) {
content = content.replace(TAG_CHECKED, "");
content = content.replace(TAG_UNCHECKED, "");
return content.length() > SHORTCUT_ICON_TITLE_MAX_LEN ? content.substring(0,
SHORTCUT_ICON_TITLE_MAX_LEN) : content;
}
private void showToast(int resId) {
showToast(resId, Toast.LENGTH_SHORT);
}
private void showToast(int resId, int duration) {
Toast.makeText(this, resId, duration).show();
}
}

@ -37,15 +37,25 @@ import net.micode.notes.R;
import java.util.HashMap; import java.util.HashMap;
import java.util.Map; import java.util.Map;
// NoteEditText类继承自EditText是一个自定义的文本编辑框在基础的文本编辑功能上添加了一些特定的交互逻辑
// 比如处理按键事件(回车键、删除键)、焦点变化事件以及创建上下文菜单(处理链接点击等情况),并通过接口与外部进行交互,通知相关的文本变化情况等。
public class NoteEditText extends EditText { public class NoteEditText extends EditText {
// 用于日志记录的标签,方便在调试等场景下识别该类相关的日志输出。
private static final String TAG = "NoteEditText"; private static final String TAG = "NoteEditText";
// 当前文本编辑框在父容器(如列表布局中多个编辑框的情况)中的索引位置,用于标识自身顺序以及在一些操作中确定与其他编辑框的关系。
private int mIndex; private int mIndex;
// 在处理删除键按下事件时,记录删除操作前文本的起始选择位置,用于后续判断是否触发特定的删除逻辑,比如删除当前编辑框内容等情况。
private int mSelectionStartBeforeDelete; private int mSelectionStartBeforeDelete;
private static final String SCHEME_TEL = "tel:" ; // 定义表示电话号码链接的协议头字符串,用于识别文本中电话号码类型的链接,格式为"tel:"。
private static final String SCHEME_HTTP = "http:" ; private static final String SCHEME_TEL = "tel:";
private static final String SCHEME_EMAIL = "mailto:" ; // 定义表示网页链接的协议头字符串,用于识别文本中网页类型的链接,格式为"http:"。
private static final String SCHEME_HTTP = "http:";
// 定义表示邮件链接的协议头字符串,用于识别文本中邮件类型的链接,格式为"mailto:"。
private static final String SCHEME_EMAIL = "mailto:";
// 用于建立链接协议头与对应提示字符串资源ID的映射关系的集合方便根据链接类型获取相应的显示文本告知用户链接类型。
private static final Map<String, Integer> sSchemaActionResMap = new HashMap<String, Integer>(); private static final Map<String, Integer> sSchemaActionResMap = new HashMap<String, Integer>();
static { static {
sSchemaActionResMap.put(SCHEME_TEL, R.string.note_link_tel); sSchemaActionResMap.put(SCHEME_TEL, R.string.note_link_tel);
@ -53,6 +63,8 @@ public class NoteEditText extends EditText {
sSchemaActionResMap.put(SCHEME_EMAIL, R.string.note_link_email); sSchemaActionResMap.put(SCHEME_EMAIL, R.string.note_link_email);
} }
// 定义一个接口,用于外部类实现,该接口提供了几个方法,当文本编辑框内发生特定文本操作事件(如删除、回车键按下、文本内容变化等)时,
// 会回调相应的方法,以便外部可以根据这些事件做出相应的处理,实现与外部的交互逻辑。
/** /**
* Call by the {@link NoteEditActivity} to delete or add edit text * Call by the {@link NoteEditActivity} to delete or add edit text
*/ */
@ -75,35 +87,45 @@ public class NoteEditText extends EditText {
void onTextChange(int index, boolean hasText); void onTextChange(int index, boolean hasText);
} }
// 用于存储实现了OnTextViewChangeListener接口的对象实例通过设置此监听器使得外部可以接收该文本编辑框内发生相关文本操作事件的通知进行相应处理。
private OnTextViewChangeListener mOnTextViewChangeListener; private OnTextViewChangeListener mOnTextViewChangeListener;
// 构造函数接收上下文作为参数调用父类EditText的构造函数进行初始化同时设置当前编辑框的索引初始值为0。
public NoteEditText(Context context) { public NoteEditText(Context context) {
super(context, null); super(context, null);
mIndex = 0; mIndex = 0;
} }
// 用于设置当前文本编辑框在父容器中的索引位置的方法,外部可通过调用此方法来更新索引值,方便后续基于索引的相关操作逻辑。
public void setIndex(int index) { public void setIndex(int index) {
mIndex = index; mIndex = index;
} }
// 用于设置文本操作事件监听器OnTextViewChangeListener的方法外部类实现该接口后通过调用此方法将实现的监听器对象传递进来
// 使得该文本编辑框能在相应事件发生时通知外部进行处理。
public void setOnTextViewChangeListener(OnTextViewChangeListener listener) { public void setOnTextViewChangeListener(OnTextViewChangeListener listener) {
mOnTextViewChangeListener = listener; mOnTextViewChangeListener = listener;
} }
// 构造函数接收上下文和属性集AttributeSet作为参数调用父类EditText的构造函数并指定默认的编辑框样式android.R.attr.editTextStyle进行初始化。
public NoteEditText(Context context, AttributeSet attrs) { public NoteEditText(Context context, AttributeSet attrs) {
super(context, attrs, android.R.attr.editTextStyle); super(context, attrs, android.R.attr.editTextStyle);
} }
// 构造函数接收上下文、属性集AttributeSet和默认样式defStyle作为参数调用父类EditText的构造函数进行初始化
// 这里暂时没有额外的自定义初始化逻辑(除了调用父类构造函数),只是保留了构造函数的标准写法,注释中提示了待完善的部分(可能后续会添加更多初始化相关操作)。
public NoteEditText(Context context, AttributeSet attrs, int defStyle) { public NoteEditText(Context context, AttributeSet attrs, int defStyle) {
super(context, attrs, defStyle); super(context, attrs, defStyle);
// TODO Auto-generated constructor stub // TODO Auto-generated constructor stub
} }
// 重写父类的onTouchEvent方法用于处理触摸事件主要在触摸按下ACTION_DOWN根据触摸位置来设置文本的选择位置
// 使得用户点击文本区域时能准确地定位到相应位置进行后续操作,如复制、粘贴等文本选择相关操作,其他触摸动作则按照父类默认逻辑处理。
@Override @Override
public boolean onTouchEvent(MotionEvent event) { public boolean onTouchEvent(MotionEvent event) {
switch (event.getAction()) { switch (event.getAction()) {
case MotionEvent.ACTION_DOWN: case MotionEvent.ACTION_DOWN:
// 获取触摸点的原始X坐标并减去文本编辑框的左内边距得到相对文本内容区域的X坐标再加上滚动的X偏移量处理滚动情况
int x = (int) event.getX(); int x = (int) event.getX();
int y = (int) event.getY(); int y = (int) event.getY();
x -= getTotalPaddingLeft(); x -= getTotalPaddingLeft();
@ -111,6 +133,8 @@ public class NoteEditText extends EditText {
x += getScrollX(); x += getScrollX();
y += getScrollY(); y += getScrollY();
// 根据触摸点的垂直位置获取对应的文本行数,然后根据该行数和水平位置获取对应的文本偏移量(字符位置),
// 最后将文本选择位置设置为该偏移量对应的位置,实现触摸定位文本选择的功能。
Layout layout = getLayout(); Layout layout = getLayout();
int line = layout.getLineForVertical(y); int line = layout.getLineForVertical(y);
int off = layout.getOffsetForHorizontal(line, x); int off = layout.getOffsetForHorizontal(line, x);
@ -121,11 +145,14 @@ public class NoteEditText extends EditText {
return super.onTouchEvent(event); return super.onTouchEvent(event);
} }
// 重写父类的onKeyDown方法用于处理按键按下事件在这里主要是记录删除键KEYCODE_DEL按下时文本的起始选择位置
// 对于回车键KEYCODE_ENTER按下的情况如果设置了文本操作事件监听器OnTextViewChangeListener则直接返回false
// 可能是让外部来进一步处理回车键按下的逻辑,其他按键则按照父类默认逻辑处理。
@Override @Override
public boolean onKeyDown(int keyCode, KeyEvent event) { public boolean onKeyDown(int keyCode, KeyEvent event) {
switch (keyCode) { switch (keyCode) {
case KeyEvent.KEYCODE_ENTER: case KeyEvent.KEYCODE_ENTER:
if (mOnTextViewChangeListener != null) { if (mOnTextViewChangeListener!= null) {
return false; return false;
} }
break; break;
@ -138,12 +165,17 @@ public class NoteEditText extends EditText {
return super.onKeyDown(keyCode, event); return super.onKeyDown(keyCode, event);
} }
// 重写父类的onKeyUp方法用于处理按键抬起事件在这里重点处理删除键KEYCODE_DEL和回车键KEYCODE_ENTER抬起时的逻辑
// 如果设置了文本操作事件监听器OnTextViewChangeListener对于删除键抬起情况当起始选择位置为0且当前编辑框不是第一个索引不为0
// 调用监听器的onEditTextDelete方法通知外部删除当前编辑框内容对于回车键抬起情况获取当前选择位置后的文本内容
// 然后将文本编辑框内容更新为选择位置前的部分并调用监听器的onEditTextEnter方法通知外部在当前编辑框后添加新的编辑框及相应文本内容
// 其他按键则按照父类默认逻辑处理。
@Override @Override
public boolean onKeyUp(int keyCode, KeyEvent event) { public boolean onKeyUp(int keyCode, KeyEvent event) {
switch(keyCode) { switch (keyCode) {
case KeyEvent.KEYCODE_DEL: case KeyEvent.KEYCODE_DEL:
if (mOnTextViewChangeListener != null) { if (mOnTextViewChangeListener!= null) {
if (0 == mSelectionStartBeforeDelete && mIndex != 0) { if (0 == mSelectionStartBeforeDelete && mIndex!= 0) {
mOnTextViewChangeListener.onEditTextDelete(mIndex, getText().toString()); mOnTextViewChangeListener.onEditTextDelete(mIndex, getText().toString());
return true; return true;
} }
@ -152,7 +184,7 @@ public class NoteEditText extends EditText {
} }
break; break;
case KeyEvent.KEYCODE_ENTER: case KeyEvent.KEYCODE_ENTER:
if (mOnTextViewChangeListener != null) { if (mOnTextViewChangeListener!= null) {
int selectionStart = getSelectionStart(); int selectionStart = getSelectionStart();
String text = getText().subSequence(selectionStart, length()).toString(); String text = getText().subSequence(selectionStart, length()).toString();
setText(getText().subSequence(0, selectionStart)); setText(getText().subSequence(0, selectionStart));
@ -167,9 +199,12 @@ public class NoteEditText extends EditText {
return super.onKeyUp(keyCode, event); return super.onKeyUp(keyCode, event);
} }
// 重写父类的onFocusChanged方法用于处理焦点变化事件当焦点改变时如果设置了文本操作事件监听器OnTextViewChangeListener
// 根据当前是否获取焦点以及文本内容是否为空调用监听器的onTextChange方法通知外部相应的文本显示相关选项如是否隐藏、显示某些操作按钮等的变化情况
// 然后再按照父类默认逻辑处理焦点变化的其他相关操作。
@Override @Override
protected void onFocusChanged(boolean focused, int direction, Rect previouslyFocusedRect) { protected void onFocusChanged(boolean focused, int direction, Rect previouslyFocusedRect) {
if (mOnTextViewChangeListener != null) { if (mOnTextViewChangeListener!= null) {
if (!focused && TextUtils.isEmpty(getText())) { if (!focused && TextUtils.isEmpty(getText())) {
mOnTextViewChangeListener.onTextChange(mIndex, false); mOnTextViewChangeListener.onTextChange(mIndex, false);
} else { } else {
@ -179,6 +214,10 @@ public class NoteEditText extends EditText {
super.onFocusChanged(focused, direction, previouslyFocusedRect); super.onFocusChanged(focused, direction, previouslyFocusedRect);
} }
// 重写父类的onCreateContextMenu方法用于创建上下文菜单当文本被长按选中时弹出的菜单内容相关逻辑在此处理。
// 如果文本内容是Spanned类型包含富文本等情况如包含链接获取选中的文本范围查找其中的URLSpan表示链接的一种形式
// 如果只找到一个链接,根据链接的协议头(如"tel:"、"http:"、"mailto:"等获取对应的提示字符串资源ID若找不到对应协议头则使用默认的资源ID
// 然后添加一个菜单项到上下文菜单中点击该菜单项会触发相应的链接跳转逻辑通过调用URLSpan的onClick方法最后再按照父类默认逻辑处理菜单创建的其他相关操作。
@Override @Override
protected void onCreateContextMenu(ContextMenu menu) { protected void onCreateContextMenu(ContextMenu menu) {
if (getText() instanceof Spanned) { if (getText() instanceof Spanned) {
@ -191,8 +230,8 @@ public class NoteEditText extends EditText {
final URLSpan[] urls = ((Spanned) getText()).getSpans(min, max, URLSpan.class); final URLSpan[] urls = ((Spanned) getText()).getSpans(min, max, URLSpan.class);
if (urls.length == 1) { if (urls.length == 1) {
int defaultResId = 0; int defaultResId = 0;
for(String schema: sSchemaActionResMap.keySet()) { for (String schema : sSchemaActionResMap.keySet()) {
if(urls[0].getURL().indexOf(schema) >= 0) { if (urls[0].getURL().indexOf(schema) >= 0) {
defaultResId = sSchemaActionResMap.get(schema); defaultResId = sSchemaActionResMap.get(schema);
break; break;
} }
@ -214,4 +253,4 @@ public class NoteEditText extends EditText {
} }
super.onCreateContextMenu(menu); super.onCreateContextMenu(menu);
} }
} }

@ -26,76 +26,128 @@ import net.micode.notes.data.Notes.NoteColumns;
import net.micode.notes.tool.DataUtils; import net.micode.notes.tool.DataUtils;
// NoteItemData类主要用于封装从数据库游标Cursor中获取的笔记相关数据并提供一系列方法方便外部获取这些数据以及判断笔记的一些状态属性
// 例如是否是最后一项、是否是通话记录等情况,它是对笔记数据在业务逻辑层面的一种抽象和封装。
public class NoteItemData { public class NoteItemData {
// 定义一个字符串数组用于指定从数据库查询笔记信息时要获取的列名涵盖了笔记的ID、提醒日期、背景颜色ID、创建日期等多个重要属性字段。
static final String [] PROJECTION = new String [] { static final String [] PROJECTION = new String [] {
NoteColumns.ID, NoteColumns.ID,
NoteColumns.ALERTED_DATE, NoteColumns.ALERTED_DATE,
NoteColumns.BG_COLOR_ID, NoteColumns.BG_COLOR_ID,
NoteColumns.CREATED_DATE, NoteColumns.CREATED_DATE,
NoteColumns.HAS_ATTACHMENT, NoteColumns.HAS_ATTACHMENT,
NoteColumns.MODIFIED_DATE, NoteColumns.MODIFIED_DATE,
NoteColumns.NOTES_COUNT, NoteColumns.NOTES_COUNT,
NoteColumns.PARENT_ID, NoteColumns.PARENT_ID,
NoteColumns.SNIPPET, NoteColumns.SNIPPET,
NoteColumns.TYPE, NoteColumns.TYPE,
NoteColumns.WIDGET_ID, NoteColumns.WIDGET_ID,
NoteColumns.WIDGET_TYPE, NoteColumns.WIDGET_TYPE,
}; };
// 定义常量表示查询结果中笔记ID所在列的索引值为0方便后续从游标中准确获取对应数据这里命名为ID_COLUMN。
private static final int ID_COLUMN = 0; private static final int ID_COLUMN = 0;
// 定义常量表示查询结果中提醒日期所在列的索引值为1用于后续获取提醒日期数据命名为ALERTED_DATE_COLUMN。
private static final int ALERTED_DATE_COLUMN = 1; private static final int ALERTED_DATE_COLUMN = 1;
// 定义常量表示查询结果中背景颜色ID所在列的索引值为2便于获取背景颜色相关设置信息命名为BG_COLOR_ID_COLUMN。
private static final int BG_COLOR_ID_COLUMN = 2; private static final int BG_COLOR_ID_COLUMN = 2;
// 定义常量表示查询结果中创建日期所在列的索引值为3用于获取笔记创建时间数据命名为CREATED_DATE_COLUMN。
private static final int CREATED_DATE_COLUMN = 3; private static final int CREATED_DATE_COLUMN = 3;
// 定义常量表示查询结果中是否有附件所在列的索引值为4通过判断该列的值来确定笔记是否包含附件命名为HAS_ATTACHMENT_COLUMN。
private static final int HAS_ATTACHMENT_COLUMN = 4; private static final int HAS_ATTACHMENT_COLUMN = 4;
// 定义常量表示查询结果中修改日期所在列的索引值为5用于获取笔记最后修改时间信息命名为MODIFIED_DATE_COLUMN。
private static final int MODIFIED_DATE_COLUMN = 5; private static final int MODIFIED_DATE_COLUMN = 5;
// 定义常量表示查询结果中笔记数量所在列的索引值为6可能用于某些与笔记数量相关的业务逻辑判断命名为NOTES_COUNT_COLUMN。
private static final int NOTES_COUNT_COLUMN = 6; private static final int NOTES_COUNT_COLUMN = 6;
// 定义常量表示查询结果中父文件夹ID所在列的索引值为7可通过该值确定笔记所属的父文件夹命名为PARENT_ID_COLUMN。
private static final int PARENT_ID_COLUMN = 7; private static final int PARENT_ID_COLUMN = 7;
// 定义常量表示查询结果中摘要片段信息所在列的索引值为8通常用于展示笔记的简短内容描述命名为SNIPPET_COLUMN。
private static final int SNIPPET_COLUMN = 8; private static final int SNIPPET_COLUMN = 8;
// 定义常量表示查询结果中笔记类型所在列的索引值为9用于判断笔记是普通笔记、文件夹还是其他类型命名为TYPE_COLUMN。
private static final int TYPE_COLUMN = 9; private static final int TYPE_COLUMN = 9;
// 定义常量表示查询结果中小部件ID所在列的索引值为10可能涉及与桌面小部件相关的业务逻辑命名为WIDGET_ID_COLUMN。
private static final int WIDGET_ID_COLUMN = 10; private static final int WIDGET_ID_COLUMN = 10;
// 定义常量表示查询结果中小部件类型所在列的索引值为11同样用于小部件相关的类型判断等操作命名为WIDGET_TYPE_COLUMN。
private static final int WIDGET_TYPE_COLUMN = 11; private static final int WIDGET_TYPE_COLUMN = 11;
// 笔记的唯一标识符存储从游标中获取的笔记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;
// 用于标记笔记是否包含附件根据游标中对应列的值大于0表示有附件进行设置方便在业务逻辑中判断是否需要处理附件相关操作。
private boolean mHasAttachment; private boolean mHasAttachment;
// 笔记的最后修改日期,同样以时间戳形式存储,可用于展示笔记的更新情况以及相关业务逻辑判断,比如判断笔记是否被修改等。
private long mModifiedDate; private long mModifiedDate;
// 可能表示与笔记相关的数量信息(具体含义取决于业务场景),从游标对应列获取该整数值,用于相应的业务逻辑处理。
private int mNotesCount; private int mNotesCount;
// 笔记所属的父文件夹ID通过游标获取该值可以确定笔记在文件夹层级结构中的位置关系方便进行分类、查找等操作。
private long mParentId; private long mParentId;
// 笔记的摘要(片段)内容,从游标获取后存储,通常是笔记内容的简短描述,用于在列表等场景展示给用户一个大致的内容提示,
// 并且在这里会去除一些特定的标记字符(如复选框相关的标记)进行规范化处理。
private String mSnippet; private String mSnippet;
// 笔记的类型,通过游标获取对应列的整数值,用于区分是普通笔记、文件夹还是其他特定类型的记录,以便执行不同的业务逻辑。
private int mType; private int mType;
// 与笔记关联的小部件ID可能用于桌面小部件相关的业务逻辑比如根据小部件ID来更新对应的小部件显示内容等操作。
private int mWidgetId; private int mWidgetId;
// 笔记关联的小部件类型,同样用于小部件相关的业务逻辑判断和处理,例如不同类型小部件展示方式可能不同等情况。
private int mWidgetType; private int mWidgetType;
// 用于存储通话记录相关的联系人姓名,如果笔记属于通话记录文件夹,则尝试获取对应的联系人姓名,若获取失败则使用电话号码作为替代。
private String mName; private String mName;
// 用于存储通话记录相关的电话号码,当笔记属于通话记录文件夹时,通过工具方法获取对应的电话号码信息,用于通话记录相关的业务逻辑处理。
private String mPhoneNumber; private String mPhoneNumber;
// 标记当前笔记是否是列表中的最后一项,通过游标的相关方法判断并设置,方便在列表展示等场景中进行相应的界面处理或业务逻辑判断。
private boolean mIsLastItem; private boolean mIsLastItem;
// 标记当前笔记是否是列表中的第一项,同样依据游标状态进行判断和设置,可用于列表相关的展示逻辑以及操作逻辑区分。
private boolean mIsFirstItem; private boolean mIsFirstItem;
// 标记当前笔记所在的列表是否只包含这一项通过判断游标获取的总记录数是否为1来确定用于一些特殊业务场景下的逻辑判断。
private boolean mIsOnlyOneItem; private boolean mIsOnlyOneItem;
// 标记当前笔记是否是某个文件夹下唯一的一条笔记(后续跟着文件夹的情况),通过特定的游标移动和类型判断逻辑来确定,用于相关业务逻辑处理。
private boolean mIsOneNoteFollowingFolder; private boolean mIsOneNoteFollowingFolder;
// 标记当前笔记是否是某个文件夹后跟着多条笔记中的一条(即所在文件夹下有多条笔记的情况),同样基于游标操作和类型判断逻辑来设置,用于对应业务场景的处理。
private boolean mIsMultiNotesFollowingFolder; private boolean mIsMultiNotesFollowingFolder;
// 构造函数接收上下文和数据库游标作为参数用于从游标中获取各项笔记数据并进行初始化同时调用checkPostion方法来判断笔记在列表中的相关位置状态属性。
public NoteItemData(Context context, Cursor cursor) { public NoteItemData(Context context, Cursor cursor) {
// 从游标中获取笔记的ID并赋值给对应的成员变量通过使用预定义的列索引常量ID_COLUMN来确保准确获取相应数据。
mId = cursor.getLong(ID_COLUMN); mId = cursor.getLong(ID_COLUMN);
// 从游标获取笔记的提醒日期并存储使用ALERTED_DATE_COLUMN索引确保获取正确列的数据。
mAlertDate = cursor.getLong(ALERTED_DATE_COLUMN); mAlertDate = cursor.getLong(ALERTED_DATE_COLUMN);
// 获取笔记的背景颜色ID依据BG_COLOR_ID_COLUMN索引从游标中提取对应数据并赋值。
mBgColorId = cursor.getInt(BG_COLOR_ID_COLUMN); mBgColorId = cursor.getInt(BG_COLOR_ID_COLUMN);
// 获取笔记的创建日期按照CREATED_DATE_COLUMN索引从游标获取相应时间戳数据进行存储。
mCreatedDate = cursor.getLong(CREATED_DATE_COLUMN); mCreatedDate = cursor.getLong(CREATED_DATE_COLUMN);
mHasAttachment = (cursor.getInt(HAS_ATTACHMENT_COLUMN) > 0) ? true : false; // 根据游标中对应列的值判断笔记是否有附件大于0则设置为true否则为false使用HAS_ATTACHMENT_COLUMN索引来定位数据列。
mHasAttachment = (cursor.getInt(HAS_ATTACHMENT_COLUMN) > 0)? true : false;
// 获取笔记的修改日期通过MODIFIED_DATE_COLUMN索引从游标获取相应时间戳并赋值给成员变量。
mModifiedDate = cursor.getLong(MODIFIED_DATE_COLUMN); mModifiedDate = cursor.getLong(MODIFIED_DATE_COLUMN);
// 获取笔记相关的数量信息具体含义取决于业务场景利用NOTES_COUNT_COLUMN索引从游标中获取整数值存储起来。
mNotesCount = cursor.getInt(NOTES_COUNT_COLUMN); mNotesCount = cursor.getInt(NOTES_COUNT_COLUMN);
// 获取笔记所属的父文件夹ID借助PARENT_ID_COLUMN索引从游标获取对应数据赋值给成员变量用于后续确定笔记的层级关系等操作。
mParentId = cursor.getLong(PARENT_ID_COLUMN); mParentId = cursor.getLong(PARENT_ID_COLUMN);
// 获取笔记的摘要片段内容通过SNIPPET_COLUMN索引从游标获取字符串数据并去除特定的复选框相关标记字符进行规范化处理后存储。
mSnippet = cursor.getString(SNIPPET_COLUMN); mSnippet = cursor.getString(SNIPPET_COLUMN);
mSnippet = mSnippet.replace(NoteEditActivity.TAG_CHECKED, "").replace( mSnippet = mSnippet.replace(NoteEditActivity.TAG_CHECKED, "").replace(
NoteEditActivity.TAG_UNCHECKED, ""); NoteEditActivity.TAG_UNCHECKED, "");
// 获取笔记的类型根据TYPE_COLUMN索引从游标获取整数值来确定笔记是何种类型如普通笔记、文件夹等用于后续不同类型的业务逻辑处理。
mType = cursor.getInt(TYPE_COLUMN); mType = cursor.getInt(TYPE_COLUMN);
// 获取与笔记关联的小部件ID使用WIDGET_ID_COLUMN索引从游标获取对应整数值存储起来用于小部件相关业务逻辑。
mWidgetId = cursor.getInt(WIDGET_ID_COLUMN); mWidgetId = cursor.getInt(WIDGET_ID_COLUMN);
// 获取笔记关联的小部件类型依靠WIDGET_TYPE_COLUMN索引从游标获取相应整数值便于针对不同小部件类型的处理操作。
mWidgetType = cursor.getInt(WIDGET_TYPE_COLUMN); mWidgetType = cursor.getInt(WIDGET_TYPE_COLUMN);
// 初始化通话记录相关的电话号码为空字符串,后续根据笔记所属文件夹等情况判断是否需要获取实际电话号码。
mPhoneNumber = ""; mPhoneNumber = "";
if (mParentId == Notes.ID_CALL_RECORD_FOLDER) { if (mParentId == Notes.ID_CALL_RECORD_FOLDER) {
// 如果笔记所属的父文件夹是通话记录文件夹通过工具方法DataUtils.getCallNumberByNoteId尝试从内容解析器获取对应的电话号码信息。
mPhoneNumber = DataUtils.getCallNumberByNoteId(context.getContentResolver(), mId); mPhoneNumber = DataUtils.getCallNumberByNoteId(context.getContentResolver(), mId);
if (!TextUtils.isEmpty(mPhoneNumber)) { if (!TextUtils.isEmpty(mPhoneNumber)) {
// 如果获取到了电话号码尝试通过联系人工具类Contact根据电话号码获取对应的联系人姓名若获取失败则使用电话号码作为姓名显示。
mName = Contact.getContact(context, mPhoneNumber); mName = Contact.getContact(context, mPhoneNumber);
if (mName == null) { if (mName == null) {
mName = mPhoneNumber; mName = mPhoneNumber;
@ -109,14 +161,19 @@ public class NoteItemData {
checkPostion(cursor); checkPostion(cursor);
} }
// 用于判断当前笔记在列表中的位置相关状态属性的私有方法,通过游标操作来判断是否是最后一项、第一项、是否唯一一项以及是否是某个文件夹后的笔记情况等,
// 并设置相应的成员变量标记,方便外部通过对应的访问方法获取这些状态信息进行业务逻辑处理。
private void checkPostion(Cursor cursor) { private void checkPostion(Cursor cursor) {
mIsLastItem = cursor.isLast() ? true : false; // 判断游标是否指向最后一条记录若是则将mIsLastItem设置为true表示当前笔记是列表中的最后一项否则为false。
mIsFirstItem = cursor.isFirst() ? true : false; mIsLastItem = cursor.isLast()? true : false;
// 判断游标是否指向第一条记录若为是则将mIsFirstItem设置为true表明当前笔记是列表中的第一项反之则为false。
mIsFirstItem = cursor.isFirst()? true : false;
// 通过判断游标获取的记录总数是否为1来确定当前笔记所在的列表是否只有这一项若是则将mIsOnlyOneItem设置为true。
mIsOnlyOneItem = (cursor.getCount() == 1); mIsOnlyOneItem = (cursor.getCount() == 1);
mIsMultiNotesFollowingFolder = false; mIsMultiNotesFollowingFolder = false;
mIsOneNoteFollowingFolder = false; mIsOneNoteFollowingFolder = false;
if (mType == Notes.TYPE_NOTE && !mIsFirstItem) { if (mType == Notes.TYPE_NOTE &&!mIsFirstItem) {
int position = cursor.getPosition(); int position = cursor.getPosition();
if (cursor.moveToPrevious()) { if (cursor.moveToPrevious()) {
if (cursor.getInt(TYPE_COLUMN) == Notes.TYPE_FOLDER if (cursor.getInt(TYPE_COLUMN) == Notes.TYPE_FOLDER
@ -134,91 +191,70 @@ public class NoteItemData {
} }
} }
// 用于判断当前笔记是否是某个文件夹下唯一的一条笔记(后续跟着文件夹的情况)的方法,返回对应的成员变量值,外部可通过调用此方法获取该状态信息进行相应逻辑处理。
public boolean isOneFollowingFolder() { public boolean isOneFollowingFolder() {
return mIsOneNoteFollowingFolder; return mIsOneNoteFollowingFolder;
} }
// 用于判断当前笔记是否是某个文件夹后跟着多条笔记中的一条(即所在文件夹下有多条笔记的情况)的方法,返回相应的成员变量值,方便外部根据此状态进行业务逻辑操作。
public boolean isMultiFollowingFolder() { public boolean isMultiFollowingFolder() {
return mIsMultiNotesFollowingFolder; return mIsMultiNotesFollowingFolder;
} }
// 用于判断当前笔记是否是列表中的最后一项的方法,返回对应的成员变量值,可在列表展示等场景中根据此结果进行界面处理或其他相关逻辑判断。
public boolean isLast() { public boolean isLast() {
return mIsLastItem; return mIsLastItem;
} }
// 用于获取通话记录相关的联系人姓名的方法,如果笔记属于通话记录文件夹,则返回获取到的联系人姓名(若获取失败则返回电话号码或者空字符串),方便外部展示相关信息。
public String getCallName() { public String getCallName() {
return mName; return mName;
} }
// 用于判断当前笔记是否是列表中的第一项的方法,返回对应的成员变量值,在列表相关的业务逻辑中可依据此结果进行不同的处理操作。
public boolean isFirst() { public boolean isFirst() {
return mIsFirstItem; return mIsFirstItem;
} }
// 用于判断当前笔记所在的列表是否只包含这一项的方法,返回对应的成员变量值,可用于特定业务场景下的逻辑判断和处理。
public boolean isSingle() { public boolean isSingle() {
return mIsOnlyOneItem; return mIsOnlyOneItem;
} }
// 用于获取笔记的唯一标识符ID的方法返回存储的笔记ID值外部可通过调用此方法获取该笔记的ID进行如查找、关联等相关操作。
public long getId() { public long getId() {
return mId; return mId;
} }
// 用于获取笔记设置的提醒日期的方法,返回存储的提醒日期时间戳数据,可用于判断笔记是否有提醒以及相关提醒时间相关的业务逻辑处理。
public long getAlertDate() { public long getAlertDate() {
return mAlertDate; return mAlertDate;
} }
// 用于获取笔记的创建日期的方法,返回存储的创建日期时间戳,便于在展示笔记信息等场景中显示创建时间相关内容。
public long getCreatedDate() { public long getCreatedDate() {
return mCreatedDate; return mCreatedDate;
} }
// 用于判断笔记是否包含附件的方法,返回对应的成员变量值,外部可依据此结果决定是否展示附件相关操作入口等业务逻辑处理。
public boolean hasAttachment() { public boolean hasAttachment() {
return mHasAttachment; return mHasAttachment;
} }
// 用于获取笔记的最后修改日期的方法,返回存储的修改日期时间戳,可用于展示笔记更新情况以及相关业务逻辑判断,比如判断笔记是否被修改等操作。
public long getModifiedDate() { public long getModifiedDate() {
return mModifiedDate; return mModifiedDate;
} }
// 用于获取笔记的背景颜色ID的方法返回存储的背景颜色ID值方便在界面展示等场景中根据该ID设置笔记的背景颜色相关操作。
public int getBgColorId() { public int getBgColorId() {
return mBgColorId; return mBgColorId;
} }
// 用于获取笔记所属的父文件夹ID的方法返回存储的父文件夹ID值通过此方法可确定笔记在文件夹层级结构中的位置关系方便进行分类、查找等操作。
public long getParentId() { public long getParentId() {
return mParentId; return mParentId;
} }
public int getNotesCount() { // 用于获取与笔记相关的数量信息(具体含义取决于业务场景)的方法,返回存储的整数值,用于相应的业务逻辑处理。
return mNotesCount; public
}
public long getFolderId () {
return mParentId;
}
public int getType() {
return mType;
}
public int getWidgetType() {
return mWidgetType;
}
public int getWidgetId() {
return mWidgetId;
}
public String getSnippet() {
return mSnippet;
}
public boolean hasAlert() {
return (mAlertDate > 0);
}
public boolean isCallRecord() {
return (mParentId == Notes.ID_CALL_RECORD_FOLDER && !TextUtils.isEmpty(mPhoneNumber));
}
public static int getNoteType(Cursor cursor) {
return cursor.getInt(TYPE_COLUMN);
}
}

@ -32,153 +32,29 @@ import java.util.Iterator;
public class NotesListAdapter extends CursorAdapter { public class NotesListAdapter extends CursorAdapter {
// 用于日志输出的标签
private static final String TAG = "NotesListAdapter"; private static final String TAG = "NotesListAdapter";
// 上下文对象,用于获取资源等操作
private Context mContext; private Context mContext;
// 用于记录已选中项的索引及对应选中状态的哈希映射,键为列表项索引,值为是否选中的布尔值
private HashMap<Integer, Boolean> mSelectedIndex; private HashMap<Integer, Boolean> mSelectedIndex;
// 笔记的数量统计
private int mNotesCount; private int mNotesCount;
// 表示是否处于选择模式的标志
private boolean mChoiceMode; private boolean mChoiceMode;
// 内部静态类用于封装与应用小部件相关的属性小部件ID和类型
public static class AppWidgetAttribute { public static class AppWidgetAttribute {
public int widgetId; public int widgetId;
public int widgetType; public int widgetType;
}; };
public NotesListAdapter(Context context) { public NotesListAdapter(Context context) {
// 调用父类构造方法传入上下文并将游标初始化为null
super(context, null); super(context, null);
// 初始化选中索引的哈希映射
mSelectedIndex = new HashMap<Integer, Boolean>(); mSelectedIndex = new HashMap<Integer, Boolean>();
// 保存传入的上下文对象
mContext = context; mContext = context;
// 初始化笔记数量为0
mNotesCount = 0; mNotesCount = 0;
} }
@Override
public View newView(Context context, Cursor cursor, ViewGroup parent) {
return new NotesListItem(context);
}
@Override
public void bindView(View view, Context context, Cursor cursor) {
if (view instanceof NotesListItem) {
NoteItemData itemData = new NoteItemData(context, cursor);
((NotesListItem) view).bind(context, itemData, mChoiceMode,
isSelectedItem(cursor.getPosition()));
}
}
public void setCheckedItem(final int position, final boolean checked) {
mSelectedIndex.put(position, checked);
notifyDataSetChanged();
}
public boolean isInChoiceMode() {
return mChoiceMode;
}
public void setChoiceMode(boolean mode) {
mSelectedIndex.clear();
mChoiceMode = mode;
}
public void selectAll(boolean checked) {
Cursor cursor = getCursor();
for (int i = 0; i < getCount(); i++) {
if (cursor.moveToPosition(i)) {
if (NoteItemData.getNoteType(cursor) == Notes.TYPE_NOTE) {
setCheckedItem(i, checked);
}
}
}
}
public HashSet<Long> getSelectedItemIds() {
HashSet<Long> itemSet = new HashSet<Long>();
for (Integer position : mSelectedIndex.keySet()) {
if (mSelectedIndex.get(position) == true) {
Long id = getItemId(position);
if (id == Notes.ID_ROOT_FOLDER) {
Log.d(TAG, "Wrong item id, should not happen");
} else {
itemSet.add(id);
}
}
}
return itemSet;
}
public HashSet<AppWidgetAttribute> getSelectedWidget() {
HashSet<AppWidgetAttribute> itemSet = new HashSet<AppWidgetAttribute>();
for (Integer position : mSelectedIndex.keySet()) {
if (mSelectedIndex.get(position) == true) {
Cursor c = (Cursor) getItem(position);
if (c != null) {
AppWidgetAttribute widget = new AppWidgetAttribute();
NoteItemData item = new NoteItemData(mContext, c);
widget.widgetId = item.getWidgetId();
widget.widgetType = item.getWidgetType();
itemSet.add(widget);
/**
* Don't close cursor here, only the adapter could close it
*/
} else {
Log.e(TAG, "Invalid cursor");
return null;
}
}
}
return itemSet;
}
public int getSelectedCount() {
Collection<Boolean> values = mSelectedIndex.values();
if (null == values) {
return 0;
}
Iterator<Boolean> iter = values.iterator();
int count = 0;
while (iter.hasNext()) {
if (true == iter.next()) {
count++;
}
}
return count;
}
public boolean isAllSelected() {
int checkedCount = getSelectedCount();
return (checkedCount != 0 && checkedCount == mNotesCount);
}
public boolean isSelectedItem(final int position) {
if (null == mSelectedIndex.get(position)) {
return false;
}
return mSelectedIndex.get(position);
}
@Override
protected void onContentChanged() {
super.onContentChanged();
calcNotesCount();
}
@Override
public void changeCursor(Cursor cursor) {
super.changeCursor(cursor);
calcNotesCount();
}
private void calcNotesCount() {
mNotesCount = 0;
for (int i = 0; i < getCount(); i++) {
Cursor c = (Cursor) getItem(i);
if (c != null) {
if (NoteItemData.getNoteType(c) == Notes.TYPE_NOTE) {
mNotesCount++;
}
} else {
Log.e(TAG, "Invalid cursor");
return;
}
}
}
}

@ -31,33 +31,42 @@ import net.micode.notes.tool.ResourceParser.NoteItemBgResources;
public class NotesListItem extends LinearLayout { public class NotesListItem extends LinearLayout {
// 用于显示提醒相关图标的 ImageView可能表示笔记有提醒等情况
private ImageView mAlert; private ImageView mAlert;
// 用于显示笔记或文件夹标题的 TextView
private TextView mTitle; private TextView mTitle;
// 用于显示时间相关信息(如修改时间等)的 TextView
private TextView mTime; private TextView mTime;
// 用于显示通话记录相关名称的 TextView可能在特定的通话记录相关场景下使用
private TextView mCallName; private TextView mCallName;
// 封装了笔记或文件夹相关数据的对象,用于在列表项中展示具体内容
private NoteItemData mItemData; private NoteItemData mItemData;
// 复选框,用于在选择模式下标记该项是否被选中
private CheckBox mCheckBox; private CheckBox mCheckBox;
public NotesListItem(Context context) { public NotesListItem(Context context) {
super(context); super(context);
// 通过布局资源文件来填充当前的LinearLayout即NotesListItem自身使其具备相应的子视图布局结构
inflate(context, R.layout.note_item, this); inflate(context, R.layout.note_item, this);
// 通过ID查找并初始化对应的子视图组件
mAlert = (ImageView) findViewById(R.id.iv_alert_icon); mAlert = (ImageView) findViewById(R.id.iv_alert_icon);
mTitle = (TextView) findViewById(R.id.tv_title); mTitle = (TextView) findViewById(R.id.tv_title);
mTime = (TextView) findViewById(R.id.tv_time); mTime = (TextView) findViewById(R.id.tv_time);
mCallName = (TextView) findViewById(R.id.tv_name); mCallName = (TextView) findViewById(R.id.tv_name);
mCheckBox = (CheckBox) findViewById(android.R.id.checkbox); mCheckBox = (CheckBox) findViewById(android.R.id.checkbox);
} }
public void bind(Context context, NoteItemData data, boolean choiceMode, boolean checked) { public void bind(Context context, NoteItemData data, boolean choiceMode, boolean checked) {
if (choiceMode && data.getType() == Notes.TYPE_NOTE) { if (choiceMode && data.getType() == Notes.TYPE_NOTE) {
// 如果处于选择模式且当前数据对应的是笔记类型,则显示复选框,并根据传入的选中状态设置复选框的勾选状态
mCheckBox.setVisibility(View.VISIBLE); mCheckBox.setVisibility(View.VISIBLE);
mCheckBox.setChecked(checked); mCheckBox.setChecked(checked);
} else { } else {
// 否则隐藏复选框,比如在非选择模式或者是文件夹类型等情况时不需要显示复选框
mCheckBox.setVisibility(View.GONE); mCheckBox.setVisibility(View.GONE);
} }
mItemData = data; mItemData = data;
if (data.getId() == Notes.ID_CALL_RECORD_FOLDER) { if (data.getId() == Notes.ID_CALL_RECORD_FOLDER) {
// 如果当前数据对应的是通话记录文件夹
mCallName.setVisibility(View.GONE); mCallName.setVisibility(View.GONE);
mAlert.setVisibility(View.VISIBLE); mAlert.setVisibility(View.VISIBLE);
mTitle.setTextAppearance(context, R.style.TextAppearancePrimaryItem); mTitle.setTextAppearance(context, R.style.TextAppearancePrimaryItem);
@ -65,6 +74,7 @@ public class NotesListItem extends LinearLayout {
+ context.getString(R.string.format_folder_files_count, data.getNotesCount())); + context.getString(R.string.format_folder_files_count, data.getNotesCount()));
mAlert.setImageResource(R.drawable.call_record); mAlert.setImageResource(R.drawable.call_record);
} else if (data.getParentId() == Notes.ID_CALL_RECORD_FOLDER) { } else if (data.getParentId() == Notes.ID_CALL_RECORD_FOLDER) {
// 如果当前数据的父文件夹是通话记录文件夹,通常表示属于通话记录相关的具体内容
mCallName.setVisibility(View.VISIBLE); mCallName.setVisibility(View.VISIBLE);
mCallName.setText(data.getCallName()); mCallName.setText(data.getCallName());
mTitle.setTextAppearance(context,R.style.TextAppearanceSecondaryItem); mTitle.setTextAppearance(context,R.style.TextAppearanceSecondaryItem);
@ -80,11 +90,13 @@ public class NotesListItem extends LinearLayout {
mTitle.setTextAppearance(context, R.style.TextAppearancePrimaryItem); mTitle.setTextAppearance(context, R.style.TextAppearancePrimaryItem);
if (data.getType() == Notes.TYPE_FOLDER) { if (data.getType() == Notes.TYPE_FOLDER) {
// 如果当前数据对应的是普通文件夹类型,设置标题文本包含文件夹名称及其中文件数量信息,并隐藏提醒图标
mTitle.setText(data.getSnippet() mTitle.setText(data.getSnippet()
+ context.getString(R.string.format_folder_files_count, + context.getString(R.string.format_folder_files_count,
data.getNotesCount())); data.getNotesCount()));
mAlert.setVisibility(View.GONE); mAlert.setVisibility(View.GONE);
} else { } else {
// 如果是普通笔记类型,设置标题为格式化后的笔记摘要内容,并根据是否有提醒来显示或隐藏提醒图标
mTitle.setText(DataUtils.getFormattedSnippet(data.getSnippet())); mTitle.setText(DataUtils.getFormattedSnippet(data.getSnippet()));
if (data.hasAlert()) { if (data.hasAlert()) {
mAlert.setImageResource(R.drawable.clock); mAlert.setImageResource(R.drawable.clock);
@ -94,11 +106,12 @@ public class NotesListItem extends LinearLayout {
} }
} }
} }
// 设置时间文本,显示相对时间(可能是相对于当前时间的修改时间等)
mTime.setText(DateUtils.getRelativeTimeSpanString(data.getModifiedDate())); mTime.setText(DateUtils.getRelativeTimeSpanString(data.getModifiedDate()));
// 根据数据设置列表项的背景样式,区分笔记和文件夹以及笔记的不同状态等情况
setBackground(data); setBackground(data);
} }
private void setBackground(NoteItemData data) { private void setBackground(NoteItemData data) {
int id = data.getBgColorId(); int id = data.getBgColorId();
if (data.getType() == Notes.TYPE_NOTE) { if (data.getType() == Notes.TYPE_NOTE) {
@ -115,8 +128,6 @@ public class NotesListItem extends LinearLayout {
setBackgroundResource(NoteItemBgResources.getFolderBgRes()); setBackgroundResource(NoteItemBgResources.getFolderBgRes());
} }
} }
public NoteItemData getItemData() { public NoteItemData getItemData() {
return mItemData; return mItemData;
} }
}

@ -49,42 +49,51 @@ import net.micode.notes.gtask.remote.GTaskSyncService;
public class NotesPreferenceActivity extends PreferenceActivity { public class NotesPreferenceActivity extends PreferenceActivity {
// 存储偏好设置的名称
public static final String PREFERENCE_NAME = "notes_preferences"; public static final String PREFERENCE_NAME = "notes_preferences";
// 偏好设置中同步账号名称对应的键
public static final String PREFERENCE_SYNC_ACCOUNT_NAME = "pref_key_account_name"; public static final String PREFERENCE_SYNC_ACCOUNT_NAME = "pref_key_account_name";
// 偏好设置中上次同步时间对应的键
public static final String PREFERENCE_LAST_SYNC_TIME = "pref_last_sync_time"; public static final String PREFERENCE_LAST_SYNC_TIME = "pref_last_sync_time";
// 偏好设置中设置背景颜色相关键(从变量名推测,可能用于控制背景颜色随机出现相关功能)
public static final String PREFERENCE_SET_BG_COLOR_KEY = "pref_key_bg_random_appear"; public static final String PREFERENCE_SET_BG_COLOR_KEY = "pref_key_bg_random_appear";
// 同步账号相关偏好设置分类的键
private static final String PREFERENCE_SYNC_ACCOUNT_KEY = "pref_sync_account_key"; private static final String PREFERENCE_SYNC_ACCOUNT_KEY = "pref_sync_account_key";
// 权限相关过滤键(可能用于账户相关权限过滤,具体需结合更多上下文判断)
private static final String AUTHORITIES_FILTER_KEY = "authorities"; private static final String AUTHORITIES_FILTER_KEY = "authorities";
// 用于展示同步账号相关偏好设置的分类
private PreferenceCategory mAccountCategory; private PreferenceCategory mAccountCategory;
// 广播接收器,用于接收同步服务相关广播
private GTaskReceiver mReceiver; private GTaskReceiver mReceiver;
// 记录原始的账号列表(用于对比账号变化等情况)
private Account[] mOriAccounts; private Account[] mOriAccounts;
// 标记是否添加了新账号
private boolean mHasAddedAccount; private boolean mHasAddedAccount;
@Override @Override
protected void onCreate(Bundle icicle) { protected void onCreate(Bundle icicle) {
super.onCreate(icicle); super.onCreate(icicle);
/* using the app icon for navigation */ // 使用应用图标进行导航启用返回上级页面功能ActionBar上显示返回箭头
getActionBar().setDisplayHomeAsUpEnabled(true); getActionBar().setDisplayHomeAsUpEnabled(true);
// 从指定的XML资源文件加载偏好设置界面布局
addPreferencesFromResource(R.xml.preferences); addPreferencesFromResource(R.xml.preferences);
// 获取同步账号相关的偏好设置分类
mAccountCategory = (PreferenceCategory) findPreference(PREFERENCE_SYNC_ACCOUNT_KEY); mAccountCategory = (PreferenceCategory) findPreference(PREFERENCE_SYNC_ACCOUNT_KEY);
// 创建广播接收器实例
mReceiver = new GTaskReceiver(); mReceiver = new GTaskReceiver();
IntentFilter filter = new IntentFilter(); IntentFilter filter = new IntentFilter();
// 注册接收同步服务广播的过滤器,监听同步服务广播的特定动作
filter.addAction(GTaskSyncService.GTASK_SERVICE_BROADCAST_NAME); filter.addAction(GTaskSyncService.GTASK_SERVICE_BROADCAST_NAME);
// 注册广播接收器,用于接收同步服务相关广播
registerReceiver(mReceiver, filter); registerReceiver(mReceiver, filter);
mOriAccounts = null; mOriAccounts = null;
// 加载设置界面头部视图
View header = LayoutInflater.from(this).inflate(R.layout.settings_header, null); View header = LayoutInflater.from(this).inflate(R.layout.settings_header, null);
// 将头部视图添加到ListView用于显示偏好设置的列表视图并设置相关参数
getListView().addHeaderView(header, null, true); getListView().addHeaderView(header, null, true);
} }
@ -92,19 +101,23 @@ public class NotesPreferenceActivity extends PreferenceActivity {
protected void onResume() { protected void onResume() {
super.onResume(); super.onResume();
// need to set sync account automatically if user has added a new // 如果用户添加了新账号,需要自动设置同步账号
// account
if (mHasAddedAccount) { if (mHasAddedAccount) {
// 获取当前的谷歌账号列表
Account[] accounts = getGoogleAccounts(); Account[] accounts = getGoogleAccounts();
if (mOriAccounts != null && accounts.length > mOriAccounts.length) { // 判断原始账号列表不为空且当前账号数量比原始账号数量多(意味着可能添加了新账号)
if (mOriAccounts!= null && accounts.length > mOriAccounts.length) {
// 遍历新账号列表
for (Account accountNew : accounts) { for (Account accountNew : accounts) {
boolean found = false; boolean found = false;
// 遍历原始账号列表,对比新账号是否已经存在
for (Account accountOld : mOriAccounts) { for (Account accountOld : mOriAccounts) {
if (TextUtils.equals(accountOld.name, accountNew.name)) { if (TextUtils.equals(accountOld.name, accountNew.name)) {
found = true; found = true;
break; break;
} }
} }
// 如果新账号在原始账号中不存在,设置该新账号为同步账号,并跳出循环
if (!found) { if (!found) {
setSyncAccount(accountNew.name); setSyncAccount(accountNew.name);
break; break;
@ -113,120 +126,164 @@ public class NotesPreferenceActivity extends PreferenceActivity {
} }
} }
// 刷新界面UI更新相关显示内容比如账号信息、同步按钮状态等
refreshUI(); refreshUI();
} }
@Override @Override
protected void onDestroy() { protected void onDestroy() {
if (mReceiver != null) { // 如果广播接收器不为空,注销广播接收器,避免内存泄漏等问题
if (mReceiver!= null) {
unregisterReceiver(mReceiver); unregisterReceiver(mReceiver);
} }
super.onDestroy(); super.onDestroy();
} }
/**
*
*/
private void loadAccountPreference() { private void loadAccountPreference() {
// 移除账号分类下的所有已有偏好设置项
mAccountCategory.removeAll(); mAccountCategory.removeAll();
// 创建一个新的偏好设置项(用于展示账号相关操作入口)
Preference accountPref = new Preference(this); Preference accountPref = new Preference(this);
// 获取当前设置的同步账号名称(如果有的话)
final String defaultAccount = getSyncAccountName(this); final String defaultAccount = getSyncAccountName(this);
// 设置账号偏好设置项的标题
accountPref.setTitle(getString(R.string.preferences_account_title)); accountPref.setTitle(getString(R.string.preferences_account_title));
// 设置账号偏好设置项的摘要内容
accountPref.setSummary(getString(R.string.preferences_account_summary)); accountPref.setSummary(getString(R.string.preferences_account_summary));
// 设置账号偏好设置项的点击监听器,处理点击事件逻辑
accountPref.setOnPreferenceClickListener(new OnPreferenceClickListener() { accountPref.setOnPreferenceClickListener(new OnPreferenceClickListener() {
public boolean onPreferenceClick(Preference preference) { public boolean onPreferenceClick(Preference preference) {
// 如果同步服务当前没有在同步中
if (!GTaskSyncService.isSyncing()) { if (!GTaskSyncService.isSyncing()) {
// 如果还没有设置过同步账号(账号名称为空)
if (TextUtils.isEmpty(defaultAccount)) { if (TextUtils.isEmpty(defaultAccount)) {
// the first time to set account // 首次设置账号,弹出选择账号的对话框
showSelectAccountAlertDialog(); showSelectAccountAlertDialog();
} else { } else {
// if the account has already been set, we need to promp // 如果已经设置过账号,弹出确认修改账号的对话框(提示相关风险等)
// user about the risk
showChangeAccountConfirmAlertDialog(); showChangeAccountConfirmAlertDialog();
} }
} else { } else {
// 如果同步服务正在同步,显示提示信息告知用户不能修改账号
Toast.makeText(NotesPreferenceActivity.this, Toast.makeText(NotesPreferenceActivity.this,
R.string.preferences_toast_cannot_change_account, Toast.LENGTH_SHORT) R.string.preferences_toast_cannot_change_account, Toast.LENGTH_SHORT)
.show(); .show();
} }
return true; return true;
} }
}); });
// 将账号偏好设置项添加到账号分类下
mAccountCategory.addPreference(accountPref); mAccountCategory.addPreference(accountPref);
} }
/**
*
*/
private void loadSyncButton() { private void loadSyncButton() {
// 获取同步按钮实例
Button syncButton = (Button) findViewById(R.id.preference_sync_button); Button syncButton = (Button) findViewById(R.id.preference_sync_button);
// 获取显示上次同步时间的文本视图实例
TextView lastSyncTimeView = (TextView) findViewById(R.id.prefenerece_sync_status_textview); TextView lastSyncTimeView = (TextView) findViewById(R.id.prefenerece_sync_status_textview);
// set button state // 根据同步服务是否正在同步来设置同步按钮的文本和点击事件逻辑
if (GTaskSyncService.isSyncing()) { if (GTaskSyncService.isSyncing()) {
// 如果正在同步,按钮文本设置为取消同步
syncButton.setText(getString(R.string.preferences_button_sync_cancel)); syncButton.setText(getString(R.string.preferences_button_sync_cancel));
// 设置按钮点击事件,点击时取消同步操作
syncButton.setOnClickListener(new View.OnClickListener() { syncButton.setOnClickListener(new View.OnClickListener() {
public void onClick(View v) { public void onClick(View v) {
GTaskSyncService.cancelSync(NotesPreferenceActivity.this); GTaskSyncService.cancelSync(NotesPreferenceActivity.this);
} }
}); });
} else { } else {
// 如果没有同步,按钮文本设置为立即同步
syncButton.setText(getString(R.string.preferences_button_sync_immediately)); syncButton.setText(getString(R.string.preferences_button_sync_immediately));
// 设置按钮点击事件,点击时开始同步操作
syncButton.setOnClickListener(new View.OnClickListener() { syncButton.setOnClickListener(new View.OnClickListener() {
public void onClick(View v) { public void onClick(View v) {
GTaskSyncService.startSync(NotesPreferenceActivity.this); GTaskSyncService.startSync(NotesPreferenceActivity.this);
} }
}); });
} }
// 按钮是否可用取决于是否设置了同步账号(账号名称不为空时可用)
syncButton.setEnabled(!TextUtils.isEmpty(getSyncAccountName(this))); syncButton.setEnabled(!TextUtils.isEmpty(getSyncAccountName(this)));
// set last sync time // 根据同步服务状态设置上次同步时间文本视图的显示内容和可见性
if (GTaskSyncService.isSyncing()) { if (GTaskSyncService.isSyncing()) {
// 如果正在同步,显示同步进度相关信息
lastSyncTimeView.setText(GTaskSyncService.getProgressString()); lastSyncTimeView.setText(GTaskSyncService.getProgressString());
lastSyncTimeView.setVisibility(View.VISIBLE); lastSyncTimeView.setVisibility(View.VISIBLE);
} else { } else {
// 如果没有同步,获取上次同步时间
long lastSyncTime = getLastSyncTime(this); long lastSyncTime = getLastSyncTime(this);
if (lastSyncTime != 0) { if (lastSyncTime!= 0) {
// 如果上次同步时间不为0格式化时间并设置显示文本
lastSyncTimeView.setText(getString(R.string.preferences_last_sync_time, lastSyncTimeView.setText(getString(R.string.preferences_last_sync_time,
DateFormat.format(getString(R.string.preferences_last_sync_time_format), DateFormat.format(getString(R.string.preferences_last_sync_time_format),
lastSyncTime))); lastSyncTime)));
lastSyncTimeView.setVisibility(View.VISIBLE); lastSyncTimeView.setVisibility(View.VISIBLE);
} else { } else {
// 如果上次同步时间为0隐藏该文本视图
lastSyncTimeView.setVisibility(View.GONE); lastSyncTimeView.setVisibility(View.GONE);
} }
} }
} }
/**
* UI
*/
private void refreshUI() { private void refreshUI() {
loadAccountPreference(); loadAccountPreference();
loadSyncButton(); loadSyncButton();
} }
/**
*
*/
private void showSelectAccountAlertDialog() { private void showSelectAccountAlertDialog() {
AlertDialog.Builder dialogBuilder = new AlertDialog.Builder(this); AlertDialog.Builder dialogBuilder = new AlertDialog.Builder(this);
// 加载对话框标题视图布局
View titleView = LayoutInflater.from(this).inflate(R.layout.account_dialog_title, null); View titleView = LayoutInflater.from(this).inflate(R.layout.account_dialog_title, null);
TextView titleTextView = (TextView) titleView.findViewById(R.id.account_dialog_title); TextView titleTextView = (TextView) titleView.findViewById(R.id.account_dialog_title);
// 设置对话框标题文本
titleTextView.setText(getString(R.string.preferences_dialog_select_account_title)); titleTextView.setText(getString(R.string.preferences_dialog_select_account_title));
TextView subtitleTextView = (TextView) titleView.findViewById(R.id.account_dialog_subtitle); TextView subtitleTextView = (TextView) titleView.findViewById(R.id.account_dialog_subtitle);
// 设置对话框副标题文本(提示相关信息)
subtitleTextView.setText(getString(R.string.preferences_dialog_select_account_tips)); subtitleTextView.setText(getString(R.string.preferences_dialog_select_account_tips));
// 设置对话框的自定义标题视图
dialogBuilder.setCustomTitle(titleView); dialogBuilder.setCustomTitle(titleView);
// 设置对话框的确定按钮这里先设置为null可能后续根据需求再处理
dialogBuilder.setPositiveButton(null, null); dialogBuilder.setPositiveButton(null, null);
// 获取当前的谷歌账号列表
Account[] accounts = getGoogleAccounts(); Account[] accounts = getGoogleAccounts();
// 获取当前设置的同步账号名称(如果有的话)
String defAccount = getSyncAccountName(this); String defAccount = getSyncAccountName(this);
mOriAccounts = accounts; mOriAccounts = accounts;
mHasAddedAccount = false; mHasAddedAccount = false;
if (accounts.length > 0) { if (accounts.length > 0) {
// 创建用于显示账号名称的字符序列数组(长度与账号列表长度一致)
CharSequence[] items = new CharSequence[accounts.length]; CharSequence[] items = new CharSequence[accounts.length];
final CharSequence[] itemMapping = items; final CharSequence[] itemMapping = items;
int checkedItem = -1; int checkedItem = -1;
int index = 0; int index = 0;
// 遍历账号列表,填充显示账号名称的数组,并记录当前已设置账号在数组中的位置(用于默认选中)
for (Account account : accounts) { for (Account account : accounts) {
if (TextUtils.equals(account.name, defAccount)) { if (TextUtils.equals(account.name, defAccount)) {
checkedItem = index; checkedItem = index;
} }
items[index++] = account.name; items[index++] = account.name;
} }
// 设置对话框的单选列表项,用户选择账号后执行相应逻辑(设置选中账号为同步账号等)
dialogBuilder.setSingleChoiceItems(items, checkedItem, dialogBuilder.setSingleChoiceItems(items, checkedItem,
new DialogInterface.OnClickListener() { new DialogInterface.OnClickListener() {
public void onClick(DialogInterface dialog, int which) { public void onClick(DialogInterface dialog, int which) {
@ -237,16 +294,18 @@ public class NotesPreferenceActivity extends PreferenceActivity {
}); });
} }
// 加载添加账号相关视图布局(可能用于提示用户添加账号等操作)
View addAccountView = LayoutInflater.from(this).inflate(R.layout.add_account_text, null); View addAccountView = LayoutInflater.from(this).inflate(R.layout.add_account_text, null);
dialogBuilder.setView(addAccountView); dialogBuilder.setView(addAccountView);
final AlertDialog dialog = dialogBuilder.show(); final AlertDialog dialog = dialogBuilder.show();
// 设置添加账号视图的点击事件,点击时跳转到添加账号设置页面,并标记添加了新账号等操作
addAccountView.setOnClickListener(new View.OnClickListener() { addAccountView.setOnClickListener(new View.OnClickListener() {
public void onClick(View v) { public void onClick(View v) {
mHasAddedAccount = true; mHasAddedAccount = true;
Intent intent = new Intent("android.settings.ADD_ACCOUNT_SETTINGS"); Intent intent = new Intent("android.settings.ADD_ACCOUNT_SETTINGS");
intent.putExtra(AUTHORITIES_FILTER_KEY, new String[] { intent.putExtra(AUTHORITIES_FILTER_KEY, new String[] {
"gmail-ls" "gmail-ls"
}); });
startActivityForResult(intent, -1); startActivityForResult(intent, -1);
dialog.dismiss(); dialog.dismiss();
@ -254,22 +313,30 @@ public class NotesPreferenceActivity extends PreferenceActivity {
}); });
} }
/**
*
*/
private void showChangeAccountConfirmAlertDialog() { private void showChangeAccountConfirmAlertDialog() {
AlertDialog.Builder dialogBuilder = new AlertDialog.Builder(this); AlertDialog.Builder dialogBuilder = new AlertDialog.Builder(this);
// 加载对话框标题视图布局
View titleView = LayoutInflater.from(this).inflate(R.layout.account_dialog_title, null); View titleView = LayoutInflater.from(this).inflate(R.layout.account_dialog_title, null);
TextView titleTextView = (TextView) titleView.findViewById(R.id.account_dialog_title); TextView titleTextView = (TextView) titleView.findViewById(R.id.account_dialog_title);
// 设置对话框标题文本,包含当前已设置的同步账号名称
titleTextView.setText(getString(R.string.preferences_dialog_change_account_title, titleTextView.setText(getString(R.string.preferences_dialog_change_account_title,
getSyncAccountName(this))); getSyncAccountName(this)));
TextView subtitleTextView = (TextView) titleView.findViewById(R.id.account_dialog_subtitle); TextView subtitleTextView = (TextView) titleView.findViewById(R.id.account_dialog_subtitle);
// 设置对话框副标题文本(提示修改账号相关的警告信息)
subtitleTextView.setText(getString(R.string.preferences_dialog_change_account_warn_msg)); subtitleTextView.setText(getString(R.string.preferences_dialog_change_account_warn_msg));
dialogBuilder.setCustomTitle(titleView); dialogBuilder.setCustomTitle(titleView);
// 创建菜单项字符序列数组,包含修改账号、删除账号、取消等选项
CharSequence[] menuItemArray = new CharSequence[] { CharSequence[] menuItemArray = new CharSequence[] {
getString(R.string.preferences_menu_change_account), getString(R.string.preferences_menu_change_account),
getString(R.string.preferences_menu_remove_account), getString(R.string.preferences_menu_remove_account),
getString(R.string.preferences_menu_cancel) getString(R.string.preferences_menu_cancel)
}; };
// 设置对话框的菜单项点击事件逻辑,根据用户选择执行相应操作
dialogBuilder.setItems(menuItemArray, new DialogInterface.OnClickListener() { dialogBuilder.setItems(menuItemArray, new DialogInterface.OnClickListener() {
public void onClick(DialogInterface dialog, int which) { public void onClick(DialogInterface dialog, int which) {
if (which == 0) { if (which == 0) {
@ -283,26 +350,40 @@ public class NotesPreferenceActivity extends PreferenceActivity {
dialogBuilder.show(); dialogBuilder.show();
} }
/**
*
*
* @return
*/
private Account[] getGoogleAccounts() { private Account[] getGoogleAccounts() {
AccountManager accountManager = AccountManager.get(this); AccountManager accountManager = AccountManager.get(this);
return accountManager.getAccountsByType("com.google"); return accountManager.getAccountsByType("com.google");
} }
/**
*
*
* @param account
*/
private void setSyncAccount(String account) { private void setSyncAccount(String account) {
// 如果传入的账号与当前设置的账号不一致
if (!getSyncAccountName(this).equals(account)) { if (!getSyncAccountName(this).equals(account)) {
// 获取偏好设置实例
SharedPreferences settings = getSharedPreferences(PREFERENCE_NAME, Context.MODE_PRIVATE); SharedPreferences settings = getSharedPreferences(PREFERENCE_NAME, Context.MODE_PRIVATE);
SharedPreferences.Editor editor = settings.edit(); SharedPreferences.Editor editor = settings.edit();
if (account != null) { if (account!= null) {
// 如果账号不为空,将账号名称保存到偏好设置中
editor.putString(PREFERENCE_SYNC_ACCOUNT_NAME, account); editor.putString(PREFERENCE_SYNC_ACCOUNT_NAME, account);
} else { } else {
// 如果账号为空,清除已保存的账号名称
editor.putString(PREFERENCE_SYNC_ACCOUNT_NAME, ""); editor.putString(PREFERENCE_SYNC_ACCOUNT_NAME, "");
} }
editor.commit(); editor.commit();
// clean up last sync time // 清理上次同步时间设置为0
setLastSyncTime(this, 0); setLastSyncTime(this, 0);
// clean up local gtask related info // 清理本地与GTask相关的信息在新线程中执行数据库更新操作
new Thread(new Runnable() { new Thread(new Runnable() {
public void run() { public void run() {
ContentValues values = new ContentValues(); ContentValues values = new ContentValues();
@ -312,12 +393,16 @@ public class NotesPreferenceActivity extends PreferenceActivity {
} }
}).start(); }).start();
// 显示设置账号成功的提示信息
Toast.makeText(NotesPreferenceActivity.this, Toast.makeText(NotesPreferenceActivity.this,
getString(R.string.preferences_toast_success_set_accout, account), getString(R.string.preferences_toast_success_set_accout, account),
Toast.LENGTH_SHORT).show(); Toast.LENGTH_SHORT).show();
} }
} }
/**
* GTask
*/
private void removeSyncAccount() { private void removeSyncAccount() {
SharedPreferences settings = getSharedPreferences(PREFERENCE_NAME, Context.MODE_PRIVATE); SharedPreferences settings = getSharedPreferences(PREFERENCE_NAME, Context.MODE_PRIVATE);
SharedPreferences.Editor editor = settings.edit(); SharedPreferences.Editor editor = settings.edit();
@ -329,7 +414,7 @@ public class NotesPreferenceActivity extends PreferenceActivity {
} }
editor.commit(); editor.commit();
// clean up local gtask related info // 清理本地与GTask相关的信息在新线程中执行数据库更新操作
new Thread(new Runnable() { new Thread(new Runnable() {
public void run() { public void run() {
ContentValues values = new ContentValues(); ContentValues values = new ContentValues();
@ -340,49 +425,18 @@ public class NotesPreferenceActivity extends PreferenceActivity {
}).start(); }).start();
} }
/**
*
*
* @param context
* @return
*/
public static String getSyncAccountName(Context context) { public static String getSyncAccountName(Context context) {
SharedPreferences settings = context.getSharedPreferences(PREFERENCE_NAME, SharedPreferences settings = context.getSharedPreferences(PREFERENCE_NAME,
Context.MODE_PRIVATE); Context.MODE_PRIVATE);
return settings.getString(PREFERENCE_SYNC_ACCOUNT_NAME, ""); return settings.getString(PREFERENCE_SYNC_ACCOUNT_NAME, "");
} }
public static void setLastSyncTime(Context context, long time) { /**
SharedPreferences settings = context.getSharedPreferences(PREFERENCE_NAME, *
Context.MODE_PRIVATE); *
SharedPreferences.Editor editor = settings.edit();
editor.putLong(PREFERENCE_LAST_SYNC_TIME, time);
editor.commit();
}
public static long getLastSyncTime(Context context) {
SharedPreferences settings = context.getSharedPreferences(PREFERENCE_NAME,
Context.MODE_PRIVATE);
return settings.getLong(PREFERENCE_LAST_SYNC_TIME, 0);
}
private class GTaskReceiver extends BroadcastReceiver {
@Override
public void onReceive(Context context, Intent intent) {
refreshUI();
if (intent.getBooleanExtra(GTaskSyncService.GTASK_SERVICE_BROADCAST_IS_SYNCING, false)) {
TextView syncStatus = (TextView) findViewById(R.id.prefenerece_sync_status_textview);
syncStatus.setText(intent
.getStringExtra(GTaskSyncService.GTASK_SERVICE_BROADCAST_PROGRESS_MSG));
}
}
}
public boolean onOptionsItemSelected(MenuItem item) {
switch (item.getItemId()) {
case android.R.id.home:
Intent intent = new Intent(this, NotesListActivity.class);
intent.addFlags(Intent.FLAG_ACTIVITY_CLEAR_TOP);
startActivity(intent);
return true;
default:
return false;
}
}
}

@ -32,24 +32,37 @@ import net.micode.notes.tool.ResourceParser;
import net.micode.notes.ui.NoteEditActivity; import net.micode.notes.ui.NoteEditActivity;
import net.micode.notes.ui.NotesListActivity; import net.micode.notes.ui.NotesListActivity;
// NoteWidgetProvider抽象类继承自AppWidgetProvider用于处理与笔记相关的桌面小部件逻辑
public abstract class NoteWidgetProvider extends AppWidgetProvider { public abstract class NoteWidgetProvider extends AppWidgetProvider {
// 定义一个字符串数组,用于指定从数据库查询时要获取的列名
// 包含笔记的ID、背景颜色ID以及摘要信息等列
public static final String [] PROJECTION = new String [] { public static final String [] PROJECTION = new String [] {
NoteColumns.ID, NoteColumns.ID,
NoteColumns.BG_COLOR_ID, NoteColumns.BG_COLOR_ID,
NoteColumns.SNIPPET NoteColumns.SNIPPET
}; };
public static final int COLUMN_ID = 0; // 定义常量表示PROJECTION数组中对应列的索引方便后续从查询结果如Cursor中获取具体数据
public static final int COLUMN_BG_COLOR_ID = 1; public static final int COLUMN_ID = 0;
public static final int COLUMN_SNIPPET = 2; public static final int COLUMN_BG_COLOR_ID = 1;
public static final int COLUMN_SNIPPET = 2;
// 定义一个私有静态常量,用于日志记录时标识当前类
private static final String TAG = "NoteWidgetProvider"; private static final String TAG = "NoteWidgetProvider";
// 重写AppWidgetProvider的onDeleted方法当桌面小部件被删除时触发该方法
@Override @Override
public void onDeleted(Context context, int[] appWidgetIds) { public void onDeleted(Context context, int[] appWidgetIds) {
// 创建一个ContentValues对象用于存储要更新的数据
ContentValues values = new ContentValues(); ContentValues values = new ContentValues();
// 将NoteColumns.WIDGET_ID对应的字段值设为AppWidgetManager.INVALID_APPWIDGET_ID标记小部件已无效
values.put(NoteColumns.WIDGET_ID, AppWidgetManager.INVALID_APPWIDGET_ID); values.put(NoteColumns.WIDGET_ID, AppWidgetManager.INVALID_APPWIDGET_ID);
// 遍历被删除小部件的ID数组
for (int i = 0; i < appWidgetIds.length; i++) { for (int i = 0; i < appWidgetIds.length; i++) {
// 通过ContentResolver根据小部件ID条件去更新数据库中相关记录
// 将对应的小部件ID标记为无效Notes.CONTENT_NOTE_URI表示数据源
context.getContentResolver().update(Notes.CONTENT_NOTE_URI, context.getContentResolver().update(Notes.CONTENT_NOTE_URI,
values, values,
NoteColumns.WIDGET_ID + "=?", NoteColumns.WIDGET_ID + "=?",
@ -57,7 +70,12 @@ public abstract class NoteWidgetProvider extends AppWidgetProvider {
} }
} }
// 私有方法用于根据给定的小部件IDwidgetId从内容提供器查询相关的笔记小部件信息
private Cursor getNoteWidgetInfo(Context context, int widgetId) { private Cursor getNoteWidgetInfo(Context context, int widgetId) {
// 通过ContentResolver进行查询操作
// 查询的数据源是Notes.CONTENT_NOTE_URI查询的列由PROJECTION指定
// 筛选条件要求NoteColumns.WIDGET_ID等于传入的小部件ID且NoteColumns.PARENT_ID不等于特定的垃圾文件夹IDNotes.ID_TRASH_FOLER
// 最后返回查询得到的Cursor对象如果没有符合条件的数据则返回null
return context.getContentResolver().query(Notes.CONTENT_NOTE_URI, return context.getContentResolver().query(Notes.CONTENT_NOTE_URI,
PROJECTION, PROJECTION,
NoteColumns.WIDGET_ID + "=? AND " + NoteColumns.PARENT_ID + "<>?", NoteColumns.WIDGET_ID + "=? AND " + NoteColumns.PARENT_ID + "<>?",
@ -65,68 +83,95 @@ public abstract class NoteWidgetProvider extends AppWidgetProvider {
null); null);
} }
// 对外可调用的更新小部件的方法它内部调用另一个带有更多参数的update方法并传入false作为隐私模式privacyMode的参数值
protected void update(Context context, AppWidgetManager appWidgetManager, int[] appWidgetIds) { protected void update(Context context, AppWidgetManager appWidgetManager, int[] appWidgetIds) {
update(context, appWidgetManager, appWidgetIds, false); update(context, appWidgetManager, appWidgetIds, false);
} }
// 具体执行小部件更新逻辑的方法,用于更新桌面小部件的显示内容等信息
private void update(Context context, AppWidgetManager appWidgetManager, int[] appWidgetIds, private void update(Context context, AppWidgetManager appWidgetManager, int[] appWidgetIds,
boolean privacyMode) { boolean privacyMode) {
// 遍历传入的小部件ID数组
for (int i = 0; i < appWidgetIds.length; i++) { for (int i = 0; i < appWidgetIds.length; i++) {
if (appWidgetIds[i] != AppWidgetManager.INVALID_APPWIDGET_ID) { // 只处理有效的小部件ID不等于AppWidgetManager.INVALID_APPWIDGET_ID的情况
if (appWidgetIds[i]!= AppWidgetManager.INVALID_APPWIDGET_ID) {
// 获取默认的背景ID具体获取逻辑由ResourceParser.getDefaultBgId方法实现
int bgId = ResourceParser.getDefaultBgId(context); int bgId = ResourceParser.getDefaultBgId(context);
// 初始化摘要信息为空字符串
String snippet = ""; String snippet = "";
// 创建一个用于启动NoteEditActivity的Intent设置相关标志位和额外数据
Intent intent = new Intent(context, NoteEditActivity.class); Intent intent = new Intent(context, NoteEditActivity.class);
intent.setFlags(Intent.FLAG_ACTIVITY_SINGLE_TOP); intent.setFlags(Intent.FLAG_ACTIVITY_SINGLE_TOP);
intent.putExtra(Notes.INTENT_EXTRA_WIDGET_ID, appWidgetIds[i]); intent.putExtra(Notes.INTENT_EXTRA_WIDGET_ID, appWidgetIds[i]);
intent.putExtra(Notes.INTENT_EXTRA_WIDGET_TYPE, getWidgetType()); intent.putExtra(Notes.INTENT_EXTRA_WIDGET_TYPE, getWidgetType());
// 获取对应小部件的笔记信息Cursor
Cursor c = getNoteWidgetInfo(context, appWidgetIds[i]); Cursor c = getNoteWidgetInfo(context, appWidgetIds[i]);
if (c != null && c.moveToFirst()) { if (c!= null && c.moveToFirst()) {
// 如果查询结果中存在多条符合条件的数据理论上小部件ID应该唯一对应一条记录则记录错误日志并关闭Cursor直接返回
if (c.getCount() > 1) { if (c.getCount() > 1) {
Log.e(TAG, "Multiple message with same widget id:" + appWidgetIds[i]); Log.e(TAG, "Multiple message with same widget id:" + appWidgetIds[i]);
c.close(); c.close();
return; return;
} }
// 从Cursor中获取摘要信息
snippet = c.getString(COLUMN_SNIPPET); snippet = c.getString(COLUMN_SNIPPET);
// 从Cursor中获取背景颜色ID
bgId = c.getInt(COLUMN_BG_COLOR_ID); bgId = c.getInt(COLUMN_BG_COLOR_ID);
// 向Intent中添加额外数据用户ID等信息
intent.putExtra(Intent.EXTRA_UID, c.getLong(COLUMN_ID)); intent.putExtra(Intent.EXTRA_UID, c.getLong(COLUMN_ID));
// 设置Intent的动作表示是查看操作
intent.setAction(Intent.ACTION_VIEW); intent.setAction(Intent.ACTION_VIEW);
} else { } else {
// 如果没有查询到对应小部件的笔记信息,设置默认的摘要信息
snippet = context.getResources().getString(R.string.widget_havenot_content); snippet = context.getResources().getString(R.string.widget_havenot_content);
// 设置Intent的动作表示是插入/编辑操作
intent.setAction(Intent.ACTION_INSERT_OR_EDIT); intent.setAction(Intent.ACTION_INSERT_OR_EDIT);
} }
if (c != null) { // 如果Cursor不为空关闭它以释放资源
if (c!= null) {
c.close(); c.close();
} }
// 创建一个RemoteViews对象用于构建小部件的界面显示传入当前应用的包名和通过抽象方法获取的布局资源ID
RemoteViews rv = new RemoteViews(context.getPackageName(), getLayoutId()); RemoteViews rv = new RemoteViews(context.getPackageName(), getLayoutId());
// 根据抽象方法获取的背景资源ID来设置小部件的背景图片资源
rv.setImageViewResource(R.id.widget_bg_image, getBgResourceId(bgId)); rv.setImageViewResource(R.id.widget_bg_image, getBgResourceId(bgId));
// 向Intent中添加额外的背景ID数据
intent.putExtra(Notes.INTENT_EXTRA_BACKGROUND_ID, bgId); intent.putExtra(Notes.INTENT_EXTRA_BACKGROUND_ID, bgId);
/**
* Generate the pending intent to start host for the widget // 用于生成点击小部件时启动对应Activity的PendingIntent初始化为null
*/
PendingIntent pendingIntent = null; PendingIntent pendingIntent = null;
if (privacyMode) { if (privacyMode) {
// 如果处于隐私模式,设置小部件文本显示特定的隐私提示信息
rv.setTextViewText(R.id.widget_text, rv.setTextViewText(R.id.widget_text,
context.getString(R.string.widget_under_visit_mode)); context.getString(R.string.widget_under_visit_mode));
// 创建一个用于启动NotesListActivity的PendingIntent用于隐私模式下的点击响应
pendingIntent = PendingIntent.getActivity(context, appWidgetIds[i], new Intent( pendingIntent = PendingIntent.getActivity(context, appWidgetIds[i], new Intent(
context, NotesListActivity.class), PendingIntent.FLAG_UPDATE_CURRENT); context, NotesListActivity.class), PendingIntent.FLAG_UPDATE_CURRENT);
} else { } else {
// 正常情况下设置小部件文本显示摘要信息snippet
rv.setTextViewText(R.id.widget_text, snippet); rv.setTextViewText(R.id.widget_text, snippet);
// 创建一个用于启动NoteEditActivity由前面intent定义的PendingIntent用于正常模式下的点击响应
pendingIntent = PendingIntent.getActivity(context, appWidgetIds[i], intent, pendingIntent = PendingIntent.getActivity(context, appWidgetIds[i], intent,
PendingIntent.FLAG_UPDATE_CURRENT); PendingIntent.FLAG_UPDATE_CURRENT);
} }
// 为小部件文本设置点击PendingIntent实现点击交互功能
rv.setOnClickPendingIntent(R.id.widget_text, pendingIntent); rv.setOnClickPendingIntent(R.id.widget_text, pendingIntent);
// 通过AppWidgetManager更新小部件的实际显示内容
appWidgetManager.updateAppWidget(appWidgetIds[i], rv); appWidgetManager.updateAppWidget(appWidgetIds[i], rv);
} }
} }
} }
// 抽象方法要求子类实现该方法根据传入的背景ID获取对应的背景资源ID用于设置小部件的背景显示资源
protected abstract int getBgResourceId(int bgId); protected abstract int getBgResourceId(int bgId);
// 抽象方法子类需实现此方法来返回小部件对应的布局资源ID用于构建小部件的界面布局
protected abstract int getLayoutId(); protected abstract int getLayoutId();
// 抽象方法,需要子类实现,用于返回小部件的类型相关信息,具体的类型定义由业务逻辑决定,在小部件相关处理中可能根据类型做不同操作
protected abstract int getWidgetType(); protected abstract int getWidgetType();
} }

@ -24,22 +24,34 @@ import net.micode.notes.data.Notes;
import net.micode.notes.tool.ResourceParser; import net.micode.notes.tool.ResourceParser;
// NoteWidgetProvider_2x类继承自NoteWidgetProvider抽象类用于实现特定尺寸可能是2倍尺寸相关从类名推测的笔记桌面小部件相关逻辑
public class NoteWidgetProvider_2x extends NoteWidgetProvider { public class NoteWidgetProvider_2x extends NoteWidgetProvider {
// 重写onUpdate方法当桌面小部件需要更新时会触发该方法
// 这里调用了父类NoteWidgetProvider的update方法来执行具体的更新操作
@Override @Override
public void onUpdate(Context context, AppWidgetManager appWidgetManager, int[] appWidgetIds) { public void onUpdate(Context context, AppWidgetManager appWidgetManager, int[] appWidgetIds) {
super.update(context, appWidgetManager, appWidgetIds); super.update(context, appWidgetManager, appWidgetIds);
} }
// 实现父类NoteWidgetProvider中定义的抽象方法getLayoutId
// 返回用于该特定小部件2x尺寸相关的布局资源ID对应布局资源为R.layout.widget_2x
@Override @Override
protected int getLayoutId() { protected int getLayoutId() {
return R.layout.widget_2x; return R.layout.widget_2x;
} }
// 实现父类NoteWidgetProvider中定义的抽象方法getBgResourceId
// 根据传入的背景IDbgId通过ResourceParser.WidgetBgResources.getWidget2xBgResource方法来获取对应的2x尺寸小部件的背景资源ID
// 用于设置该特定小部件的背景显示资源
@Override @Override
protected int getBgResourceId(int bgId) { protected int getBgResourceId(int bgId) {
return ResourceParser.WidgetBgResources.getWidget2xBgResource(bgId); return ResourceParser.WidgetBgResources.getWidget2xBgResource(bgId);
} }
// 实现父类NoteWidgetProvider中定义的抽象方法getWidgetType
// 返回该小部件的类型标识此处返回值为Notes.TYPE_WIDGET_2X表示这是2x尺寸类型的小部件
// 在整个小部件相关的处理逻辑中,可能会根据这个类型做不同的操作(例如不同类型小部件显示不同样式、功能等)
@Override @Override
protected int getWidgetType() { protected int getWidgetType() {
return Notes.TYPE_WIDGET_2X; return Notes.TYPE_WIDGET_2X;

@ -24,23 +24,34 @@ import net.micode.notes.data.Notes;
import net.micode.notes.tool.ResourceParser; import net.micode.notes.tool.ResourceParser;
// NoteWidgetProvider_4x类继承自NoteWidgetProvider抽象类它主要负责实现特定的推测为4倍尺寸相关从类名判断笔记桌面小部件相关的具体逻辑。
public class NoteWidgetProvider_4x extends NoteWidgetProvider { public class NoteWidgetProvider_4x extends NoteWidgetProvider {
// 重写onUpdate方法该方法会在桌面小部件需要进行更新操作时被触发。
// 在这里它调用了父类NoteWidgetProvider的update方法来执行实际的小部件更新逻辑利用了父类中已经定义好的通用更新流程。
@Override @Override
public void onUpdate(Context context, AppWidgetManager appWidgetManager, int[] appWidgetIds) { public void onUpdate(Context context, AppWidgetManager appWidgetManager, int[] appWidgetIds) {
super.update(context, appWidgetManager, appWidgetIds); super.update(context, appWidgetManager, appWidgetIds);
} }
// 重写父类NoteWidgetProvider中定义的抽象方法getLayoutId用于返回此特定小部件4x尺寸相关对应的布局资源ID。
// 通过返回R.layout.widget_4x指定了该小部件所使用的布局文件这个布局文件应该是按照4x尺寸的设计需求进行定制的。
// 注意:这里方法的修饰符应该是@Override原代码中缺少该注解可能会导致代码逻辑与预期不符若后续在父类中修改了抽象方法的签名等情况编译器无法准确检查此处是否正确重写。
protected int getLayoutId() { protected int getLayoutId() {
return R.layout.widget_4x; return R.layout.widget_4x;
} }
// 重写父类NoteWidgetProvider中定义的抽象方法getBgResourceId根据传入的背景IDbgId来获取对应的背景资源ID。
// 具体是通过调用ResourceParser.WidgetBgResources.getWidget4xBgResource方法来获取适用于4x尺寸小部件的背景资源以用于设置该小部件的背景显示效果。
@Override @Override
protected int getBgResourceId(int bgId) { protected int getBgResourceId(int bgId) {
return ResourceParser.WidgetBgResources.getWidget4xBgResource(bgId); return ResourceParser.WidgetBgResources.getWidget4xBgResource(bgId);
} }
// 重写父类NoteWidgetProvider中定义的抽象方法getWidgetType用于返回该小部件的类型标识。
// 这里返回Notes.TYPE_WIDGET_4X表示这是一个4x尺寸类型的小部件在整个小部件相关的处理流程中可能会依据这个类型标识进行不同的业务处理比如展现不同的样式、启用不同的功能等。
@Override @Override
protected int getWidgetType() { protected int getWidgetType() {
return Notes.TYPE_WIDGET_4X; return Notes.TYPE_WIDGET_4X;
} }
} }
Loading…
Cancel
Save