();
}
- // 检查缓存中是否已存在该电话号码的记录
if(sContactCache.containsKey(phoneNumber)) {
return sContactCache.get(phoneNumber);
}
- // 动态构建查询条件（替换模板中的"+"为实际的匹配前缀）
String selection = CALLER_ID_SELECTION.replace("+",
PhoneNumberUtils.toCallerIDMinMatch(phoneNumber));
Cursor cursor = context.getContentResolver().query(
@@ -60,7 +54,6 @@ public class Contact {
new String[] { phoneNumber },
null);
- // 处理查询结果
if (cursor != null && cursor.moveToFirst()) {
try {
String name = cursor.getString(0);
diff --git a/java/net/micode/notes/data/Notes.java b/java/net/micode/notes/data/Notes.java
index 7009eec..f240604 100644
--- a/java/net/micode/notes/data/Notes.java
+++ b/java/net/micode/notes/data/Notes.java
@@ -18,10 +18,8 @@ package net.micode.notes.data;
import android.net.Uri;
public class Notes {
- public static final String AUTHORITY = "micode_notes";//应用的权限
- public static final String TAG = "Notes";//应用的标签
-
- //定义了标签的类型，分别表示便签、文件夹和系统类型
+ public static final String AUTHORITY = "micode_notes";
+ public static final String TAG = "Notes";
public static final int TYPE_NOTE = 0;
public static final int TYPE_FOLDER = 1;
public static final int TYPE_SYSTEM = 2;
@@ -32,13 +30,11 @@ public class Notes {
* {@link Notes#ID_TEMPARAY_FOLDER } is for notes belonging no folder
* {@link Notes#ID_CALL_RECORD_FOLDER} is to store call records
*/
- //定义了系统文件夹的标识符
public static final int ID_ROOT_FOLDER = 0;
public static final int ID_TEMPARAY_FOLDER = -1;
public static final int ID_CALL_RECORD_FOLDER = -2;
public static final int ID_TRASH_FOLER = -3;
- //定义了意图中的额外数据键
public static final String INTENT_EXTRA_ALERT_DATE = "net.micode.notes.alert_date";
public static final String INTENT_EXTRA_BACKGROUND_ID = "net.micode.notes.background_color_id";
public static final String INTENT_EXTRA_WIDGET_ID = "net.micode.notes.widget_id";
@@ -46,7 +42,6 @@ public class Notes {
public static final String INTENT_EXTRA_FOLDER_ID = "net.micode.notes.folder_id";
public static final String INTENT_EXTRA_CALL_DATE = "net.micode.notes.call_date";
- //定义了组件的类型、无效类型、2倍大小和4倍大小
public static final int TYPE_WIDGET_INVALIDE = -1;
public static final int TYPE_WIDGET_2X = 0;
public static final int TYPE_WIDGET_4X = 1;
@@ -59,24 +54,13 @@ public class Notes {
/**
* Uri to query all notes and folders
*/
-
- /**
- * 表示便签（Note）的内容URI，用于访问便签相关数据
- */
-
public static final Uri CONTENT_NOTE_URI = Uri.parse("content://" + AUTHORITY + "/note");
/**
* Uri to query data
*/
- //表示数据（Data）的内容URI，用于访问数据相关信息。
public static final Uri CONTENT_DATA_URI = Uri.parse("content://" + AUTHORITY + "/data");
- /**
- 定义了便签（Note）数据表的列名和数据类型，
- *包括便签的唯一ID、父级ID、创建日期、修改日期、
- *提醒日期、内容摘要、小部件ID、小部件类型、背景颜色ID、
- * 附件标识、便签数量、类型、同步ID、本地修改标识、原始父级ID、GTask ID和版本号等。*/
public interface NoteColumns {
/**
* The unique ID for a row
@@ -183,11 +167,6 @@ public class Notes {
public static final String VERSION = "version";
}
- /**
- * 定义了数据（Data）表的列名和数据类型，
- * 包括数据的唯一ID、MIME类型、关联的便签ID、创建日期、修改日期、内容、
- * 以及5个通用数据列（data1至data5）用于不同类型的数据存储。
- */
public interface DataColumns {
/**
* The unique ID for a row
@@ -226,19 +205,39 @@ public class Notes {
public static final String CONTENT = "content";
-
+ /**
+ * Generic data column, the meaning is {@link #MIMETYPE} specific, used for
+ * integer data type
+ * Type: INTEGER
+ */
public static final String DATA1 = "data1";
-
+ /**
+ * Generic data column, the meaning is {@link #MIMETYPE} specific, used for
+ * integer data type
+ * Type: INTEGER
+ */
public static final String DATA2 = "data2";
-
+ /**
+ * Generic data column, the meaning is {@link #MIMETYPE} specific, used for
+ * TEXT data type
+ * Type: TEXT
+ */
public static final String DATA3 = "data3";
-
+ /**
+ * Generic data column, the meaning is {@link #MIMETYPE} specific, used for
+ * TEXT data type
+ * Type: TEXT
+ */
public static final String DATA4 = "data4";
-
+ /**
+ * Generic data column, the meaning is {@link #MIMETYPE} specific, used for
+ * TEXT data type
+ * Type: TEXT
+ */
public static final String DATA5 = "data5";
}
@@ -247,45 +246,34 @@ public class Notes {
* Mode to indicate the text in check list mode or not
* Type: Integer 1:check list mode 0: normal mode
*/
- //表示文本便签的形式，用于指示是否处于检查列表模式
public static final String MODE = DATA1;
- //表示检查列表模式的常量值
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_ITEM_TYPE = "vnd.android.cursor.item/text_note";
- //定义了文本便签的内容Uri
public static final Uri CONTENT_URI = Uri.parse("content://" + AUTHORITY + "/text_note");
}
-
public static final class CallNote implements DataColumns {
/**
* Call date for this record
* Type: INTEGER (long)
*/
- //表示通话记录的日期
public static final String CALL_DATE = DATA1;
/**
* Phone number for this record
* Type: TEXT
*/
- //表示通话记录的电话号码
public static final String PHONE_NUMBER = DATA3;
- //定义了通话记录的内容类型
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";
- //定义了通话记录的内容Uri
public static final Uri CONTENT_URI = Uri.parse("content://" + AUTHORITY + "/call_note");
}
}
diff --git a/java/net/micode/notes/data/NotesDatabaseHelper.java b/java/net/micode/notes/data/NotesDatabaseHelper.java
index 76c48e8..ffe5d57 100644
--- a/java/net/micode/notes/data/NotesDatabaseHelper.java
+++ b/java/net/micode/notes/data/NotesDatabaseHelper.java
@@ -22,34 +22,26 @@ import android.database.sqlite.SQLiteDatabase;
import android.database.sqlite.SQLiteOpenHelper;
import android.util.Log;
-//对Notes类中DataColumns、DataConstants、NoteColumns进行引用：
import net.micode.notes.data.Notes.DataColumns;
import net.micode.notes.data.Notes.DataConstants;
import net.micode.notes.data.Notes.NoteColumns;
public class NotesDatabaseHelper extends SQLiteOpenHelper {
- //定义了数据库名称
private static final String DB_NAME = "note.db";
- //定义了数据库版本
private static final int DB_VERSION = 4;
- //定义了TABLE接口
public interface TABLE {
- //定义了两个表的名称
public static final String NOTE = "note";
public static final String DATA = "data";
}
- //定义了标签
private static final String TAG = "NotesDatabaseHelper";
- //定义了一个静态变量mInstance，用于表示NotesDatabaseHelper类的实例
private static NotesDatabaseHelper mInstance;
- //定义了SQL语句分别用于创建便签表、数据表、包含ID、便签和数据的表格
private static final String CREATE_NOTE_TABLE_SQL =
"CREATE TABLE " + TABLE.NOTE + "(" +
NoteColumns.ID + " INTEGER PRIMARY KEY," +
@@ -92,9 +84,7 @@ public class NotesDatabaseHelper extends SQLiteOpenHelper {
/**
* Increase folder's note count when move note to the folder
- * 将笔记移动到文件夹时增加文件夹的笔记数
*/
- //定义了对数据库进行增删改查等工作的SQL语句
private static final String NOTE_INCREASE_FOLDER_COUNT_ON_UPDATE_TRIGGER =
"CREATE TRIGGER increase_folder_count_on_update "+
" AFTER UPDATE OF " + NoteColumns.PARENT_ID + " ON " + TABLE.NOTE +
@@ -106,7 +96,6 @@ public class NotesDatabaseHelper extends SQLiteOpenHelper {
/**
* Decrease folder's note count when move note from folder
- * 从文件夹中移动笔记时减少文件夹的笔记计数
*/
private static final String NOTE_DECREASE_FOLDER_COUNT_ON_UPDATE_TRIGGER =
"CREATE TRIGGER decrease_folder_count_on_update " +
@@ -120,7 +109,6 @@ public class NotesDatabaseHelper extends SQLiteOpenHelper {
/**
* Increase folder's note count when insert new note to the folder
- * 在文件夹中插入新笔记时增加文件夹的笔记数
*/
private static final String NOTE_INCREASE_FOLDER_COUNT_ON_INSERT_TRIGGER =
"CREATE TRIGGER increase_folder_count_on_insert " +
@@ -133,7 +121,6 @@ public class NotesDatabaseHelper extends SQLiteOpenHelper {
/**
* Decrease folder's note count when delete note from the folder
- * 从文件夹中删除笔记时减少文件夹的笔记计数
*/
private static final String NOTE_DECREASE_FOLDER_COUNT_ON_DELETE_TRIGGER =
"CREATE TRIGGER decrease_folder_count_on_delete " +
@@ -147,7 +134,6 @@ public class NotesDatabaseHelper extends SQLiteOpenHelper {
/**
* Update note's content when insert data with type {@link DataConstants#NOTE}
- * 插入类型为｛DataConstants.Note｝的数据时更新注释的内容
*/
private static final String DATA_UPDATE_NOTE_CONTENT_ON_INSERT_TRIGGER =
"CREATE TRIGGER update_note_content_on_insert " +
@@ -161,7 +147,6 @@ public class NotesDatabaseHelper extends SQLiteOpenHelper {
/**
* Update note's content when data with {@link DataConstants#NOTE} type has changed
- * 当｛DataConstants.Note｝类型的数据发生更改时，更新注释的内容
*/
private static final String DATA_UPDATE_NOTE_CONTENT_ON_UPDATE_TRIGGER =
"CREATE TRIGGER update_note_content_on_update " +
@@ -175,7 +160,6 @@ public class NotesDatabaseHelper extends SQLiteOpenHelper {
/**
* Update note's content when data with {@link DataConstants#NOTE} type has deleted
- * 删除｛DataConstants.Note｝类型的数据后，更新注释的内容
*/
private static final String DATA_UPDATE_NOTE_CONTENT_ON_DELETE_TRIGGER =
"CREATE TRIGGER update_note_content_on_delete " +
@@ -189,7 +173,6 @@ public class NotesDatabaseHelper extends SQLiteOpenHelper {
/**
* Delete datas belong to note which has been deleted
- * 删除数据属于已删除的注释
*/
private static final String NOTE_DELETE_DATA_ON_DELETE_TRIGGER =
"CREATE TRIGGER delete_data_on_delete " +
@@ -201,7 +184,6 @@ public class NotesDatabaseHelper extends SQLiteOpenHelper {
/**
* Delete notes belong to folder which has been deleted
- * 删除数据属于已删除的注释
*/
private static final String FOLDER_DELETE_NOTES_ON_DELETE_TRIGGER =
"CREATE TRIGGER folder_delete_notes_on_delete " +
@@ -213,7 +195,6 @@ public class NotesDatabaseHelper extends SQLiteOpenHelper {
/**
* Move notes belong to folder which has been moved to trash folder
- * 移动笔记属于已移动到垃圾文件夹的文件夹
*/
private static final String FOLDER_MOVE_NOTES_ON_TRASH_TRIGGER =
"CREATE TRIGGER folder_move_notes_on_trash " +
@@ -229,19 +210,13 @@ public class NotesDatabaseHelper extends SQLiteOpenHelper {
super(context, DB_NAME, null, DB_VERSION);
}
- //创建便签表
public void createNoteTable(SQLiteDatabase db) {
- //执行创建表的SQL语句
db.execSQL(CREATE_NOTE_TABLE_SQL);
- //重新创建表的触发器
reCreateNoteTableTriggers(db);
- //创建系统文件夹
createSystemFolder(db);
- //打印日志
Log.d(TAG, "note table has been created");
}
- //重新创建便签表的触发器
private void reCreateNoteTableTriggers(SQLiteDatabase db) {
db.execSQL("DROP TRIGGER IF EXISTS increase_folder_count_on_update");
db.execSQL("DROP TRIGGER IF EXISTS decrease_folder_count_on_update");
@@ -260,7 +235,6 @@ public class NotesDatabaseHelper extends SQLiteOpenHelper {
db.execSQL(FOLDER_MOVE_NOTES_ON_TRASH_TRIGGER);
}
- //创建系统文件夹，包括通话记录文件夹、默认文件夹、临时文件夹和回收站文件夹。
private void createSystemFolder(SQLiteDatabase db) {
ContentValues values = new ContentValues();
@@ -296,19 +270,13 @@ public class NotesDatabaseHelper extends SQLiteOpenHelper {
db.insert(TABLE.NOTE, null, values);
}
- //创建数据表
public void createDataTable(SQLiteDatabase db) {
- //执行创建表的SQL语句
db.execSQL(CREATE_DATA_TABLE_SQL);
- //重新创建表的触发器
reCreateDataTableTriggers(db);
- //创建数据表的索引
db.execSQL(CREATE_DATA_NOTE_ID_INDEX_SQL);
- //打印日志
Log.d(TAG, "data table has been created");
}
- //重新创建数据表的触发器
private void reCreateDataTableTriggers(SQLiteDatabase db) {
db.execSQL("DROP TRIGGER IF EXISTS update_note_content_on_insert");
db.execSQL("DROP TRIGGER IF EXISTS update_note_content_on_update");
@@ -319,7 +287,6 @@ public class NotesDatabaseHelper extends SQLiteOpenHelper {
db.execSQL(DATA_UPDATE_NOTE_CONTENT_ON_DELETE_TRIGGER);
}
- //获取NotesDatabaseHelper类的实例
static synchronized NotesDatabaseHelper getInstance(Context context) {
if (mInstance == null) {
mInstance = new NotesDatabaseHelper(context);
@@ -327,14 +294,12 @@ public class NotesDatabaseHelper extends SQLiteOpenHelper {
return mInstance;
}
- //在数据库创建时调用，执行创建便签表和数据表的操作。
@Override
public void onCreate(SQLiteDatabase db) {
createNoteTable(db);
createDataTable(db);
}
- //在数据库升级时调用，根据旧版本和新版本执行相应的升级操作
@Override
public void onUpgrade(SQLiteDatabase db, int oldVersion, int newVersion) {
boolean reCreateTriggers = false;
@@ -368,7 +333,6 @@ public class NotesDatabaseHelper extends SQLiteOpenHelper {
}
}
- //升级数据库到版本2的操作
private void upgradeToV2(SQLiteDatabase db) {
db.execSQL("DROP TABLE IF EXISTS " + TABLE.NOTE);
db.execSQL("DROP TABLE IF EXISTS " + TABLE.DATA);
@@ -376,7 +340,6 @@ public class NotesDatabaseHelper extends SQLiteOpenHelper {
createDataTable(db);
}
- //升级数据库到版本3的操作
private void upgradeToV3(SQLiteDatabase db) {
// drop unused triggers
db.execSQL("DROP TRIGGER IF EXISTS update_note_modified_date_on_insert");
@@ -392,7 +355,6 @@ public class NotesDatabaseHelper extends SQLiteOpenHelper {
db.insert(TABLE.NOTE, null, values);
}
- //升级数据库到版本4的操作
private void upgradeToV4(SQLiteDatabase db) {
db.execSQL("ALTER TABLE " + TABLE.NOTE + " ADD COLUMN " + NoteColumns.VERSION
+ " INTEGER NOT NULL DEFAULT 0");
diff --git a/java/net/micode/notes/data/NotesProvider.java b/java/net/micode/notes/data/NotesProvider.java
index 93d8778..edb0a60 100644
--- a/java/net/micode/notes/data/NotesProvider.java
+++ b/java/net/micode/notes/data/NotesProvider.java
@@ -36,16 +36,12 @@ import net.micode.notes.data.NotesDatabaseHelper.TABLE;
public class NotesProvider extends ContentProvider {
- //UriMatcher对象，用于匹配URI并返回相应的整数值
private static final UriMatcher mMatcher;
- //表示NotesDatabaseHelper的实例
private NotesDatabaseHelper mHelper;
- //用于标识日志的标签
private static final String TAG = "NotesProvider";
- //定义了不同类型的URI匹配值
private static final int URI_NOTE = 1;
private static final int URI_NOTE_ITEM = 2;
private static final int URI_DATA = 3;
@@ -69,7 +65,6 @@ public class NotesProvider extends ContentProvider {
* x'0A' represents the '\n' character in sqlite. For title and content in the search result,
* we will trim '\n' and white space in order to show more information.
*/
- //定义了搜索结果的投影，包括便签ID、额外数据、文本1、文本2、图标、意图操作和数据
private static final String NOTES_SEARCH_PROJECTION = NoteColumns.ID + ","
+ NoteColumns.ID + " AS " + SearchManager.SUGGEST_COLUMN_INTENT_EXTRA_DATA + ","
+ "TRIM(REPLACE(" + NoteColumns.SNIPPET + ", x'0A','')) AS " + SearchManager.SUGGEST_COLUMN_TEXT_1 + ","
@@ -78,7 +73,6 @@ public class NotesProvider extends ContentProvider {
+ "'" + Intent.ACTION_VIEW + "' AS " + SearchManager.SUGGEST_COLUMN_INTENT_ACTION + ","
+ "'" + Notes.TextNote.CONTENT_TYPE + "' AS " + SearchManager.SUGGEST_COLUMN_INTENT_DATA;
- //定义了搜索便签摘要的查询语句，用于从便签表中查询符合条件的便签摘要数据
private static String NOTES_SNIPPET_SEARCH_QUERY = "SELECT " + NOTES_SEARCH_PROJECTION
+ " FROM " + TABLE.NOTE
+ " WHERE " + NoteColumns.SNIPPET + " LIKE ?"
@@ -91,7 +85,6 @@ public class NotesProvider extends ContentProvider {
return true;
}
- //处理查询操作，根据URI匹配不同的查询类型，包括便签、数据和搜索结果的查询。
@Override
public Cursor query(Uri uri, String[] projection, String selection, String[] selectionArgs,
String sortOrder) {
@@ -154,7 +147,6 @@ public class NotesProvider extends ContentProvider {
return c;
}
- //处理插入操作
@Override
public Uri insert(Uri uri, ContentValues values) {
SQLiteDatabase db = mHelper.getWritableDatabase();
@@ -189,7 +181,6 @@ public class NotesProvider extends ContentProvider {
return ContentUris.withAppendedId(uri, insertedId);
}
- //处理删除操作
@Override
public int delete(Uri uri, String selection, String[] selectionArgs) {
int count = 0;
@@ -236,7 +227,6 @@ public class NotesProvider extends ContentProvider {
return count;
}
- //处理更新操作
@Override
public int update(Uri uri, ContentValues values, String selection, String[] selectionArgs) {
int count = 0;
@@ -277,12 +267,10 @@ public class NotesProvider extends ContentProvider {
return count;
}
- //辅助方法，用于解析查询条件
private String parseSelection(String selection) {
return (!TextUtils.isEmpty(selection) ? " AND (" + selection + ')' : "");
}
- //辅助方法，用于增加便签版本号
private void increaseNoteVersion(long id, String selection, String[] selectionArgs) {
StringBuilder sql = new StringBuilder(120);
sql.append("UPDATE ");
@@ -308,7 +296,6 @@ public class NotesProvider extends ContentProvider {
mHelper.getWritableDatabase().execSQL(sql.toString());
}
- //获取URI的MIME类型，暂未实现
@Override
public String getType(Uri uri) {
// TODO Auto-generated method stub
diff --git a/java/net/micode/notes/gtask/data/MetaData.java b/java/net/micode/notes/gtask/data/MetaData.java
index da1eaaa..3a2050b 100644
--- a/java/net/micode/notes/gtask/data/MetaData.java
+++ b/java/net/micode/notes/gtask/data/MetaData.java
@@ -24,58 +24,31 @@ import net.micode.notes.tool.GTaskStringUtils;
import org.json.JSONException;
import org.json.JSONObject;
+
public class MetaData extends Task {
- /*
- * 功能描述：得到类的简写名称存入字符串TAG中
- * 实现过程：调用getSimpleName ()函数
- */
private final static String TAG = MetaData.class.getSimpleName();
- // 存储关联的Google Tasks ID
private String mRelatedGid = null;
- /*
- * 功能描述：设置数据，即生成元数据库
- * 实现过程：调用JSONObject库函数put ()，Task类中的setNotes ()和setName ()函数
- * 参数注解：
- */
public void setMeta(String gid, JSONObject metaInfo) {
- //对函数块进行注释
try {
metaInfo.put(GTaskStringUtils.META_HEAD_GTASK_ID, gid);
- /*
- * 将这对键值放入metaInfo这个jsonobject对象中
- */
} catch (JSONException e) {
Log.e(TAG, "failed to put related gid");
- /*
- * 输出错误信息
- */
}
setNotes(metaInfo.toString());
setName(GTaskStringUtils.META_NOTE_NAME);
}
- /*
- * 功能描述：获取相关联的Gid
- */
public String getRelatedGid() {
return mRelatedGid;
}
- /*
- * 功能描述：判断当前数据是否为空，若为空则返回真即值得保存
- */
@Override
public boolean isWorthSaving() {
return getNotes() != null;
}
- /*
- * 功能描述：使用远程json数据对象设置元数据内容
- * 实现过程：调用父类Task中的setContentByRemoteJSON ()函数，并
- * 参数注解：
- */
@Override
public void setContentByRemoteJSON(JSONObject js) {
super.setContentByRemoteJSON(js);
@@ -90,27 +63,20 @@ public class MetaData extends Task {
}
}
- /*
- * 功能描述：使用本地json数据对象设置元数据内容，一般不会用到，若用到，则抛出异常
- */
@Override
public void setContentByLocalJSON(JSONObject js) {
+ // this function should not be called
throw new IllegalAccessError("MetaData:setContentByLocalJSON should not be called");
}
- /*
- * 功能描述：从元数据内容中获取本地json对象，一般不会用到，若用到，则抛出异常
- */
@Override
public JSONObject getLocalJSONFromContent() {
throw new IllegalAccessError("MetaData:getLocalJSONFromContent should not be called");
}
- /*
- * 功能描述：获取同步动作状态，一般不会用到，若用到，则抛出异常
- */
@Override
public int getSyncAction(Cursor c) {
throw new IllegalAccessError("MetaData:getSyncAction should not be called");
}
+
}
diff --git a/java/net/micode/notes/gtask/data/Node.java b/java/net/micode/notes/gtask/data/Node.java
index 4d99f31..63950e0 100644
--- a/java/net/micode/notes/gtask/data/Node.java
+++ b/java/net/micode/notes/gtask/data/Node.java
@@ -21,24 +21,32 @@ import android.database.Cursor;
import org.json.JSONObject;
public abstract class Node {
- // 同步动作常量（定义9种同步操作类型）
public static final int SYNC_ACTION_NONE = 0;
+
public static final int SYNC_ACTION_ADD_REMOTE = 1;
+
public static final int SYNC_ACTION_ADD_LOCAL = 2;
+
public static final int SYNC_ACTION_DEL_REMOTE = 3;
+
public static final int SYNC_ACTION_DEL_LOCAL = 4;
+
public static final int SYNC_ACTION_UPDATE_REMOTE = 5;
+
public static final int SYNC_ACTION_UPDATE_LOCAL = 6;
+
public static final int SYNC_ACTION_UPDATE_CONFLICT = 7;
+
public static final int SYNC_ACTION_ERROR = 8;
- // 节点基础属性
- private String mGid; // Google Tasks ID或全局唯一标识
- private String mName; // 节点名称
- private long mLastModified; // 最后修改时间
- private boolean mDeleted; // 删除状态
+ private String mGid;
+
+ private String mName;
+
+ private long mLastModified;
+
+ private boolean mDeleted;
- // 构造函数：初始化属性默认值
public Node() {
mGid = null;
mName = "";
@@ -46,21 +54,48 @@ public abstract class Node {
mDeleted = false;
}
- // 抽象方法：由子类实现具体逻辑
- public abstract JSONObject getCreateAction(int actionId); // 创建同步动作的JSON
- public abstract JSONObject getUpdateAction(int actionId); // 更新同步动作的JSON
- public abstract void setContentByRemoteJSON(JSONObject js); // 从远程JSON设置内容
- public abstract void setContentByLocalJSON(JSONObject js); // 从本地JSON设置内容
- public abstract JSONObject getLocalJSONFromContent(); // 从内容生成本地JSON
- public abstract int getSyncAction(Cursor c); // 获取同步动作类型
-
- // 基础属性的getter和setter方法
- public void setGid(String gid) { this.mGid = gid; }
- public void setName(String name) { this.mName = name; }
- public void setLastModified(long lastModified) { this.mLastModified = lastModified; }
- public void setDeleted(boolean deleted) { this.mDeleted = deleted; }
- public String getGid() { return mGid; }
- public String getName() { return mName; }
- public long getLastModified() { return mLastModified; }
- public boolean getDeleted() { return mDeleted; }
-}
\ No newline at end of file
+ public abstract JSONObject getCreateAction(int actionId);
+
+ public abstract JSONObject getUpdateAction(int actionId);
+
+ public abstract void setContentByRemoteJSON(JSONObject js);
+
+ public abstract void setContentByLocalJSON(JSONObject js);
+
+ public abstract JSONObject getLocalJSONFromContent();
+
+ public abstract int getSyncAction(Cursor c);
+
+ public void setGid(String gid) {
+ this.mGid = gid;
+ }
+
+ public void setName(String name) {
+ this.mName = name;
+ }
+
+ public void setLastModified(long lastModified) {
+ this.mLastModified = lastModified;
+ }
+
+ public void setDeleted(boolean deleted) {
+ this.mDeleted = deleted;
+ }
+
+ public String getGid() {
+ return this.mGid;
+ }
+
+ public String getName() {
+ return this.mName;
+ }
+
+ public long getLastModified() {
+ return this.mLastModified;
+ }
+
+ public boolean getDeleted() {
+ return this.mDeleted;
+ }
+
+}
diff --git a/java/net/micode/notes/gtask/data/SqlData.java b/java/net/micode/notes/gtask/data/SqlData.java
index 5013ca7..d3ec3be 100644
--- a/java/net/micode/notes/gtask/data/SqlData.java
+++ b/java/net/micode/notes/gtask/data/SqlData.java
@@ -37,31 +37,40 @@ import org.json.JSONObject;
public class SqlData {
private static final String TAG = SqlData.class.getSimpleName();
- private static final int INVALID_ID = -99999; // 无效ID标识
- // 数据库查询投影（指定查询的列）
+ private static final int INVALID_ID = -99999;
+
public static final String[] PROJECTION_DATA = new String[] {
- DataColumns.ID, DataColumns.MIME_TYPE, DataColumns.CONTENT,
- DataColumns.DATA1, DataColumns.DATA3
+ DataColumns.ID, DataColumns.MIME_TYPE, DataColumns.CONTENT, DataColumns.DATA1,
+ DataColumns.DATA3
};
- // 投影列的索引常量
+
public static final int DATA_ID_COLUMN = 0;
+
public static final int DATA_MIME_TYPE_COLUMN = 1;
+
public static final int DATA_CONTENT_COLUMN = 2;
+
public static final int DATA_CONTENT_DATA_1_COLUMN = 3;
+
public static final int DATA_CONTENT_DATA_3_COLUMN = 4;
- // 对象属性（对应数据库表字段）
- private ContentResolver mContentResolver; // 内容解析器
- private boolean mIsCreate; // 是否为新建状态
- private long mDataId; // 数据ID
- private String mDataMimeType; // MIME类型
- private String mDataContent; // 数据内容
- private long mDataContentData1; // 附加数据1（长整型）
- private String mDataContentData3; // 附加数据3（字符串）
- private ContentValues mDiffDataValues; // 记录变更的ContentValues
-
- // 构造函数：初始化新对象
+ private ContentResolver mContentResolver;
+
+ private boolean mIsCreate;
+
+ private long mDataId;
+
+ private String mDataMimeType;
+
+ private String mDataContent;
+
+ private long mDataContentData1;
+
+ private String mDataContentData3;
+
+ private ContentValues mDiffDataValues;
+
public SqlData(Context context) {
mContentResolver = context.getContentResolver();
mIsCreate = true;
@@ -73,15 +82,13 @@ public class SqlData {
mDiffDataValues = new ContentValues();
}
- // 从Cursor加载数据的构造函数
public SqlData(Context context, Cursor c) {
mContentResolver = context.getContentResolver();
mIsCreate = false;
- loadFromCursor(c); // 从游标加载数据
+ loadFromCursor(c);
mDiffDataValues = new ContentValues();
}
- // 从Cursor加载数据的辅助方法
private void loadFromCursor(Cursor c) {
mDataId = c.getLong(DATA_ID_COLUMN);
mDataMimeType = c.getString(DATA_MIME_TYPE_COLUMN);
@@ -90,16 +97,13 @@ public class SqlData {
mDataContentData3 = c.getString(DATA_CONTENT_DATA_3_COLUMN);
}
- // 根据JSON设置数据内容，并记录变更
public void setContent(JSONObject js) throws JSONException {
- // 解析ID
long dataId = js.has(DataColumns.ID) ? js.getLong(DataColumns.ID) : INVALID_ID;
if (mIsCreate || mDataId != dataId) {
mDiffDataValues.put(DataColumns.ID, dataId);
}
mDataId = dataId;
- // 解析MIME类型
String dataMimeType = js.has(DataColumns.MIME_TYPE) ? js.getString(DataColumns.MIME_TYPE)
: DataConstants.NOTE;
if (mIsCreate || !mDataMimeType.equals(dataMimeType)) {
@@ -107,21 +111,18 @@ public class SqlData {
}
mDataMimeType = dataMimeType;
- // 解析内容
String dataContent = js.has(DataColumns.CONTENT) ? js.getString(DataColumns.CONTENT) : "";
if (mIsCreate || !mDataContent.equals(dataContent)) {
mDiffDataValues.put(DataColumns.CONTENT, dataContent);
}
mDataContent = dataContent;
- // 解析附加数据1
long dataContentData1 = js.has(DataColumns.DATA1) ? js.getLong(DataColumns.DATA1) : 0;
if (mIsCreate || mDataContentData1 != dataContentData1) {
mDiffDataValues.put(DataColumns.DATA1, dataContentData1);
}
mDataContentData1 = dataContentData1;
- // 解析附加数据3
String dataContentData3 = js.has(DataColumns.DATA3) ? js.getString(DataColumns.DATA3) : "";
if (mIsCreate || !mDataContentData3.equals(dataContentData3)) {
mDiffDataValues.put(DataColumns.DATA3, dataContentData3);
@@ -129,10 +130,9 @@ public class SqlData {
mDataContentData3 = dataContentData3;
}
- // 将对象数据转换为JSON
public JSONObject getContent() throws JSONException {
if (mIsCreate) {
- Log.e(TAG, "数据未创建到数据库中");
+ Log.e(TAG, "it seems that we haven't created this in database yet");
return null;
}
JSONObject js = new JSONObject();
@@ -144,52 +144,46 @@ public class SqlData {
return js;
}
- // 提交数据到数据库（插入或更新）
public void commit(long noteId, boolean validateVersion, long version) {
+
if (mIsCreate) {
- // 新建数据时移除无效ID，并添加noteId关联
if (mDataId == INVALID_ID && mDiffDataValues.containsKey(DataColumns.ID)) {
mDiffDataValues.remove(DataColumns.ID);
}
+
mDiffDataValues.put(DataColumns.NOTE_ID, noteId);
- // 插入数据
Uri uri = mContentResolver.insert(Notes.CONTENT_DATA_URI, mDiffDataValues);
try {
- mDataId = Long.parseLong(uri.getPathSegments().get(1));
+ mDataId = Long.valueOf(uri.getPathSegments().get(1));
} catch (NumberFormatException e) {
- Log.e(TAG, "获取ID失败", e);
- throw new ActionFailureException("创建笔记失败");
+ Log.e(TAG, "Get note id error :" + e.toString());
+ throw new ActionFailureException("create note failed");
}
} else {
- // 更新数据时支持版本验证
if (mDiffDataValues.size() > 0) {
int result = 0;
if (!validateVersion) {
- // 不验证版本时直接更新
- result = mContentResolver.update(
- ContentUris.withAppendedId(Notes.CONTENT_DATA_URI, mDataId),
- mDiffDataValues, null, null);
+ result = mContentResolver.update(ContentUris.withAppendedId(
+ Notes.CONTENT_DATA_URI, mDataId), mDiffDataValues, null, null);
} else {
- // 验证版本时添加条件（防止并发冲突）
- result = mContentResolver.update(
- ContentUris.withAppendedId(Notes.CONTENT_DATA_URI, mDataId),
- mDiffDataValues,
- " ? IN (SELECT " + NoteColumns.ID + " FROM " + TABLE.NOTE
- + " WHERE " + NoteColumns.VERSION + "=?)",
- new String[] {String.valueOf(noteId), String.valueOf(version)});
+ result = mContentResolver.update(ContentUris.withAppendedId(
+ Notes.CONTENT_DATA_URI, mDataId), mDiffDataValues,
+ " ? in (SELECT " + NoteColumns.ID + " FROM " + TABLE.NOTE
+ + " WHERE " + NoteColumns.VERSION + "=?)", new String[] {
+ String.valueOf(noteId), String.valueOf(version)
+ });
}
if (result == 0) {
- Log.w(TAG, "更新失败，可能同步时用户已修改笔记");
+ Log.w(TAG, "there is no update. maybe user updates note when syncing");
}
}
}
- // 清空变更记录，并标记为非新建状态
+
mDiffDataValues.clear();
mIsCreate = false;
}
- // 获取数据ID
public long getId() {
return mDataId;
}
-}
\ No newline at end of file
+}
diff --git a/java/net/micode/notes/gtask/data/SqlNote.java b/java/net/micode/notes/gtask/data/SqlNote.java
index d4a9d21..79a4095 100644
--- a/java/net/micode/notes/gtask/data/SqlNote.java
+++ b/java/net/micode/notes/gtask/data/SqlNote.java
@@ -38,37 +38,11 @@ import org.json.JSONObject;
import java.util.ArrayList;
-import android.appwidget.AppWidgetManager;
-import android.content.ContentResolver;
-import android.content.ContentValues;
-import android.content.Context;
-import android.database.Cursor;
-import android.net.Uri;
-import android.util.Log;
-
-import net.micode.notes.data.Notes;
-import net.micode.notes.data.Notes.DataColumns;
-import net.micode.notes.data.Notes.NoteColumns;
-import net.micode.notes.gtask.exception.ActionFailureException;
-import net.micode.notes.tool.GTaskStringUtils;
-import net.micode.notes.tool.ResourceParser;
-
-import org.json.JSONArray;
-import org.json.JSONException;
-import org.json.JSONObject;
-
-import java.util.ArrayList;
-
-/*
- * 功能描述：得到类的简写名称存入字符串TAG中
- * 实现过程：调用getSimpleName ()函数
- */
public class SqlNote {
private static final String TAG = SqlNote.class.getSimpleName();
private static final int INVALID_ID = -99999;
- // 集合了interface DataColumns中所有SF常量
public static final String[] PROJECTION_NOTE = new String[] {
NoteColumns.ID, NoteColumns.ALERTED_DATE, NoteColumns.BG_COLOR_ID,
NoteColumns.CREATED_DATE, NoteColumns.HAS_ATTACHMENT, NoteColumns.MODIFIED_DATE,
@@ -78,9 +52,6 @@ public class SqlNote {
NoteColumns.VERSION
};
- /*
- * 以下五个变量作为sql表中5列的编号
- */
public static final int ID_COLUMN = 0;
public static final int ALERTED_DATE_COLUMN = 1;
@@ -118,7 +89,7 @@ public class SqlNote {
private Context mContext;
private ContentResolver mContentResolver;
- //判断是否直接用Content生成，是为true，否则为false
+
private boolean mIsCreate;
private long mId;
@@ -172,13 +143,6 @@ public class SqlNote {
mDataList = new ArrayList();
}
- /*
- * 功能描述：构造函数，用于初始化数据
- * 参数注解：mContentResolver用于获取ContentProvider提供的数据
- * 参数注解： mIsCreate表征当前数据是用哪种方式创建（两种构造函数的参数不同）
- * 参数注解：
- */
-
public SqlNote(Context context, Cursor c) {
mContext = context;
mContentResolver = context.getContentResolver();
@@ -190,13 +154,6 @@ public class SqlNote {
mDiffNoteValues = new ContentValues();
}
- /*
- * 功能描述：构造函数，初始化数据
- * 参数注解：mContentResolver用于获取ContentProvider提供的数据
- * 参数注解： mIsCreate表征当前数据是用哪种方式创建（两种构造函数的参数不同）
- * 参数注解：
- */
-
public SqlNote(Context context, long id) {
mContext = context;
mContentResolver = context.getContentResolver();
@@ -209,16 +166,12 @@ public class SqlNote {
}
- /*
- * 功能描述：从光标处加载数据
- * 从当前的光标处将五列的数据加载到该类的对象
- */
private void loadFromCursor(long id) {
Cursor c = null;
try {
c = mContentResolver.query(Notes.CONTENT_NOTE_URI, PROJECTION_NOTE, "(_id=?)",
new String[] {
- String.valueOf(id)
+ String.valueOf(id)
}, null);
if (c != null) {
c.moveToNext();
@@ -253,7 +206,7 @@ public class SqlNote {
try {
c = mContentResolver.query(Notes.CONTENT_DATA_URI, SqlData.PROJECTION_DATA,
"(note_id=?)", new String[] {
- String.valueOf(mId)
+ String.valueOf(mId)
}, null);
if (c != null) {
if (c.getCount() == 0) {
@@ -273,10 +226,6 @@ public class SqlNote {
}
}
- /*
- * 功能描述：设置用于共享的数据，并提供异常抛出与处理机制
- * 参数注解：
- */
public boolean setContent(JSONObject js) {
try {
JSONObject note = js.getJSONObject(GTaskStringUtils.META_HEAD_NOTE);
@@ -410,12 +359,6 @@ public class SqlNote {
return true;
}
-
- /*
- * 功能描述：获取共享的数据内容，并提供异常抛出与处理机制
- * 参数注解：
- * Made By CuiCan
- */
public JSONObject getContent() {
try {
JSONObject js = new JSONObject();
@@ -481,12 +424,6 @@ public class SqlNote {
mDiffNoteValues.put(NoteColumns.LOCAL_MODIFIED, 0);
}
- /*
- * 功能描述：获取当前id
- * 实现过程：
- * 参数注解：
- * Made By CuiCan
- */
public long getId() {
return mId;
}
@@ -503,11 +440,6 @@ public class SqlNote {
return mType == Notes.TYPE_NOTE;
}
- /*
- * 功能描述：commit函数用于把当前造作所做的修改保存到数据库
- * 参数注解：
- * Made By CuiCan
- */
public void commit(boolean validateVersion) {
if (mIsCreate) {
if (mId == INVALID_ID && mDiffNoteValues.containsKey(NoteColumns.ID)) {
@@ -541,11 +473,11 @@ public class SqlNote {
if (!validateVersion) {
result = mContentResolver.update(Notes.CONTENT_NOTE_URI, mDiffNoteValues, "("
+ NoteColumns.ID + "=?)", new String[] {
- String.valueOf(mId)
+ String.valueOf(mId)
});
} else {
result = mContentResolver.update(Notes.CONTENT_NOTE_URI, mDiffNoteValues, "("
- + NoteColumns.ID + "=?) AND (" + NoteColumns.VERSION + "<=?)",
+ + NoteColumns.ID + "=?) AND (" + NoteColumns.VERSION + "<=?)",
new String[] {
String.valueOf(mId), String.valueOf(mVersion)
});
diff --git a/java/net/micode/notes/gtask/data/Task.java b/java/net/micode/notes/gtask/data/Task.java
index 70c0ccf..6a19454 100644
--- a/java/net/micode/notes/gtask/data/Task.java
+++ b/java/net/micode/notes/gtask/data/Task.java
@@ -34,13 +34,17 @@ import org.json.JSONObject;
public class Task extends Node {
private static final String TAG = Task.class.getSimpleName();
- private boolean mCompleted; // 任务完成状态
- private String mNotes; // 任务备注
- private JSONObject mMetaInfo; // 元数据（存储本地笔记与GTask的映射）
- private Task mPriorSibling; // 前一个兄弟任务（用于排序）
- private TaskList mParent; // 所属任务列表
- // 构造函数：初始化任务属性
+ private boolean mCompleted;
+
+ private String mNotes;
+
+ private JSONObject mMetaInfo;
+
+ private Task mPriorSibling;
+
+ private TaskList mParent;
+
public Task() {
super();
mCompleted = false;
@@ -50,94 +54,166 @@ public class Task extends Node {
mMetaInfo = null;
}
- // 生成创建任务的JSON请求
public JSONObject getCreateAction(int actionId) {
JSONObject js = new JSONObject();
+
try {
- js.put(GTaskStringUtils.GTASK_JSON_ACTION_TYPE, "create"); // 动作类型
- js.put(GTaskStringUtils.GTASK_JSON_ACTION_ID, actionId); // 动作ID
- js.put(GTaskStringUtils.GTASK_JSON_INDEX, mParent.getChildTaskIndex(this)); // 排序索引
- // 任务实体数据
+ // action_type
+ js.put(GTaskStringUtils.GTASK_JSON_ACTION_TYPE,
+ GTaskStringUtils.GTASK_JSON_ACTION_TYPE_CREATE);
+
+ // action_id
+ js.put(GTaskStringUtils.GTASK_JSON_ACTION_ID, actionId);
+
+ // index
+ js.put(GTaskStringUtils.GTASK_JSON_INDEX, mParent.getChildTaskIndex(this));
+
+ // entity_delta
JSONObject entity = new JSONObject();
- entity.put(GTaskStringUtils.GTASK_JSON_NAME, getName()); // 任务名称
- entity.put(GTaskStringUtils.GTASK_JSON_ENTITY_TYPE, "task"); // 实体类型
- if (getNotes() != null) entity.put(GTaskStringUtils.GTASK_JSON_NOTES, getNotes());
+ entity.put(GTaskStringUtils.GTASK_JSON_NAME, getName());
+ entity.put(GTaskStringUtils.GTASK_JSON_CREATOR_ID, "null");
+ entity.put(GTaskStringUtils.GTASK_JSON_ENTITY_TYPE,
+ GTaskStringUtils.GTASK_JSON_TYPE_TASK);
+ if (getNotes() != null) {
+ entity.put(GTaskStringUtils.GTASK_JSON_NOTES, getNotes());
+ }
js.put(GTaskStringUtils.GTASK_JSON_ENTITY_DELTA, entity);
- // 父任务列表信息
+
+ // parent_id
js.put(GTaskStringUtils.GTASK_JSON_PARENT_ID, mParent.getGid());
+
+ // dest_parent_type
+ js.put(GTaskStringUtils.GTASK_JSON_DEST_PARENT_TYPE,
+ GTaskStringUtils.GTASK_JSON_TYPE_GROUP);
+
+ // list_id
js.put(GTaskStringUtils.GTASK_JSON_LIST_ID, mParent.getGid());
- // 前一个兄弟任务ID（用于排序）
+
+ // prior_sibling_id
if (mPriorSibling != null) {
js.put(GTaskStringUtils.GTASK_JSON_PRIOR_SIBLING_ID, mPriorSibling.getGid());
}
+
} catch (JSONException e) {
- throw new ActionFailureException("生成创建任务JSON失败");
+ Log.e(TAG, e.toString());
+ e.printStackTrace();
+ throw new ActionFailureException("fail to generate task-create jsonobject");
}
+
return js;
}
- // 生成更新任务的JSON请求
public JSONObject getUpdateAction(int actionId) {
JSONObject js = new JSONObject();
+
try {
- js.put(GTaskStringUtils.GTASK_JSON_ACTION_TYPE, "update"); // 动作类型
- js.put(GTaskStringUtils.GTASK_JSON_ACTION_ID, actionId); // 动作ID
- js.put(GTaskStringUtils.GTASK_JSON_ID, getGid()); // 任务ID
- // 任务实体数据（仅更新变更字段）
+ // action_type
+ js.put(GTaskStringUtils.GTASK_JSON_ACTION_TYPE,
+ GTaskStringUtils.GTASK_JSON_ACTION_TYPE_UPDATE);
+
+ // action_id
+ js.put(GTaskStringUtils.GTASK_JSON_ACTION_ID, actionId);
+
+ // id
+ js.put(GTaskStringUtils.GTASK_JSON_ID, getGid());
+
+ // entity_delta
JSONObject entity = new JSONObject();
entity.put(GTaskStringUtils.GTASK_JSON_NAME, getName());
- if (getNotes() != null) entity.put(GTaskStringUtils.GTASK_JSON_NOTES, getNotes());
- entity.put(GTaskStringUtils.GTASK_JSON_DELETED, getDeleted()); // 删除状态
+ if (getNotes() != null) {
+ entity.put(GTaskStringUtils.GTASK_JSON_NOTES, getNotes());
+ }
+ entity.put(GTaskStringUtils.GTASK_JSON_DELETED, getDeleted());
js.put(GTaskStringUtils.GTASK_JSON_ENTITY_DELTA, entity);
+
} catch (JSONException e) {
- throw new ActionFailureException("生成更新任务JSON失败");
+ Log.e(TAG, e.toString());
+ e.printStackTrace();
+ throw new ActionFailureException("fail to generate task-update jsonobject");
}
+
return js;
}
- // 从远程JSON（GTask数据）设置任务内容
public void setContentByRemoteJSON(JSONObject js) {
if (js != null) {
try {
- setGid(js.getString(GTaskStringUtils.GTASK_JSON_ID)); // 设置GTask ID
- setLastModified(js.getLong(GTaskStringUtils.GTASK_JSON_LAST_MODIFIED)); // 最后修改时间
- setName(js.getString(GTaskStringUtils.GTASK_JSON_NAME)); // 任务名称
- setNotes(js.getString(GTaskStringUtils.GTASK_JSON_NOTES)); // 任务备注
- setDeleted(js.getBoolean(GTaskStringUtils.GTASK_JSON_DELETED)); // 删除状态
- setCompleted(js.getBoolean(GTaskStringUtils.GTASK_JSON_COMPLETED)); // 完成状态
+ // id
+ if (js.has(GTaskStringUtils.GTASK_JSON_ID)) {
+ setGid(js.getString(GTaskStringUtils.GTASK_JSON_ID));
+ }
+
+ // last_modified
+ if (js.has(GTaskStringUtils.GTASK_JSON_LAST_MODIFIED)) {
+ setLastModified(js.getLong(GTaskStringUtils.GTASK_JSON_LAST_MODIFIED));
+ }
+
+ // name
+ if (js.has(GTaskStringUtils.GTASK_JSON_NAME)) {
+ setName(js.getString(GTaskStringUtils.GTASK_JSON_NAME));
+ }
+
+ // notes
+ if (js.has(GTaskStringUtils.GTASK_JSON_NOTES)) {
+ setNotes(js.getString(GTaskStringUtils.GTASK_JSON_NOTES));
+ }
+
+ // deleted
+ if (js.has(GTaskStringUtils.GTASK_JSON_DELETED)) {
+ setDeleted(js.getBoolean(GTaskStringUtils.GTASK_JSON_DELETED));
+ }
+
+ // completed
+ if (js.has(GTaskStringUtils.GTASK_JSON_COMPLETED)) {
+ setCompleted(js.getBoolean(GTaskStringUtils.GTASK_JSON_COMPLETED));
+ }
} catch (JSONException e) {
- throw new ActionFailureException("解析远程JSON失败");
+ Log.e(TAG, e.toString());
+ e.printStackTrace();
+ throw new ActionFailureException("fail to get task content from jsonobject");
}
}
}
- // 从本地JSON（笔记数据）设置任务内容
public void setContentByLocalJSON(JSONObject js) {
- if (js == null || !js.has(GTaskStringUtils.META_HEAD_NOTE)) return;
+ if (js == null || !js.has(GTaskStringUtils.META_HEAD_NOTE)
+ || !js.has(GTaskStringUtils.META_HEAD_DATA)) {
+ Log.w(TAG, "setContentByLocalJSON: nothing is avaiable");
+ }
+
try {
JSONObject note = js.getJSONObject(GTaskStringUtils.META_HEAD_NOTE);
JSONArray dataArray = js.getJSONArray(GTaskStringUtils.META_HEAD_DATA);
- // 仅处理普通笔记类型
- if (note.getInt(NoteColumns.TYPE) != Notes.TYPE_NOTE) return;
- // 从数据列表中获取笔记内容作为任务名称
+
+ if (note.getInt(NoteColumns.TYPE) != Notes.TYPE_NOTE) {
+ Log.e(TAG, "invalid type");
+ return;
+ }
+
for (int i = 0; i < dataArray.length(); i++) {
JSONObject data = dataArray.getJSONObject(i);
- if (data.getString(DataColumns.MIME_TYPE).equals(DataConstants.NOTE)) {
+ if (TextUtils.equals(data.getString(DataColumns.MIME_TYPE), DataConstants.NOTE)) {
setName(data.getString(DataColumns.CONTENT));
break;
}
}
+
} catch (JSONException e) {
- Log.e(TAG, "解析本地JSON失败", e);
+ Log.e(TAG, e.toString());
+ e.printStackTrace();
}
}
- // 从任务内容生成本地JSON（用于存储到本地数据库）
public JSONObject getLocalJSONFromContent() {
String name = getName();
try {
if (mMetaInfo == null) {
- // 新建任务（无元数据）
+ // new task created from web
+ if (name == null) {
+ Log.w(TAG, "the note seems to be an empty one");
+ return null;
+ }
+
JSONObject js = new JSONObject();
JSONObject note = new JSONObject();
JSONArray dataArray = new JSONArray();
@@ -149,87 +225,127 @@ public class Task extends Node {
js.put(GTaskStringUtils.META_HEAD_NOTE, note);
return js;
} else {
- // 已同步任务（更新元数据）
+ // synced task
JSONObject note = mMetaInfo.getJSONObject(GTaskStringUtils.META_HEAD_NOTE);
JSONArray dataArray = mMetaInfo.getJSONArray(GTaskStringUtils.META_HEAD_DATA);
+
for (int i = 0; i < dataArray.length(); i++) {
JSONObject data = dataArray.getJSONObject(i);
- if (data.getString(DataColumns.MIME_TYPE).equals(DataConstants.NOTE)) {
- data.put(DataColumns.CONTENT, name);
+ if (TextUtils.equals(data.getString(DataColumns.MIME_TYPE), DataConstants.NOTE)) {
+ data.put(DataColumns.CONTENT, getName());
break;
}
}
+
note.put(NoteColumns.TYPE, Notes.TYPE_NOTE);
return mMetaInfo;
}
} catch (JSONException e) {
- Log.e(TAG, "生成本地JSON失败", e);
+ Log.e(TAG, e.toString());
+ e.printStackTrace();
return null;
}
}
- // 设置元数据（本地笔记与GTask的映射）
public void setMetaInfo(MetaData metaData) {
if (metaData != null && metaData.getNotes() != null) {
try {
mMetaInfo = new JSONObject(metaData.getNotes());
} catch (JSONException e) {
- Log.w(TAG, "解析元数据失败", e);
+ Log.w(TAG, e.toString());
mMetaInfo = null;
}
}
}
- // 判断当前同步动作类型
public int getSyncAction(Cursor c) {
try {
- if (mMetaInfo == null || !mMetaInfo.has(GTaskStringUtils.META_HEAD_NOTE)) {
- return SYNC_ACTION_UPDATE_REMOTE; // 元数据不存在，需从远程更新
+ JSONObject noteInfo = null;
+ if (mMetaInfo != null && mMetaInfo.has(GTaskStringUtils.META_HEAD_NOTE)) {
+ noteInfo = mMetaInfo.getJSONObject(GTaskStringUtils.META_HEAD_NOTE);
+ }
+
+ if (noteInfo == null) {
+ Log.w(TAG, "it seems that note meta has been deleted");
+ return SYNC_ACTION_UPDATE_REMOTE;
+ }
+
+ if (!noteInfo.has(NoteColumns.ID)) {
+ Log.w(TAG, "remote note id seems to be deleted");
+ return SYNC_ACTION_UPDATE_LOCAL;
}
- JSONObject noteInfo = mMetaInfo.getJSONObject(GTaskStringUtils.META_HEAD_NOTE);
- // 验证笔记ID
+
+ // validate the note id now
if (c.getLong(SqlNote.ID_COLUMN) != noteInfo.getLong(NoteColumns.ID)) {
- return SYNC_ACTION_UPDATE_LOCAL; // ID不匹配，需更新本地
+ Log.w(TAG, "note id doesn't match");
+ return SYNC_ACTION_UPDATE_LOCAL;
}
- // 判断本地修改状态
+
if (c.getInt(SqlNote.LOCAL_MODIFIED_COLUMN) == 0) {
- // 本地未修改
+ // there is no local update
if (c.getLong(SqlNote.SYNC_ID_COLUMN) == getLastModified()) {
- return SYNC_ACTION_NONE; // 无变更
+ // no update both side
+ return SYNC_ACTION_NONE;
} else {
- return SYNC_ACTION_UPDATE_LOCAL; // 远程有更新，需同步到本地
+ // apply remote to local
+ return SYNC_ACTION_UPDATE_LOCAL;
}
} else {
- // 本地已修改
+ // validate gtask id
if (!c.getString(SqlNote.GTASK_ID_COLUMN).equals(getGid())) {
- return SYNC_ACTION_ERROR; // GTask ID不匹配，错误
+ Log.e(TAG, "gtask id doesn't match");
+ return SYNC_ACTION_ERROR;
}
if (c.getLong(SqlNote.SYNC_ID_COLUMN) == getLastModified()) {
- return SYNC_ACTION_UPDATE_REMOTE; // 本地修改，需同步到远程
+ // local modification only
+ return SYNC_ACTION_UPDATE_REMOTE;
} else {
- return SYNC_ACTION_UPDATE_CONFLICT; // 本地与远程都有修改，冲突
+ return SYNC_ACTION_UPDATE_CONFLICT;
}
}
} catch (Exception e) {
- Log.e(TAG, "获取同步动作失败", e);
+ Log.e(TAG, e.toString());
+ e.printStackTrace();
}
+
return SYNC_ACTION_ERROR;
}
- // 判断任务是否值得保存
public boolean isWorthSaving() {
- return mMetaInfo != null ||
- (getName() != null && getName().trim().length() > 0) ||
- (getNotes() != null && getNotes().trim().length() > 0);
- }
-
- // Getter和Setter方法
- public void setCompleted(boolean completed) { this.mCompleted = completed; }
- public void setNotes(String notes) { this.mNotes = notes; }
- public void setPriorSibling(Task priorSibling) { this.mPriorSibling = priorSibling; }
- public void setParent(TaskList parent) { this.mParent = parent; }
- public boolean getCompleted() { return mCompleted; }
- public String getNotes() { return mNotes; }
- public Task getPriorSibling() { return mPriorSibling; }
- public TaskList getParent() { return mParent; }
-}
\ No newline at end of file
+ return mMetaInfo != null || (getName() != null && getName().trim().length() > 0)
+ || (getNotes() != null && getNotes().trim().length() > 0);
+ }
+
+ public void setCompleted(boolean completed) {
+ this.mCompleted = completed;
+ }
+
+ public void setNotes(String notes) {
+ this.mNotes = notes;
+ }
+
+ public void setPriorSibling(Task priorSibling) {
+ this.mPriorSibling = priorSibling;
+ }
+
+ public void setParent(TaskList parent) {
+ this.mParent = parent;
+ }
+
+ public boolean getCompleted() {
+ return this.mCompleted;
+ }
+
+ public String getNotes() {
+ return this.mNotes;
+ }
+
+ public Task getPriorSibling() {
+ return this.mPriorSibling;
+ }
+
+ public TaskList getParent() {
+ return this.mParent;
+ }
+
+}
diff --git a/java/net/micode/notes/gtask/data/TaskList.java b/java/net/micode/notes/gtask/data/TaskList.java
index ae47bc3..4ea21c5 100644
--- a/java/net/micode/notes/gtask/data/TaskList.java
+++ b/java/net/micode/notes/gtask/data/TaskList.java
@@ -31,11 +31,11 @@ import java.util.ArrayList;
public class TaskList extends Node {
- private static final String TAG = TaskList.class.getSimpleName();//tag标记
+ private static final String TAG = TaskList.class.getSimpleName();
- private int mIndex;//当前TaskList的指针
+ private int mIndex;
- private ArrayList mChildren;//类中主要的保存数据的单元，用来实现一个以Task为元素的ArrayList
+ private ArrayList mChildren;
public TaskList() {
super();
@@ -43,10 +43,6 @@ public class TaskList extends Node {
mIndex = 1;
}
- /* (non-Javadoc)
- * @see net.micode.notes.gtask.data.Node#getCreateAction(int)
- * 生成并返回一个包含了一定数据的JSONObject实体
- */
public JSONObject getCreateAction(int actionId) {
JSONObject js = new JSONObject();
@@ -78,10 +74,6 @@ public class TaskList extends Node {
return js;
}
- /* (non-Javadoc)
- * @see net.micode.notes.gtask.data.Node#getUpdateAction(int)
- * 生成并返回一个包含了一定数据的JSONObject实体
- */
public JSONObject getUpdateAction(int actionId) {
JSONObject js = new JSONObject();
@@ -228,11 +220,6 @@ public class TaskList extends Node {
return mChildren.size();
}
- /*
- * @param task
- * @return 返回值为是否成功添加任务。
- * 功能：在当前任务表末尾添加新的任务。
- */
public boolean addChildTask(Task task) {
boolean ret = false;
if (task != null && !mChildren.contains(task)) {
@@ -247,12 +234,6 @@ public class TaskList extends Node {
return ret;
}
- /*
- * @param task
- * @param index
- * @return
- * 功能：在当前任务表的指定位置添加新的任务。
- */
public boolean addChildTask(Task task, int index) {
if (index < 0 || index > mChildren.size()) {
Log.e(TAG, "add child task: invalid index");
@@ -279,11 +260,6 @@ public class TaskList extends Node {
return true;
}
- /*
- * @param task
- * @return 返回删除是否成功
- * 功能：删除TaskList中的一个Task
- */
public boolean removeChildTask(Task task) {
boolean ret = false;
int index = mChildren.indexOf(task);
@@ -305,12 +281,6 @@ public class TaskList extends Node {
return ret;
}
- /*
- * @param task
- * @param index
- * @return
- * 功能：将当前TaskList中含有的某个Task移到index位置
- */
public boolean moveChildTask(Task task, int index) {
if (index < 0 || index >= mChildren.size()) {
@@ -329,11 +299,6 @@ public class TaskList extends Node {
return (removeChildTask(task) && addChildTask(task, index));
}
- /**
- * @param gid
- * @return返回寻找结果
- * 功能：按gid寻找Task
- */
public Task findChildTaskByGid(String gid) {
for (int i = 0; i < mChildren.size(); i++) {
Task t = mChildren.get(i);
@@ -344,20 +309,10 @@ public class TaskList extends Node {
return null;
}
- /**
- * @param task
- * @return
- * 功能：返回指定Task的index
- */
public int getChildTaskIndex(Task task) {
return mChildren.indexOf(task);
}
- /**
- * @param index
- * @return
- * 功能：返回指定index的Task
- */
public Task getChildTaskByIndex(int index) {
if (index < 0 || index >= mChildren.size()) {
Log.e(TAG, "getTaskByIndex: invalid index");
@@ -366,11 +321,6 @@ public class TaskList extends Node {
return mChildren.get(index);
}
- /**
- * @param gid
- * @return
- * 功能：返回指定gid的Task
- */
public Task getChilTaskByGid(String gid) {
for (Task task : mChildren) {
if (task.getGid().equals(gid))
diff --git a/java/net/micode/notes/gtask/exception/ActionFailureException.java b/java/net/micode/notes/gtask/exception/ActionFailureException.java
index 403539d..15504be 100644
--- a/java/net/micode/notes/gtask/exception/ActionFailureException.java
+++ b/java/net/micode/notes/gtask/exception/ActionFailureException.java
@@ -16,24 +16,13 @@
package net.micode.notes.gtask.exception;
-/*
- * Description：支持小米便签运行过程中的运行异常处理。
- */
public class ActionFailureException extends RuntimeException {
private static final long serialVersionUID = 4425249765923293627L;
- /*
- * serialVersionUID相当于java类的身份证。主要用于版本控制。
- * serialVersionUID作用是序列化时保持版本的兼容性，即在版本升级时反序列化仍保持对象的唯一性。
- */
+
public ActionFailureException() {
super();
}
- /*
- * 在JAVA类中使用super来引用父类的成分，用this来引用当前对象.
- * 如果一个类从另外一个类继承，我们new这个子类的实例对象的时候，这个子类对象里面会有一个父类对象。
- * 怎么去引用里面的父类对象呢？使用super来引用
- * 也就是说，此处super()以及super (paramString)可认为是Exception ()和Exception (paramString)
- */
+
public ActionFailureException(String paramString) {
super(paramString);
}
diff --git a/java/net/micode/notes/gtask/exception/NetworkFailureException.java b/java/net/micode/notes/gtask/exception/NetworkFailureException.java
index ce87949..b08cfb1 100644
--- a/java/net/micode/notes/gtask/exception/NetworkFailureException.java
+++ b/java/net/micode/notes/gtask/exception/NetworkFailureException.java
@@ -13,27 +13,16 @@
* See the License for the specific language governing permissions and
* limitations under the License.
*/
-/*
- * Description：支持小米便签运行过程中的网络异常处理。
- */
+
package net.micode.notes.gtask.exception;
public class NetworkFailureException extends Exception {
private static final long serialVersionUID = 2107610287180234136L;
- /*
- * serialVersionUID相当于java类的身份证。主要用于版本控制。
- * serialVersionUID作用是序列化时保持版本的兼容性，即在版本升级时反序列化仍保持对象的唯一性。
- */
+
public NetworkFailureException() {
super();
}
- /*
- * 在JAVA类中使用super来引用父类的成分，用this来引用当前对象.
- * 如果一个类从另外一个类继承，我们new这个子类的实例对象的时候，这个子类对象里面会有一个父类对象。
- * 怎么去引用里面的父类对象呢？使用super来引用
- * 也就是说，此处super()以及super (paramString)可认为是Exception ()和Exception (paramString)
- */
public NetworkFailureException(String paramString) {
super(paramString);
}
diff --git a/java/net/micode/notes/gtask/remote/GTaskASyncTask.java b/java/net/micode/notes/gtask/remote/GTaskASyncTask.java
index 3b751df..08d20f7 100644
--- a/java/net/micode/notes/gtask/remote/GTaskASyncTask.java
+++ b/java/net/micode/notes/gtask/remote/GTaskASyncTask.java
@@ -28,106 +28,114 @@ import net.micode.notes.R;
import net.micode.notes.ui.NotesListActivity;
import net.micode.notes.ui.NotesPreferenceActivity;
-/*异步操作类，实现GTask的异步操作过程
- * 主要方法：
- * private void showNotification(int tickerId, String content) 向用户提示当前同步的状态，是一个用于交互的方法
- * protected Integer doInBackground(Void... unused) 此方法在后台线程执行，完成任务的主要工作，通常需要较长的时间
- * protected void onProgressUpdate(String... progress) 可以使用进度条增加用户体验度。 此方法在主线程执行，用于显示任务执行的进度。
- * protected void onPostExecute(Integer result) 相当于Handler 处理UI的方式，在这里面可以使用在doInBackground 得到的结果处理操作UI
- */
+
public class GTaskASyncTask extends AsyncTask {
- private static int GTASK_SYNC_NOTIFICATION_ID = 5234235; // 通知ID
- // 同步完成回调接口
+ private static int GTASK_SYNC_NOTIFICATION_ID = 5234235;
+
public interface OnCompleteListener {
void onComplete();
}
- private Context mContext; // 上下文
- private NotificationManager mNotifiManager; // 通知管理器
- private GTaskManager mTaskManager; // GTask管理类
- private OnCompleteListener mOnCompleteListener; // 完成回调
+ private Context mContext;
+
+ private NotificationManager mNotifiManager;
+
+ private GTaskManager mTaskManager;
+
+ private OnCompleteListener mOnCompleteListener;
- // 构造函数：初始化任务
public GTaskASyncTask(Context context, OnCompleteListener listener) {
mContext = context;
mOnCompleteListener = listener;
- mNotifiManager = (NotificationManager) context.getSystemService(Context.NOTIFICATION_SERVICE);
- mTaskManager = GTaskManager.getInstance(); // 获取GTask管理单例
+ mNotifiManager = (NotificationManager) mContext
+ .getSystemService(Context.NOTIFICATION_SERVICE);
+ mTaskManager = GTaskManager.getInstance();
}
- // 取消同步任务
public void cancelSync() {
mTaskManager.cancelSync();
}
- // 发布进度（封装参数格式）
public void publishProgess(String message) {
- publishProgress(new String[] { message });
+ publishProgress(new String[] {
+ message
+ });
}
- // 显示同步通知
- private void showNotification(int tickerId, String content) {
- PendingIntent pendingIntent;
- // 根据通知类型设置点击跳转的页面
- if (tickerId != R.string.ticker_success) {
- pendingIntent = PendingIntent.getActivity(mContext, 0,
- new Intent(mContext, NotesPreferenceActivity.class),
- PendingIntent.FLAG_IMMUTABLE);
- } else {
- pendingIntent = PendingIntent.getActivity(mContext, 0,
- new Intent(mContext, NotesListActivity.class),
- PendingIntent.FLAG_IMMUTABLE);
- }
- // 构建通知
- Notification.Builder builder = new Notification.Builder(mContext)
- .setAutoCancel(true) // 点击后自动取消
- .setContentTitle(mContext.getString(R.string.app_name))
- .setContentText(content)
- .setContentIntent(pendingIntent) // 点击通知后的跳转意图
- .setWhen(System.currentTimeMillis())
- .setOngoing(true); // 显示为进行中状态
- mNotifiManager.notify(GTASK_SYNC_NOTIFICATION_ID, builder.getNotification());
+// private void showNotification(int tickerId, String content) {
+// Notification notification = new Notification(R.drawable.notification, mContext
+// .getString(tickerId), System.currentTimeMillis());
+// notification.defaults = Notification.DEFAULT_LIGHTS;
+// notification.flags = Notification.FLAG_AUTO_CANCEL;
+// PendingIntent pendingIntent;
+// if (tickerId != R.string.ticker_success) {
+// pendingIntent = PendingIntent.getActivity(mContext, 0, new Intent(mContext,
+// NotesPreferenceActivity.class), 0);
+//
+// } else {
+// pendingIntent = PendingIntent.getActivity(mContext, 0, new Intent(mContext,
+// NotesListActivity.class), 0);
+// }
+// notification.setLatestEventInfo(mContext, mContext.getString(R.string.app_name), content,
+// pendingIntent);
+// mNotifiManager.notify(GTASK_SYNC_NOTIFICATION_ID, notification);
+// }
+private void showNotification(int tickerId, String content) {
+ PendingIntent pendingIntent;
+ if (tickerId != R.string.ticker_success) {
+ pendingIntent = PendingIntent.getActivity(mContext, 0, new Intent(mContext,
+ NotesPreferenceActivity.class), PendingIntent.FLAG_IMMUTABLE);
+ } else {
+ pendingIntent = PendingIntent.getActivity(mContext, 0, new Intent(mContext,
+ NotesListActivity.class), PendingIntent.FLAG_IMMUTABLE);
}
-
- // 后台执行同步任务（异步任务核心方法）
+ Notification.Builder builder = new Notification.Builder(mContext)
+ .setAutoCancel(true)
+ .setContentTitle(mContext.getString(R.string.app_name))
+ .setContentText(content)
+ .setContentIntent(pendingIntent)
+ .setWhen(System.currentTimeMillis())
+ .setOngoing(true);
+ Notification notification=builder.getNotification();
+ mNotifiManager.notify(GTASK_SYNC_NOTIFICATION_ID, notification);
+}
@Override
protected Integer doInBackground(Void... unused) {
- // 发布登录进度通知
- publishProgess(mContext.getString(R.string.sync_progress_login,
- NotesPreferenceActivity.getSyncAccountName(mContext)));
- // 调用GTaskManager执行同步，返回状态码
+ publishProgess(mContext.getString(R.string.sync_progress_login, NotesPreferenceActivity
+ .getSyncAccountName(mContext)));
return mTaskManager.sync(mContext, this);
}
- // 更新进度（UI线程执行）
@Override
protected void onProgressUpdate(String... progress) {
- showNotification(R.string.ticker_syncing, progress[0]); // 显示同步中通知
- // 向服务发送广播（如果上下文是GTaskSyncService）
+ showNotification(R.string.ticker_syncing, progress[0]);
if (mContext instanceof GTaskSyncService) {
((GTaskSyncService) mContext).sendBroadcast(progress[0]);
}
}
- // 任务完成后执行（UI线程执行）
@Override
protected void onPostExecute(Integer result) {
- // 根据同步结果显示不同通知
if (result == GTaskManager.STATE_SUCCESS) {
- showNotification(R.string.ticker_success,
- mContext.getString(R.string.success_sync_account, mTaskManager.getSyncAccount()));
- NotesPreferenceActivity.setLastSyncTime(mContext, System.currentTimeMillis()); // 记录最后同步时间
+ showNotification(R.string.ticker_success, mContext.getString(
+ R.string.success_sync_account, mTaskManager.getSyncAccount()));
+ NotesPreferenceActivity.setLastSyncTime(mContext, System.currentTimeMillis());
} else if (result == GTaskManager.STATE_NETWORK_ERROR) {
showNotification(R.string.ticker_fail, mContext.getString(R.string.error_sync_network));
} else if (result == GTaskManager.STATE_INTERNAL_ERROR) {
showNotification(R.string.ticker_fail, mContext.getString(R.string.error_sync_internal));
} else if (result == GTaskManager.STATE_SYNC_CANCELLED) {
- showNotification(R.string.ticker_cancel, mContext.getString(R.string.error_sync_cancelled));
+ showNotification(R.string.ticker_cancel, mContext
+ .getString(R.string.error_sync_cancelled));
}
- // 异步执行回调（避免阻塞UI线程）
if (mOnCompleteListener != null) {
- new Thread(() -> mOnCompleteListener.onComplete()).start();
+ new Thread(new Runnable() {
+
+ public void run() {
+ mOnCompleteListener.onComplete();
+ }
+ }).start();
}
}
-}
\ No newline at end of file
+}
diff --git a/java/net/micode/notes/gtask/remote/GTaskClient.java b/java/net/micode/notes/gtask/remote/GTaskClient.java
index 2e018e8..620284c 100644
--- a/java/net/micode/notes/gtask/remote/GTaskClient.java
+++ b/java/net/micode/notes/gtask/remote/GTaskClient.java
@@ -24,6 +24,8 @@ import android.os.Bundle;
import android.text.TextUtils;
import android.util.Log;
+//import com.google.firebase.crashlytics.buildtools.reloc.org.apache.http.HttpEntity;
+
import net.micode.notes.gtask.data.Node;
import net.micode.notes.gtask.data.Task;
import net.micode.notes.gtask.data.TaskList;
@@ -31,7 +33,6 @@ 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;
@@ -60,10 +61,7 @@ import java.util.zip.GZIPInputStream;
import java.util.zip.Inflater;
import java.util.zip.InflaterInputStream;
-/*
- * 主要功能：实现GTASK的登录操作，进行GTASK任务的创建，创建任务列表，从网络上获取任务和任务列表的内容
- * 主要使用类或技术：accountManager JSONObject HttpParams authToken Gid
- */
+
public class GTaskClient {
private static final String TAG = GTaskClient.class.getSimpleName();
@@ -93,7 +91,6 @@ public class GTaskClient {
private JSONArray mUpdateArray;
-
private GTaskClient() {
mHttpClient = null;
mGetUrl = GTASK_GET_URL;
@@ -106,10 +103,6 @@ public class GTaskClient {
mUpdateArray = null;
}
- /*用来获取的实例化对象
- * 使用 getInstance()
- * 返回mInstance这个实例化对象
- */
public static synchronized GTaskClient getInstance() {
if (mInstance == null) {
mInstance = new GTaskClient();
@@ -117,54 +110,42 @@ public class GTaskClient {
return mInstance;
}
- /*用来实现登录操作的函数，传入的参数是一个Activity
- * 设置登录操作限制时间，如果超时则需要重新登录
- * 有两种登录方式，使用用户自己的URL登录或者使用谷歌官方的URL登录
- * 返回true或者false，即最后是否登陆成功
- */
public boolean login(Activity activity) {
// we suppose that the cookie would expire after 5 minutes
// then we need to re-login
- //判断距离最后一次登录操作是否超过5分钟
final long interval = 1000 * 60 * 5;
if (mLastLoginTime + interval < System.currentTimeMillis()) {
mLoggedin = false;
}
- // need to re-login after account switch 重新登录操作
+ // need to re-login after account switch
if (mLoggedin
&& !TextUtils.equals(getSyncAccount().name, NotesPreferenceActivity
.getSyncAccountName(activity))) {
mLoggedin = false;
}
- //如果没超过时间，则不需要重新登录
if (mLoggedin) {
Log.d(TAG, "already logged in");
return true;
}
- //更新最后登录时间，改为系统当前的时间
mLastLoginTime = System.currentTimeMillis();
String authToken = loginGoogleAccount(activity, false);
- //判断是否登录到谷歌账户
if (authToken == null) {
Log.e(TAG, "login google account failed");
return false;
}
// login with custom domain if necessary
-
-
if (!(mAccount.name.toLowerCase().endsWith("gmail.com") || mAccount.name.toLowerCase()
-//将用户账号名改为统一格式（小写）后判断是否为一个谷歌账号地址
.endsWith("googlemail.com"))) {
StringBuilder url = new StringBuilder(GTASK_URL).append("a/");
int index = mAccount.name.indexOf('@') + 1;
String suffix = mAccount.name.substring(index);
url.append(suffix + "/");
- mGetUrl = url.toString() + "ig"; //设置用户对应的getUrl
- mPostUrl = url.toString() + "r/ig";//设置用户对应的postUrl
+ mGetUrl = url.toString() + "ig";
+ mPostUrl = url.toString() + "r/ig";
if (tryToLoginGtask(activity, authToken)) {
mLoggedin = true;
@@ -172,7 +153,6 @@ public class GTaskClient {
}
// try to login with google official url
- //如果用户账户无法登录，则使用谷歌官方的URI进行登录
if (!mLoggedin) {
mGetUrl = GTASK_GET_URL;
mPostUrl = GTASK_POST_URL;
@@ -185,17 +165,9 @@ public class GTaskClient {
return true;
}
- /*具体实现登录谷歌账户的方法
- * 使用令牌机制
- * 使用AccountManager来管理注册账号
- * 返回值是账号的令牌
- */
- private String loginGoogleAccount(Activity activity, boolean invalidateToken) {//令牌，是登录操作保证安全性的一个方法
+ private String loginGoogleAccount(Activity activity, boolean invalidateToken) {
String authToken;
- //AccountManager这个类给用户提供了集中注册账号的接口
AccountManager accountManager = AccountManager.get(activity);
-
- //获取全部以com.google结尾的account
Account[] accounts = accountManager.getAccountsByType("com.google");
if (accounts.length == 0) {
@@ -205,7 +177,6 @@ public class GTaskClient {
String accountName = NotesPreferenceActivity.getSyncAccountName(activity);
Account account = null;
- //遍历获得的accounts信息，寻找已经记录过的账户信息
for (Account a : accounts) {
if (a.name.equals(accountName)) {
account = a;
@@ -220,13 +191,11 @@ public class GTaskClient {
}
// get the token now
- //获取选中账号的令牌
AccountManagerFuture accountManagerFuture = accountManager.getAuthToken(account,
"goanna_mobile", null, activity, null, null);
try {
Bundle authTokenBundle = accountManagerFuture.getResult();
authToken = authTokenBundle.getString(AccountManager.KEY_AUTHTOKEN);
- //如果是invalidateToken，那么需要调用invalidateAuthToken(String, String)方法废除这个无效token
if (invalidateToken) {
accountManager.invalidateAuthToken("com.google", authToken);
loginGoogleAccount(activity, false);
@@ -239,13 +208,10 @@ public class GTaskClient {
return authToken;
}
- //尝试登陆Gtask，这只是一个预先判断令牌是否是有效以及是否能登上GTask的方法,而不是具体实现登陆的方法
private boolean tryToLoginGtask(Activity activity, String authToken) {
if (!loginGtask(authToken)) {
// maybe the auth token is out of date, now let's invalidate the
// token and try again
-
- //删除过一个无效的authToken，申请一个新的后再次尝试登陆
authToken = loginGoogleAccount(activity, true);
if (authToken == null) {
Log.e(TAG, "login google account failed");
@@ -260,34 +226,25 @@ public class GTaskClient {
return true;
}
- //实现登录GTask的具体操作
private boolean loginGtask(String authToken) {
int timeoutConnection = 10000;
int timeoutSocket = 15000;
- //socket是一种通信连接实现数据的交换的端口
HttpParams httpParameters = new BasicHttpParams();
- //实例化一个新的HTTP参数类
HttpConnectionParams.setConnectionTimeout(httpParameters, timeoutConnection);
- //设置连接超时时间
HttpConnectionParams.setSoTimeout(httpParameters, timeoutSocket);
- //设置设置端口超时时间
mHttpClient = new DefaultHttpClient(httpParameters);
BasicCookieStore localBasicCookieStore = new BasicCookieStore();
- //设置本地cookie
mHttpClient.setCookieStore(localBasicCookieStore);
HttpProtocolParams.setUseExpectContinue(mHttpClient.getParams(), false);
// login gtask
try {
String loginUrl = mGetUrl + "?auth=" + authToken;
- //设置登录的url
HttpGet httpGet = new HttpGet(loginUrl);
- //通过登录的uri实例化网页上资源的查找
HttpResponse response = null;
response = mHttpClient.execute(httpGet);
// get the cookie now
- //获取CookieStore里存放的cookie,看如果存有“GTL(不知道什么意思)”，则说明有验证成功的有效的cookie
List cookies = mHttpClient.getCookieStore().getCookies();
boolean hasAuthCookie = false;
for (Cookie cookie : cookies) {
@@ -300,7 +257,6 @@ public class GTaskClient {
}
// get the client version
- //获取client的内容，具体操作是在返回的Content中截取从_setup(开始到)}中间的字符串内容，也就是gtask_url的内容
String resString = getResponseContent(response.getEntity());
String jsBegin = "_setup(";
String jsEnd = ")}";
@@ -329,10 +285,6 @@ public class GTaskClient {
return mActionId++;
}
- /*实例化创建一个用于向网络传输数据的对象
- * 使用HttpPost类
- * 返回一个httpPost实例化对象，但里面还没有内容
- */
private HttpPost createHttpPost() {
HttpPost httpPost = new HttpPost(mPostUrl);
httpPost.setHeader("Content-Type", "application/x-www-form-urlencoded;charset=utf-8");
@@ -340,23 +292,17 @@ public class GTaskClient {
return httpPost;
}
- /*通过URL获取响应后返回的数据，也就是网络上的数据和资源
- * 使用getContentEncoding()获取网络上的资源和数据
- * 返回值就是获取到的资源
- */
private String getResponseContent(HttpEntity entity) throws IOException {
String contentEncoding = null;
if (entity.getContentEncoding() != null) {
- //通过URL得到HttpEntity对象，如果不为空则使用getContent（）方法创建一个流将数据从网络都过来
contentEncoding = entity.getContentEncoding().getValue();
Log.d(TAG, "encoding: " + contentEncoding);
}
InputStream input = entity.getContent();
if (contentEncoding != null && contentEncoding.equalsIgnoreCase("gzip")) {
-//GZIP是使用DEFLATE进行压缩数据的另一个压缩库
input = new GZIPInputStream(entity.getContent());
- } else if (contentEncoding != null && contentEncoding.equalsIgnoreCase("deflate")) {//DEFLATE是一个无专利的压缩算法，它可以实现无损数据压缩
+ } else if (contentEncoding != null && contentEncoding.equalsIgnoreCase("deflate")) {
Inflater inflater = new Inflater(true);
input = new InflaterInputStream(entity.getContent(), inflater);
}
@@ -364,7 +310,6 @@ public class GTaskClient {
try {
InputStreamReader isr = new InputStreamReader(input);
BufferedReader br = new BufferedReader(isr);
-//是一个包装类，它可以包装字符流，将字符流放入缓存里，先把字符读到缓存里，到缓存满了时候，再读入内存，是为了提供读的效率而设计的
StringBuilder sb = new StringBuilder();
while (true) {
@@ -379,19 +324,12 @@ public class GTaskClient {
}
}
- /*通过JSON发送请求
- * 请求的具体内容在json的实例化对象js中然后传入
- * 利用UrlEncodedFormEntity entity和httpPost.setEntity(entity)方法把js中的内容放置到httpPost中
- * 执行请求后使用getResponseContent方法得到返回的数据和资源
- * 将资源再次放入json后返回
- */
-
private JSONObject postRequest(JSONObject js) throws NetworkFailureException {
if (!mLoggedin) {
Log.e(TAG, "please login first");
throw new ActionFailureException("not logged in");
}
- //实例化一个httpPost的对象用来向服务器传输数据，在这里就是发送请求，而请求的内容在js里
+
HttpPost httpPost = createHttpPost();
try {
LinkedList list = new LinkedList();
@@ -423,13 +361,6 @@ public class GTaskClient {
}
}
- /*创建单个任务
- * 传入参数是一个.gtask.data.Task包里Task类的对象
- * 利用json获取Task里的内容,并且创建相应的jsPost
- * 利用postRequest得到任务的返回信息
- * 使用task.setGid设置task的new_ID
- */
-
public void createTask(Task task) throws NetworkFailureException {
commitUpdate();
try {
@@ -456,9 +387,6 @@ public class GTaskClient {
}
}
- /*
- * 创建一个任务列表，与createTask几乎一样，区别就是最后设置的是tasklist的gid
- */
public void createTaskList(TaskList tasklist) throws NetworkFailureException {
commitUpdate();
try {
@@ -485,11 +413,6 @@ public class GTaskClient {
}
}
- /*
- * 同步更新操作
- * 使用JSONObject进行数据存储，使用jsPost.put，Put的信息包括UpdateArray和ClientVersion
- * 使用postRequest发送这个jspost,进行处理
- */
public void commitUpdate() throws NetworkFailureException {
if (mUpdateArray != null) {
try {
@@ -511,10 +434,6 @@ public class GTaskClient {
}
}
- /*
- * 添加更新的事项
- * 调用commitUpdate()实现
- */
public void addUpdateNode(Node node) throws NetworkFailureException {
if (node != null) {
// too many update items may result in an error
@@ -529,12 +448,6 @@ public class GTaskClient {
}
}
- /*
- * 移动task,比如讲task移动到不同的task列表中去
- * 通过getGid获取task所属列表的gid
- * 通过JSONObject.put(String name, Object value)函数设置移动后的task的相关属性值，从而达到移动的目的
- * 最后还是通过postRequest进行更新后的发送
- */
public void moveTask(Task task, TaskList preParent, TaskList curParent)
throws NetworkFailureException {
commitUpdate();
@@ -550,8 +463,6 @@ public class GTaskClient {
action.put(GTaskStringUtils.GTASK_JSON_ID, task.getGid());
if (preParent == curParent && task.getPriorSibling() != null) {
// put prioring_sibing_id only if moving within the tasklist and
-
- //设置优先级ID，只有当移动是发生在文件中
// it is not the first one
action.put(GTaskStringUtils.GTASK_JSON_PRIOR_SIBLING_ID, task.getPriorSibling());
}
@@ -562,7 +473,6 @@ public class GTaskClient {
action.put(GTaskStringUtils.GTASK_JSON_DEST_LIST, curParent.getGid());
}
actionList.put(action);
- //最后将ACTION_LIST加入到jsPost中
jsPost.put(GTaskStringUtils.GTASK_JSON_ACTION_LIST, actionList);
// client_version
@@ -577,11 +487,6 @@ public class GTaskClient {
}
}
- /*
- * 删除操作节点
- * 还是利用JSON
- * 删除过后使用postRequest发送删除后的结果
- */
public void deleteNode(Node node) throws NetworkFailureException {
commitUpdate();
try {
@@ -605,11 +510,6 @@ public class GTaskClient {
}
}
- /*
- * 获取任务列表
- * 首先通过GetURI使用getResponseContent从网上获取数据
- * 然后筛选出"_setup("到)}的部分，并且从中获取GTASK_JSON_LISTS的内容返回
- */
public JSONArray getTaskLists() throws NetworkFailureException {
if (!mLoggedin) {
Log.e(TAG, "please login first");
@@ -622,7 +522,6 @@ public class GTaskClient {
response = mHttpClient.execute(httpGet);
// get the task list
- //筛选工作，把筛选出的字符串放入jsString
String resString = getResponseContent(response.getEntity());
String jsBegin = "_setup(";
String jsEnd = ")}";
@@ -649,9 +548,6 @@ public class GTaskClient {
}
}
- /*
- * 通过传入的TASKList的gid,从网络上获取相应属于这个任务列表的任务
- */
public JSONArray getTaskList(String listGid) throws NetworkFailureException {
commitUpdate();
try {
@@ -684,8 +580,6 @@ public class GTaskClient {
return mAccount;
}
-
- //重置更新的内容
public void resetUpdateArray() {
mUpdateArray = null;
}
diff --git a/java/net/micode/notes/gtask/remote/GTaskManager.java b/java/net/micode/notes/gtask/remote/GTaskManager.java
index d9526dd..d2b4082 100644
--- a/java/net/micode/notes/gtask/remote/GTaskManager.java
+++ b/java/net/micode/notes/gtask/remote/GTaskManager.java
@@ -87,13 +87,10 @@ public class GTaskManager {
private HashMap mNidToGid;
- private GTaskManager() {//对象初始化函数
+ private GTaskManager() {
mSyncing = false;
- //正在同步,flase代表未执行
mCancelled = false;
- //全局标识，flase代表可以执行
mGTaskListHashMap = new HashMap();
- //<>代表Java的泛型,就是创建一个用类型作为参数的类。
mGTaskHashMap = new HashMap();
mMetaHashMap = new HashMap();
mMetaList = null;
@@ -101,42 +98,22 @@ public class GTaskManager {
mGidToNid = new HashMap();
mNidToGid = new HashMap();
}
- /*
- * 包含关键字synchronized，语言级同步，指明该函数可能运行在多线程的环境下。
- * 功能：类初始化函数
- * @author TTS
- * @return GtaskManger
- */
-
- public static synchronized GTaskManager getInstance() { //可能运行在多线程环境下，使用语言级同步--synchronized
+
+ public static synchronized GTaskManager getInstance() {
if (mInstance == null) {
mInstance = new GTaskManager();
}
return mInstance;
}
- /*
- * 包含关键字synchronized，语言级同步，指明该函数可能运行在多线程的环境下。
- * @author TTS
- * @param activity
- */
public synchronized void setActivityContext(Activity activity) {
// used for getting authtoken
mActivity = activity;
}
- /*
- * 核心函数
- * 功能：实现了本地同步操作和远端同步操作
- * @author TTS
- * @param context-----获取上下文
- * @param asyncTask-------用于同步的异步操作类
- * @return int
- */
public int sync(Context context, GTaskASyncTask asyncTask) {
if (mSyncing) {
Log.d(TAG, "Sync is in progress");
- //创建日志文件（调试信息），debug
return STATE_SYNC_IN_PROGRESS;
}
mContext = context;
@@ -153,7 +130,6 @@ public class GTaskManager {
try {
GTaskClient client = GTaskClient.getInstance();
client.resetUpdateArray();
-//JSONArray类型，reset即置为NULL
// login google task
if (!mCancelled) {
@@ -165,18 +141,14 @@ public class GTaskManager {
// get the task list from google
asyncTask.publishProgess(mContext.getString(R.string.sync_progress_init_list));
initGTaskList();
- //获取Google上的JSONtasklist转为本地TaskList
// do content sync work
asyncTask.publishProgess(mContext.getString(R.string.sync_progress_syncing));
syncContent();
} catch (NetworkFailureException e) {
- //分为两种异常，此类异常为网络异常
Log.e(TAG, e.toString());
- //创建日志文件（调试信息），error
return STATE_NETWORK_ERROR;
} catch (ActionFailureException e) {
- //此类异常为操作异常
Log.e(TAG, e.toString());
return STATE_INTERNAL_ERROR;
} catch (Exception e) {
@@ -196,22 +168,11 @@ public class GTaskManager {
return mCancelled ? STATE_SYNC_CANCELLED : STATE_SUCCESS;
}
- /*
- *功能：初始化GtaskList，获取Google上的JSONtasklist转为本地TaskList。
- *获得的数据存储在mMetaList，mGTaskListHashMap，mGTaskHashMap
- *@author TTS
- *@exception NetworkFailureException
- *@return void
- */
-
private void initGTaskList() throws NetworkFailureException {
if (mCancelled)
return;
GTaskClient client = GTaskClient.getInstance();
- try {//Json对象是Name Value对(即子元素)的无序集合，相当于一个Map对象。JsonObject类是bantouyan-json库对Json对象的抽象，提供操纵Json对象的各种方法。
- //其格式为{"key1":value1,"key2",value2....};key 必须是字符串。
- //因为ajax请求不刷新页面，但配合js可以实现局部刷新，因此json常常被用来作为异步请求的返回对象使用。
-
+ try {
JSONArray jsTaskLists = client.getTaskLists();
// init meta list first
@@ -224,7 +185,7 @@ public class GTaskManager {
if (name
.equals(GTaskStringUtils.MIUI_FOLDER_PREFFIX + GTaskStringUtils.FOLDER_META)) {
mMetaList = new TaskList();
- mMetaList.setContentByRemoteJSON(object);//将JSON中部分数据复制到自己定义的对象中相对应的数据：name->mname...
+ mMetaList.setContentByRemoteJSON(object);
// load meta data
JSONArray jsMetas = client.getTaskList(gid);
@@ -286,17 +247,9 @@ public class GTaskManager {
}
}
- /*
- * 功能：本地内容同步操作
- * @throws NetworkFailureException
- * @return 无返回值
- */
private void syncContent() throws NetworkFailureException {
- //本地内容同步操作
int syncType;
Cursor c = null;
-
- //数据库指针
String gid;
Node node;
@@ -523,14 +476,6 @@ public class GTaskManager {
GTaskClient.getInstance().commitUpdate();
}
- /*
- * 功能：syncType分类，addLocalNode，addRemoteNode，deleteNode，updateLocalNode，updateRemoteNode
- * @author TTS
- * @param syncType
- * @param node
- * @param c
- * @throws NetworkFailureException
- */
private void doContentSync(int syncType, Node node, Cursor c) throws NetworkFailureException {
if (mCancelled) {
return;
@@ -577,12 +522,6 @@ public class GTaskManager {
}
}
- /*
- * 功能：本地增加Node
- * @author TTS
- * @param node
- * @throws NetworkFailureException
- */
private void addLocalNode(Node node) throws NetworkFailureException {
if (mCancelled) {
return;
@@ -657,16 +596,6 @@ public class GTaskManager {
updateRemoteMeta(node.getGid(), sqlNote);
}
- /*
- * 功能：update本地node
- * @author TTS
- * @param node
- * ----同步操作的基础数据类型
- * @param c
- * ----Cursor
- * @throws NetworkFailureException
- */
-
private void updateLocalNode(Node node, Cursor c) throws NetworkFailureException {
if (mCancelled) {
return;
@@ -690,17 +619,6 @@ public class GTaskManager {
updateRemoteMeta(node.getGid(), sqlNote);
}
- /*
- * 功能：远程增加Node
- * 需要updateRemoteMeta
- * @author TTS
- * @param node
- * ----同步操作的基础数据类型
- * @param c
- * --Cursor
- * @throws NetworkFailureException
- */
-
private void addRemoteNode(Node node, Cursor c) throws NetworkFailureException {
if (mCancelled) {
return;
@@ -720,7 +638,7 @@ public class GTaskManager {
throw new ActionFailureException("cannot add remote task");
}
mGTaskListHashMap.get(parentGid).addChildTask(task);
-//登录远程服务器，创建Task
+
GTaskClient.getInstance().createTask(task);
n = (Node) task;
@@ -738,7 +656,6 @@ public class GTaskManager {
else
folderName += sqlNote.getSnippet();
- //iterator迭代器，通过统一的接口迭代所有的map元素
Iterator> iter = mGTaskListHashMap.entrySet().iterator();
while (iter.hasNext()) {
Map.Entry entry = iter.next();
@@ -775,16 +692,6 @@ public class GTaskManager {
mNidToGid.put(sqlNote.getId(), n.getGid());
}
- /*
- * 功能：更新远端的Node，包含meta更新(updateRemoteMeta)
- * @author TTS
- * @param node
- * ----同步操作的基础数据类型
- * @param c
- * --Cursor
- * @throws NetworkFailureException
- */
-
private void updateRemoteNode(Node node, Cursor c) throws NetworkFailureException {
if (mCancelled) {
return;
@@ -803,14 +710,12 @@ public class GTaskManager {
if (sqlNote.isNoteType()) {
Task task = (Task) node;
TaskList preParentList = task.getParent();
- //preParentList为通过node获取的父节点列表
String curParentGid = mNidToGid.get(sqlNote.getParentId());
if (curParentGid == null) {
Log.e(TAG, "cannot find task's parent tasklist");
throw new ActionFailureException("cannot update remote task");
}
- //通过HashMap找到对应Gid的TaskList
TaskList curParentList = mGTaskListHashMap.get(curParentGid);
if (preParentList != curParentList) {
@@ -822,18 +727,9 @@ public class GTaskManager {
// clear local modified flag
sqlNote.resetLocalModified();
- sqlNote.commit(true); //commit到本地数据库
+ sqlNote.commit(true);
}
- /**
- * 功能：升级远程meta。 meta---元数据----计算机文件系统管理数据---管理数据的数据。
- * @author TTS
- * @param gid
- * ---GoogleID为String类型
- * @param sqlNote
- * ---同步前的数据库操作，故使用类SqlNote
- * @throws NetworkFailureException
- */
private void updateRemoteMeta(String gid, SqlNote sqlNote) throws NetworkFailureException {
if (sqlNote != null && sqlNote.isNoteType()) {
MetaData metaData = mMetaHashMap.get(gid);
@@ -850,12 +746,6 @@ public class GTaskManager {
}
}
- /**
- * 功能：刷新本地，给sync的ID对应上最后更改过的对象
- * @author TTS
- * @return void
- * @throws NetworkFailureException
- */
private void refreshLocalSyncId() throws NetworkFailureException {
if (mCancelled) {
return;
@@ -900,19 +790,10 @@ public class GTaskManager {
}
}
- /**
- * 功能：获取同步账号,mAccount.name
- * @author TTS
- * @return String
- */
public String getSyncAccount() {
return GTaskClient.getInstance().getSyncAccount().name;
}
- /**
- * 功能：取消同步，置mCancelled为true
- * @author TTS
- */
public void cancelSync() {
mCancelled = true;
}
diff --git a/java/net/micode/notes/gtask/remote/GTaskSyncService.java b/java/net/micode/notes/gtask/remote/GTaskSyncService.java
index 81dc1d6..cca36f7 100644
--- a/java/net/micode/notes/gtask/remote/GTaskSyncService.java
+++ b/java/net/micode/notes/gtask/remote/GTaskSyncService.java
@@ -15,22 +15,6 @@
*/
package net.micode.notes.gtask.remote;
-/*
- * Service是在一段不定的时间运行在后台，不和用户交互的应用组件
- * 主要方法：
- * private void startSync() 启动一个同步工作
- * private void cancelSync() 取消同步
- * public void onCreate()
- * public int onStartCommand(Intent intent, int flags, int startId) service生命周期的组成部分，相当于重启service（比如在被暂停之后），而不是创建一个新的service
- * public void onLowMemory() 在没有内存的情况下如果存在service则结束掉这的service
- * public IBinder onBind()
- * public void sendBroadcast(String msg) 发送同步的相关通知
- * public static void startSync(Activity activity)
- * public static void cancelSync(Context context)
- * public static boolean isSyncing() 判读是否在进行同步
- * public static String getProgressString() 获取当前进度的信息
- */
-
import android.app.Activity;
import android.app.Service;
@@ -58,7 +42,7 @@ public class GTaskSyncService extends Service {
private static String mSyncProgress = "";
- private void startSync() {//开始一个同步的工作
+ private void startSync() {
if (mSyncTask == null) {
mSyncTask = new GTaskASyncTask(this, new GTaskASyncTask.OnCompleteListener() {
public void onComplete() {
@@ -68,7 +52,7 @@ public class GTaskSyncService extends Service {
}
});
sendBroadcast("");
- mSyncTask.execute();//这个函数让任务是以单线程队列方式或线程池队列方式运行
+ mSyncTask.execute();
}
}
@@ -78,7 +62,6 @@ public class GTaskSyncService extends Service {
}
}
- //初始化一个service
@Override
public void onCreate() {
mSyncTask = null;
@@ -89,7 +72,6 @@ public class GTaskSyncService extends Service {
Bundle bundle = intent.getExtras();
if (bundle != null && bundle.containsKey(ACTION_STRING_NAME)) {
switch (bundle.getInt(ACTION_STRING_NAME, ACTION_INVALID)) {
- //两种情况，开始同步或者取消同步
case ACTION_START_SYNC:
startSync();
break;
@@ -99,7 +81,7 @@ public class GTaskSyncService extends Service {
default:
break;
}
- return START_STICKY;//等待新的intent来是这个service继续运行
+ return START_STICKY;
}
return super.onStartCommand(intent, flags, startId);
}
@@ -117,20 +99,20 @@ public class GTaskSyncService extends Service {
public void sendBroadcast(String msg) {
mSyncProgress = msg;
- Intent intent = new Intent(GTASK_SERVICE_BROADCAST_NAME);//创建一个新的Intent
- intent.putExtra(GTASK_SERVICE_BROADCAST_IS_SYNCING, mSyncTask != null);//附加INTENT中的相应参数的值
+ Intent intent = new Intent(GTASK_SERVICE_BROADCAST_NAME);
+ intent.putExtra(GTASK_SERVICE_BROADCAST_IS_SYNCING, mSyncTask != null);
intent.putExtra(GTASK_SERVICE_BROADCAST_PROGRESS_MSG, msg);
- sendBroadcast(intent); //发送这个通知
+ sendBroadcast(intent);
}
- public static void startSync(Activity activity) {//执行一个service，service的内容里的同步动作就是开始同步
+ public static void startSync(Activity activity) {
GTaskManager.getInstance().setActivityContext(activity);
Intent intent = new Intent(activity, GTaskSyncService.class);
intent.putExtra(GTaskSyncService.ACTION_STRING_NAME, GTaskSyncService.ACTION_START_SYNC);
activity.startService(intent);
}
- public static void cancelSync(Context context) {//执行一个service，service的内容里的同步动作就是取消同步
+ public static void cancelSync(Context context) {
Intent intent = new Intent(context, GTaskSyncService.class);
intent.putExtra(GTaskSyncService.ACTION_STRING_NAME, GTaskSyncService.ACTION_CANCEL_SYNC);
context.startService(intent);
diff --git a/java/net/micode/notes/model/Note.java b/java/net/micode/notes/model/Note.java
index 5975683..6706cf6 100644
--- a/java/net/micode/notes/model/Note.java
+++ b/java/net/micode/notes/model/Note.java
@@ -49,10 +49,8 @@ public class Note {
values.put(NoteColumns.MODIFIED_DATE, createdTime);
values.put(NoteColumns.TYPE, Notes.TYPE_NOTE);
values.put(NoteColumns.LOCAL_MODIFIED, 1);
- values.put(NoteColumns.PARENT_ID, folderId);//将数据写入数据库表格
+ values.put(NoteColumns.PARENT_ID, folderId);
Uri uri = context.getContentResolver().insert(Notes.CONTENT_NOTE_URI, values);
- //ContentResolver()主要是实现外部应用对ContentProvider中的数据
- //进行添加、删除、修改和查询操作
long noteId = 0;
try {
@@ -67,38 +65,38 @@ public class Note {
return noteId;
}
- public Note() {//定义两个变量用来存储便签的数据，一个是存储便签属性、一个是存储便签内容
+ public Note() {
mNoteDiffValues = new ContentValues();
mNoteData = new NoteData();
}
- public void setNoteValue(String key, String value) {//设置数据库表格的标签属性数据
+ public void setNoteValue(String key, String value) {
mNoteDiffValues.put(key, value);
mNoteDiffValues.put(NoteColumns.LOCAL_MODIFIED, 1);
mNoteDiffValues.put(NoteColumns.MODIFIED_DATE, System.currentTimeMillis());
}
- public void setTextData(String key, String value) {//设置数据库表格的标签文本内容的数据
+ public void setTextData(String key, String value) {
mNoteData.setTextData(key, value);
}
- public void setTextDataId(long id) {//设置文本数据的ID
+ public void setTextDataId(long id) {
mNoteData.setTextDataId(id);
}
- public long getTextDataId() {//得到文本数据的ID
+ public long getTextDataId() {
return mNoteData.mTextDataId;
}
- public void setCallDataId(long id) {//设置电话号码数据的ID
+ public void setCallDataId(long id) {
mNoteData.setCallDataId(id);
}
- public void setCallData(String key, String value) {//得到电话号码数据的ID
+ public void setCallData(String key, String value) {
mNoteData.setCallData(key, value);
}
- public boolean isLocalModified() {//判断是否本地修改
+ public boolean isLocalModified() {
return mNoteDiffValues.size() > 0 || mNoteData.isLocalModified();
}
@@ -132,7 +130,6 @@ public class Note {
return true;
}
- //定义一个基本的便签内容的数据类，主要包含文本数据和电话号码数据
private class NoteData {
private long mTextDataId;
@@ -180,7 +177,7 @@ public class Note {
mNoteDiffValues.put(NoteColumns.LOCAL_MODIFIED, 1);
mNoteDiffValues.put(NoteColumns.MODIFIED_DATE, System.currentTimeMillis());
}
- //将新的数据通过Uri的操作存储到数据库
+
Uri pushIntoContentResolver(Context context, long noteId) {
/**
* Check for safety
@@ -212,7 +209,7 @@ public class Note {
operationList.add(builder.build());
}
mTextDataValues.clear();
- }//把文本数据存入DataColumns
+ }
if(mCallDataValues.size() > 0) {
mCallDataValues.put(DataColumns.NOTE_ID, noteId);
@@ -234,7 +231,7 @@ public class Note {
operationList.add(builder.build());
}
mCallDataValues.clear();
- }//把电话号码数据存入DataColumns
+ }
if (operationList.size() > 0) {
try {
@@ -249,7 +246,7 @@ public class Note {
Log.e(TAG, String.format("%s: %s", e.toString(), e.getMessage()));
return null;
}
- }//存储过程中的异常处理
+ }
return null;
}
}
diff --git a/java/net/micode/notes/model/WorkingNote.java b/java/net/micode/notes/model/WorkingNote.java
index 289f70f..be081e4 100644
--- a/java/net/micode/notes/model/WorkingNote.java
+++ b/java/net/micode/notes/model/WorkingNote.java
@@ -61,7 +61,7 @@ public class WorkingNote {
private boolean mIsDeleted;
private NoteSettingChangedListener mNoteSettingStatusListener;
- // 声明 DATA_PROJECTION字符串数组
+
public static final String[] DATA_PROJECTION = new String[] {
DataColumns.ID,
DataColumns.CONTENT,
@@ -123,13 +123,12 @@ public class WorkingNote {
mNote = new Note();
loadNote();
}
- // 加载Note
- // 通过数据库调用query函数找到第一个条目
+
private void loadNote() {
Cursor cursor = mContext.getContentResolver().query(
ContentUris.withAppendedId(Notes.CONTENT_NOTE_URI, mNoteId), NOTE_PROJECTION, null,
null, null);
-// 若存在，储存相应信息
+
if (cursor != null) {
if (cursor.moveToFirst()) {
mFolderId = cursor.getLong(NOTE_PARENT_ID_COLUMN);
@@ -140,18 +139,17 @@ public class WorkingNote {
mModifiedDate = cursor.getLong(NOTE_MODIFIED_DATE_COLUMN);
}
cursor.close();
- // 若不存在，报错
} else {
Log.e(TAG, "No note with id:" + mNoteId);
throw new IllegalArgumentException("Unable to find note with id " + mNoteId);
}
loadNoteData();
}
- // 加载NoteData
+
private void loadNoteData() {
Cursor cursor = mContext.getContentResolver().query(Notes.CONTENT_DATA_URI, DATA_PROJECTION,
DataColumns.NOTE_ID + "=?", new String[] {
- String.valueOf(mNoteId)
+ String.valueOf(mNoteId)
}, null);
if (cursor != null) {
@@ -175,12 +173,10 @@ public class WorkingNote {
throw new IllegalArgumentException("Unable to find note's data with id " + mNoteId);
}
}
- // 创建空的Note
- // 传参：context，文件夹id，widget，背景颜色
+
public static WorkingNote createEmptyNote(Context context, long folderId, int widgetId,
- int widgetType, int defaultBgColorId) {
+ int widgetType, int defaultBgColorId) {
WorkingNote note = new WorkingNote(context, folderId);
- // 设定相关属性
note.setBgColorId(defaultBgColorId);
note.setWidgetId(widgetId);
note.setWidgetType(widgetType);
@@ -191,7 +187,6 @@ public class WorkingNote {
return new WorkingNote(context, id, 0);
}
- // 保存Note
public synchronized boolean saveNote() {
if (isWorthSaving()) {
if (!existInDatabase()) {
@@ -229,12 +224,11 @@ public class WorkingNote {
return true;
}
}
- // 设置mNoteSettingStatusListener
+
public void setOnSettingStatusChangedListener(NoteSettingChangedListener l) {
mNoteSettingStatusListener = l;
}
- // 设置AlertDate
- // 若 mAlertDate与data不同，则更改mAlertDate并设定NoteValue
+
public void setAlertDate(long date, boolean set) {
if (date != mAlertDate) {
mAlertDate = date;
@@ -244,17 +238,17 @@ public class WorkingNote {
mNoteSettingStatusListener.onClockAlertChanged(date, set);
}
}
- // 设定删除标记
+
public void markDeleted(boolean mark) {
mIsDeleted = mark;
if (mWidgetId != AppWidgetManager.INVALID_APPWIDGET_ID
&& mWidgetType != Notes.TYPE_WIDGET_INVALIDE && mNoteSettingStatusListener != null) {
- mNoteSettingStatusListener.onWidgetChanged();// 调用mNoteSettingStatusListener的 onWidgetChanged方法
+ mNoteSettingStatusListener.onWidgetChanged();
}
}
- // 设定背景颜色
+
public void setBgColorId(int id) {
- if (id != mBgColorId) {//设定条件 id != mBgColorId
+ if (id != mBgColorId) {
mBgColorId = id;
if (mNoteSettingStatusListener != null) {
mNoteSettingStatusListener.onBackgroundColorChanged();
@@ -262,8 +256,7 @@ public class WorkingNote {
mNote.setNoteValue(NoteColumns.BG_COLOR_ID, String.valueOf(id));
}
}
- // 设定检查列表模式
- // 参数：mode
+
public void setCheckListMode(int mode) {
if (mMode != mode) {
if (mNoteSettingStatusListener != null) {
@@ -273,88 +266,82 @@ public class WorkingNote {
mNote.setTextData(TextNote.MODE, String.valueOf(mMode));
}
}
- // 设定WidgetType
- // 参数：type
+
public void setWidgetType(int type) {
if (type != mWidgetType) {
mWidgetType = type;
mNote.setNoteValue(NoteColumns.WIDGET_TYPE, String.valueOf(mWidgetType));
}
}
- // 设定WidgetId
- // 参数：id
+
public void setWidgetId(int id) {
if (id != mWidgetId) {
mWidgetId = id;
mNote.setNoteValue(NoteColumns.WIDGET_ID, String.valueOf(mWidgetId));
}
}
- // 设定WorkingTex
- // 参数：更改的text
+
public void setWorkingText(String text) {
if (!TextUtils.equals(mContent, text)) {
mContent = text;
mNote.setTextData(DataColumns.CONTENT, mContent);
}
}
- // 转变mNote的CallData及CallNote信息
- // 参数：String phoneNumber, long callDate
+
public void convertToCallNote(String phoneNumber, long callDate) {
mNote.setCallData(CallNote.CALL_DATE, String.valueOf(callDate));
mNote.setCallData(CallNote.PHONE_NUMBER, phoneNumber);
mNote.setNoteValue(NoteColumns.PARENT_ID, String.valueOf(Notes.ID_CALL_RECORD_FOLDER));
}
- // 判断是否有时钟题型
+
public boolean hasClockAlert() {
return (mAlertDate > 0 ? true : false);
}
- // 获取Content
+
public String getContent() {
return mContent;
}
- // 获取AlertDate
+
public long getAlertDate() {
return mAlertDate;
}
- // 获取ModifiedDate
+
public long getModifiedDate() {
return mModifiedDate;
}
- // 获取背景颜色来源id
+
public int getBgColorResId() {
return NoteBgResources.getNoteBgResource(mBgColorId);
}
- // 获取背景颜色id
+
public int getBgColorId() {
return mBgColorId;
}
- // 获取标题背景颜色id
+
public int getTitleBgResId() {
return NoteBgResources.getNoteTitleBgResource(mBgColorId);
}
- // 获取CheckListMode
+
public int getCheckListMode() {
return mMode;
}
- // 获取便签id
+
public long getNoteId() {
return mNoteId;
}
- // 获取文件夹id
+
public long getFolderId() {
return mFolderId;
}
- // 获取WidgetId
+
public int getWidgetId() {
return mWidgetId;
}
- // 获取WidgetType
+
public int getWidgetType() {
return mWidgetType;
}
- // 创建接口 NoteSettingChangedListener,便签更新监视
- // 为NoteEditActivity提供接口
- // 提供函数有
+
public interface NoteSettingChangedListener {
/**
* Called when the background color of current note has just changed
diff --git a/java/net/micode/notes/tool/BackupUtils.java b/java/net/micode/notes/tool/BackupUtils.java
index dbb04c1..39f6ec4 100644
--- a/java/net/micode/notes/tool/BackupUtils.java
+++ b/java/net/micode/notes/tool/BackupUtils.java
@@ -13,7 +13,7 @@
* See the License for the specific language governing permissions and
* limitations under the License.
*/
-//哈哈哈哈
+
package net.micode.notes.tool;
import android.content.Context;
@@ -39,15 +39,10 @@ import java.io.PrintStream;
public class BackupUtils {
private static final String TAG = "BackupUtils";
// Singleton stuff
- private static BackupUtils sInstance;//类里面为什么可以定义自身类的对象？
+ private static BackupUtils sInstance;
public static synchronized BackupUtils getInstance(Context context) {
- //ynchronized 关键字，代表这个方法加锁,相当于不管哪一个线程（例如线程A）
- //运行到这个方法时,都要检查有没有其它线程B（或者C、 D等）正在用这个方法(或者该类的其他同步方法)，有的话要等正在使用synchronized方法的线程B（或者C 、D）运行完这个方法后再运行此线程A,没有的话,锁定调用者,然后直接运行。
- //它包括两种用法：synchronized 方法和 synchronized 块。
-
if (sInstance == null) {
- //如果当前备份不存在，则新声明一个
sInstance = new BackupUtils(context);
}
return sInstance;
@@ -70,12 +65,10 @@ public class BackupUtils {
private TextExport mTextExport;
- //初始化函数
private BackupUtils(Context context) {
mTextExport = new TextExport(context);
}
- //外部存储功能是否可用
private static boolean externalStorageAvailable() {
return Environment.MEDIA_MOUNTED.equals(Environment.getExternalStorageState());
}
@@ -153,7 +146,7 @@ public class BackupUtils {
folderId
}, null);
- if (notesCursor != null) {//利用光标来扫描内容，区别为callnote和note两种，靠ps.printline输出
+ if (notesCursor != null) {
if (notesCursor.moveToFirst()) {
do {
// Print note's last modified date
@@ -225,7 +218,7 @@ public class BackupUtils {
/**
* Note will be exported as text which is user readable
*/
- public int exportToText() {//总函数，调用上面的exportFolder和exportNote
+ public int exportToText() {
if (!externalStorageAvailable()) {
Log.d(TAG, "Media was not mounted");
return STATE_SD_CARD_UNMOUONTED;
diff --git a/java/net/micode/notes/tool/DataUtils.java b/java/net/micode/notes/tool/DataUtils.java
index c184244..2a14982 100644
--- a/java/net/micode/notes/tool/DataUtils.java
+++ b/java/net/micode/notes/tool/DataUtils.java
@@ -52,13 +52,13 @@ public class DataUtils {
if(id == Notes.ID_ROOT_FOLDER) {
Log.e(TAG, "Don't delete system folder root");
continue;
- }//如果发现是根文件夹，则不删除
+ }
ContentProviderOperation.Builder builder = ContentProviderOperation
.newDelete(ContentUris.withAppendedId(Notes.CONTENT_NOTE_URI, id));
operationList.add(builder.build());
}
try {
- ContentProviderResult[] results = resolver.applyBatch(Notes.AUTHORITY, operationList); //数据库事务，数据库事务是由一组数据库操作序列组成，事务作为一个整体被执行
+ ContentProviderResult[] results = resolver.applyBatch(Notes.AUTHORITY, operationList);
if (results == null || results.length == 0 || results[0] == null) {
Log.d(TAG, "delete notes failed, ids:" + ids.toString());
return false;
diff --git a/java/net/micode/notes/ui/AlarmAlertActivity.java b/java/net/micode/notes/ui/AlarmAlertActivity.java
index 85723be..5bf372d 100644
--- a/java/net/micode/notes/ui/AlarmAlertActivity.java
+++ b/java/net/micode/notes/ui/AlarmAlertActivity.java
@@ -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.ui;
import android.app.Activity;
@@ -39,58 +23,81 @@ import net.micode.notes.tool.DataUtils;
import java.io.IOException;
-
public class AlarmAlertActivity extends Activity implements OnClickListener, OnDismissListener {
- private long mNoteId;
- private String mSnippet;
+ private long mNoteId; //文本在数据库存储中的ID号
+ private String mSnippet; //闹钟提示时出现的文本片段
private static final int SNIPPET_PREW_MAX_LEN = 60;
MediaPlayer mPlayer;
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
+ //Bundle类型的数据与Map类型的数据相似，都是以key-value的形式存储数据的
+ //onsaveInstanceState方法是用来保存Activity的状态的
+ //能从onCreate的参数savedInsanceState中获得状态数据
requestWindowFeature(Window.FEATURE_NO_TITLE);
+ //界面显示——无标题
final Window win = getWindow();
win.addFlags(WindowManager.LayoutParams.FLAG_SHOW_WHEN_LOCKED);
if (!isScreenOn()) {
win.addFlags(WindowManager.LayoutParams.FLAG_KEEP_SCREEN_ON
+ //保持窗体点亮
| WindowManager.LayoutParams.FLAG_TURN_SCREEN_ON
+ //将窗体点亮
| WindowManager.LayoutParams.FLAG_ALLOW_LOCK_WHILE_SCREEN_ON
+ //允许窗体点亮时锁屏
| WindowManager.LayoutParams.FLAG_LAYOUT_INSET_DECOR);
- }
+ }//在手机锁屏后如果到了闹钟提示时间，点亮屏幕
Intent intent = getIntent();
try {
mNoteId = Long.valueOf(intent.getData().getPathSegments().get(1));
mSnippet = DataUtils.getSnippetById(this.getContentResolver(), mNoteId);
+ //根据ID从数据库中获取标签的内容；
+ //getContentResolver（）是实现数据共享，实例存储。
mSnippet = mSnippet.length() > SNIPPET_PREW_MAX_LEN ? mSnippet.substring(0,
SNIPPET_PREW_MAX_LEN) + getResources().getString(R.string.notelist_string_info)
: mSnippet;
+ //判断标签片段是否达到符合长度
} catch (IllegalArgumentException e) {
e.printStackTrace();
return;
}
-
+ /*
+ try
+ {
+ // 代码区
+ }
+ catch(Exception e)
+ {
+ // 异常处理
+ }
+ 代码区如果有错误，就会返回所写异常的处理。*/
mPlayer = new MediaPlayer();
if (DataUtils.visibleInNoteDatabase(getContentResolver(), mNoteId, Notes.TYPE_NOTE)) {
showActionDialog();
+ //弹出对话框
playAlarmSound();
+ //闹钟提示音激发
} else {
finish();
+ //完成闹钟动作
}
}
private boolean isScreenOn() {
+ //判断屏幕是否锁屏，调用系统函数判断，最后返回值是布尔类型
PowerManager pm = (PowerManager) getSystemService(Context.POWER_SERVICE);
return pm.isScreenOn();
}
private void playAlarmSound() {
+ //闹钟提示音激发
Uri url = RingtoneManager.getActualDefaultRingtoneUri(this, RingtoneManager.TYPE_ALARM);
-
+ //调用系统的铃声管理URI，得到闹钟提示音
int silentModeStreams = Settings.System.getInt(getContentResolver(),
Settings.System.MODE_RINGER_STREAMS_AFFECTED, 0);
@@ -101,12 +108,19 @@ public class AlarmAlertActivity extends Activity implements OnClickListener, OnD
}
try {
mPlayer.setDataSource(this, url);
+ //方法：setDataSource(Context context, Uri uri)
+ //解释：无返回值，设置多媒体数据来源【根据 Uri】
mPlayer.prepare();
+ //准备同步
mPlayer.setLooping(true);
+ //设置是否循环播放
mPlayer.start();
+ //开始播放
} catch (IllegalArgumentException e) {
// TODO Auto-generated catch block
e.printStackTrace();
+ //e.printStackTrace()函数功能是抛出异常， 还将显示出更深的调用信息
+ //System.out.println(e)，这个方法打印出异常，并且输出在哪里出现的异常
} catch (SecurityException e) {
// TODO Auto-generated catch block
e.printStackTrace();
@@ -121,38 +135,58 @@ public class AlarmAlertActivity extends Activity implements OnClickListener, OnD
private void showActionDialog() {
AlertDialog.Builder dialog = new AlertDialog.Builder(this);
+ //AlertDialog的构造方法全部是Protected的
+ //所以不能直接通过new一个AlertDialog来创建出一个AlertDialog。
+ //要创建一个AlertDialog，就要用到AlertDialog.Builder中的create()方法
+ //如这里的dialog就是新建了一个AlertDialog
dialog.setTitle(R.string.app_name);
+ //为对话框设置标题
dialog.setMessage(mSnippet);
+ //为对话框设置内容
dialog.setPositiveButton(R.string.notealert_ok, this);
+ //给对话框添加"Yes"按钮
if (isScreenOn()) {
dialog.setNegativeButton(R.string.notealert_enter, this);
- }
+ }//对话框添加"No"按钮
dialog.show().setOnDismissListener(this);
}
public void onClick(DialogInterface dialog, int which) {
switch (which) {
+ //用which来选择click后下一步的操作
case DialogInterface.BUTTON_NEGATIVE:
+ //这是取消操作
Intent intent = new Intent(this, NoteEditActivity.class);
+ //实现两个类间的数据传输
intent.setAction(Intent.ACTION_VIEW);
+ //设置动作属性
intent.putExtra(Intent.EXTRA_UID, mNoteId);
+ //实现key-value对
+ //EXTRA_UID为key；mNoteId为键
startActivity(intent);
+ //开始动作
break;
default:
+ //这是确定操作
break;
}
}
public void onDismiss(DialogInterface dialog) {
+ //忽略
stopAlarmSound();
+ //停止闹钟声音
finish();
+ //完成该动作
}
private void stopAlarmSound() {
if (mPlayer != null) {
mPlayer.stop();
+ //停止播放
mPlayer.release();
+ //释放MediaPlayer对象
mPlayer = null;
}
}
-}
+}
\ No newline at end of file
diff --git a/java/net/micode/notes/ui/AlarmInitReceiver.java b/java/net/micode/notes/ui/AlarmInitReceiver.java
index f221202..4163ccd 100644
--- a/java/net/micode/notes/ui/AlarmInitReceiver.java
+++ b/java/net/micode/notes/ui/AlarmInitReceiver.java
@@ -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.ui;
import android.app.AlarmManager;
@@ -31,21 +15,25 @@ import net.micode.notes.data.Notes.NoteColumns;
public class AlarmInitReceiver extends BroadcastReceiver {
private static final String [] PROJECTION = new String [] {
- NoteColumns.ID,
- NoteColumns.ALERTED_DATE
+ NoteColumns.ID,
+ NoteColumns.ALERTED_DATE
};
-
+ //对数据库的操作，调用标签ID和闹钟时间
private static final int COLUMN_ID = 0;
private static final int COLUMN_ALERTED_DATE = 1;
@Override
public void onReceive(Context context, Intent intent) {
long currentDate = System.currentTimeMillis();
+ //System.currentTimeMillis()产生一个当前的毫秒
+ //这个毫秒其实就是自1970年1月1日0时起的毫秒数
Cursor c = context.getContentResolver().query(Notes.CONTENT_NOTE_URI,
PROJECTION,
NoteColumns.ALERTED_DATE + ">? AND " + NoteColumns.TYPE + "=" + Notes.TYPE_NOTE,
new String[] { String.valueOf(currentDate) },
+ //将long变量currentDate转化为字符串
null);
+ //Cursor在这里的作用是通过查找数据库中的标签内容，找到和当前系统时间相等的标签
if (c != null) {
if (c.moveToFirst()) {
@@ -61,5 +49,8 @@ public class AlarmInitReceiver extends BroadcastReceiver {
}
c.close();
}
+ //然而通过网上查找资料发现，对于闹钟机制的启动，通常需要上面的几个步骤
+ //如新建Intent、PendingIntent以及AlarmManager等
+ //这里就是根据数据库里的闹钟时间创建一个闹钟机制
}
-}
+}
\ No newline at end of file
diff --git a/java/net/micode/notes/ui/AlarmReceiver.java b/java/net/micode/notes/ui/AlarmReceiver.java
index 54e503b..6e22aff 100644
--- a/java/net/micode/notes/ui/AlarmReceiver.java
+++ b/java/net/micode/notes/ui/AlarmReceiver.java
@@ -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.ui;
import android.content.BroadcastReceiver;
@@ -24,7 +8,13 @@ public class AlarmReceiver extends BroadcastReceiver {
@Override
public void onReceive(Context context, Intent intent) {
intent.setClass(context, AlarmAlertActivity.class);
+ //启动AlarmAlertActivity
intent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
+ //activity要存在于activity的栈中，而非activity的途径启动activity时必然不存在一个activity的栈
+ //所以要新起一个栈装入启动的activity
context.startActivity(intent);
}
}
+//这是实现alarm这个功能最接近用户层的包，基于上面的两个包，
+//作用还需要深究但是对于setClass和addFlags的
+
\ No newline at end of file
diff --git a/java/net/micode/notes/ui/DateTimePicker.java b/java/net/micode/notes/ui/DateTimePicker.java
index 496b0cd..8d74062 100644
--- a/java/net/micode/notes/ui/DateTimePicker.java
+++ b/java/net/micode/notes/ui/DateTimePicker.java
@@ -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.ui;
import java.text.DateFormatSymbols;
@@ -29,7 +13,8 @@ import android.widget.FrameLayout;
import android.widget.NumberPicker;
public class DateTimePicker extends FrameLayout {
-
+ //FrameLayout是布局模板之一
+ //所有的子元素全部在屏幕的右上方
private static final boolean DEFAULT_ENABLE_STATE = true;
private static final int HOURS_IN_HALF_DAY = 12;
@@ -45,13 +30,15 @@ public class DateTimePicker extends FrameLayout {
private static final int MINUT_SPINNER_MAX_VAL = 59;
private static final int AMPM_SPINNER_MIN_VAL = 0;
private static final int AMPM_SPINNER_MAX_VAL = 1;
-
+ //初始化控件
private final NumberPicker mDateSpinner;
private final NumberPicker mHourSpinner;
private final NumberPicker mMinuteSpinner;
private final NumberPicker mAmPmSpinner;
+ //NumberPicker是数字选择器
+ //这里定义的四个变量全部是在设置闹钟时需要选择的变量（如日期、时、分、上午或者下午）
private Calendar mDate;
-
+ //定义了Calendar类型的变量mDate，用于操作时间
private String[] mDateDisplayValues = new String[DAYS_IN_ALL_WEEK];
private boolean mIsAm;
@@ -71,41 +58,49 @@ public class DateTimePicker extends FrameLayout {
updateDateControl();
onDateTimeChanged();
}
- };
+ };//OnValueChangeListener，这是时间改变监听器，这里主要是对日期的监听
+ //将现在日期的值传递给mDate；updateDateControl是同步操作
private NumberPicker.OnValueChangeListener mOnHourChangedListener = new NumberPicker.OnValueChangeListener() {
+ //这里是对 小时（Hour） 的监听
@Override
public void onValueChange(NumberPicker picker, int oldVal, int newVal) {
boolean isDateChanged = false;
Calendar cal = Calendar.getInstance();
+ //声明一个Calendar的变量cal，便于后续的操作
if (!mIs24HourView) {
if (!mIsAm && oldVal == HOURS_IN_HALF_DAY - 1 && newVal == HOURS_IN_HALF_DAY) {
cal.setTimeInMillis(mDate.getTimeInMillis());
cal.add(Calendar.DAY_OF_YEAR, 1);
isDateChanged = true;
+ //这里是对于12小时制时，晚上11点和12点交替时对日期的更改
} else if (mIsAm && oldVal == HOURS_IN_HALF_DAY && newVal == HOURS_IN_HALF_DAY - 1) {
cal.setTimeInMillis(mDate.getTimeInMillis());
cal.add(Calendar.DAY_OF_YEAR, -1);
isDateChanged = true;
}
+ //这里是对于12小时制时，凌晨11点和12点交替时对日期的更改
if (oldVal == HOURS_IN_HALF_DAY - 1 && newVal == HOURS_IN_HALF_DAY ||
oldVal == HOURS_IN_HALF_DAY && newVal == HOURS_IN_HALF_DAY - 1) {
mIsAm = !mIsAm;
updateAmPmControl();
- }
+ }//这里是对于12小时制时，中午11点和12点交替时对AM和PM的更改
} else {
if (oldVal == HOURS_IN_ALL_DAY - 1 && newVal == 0) {
cal.setTimeInMillis(mDate.getTimeInMillis());
cal.add(Calendar.DAY_OF_YEAR, 1);
isDateChanged = true;
+ //这里是对于24小时制时，晚上11点和12点交替时对日期的更改
} else if (oldVal == 0 && newVal == HOURS_IN_ALL_DAY - 1) {
cal.setTimeInMillis(mDate.getTimeInMillis());
cal.add(Calendar.DAY_OF_YEAR, -1);
isDateChanged = true;
}
- }
+ } //这里是对于12小时制时，凌晨11点和12点交替时对日期的更改
int newHour = mHourSpinner.getValue() % HOURS_IN_HALF_DAY + (mIsAm ? 0 : HOURS_IN_HALF_DAY);
+ //通过数字选择器对newHour的赋值
mDate.set(Calendar.HOUR_OF_DAY, newHour);
+ //通过set函数将新的Hour值传给mDate
onDateTimeChanged();
if (isDateChanged) {
setCurrentYear(cal.get(Calendar.YEAR));
@@ -117,15 +112,19 @@ public class DateTimePicker extends FrameLayout {
private NumberPicker.OnValueChangeListener mOnMinuteChangedListener = new NumberPicker.OnValueChangeListener() {
@Override
+ //这里是对 分钟（Minute）改变的监听
public void onValueChange(NumberPicker picker, int oldVal, int newVal) {
int minValue = mMinuteSpinner.getMinValue();
int maxValue = mMinuteSpinner.getMaxValue();
int offset = 0;
+ //设置offset，作为小时改变的一个记录数据
if (oldVal == maxValue && newVal == minValue) {
offset += 1;
} else if (oldVal == minValue && newVal == maxValue) {
offset -= 1;
}
+ //如果原值为59，新值为0，则offset加1
+ //如果原值为0，新值为59，则offset减1
if (offset != 0) {
mDate.add(Calendar.HOUR_OF_DAY, offset);
mHourSpinner.setValue(getCurrentHour());
@@ -145,6 +144,7 @@ public class DateTimePicker extends FrameLayout {
};
private NumberPicker.OnValueChangeListener mOnAmPmChangedListener = new NumberPicker.OnValueChangeListener() {
+ //对AM和PM的监听
@Override
public void onValueChange(NumberPicker picker, int oldVal, int newVal) {
mIsAm = !mIsAm;
@@ -160,24 +160,27 @@ public class DateTimePicker extends FrameLayout {
public interface OnDateTimeChangedListener {
void onDateTimeChanged(DateTimePicker view, int year, int month,
- int dayOfMonth, int hourOfDay, int minute);
+ int dayOfMonth, int hourOfDay, int minute);
}
public DateTimePicker(Context context) {
this(context, System.currentTimeMillis());
- }
+ }//通过对数据库的访问，获取当前的系统时间
public DateTimePicker(Context context, long date) {
this(context, date, DateFormat.is24HourFormat(context));
- }
+ }//上面函数的得到的是一个天文数字（1970至今的秒数），需要DateFormat将其变得有意义
public DateTimePicker(Context context, long date, boolean is24HourView) {
super(context);
+ //获取系统时间
mDate = Calendar.getInstance();
mInitialising = true;
mIsAm = getCurrentHourOfDay() >= HOURS_IN_HALF_DAY;
inflate(context, R.layout.datetime_picker, this);
-
+ //如果当前Activity里用到别的layout，比如对话框layout
+ //还要设置这个layout上的其他组件的内容，就必须用inflate()方法先将对话框的layout找出来
+ //然后再用findViewById()找到它上面的其它组件
mDateSpinner = (NumberPicker) findViewById(R.id.date);
mDateSpinner.setMinValue(DATE_SPINNER_MIN_VAL);
mDateSpinner.setMaxValue(DATE_SPINNER_MAX_VAL);
@@ -185,7 +188,7 @@ public class DateTimePicker extends FrameLayout {
mHourSpinner = (NumberPicker) findViewById(R.id.hour);
mHourSpinner.setOnValueChangedListener(mOnHourChangedListener);
- mMinuteSpinner = (NumberPicker) findViewById(R.id.minute);
+ mMinuteSpinner = (NumberPicker) findViewById(R.id.minute);
mMinuteSpinner.setMinValue(MINUT_SPINNER_MIN_VAL);
mMinuteSpinner.setMaxValue(MINUT_SPINNER_MAX_VAL);
mMinuteSpinner.setOnLongPressUpdateInterval(100);
@@ -226,7 +229,9 @@ public class DateTimePicker extends FrameLayout {
mAmPmSpinner.setEnabled(enabled);
mIsEnabled = enabled;
}
-
+ //存在疑问！！！！！！！！！！！！！setEnabled的作用
+ //下面的代码通过原程序的注释已经比较清晰，另外可以通过函数名来判断
+ //下面的各函数主要是对上面代码引用到的各函数功能的实现
@Override
public boolean isEnabled() {
return mIsEnabled;
@@ -239,7 +244,7 @@ public class DateTimePicker extends FrameLayout {
*/
public long getCurrentDateInTimeMillis() {
return mDate.getTimeInMillis();
- }
+ }//实现函数——得到当前的秒数
/**
* Set the current date
@@ -251,7 +256,7 @@ public class DateTimePicker extends FrameLayout {
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));
- }
+ }//实现函数功能——设置当前的时间，参数是date
/**
* Set the current date
@@ -263,19 +268,20 @@ public class DateTimePicker extends FrameLayout {
* @param minute The current minute
*/
public void setCurrentDate(int year, int month,
- int dayOfMonth, int hourOfDay, int minute) {
+ int dayOfMonth, int hourOfDay, int minute) {
setCurrentYear(year);
setCurrentMonth(month);
setCurrentDay(dayOfMonth);
setCurrentHour(hourOfDay);
setCurrentMinute(minute);
- }
+ }//实现函数功能——设置当前的时间，参数是各详细的变量
/**
* Get current year
*
* @return The current year
*/
+ //下面是得到year、month、day等值
public int getCurrentYear() {
return mDate.get(Calendar.YEAR);
}
@@ -446,7 +452,7 @@ public class DateTimePicker extends FrameLayout {
mDateSpinner.setDisplayedValues(mDateDisplayValues);
mDateSpinner.setValue(DAYS_IN_ALL_WEEK / 2);
mDateSpinner.invalidate();
- }
+ }// 对于星期几的算法
private void updateAmPmControl() {
if (mIs24HourView) {
@@ -455,7 +461,7 @@ public class DateTimePicker extends FrameLayout {
int index = mIsAm ? Calendar.AM : Calendar.PM;
mAmPmSpinner.setValue(index);
mAmPmSpinner.setVisibility(View.VISIBLE);
- }
+ }// 对于上下午操作的算法
}
private void updateHourControl() {
@@ -465,7 +471,7 @@ public class DateTimePicker extends FrameLayout {
} else {
mHourSpinner.setMinValue(HOUR_SPINNER_MIN_VAL_12_HOUR_VIEW);
mHourSpinner.setMaxValue(HOUR_SPINNER_MAX_VAL_12_HOUR_VIEW);
- }
+ }// 对与小时的算法
}
/**
@@ -482,4 +488,4 @@ public class DateTimePicker extends FrameLayout {
getCurrentMonth(), getCurrentDay(), getCurrentHourOfDay(), getCurrentMinute());
}
}
-}
+}
\ No newline at end of file
diff --git a/java/net/micode/notes/ui/DateTimePickerDialog.java b/java/net/micode/notes/ui/DateTimePickerDialog.java
index 2c47ba4..d6ad95e 100644
--- a/java/net/micode/notes/ui/DateTimePickerDialog.java
+++ b/java/net/micode/notes/ui/DateTimePickerDialog.java
@@ -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.ui;
import java.util.Calendar;
@@ -32,35 +16,47 @@ import android.text.format.DateUtils;
public class DateTimePickerDialog extends AlertDialog implements OnClickListener {
private Calendar mDate = Calendar.getInstance();
+ //创建一个Calendar类型的变量 mDate，方便时间的操作
private boolean mIs24HourView;
private OnDateTimeSetListener mOnDateTimeSetListener;
+ //声明一个时间日期滚动选择控件 mOnDateTimeSetListener
private DateTimePicker mDateTimePicker;
+ //DateTimePicker控件，控件一般用于让用户可以从日期列表中选择单个值。
+ //运行时，单击控件边上的下拉箭头，会显示为两个部分：一个下拉列表，一个用于选择日期的
public interface OnDateTimeSetListener {
void OnDateTimeSet(AlertDialog dialog, long date);
}
public DateTimePickerDialog(Context context, long date) {
+ //对该界面对话框的实例化
super(context);
+ //对数据库的操作
mDateTimePicker = new DateTimePicker(context);
setView(mDateTimePicker);
+ //添加一个子视图
mDateTimePicker.setOnDateTimeChangedListener(new OnDateTimeChangedListener() {
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.MONTH, month);
mDate.set(Calendar.DAY_OF_MONTH, dayOfMonth);
mDate.set(Calendar.HOUR_OF_DAY, hourOfDay);
mDate.set(Calendar.MINUTE, minute);
+ //将视图中的各选项设置为系统当前时间
updateTitle(mDate.getTimeInMillis());
}
});
mDate.setTimeInMillis(date);
+ //得到系统时间
mDate.set(Calendar.SECOND, 0);
+ //将秒数设置为0
mDateTimePicker.setCurrentDate(mDate.getTimeInMillis());
setButton(context.getString(R.string.datetime_dialog_ok), this);
setButton2(context.getString(R.string.datetime_dialog_cancel), (OnClickListener)null);
+ //设置按钮
set24HourView(DateFormat.is24HourFormat(this.getContext()));
+ //时间标准化打印
updateTitle(mDate.getTimeInMillis());
}
@@ -70,21 +66,22 @@ public class DateTimePickerDialog extends AlertDialog implements OnClickListener
public void setOnDateTimeSetListener(OnDateTimeSetListener callBack) {
mOnDateTimeSetListener = callBack;
- }
+ }//将时间日期滚动选择控件实例化
private void updateTitle(long date) {
int flag =
- DateUtils.FORMAT_SHOW_YEAR |
- DateUtils.FORMAT_SHOW_DATE |
- DateUtils.FORMAT_SHOW_TIME;
+ DateUtils.FORMAT_SHOW_YEAR |
+ DateUtils.FORMAT_SHOW_DATE |
+ DateUtils.FORMAT_SHOW_TIME;
flag |= mIs24HourView ? DateUtils.FORMAT_24HOUR : DateUtils.FORMAT_24HOUR;
setTitle(DateUtils.formatDateTime(this.getContext(), date, flag));
- }
+ }//android开发中常见日期管理工具类（API）——DateUtils：按照上下午显示时间
public void onClick(DialogInterface arg0, int arg1) {
if (mOnDateTimeSetListener != null) {
mOnDateTimeSetListener.OnDateTimeSet(this, mDate.getTimeInMillis());
}
- }
+ }//第一个参数arg0是接收到点击事件的对话框
+ //第二个参数arg1是该对话框上的按钮
}
\ No newline at end of file
diff --git a/java/net/micode/notes/ui/DropdownMenu.java b/java/net/micode/notes/ui/DropdownMenu.java
index 613dc74..c831a9b 100644
--- a/java/net/micode/notes/ui/DropdownMenu.java
+++ b/java/net/micode/notes/ui/DropdownMenu.java
@@ -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.ui;
import android.content.Context;
@@ -30,14 +14,18 @@ import net.micode.notes.R;
public class DropdownMenu {
private Button mButton;
private PopupMenu mPopupMenu;
+ //声明一个下拉菜单
private Menu mMenu;
public DropdownMenu(Context context, Button button, int menuId) {
mButton = button;
mButton.setBackgroundResource(R.drawable.dropdown_icon);
+ //设置这个view的背景
mPopupMenu = new PopupMenu(context, mButton);
mMenu = mPopupMenu.getMenu();
mPopupMenu.getMenuInflater().inflate(menuId, mMenu);
+ //MenuInflater是用来实例化Menu目录下的Menu布局文件
+ //根据ID来确认menu的内容选项
mButton.setOnClickListener(new OnClickListener() {
public void onClick(View v) {
mPopupMenu.show();
@@ -48,14 +36,14 @@ public class DropdownMenu {
public void setOnDropdownMenuItemClickListener(OnMenuItemClickListener listener) {
if (mPopupMenu != null) {
mPopupMenu.setOnMenuItemClickListener(listener);
- }
+ }//设置菜单的监听
}
public MenuItem findItem(int id) {
return mMenu.findItem(id);
- }
+ }//对于菜单选项的初始化，根据索引搜索菜单需要的选项
public void setTitle(CharSequence title) {
mButton.setText(title);
- }
-}
+ }//布局文件，设置标题
+}
\ No newline at end of file
diff --git a/java/net/micode/notes/ui/FoldersListAdapter.java b/java/net/micode/notes/ui/FoldersListAdapter.java
index 96b77da..b6867fb 100644
--- a/java/net/micode/notes/ui/FoldersListAdapter.java
+++ b/java/net/micode/notes/ui/FoldersListAdapter.java
@@ -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.ui;
import android.content.Context;
@@ -30,10 +14,14 @@ import net.micode.notes.data.Notes.NoteColumns;
public class FoldersListAdapter extends CursorAdapter {
+ //CursorAdapter是Cursor和ListView的接口
+ //FoldersListAdapter继承了CursorAdapter的类
+ //主要作用是便签数据库和用户的交互
+ //这里就是用folder（文件夹）的形式展现给用户
public static final String [] PROJECTION = {
- NoteColumns.ID,
- NoteColumns.SNIPPET
- };
+ NoteColumns.ID,
+ NoteColumns.SNIPPET
+ };//调用数据库中便签的ID和片段
public static final int ID_COLUMN = 0;
public static final int NAME_COLUMN = 1;
@@ -41,12 +29,13 @@ public class FoldersListAdapter extends CursorAdapter {
public FoldersListAdapter(Context context, Cursor c) {
super(context, c);
// TODO Auto-generated constructor stub
- }
+ }//数据库操作
@Override
public View newView(Context context, Cursor cursor, ViewGroup parent) {
+ //ViewGroup是容器
return new FolderListItem(context);
- }
+ }//创建一个文件夹，对于各文件夹中子标签的初始化
@Override
public void bindView(View view, Context context, Cursor cursor) {
@@ -55,20 +44,22 @@ public class FoldersListAdapter extends CursorAdapter {
.getString(R.string.menu_move_parent_folder) : cursor.getString(NAME_COLUMN);
((FolderListItem) view).bind(folderName);
}
- }
+ }//将各个布局文件绑定起来
public String getFolderName(Context context, int position) {
Cursor cursor = (Cursor) getItem(position);
return (cursor.getLong(ID_COLUMN) == Notes.ID_ROOT_FOLDER) ? context
.getString(R.string.menu_move_parent_folder) : cursor.getString(NAME_COLUMN);
- }
+ }//根据数据库中标签的ID得到标签的各项内容
private class FolderListItem extends LinearLayout {
private TextView mName;
public FolderListItem(Context context) {
super(context);
+ //操作数据库
inflate(context, R.layout.folder_list_item, this);
+ //根据布局文件的名字等信息将其找出来
mName = (TextView) findViewById(R.id.tv_folder_name);
}
@@ -77,4 +68,4 @@ public class FoldersListAdapter extends CursorAdapter {
}
}
-}
+}
\ No newline at end of file
diff --git a/java/net/micode/notes/ui/NoteEditActivity.java b/java/net/micode/notes/ui/NoteEditActivity.java
index 96a9ff8..0faa62e 100644
--- a/java/net/micode/notes/ui/NoteEditActivity.java
+++ b/java/net/micode/notes/ui/NoteEditActivity.java
@@ -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.ui;
import android.app.Activity;
@@ -74,6 +58,8 @@ import java.util.regex.Pattern;
public class NoteEditActivity extends Activity implements OnClickListener,
NoteSettingChangedListener, OnTextViewChangeListener {
+ //该类主要是针对标签的编辑
+ //继承了系统内部许多和监听有关的类
private class HeadViewHolder {
public TextView tvModified;
@@ -83,7 +69,7 @@ public class NoteEditActivity extends Activity implements OnClickListener,
public ImageView ibSetBgColor;
}
-
+ //使用Map实现数据存储
private static final Map sBgSelectorBtnsMap = new HashMap();
static {
sBgSelectorBtnsMap.put(R.id.iv_bg_yellow, ResourceParser.YELLOW);
@@ -91,6 +77,7 @@ public class NoteEditActivity extends Activity implements OnClickListener,
sBgSelectorBtnsMap.put(R.id.iv_bg_blue, ResourceParser.BLUE);
sBgSelectorBtnsMap.put(R.id.iv_bg_green, ResourceParser.GREEN);
sBgSelectorBtnsMap.put(R.id.iv_bg_white, ResourceParser.WHITE);
+ //put函数是将指定值和指定键相连
}
private static final Map sBgSelectorSelectionMap = new HashMap();
@@ -100,6 +87,7 @@ public class NoteEditActivity extends Activity implements OnClickListener,
sBgSelectorSelectionMap.put(ResourceParser.BLUE, R.id.iv_bg_blue_select);
sBgSelectorSelectionMap.put(ResourceParser.GREEN, R.id.iv_bg_green_select);
sBgSelectorSelectionMap.put(ResourceParser.WHITE, R.id.iv_bg_white_select);
+ //put函数是将指定值和指定键相连
}
private static final Map sFontSizeBtnsMap = new HashMap();
@@ -108,6 +96,7 @@ public class NoteEditActivity extends Activity implements OnClickListener,
sFontSizeBtnsMap.put(R.id.ll_font_small, ResourceParser.TEXT_SMALL);
sFontSizeBtnsMap.put(R.id.ll_font_normal, ResourceParser.TEXT_MEDIUM);
sFontSizeBtnsMap.put(R.id.ll_font_super, ResourceParser.TEXT_SUPER);
+ //put函数是将指定值和指定键相连
}
private static final Map sFontSelectorSelectionMap = new HashMap();
@@ -116,6 +105,7 @@ public class NoteEditActivity extends Activity implements OnClickListener,
sFontSelectorSelectionMap.put(ResourceParser.TEXT_SMALL, R.id.iv_small_select);
sFontSelectorSelectionMap.put(ResourceParser.TEXT_MEDIUM, R.id.iv_medium_select);
sFontSelectorSelectionMap.put(ResourceParser.TEXT_SUPER, R.id.iv_super_select);
+ //put函数是将指定值和指定键相连
}
private static final String TAG = "NoteEditActivity";
@@ -123,20 +113,23 @@ public class NoteEditActivity extends Activity implements OnClickListener,
private HeadViewHolder mNoteHeaderHolder;
private View mHeadViewPanel;
-
+ //私有化一个界面操作mHeadViewPanel，对表头的操作
private View mNoteBgColorSelector;
-
+ //私有化一个界面操作mNoteBgColorSelector，对背景颜色的操作
private View mFontSizeSelector;
-
+ //私有化一个界面操作mFontSizeSelector，对标签字体的操作
private EditText mNoteEditor;
-
+ //声明编辑控件，对文本操作
private View mNoteEditorPanel;
-
- private WorkingNote mWorkingNote;
-
+ //私有化一个界面操作mNoteEditorPanel，文本编辑的控制板
+ //private WorkingNote mWorkingNote;
+ public WorkingNote mWorkingNote;
+ //对模板WorkingNote的初始化
private SharedPreferences mSharedPrefs;
+ //私有化SharedPreferences的数据存储方式
+ //它的本质是基于XML文件存储key-value键值对数据
private int mFontSizeId;
-
+ //用于操作字体的大小
private static final String PREFERENCE_FONT_SIZE = "pref_font_size";
private static final int SHORTCUT_ICON_TITLE_MAX_LEN = 10;
@@ -145,7 +138,7 @@ public class NoteEditActivity extends Activity implements OnClickListener,
public static final String TAG_UNCHECKED = String.valueOf('\u25A1');
private LinearLayout mEditTextList;
-
+ //线性布局
private String mUserQuery;
private Pattern mPattern;
@@ -153,7 +146,7 @@ public class NoteEditActivity extends Activity implements OnClickListener,
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
this.setContentView(R.layout.note_edit);
-
+ //对数据库的访问操作
if (savedInstanceState == null && !initActivityState(getIntent())) {
finish();
return;
@@ -176,7 +169,7 @@ public class NoteEditActivity extends Activity implements OnClickListener,
return;
}
Log.d(TAG, "Restoring from killed activity");
- }
+ }//为防止内存不足时程序的终止，在这里有一个保存现场的函数
}
private boolean initActivityState(Intent intent) {
@@ -188,34 +181,42 @@ public class NoteEditActivity extends Activity implements OnClickListener,
if (TextUtils.equals(Intent.ACTION_VIEW, intent.getAction())) {
long noteId = intent.getLongExtra(Intent.EXTRA_UID, 0);
mUserQuery = "";
-
+ //如果用户实例化标签时，系统并未给出标签ID
/**
* Starting from the searched result
*/
+ //根据键值查找ID
if (intent.hasExtra(SearchManager.EXTRA_DATA_KEY)) {
noteId = Long.parseLong(intent.getStringExtra(SearchManager.EXTRA_DATA_KEY));
mUserQuery = intent.getStringExtra(SearchManager.USER_QUERY);
}
-
+ //如果ID在数据库中未找到
if (!DataUtils.visibleInNoteDatabase(getContentResolver(), noteId, Notes.TYPE_NOTE)) {
Intent jump = new Intent(this, NotesListActivity.class);
startActivity(jump);
+ //程序将跳转到上面声明的intent——jump
showToast(R.string.error_note_not_exist);
finish();
return false;
- } else {
+ }
+ //ID在数据库中找到
+ else {
mWorkingNote = WorkingNote.load(this, noteId);
if (mWorkingNote == null) {
Log.e(TAG, "load note failed with note id" + noteId);
+ //打印出红色的错误信息
finish();
return false;
}
}
+ //setSoftInputMode——软键盘输入模式
getWindow().setSoftInputMode(
WindowManager.LayoutParams.SOFT_INPUT_STATE_HIDDEN
| WindowManager.LayoutParams.SOFT_INPUT_ADJUST_RESIZE);
} else if(TextUtils.equals(Intent.ACTION_INSERT_OR_EDIT, intent.getAction())) {
- // New note
+ // intent.getAction()
+ // 大多用于broadcast发送广播时给机制（intent）设置一个action，就是一个字符串
+ // 用户可以通过receive（接受）intent，通过 getAction得到的字符串，来决定做什么
long folderId = intent.getLongExtra(Notes.INTENT_EXTRA_FOLDER_ID, 0);
int widgetId = intent.getIntExtra(Notes.INTENT_EXTRA_WIDGET_ID,
AppWidgetManager.INVALID_APPWIDGET_ID);
@@ -223,7 +224,7 @@ public class NoteEditActivity extends Activity implements OnClickListener,
Notes.TYPE_WIDGET_INVALIDE);
int bgResId = intent.getIntExtra(Notes.INTENT_EXTRA_BACKGROUND_ID,
ResourceParser.getDefaultBgId(this));
-
+ // intent.getInt（Long、String）Extra是对各变量的语法分析
// Parse call-record note
String phoneNumber = intent.getStringExtra(Intent.EXTRA_PHONE_NUMBER);
long callDate = intent.getLongExtra(Notes.INTENT_EXTRA_CALL_DATE, 0);
@@ -240,15 +241,17 @@ public class NoteEditActivity extends Activity implements OnClickListener,
finish();
return false;
}
+ //将电话号码与手机的号码簿相关
} else {
mWorkingNote = WorkingNote.createEmptyNote(this, folderId, widgetId,
widgetType, bgResId);
mWorkingNote.convertToCallNote(phoneNumber, callDate);
+ //
}
} else {
mWorkingNote = WorkingNote.createEmptyNote(this, folderId, widgetId, widgetType,
bgResId);
- }
+ }//创建一个新的WorkingNote
getWindow().setSoftInputMode(
WindowManager.LayoutParams.SOFT_INPUT_ADJUST_RESIZE
@@ -269,8 +272,10 @@ public class NoteEditActivity extends Activity implements OnClickListener,
}
private void initNoteScreen() {
+ //对界面的初始化操作
mNoteEditor.setTextAppearance(this, TextAppearanceResources
.getTexAppearanceResource(mFontSizeId));
+ //设置外观
if (mWorkingNote.getCheckListMode() == TextNote.MODE_CHECK_LIST) {
switchToListMode(mWorkingNote.getContent());
} else {
@@ -294,18 +299,21 @@ public class NoteEditActivity extends Activity implements OnClickListener,
*/
showAlertHeader();
}
-
+ //设置闹钟的显示
private void showAlertHeader() {
if (mWorkingNote.hasClockAlert()) {
long time = System.currentTimeMillis();
if (time > mWorkingNote.getAlertDate()) {
mNoteHeaderHolder.tvAlertDate.setText(R.string.note_alert_expired);
- } else {
+ }
+ //如果系统时间大于了闹钟设置的时间，那么闹钟失效
+ else {
mNoteHeaderHolder.tvAlertDate.setText(DateUtils.getRelativeTimeSpanString(
mWorkingNote.getAlertDate(), time, DateUtils.MINUTE_IN_MILLIS));
}
mNoteHeaderHolder.tvAlertDate.setVisibility(View.VISIBLE);
mNoteHeaderHolder.ivAlertIcon.setVisibility(View.VISIBLE);
+ //显示闹钟开启的图标
} else {
mNoteHeaderHolder.tvAlertDate.setVisibility(View.GONE);
mNoteHeaderHolder.ivAlertIcon.setVisibility(View.GONE);
@@ -329,26 +337,29 @@ public class NoteEditActivity extends Activity implements OnClickListener,
if (!mWorkingNote.existInDatabase()) {
saveNote();
}
+ //在创建一个新的标签时，先在数据库中匹配
+ //如果不存在，那么先在数据库中存储
outState.putLong(Intent.EXTRA_UID, mWorkingNote.getNoteId());
Log.d(TAG, "Save working note id: " + mWorkingNote.getNoteId() + " onSaveInstanceState");
}
@Override
+ //MotionEvent是对屏幕触控的传递机制
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);
@@ -357,9 +368,11 @@ public class NoteEditActivity extends Activity implements OnClickListener,
if (ev.getX() < x
|| ev.getX() > (x + view.getWidth())
|| ev.getY() < y
- || ev.getY() > (y + view.getHeight())) {
- return false;
- }
+ || ev.getY() > (y + view.getHeight()))
+ //如果触控的位置超出了给定的范围，返回false
+ {
+ return false;
+ }
return true;
}
@@ -377,13 +390,13 @@ public class NoteEditActivity extends Activity implements OnClickListener,
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);
/**
@@ -405,7 +418,7 @@ public class NoteEditActivity extends Activity implements OnClickListener,
}
clearSettingState();
}
-
+ //和桌面小工具的同步
private void updateWidget() {
Intent intent = new Intent(AppWidgetManager.ACTION_APPWIDGET_UPDATE);
if (mWorkingNote.getWidgetType() == Notes.TYPE_WIDGET_2X) {
@@ -418,7 +431,7 @@ public class NoteEditActivity extends Activity implements OnClickListener,
}
intent.putExtra(AppWidgetManager.EXTRA_APPWIDGET_IDS, new int[] {
- mWorkingNote.getWidgetId()
+ mWorkingNote.getWidgetId()
});
sendBroadcast(intent);
@@ -450,7 +463,7 @@ public class NoteEditActivity extends Activity implements OnClickListener,
}
mFontSizeSelector.setVisibility(View.GONE);
}
- }
+ }//************************存在问题
@Override
public void onBackPressed() {
@@ -481,6 +494,7 @@ public class NoteEditActivity extends Activity implements OnClickListener,
}
@Override
+ //对选择菜单的准备
public boolean onPrepareOptionsMenu(Menu menu) {
if (isFinishing()) {
return true;
@@ -489,6 +503,7 @@ public class NoteEditActivity extends Activity implements OnClickListener,
menu.clear();
if (mWorkingNote.getFolderId() == Notes.ID_CALL_RECORD_FOLDER) {
getMenuInflater().inflate(R.menu.call_note_edit, menu);
+ // MenuInflater是用来实例化Menu目录下的Menu布局文件的
} else {
getMenuInflater().inflate(R.menu.note_edit, menu);
}
@@ -506,45 +521,71 @@ public class NoteEditActivity extends Activity implements OnClickListener,
}
@Override
+ /*
+ * 函数功能：动态改变菜单选项内容
+ * 函数实现：如下注释
+ */
public boolean onOptionsItemSelected(MenuItem item) {
switch (item.getItemId()) {
+ //根据菜单的id来编剧相关项目
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));
+ // 设置标签的标题为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();
}
});
+ //添加“YES”按钮
builder.setNegativeButton(android.R.string.cancel, null);
+ //添加“NO”的按钮
builder.show();
+ //显示对话框
break;
case R.id.menu_font_size:
+ //字体大小的编辑
mFontSizeSelector.setVisibility(View.VISIBLE);
+ // 将字体选择器置为可见
findViewById(sFontSelectorSelectionMap.get(mFontSizeId)).setVisibility(View.VISIBLE);
+ // 通过id找到相应的大小
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());
+ // 用sendto函数将运行文本发送到遍历的本文内
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:
@@ -553,111 +594,170 @@ public class NoteEditActivity extends Activity implements OnClickListener,
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链接选项
intent.putExtra(Intent.EXTRA_TEXT, info);
+ //将需要传递的便签信息放入text文件中
intent.setType("text/plain");
+ //编辑连接器的类型
context.startActivity(intent);
+ //在acti中进行链接
}
+ /*
+ * 函数功能：创建一个新的便签
+ * 函数实现：如下注释
+ */
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());
+ //将运行便签的id添加到INTENT_EXTRA_FOLDER_ID标记中
startActivity(intent);
+ //开始activity并链接
}
+ /*
+ * 函数功能：删除当前便签
+ * 函数实现：如下注释
+ */
private void deleteCurrentNote() {
if (mWorkingNote.existInDatabase()) {
+ //假如当前运行的便签内存有数据
HashSet ids = new HashSet();
long id = mWorkingNote.getNoteId();
if (id != Notes.ID_ROOT_FOLDER) {
ids.add(id);
+ //如果不是头文件夹建立一个hash表把便签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);
+ //将这些标签的删除标记置为true
}
+ /*
+ * 函数功能：判断是否为同步模式
+ * 函数实现：直接看NotesPreferenceActivity中同步名称是否为空
+ */
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()));
+ //若有有运行的便签就是建立一个链接器将标签id都存在uri中
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);
}
}
+ /*
+ * 函数功能：Widget发生改变的所触发的事件
+ */
public void onWidgetChanged() {
- updateWidget();
+ updateWidget();//更新Widget
}
+ /*
+ * 函数功能： 删除编辑文本框所触发的事件
+ * 函数实现：如下注释
+ */
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);
+ //通过id把编辑框存在便签编辑框中
}
mEditTextList.removeViewAt(index);
+ //删除特定位置的视图
NoteEditText edit = null;
if(index == 0) {
edit = (NoteEditText) mEditTextList.getChildAt(0).findViewById(
@@ -666,69 +766,101 @@ public class NoteEditActivity extends Activity implements OnClickListener,
edit = (NoteEditText) mEditTextList.getChildAt(index - 1).findViewById(
R.id.et_edit_text);
}
+ //通过id把编辑框存在空的NoteEditText中
int length = edit.length();
edit.append(text);
- edit.requestFocus();
- edit.setSelection(length);
+ edit.requestFocus();//请求优先完成该此 编辑
+ edit.setSelection(length);//定位到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);
+ 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);
+ //建立一个状态机检查Pattern并进行匹配
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) {
@@ -739,12 +871,15 @@ public class NoteEditActivity extends Activity implements OnClickListener,
}
}
});
+ //建立一个打钩框并设置监听器
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();
@@ -753,61 +888,94 @@ public class NoteEditActivity extends Activity implements OnClickListener,
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;
+ //初始化check标记
if (mWorkingNote.getCheckListMode() == TextNote.MODE_CHECK_LIST) {
+ // 若模式为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;
+ //扩展字符串为已打钩并把标记置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();
+ //运行 getWorkingText()之后保存
if (saved) {
/**
* There are two modes from List view to edit view, open one note,
@@ -816,11 +984,16 @@ public class NoteEditActivity extends Activity implements OnClickListener,
* new node requires to the top of the list. This code
* {@link #RESULT_OK} is used to identify the create/edit state
*/
+ //如英文注释所说链接RESULT_OK是为了识别保存的2种情况，一是创建后保存，二是修改后保存
setResult(RESULT_OK);
}
return saved;
}
+ /*
+ * 函数功能：将便签发送至桌面
+ * 函数实现：如下注释
+ */
private void sendToDesktop() {
/**
* Before send message to home, we should make sure that current
@@ -829,12 +1002,16 @@ public class NoteEditActivity extends Activity implements OnClickListener,
*/
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,
@@ -842,9 +1019,12 @@ public class NoteEditActivity extends Activity implements OnClickListener,
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");
+ //设置sneder的行为是发送
showToast(R.string.info_note_enter_desktop);
sendBroadcast(sender);
+ //显示到桌面
} else {
/**
* There is the condition that user has input nothing (the note is
@@ -853,21 +1033,35 @@ public class NoteEditActivity extends Activity implements OnClickListener,
*/
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;
+ //直接设置为content中的内容并返回，有勾选和未勾选2种
}
+ /*
+ * 函数功能：显示提示的视图
+ * 函数实现：根据下标显示对应的提示
+ */
private void showToast(int resId) {
showToast(resId, Toast.LENGTH_SHORT);
}
+ /*
+ * 函数功能：持续显示提示的视图
+ * 函数实现：根据下标和持续的时间（duration）编辑提示视图并显示
+ */
private void showToast(int resId, int duration) {
Toast.makeText(this, resId, duration).show();
}
-}
+}
\ No newline at end of file
diff --git a/java/net/micode/notes/ui/NoteEditText.java b/java/net/micode/notes/ui/NoteEditText.java
index 2afe2a8..f658bd6 100644
--- a/java/net/micode/notes/ui/NoteEditText.java
+++ b/java/net/micode/notes/ui/NoteEditText.java
@@ -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.ui;
import android.content.Context;
@@ -37,6 +21,7 @@ import net.micode.notes.R;
import java.util.HashMap;
import java.util.Map;
+//继承edittext，设置便签设置文本框
public class NoteEditText extends EditText {
private static final String TAG = "NoteEditText";
private int mIndex;
@@ -46,6 +31,7 @@ public class NoteEditText extends EditText {
private static final String SCHEME_HTTP = "http:" ;
private static final String SCHEME_EMAIL = "mailto:" ;
+ ///建立一个字符和整数的hash表，用于链接电话，网站，还有邮箱
private static final Map sSchemaActionResMap = new HashMap();
static {
sSchemaActionResMap.put(SCHEME_TEL, R.string.note_link_tel);
@@ -56,17 +42,20 @@ public class NoteEditText extends EditText {
/**
* Call by the {@link NoteEditActivity} to delete or add edit text
*/
+ //在NoteEditActivity中删除或添加文本的操作，可以看做是一个文本是否被变的标记，英文注释已说明的很清楚
public interface OnTextViewChangeListener {
/**
* Delete current edit text when {@link KeyEvent#KEYCODE_DEL} happens
* and the text is null
*/
+ //处理删除按键时的操作
void onEditTextDelete(int index, String text);
/**
* Add edit text after current edit text when {@link KeyEvent#KEYCODE_ENTER}
* happen
*/
+ //处理进入按键时的操作
void onEditTextEnter(int index, String text);
/**
@@ -77,33 +66,43 @@ public class NoteEditText extends EditText {
private OnTextViewChangeListener mOnTextViewChangeListener;
+ //根据context设置文本
public NoteEditText(Context context) {
- super(context, null);
+ super(context, null);//用super引用父类变量
mIndex = 0;
}
+ //设置当前光标
public void setIndex(int index) {
mIndex = index;
}
+ //初始化文本修改标记
public void setOnTextViewChangeListener(OnTextViewChangeListener listener) {
mOnTextViewChangeListener = listener;
}
- public NoteEditText(Context context, AttributeSet attrs) {
+ //AttributeSet 百度了一下是自定义空控件属性，用于维护便签动态变化的属性
+ //初始化便签
+ public NoteEditText(Context context, AttributeSet attrs) {
super(context, attrs, android.R.attr.editTextStyle);
}
+ // 根据defstyle自动初始化
public NoteEditText(Context context, AttributeSet attrs, int defStyle) {
super(context, attrs, defStyle);
- // TODO Auto-generated constructor stub
+ // TODO Auto-generated construct or stub
}
@Override
+ //view里的函数，处理手机屏幕的所有事件
+ /*参数event为手机屏幕触摸事件封装类的对象，其中封装了该事件的所有信息，
+ 例如触摸的位置、触摸的类型以及触摸的时间等。该对象会在用户触摸手机屏幕时被创建。*/
public boolean onTouchEvent(MotionEvent event) {
switch (event.getAction()) {
+ //重写了需要处理屏幕被按下的事件
case MotionEvent.ACTION_DOWN:
-
+ //跟新当前坐标值
int x = (int) event.getX();
int y = (int) event.getY();
x -= getTotalPaddingLeft();
@@ -111,9 +110,12 @@ public class NoteEditText extends EditText {
x += getScrollX();
y += getScrollY();
+ //用布局控件layout根据x,y的新值设置新的位置
Layout layout = getLayout();
int line = layout.getLineForVertical(y);
int off = layout.getOffsetForHorizontal(line, x);
+
+ //更新光标新的位置
Selection.setSelection(getText(), off);
break;
}
@@ -122,96 +124,147 @@ public class NoteEditText extends EditText {
}
@Override
+ /*
+ * 函数功能：处理用户按下一个键盘按键时会触发 的事件
+ * 实现过程：如下注释
+ */
public boolean onKeyDown(int keyCode, KeyEvent event) {
switch (keyCode) {
+ //根据按键的 Unicode 编码值来处理
case KeyEvent.KEYCODE_ENTER:
+ //“进入”按键
if (mOnTextViewChangeListener != null) {
return false;
}
break;
case KeyEvent.KEYCODE_DEL:
+ //“删除”按键
mSelectionStartBeforeDelete = getSelectionStart();
break;
default:
break;
}
+ //继续执行父类的其他点击事件
return super.onKeyDown(keyCode, event);
}
@Override
+ /*
+ * 函数功能：处理用户松开一个键盘按键时会触发 的事件
+ * 实现方式：如下注释
+ */
public boolean onKeyUp(int keyCode, KeyEvent event) {
switch(keyCode) {
+ //根据按键的 Unicode 编码值来处理，有删除和进入2种操作
case KeyEvent.KEYCODE_DEL:
if (mOnTextViewChangeListener != null) {
+ //若是被修改过
if (0 == mSelectionStartBeforeDelete && mIndex != 0) {
+ //若之前有被修改并且文档不为空
mOnTextViewChangeListener.onEditTextDelete(mIndex, getText().toString());
+ //利用上文OnTextViewChangeListener对KEYCODE_DEL按键情况的删除函数进行删除
return true;
}
} else {
Log.d(TAG, "OnTextViewChangeListener was not seted");
+ //其他情况报错，文档的改动监听器并没有建立
}
break;
case KeyEvent.KEYCODE_ENTER:
+ //同上也是分为监听器是否建立2种情况
if (mOnTextViewChangeListener != null) {
int selectionStart = getSelectionStart();
+ //获取当前位置
String text = getText().subSequence(selectionStart, length()).toString();
+ //获取当前文本
setText(getText().subSequence(0, selectionStart));
+ //根据获取的文本设置当前文本
mOnTextViewChangeListener.onEditTextEnter(mIndex + 1, text);
+ //当{@link KeyEvent#KEYCODE_ENTER}添加新文本
} else {
Log.d(TAG, "OnTextViewChangeListener was not seted");
+ //其他情况报错，文档的改动监听器并没有建立
}
break;
default:
break;
}
+ //继续执行父类的其他按键弹起的事件
return super.onKeyUp(keyCode, event);
}
@Override
+ /*
+ * 函数功能：当焦点发生变化时，会自动调用该方法来处理焦点改变的事件
+ * 实现方式：如下注释
+ * 参数：focused表示触发该事件的View是否获得了焦点，当该控件获得焦点时，Focused等于true，否则等于false。
+ direction表示焦点移动的方向，用数值表示
+ Rect：表示在触发事件的View的坐标系中，前一个获得焦点的矩形区域，即表示焦点是从哪里来的。如果不可用则为null
+ */
protected void onFocusChanged(boolean focused, int direction, Rect previouslyFocusedRect) {
if (mOnTextViewChangeListener != null) {
+ //若监听器已经建立
if (!focused && TextUtils.isEmpty(getText())) {
+ //获取到焦点并且文本不为空
mOnTextViewChangeListener.onTextChange(mIndex, false);
+ //mOnTextViewChangeListener子函数，置false隐藏事件选项
} else {
mOnTextViewChangeListener.onTextChange(mIndex, true);
+ //mOnTextViewChangeListener子函数，置true显示事件选项
}
}
+ //继续执行父类的其他焦点变化的事件
super.onFocusChanged(focused, direction, previouslyFocusedRect);
}
@Override
+ /*
+ * 函数功能：生成上下文菜单
+ * 函数实现：如下注释
+ */
protected void onCreateContextMenu(ContextMenu menu) {
if (getText() instanceof Spanned) {
+ //有文本存在
int selStart = getSelectionStart();
int selEnd = getSelectionEnd();
+ //获取文本开始和结尾位置
int min = Math.min(selStart, selEnd);
int max = Math.max(selStart, selEnd);
+ //获取开始到结尾的最大值和最小值
final URLSpan[] urls = ((Spanned) getText()).getSpans(min, max, URLSpan.class);
+ //设置url的信息的范围值
if (urls.length == 1) {
int defaultResId = 0;
for(String schema: sSchemaActionResMap.keySet()) {
+ //获取计划表中所有的key值
if(urls[0].getURL().indexOf(schema) >= 0) {
+ //若url可以添加则在添加后将defaultResId置为key所映射的值
defaultResId = sSchemaActionResMap.get(schema);
break;
}
}
if (defaultResId == 0) {
+ //defaultResId == 0则说明url并没有添加任何东西，所以置为连接其他SchemaActionResMap的值
defaultResId = R.string.note_link_other;
}
+ //建立菜单
menu.add(0, 0, 0, defaultResId).setOnMenuItemClickListener(
new OnMenuItemClickListener() {
+ //新建按键监听器
public boolean onMenuItemClick(MenuItem item) {
// goto a new intent
urls[0].onClick(NoteEditText.this);
+ //根据相应的文本设置菜单的按键
return true;
}
});
}
}
+ //继续执行父类的其他菜单创建的事件
super.onCreateContextMenu(menu);
}
-}
+}
\ No newline at end of file
diff --git a/java/net/micode/notes/ui/NoteItemData.java b/java/net/micode/notes/ui/NoteItemData.java
index 0f5a878..4acfd7c 100644
--- a/java/net/micode/notes/ui/NoteItemData.java
+++ b/java/net/micode/notes/ui/NoteItemData.java
@@ -28,18 +28,18 @@ import net.micode.notes.tool.DataUtils;
public class NoteItemData {
static final String [] PROJECTION = new String [] {
- NoteColumns.ID,
- NoteColumns.ALERTED_DATE,
- NoteColumns.BG_COLOR_ID,
- NoteColumns.CREATED_DATE,
- NoteColumns.HAS_ATTACHMENT,
- NoteColumns.MODIFIED_DATE,
- NoteColumns.NOTES_COUNT,
- NoteColumns.PARENT_ID,
- NoteColumns.SNIPPET,
- NoteColumns.TYPE,
- NoteColumns.WIDGET_ID,
- NoteColumns.WIDGET_TYPE,
+ NoteColumns.ID,
+ NoteColumns.ALERTED_DATE,
+ NoteColumns.BG_COLOR_ID,
+ NoteColumns.CREATED_DATE,
+ NoteColumns.HAS_ATTACHMENT,
+ NoteColumns.MODIFIED_DATE,
+ NoteColumns.NOTES_COUNT,
+ NoteColumns.PARENT_ID,
+ NoteColumns.SNIPPET,
+ NoteColumns.TYPE,
+ NoteColumns.WIDGET_ID,
+ NoteColumns.WIDGET_TYPE,
};
private static final int ID_COLUMN = 0;
diff --git a/java/net/micode/notes/ui/NotesListActivity.java b/java/net/micode/notes/ui/NotesListActivity.java
index e843aec..125c058 100644
--- a/java/net/micode/notes/ui/NotesListActivity.java
+++ b/java/net/micode/notes/ui/NotesListActivity.java
@@ -1,21 +1,6 @@
-/*
- * 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.ui;
+import android.Manifest;
import android.app.Activity;
import android.app.AlertDialog;
import android.app.Dialog;
@@ -27,6 +12,7 @@ import android.content.Context;
import android.content.DialogInterface;
import android.content.Intent;
import android.content.SharedPreferences;
+import android.content.pm.PackageManager;
import android.database.Cursor;
import android.os.AsyncTask;
import android.os.Bundle;
@@ -60,6 +46,9 @@ import android.widget.PopupMenu;
import android.widget.TextView;
import android.widget.Toast;
+import androidx.core.app.ActivityCompat;
+import androidx.core.content.ContextCompat;
+
import net.micode.notes.R;
import net.micode.notes.data.Notes;
import net.micode.notes.data.Notes.NoteColumns;
@@ -78,141 +67,207 @@ import java.io.InputStream;
import java.io.InputStreamReader;
import java.util.HashSet;
+/**
+ * 便签列表主活动
+ * 负责展示便签列表、处理便签的增删改查操作
+ * 管理文件夹结构和私密模式功能
+ */
public class NotesListActivity extends Activity implements OnClickListener, OnItemLongClickListener {
- private static final int FOLDER_NOTE_LIST_QUERY_TOKEN = 0;
-
- private static final int FOLDER_LIST_QUERY_TOKEN = 1;
-
- private static final int MENU_FOLDER_DELETE = 0;
+ private static final int FOLDER_NOTE_LIST_QUERY_TOKEN = 0; // 便签列表查询令牌
+ public static int secret_mode = 0; // 私密模式标志(0:正常模式,1:私密模式)
+ private static final int FOLDER_LIST_QUERY_TOKEN = 1; // 文件夹列表查询令牌
- private static final int MENU_FOLDER_VIEW = 1;
+ private static final int MENU_FOLDER_DELETE = 0; // 文件夹删除菜单项ID
+ private static final int MENU_FOLDER_VIEW = 1; // 文件夹查看菜单项ID
+ private static final int MENU_FOLDER_CHANGE_NAME = 2; // 文件夹重命名菜单项ID
- private static final int MENU_FOLDER_CHANGE_NAME = 2;
-
- private static final String PREFERENCE_ADD_INTRODUCTION = "net.micode.notes.introduction";
+ private static final String PREFERENCE_ADD_INTRODUCTION = "net.micode.notes.introduction"; // 首次添加介绍便签的偏好设置键
private enum ListEditState {
- NOTE_LIST, SUB_FOLDER, CALL_RECORD_FOLDER
- };
-
- private ListEditState mState;
-
- private BackgroundQueryHandler mBackgroundQueryHandler;
-
- private NotesListAdapter mNotesListAdapter;
-
- private ListView mNotesListView;
-
- private Button mAddNewNote;
-
- private boolean mDispatch;
-
- private int mOriginY;
-
- private int mDispatchY;
-
- private TextView mTitleBar;
-
- private long mCurrentFolderId;
-
- private ContentResolver mContentResolver;
-
- private ModeCallback mModeCallBack;
-
- private static final String TAG = "NotesListActivity";
-
- public static final int NOTES_LISTVIEW_SCROLL_RATE = 30;
-
- private NoteItemData mFocusNoteDataItem;
+ NOTE_LIST, SUB_FOLDER, CALL_RECORD_FOLDER // 列表编辑状态枚举
+ }
+ private ListEditState mState; // 当前列表编辑状态
+ private BackgroundQueryHandler mBackgroundQueryHandler; // 后台查询处理器
+ private NotesListAdapter mNotesListAdapter; // 便签列表适配器
+ private ListView mNotesListView; // 便签列表视图
+ private Button mAddNewNote; // 添加新便签按钮
+ private boolean mDispatch; // 触摸事件分发标志
+ private int mOriginY; // 触摸事件原始Y坐标
+ private int mDispatchY; // 触摸事件分发Y坐标
+ private TextView mTitleBar; // 标题栏文本
+ private long mCurrentFolderId; // 当前文件夹ID
+ private ContentResolver mContentResolver; // 内容解析器
+ private ModeCallback mModeCallBack; // 多选模式回调
+ private static final String TAG = "NotesListActivity"; // 日志标签
+ public static final int NOTES_LISTVIEW_SCROLL_RATE = 30; // 列表视图滚动速率
+
+ // 初始化时设为null，使用前进行null检查
+ private NoteItemData mFocusNoteDataItem = null; // 聚焦的便签数据项
+
+ // 数据库查询条件
private static final String NORMAL_SELECTION = NoteColumns.PARENT_ID + "=?";
-
private static final String ROOT_FOLDER_SELECTION = "(" + NoteColumns.TYPE + "<>"
+ Notes.TYPE_SYSTEM + " AND " + NoteColumns.PARENT_ID + "=?)" + " OR ("
+ NoteColumns.ID + "=" + Notes.ID_CALL_RECORD_FOLDER + " AND "
+ NoteColumns.NOTES_COUNT + ">0)";
- private final static int REQUEST_CODE_OPEN_NODE = 102;
- private final static int REQUEST_CODE_NEW_NODE = 103;
+ private final static int REQUEST_CODE_OPEN_NODE = 102; // 打开便签请求码
+ private final static int REQUEST_CODE_NEW_NODE = 103; // 新建便签请求码
+ private final static int PERMISSION_REQUEST_STORAGE = 100; // 存储权限请求码
+
+ // 声明异步任务，以便在Activity销毁时取消
+ private AsyncTask mCurrentAsyncTask; // 当前执行的异步任务
+ /**
+ * Activity创建时调用
+ * 初始化UI、检查权限、设置应用信息
+ */
@Override
protected void onCreate(Bundle savedInstanceState) {
- super.onCreate(savedInstanceState);
- setContentView(R.layout.note_list);
- initResources();
-
- /**
- * Insert an introduction when user firstly use this application
- */
- setAppInfoFromRawRes();
+ try {
+ super.onCreate(savedInstanceState);
+ setContentView(R.layout.note_list);
+ initResources(); // 初始化资源和UI组件
+ checkPermissions(); // 检查存储权限
+ setAppInfoFromRawRes(); // 从原始资源设置应用信息
+ } catch (Exception e) {
+ Log.e(TAG, "onCreate error: " + e.getMessage(), e);
+ Toast.makeText(this, "应用启动失败: " + e.getMessage(), Toast.LENGTH_LONG).show();
+ }
}
+ /**
+ * Activity结果回调
+ * 处理子Activity返回的结果
+ */
@Override
protected void onActivityResult(int requestCode, int resultCode, Intent data) {
- if (resultCode == RESULT_OK
- && (requestCode == REQUEST_CODE_OPEN_NODE || requestCode == REQUEST_CODE_NEW_NODE)) {
- mNotesListAdapter.changeCursor(null);
- } else {
- super.onActivityResult(requestCode, resultCode, data);
+ try {
+ if (resultCode == RESULT_OK
+ && (requestCode == REQUEST_CODE_OPEN_NODE || requestCode == REQUEST_CODE_NEW_NODE)) {
+ if (mNotesListAdapter != null) {
+ mNotesListAdapter.changeCursor(null); // 刷新便签列表
+ }
+ } else {
+ super.onActivityResult(requestCode, resultCode, data);
+ }
+ } catch (Exception e) {
+ Log.e(TAG, "onActivityResult error: " + e.getMessage(), e);
+ }
+ }
+
+ /**
+ * 检查存储权限
+ * 如需权限则请求用户授权
+ */
+ private void checkPermissions() {
+ if (ContextCompat.checkSelfPermission(this, Manifest.permission.WRITE_EXTERNAL_STORAGE)
+ != PackageManager.PERMISSION_GRANTED) {
+ ActivityCompat.requestPermissions(this,
+ new String[]{Manifest.permission.WRITE_EXTERNAL_STORAGE},
+ PERMISSION_REQUEST_STORAGE);
}
}
+ /**
+ * 权限请求结果回调
+ * 处理用户对权限请求的响应
+ */
+ @Override
+ public void onRequestPermissionsResult(int requestCode, String[] permissions, int[] grantResults) {
+ super.onRequestPermissionsResult(requestCode, permissions, grantResults);
+ if (requestCode == PERMISSION_REQUEST_STORAGE) {
+ if (grantResults.length > 0 && grantResults[0] == PackageManager.PERMISSION_GRANTED) {
+ Toast.makeText(this, "存储权限已获取", Toast.LENGTH_SHORT).show();
+ } else {
+ Toast.makeText(this, "需要存储权限才能使用导出功能", Toast.LENGTH_SHORT).show();
+ }
+ }
+ }
+
+ /**
+ * 从原始资源设置应用信息
+ * 首次启动时创建介绍便签
+ */
private void setAppInfoFromRawRes() {
SharedPreferences sp = PreferenceManager.getDefaultSharedPreferences(this);
if (!sp.getBoolean(PREFERENCE_ADD_INTRODUCTION, false)) {
StringBuilder sb = new StringBuilder();
InputStream in = null;
try {
- in = getResources().openRawResource(R.raw.introduction);
+ // 读取介绍文件内容
+ in = getResources().openRawResource(R.raw.introduction);
if (in != null) {
InputStreamReader isr = new InputStreamReader(in);
BufferedReader br = new BufferedReader(isr);
- char [] buf = new char[1024];
- int len = 0;
+ char[] buf = new char[1024];
+ int len;
while ((len = br.read(buf)) > 0) {
sb.append(buf, 0, len);
}
} else {
- Log.e(TAG, "Read introduction file error");
+ Log.e(TAG, "Read introduction file error: in is null");
return;
}
} catch (IOException e) {
- e.printStackTrace();
+ Log.e(TAG, "Read introduction file error", e);
return;
} finally {
- if(in != null) {
+ if (in != null) {
try {
in.close();
} catch (IOException e) {
- // TODO Auto-generated catch block
- e.printStackTrace();
+ Log.e(TAG, "Close introduction file error", e);
}
}
}
- WorkingNote note = WorkingNote.createEmptyNote(this, Notes.ID_ROOT_FOLDER,
- AppWidgetManager.INVALID_APPWIDGET_ID, Notes.TYPE_WIDGET_INVALIDE,
- ResourceParser.RED);
- note.setWorkingText(sb.toString());
- if (note.saveNote()) {
- sp.edit().putBoolean(PREFERENCE_ADD_INTRODUCTION, true).commit();
- } else {
- Log.e(TAG, "Save introduction note error");
- return;
+ try {
+ // 创建介绍便签并保存
+ WorkingNote note = WorkingNote.createEmptyNote(this, Notes.ID_ROOT_FOLDER,
+ AppWidgetManager.INVALID_APPWIDGET_ID, Notes.TYPE_WIDGET_INVALIDE,
+ ResourceParser.RED);
+ if (note != null) {
+ note.setWorkingText(sb.toString());
+ if (note.saveNote()) {
+ sp.edit().putBoolean(PREFERENCE_ADD_INTRODUCTION, true).commit();
+ } else {
+ Log.e(TAG, "Save introduction note error: saveNote failed");
+ }
+ } else {
+ Log.e(TAG, "Save introduction note error: note is null");
+ }
+ } catch (Exception e) {
+ Log.e(TAG, "Save introduction note error", e);
}
}
}
+ /**
+ * Activity开始时调用
+ * 启动异步便签列表查询
+ */
@Override
protected void onStart() {
- super.onStart();
- startAsyncNotesListQuery();
+ try {
+ super.onStart();
+ startAsyncNotesListQuery(); // 异步查询便签列表
+ } catch (Exception e) {
+ Log.e(TAG, "onStart error: " + e.getMessage(), e);
+ }
}
+ /**
+ * 初始化资源和UI组件
+ * 绑定视图、设置适配器和事件监听
+ */
private void initResources() {
- mContentResolver = this.getContentResolver();
+ mContentResolver = this.getContentResolver(); // 获取内容解析器，用于数据操作
mBackgroundQueryHandler = new BackgroundQueryHandler(this.getContentResolver());
- mCurrentFolderId = Notes.ID_ROOT_FOLDER;
+ mCurrentFolderId = Notes.ID_ROOT_FOLDER; // 默认显示根文件夹
+
+ // 绑定UI组件
mNotesListView = (ListView) findViewById(R.id.notes_list);
mNotesListView.addFooterView(LayoutInflater.from(this).inflate(R.layout.note_list_footer, null),
null, false);
@@ -220,735 +275,1175 @@ public class NotesListActivity extends Activity implements OnClickListener, OnIt
mNotesListView.setOnItemLongClickListener(this);
mNotesListAdapter = new NotesListAdapter(this);
mNotesListView.setAdapter(mNotesListAdapter);
+
mAddNewNote = (Button) findViewById(R.id.btn_new_note);
mAddNewNote.setOnClickListener(this);
mAddNewNote.setOnTouchListener(new NewNoteOnTouchListener());
+
mDispatch = false;
mDispatchY = 0;
mOriginY = 0;
mTitleBar = (TextView) findViewById(R.id.tv_title_bar);
- mState = ListEditState.NOTE_LIST;
- mModeCallBack = new ModeCallback();
+ mState = ListEditState.NOTE_LIST; // 初始状态为便签列表
+ mModeCallBack = new ModeCallback(); // 初始化多选模式回调
}
+ /**
+ * 多选模式回调类
+ * 处理ListView的多选模式相关事件
+ */
private class ModeCallback implements ListView.MultiChoiceModeListener, OnMenuItemClickListener {
- private DropdownMenu mDropDownMenu;
- private ActionMode mActionMode;
- private MenuItem mMoveMenu;
+ private DropdownMenu mDropDownMenu; // 下拉菜单
+ private ActionMode mActionMode; // 操作模式
+ private MenuItem mMoveMenu; // 移动菜单项
+ /**
+ * 创建操作模式时调用
+ * 初始化操作模式菜单
+ */
public boolean onCreateActionMode(ActionMode mode, Menu menu) {
- getMenuInflater().inflate(R.menu.note_list_options, menu);
- menu.findItem(R.id.delete).setOnMenuItemClickListener(this);
- mMoveMenu = menu.findItem(R.id.move);
- if (mFocusNoteDataItem.getParentId() == Notes.ID_CALL_RECORD_FOLDER
- || DataUtils.getUserFolderCount(mContentResolver) == 0) {
- mMoveMenu.setVisible(false);
- } else {
- mMoveMenu.setVisible(true);
- mMoveMenu.setOnMenuItemClickListener(this);
- }
- mActionMode = mode;
- mNotesListAdapter.setChoiceMode(true);
- mNotesListView.setLongClickable(false);
- mAddNewNote.setVisibility(View.GONE);
-
- View customView = LayoutInflater.from(NotesListActivity.this).inflate(
- R.layout.note_list_dropdown_menu, null);
- mode.setCustomView(customView);
- mDropDownMenu = new DropdownMenu(NotesListActivity.this,
- (Button) customView.findViewById(R.id.selection_menu),
- R.menu.note_list_dropdown);
- mDropDownMenu.setOnDropdownMenuItemClickListener(new PopupMenu.OnMenuItemClickListener(){
- public boolean onMenuItemClick(MenuItem item) {
- mNotesListAdapter.selectAll(!mNotesListAdapter.isAllSelected());
- updateMenu();
- return true;
+ try {
+ getMenuInflater().inflate(R.menu.note_list_options, menu);
+ menu.findItem(R.id.delete).setOnMenuItemClickListener(this);
+ mMoveMenu = menu.findItem(R.id.move);
+
+ // 根据当前聚焦的便签数据项设置菜单项可见性
+ if (mFocusNoteDataItem != null) {
+ if (mFocusNoteDataItem.getParentId() == Notes.ID_CALL_RECORD_FOLDER
+ || DataUtils.getUserFolderCount(mContentResolver) == 0) {
+ mMoveMenu.setVisible(false);
+ } else {
+ mMoveMenu.setVisible(true);
+ mMoveMenu.setOnMenuItemClickListener(this);
+ }
}
- });
- return true;
+ mActionMode = mode;
+ if (mNotesListAdapter != null) {
+ mNotesListAdapter.setChoiceMode(true); // 设置列表为多选模式
+ }
+ if (mNotesListView != null) {
+ mNotesListView.setLongClickable(false); // 禁用长按
+ }
+ if (mAddNewNote != null) {
+ mAddNewNote.setVisibility(View.GONE); // 隐藏添加按钮
+ }
+
+ // 设置操作模式的自定义视图
+ View customView = LayoutInflater.from(NotesListActivity.this).inflate(
+ R.layout.note_list_dropdown_menu, null);
+ mode.setCustomView(customView);
+ mDropDownMenu = new DropdownMenu(NotesListActivity.this,
+ (Button) customView.findViewById(R.id.selection_menu),
+ R.menu.note_list_dropdown);
+ mDropDownMenu.setOnDropdownMenuItemClickListener(new PopupMenu.OnMenuItemClickListener() {
+ public boolean onMenuItemClick(MenuItem item) {
+ if (mNotesListAdapter != null) {
+ mNotesListAdapter.selectAll(!mNotesListAdapter.isAllSelected());
+ updateMenu(); // 更新菜单状态
+ }
+ return true;
+ }
+ });
+ return true;
+ } catch (Exception e) {
+ Log.e(TAG, "onCreateActionMode error: " + e.getMessage(), e);
+ return false;
+ }
}
+ /**
+ * 更新菜单状态
+ * 显示当前选中的项目数量
+ */
private void updateMenu() {
- int selectedCount = mNotesListAdapter.getSelectedCount();
- // Update dropdown menu
- String format = getResources().getString(R.string.menu_select_title, selectedCount);
- mDropDownMenu.setTitle(format);
- MenuItem item = mDropDownMenu.findItem(R.id.action_select_all);
- if (item != null) {
- if (mNotesListAdapter.isAllSelected()) {
- item.setChecked(true);
- item.setTitle(R.string.menu_deselect_all);
- } else {
- item.setChecked(false);
- item.setTitle(R.string.menu_select_all);
+ try {
+ if (mNotesListAdapter != null) {
+ int selectedCount = mNotesListAdapter.getSelectedCount();
+ String format = getResources().getString(R.string.menu_select_title, selectedCount);
+ if (mDropDownMenu != null) {
+ mDropDownMenu.setTitle(format);
+ MenuItem item = mDropDownMenu.findItem(R.id.action_select_all);
+ if (item != null) {
+ if (mNotesListAdapter.isAllSelected()) {
+ item.setChecked(true);
+ item.setTitle(R.string.menu_deselect_all);
+ } else {
+ item.setChecked(false);
+ item.setTitle(R.string.menu_select_all);
+ }
+ }
+ }
}
+ } catch (Exception e) {
+ Log.e(TAG, "updateMenu error: " + e.getMessage(), e);
}
}
+ // 以下方法为ListView.MultiChoiceModeListener接口实现，此处为简化注释省略详细说明
public boolean onPrepareActionMode(ActionMode mode, Menu menu) {
- // TODO Auto-generated method stub
return false;
}
public boolean onActionItemClicked(ActionMode mode, MenuItem item) {
- // TODO Auto-generated method stub
return false;
}
public void onDestroyActionMode(ActionMode mode) {
- mNotesListAdapter.setChoiceMode(false);
- mNotesListView.setLongClickable(true);
- mAddNewNote.setVisibility(View.VISIBLE);
+ try {
+ if (mNotesListAdapter != null) {
+ mNotesListAdapter.setChoiceMode(false); // 取消多选模式
+ }
+ if (mNotesListView != null) {
+ mNotesListView.setLongClickable(true); // 启用长按
+ }
+ if (mAddNewNote != null) {
+ mAddNewNote.setVisibility(View.VISIBLE); // 显示添加按钮
+ }
+ } catch (Exception e) {
+ Log.e(TAG, "onDestroyActionMode error: " + e.getMessage(), e);
+ }
}
public void finishActionMode() {
- mActionMode.finish();
+ if (mActionMode != null) {
+ mActionMode.finish();
+ }
}
- public void onItemCheckedStateChanged(ActionMode mode, int position, long id,
- boolean checked) {
- mNotesListAdapter.setCheckedItem(position, checked);
- updateMenu();
+ public void onItemCheckedStateChanged(ActionMode mode, int position, long id, boolean checked) {
+ try {
+ if (mNotesListAdapter != null) {
+ mNotesListAdapter.setCheckedItem(position, checked);
+ updateMenu(); // 更新菜单状态
+ }
+ } catch (Exception e) {
+ Log.e(TAG, "onItemCheckedStateChanged error: " + e.getMessage(), e);
+ }
}
+ /**
+ * 菜单项点击回调
+ * 处理删除和移动操作
+ */
public boolean onMenuItemClick(MenuItem item) {
- if (mNotesListAdapter.getSelectedCount() == 0) {
- Toast.makeText(NotesListActivity.this, getString(R.string.menu_select_none),
- Toast.LENGTH_SHORT).show();
+ try {
+ if (mNotesListAdapter != null && mNotesListAdapter.getSelectedCount() == 0) {
+ Toast.makeText(NotesListActivity.this, getString(R.string.menu_select_none),
+ Toast.LENGTH_SHORT).show();
+ return true;
+ }
+
+ switch (item.getItemId()) {
+ case R.id.delete:
+ showDeleteDialog(); // 显示删除确认对话框
+ break;
+ case R.id.move:
+ startQueryDestinationFolders(); // 开始查询目标文件夹
+ break;
+ default:
+ return false;
+ }
return true;
+ } catch (Exception e) {
+ Log.e(TAG, "onMenuItemClick error: " + e.getMessage(), e);
+ return false;
}
+ }
- switch (item.getItemId()) {
- case R.id.delete:
- AlertDialog.Builder builder = new AlertDialog.Builder(NotesListActivity.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_notes,
- mNotesListAdapter.getSelectedCount()));
- builder.setPositiveButton(android.R.string.ok,
- new DialogInterface.OnClickListener() {
- public void onClick(DialogInterface dialog,
- int which) {
- batchDelete();
- }
- });
- builder.setNegativeButton(android.R.string.cancel, null);
- builder.show();
- break;
- case R.id.move:
- startQueryDestinationFolders();
- break;
- default:
- return false;
- }
- return true;
+ /**
+ * 显示删除确认对话框
+ */
+ private void showDeleteDialog() {
+ AlertDialog.Builder builder = new AlertDialog.Builder(NotesListActivity.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_notes,
+ mNotesListAdapter.getSelectedCount()));
+ builder.setPositiveButton(android.R.string.ok,
+ new DialogInterface.OnClickListener() {
+ public void onClick(DialogInterface dialog, int which) {
+ batchDelete(); // 批量删除选中的便签
+ }
+ });
+ builder.setNegativeButton(android.R.string.cancel, null);
+ builder.show();
}
}
+ /**
+ * 新建便签按钮触摸事件监听器
+ * 处理按钮的触摸滑动事件
+ */
private class NewNoteOnTouchListener implements OnTouchListener {
-
public boolean onTouch(View v, MotionEvent event) {
- switch (event.getAction()) {
- case MotionEvent.ACTION_DOWN: {
- Display display = getWindowManager().getDefaultDisplay();
- int screenHeight = display.getHeight();
- int newNoteViewHeight = mAddNewNote.getHeight();
- int start = screenHeight - newNoteViewHeight;
- int eventY = start + (int) event.getY();
- /**
- * Minus TitleBar's height
- */
- if (mState == ListEditState.SUB_FOLDER) {
- eventY -= mTitleBar.getHeight();
- start -= mTitleBar.getHeight();
+ try {
+ switch (event.getAction()) {
+ case MotionEvent.ACTION_DOWN: {
+ // 处理触摸按下事件，计算事件坐标
+ Display display = getWindowManager().getDefaultDisplay();
+ int screenHeight = display.getHeight();
+ int newNoteViewHeight = mAddNewNote.getHeight();
+ int start = screenHeight - newNoteViewHeight;
+ int eventY = start + (int) event.getY();
+
+ if (mState == ListEditState.SUB_FOLDER && mTitleBar != null) {
+ eventY -= mTitleBar.getHeight();
+ start -= mTitleBar.getHeight();
+ }
+
+ // 分发触摸事件到ListView
+ if (event.getY() < (event.getX() * (-0.12) + 94)) {
+ if (mNotesListView != null) {
+ View view = mNotesListView.getChildAt(mNotesListView.getChildCount() - 1
+ - mNotesListView.getFooterViewsCount());
+ if (view != null && view.getBottom() > start
+ && (view.getTop() < (start + 94))) {
+ mOriginY = (int) event.getY();
+ mDispatchY = eventY;
+ event.setLocation(event.getX(), mDispatchY);
+ mDispatch = true;
+ return mNotesListView.dispatchTouchEvent(event);
+ }
+ }
+ }
+ break;
}
- /**
- * HACKME:When click the transparent part of "New Note" button, dispatch
- * the event to the list view behind this button. The transparent part of
- * "New Note" button could be expressed by formula y=-0.12x+94（Unit:pixel）
- * and the line top of the button. The coordinate based on left of the "New
- * Note" button. The 94 represents maximum height of the transparent part.
- * Notice that, if the background of the button changes, the formula should
- * also change. This is very bad, just for the UI designer's strong requirement.
- */
- if (event.getY() < (event.getX() * (-0.12) + 94)) {
- View view = mNotesListView.getChildAt(mNotesListView.getChildCount() - 1
- - mNotesListView.getFooterViewsCount());
- if (view != null && view.getBottom() > start
- && (view.getTop() < (start + 94))) {
- mOriginY = (int) event.getY();
- mDispatchY = eventY;
+ case MotionEvent.ACTION_MOVE: {
+ // 处理触摸移动事件，更新分发坐标
+ if (mDispatch) {
+ mDispatchY += (int) event.getY() - mOriginY;
event.setLocation(event.getX(), mDispatchY);
- mDispatch = true;
- return mNotesListView.dispatchTouchEvent(event);
+ if (mNotesListView != null) {
+ return mNotesListView.dispatchTouchEvent(event);
+ }
}
+ break;
}
- break;
- }
- case MotionEvent.ACTION_MOVE: {
- if (mDispatch) {
- mDispatchY += (int) event.getY() - mOriginY;
- event.setLocation(event.getX(), mDispatchY);
- return mNotesListView.dispatchTouchEvent(event);
- }
- break;
- }
- default: {
- if (mDispatch) {
- event.setLocation(event.getX(), mDispatchY);
- mDispatch = false;
- return mNotesListView.dispatchTouchEvent(event);
+ default: {
+ // 处理触摸事件结束，重置分发状态
+ if (mDispatch) {
+ event.setLocation(event.getX(), mDispatchY);
+ mDispatch = false;
+ if (mNotesListView != null) {
+ return mNotesListView.dispatchTouchEvent(event);
+ }
+ }
+ break;
}
- break;
}
+ } catch (Exception e) {
+ Log.e(TAG, "NewNoteOnTouchListener error: " + e.getMessage(), e);
}
return false;
}
+ }
- };
-
+ /**
+ * 启动异步便签列表查询
+ * 根据当前文件夹ID和私密模式状态执行查询
+ */
private void startAsyncNotesListQuery() {
- String selection = (mCurrentFolderId == Notes.ID_ROOT_FOLDER) ? ROOT_FOLDER_SELECTION
- : NORMAL_SELECTION;
- mBackgroundQueryHandler.startQuery(FOLDER_NOTE_LIST_QUERY_TOKEN, null,
- Notes.CONTENT_NOTE_URI, NoteItemData.PROJECTION, selection, new String[] {
- String.valueOf(mCurrentFolderId)
- }, NoteColumns.TYPE + " DESC," + NoteColumns.MODIFIED_DATE + " DESC");
+ try {
+ String selection = (mCurrentFolderId == Notes.ID_ROOT_FOLDER) ? ROOT_FOLDER_SELECTION
+ : NORMAL_SELECTION;
+ if (secret_mode == 0) {
+ // 正常模式下的查询
+ mBackgroundQueryHandler.startQuery(FOLDER_NOTE_LIST_QUERY_TOKEN, null,
+ Notes.CONTENT_NOTE_URI, NoteItemData.PROJECTION, selection, new String[]{
+ String.valueOf(mCurrentFolderId)
+ }, NoteColumns.TYPE + " DESC," + NoteColumns.MODIFIED_DATE + " DESC");
+ } else {
+ // 私密模式下的查询，包含额外字段
+ String str1 = "123";
+ String[] PROJECTION = new String[]{
+ NoteColumns.ID,
+ NoteColumns.ALERTED_DATE,
+ NoteColumns.BG_COLOR_ID,
+ NoteColumns.CREATED_DATE,
+ NoteColumns.HAS_ATTACHMENT,
+ NoteColumns.MODIFIED_DATE,
+ NoteColumns.NOTES_COUNT,
+ NoteColumns.PARENT_ID,
+ str1,
+ NoteColumns.TYPE,
+ NoteColumns.WIDGET_ID,
+ NoteColumns.WIDGET_TYPE,
+ };
+ mBackgroundQueryHandler.startQuery(FOLDER_NOTE_LIST_QUERY_TOKEN, null,
+ Notes.CONTENT_NOTE_URI, PROJECTION, selection, new String[]{
+ String.valueOf(mCurrentFolderId)
+ }, NoteColumns.TYPE + " DESC," + NoteColumns.MODIFIED_DATE + " DESC");
+ }
+ } catch (Exception e) {
+ Log.e(TAG, "startAsyncNotesListQuery error: " + e.getMessage(), e);
+ }
}
+ /**
+ * 后台查询处理器
+ * 处理异步查询结果
+ */
private final class BackgroundQueryHandler extends AsyncQueryHandler {
public BackgroundQueryHandler(ContentResolver contentResolver) {
super(contentResolver);
}
+ /**
+ * 查询完成时回调
+ * 根据查询令牌处理不同的查询结果
+ */
@Override
protected void onQueryComplete(int token, Object cookie, Cursor cursor) {
- switch (token) {
- case FOLDER_NOTE_LIST_QUERY_TOKEN:
- mNotesListAdapter.changeCursor(cursor);
- break;
- case FOLDER_LIST_QUERY_TOKEN:
- if (cursor != null && cursor.getCount() > 0) {
- showFolderListMenu(cursor);
- } else {
- Log.e(TAG, "Query folder failed");
- }
- break;
- default:
- return;
+ try {
+ switch (token) {
+ case FOLDER_NOTE_LIST_QUERY_TOKEN:
+ if (mNotesListAdapter != null) {
+ mNotesListAdapter.changeCursor(cursor); // 更新便签列表适配器
+ }
+ break;
+ case FOLDER_LIST_QUERY_TOKEN:
+ if (cursor != null && cursor.getCount() > 0) {
+ showFolderListMenu(cursor); // 显示文件夹列表菜单
+ } else {
+ Log.e(TAG, "Query folder failed");
+ }
+ break;
+ default:
+ break;
+ }
+ } catch (Exception e) {
+ Log.e(TAG, "onQueryComplete error: " + e.getMessage(), e);
+ if (cursor != null) {
+ cursor.close();
+ }
}
}
}
+ /**
+ * 显示文件夹列表菜单
+ * 用于选择移动便签的目标文件夹
+ */
private void showFolderListMenu(Cursor cursor) {
- AlertDialog.Builder builder = new AlertDialog.Builder(NotesListActivity.this);
- builder.setTitle(R.string.menu_title_select_folder);
- final FoldersListAdapter adapter = new FoldersListAdapter(this, cursor);
- builder.setAdapter(adapter, new DialogInterface.OnClickListener() {
-
- public void onClick(DialogInterface dialog, int which) {
- DataUtils.batchMoveToFolder(mContentResolver,
- mNotesListAdapter.getSelectedItemIds(), adapter.getItemId(which));
- Toast.makeText(
- NotesListActivity.this,
- getString(R.string.format_move_notes_to_folder,
- mNotesListAdapter.getSelectedCount(),
- adapter.getFolderName(NotesListActivity.this, which)),
- Toast.LENGTH_SHORT).show();
- mModeCallBack.finishActionMode();
+ try {
+ AlertDialog.Builder builder = new AlertDialog.Builder(NotesListActivity.this);
+ builder.setTitle(R.string.menu_title_select_folder);
+ final FoldersListAdapter adapter = new FoldersListAdapter(this, cursor);
+ builder.setAdapter(adapter, new DialogInterface.OnClickListener() {
+ public void onClick(DialogInterface dialog, int which) {
+ if (mContentResolver != null && mNotesListAdapter != null) {
+ // 批量移动便签到目标文件夹
+ DataUtils.batchMoveToFolder(mContentResolver,
+ mNotesListAdapter.getSelectedItemIds(), adapter.getItemId(which));
+ Toast.makeText(
+ NotesListActivity.this,
+ getString(R.string.format_move_notes_to_folder,
+ mNotesListAdapter.getSelectedCount(),
+ adapter.getFolderName(NotesListActivity.this, which)),
+ Toast.LENGTH_SHORT).show();
+ mModeCallBack.finishActionMode(); // 结束操作模式
+ }
+ }
+ });
+ builder.show();
+ } catch (Exception e) {
+ Log.e(TAG, "showFolderListMenu error: " + e.getMessage(), e);
+ if (cursor != null) {
+ cursor.close();
}
- });
- builder.show();
+ }
}
+ /**
+ * 创建新便签
+ * 启动便签编辑活动
+ */
private void createNewNote() {
- Intent intent = new Intent(this, NoteEditActivity.class);
- intent.setAction(Intent.ACTION_INSERT_OR_EDIT);
- intent.putExtra(Notes.INTENT_EXTRA_FOLDER_ID, mCurrentFolderId);
- this.startActivityForResult(intent, REQUEST_CODE_NEW_NODE);
+ try {
+ Intent intent = new Intent(this, NoteEditActivity.class);
+ intent.setAction(Intent.ACTION_INSERT_OR_EDIT);
+ intent.putExtra(Notes.INTENT_EXTRA_FOLDER_ID, mCurrentFolderId);
+ this.startActivityForResult(intent, REQUEST_CODE_NEW_NODE);
+ } catch (Exception e) {
+ Log.e(TAG, "createNewNote error: " + e.getMessage(), e);
+ }
}
+ /**
+ * 批量删除便签
+ * 在异步任务中执行删除操作
+ */
private void batchDelete() {
- new AsyncTask>() {
- protected HashSet doInBackground(Void... unused) {
- HashSet widgets = mNotesListAdapter.getSelectedWidget();
- if (!isSyncMode()) {
- // if not synced, delete notes directly
- if (DataUtils.batchDeleteNotes(mContentResolver, mNotesListAdapter
- .getSelectedItemIds())) {
- } else {
- Log.e(TAG, "Delete notes error, should not happens");
+ try {
+ mCurrentAsyncTask = new AsyncTask>() {
+ protected HashSet doInBackground(Void... unused) {
+ HashSet widgets = null;
+ if (mNotesListAdapter != null) {
+ widgets = mNotesListAdapter.getSelectedWidget();
}
- } else {
- // in sync mode, we'll move the deleted note into the trash
- // folder
- if (!DataUtils.batchMoveToFolder(mContentResolver, mNotesListAdapter
- .getSelectedItemIds(), Notes.ID_TRASH_FOLER)) {
- Log.e(TAG, "Move notes to trash folder error, should not happens");
+ if (mContentResolver != null && mNotesListAdapter != null) {
+ // 根据同步模式决定是删除还是移动到回收站
+ if (!isSyncMode()) {
+ DataUtils.batchDeleteNotes(mContentResolver, mNotesListAdapter
+ .getSelectedItemIds());
+ } else {
+ DataUtils.batchMoveToFolder(mContentResolver, mNotesListAdapter
+ .getSelectedItemIds(), Notes.ID_TRASH_FOLER);
+ }
}
+ return widgets;
}
- return widgets;
- }
- @Override
- protected void onPostExecute(HashSet widgets) {
- if (widgets != null) {
- for (AppWidgetAttribute widget : widgets) {
- if (widget.widgetId != AppWidgetManager.INVALID_APPWIDGET_ID
- && widget.widgetType != Notes.TYPE_WIDGET_INVALIDE) {
- updateWidget(widget.widgetId, widget.widgetType);
+ @Override
+ protected void onPostExecute(HashSet widgets) {
+ if (widgets != null) {
+ // 更新相关的桌面小部件
+ for (AppWidgetAttribute widget : widgets) {
+ if (widget.widgetId != AppWidgetManager.INVALID_APPWIDGET_ID
+ && widget.widgetType != Notes.TYPE_WIDGET_INVALIDE) {
+ updateWidget(widget.widgetId, widget.widgetType);
+ }
}
}
+ if (mModeCallBack != null) {
+ mModeCallBack.finishActionMode(); // 结束操作模式
+ }
}
- mModeCallBack.finishActionMode();
- }
- }.execute();
+ }.execute();
+ } catch (Exception e) {
+ Log.e(TAG, "batchDelete error: " + e.getMessage(), e);
+ }
}
+ /**
+ * 删除文件夹
+ * 删除文件夹及其包含的便签
+ */
private void deleteFolder(long folderId) {
- if (folderId == Notes.ID_ROOT_FOLDER) {
- Log.e(TAG, "Wrong folder id, should not happen " + folderId);
- return;
- }
+ try {
+ if (folderId == Notes.ID_ROOT_FOLDER) {
+ Log.e(TAG, "Wrong folder id, should not happen " + folderId);
+ return;
+ }
- HashSet ids = new HashSet();
- ids.add(folderId);
- HashSet widgets = DataUtils.getFolderNoteWidget(mContentResolver,
- folderId);
- if (!isSyncMode()) {
- // if not synced, delete folder directly
- DataUtils.batchDeleteNotes(mContentResolver, ids);
- } else {
- // in sync mode, we'll move the deleted folder into the trash folder
- DataUtils.batchMoveToFolder(mContentResolver, ids, Notes.ID_TRASH_FOLER);
- }
- if (widgets != null) {
- for (AppWidgetAttribute widget : widgets) {
- if (widget.widgetId != AppWidgetManager.INVALID_APPWIDGET_ID
- && widget.widgetType != Notes.TYPE_WIDGET_INVALIDE) {
- updateWidget(widget.widgetId, widget.widgetType);
+ HashSet ids = new HashSet();
+ ids.add(folderId);
+ HashSet widgets = null;
+ if (mContentResolver != null) {
+ widgets = DataUtils.getFolderNoteWidget(mContentResolver, folderId);
+ }
+
+ if (mContentResolver != null) {
+ // 根据同步模式决定是删除还是移动到回收站
+ if (!isSyncMode()) {
+ DataUtils.batchDeleteNotes(mContentResolver, ids);
+ } else {
+ DataUtils.batchMoveToFolder(mContentResolver, ids, Notes.ID_TRASH_FOLER);
}
}
+
+ if (widgets != null) {
+ // 更新相关的桌面小部件
+ for (AppWidgetAttribute widget : widgets) {
+ if (widget.widgetId != AppWidgetManager.INVALID_APPWIDGET_ID
+ && widget.widgetType != Notes.TYPE_WIDGET_INVALIDE) {
+ updateWidget(widget.widgetId, widget.widgetType);
+ }
+ }
+ }
+ } catch (Exception e) {
+ Log.e(TAG, "deleteFolder error: " + e.getMessage(), e);
}
}
+ /**
+ * 打开便签
+ * 启动便签编辑活动查看便签详情
+ */
private void openNode(NoteItemData data) {
- Intent intent = new Intent(this, NoteEditActivity.class);
- intent.setAction(Intent.ACTION_VIEW);
- intent.putExtra(Intent.EXTRA_UID, data.getId());
- this.startActivityForResult(intent, REQUEST_CODE_OPEN_NODE);
+ try {
+ if (data != null) {
+ Intent intent = new Intent(this, NoteEditActivity.class);
+ intent.setAction(Intent.ACTION_VIEW);
+ intent.putExtra(Intent.EXTRA_UID, data.getId());
+ this.startActivityForResult(intent, REQUEST_CODE_OPEN_NODE);
+ }
+ } catch (Exception e) {
+ Log.e(TAG, "openNode error: " + e.getMessage(), e);
+ }
}
+ /**
+ * 打开文件夹
+ * 显示文件夹内的便签列表
+ */
private void openFolder(NoteItemData data) {
- mCurrentFolderId = data.getId();
- startAsyncNotesListQuery();
- if (data.getId() == Notes.ID_CALL_RECORD_FOLDER) {
- mState = ListEditState.CALL_RECORD_FOLDER;
- mAddNewNote.setVisibility(View.GONE);
- } else {
- mState = ListEditState.SUB_FOLDER;
- }
- if (data.getId() == Notes.ID_CALL_RECORD_FOLDER) {
- mTitleBar.setText(R.string.call_record_folder_name);
- } else {
- mTitleBar.setText(data.getSnippet());
+ try {
+ if (data != null) {
+ mCurrentFolderId = data.getId();
+ startAsyncNotesListQuery(); // 查询当前文件夹的便签列表
+
+ // 根据文件夹类型更新界面状态
+ if (data.getId() == Notes.ID_CALL_RECORD_FOLDER) {
+ mState = ListEditState.CALL_RECORD_FOLDER;
+ if (mAddNewNote != null) {
+ mAddNewNote.setVisibility(View.GONE);
+ }
+ } else {
+ mState = ListEditState.SUB_FOLDER;
+ }
+ if (mTitleBar != null) {
+ if (data.getId() == Notes.ID_CALL_RECORD_FOLDER) {
+ mTitleBar.setText(R.string.call_record_folder_name);
+ } else {
+ mTitleBar.setText(data.getSnippet());
+ }
+ mTitleBar.setVisibility(View.VISIBLE);
+ }
+ }
+ } catch (Exception e) {
+ Log.e(TAG, "openFolder error: " + e.getMessage(), e);
}
- mTitleBar.setVisibility(View.VISIBLE);
}
+ /**
+ * 视图点击回调
+ * 处理添加新便签按钮的点击事件
+ */
public void onClick(View v) {
- switch (v.getId()) {
- case R.id.btn_new_note:
- createNewNote();
- break;
- default:
- break;
+ try {
+ switch (v.getId()) {
+ case R.id.btn_new_note:
+ createNewNote(); // 创建新便签
+ break;
+ default:
+ break;
+ }
+ } catch (Exception e) {
+ Log.e(TAG, "onClick error: " + e.getMessage(), e);
}
}
+ /**
+ * 显示软键盘
+ */
private void showSoftInput() {
- InputMethodManager inputMethodManager = (InputMethodManager) getSystemService(Context.INPUT_METHOD_SERVICE);
- if (inputMethodManager != null) {
- inputMethodManager.toggleSoftInput(InputMethodManager.SHOW_FORCED, 0);
+ try {
+ InputMethodManager inputMethodManager = (InputMethodManager) getSystemService(Context.INPUT_METHOD_SERVICE);
+ if (inputMethodManager != null) {
+ inputMethodManager.toggleSoftInput(InputMethodManager.SHOW_FORCED, 0);
+ }
+ } catch (Exception e) {
+ Log.e(TAG, "showSoftInput error: " + e.getMessage(), e);
}
}
+ /**
+ * 隐藏软键盘
+ */
private void hideSoftInput(View view) {
- InputMethodManager inputMethodManager = (InputMethodManager) getSystemService(Context.INPUT_METHOD_SERVICE);
- inputMethodManager.hideSoftInputFromWindow(view.getWindowToken(), 0);
+ try {
+ InputMethodManager inputMethodManager = (InputMethodManager) getSystemService(Context.INPUT_METHOD_SERVICE);
+ if (inputMethodManager != null && view != null) {
+ inputMethodManager.hideSoftInputFromWindow(view.getWindowToken(), 0);
+ }
+ } catch (Exception e) {
+ Log.e(TAG, "hideSoftInput error: " + e.getMessage(), e);
+ }
}
+ /**
+ * 显示创建或修改文件夹对话框
+ * @param create 是否为创建新文件夹
+ */
private void showCreateOrModifyFolderDialog(final boolean create) {
- final AlertDialog.Builder builder = new AlertDialog.Builder(this);
- View view = LayoutInflater.from(this).inflate(R.layout.dialog_edit_text, null);
- final EditText etName = (EditText) view.findViewById(R.id.et_foler_name);
- showSoftInput();
- if (!create) {
- if (mFocusNoteDataItem != null) {
- etName.setText(mFocusNoteDataItem.getSnippet());
- builder.setTitle(getString(R.string.menu_folder_change_name));
+ try {
+ AlertDialog.Builder builder = new AlertDialog.Builder(this);
+ View view = LayoutInflater.from(this).inflate(R.layout.dialog_edit_text, null);
+ final EditText etName = (EditText) view.findViewById(R.id.et_foler_name);
+ showSoftInput(); // 显示软键盘
+
+ // 根据操作类型设置对话框标题和初始文本
+ if (!create) {
+ if (mFocusNoteDataItem != null) {
+ etName.setText(mFocusNoteDataItem.getSnippet());
+ builder.setTitle(getString(R.string.menu_folder_change_name));
+ } else {
+ Log.e(TAG, "The long click data item is null");
+ return;
+ }
} else {
- Log.e(TAG, "The long click data item is null");
- return;
+ etName.setText("");
+ builder.setTitle(this.getString(R.string.menu_create_folder));
}
- } else {
- etName.setText("");
- builder.setTitle(this.getString(R.string.menu_create_folder));
- }
- builder.setPositiveButton(android.R.string.ok, null);
- builder.setNegativeButton(android.R.string.cancel, new DialogInterface.OnClickListener() {
- public void onClick(DialogInterface dialog, int which) {
- hideSoftInput(etName);
- }
- });
-
- final Dialog dialog = builder.setView(view).show();
- final Button positive = (Button)dialog.findViewById(android.R.id.button1);
- positive.setOnClickListener(new OnClickListener() {
- public void onClick(View v) {
- hideSoftInput(etName);
- String name = etName.getText().toString();
- if (DataUtils.checkVisibleFolderName(mContentResolver, name)) {
- Toast.makeText(NotesListActivity.this, getString(R.string.folder_exist, name),
- Toast.LENGTH_LONG).show();
- etName.setSelection(0, etName.length());
- return;
+ builder.setPositiveButton(android.R.string.ok, null);
+ builder.setNegativeButton(android.R.string.cancel, new DialogInterface.OnClickListener() {
+ public void onClick(DialogInterface dialog, int which) {
+ hideSoftInput(etName); // 隐藏软键盘
}
- if (!create) {
- if (!TextUtils.isEmpty(name)) {
+ });
+
+ final Dialog dialog = builder.setView(view).show();
+ final Button positive = (Button) dialog.findViewById(android.R.id.button1);
+ positive.setOnClickListener(new OnClickListener() {
+ public void onClick(View v) {
+ hideSoftInput(etName); // 隐藏软键盘
+ String name = etName.getText().toString();
+ // 检查文件夹名称是否已存在
+ if (mContentResolver != null && DataUtils.checkVisibleFolderName(mContentResolver, name)) {
+ Toast.makeText(NotesListActivity.this, getString(R.string.folder_exist, name),
+ Toast.LENGTH_LONG).show();
+ etName.setSelection(0, etName.length());
+ return;
+ }
+ // 根据操作类型执行创建或修改文件夹
+ if (!create && mFocusNoteDataItem != null) {
+ if (!TextUtils.isEmpty(name)) {
+ ContentValues values = new ContentValues();
+ values.put(NoteColumns.SNIPPET, name);
+ values.put(NoteColumns.TYPE, Notes.TYPE_FOLDER);
+ values.put(NoteColumns.LOCAL_MODIFIED, 1);
+ mContentResolver.update(Notes.CONTENT_NOTE_URI, values, NoteColumns.ID
+ + "=?", new String[]{
+ String.valueOf(mFocusNoteDataItem.getId())
+ });
+ }
+ } else if (!TextUtils.isEmpty(name)) {
ContentValues values = new ContentValues();
values.put(NoteColumns.SNIPPET, name);
values.put(NoteColumns.TYPE, Notes.TYPE_FOLDER);
- values.put(NoteColumns.LOCAL_MODIFIED, 1);
- mContentResolver.update(Notes.CONTENT_NOTE_URI, values, NoteColumns.ID
- + "=?", new String[] {
- String.valueOf(mFocusNoteDataItem.getId())
- });
+ if (mContentResolver != null) {
+ mContentResolver.insert(Notes.CONTENT_NOTE_URI, values);
+ }
}
- } else if (!TextUtils.isEmpty(name)) {
- ContentValues values = new ContentValues();
- values.put(NoteColumns.SNIPPET, name);
- values.put(NoteColumns.TYPE, Notes.TYPE_FOLDER);
- mContentResolver.insert(Notes.CONTENT_NOTE_URI, values);
+ dialog.dismiss();
}
- dialog.dismiss();
- }
- });
-
- if (TextUtils.isEmpty(etName.getText())) {
- positive.setEnabled(false);
- }
- /**
- * When the name edit text is null, disable the positive button
- */
- etName.addTextChangedListener(new TextWatcher() {
- public void beforeTextChanged(CharSequence s, int start, int count, int after) {
- // TODO Auto-generated method stub
+ });
+ // 根据输入框内容启用或禁用确认按钮
+ if (TextUtils.isEmpty(etName.getText())) {
+ positive.setEnabled(false);
}
- public void onTextChanged(CharSequence s, int start, int before, int count) {
- if (TextUtils.isEmpty(etName.getText())) {
- positive.setEnabled(false);
- } else {
- positive.setEnabled(true);
+ etName.addTextChangedListener(new TextWatcher() {
+ public void beforeTextChanged(CharSequence s, int start, int count, int after) {
}
- }
- public void afterTextChanged(Editable s) {
- // TODO Auto-generated method stub
+ public void onTextChanged(CharSequence s, int start, int before, int count) {
+ if (positive != null) {
+ positive.setEnabled(!TextUtils.isEmpty(etName.getText()));
+ }
+ }
- }
- });
+ public void afterTextChanged(Editable s) {
+ }
+ });
+ } catch (Exception e) {
+ Log.e(TAG, "showCreateOrModifyFolderDialog error: " + e.getMessage(), e);
+ }
}
+ /**
+ * 处理返回按钮点击
+ * 根据当前状态处理返回逻辑
+ */
@Override
public void onBackPressed() {
- switch (mState) {
- case SUB_FOLDER:
- mCurrentFolderId = Notes.ID_ROOT_FOLDER;
- mState = ListEditState.NOTE_LIST;
- startAsyncNotesListQuery();
- mTitleBar.setVisibility(View.GONE);
- break;
- case CALL_RECORD_FOLDER:
- mCurrentFolderId = Notes.ID_ROOT_FOLDER;
- mState = ListEditState.NOTE_LIST;
- mAddNewNote.setVisibility(View.VISIBLE);
- mTitleBar.setVisibility(View.GONE);
- startAsyncNotesListQuery();
- break;
- case NOTE_LIST:
- super.onBackPressed();
- break;
- default:
- break;
+ try {
+ switch (mState) {
+ case SUB_FOLDER:
+ // 从子文件夹返回根文件夹
+ mCurrentFolderId = Notes.ID_ROOT_FOLDER;
+ mState = ListEditState.NOTE_LIST;
+ startAsyncNotesListQuery();
+ if (mTitleBar != null) {
+ mTitleBar.setVisibility(View.GONE);
+ }
+ break;
+ case CALL_RECORD_FOLDER:
+ // 从通话记录文件夹返回根文件夹
+ mCurrentFolderId = Notes.ID_ROOT_FOLDER;
+ mState = ListEditState.NOTE_LIST;
+ if (mAddNewNote != null) {
+ mAddNewNote.setVisibility(View.VISIBLE);
+ }
+ if (mTitleBar != null) {
+ mTitleBar.setVisibility(View.GONE);
+ }
+ startAsyncNotesListQuery();
+ break;
+ case NOTE_LIST:
+ super.onBackPressed();
+ break;
+ default:
+ break;
+ }
+ } catch (Exception e) {
+ Log.e(TAG, "onBackPressed error: " + e.getMessage(), e);
}
}
+ /**
+ * 更新桌面小部件
+ * @param appWidgetId 小部件ID
+ * @param appWidgetType 小部件类型
+ */
private void updateWidget(int appWidgetId, int appWidgetType) {
- Intent intent = new Intent(AppWidgetManager.ACTION_APPWIDGET_UPDATE);
- if (appWidgetType == Notes.TYPE_WIDGET_2X) {
- intent.setClass(this, NoteWidgetProvider_2x.class);
- } else if (appWidgetType == 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[] {
- appWidgetId
- });
+ try {
+ Intent intent = new Intent(AppWidgetManager.ACTION_APPWIDGET_UPDATE);
+ // 根据小部件类型设置对应的提供者类
+ if (appWidgetType == Notes.TYPE_WIDGET_2X) {
+ intent.setClass(this, NoteWidgetProvider_2x.class);
+ } else if (appWidgetType == Notes.TYPE_WIDGET_4X) {
+ intent.setClass(this, NoteWidgetProvider_4x.class);
+ } else {
+ Log.e(TAG, "Unspported widget type");
+ return;
+ }
- sendBroadcast(intent);
- setResult(RESULT_OK, intent);
+ intent.putExtra(AppWidgetManager.EXTRA_APPWIDGET_IDS, new int[]{appWidgetId});
+ sendBroadcast(intent);
+ setResult(RESULT_OK, intent);
+ } catch (Exception e) {
+ Log.e(TAG, "updateWidget error: " + e.getMessage(), e);
+ }
}
+ /**
+ * 文件夹上下文菜单创建监听器
+ * 为文件夹项创建上下文菜单
+ */
private final OnCreateContextMenuListener mFolderOnCreateContextMenuListener = new OnCreateContextMenuListener() {
public void onCreateContextMenu(ContextMenu menu, View v, ContextMenuInfo menuInfo) {
- if (mFocusNoteDataItem != null) {
- menu.setHeaderTitle(mFocusNoteDataItem.getSnippet());
- menu.add(0, MENU_FOLDER_VIEW, 0, R.string.menu_folder_view);
- menu.add(0, MENU_FOLDER_DELETE, 0, R.string.menu_folder_delete);
- menu.add(0, MENU_FOLDER_CHANGE_NAME, 0, R.string.menu_folder_change_name);
+ try {
+ if (mFocusNoteDataItem != null) {
+ // 设置菜单标题和菜单项
+ menu.setHeaderTitle(mFocusNoteDataItem.getSnippet());
+ menu.add(0, MENU_FOLDER_VIEW, 0, R.string.menu_folder_view);
+ menu.add(0, MENU_FOLDER_DELETE, 0, R.string.menu_folder_delete);
+ menu.add(0, MENU_FOLDER_CHANGE_NAME, 0, R.string.menu_folder_change_name);
+ }
+ } catch (Exception e) {
+ Log.e(TAG, "onCreateContextMenu error: " + e.getMessage(), e);
}
}
};
+ /**
+ * 上下文菜单关闭回调
+ * 清除上下文菜单监听器
+ */
@Override
public void onContextMenuClosed(Menu menu) {
- if (mNotesListView != null) {
- mNotesListView.setOnCreateContextMenuListener(null);
+ try {
+ if (mNotesListView != null) {
+ mNotesListView.setOnCreateContextMenuListener(null);
+ }
+ super.onContextMenuClosed(menu);
+ } catch (Exception e) {
+ Log.e(TAG, "onContextMenuClosed error: " + e.getMessage(), e);
}
- super.onContextMenuClosed(menu);
}
+ /**
+ * 上下文菜单项选中回调
+ * 处理文件夹上下文菜单的选择事件
+ */
@Override
public boolean onContextItemSelected(MenuItem item) {
- if (mFocusNoteDataItem == null) {
- Log.e(TAG, "The long click data item is null");
+ try {
+ if (mFocusNoteDataItem == null) {
+ Log.e(TAG, "The long click data item is null");
+ return false;
+ }
+ switch (item.getItemId()) {
+ case MENU_FOLDER_VIEW:
+ openFolder(mFocusNoteDataItem); // 打开文件夹
+ break;
+ case MENU_FOLDER_DELETE:
+ showDeleteFolderDialog(); // 显示删除文件夹对话框
+ break;
+ case MENU_FOLDER_CHANGE_NAME:
+ showCreateOrModifyFolderDialog(false); // 显示重命名文件夹对话框
+ break;
+ default:
+ break;
+ }
+ return true;
+ } catch (Exception e) {
+ Log.e(TAG, "onContextItemSelected error: " + e.getMessage(), e);
return false;
}
- switch (item.getItemId()) {
- case MENU_FOLDER_VIEW:
- openFolder(mFocusNoteDataItem);
- break;
- case MENU_FOLDER_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_folder));
- builder.setPositiveButton(android.R.string.ok,
- new DialogInterface.OnClickListener() {
- public void onClick(DialogInterface dialog, int which) {
- deleteFolder(mFocusNoteDataItem.getId());
- }
- });
- builder.setNegativeButton(android.R.string.cancel, null);
- builder.show();
- break;
- case MENU_FOLDER_CHANGE_NAME:
- showCreateOrModifyFolderDialog(false);
- break;
- default:
- break;
- }
+ }
- return true;
+ /**
+ * 显示删除文件夹对话框
+ */
+ private void showDeleteFolderDialog() {
+ 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_folder));
+ builder.setPositiveButton(android.R.string.ok,
+ new DialogInterface.OnClickListener() {
+ public void onClick(DialogInterface dialog, int which) {
+ deleteFolder(mFocusNoteDataItem.getId()); // 删除文件夹
+ }
+ });
+ builder.setNegativeButton(android.R.string.cancel, null);
+ builder.show();
}
+ /**
+ * 准备选项菜单
+ * 根据当前状态加载对应的菜单资源
+ */
@Override
public boolean onPrepareOptionsMenu(Menu menu) {
- menu.clear();
- if (mState == ListEditState.NOTE_LIST) {
- getMenuInflater().inflate(R.menu.note_list, menu);
- // set sync or sync_cancel
- menu.findItem(R.id.menu_sync).setTitle(
- GTaskSyncService.isSyncing() ? R.string.menu_sync_cancel : R.string.menu_sync);
- } else if (mState == ListEditState.SUB_FOLDER) {
- getMenuInflater().inflate(R.menu.sub_folder, menu);
- } else if (mState == ListEditState.CALL_RECORD_FOLDER) {
- getMenuInflater().inflate(R.menu.call_record_folder, menu);
- } else {
- Log.e(TAG, "Wrong state:" + mState);
- }
- return true;
+ try {
+ // 清空菜单并根据状态加载不同的菜单资源
+ menu.clear();
+ if (mState == ListEditState.NOTE_LIST) {
+ getMenuInflater().inflate(R.menu.note_list, menu);
+ menu.findItem(R.id.menu_sync).setTitle(
+ GTaskSyncService.isSyncing() ? R.string.menu_sync_cancel : R.string.menu_sync);
+ } else if (mState == ListEditState.SUB_FOLDER) {
+ getMenuInflater().inflate(R.menu.sub_folder, menu);
+ } else if (mState == ListEditState.CALL_RECORD_FOLDER) {
+ getMenuInflater().inflate(R.menu.call_record_folder, menu);
+ } else {
+ Log.e(TAG, "Wrong state:" + mState);
+ }
+
+ // 根据私密模式状态设置菜单项可见性
+ MenuItem secretItem = menu.findItem(R.id.menu_secret);
+ MenuItem quitSecretItem = menu.findItem(R.id.menu_quit_secret);
+
+ if (secretItem != null) {
+ secretItem.setVisible(secret_mode == 0);
+ }
+ if (quitSecretItem != null) {
+ quitSecretItem.setVisible(secret_mode == 1);
+ }
+
+ return true;
+ } catch (Exception e) {
+ Log.e(TAG, "onPrepareOptionsMenu error: " + e.getMessage(), e);
+ return false;
+ }
}
+ /**
+ * 选项菜单项选中回调
+ * 处理选项菜单的选择事件
+ */
@Override
public boolean onOptionsItemSelected(MenuItem item) {
- switch (item.getItemId()) {
- case R.id.menu_new_folder: {
- showCreateOrModifyFolderDialog(true);
- break;
- }
- case R.id.menu_export_text: {
- exportNoteToText();
- break;
- }
- case R.id.menu_sync: {
- if (isSyncMode()) {
- if (TextUtils.equals(item.getTitle(), getString(R.string.menu_sync))) {
- GTaskSyncService.startSync(this);
+ try {
+ switch (item.getItemId()) {
+ case R.id.menu_secret:
+ showSecretModeDialog(true); // 显示进入私密模式对话框
+ break;
+ case R.id.menu_quit_secret:
+ showSecretModeDialog(false); // 显示退出私密模式对话框
+ break;
+ case R.id.menu_new_folder:
+ showCreateOrModifyFolderDialog(true); // 显示创建文件夹对话框
+ break;
+ case R.id.menu_export_text:
+ exportNoteToText(); // 导出便签为文本
+ break;
+ case R.id.menu_sync:
+ // 处理同步相关操作
+ if (isSyncMode()) {
+ if (TextUtils.equals(item.getTitle(), getString(R.string.menu_sync))) {
+ GTaskSyncService.startSync(this);
+ } else {
+ GTaskSyncService.cancelSync(this);
+ }
} else {
- GTaskSyncService.cancelSync(this);
+ startPreferenceActivity();
}
+ break;
+ case R.id.menu_setting:
+ startPreferenceActivity(); // 启动设置活动
+ break;
+ case R.id.menu_new_note:
+ createNewNote(); // 创建新便签
+ break;
+ case R.id.menu_search:
+ onSearchRequested(); // 启动搜索
+ break;
+ default:
+ break;
+ }
+ return true;
+ } catch (Exception e) {
+ Log.e(TAG, "onOptionsItemSelected error: " + e.getMessage(), e);
+ return false;
+ }
+ }
+
+ /**
+ * 显示私密模式切换对话框
+ * @param enter 是否进入私密模式
+ */
+ private void showSecretModeDialog(final boolean enter) {
+ AlertDialog.Builder dialog = new AlertDialog.Builder(NotesListActivity.this);
+ dialog.setTitle("重要提醒");
+ dialog.setMessage(enter ? "您确认进入私密模式吗？" : "您确认退出私密模式吗？");
+ dialog.setCancelable(false);
+ dialog.setPositiveButton("确认", new DialogInterface.OnClickListener() {
+ @Override
+ public void onClick(DialogInterface dialog, int which) {
+ // 只有在用户确认后才切换私密模式并刷新列表
+ if (enter) {
+ secret_mode = 1;
+ Toast.makeText(NotesListActivity.this, "您已进入私密模式", Toast.LENGTH_SHORT).show();
} else {
- startPreferenceActivity();
+ secret_mode = 0;
+ Toast.makeText(NotesListActivity.this, "您已退出私密模式", Toast.LENGTH_SHORT).show();
}
- break;
- }
- case R.id.menu_setting: {
- startPreferenceActivity();
- break;
+ startAsyncNotesListQuery(); // 刷新便签列表
}
- case R.id.menu_new_note: {
- createNewNote();
- break;
+ });
+ dialog.setNegativeButton("取消", new DialogInterface.OnClickListener() {
+ @Override
+ public void onClick(DialogInterface dialog, int which) {
+ // 取消时不做任何操作
}
- case R.id.menu_search:
- onSearchRequested();
- break;
- default:
- break;
- }
- return true;
+ });
+ dialog.show();
}
+ /**
+ * 处理搜索请求
+ */
@Override
public boolean onSearchRequested() {
- startSearch(null, false, null /* appData */, false);
- return true;
+ try {
+ startSearch(null, false, null, false);
+ return true;
+ } catch (Exception e) {
+ Log.e(TAG, "onSearchRequested error: " + e.getMessage(), e);
+ return false;
+ }
}
+ /**
+ * 导出便签为文本文件
+ */
private void exportNoteToText() {
- final BackupUtils backup = BackupUtils.getInstance(NotesListActivity.this);
- new AsyncTask() {
-
- @Override
- protected Integer doInBackground(Void... unused) {
- return backup.exportToText();
+ try {
+ if (ContextCompat.checkSelfPermission(this, Manifest.permission.WRITE_EXTERNAL_STORAGE)
+ != PackageManager.PERMISSION_GRANTED) {
+ ActivityCompat.requestPermissions(this,
+ new String[]{Manifest.permission.WRITE_EXTERNAL_STORAGE},
+ PERMISSION_REQUEST_STORAGE);
+ return;
}
- @Override
- protected void onPostExecute(Integer result) {
- if (result == BackupUtils.STATE_SD_CARD_UNMOUONTED) {
- AlertDialog.Builder builder = new AlertDialog.Builder(NotesListActivity.this);
- builder.setTitle(NotesListActivity.this
- .getString(R.string.failed_sdcard_export));
- builder.setMessage(NotesListActivity.this
- .getString(R.string.error_sdcard_unmounted));
- builder.setPositiveButton(android.R.string.ok, null);
- builder.show();
- } else if (result == BackupUtils.STATE_SUCCESS) {
- AlertDialog.Builder builder = new AlertDialog.Builder(NotesListActivity.this);
- builder.setTitle(NotesListActivity.this
- .getString(R.string.success_sdcard_export));
- builder.setMessage(NotesListActivity.this.getString(
- R.string.format_exported_file_location, backup
- .getExportedTextFileName(), backup.getExportedTextFileDir()));
- builder.setPositiveButton(android.R.string.ok, null);
- builder.show();
- } else if (result == BackupUtils.STATE_SYSTEM_ERROR) {
- AlertDialog.Builder builder = new AlertDialog.Builder(NotesListActivity.this);
- builder.setTitle(NotesListActivity.this
- .getString(R.string.failed_sdcard_export));
- builder.setMessage(NotesListActivity.this
- .getString(R.string.error_sdcard_export));
- builder.setPositiveButton(android.R.string.ok, null);
- builder.show();
- }
- }
-
- }.execute();
+ final BackupUtils backup = BackupUtils.getInstance(NotesListActivity.this);
+ mCurrentAsyncTask = new AsyncTask() {
+ @Override
+ protected Integer doInBackground(Void... unused) {
+ return backup.exportToText(); // 执行导出操作
+ }
+
+ @Override
+ protected void onPostExecute(Integer result) {
+ showExportResultDialog(result); // 显示导出结果对话框
+ }
+ }.execute();
+ } catch (Exception e) {
+ Log.e(TAG, "exportNoteToText error: " + e.getMessage(), e);
+ }
}
+ /**
+ * 显示导出结果对话框
+ * @param result 导出结果状态
+ */
+ private void showExportResultDialog(int result) {
+ try {
+ AlertDialog.Builder builder = new AlertDialog.Builder(NotesListActivity.this);
+ // 根据导出结果显示不同的提示信息
+ if (result == BackupUtils.STATE_SD_CARD_UNMOUONTED) {
+ builder.setTitle(getString(R.string.failed_sdcard_export));
+ builder.setMessage(getString(R.string.error_sdcard_unmounted));
+ } else if (result == BackupUtils.STATE_SUCCESS) {
+ BackupUtils backup = BackupUtils.getInstance(NotesListActivity.this);
+ builder.setTitle(getString(R.string.success_sdcard_export));
+ builder.setMessage(getString(
+ R.string.format_exported_file_location,
+ backup.getExportedTextFileName(),
+ backup.getExportedTextFileDir()));
+ } else if (result == BackupUtils.STATE_SYSTEM_ERROR) {
+ builder.setTitle(getString(R.string.failed_sdcard_export));
+ builder.setMessage(getString(R.string.error_sdcard_export));
+ }
+ builder.setPositiveButton(android.R.string.ok, null);
+ builder.show();
+ } catch (Exception e) {
+ Log.e(TAG, "showExportResultDialog error: " + e.getMessage(), e);
+ }
+ }
+
+ /**
+ * 判断是否为同步模式
+ * @return 是否已设置同步账户
+ */
private boolean isSyncMode() {
- return NotesPreferenceActivity.getSyncAccountName(this).trim().length() > 0;
+ try {
+ return NotesPreferenceActivity.getSyncAccountName(this).trim().length() > 0;
+ } catch (Exception e) {
+ Log.e(TAG, "isSyncMode error: " + e.getMessage(), e);
+ return false;
+ }
}
+ /**
+ * 启动设置活动
+ */
private void startPreferenceActivity() {
- Activity from = getParent() != null ? getParent() : this;
- Intent intent = new Intent(from, NotesPreferenceActivity.class);
- from.startActivityIfNeeded(intent, -1);
+ try {
+ Activity from = getParent() != null ? getParent() : this;
+ Intent intent = new Intent(from, NotesPreferenceActivity.class);
+ from.startActivityIfNeeded(intent, -1);
+ } catch (Exception e) {
+ Log.e(TAG, "startPreferenceActivity error: " + e.getMessage(), e);
+ }
}
+ /**
+ * 列表项点击监听器
+ * 处理便签列表项的点击事件
+ */
private class OnListItemClickListener implements OnItemClickListener {
-
public void onItemClick(AdapterView parent, View view, int position, long id) {
- if (view instanceof NotesListItem) {
- NoteItemData item = ((NotesListItem) view).getItemData();
- if (mNotesListAdapter.isInChoiceMode()) {
- if (item.getType() == Notes.TYPE_NOTE) {
- position = position - mNotesListView.getHeaderViewsCount();
- mModeCallBack.onItemCheckedStateChanged(null, position, id,
- !mNotesListAdapter.isSelectedItem(position));
- }
- return;
- }
-
- switch (mState) {
- case NOTE_LIST:
- if (item.getType() == Notes.TYPE_FOLDER
- || item.getType() == Notes.TYPE_SYSTEM) {
- openFolder(item);
- } else if (item.getType() == Notes.TYPE_NOTE) {
- openNode(item);
- } else {
- Log.e(TAG, "Wrong note type in NOTE_LIST");
- }
- break;
- case SUB_FOLDER:
- case CALL_RECORD_FOLDER:
+ try {
+ if (view instanceof NotesListItem) {
+ NoteItemData item = ((NotesListItem) view).getItemData();
+ if (mNotesListAdapter != null && mNotesListAdapter.isInChoiceMode()) {
+ // 多选模式下处理选中状态
if (item.getType() == Notes.TYPE_NOTE) {
- openNode(item);
- } else {
- Log.e(TAG, "Wrong note type in SUB_FOLDER");
+ position = position - mNotesListView.getHeaderViewsCount();
+ if (mModeCallBack != null) {
+ mModeCallBack.onItemCheckedStateChanged(null, position, id,
+ !mNotesListAdapter.isSelectedItem(position));
+ }
}
- break;
- default:
- break;
+ return;
+ }
+
+ // 根据当前状态处理不同类型的项点击
+ switch (mState) {
+ case NOTE_LIST:
+ if (item.getType() == Notes.TYPE_FOLDER
+ || item.getType() == Notes.TYPE_SYSTEM) {
+ openFolder(item); // 打开文件夹
+ } else if (item.getType() == Notes.TYPE_NOTE) {
+ openNode(item); // 打开便签
+ } else {
+ Log.e(TAG, "Wrong note type in NOTE_LIST");
+ }
+ break;
+ case SUB_FOLDER:
+ case CALL_RECORD_FOLDER:
+ if (item.getType() == Notes.TYPE_NOTE) {
+ openNode(item); // 打开便签
+ } else {
+ Log.e(TAG, "Wrong note type in SUB_FOLDER");
+ }
+ break;
+ default:
+ break;
+ }
}
+ } catch (Exception e) {
+ Log.e(TAG, "OnListItemClickListener error: " + e.getMessage(), e);
}
}
-
}
+ /**
+ * 开始查询目标文件夹
+ * 用于移动便签时选择目标文件夹
+ */
private void startQueryDestinationFolders() {
- String selection = NoteColumns.TYPE + "=? AND " + NoteColumns.PARENT_ID + "<>? AND " + NoteColumns.ID + "<>?";
- selection = (mState == ListEditState.NOTE_LIST) ? selection:
- "(" + selection + ") OR (" + NoteColumns.ID + "=" + Notes.ID_ROOT_FOLDER + ")";
-
- mBackgroundQueryHandler.startQuery(FOLDER_LIST_QUERY_TOKEN,
- null,
- Notes.CONTENT_NOTE_URI,
- FoldersListAdapter.PROJECTION,
- selection,
- new String[] {
- String.valueOf(Notes.TYPE_FOLDER),
- String.valueOf(Notes.ID_TRASH_FOLER),
- String.valueOf(mCurrentFolderId)
- },
- NoteColumns.MODIFIED_DATE + " DESC");
+ try {
+ String selection = NoteColumns.TYPE + "=? AND " + NoteColumns.PARENT_ID + "<>? AND " + NoteColumns.ID + "<>?";
+ selection = (mState == ListEditState.NOTE_LIST) ? selection :
+ "(" + selection + ") OR (" + NoteColumns.ID + "=" + Notes.ID_ROOT_FOLDER + ")";
+
+ // 查询可用的目标文件夹
+ mBackgroundQueryHandler.startQuery(FOLDER_LIST_QUERY_TOKEN,
+ null,
+ Notes.CONTENT_NOTE_URI,
+ FoldersListAdapter.PROJECTION,
+ selection,
+ new String[]{
+ String.valueOf(Notes.TYPE_FOLDER),
+ String.valueOf(Notes.ID_TRASH_FOLER),
+ String.valueOf(mCurrentFolderId)
+ },
+ NoteColumns.MODIFIED_DATE + " DESC");
+ } catch (Exception e) {
+ Log.e(TAG, "startQueryDestinationFolders error: " + e.getMessage(), e);
+ }
}
+ /**
+ * 列表项长按回调
+ * 处理便签列表项的长按事件
+ */
+ @Override
public boolean onItemLongClick(AdapterView parent, View view, int position, long id) {
- if (view instanceof NotesListItem) {
- mFocusNoteDataItem = ((NotesListItem) view).getItemData();
- if (mFocusNoteDataItem.getType() == Notes.TYPE_NOTE && !mNotesListAdapter.isInChoiceMode()) {
- if (mNotesListView.startActionMode(mModeCallBack) != null) {
- mModeCallBack.onItemCheckedStateChanged(null, position, id, true);
- mNotesListView.performHapticFeedback(HapticFeedbackConstants.LONG_PRESS);
- } else {
- Log.e(TAG, "startActionMode fails");
+ try {
+ if (view instanceof NotesListItem) {
+ mFocusNoteDataItem = ((NotesListItem) view).getItemData();
+ if (mFocusNoteDataItem != null && mFocusNoteDataItem.getType() == Notes.TYPE_NOTE
+ && mNotesListAdapter != null && !mNotesListAdapter.isInChoiceMode()) {
+ // 长按照便签项，启动多选模式
+ if (mNotesListView != null && mNotesListView.startActionMode(mModeCallBack) != null) {
+ if (mModeCallBack != null) {
+ mModeCallBack.onItemCheckedStateChanged(null, position, id, true);
+ }
+ if (mNotesListView != null) {
+ mNotesListView.performHapticFeedback(HapticFeedbackConstants.LONG_PRESS);
+ }
+ } else {
+ Log.e(TAG, "startActionMode fails");
+ }
+ } else if (mFocusNoteDataItem != null && mFocusNoteDataItem.getType() == Notes.TYPE_FOLDER) {
+ // 长按照文件夹项，注册上下文菜单
+ if (mNotesListView != null) {
+ mNotesListView.setOnCreateContextMenuListener(mFolderOnCreateContextMenuListener);
+ }
}
- } else if (mFocusNoteDataItem.getType() == Notes.TYPE_FOLDER) {
- mNotesListView.setOnCreateContextMenuListener(mFolderOnCreateContextMenuListener);
}
+ return false;
+ } catch (Exception e) {
+ Log.e(TAG, "onItemLongClick error: " + e.getMessage(), e);
+ return false;
+ }
+ }
+
+ /**
+ * Activity销毁时调用
+ * 取消正在执行的异步任务，避免内存泄漏
+ */
+ @Override
+ protected void onDestroy() {
+ try {
+ if (mCurrentAsyncTask != null && !mCurrentAsyncTask.isCancelled()) {
+ mCurrentAsyncTask.cancel(true); // 取消异步任务
+ }
+ super.onDestroy();
+ } catch (Exception e) {
+ Log.e(TAG, "onDestroy error: " + e.getMessage(), e);
}
- return false;
}
-}
+}
\ No newline at end of file
diff --git a/res/color/primary_text_dark.xml b/res/color/primary_text_dark.xml
deleted file mode 100644
index 7c85459..0000000
--- a/res/color/primary_text_dark.xml
+++ /dev/null
@@ -1,22 +0,0 @@
-
-
-
-
-
-