Compare commits

...

8 Commits
main ... master

Binary file not shown.

After

Width:  |  Height:  |  Size: 460 KiB

Binary file not shown.

After

Width:  |  Height:  |  Size: 201 KiB

@ -16,19 +16,29 @@
package net.micode.notes.data; package net.micode.notes.data;
// 导入Context类
import android.content.Context; import android.content.Context;
// 导入Cursor类
import android.database.Cursor; import android.database.Cursor;
// 导入Phone类
import android.provider.ContactsContract.CommonDataKinds.Phone; import android.provider.ContactsContract.CommonDataKinds.Phone;
// 导入Data类
import android.provider.ContactsContract.Data; import android.provider.ContactsContract.Data;
// 导入PhoneNumberUtils类
import android.telephony.PhoneNumberUtils; import android.telephony.PhoneNumberUtils;
// 导入Log类
import android.util.Log; import android.util.Log;
// 导入HashMap类
import java.util.HashMap; import java.util.HashMap;
public class Contact { public class Contact {
// 定义一个静态的HashMap用于缓存联系人信息
private static HashMap<String, String> sContactCache; private static HashMap<String, String> sContactCache;
// 定义一个常量,用于打印日志
private static final String TAG = "Contact"; private static final String TAG = "Contact";
// 定义一个常量用于查询联系人信息的SQL语句
private static final String CALLER_ID_SELECTION = "PHONE_NUMBERS_EQUAL(" + Phone.NUMBER private static final String CALLER_ID_SELECTION = "PHONE_NUMBERS_EQUAL(" + Phone.NUMBER
+ ",?) AND " + Data.MIMETYPE + "='" + Phone.CONTENT_ITEM_TYPE + "'" + ",?) AND " + Data.MIMETYPE + "='" + Phone.CONTENT_ITEM_TYPE + "'"
+ " AND " + Data.RAW_CONTACT_ID + " IN " + " AND " + Data.RAW_CONTACT_ID + " IN "
@ -36,17 +46,22 @@ public class Contact {
+ " FROM phone_lookup" + " FROM phone_lookup"
+ " WHERE min_match = '+')"; + " WHERE min_match = '+')";
// 根据传入的上下文和电话号码,获取联系人信息
public static String getContact(Context context, String phoneNumber) { public static String getContact(Context context, String phoneNumber) {
// 如果sContactCache为空则创建一个新的HashMap
if(sContactCache == null) { if(sContactCache == null) {
sContactCache = new HashMap<String, String>(); sContactCache = new HashMap<String, String>();
} }
// 如果sContactCache中包含phoneNumber则返回对应的联系人
if(sContactCache.containsKey(phoneNumber)) { if(sContactCache.containsKey(phoneNumber)) {
return sContactCache.get(phoneNumber); return sContactCache.get(phoneNumber);
} }
// 将电话号码中的"+"替换为PhoneNumberUtils.toCallerIDMinMatch(phoneNumber)方法返回的值
String selection = CALLER_ID_SELECTION.replace("+", String selection = CALLER_ID_SELECTION.replace("+",
PhoneNumberUtils.toCallerIDMinMatch(phoneNumber)); PhoneNumberUtils.toCallerIDMinMatch(phoneNumber));
// 使用ContentResolver查询Data.CONTENT_URI获取Phone.DISPLAY_NAME字段的值
Cursor cursor = context.getContentResolver().query( Cursor cursor = context.getContentResolver().query(
Data.CONTENT_URI, Data.CONTENT_URI,
new String [] { Phone.DISPLAY_NAME }, new String [] { Phone.DISPLAY_NAME },
@ -54,19 +69,28 @@ public class Contact {
new String[] { phoneNumber }, new String[] { phoneNumber },
null); null);
// 判断cursor是否为空并且是否可以移动到第一行
if (cursor != null && cursor.moveToFirst()) { if (cursor != null && cursor.moveToFirst()) {
try { try {
// 获取cursor中第一列的字符串
String name = cursor.getString(0); String name = cursor.getString(0);
// 将phoneNumber和name存入sContactCache中
sContactCache.put(phoneNumber, name); sContactCache.put(phoneNumber, name);
// 返回name
return name; return name;
} catch (IndexOutOfBoundsException e) { } catch (IndexOutOfBoundsException e) {
// 如果发生IndexOutOfBoundsException异常打印错误日志
Log.e(TAG, " Cursor get string error " + e.toString()); Log.e(TAG, " Cursor get string error " + e.toString());
// 返回null
return null; return null;
} finally { } finally {
// 关闭cursor
cursor.close(); cursor.close();
} }
} else { } else {
// 打印日志,提示没有匹配到指定号码的联系人
Log.d(TAG, "No contact matched with number:" + phoneNumber); Log.d(TAG, "No contact matched with number:" + phoneNumber);
// 返回null
return null; return null;
} }
} }

@ -14,15 +14,19 @@
* limitations under the License. * limitations under the License.
*/ */
// 定义一个包,用于存放数据相关的类
package net.micode.notes.data; package net.micode.notes.data;
import android.net.Uri; import android.net.Uri;
// 定义一个Notes类用于处理笔记数据
public class Notes { public class Notes {
public static final String AUTHORITY = "micode_notes";
public static final String TAG = "Notes"; // 定义Notes类的常量
public static final int TYPE_NOTE = 0; public static final String AUTHORITY = "micode_notes"; // Notes类的授权
public static final int TYPE_FOLDER = 1; public static final String TAG = "Notes"; // Notes类的标签
public static final int TYPE_SYSTEM = 2; public static final int TYPE_NOTE = 0; // Notes类的类型常量表示笔记
public static final int TYPE_FOLDER = 1; // Notes类的类型常量表示文件夹
public static final int TYPE_SYSTEM = 2; // Notes类的类型常量表示系统
/** /**
* Following IDs are system folders' identifiers * Following IDs are system folders' identifiers
@ -30,60 +34,77 @@ public class Notes {
* {@link Notes#ID_TEMPARAY_FOLDER } is for notes belonging no folder * {@link Notes#ID_TEMPARAY_FOLDER } is for notes belonging no folder
* {@link Notes#ID_CALL_RECORD_FOLDER} is to store call records * {@link Notes#ID_CALL_RECORD_FOLDER} is to store call records
*/ */
// 定义根文件夹的ID
public static final int ID_ROOT_FOLDER = 0; public static final int ID_ROOT_FOLDER = 0;
// 定义临时文件夹的ID
public static final int ID_TEMPARAY_FOLDER = -1; public static final int ID_TEMPARAY_FOLDER = -1;
// 定义通话记录文件夹的ID
public static final int ID_CALL_RECORD_FOLDER = -2; public static final int ID_CALL_RECORD_FOLDER = -2;
// 定义垃圾桶文件夹的ID
public static final int ID_TRASH_FOLER = -3; public static final int ID_TRASH_FOLER = -3;
// 定义一个常量,表示提醒日期的意图
public static final String INTENT_EXTRA_ALERT_DATE = "net.micode.notes.alert_date"; public static final String INTENT_EXTRA_ALERT_DATE = "net.micode.notes.alert_date";
// 定义一个常量,表示背景颜色的意图
public static final String INTENT_EXTRA_BACKGROUND_ID = "net.micode.notes.background_color_id"; public static final String INTENT_EXTRA_BACKGROUND_ID = "net.micode.notes.background_color_id";
// 定义一个常量,表示小部件的意图
public static final String INTENT_EXTRA_WIDGET_ID = "net.micode.notes.widget_id"; public static final String INTENT_EXTRA_WIDGET_ID = "net.micode.notes.widget_id";
// 定义一个常量,表示小部件类型的意图
public static final String INTENT_EXTRA_WIDGET_TYPE = "net.micode.notes.widget_type"; public static final String INTENT_EXTRA_WIDGET_TYPE = "net.micode.notes.widget_type";
// 定义一个常量,表示文件夹的意图
public static final String INTENT_EXTRA_FOLDER_ID = "net.micode.notes.folder_id"; public static final String INTENT_EXTRA_FOLDER_ID = "net.micode.notes.folder_id";
// 定义一个常量,表示通话日期的意图
public static final String INTENT_EXTRA_CALL_DATE = "net.micode.notes.call_date"; public static final String INTENT_EXTRA_CALL_DATE = "net.micode.notes.call_date";
public static final int TYPE_WIDGET_INVALIDE = -1; public static final int TYPE_WIDGET_INVALIDE = -1; // 无效的widget类型
public static final int TYPE_WIDGET_2X = 0; public static final int TYPE_WIDGET_2X = 0; // 2x的widget类型
public static final int TYPE_WIDGET_4X = 1; public static final int TYPE_WIDGET_4X = 1; // 4x的widget类型
public static class DataConstants { public static class DataConstants {
public static final String NOTE = TextNote.CONTENT_ITEM_TYPE; public static final String NOTE = TextNote.CONTENT_ITEM_TYPE; // 文本笔记的类型
public static final String CALL_NOTE = CallNote.CONTENT_ITEM_TYPE; public static final String CALL_NOTE = CallNote.CONTENT_ITEM_TYPE; // 呼叫笔记的类型
} }
/** /**
* Uri to query all notes and folders * Uri to query all notes and folders
*/ */
// 定义一个常量表示note的Uri
public static final Uri CONTENT_NOTE_URI = Uri.parse("content://" + AUTHORITY + "/note"); public static final Uri CONTENT_NOTE_URI = Uri.parse("content://" + AUTHORITY + "/note");
/** /**
* Uri to query data * Uri to query data
*/ */
// 定义一个常量表示数据URI
public static final Uri CONTENT_DATA_URI = Uri.parse("content://" + AUTHORITY + "/data"); public static final Uri CONTENT_DATA_URI = Uri.parse("content://" + AUTHORITY + "/data");
// 定义一个接口,表示笔记的列
public interface NoteColumns { public interface NoteColumns {
/** /**
* The unique ID for a row * The unique ID for a row
* <P> Type: INTEGER (long) </P> * <P> Type: INTEGER (long) </P>
*/ */
// 定义一个常量表示ID
public static final String ID = "_id"; public static final String ID = "_id";
/** /**
* The parent's id for note or folder * The parent's id for note or folder
* <P> Type: INTEGER (long) </P> * <P> Type: INTEGER (long) </P>
*/ */
// 定义一个常量表示父节点的ID
public static final String PARENT_ID = "parent_id"; public static final String PARENT_ID = "parent_id";
/** /**
* Created data for note or folder * Created data for note or folder
* <P> Type: INTEGER (long) </P> * <P> Type: INTEGER (long) </P>
*/ */
// 定义一个常量,表示创建日期
public static final String CREATED_DATE = "created_date"; public static final String CREATED_DATE = "created_date";
/** /**
* Latest modified date * Latest modified date
* <P> Type: INTEGER (long) </P> * <P> Type: INTEGER (long) </P>
*/ */
// 声明一个常量,表示修改日期
public static final String MODIFIED_DATE = "modified_date"; public static final String MODIFIED_DATE = "modified_date";
@ -91,30 +112,35 @@ public class Notes {
* Alert date * Alert date
* <P> Type: INTEGER (long) </P> * <P> Type: INTEGER (long) </P>
*/ */
// 定义一个常量,表示警报日期
public static final String ALERTED_DATE = "alert_date"; public static final String ALERTED_DATE = "alert_date";
/** /**
* Folder's name or text content of note * Folder's name or text content of note
* <P> Type: TEXT </P> * <P> Type: TEXT </P>
*/ */
// 定义一个常量,用于表示代码片段
public static final String SNIPPET = "snippet"; public static final String SNIPPET = "snippet";
/** /**
* Note's widget id * Note's widget id
* <P> Type: INTEGER (long) </P> * <P> Type: INTEGER (long) </P>
*/ */
// 定义一个常量表示小部件的ID
public static final String WIDGET_ID = "widget_id"; public static final String WIDGET_ID = "widget_id";
/** /**
* Note's widget type * Note's widget type
* <P> Type: INTEGER (long) </P> * <P> Type: INTEGER (long) </P>
*/ */
// 定义一个常量,表示小部件类型
public static final String WIDGET_TYPE = "widget_type"; public static final String WIDGET_TYPE = "widget_type";
/** /**
* Note's background color's id * Note's background color's id
* <P> Type: INTEGER (long) </P> * <P> Type: INTEGER (long) </P>
*/ */
// 定义一个常量用于表示背景颜色的ID
public static final String BG_COLOR_ID = "bg_color_id"; public static final String BG_COLOR_ID = "bg_color_id";
/** /**
@ -122,86 +148,101 @@ public class Notes {
* note, it has at least one attachment * note, it has at least one attachment
* <P> Type: INTEGER </P> * <P> Type: INTEGER </P>
*/ */
// 定义一个常量,表示是否有附件
public static final String HAS_ATTACHMENT = "has_attachment"; public static final String HAS_ATTACHMENT = "has_attachment";
/** /**
* Folder's count of notes * Folder's count of notes
* <P> Type: INTEGER (long) </P> * <P> Type: INTEGER (long) </P>
*/ */
// 声明一个常量,用于存储笔记数量
public static final String NOTES_COUNT = "notes_count"; public static final String NOTES_COUNT = "notes_count";
/** /**
* The file type: folder or note * The file type: folder or note
* <P> Type: INTEGER </P> * <P> Type: INTEGER </P>
*/ */
// 定义一个常量,表示类型
public static final String TYPE = "type"; public static final String TYPE = "type";
/** /**
* The last sync id * The last sync id
* <P> Type: INTEGER (long) </P> * <P> Type: INTEGER (long) </P>
*/ */
// 定义一个常量用于同步的ID
public static final String SYNC_ID = "sync_id"; public static final String SYNC_ID = "sync_id";
/** /**
* Sign to indicate local modified or not * Sign to indicate local modified or not
* <P> Type: INTEGER </P> * <P> Type: INTEGER </P>
*/ */
// 定义一个常量,表示本地修改
public static final String LOCAL_MODIFIED = "local_modified"; public static final String LOCAL_MODIFIED = "local_modified";
/** /**
* Original parent id before moving into temporary folder * Original parent id before moving into temporary folder
* <P> Type : INTEGER </P> * <P> Type : INTEGER </P>
*/ */
// 定义一个常量表示原始父级ID
public static final String ORIGIN_PARENT_ID = "origin_parent_id"; public static final String ORIGIN_PARENT_ID = "origin_parent_id";
/** /**
* The gtask id * The gtask id
* <P> Type : TEXT </P> * <P> Type : TEXT </P>
*/ */
// 声明一个常量字符串用于表示任务ID
public static final String GTASK_ID = "gtask_id"; public static final String GTASK_ID = "gtask_id";
/** /**
* The version code * The version code
* <P> Type : INTEGER (long) </P> * <P> Type : INTEGER (long) </P>
*/ */
// 定义一个常量,表示版本号
public static final String VERSION = "version"; public static final String VERSION = "version";
} }
// 定义一个接口DataColumns
public interface DataColumns { public interface DataColumns {
/** /**
* The unique ID for a row * The unique ID for a row
* <P> Type: INTEGER (long) </P> * <P> Type: INTEGER (long) </P>
*/ */
// 定义一个常量表示ID
public static final String ID = "_id"; public static final String ID = "_id";
/** /**
* The MIME type of the item represented by this row. * The MIME type of the item represented by this row.
* <P> Type: Text </P> * <P> Type: Text </P>
*/ */
// 定义一个常量表示MIME类型
public static final String MIME_TYPE = "mime_type"; public static final String MIME_TYPE = "mime_type";
/** /**
* The reference id to note that this data belongs to * The reference id to note that this data belongs to
* <P> Type: INTEGER (long) </P> * <P> Type: INTEGER (long) </P>
*/ */
// 定义一个常量表示笔记的ID
public static final String NOTE_ID = "note_id"; public static final String NOTE_ID = "note_id";
/** /**
* Created data for note or folder * Created data for note or folder
* <P> Type: INTEGER (long) </P> * <P> Type: INTEGER (long) </P>
*/ */
// 定义一个常量,表示创建日期
public static final String CREATED_DATE = "created_date"; public static final String CREATED_DATE = "created_date";
/** /**
* Latest modified date * Latest modified date
* <P> Type: INTEGER (long) </P> * <P> Type: INTEGER (long) </P>
*/ */
// 定义一个常量,表示修改日期
public static final String MODIFIED_DATE = "modified_date"; public static final String MODIFIED_DATE = "modified_date";
/** /**
* Data's content * Data's content
* <P> Type: TEXT </P> * <P> Type: TEXT </P>
*/ */
// 定义一个常量CONTENT值为"content"
public static final String CONTENT = "content"; public static final String CONTENT = "content";
@ -210,6 +251,7 @@ public class Notes {
* integer data type * integer data type
* <P> Type: INTEGER </P> * <P> Type: INTEGER </P>
*/ */
// 定义一个常量DATA1值为"data1"
public static final String DATA1 = "data1"; public static final String DATA1 = "data1";
/** /**
@ -217,6 +259,7 @@ public class Notes {
* integer data type * integer data type
* <P> Type: INTEGER </P> * <P> Type: INTEGER </P>
*/ */
// 定义一个常量DATA2值为"data2"
public static final String DATA2 = "data2"; public static final String DATA2 = "data2";
/** /**
@ -224,6 +267,7 @@ public class Notes {
* TEXT data type * TEXT data type
* <P> Type: TEXT </P> * <P> Type: TEXT </P>
*/ */
// 定义一个常量DATA3值为"data3"
public static final String DATA3 = "data3"; public static final String DATA3 = "data3";
/** /**
@ -231,6 +275,7 @@ public class Notes {
* TEXT data type * TEXT data type
* <P> Type: TEXT </P> * <P> Type: TEXT </P>
*/ */
// 定义一个常量DATA4值为"data4"
public static final String DATA4 = "data4"; public static final String DATA4 = "data4";
/** /**
@ -238,30 +283,39 @@ public class Notes {
* TEXT data type * TEXT data type
* <P> Type: TEXT </P> * <P> Type: TEXT </P>
*/ */
// 定义一个常量DATA5值为"data5"
public static final String DATA5 = "data5"; public static final String DATA5 = "data5";
} }
// 实现DataColumns接口的TextNote类
public static final class TextNote implements DataColumns { public static final class TextNote implements DataColumns {
/** /**
* Mode to indicate the text in check list mode or not * Mode to indicate the text in check list mode or not
* <P> Type: Integer 1:check list mode 0: normal mode </P> * <P> Type: Integer 1:check list mode 0: normal mode </P>
*/ */
// 定义一个常量MODE其值为DATA1
public static final String MODE = DATA1; public static final String MODE = DATA1;
// 定义一个常量,表示检查列表的模式
public static final int MODE_CHECK_LIST = 1; public static final int MODE_CHECK_LIST = 1;
// 定义一个常量,表示内容类型为文本笔记
public static final String CONTENT_TYPE = "vnd.android.cursor.dir/text_note"; public static final String CONTENT_TYPE = "vnd.android.cursor.dir/text_note";
// 定义一个常量,表示内容项类型为文本笔记
public static final String CONTENT_ITEM_TYPE = "vnd.android.cursor.item/text_note"; public static final String CONTENT_ITEM_TYPE = "vnd.android.cursor.item/text_note";
// 定义一个常量表示内容URI用于访问文本笔记数据
public static final Uri CONTENT_URI = Uri.parse("content://" + AUTHORITY + "/text_note"); public static final Uri CONTENT_URI = Uri.parse("content://" + AUTHORITY + "/text_note");
} }
// 定义一个名为CallNote的公共静态最终类实现DataColumns接口
public static final class CallNote implements DataColumns { public static final class CallNote implements DataColumns {
/** /**
* Call date for this record * Call date for this record
* <P> Type: INTEGER (long) </P> * <P> Type: INTEGER (long) </P>
*/ */
// 定义一个常量CALL_DATE其值为DATA1
public static final String CALL_DATE = DATA1; public static final String CALL_DATE = DATA1;
/** /**
@ -270,10 +324,13 @@ public class Notes {
*/ */
public static final String PHONE_NUMBER = DATA3; public static final String PHONE_NUMBER = DATA3;
// 定义内容类型,表示这是一个目录
public static final String CONTENT_TYPE = "vnd.android.cursor.dir/call_note"; public static final String CONTENT_TYPE = "vnd.android.cursor.dir/call_note";
// 定义内容项类型,表示这是一个单个项
public static final String CONTENT_ITEM_TYPE = "vnd.android.cursor.item/call_note"; public static final String CONTENT_ITEM_TYPE = "vnd.android.cursor.item/call_note";
// 定义内容URI用于访问数据
public static final Uri CONTENT_URI = Uri.parse("content://" + AUTHORITY + "/call_note"); public static final Uri CONTENT_URI = Uri.parse("content://" + AUTHORITY + "/call_note");
} }
} }

@ -14,6 +14,7 @@
* limitations under the License. * limitations under the License.
*/ */
// 定义一个包,用于存放数据相关的类
package net.micode.notes.data; package net.micode.notes.data;
import android.content.ContentValues; import android.content.ContentValues;
@ -22,340 +23,474 @@ import android.database.sqlite.SQLiteDatabase;
import android.database.sqlite.SQLiteOpenHelper; import android.database.sqlite.SQLiteOpenHelper;
import android.util.Log; import android.util.Log;
// 导入Notes类中的DataColumns和DataConstants常量
import net.micode.notes.data.Notes.DataColumns; import net.micode.notes.data.Notes.DataColumns;
import net.micode.notes.data.Notes.DataConstants; import net.micode.notes.data.Notes.DataConstants;
// 导入Notes类中的NoteColumns常量
import net.micode.notes.data.Notes.NoteColumns; import net.micode.notes.data.Notes.NoteColumns;
public class NotesDatabaseHelper extends SQLiteOpenHelper { public class NotesDatabaseHelper extends SQLiteOpenHelper {
// 数据库名称
private static final String DB_NAME = "note.db"; private static final String DB_NAME = "note.db";
// 数据库版本号
private static final int DB_VERSION = 4; private static final int DB_VERSION = 4;
public interface TABLE { public interface TABLE {
// 定义一个常量表示note
public static final String NOTE = "note"; public static final String NOTE = "note";
// 定义一个常量表示data
public static final String DATA = "data"; public static final String DATA = "data";
} }
// 定义一个常量,用于标识数据库帮助类的标签
private static final String TAG = "NotesDatabaseHelper"; private static final String TAG = "NotesDatabaseHelper";
// 定义一个静态变量,用于存储数据库帮助类的实例
private static NotesDatabaseHelper mInstance; private static NotesDatabaseHelper mInstance;
// 定义创建NOTE表的SQL语句
private static final String CREATE_NOTE_TABLE_SQL = private static final String CREATE_NOTE_TABLE_SQL =
"CREATE TABLE " + TABLE.NOTE + "(" + "CREATE TABLE " + TABLE.NOTE + "(" +
// 定义ID列类型为INTEGER为主键
NoteColumns.ID + " INTEGER PRIMARY KEY," + NoteColumns.ID + " INTEGER PRIMARY KEY," +
// 定义PARENT_ID列类型为INTEGER默认值为0
NoteColumns.PARENT_ID + " INTEGER NOT NULL DEFAULT 0," + NoteColumns.PARENT_ID + " INTEGER NOT NULL DEFAULT 0," +
// 定义ALERTED_DATE列类型为INTEGER默认值为0
NoteColumns.ALERTED_DATE + " INTEGER NOT NULL DEFAULT 0," + NoteColumns.ALERTED_DATE + " INTEGER NOT NULL DEFAULT 0," +
// 定义BG_COLOR_ID列类型为INTEGER默认值为0
NoteColumns.BG_COLOR_ID + " INTEGER NOT NULL DEFAULT 0," + NoteColumns.BG_COLOR_ID + " INTEGER NOT NULL DEFAULT 0," +
// 定义CREATED_DATE列类型为INTEGER默认值为当前时间戳
NoteColumns.CREATED_DATE + " INTEGER NOT NULL DEFAULT (strftime('%s','now') * 1000)," + NoteColumns.CREATED_DATE + " INTEGER NOT NULL DEFAULT (strftime('%s','now') * 1000)," +
// 定义HAS_ATTACHMENT列类型为INTEGER默认值为0
NoteColumns.HAS_ATTACHMENT + " INTEGER NOT NULL DEFAULT 0," + NoteColumns.HAS_ATTACHMENT + " INTEGER NOT NULL DEFAULT 0," +
// 定义MODIFIED_DATE列类型为INTEGER默认值为当前时间戳
NoteColumns.MODIFIED_DATE + " INTEGER NOT NULL DEFAULT (strftime('%s','now') * 1000)," + NoteColumns.MODIFIED_DATE + " INTEGER NOT NULL DEFAULT (strftime('%s','now') * 1000)," +
// 定义NOTES_COUNT列类型为INTEGER默认值为0
NoteColumns.NOTES_COUNT + " INTEGER NOT NULL DEFAULT 0," + NoteColumns.NOTES_COUNT + " INTEGER NOT NULL DEFAULT 0," +
// 定义SNIPPET列类型为TEXT默认值为空字符串
NoteColumns.SNIPPET + " TEXT NOT NULL DEFAULT ''," + NoteColumns.SNIPPET + " TEXT NOT NULL DEFAULT ''," +
// 定义TYPE列类型为INTEGER默认值为0
NoteColumns.TYPE + " INTEGER NOT NULL DEFAULT 0," + NoteColumns.TYPE + " INTEGER NOT NULL DEFAULT 0," +
// 定义WIDGET_ID列类型为INTEGER默认值为0
NoteColumns.WIDGET_ID + " INTEGER NOT NULL DEFAULT 0," + NoteColumns.WIDGET_ID + " INTEGER NOT NULL DEFAULT 0," +
// 定义WIDGET_TYPE列类型为INTEGER默认值为-1
NoteColumns.WIDGET_TYPE + " INTEGER NOT NULL DEFAULT -1," + NoteColumns.WIDGET_TYPE + " INTEGER NOT NULL DEFAULT -1," +
// 定义SYNC_ID列类型为INTEGER默认值为0
NoteColumns.SYNC_ID + " INTEGER NOT NULL DEFAULT 0," + NoteColumns.SYNC_ID + " INTEGER NOT NULL DEFAULT 0," +
// 定义LOCAL_MODIFIED列类型为INTEGER默认值为0
NoteColumns.LOCAL_MODIFIED + " INTEGER NOT NULL DEFAULT 0," + NoteColumns.LOCAL_MODIFIED + " INTEGER NOT NULL DEFAULT 0," +
// 定义ORIGIN_PARENT_ID列类型为INTEGER默认值为0
NoteColumns.ORIGIN_PARENT_ID + " INTEGER NOT NULL DEFAULT 0," + NoteColumns.ORIGIN_PARENT_ID + " INTEGER NOT NULL DEFAULT 0," +
// 定义GTASK_ID列类型为TEXT默认值为空字符串
NoteColumns.GTASK_ID + " TEXT NOT NULL DEFAULT ''," + NoteColumns.GTASK_ID + " TEXT NOT NULL DEFAULT ''," +
// 定义VERSION列类型为INTEGER默认值为0
NoteColumns.VERSION + " INTEGER NOT NULL DEFAULT 0" + NoteColumns.VERSION + " INTEGER NOT NULL DEFAULT 0" +
")"; ")";
// 定义创建数据表的SQL语句
private static final String CREATE_DATA_TABLE_SQL = private static final String CREATE_DATA_TABLE_SQL =
"CREATE TABLE " + TABLE.DATA + "(" + "CREATE TABLE " + TABLE.DATA + "(" +
// 定义ID列类型为INTEGER为主键
DataColumns.ID + " INTEGER PRIMARY KEY," + DataColumns.ID + " INTEGER PRIMARY KEY," +
// 定义MIME_TYPE列类型为TEXT不能为空
DataColumns.MIME_TYPE + " TEXT NOT NULL," + DataColumns.MIME_TYPE + " TEXT NOT NULL," +
// 定义NOTE_ID列类型为INTEGER不能为空默认值为0
DataColumns.NOTE_ID + " INTEGER NOT NULL DEFAULT 0," + DataColumns.NOTE_ID + " INTEGER NOT NULL DEFAULT 0," +
// 定义CREATED_DATE列类型为INTEGER不能为空默认值为当前时间
NoteColumns.CREATED_DATE + " INTEGER NOT NULL DEFAULT (strftime('%s','now') * 1000)," + NoteColumns.CREATED_DATE + " INTEGER NOT NULL DEFAULT (strftime('%s','now') * 1000)," +
// 定义MODIFIED_DATE列类型为INTEGER不能为空默认值为当前时间
NoteColumns.MODIFIED_DATE + " INTEGER NOT NULL DEFAULT (strftime('%s','now') * 1000)," + NoteColumns.MODIFIED_DATE + " INTEGER NOT NULL DEFAULT (strftime('%s','now') * 1000)," +
// 定义CONTENT列类型为TEXT不能为空默认值为空字符串
DataColumns.CONTENT + " TEXT NOT NULL DEFAULT ''," + DataColumns.CONTENT + " TEXT NOT NULL DEFAULT ''," +
// 定义DATA1列类型为INTEGER
DataColumns.DATA1 + " INTEGER," + DataColumns.DATA1 + " INTEGER," +
// 定义DATA2列类型为INTEGER
DataColumns.DATA2 + " INTEGER," + DataColumns.DATA2 + " INTEGER," +
// 定义DATA3列类型为TEXT不能为空默认值为空字符串
DataColumns.DATA3 + " TEXT NOT NULL DEFAULT ''," + DataColumns.DATA3 + " TEXT NOT NULL DEFAULT ''," +
// 定义DATA4列类型为TEXT不能为空默认值为空字符串
DataColumns.DATA4 + " TEXT NOT NULL DEFAULT ''," + DataColumns.DATA4 + " TEXT NOT NULL DEFAULT ''," +
// 定义DATA5列类型为TEXT不能为空默认值为空字符串
DataColumns.DATA5 + " TEXT NOT NULL DEFAULT ''" + DataColumns.DATA5 + " TEXT NOT NULL DEFAULT ''" +
")"; ")";
// 定义一个常量用于创建索引的SQL语句
private static final String CREATE_DATA_NOTE_ID_INDEX_SQL = private static final String CREATE_DATA_NOTE_ID_INDEX_SQL =
// 创建一个名为note_id_index的索引如果不存在
"CREATE INDEX IF NOT EXISTS note_id_index ON " + "CREATE INDEX IF NOT EXISTS note_id_index ON " +
TABLE.DATA + "(" + DataColumns.NOTE_ID + ");"; TABLE.DATA + "(" + DataColumns.NOTE_ID + ");";
/** /**
* Increase folder's note count when move note to the folder * Increase folder's note count when move note to the folder
*/ */
// 定义一个静态常量用于创建一个触发器在更新Note表的PARENT_ID字段后增加对应文件夹的NOTES_COUNT字段
private static final String NOTE_INCREASE_FOLDER_COUNT_ON_UPDATE_TRIGGER = private static final String NOTE_INCREASE_FOLDER_COUNT_ON_UPDATE_TRIGGER =
"CREATE TRIGGER increase_folder_count_on_update "+ "CREATE TRIGGER increase_folder_count_on_update "+ // 创建一个触发器名称为increase_folder_count_on_update
" AFTER UPDATE OF " + NoteColumns.PARENT_ID + " ON " + TABLE.NOTE + " AFTER UPDATE OF " + NoteColumns.PARENT_ID + " ON " + TABLE.NOTE + // 在Note表上当PARENT_ID字段更新后
" BEGIN " + " BEGIN " + // 开始
" UPDATE " + TABLE.NOTE + " UPDATE " + TABLE.NOTE + // 更新NOTE表
" SET " + NoteColumns.NOTES_COUNT + "=" + NoteColumns.NOTES_COUNT + " + 1" + " SET " + NoteColumns.NOTES_COUNT + "=" + NoteColumns.NOTES_COUNT + " + 1" + // 将NOTES_COUNT字段加1
" WHERE " + NoteColumns.ID + "=new." + NoteColumns.PARENT_ID + ";" + " WHERE " + NoteColumns.ID + "=new." + NoteColumns.PARENT_ID + ";" + // 将ID字段与new.PARENT_ID字段相等
" END"; " END"; // 结束
/** /**
* Decrease folder's note count when move note from folder * Decrease folder's note count when move note from folder
*/ */
// 定义一个常量,用于表示在更新触发器中减少文件夹数量的操作
private static final String NOTE_DECREASE_FOLDER_COUNT_ON_UPDATE_TRIGGER = private static final String NOTE_DECREASE_FOLDER_COUNT_ON_UPDATE_TRIGGER =
// 创建一个触发器,在更新 NoteColumns.PARENT_ID 列后,减少 TABLE 表中的文件夹数量
"CREATE TRIGGER decrease_folder_count_on_update " + "CREATE TRIGGER decrease_folder_count_on_update " +
" AFTER UPDATE OF " + NoteColumns.PARENT_ID + " ON " + TABLE.NOTE + " AFTER UPDATE OF " + NoteColumns.PARENT_ID + " ON " + TABLE.NOTE +
" BEGIN " + " BEGIN " +
" UPDATE " + TABLE.NOTE + " UPDATE " + TABLE.NOTE + // 更新NOTE表
" SET " + NoteColumns.NOTES_COUNT + "=" + NoteColumns.NOTES_COUNT + "-1" + " SET " + NoteColumns.NOTES_COUNT + "=" + NoteColumns.NOTES_COUNT + "-1" + // 将NOTES_COUNT字段减1
" WHERE " + NoteColumns.ID + "=old." + NoteColumns.PARENT_ID + " WHERE " + NoteColumns.ID + "=old." + NoteColumns.PARENT_ID + // 条件ID等于old表中的PARENT_ID
" AND " + NoteColumns.NOTES_COUNT + ">0" + ";" + " AND " + NoteColumns.NOTES_COUNT + ">0" + ";" + // 条件NOTES_COUNT大于0
" END"; " END"; // 结束
/** /**
* Increase folder's note count when insert new note to the folder * Increase folder's note count when insert new note to the folder
*/ */
// 定义一个常量,用于在插入时增加文件夹计数器的触发器
private static final String NOTE_INCREASE_FOLDER_COUNT_ON_INSERT_TRIGGER = private static final String NOTE_INCREASE_FOLDER_COUNT_ON_INSERT_TRIGGER =
"CREATE TRIGGER increase_folder_count_on_insert " + "CREATE TRIGGER increase_folder_count_on_insert " +
" AFTER INSERT ON " + TABLE.NOTE + " AFTER INSERT ON " + TABLE.NOTE +
" BEGIN " + " BEGIN " +
" UPDATE " + TABLE.NOTE + " UPDATE " + TABLE.NOTE + // 更新NOTE表
" SET " + NoteColumns.NOTES_COUNT + "=" + NoteColumns.NOTES_COUNT + " + 1" + " SET " + NoteColumns.NOTES_COUNT + "=" + NoteColumns.NOTES_COUNT + " + 1" + // 将NOTES_COUNT字段加1
" WHERE " + NoteColumns.ID + "=new." + NoteColumns.PARENT_ID + ";" + " WHERE " + NoteColumns.ID + "=new." + NoteColumns.PARENT_ID + ";" + // 将ID字段与new.PARENT_ID字段相等
" END"; " END"; // 结束
/** /**
* Decrease folder's note count when delete note from the folder * Decrease folder's note count when delete note from the folder
*/ */
// 定义一个常量,用于在删除文件夹时减少文件夹计数器的触发器
private static final String NOTE_DECREASE_FOLDER_COUNT_ON_DELETE_TRIGGER = private static final String NOTE_DECREASE_FOLDER_COUNT_ON_DELETE_TRIGGER =
"CREATE TRIGGER decrease_folder_count_on_delete " + "CREATE TRIGGER decrease_folder_count_on_delete " +
" AFTER DELETE ON " + TABLE.NOTE + " AFTER DELETE ON " + TABLE.NOTE +
" BEGIN " + " BEGIN " +
" UPDATE " + TABLE.NOTE + " UPDATE " + TABLE.NOTE + // 更新NOTE表
" SET " + NoteColumns.NOTES_COUNT + "=" + NoteColumns.NOTES_COUNT + "-1" + " SET " + NoteColumns.NOTES_COUNT + "=" + NoteColumns.NOTES_COUNT + "-1" + // 将NOTES_COUNT字段减1
" WHERE " + NoteColumns.ID + "=old." + NoteColumns.PARENT_ID + " WHERE " + NoteColumns.ID + "=old." + NoteColumns.PARENT_ID + // 条件为ID等于old表中的PARENT_ID
" AND " + NoteColumns.NOTES_COUNT + ">0;" + " AND " + NoteColumns.NOTES_COUNT + ">0;" + // 且NOTES_COUNT大于0
" END"; " END";
/** /**
* Update note's content when insert data with type {@link DataConstants#NOTE} * Update note's content when insert data with type {@link DataConstants#NOTE}
*/ */
// 定义一个常量,用于存储在插入数据时更新备注内容的触发器
private static final String DATA_UPDATE_NOTE_CONTENT_ON_INSERT_TRIGGER = private static final String DATA_UPDATE_NOTE_CONTENT_ON_INSERT_TRIGGER =
"CREATE TRIGGER update_note_content_on_insert " + "CREATE TRIGGER update_note_content_on_insert " +
" AFTER INSERT ON " + TABLE.DATA + " AFTER INSERT ON " + TABLE.DATA +
" WHEN new." + DataColumns.MIME_TYPE + "='" + DataConstants.NOTE + "'" + " WHEN new." + DataColumns.MIME_TYPE + "='" + DataConstants.NOTE + "'" +
" BEGIN" + " BEGIN" + // 开始事务
" UPDATE " + TABLE.NOTE + " UPDATE " + TABLE.NOTE + // 更新NOTE表
" SET " + NoteColumns.SNIPPET + "=new." + DataColumns.CONTENT + " SET " + NoteColumns.SNIPPET + "=new." + DataColumns.CONTENT + // 将新内容的值赋给NOTE表的SNIPPET列
" WHERE " + NoteColumns.ID + "=new." + DataColumns.NOTE_ID + ";" + " WHERE " + NoteColumns.ID + "=new." + DataColumns.NOTE_ID + ";" + // 根据新内容的NOTE_ID找到NOTE表中的ID并更新SNIPPET列
" END"; " END"; // 结束事务
/** /**
* Update note's content when data with {@link DataConstants#NOTE} type has changed * Update note's content when data with {@link DataConstants#NOTE} type has changed
*/ */
// 定义一个常量,用于更新触发器时更新数据注释的内容
private static final String DATA_UPDATE_NOTE_CONTENT_ON_UPDATE_TRIGGER = private static final String DATA_UPDATE_NOTE_CONTENT_ON_UPDATE_TRIGGER =
"CREATE TRIGGER update_note_content_on_update " + "CREATE TRIGGER update_note_content_on_update " +
" AFTER UPDATE ON " + TABLE.DATA + " AFTER UPDATE ON " + TABLE.DATA +
" WHEN old." + DataColumns.MIME_TYPE + "='" + DataConstants.NOTE + "'" + " WHEN old." + DataColumns.MIME_TYPE + "='" + DataConstants.NOTE + "'" +
" BEGIN" + " BEGIN" +
" UPDATE " + TABLE.NOTE + " UPDATE " + TABLE.NOTE + // 更新NOTE表
" SET " + NoteColumns.SNIPPET + "=new." + DataColumns.CONTENT + " SET " + NoteColumns.SNIPPET + "=new." + DataColumns.CONTENT + // 将新内容的值赋给NOTE表的SNIPPET列
" WHERE " + NoteColumns.ID + "=new." + DataColumns.NOTE_ID + ";" + " WHERE " + NoteColumns.ID + "=new." + DataColumns.NOTE_ID + ";" + // 将NOTE表的ID列的值与新内容的NOTE_ID列的值进行比较
" END"; " END"; // 结束
/** /**
* Update note's content when data with {@link DataConstants#NOTE} type has deleted * Update note's content when data with {@link DataConstants#NOTE} type has deleted
*/ */
// 定义一个常量,用于存储删除触发器时更新数据注释的内容
private static final String DATA_UPDATE_NOTE_CONTENT_ON_DELETE_TRIGGER = private static final String DATA_UPDATE_NOTE_CONTENT_ON_DELETE_TRIGGER =
"CREATE TRIGGER update_note_content_on_delete " + "CREATE TRIGGER update_note_content_on_delete " +
" AFTER delete ON " + TABLE.DATA + " AFTER delete ON " + TABLE.DATA +
" WHEN old." + DataColumns.MIME_TYPE + "='" + DataConstants.NOTE + "'" + " WHEN old." + DataColumns.MIME_TYPE + "='" + DataConstants.NOTE + "'" +
" BEGIN" + " BEGIN" + // 开始事务
" UPDATE " + TABLE.NOTE + " UPDATE " + TABLE.NOTE + // 更新NOTE表
" SET " + NoteColumns.SNIPPET + "=''" + " SET " + NoteColumns.SNIPPET + "=''" + // 将SNIPPET字段设置为空字符串
" WHERE " + NoteColumns.ID + "=old." + DataColumns.NOTE_ID + ";" + " WHERE " + NoteColumns.ID + "=old." + DataColumns.NOTE_ID + ";" + // 根据ID字段和old中的NOTE_ID字段进行更新
" END"; " END"; // 结束事务
/** /**
* Delete datas belong to note which has been deleted * Delete datas belong to note which has been deleted
*/ */
// 定义一个常量,用于删除触发器时删除数据
private static final String NOTE_DELETE_DATA_ON_DELETE_TRIGGER = private static final String NOTE_DELETE_DATA_ON_DELETE_TRIGGER =
"CREATE TRIGGER delete_data_on_delete " + "CREATE TRIGGER delete_data_on_delete " + // 创建一个名为delete_data_on_delete的触发器
" AFTER DELETE ON " + TABLE.NOTE + " AFTER DELETE ON " + TABLE.NOTE + // 在删除NOTE表中的数据后触发
" BEGIN" + " BEGIN" + // 开始事务
" DELETE FROM " + TABLE.DATA + " DELETE FROM " + TABLE.DATA + // 从DATA表中删除数据
" WHERE " + DataColumns.NOTE_ID + "=old." + NoteColumns.ID + ";" + " WHERE " + DataColumns.NOTE_ID + "=old." + NoteColumns.ID + ";" + // 条件为NOTE_ID等于old中的ID
" END"; " END"; // 结束事务
/** /**
* Delete notes belong to folder which has been deleted * Delete notes belong to folder which has been deleted
*/ */
// 定义一个常量,用于删除文件夹时触发删除笔记的触发器
private static final String FOLDER_DELETE_NOTES_ON_DELETE_TRIGGER = private static final String FOLDER_DELETE_NOTES_ON_DELETE_TRIGGER =
"CREATE TRIGGER folder_delete_notes_on_delete " + "CREATE TRIGGER folder_delete_notes_on_delete " +
" AFTER DELETE ON " + TABLE.NOTE + " AFTER DELETE ON " + TABLE.NOTE +
" BEGIN" + " BEGIN" +
// 删除与该笔记相关的所有笔记
" DELETE FROM " + TABLE.NOTE + " DELETE FROM " + TABLE.NOTE +
// 从笔记表中删除
" WHERE " + NoteColumns.PARENT_ID + "=old." + NoteColumns.ID + ";" + " WHERE " + NoteColumns.PARENT_ID + "=old." + NoteColumns.ID + ";" +
// 条件为该笔记的ID等于旧笔记的ID
" END"; " END";
/** /**
* Move notes belong to folder which has been moved to trash folder * Move notes belong to folder which has been moved to trash folder
*/ */
// 定义一个常量,用于触发将文件夹移动到回收站的操作
private static final String FOLDER_MOVE_NOTES_ON_TRASH_TRIGGER = private static final String FOLDER_MOVE_NOTES_ON_TRASH_TRIGGER =
"CREATE TRIGGER folder_move_notes_on_trash " + "CREATE TRIGGER folder_move_notes_on_trash " +
" AFTER UPDATE ON " + TABLE.NOTE + " AFTER UPDATE ON " + TABLE.NOTE +
" WHEN new." + NoteColumns.PARENT_ID + "=" + Notes.ID_TRASH_FOLER + " WHEN new." + NoteColumns.PARENT_ID + "=" + Notes.ID_TRASH_FOLER +
" BEGIN" + " BEGIN" + // 开始事务
" UPDATE " + TABLE.NOTE + " UPDATE " + TABLE.NOTE + // 更新NOTE表
" SET " + NoteColumns.PARENT_ID + "=" + Notes.ID_TRASH_FOLER + " SET " + NoteColumns.PARENT_ID + "=" + Notes.ID_TRASH_FOLER + // 将PARENT_ID设置为回收站ID
" WHERE " + NoteColumns.PARENT_ID + "=old." + NoteColumns.ID + ";" + " WHERE " + NoteColumns.PARENT_ID + "=old." + NoteColumns.ID + ";" + // 将PARENT_ID等于old.ID的记录更新
" END"; " END"; // 结束事务
// 构造函数用于初始化NotesDatabaseHelper对象
public NotesDatabaseHelper(Context context) { public NotesDatabaseHelper(Context context) {
// 调用父类的构造函数,传入上下文、数据库名称、游标工厂、数据库版本号
super(context, DB_NAME, null, DB_VERSION); super(context, DB_NAME, null, DB_VERSION);
} }
public void createNoteTable(SQLiteDatabase db) { public void createNoteTable(SQLiteDatabase db) {
// 执行创建note表的SQL语句
db.execSQL(CREATE_NOTE_TABLE_SQL); db.execSQL(CREATE_NOTE_TABLE_SQL);
// 重新创建note表的触发器
reCreateNoteTableTriggers(db); reCreateNoteTableTriggers(db);
// 创建系统文件夹
createSystemFolder(db); createSystemFolder(db);
// 打印日志note表已创建
Log.d(TAG, "note table has been created"); Log.d(TAG, "note table has been created");
} }
private void reCreateNoteTableTriggers(SQLiteDatabase db) { private void reCreateNoteTableTriggers(SQLiteDatabase db) {
// 删除increase_folder_count_on_update触发器
db.execSQL("DROP TRIGGER IF EXISTS increase_folder_count_on_update"); db.execSQL("DROP TRIGGER IF EXISTS increase_folder_count_on_update");
// 删除decrease_folder_count_on_update触发器
db.execSQL("DROP TRIGGER IF EXISTS decrease_folder_count_on_update"); db.execSQL("DROP TRIGGER IF EXISTS decrease_folder_count_on_update");
// 删除decrease_folder_count_on_delete触发器
db.execSQL("DROP TRIGGER IF EXISTS decrease_folder_count_on_delete"); db.execSQL("DROP TRIGGER IF EXISTS decrease_folder_count_on_delete");
// 删除delete_data_on_delete触发器
db.execSQL("DROP TRIGGER IF EXISTS delete_data_on_delete"); db.execSQL("DROP TRIGGER IF EXISTS delete_data_on_delete");
// 删除increase_folder_count_on_insert触发器
db.execSQL("DROP TRIGGER IF EXISTS increase_folder_count_on_insert"); db.execSQL("DROP TRIGGER IF EXISTS increase_folder_count_on_insert");
// 删除folder_delete_notes_on_delete触发器
db.execSQL("DROP TRIGGER IF EXISTS folder_delete_notes_on_delete"); db.execSQL("DROP TRIGGER IF EXISTS folder_delete_notes_on_delete");
// 删除folder_move_notes_on_trash触发器
db.execSQL("DROP TRIGGER IF EXISTS folder_move_notes_on_trash"); db.execSQL("DROP TRIGGER IF EXISTS folder_move_notes_on_trash");
// 执行增加文件夹计数触发器
db.execSQL(NOTE_INCREASE_FOLDER_COUNT_ON_UPDATE_TRIGGER); db.execSQL(NOTE_INCREASE_FOLDER_COUNT_ON_UPDATE_TRIGGER);
// 执行减少文件夹计数触发器
db.execSQL(NOTE_DECREASE_FOLDER_COUNT_ON_UPDATE_TRIGGER); db.execSQL(NOTE_DECREASE_FOLDER_COUNT_ON_UPDATE_TRIGGER);
// 执行减少文件夹计数触发器
db.execSQL(NOTE_DECREASE_FOLDER_COUNT_ON_DELETE_TRIGGER); db.execSQL(NOTE_DECREASE_FOLDER_COUNT_ON_DELETE_TRIGGER);
// 执行删除数据触发器
db.execSQL(NOTE_DELETE_DATA_ON_DELETE_TRIGGER); db.execSQL(NOTE_DELETE_DATA_ON_DELETE_TRIGGER);
// 执行增加文件夹计数触发器
db.execSQL(NOTE_INCREASE_FOLDER_COUNT_ON_INSERT_TRIGGER); db.execSQL(NOTE_INCREASE_FOLDER_COUNT_ON_INSERT_TRIGGER);
// 执行删除文件夹触发器
db.execSQL(FOLDER_DELETE_NOTES_ON_DELETE_TRIGGER); db.execSQL(FOLDER_DELETE_NOTES_ON_DELETE_TRIGGER);
// 执行移动文件夹触发器
db.execSQL(FOLDER_MOVE_NOTES_ON_TRASH_TRIGGER); db.execSQL(FOLDER_MOVE_NOTES_ON_TRASH_TRIGGER);
} }
// 创建系统文件夹
private void createSystemFolder(SQLiteDatabase db) { private void createSystemFolder(SQLiteDatabase db) {
// 创建ContentValues对象用于存储数据
ContentValues values = new ContentValues(); ContentValues values = new ContentValues();
/** /**
* call record foler for call notes * call record foler for call notes
*/ */
// 将Notes.ID_CALL_RECORD_FOLDER的值放入values中
values.put(NoteColumns.ID, Notes.ID_CALL_RECORD_FOLDER); values.put(NoteColumns.ID, Notes.ID_CALL_RECORD_FOLDER);
// 将Notes.TYPE_SYSTEM的值放入values中
values.put(NoteColumns.TYPE, Notes.TYPE_SYSTEM); values.put(NoteColumns.TYPE, Notes.TYPE_SYSTEM);
// 将values中的值插入到TABLE.NOTE表中
db.insert(TABLE.NOTE, null, values); db.insert(TABLE.NOTE, null, values);
/** /**
* root folder which is default folder * root folder which is default folder
*/ */
// 清空values
values.clear(); values.clear();
// 将Notes.ID_ROOT_FOLDER放入values中
values.put(NoteColumns.ID, Notes.ID_ROOT_FOLDER); values.put(NoteColumns.ID, Notes.ID_ROOT_FOLDER);
// 将Notes.TYPE_SYSTEM放入values中
values.put(NoteColumns.TYPE, Notes.TYPE_SYSTEM); values.put(NoteColumns.TYPE, Notes.TYPE_SYSTEM);
// 将values插入到TABLE.NOTE表中
db.insert(TABLE.NOTE, null, values); db.insert(TABLE.NOTE, null, values);
/** /**
* temporary folder which is used for moving note * temporary folder which is used for moving note
*/ */
// 清空values
values.clear(); values.clear();
// 将NoteColumns.ID的值设为Notes.ID_TEMPARAY_FOLDER
values.put(NoteColumns.ID, Notes.ID_TEMPARAY_FOLDER); values.put(NoteColumns.ID, Notes.ID_TEMPARAY_FOLDER);
// 将NoteColumns.TYPE的值设为Notes.TYPE_SYSTEM
values.put(NoteColumns.TYPE, Notes.TYPE_SYSTEM); values.put(NoteColumns.TYPE, Notes.TYPE_SYSTEM);
// 将values插入到TABLE.NOTE表中
db.insert(TABLE.NOTE, null, values); db.insert(TABLE.NOTE, null, values);
/** /**
* create trash folder * create trash folder
*/ */
// 清空values
values.clear(); values.clear();
// 将NoteColumns.ID的值设为Notes.ID_TRASH_FOLER
values.put(NoteColumns.ID, Notes.ID_TRASH_FOLER); values.put(NoteColumns.ID, Notes.ID_TRASH_FOLER);
// 将NoteColumns.TYPE的值设为Notes.TYPE_SYSTEM
values.put(NoteColumns.TYPE, Notes.TYPE_SYSTEM); values.put(NoteColumns.TYPE, Notes.TYPE_SYSTEM);
// 将values插入到TABLE.NOTE表中
db.insert(TABLE.NOTE, null, values); db.insert(TABLE.NOTE, null, values);
} }
public void createDataTable(SQLiteDatabase db) { public void createDataTable(SQLiteDatabase db) {
// 执行创建数据表的SQL语句
db.execSQL(CREATE_DATA_TABLE_SQL); db.execSQL(CREATE_DATA_TABLE_SQL);
// 重新创建数据表触发器
reCreateDataTableTriggers(db); reCreateDataTableTriggers(db);
// 执行创建数据表索引的SQL语句
db.execSQL(CREATE_DATA_NOTE_ID_INDEX_SQL); db.execSQL(CREATE_DATA_NOTE_ID_INDEX_SQL);
// 打印日志,表示数据表已经创建
Log.d(TAG, "data table has been created"); Log.d(TAG, "data table has been created");
} }
// 重新创建数据表触发器
private void reCreateDataTableTriggers(SQLiteDatabase db) { private void reCreateDataTableTriggers(SQLiteDatabase db) {
// 删除update_note_content_on_insert触发器
db.execSQL("DROP TRIGGER IF EXISTS update_note_content_on_insert"); db.execSQL("DROP TRIGGER IF EXISTS update_note_content_on_insert");
// 删除update_note_content_on_update触发器
db.execSQL("DROP TRIGGER IF EXISTS update_note_content_on_update"); db.execSQL("DROP TRIGGER IF EXISTS update_note_content_on_update");
// 删除update_note_content_on_delete触发器
db.execSQL("DROP TRIGGER IF EXISTS update_note_content_on_delete"); db.execSQL("DROP TRIGGER IF EXISTS update_note_content_on_delete");
// 执行更新笔记内容的触发器
db.execSQL(DATA_UPDATE_NOTE_CONTENT_ON_INSERT_TRIGGER); db.execSQL(DATA_UPDATE_NOTE_CONTENT_ON_INSERT_TRIGGER);
// 执行更新笔记内容的触发器
db.execSQL(DATA_UPDATE_NOTE_CONTENT_ON_UPDATE_TRIGGER); db.execSQL(DATA_UPDATE_NOTE_CONTENT_ON_UPDATE_TRIGGER);
// 执行更新笔记内容的触发器
db.execSQL(DATA_UPDATE_NOTE_CONTENT_ON_DELETE_TRIGGER); db.execSQL(DATA_UPDATE_NOTE_CONTENT_ON_DELETE_TRIGGER);
} }
// 获取NotesDatabaseHelper实例
static synchronized NotesDatabaseHelper getInstance(Context context) { static synchronized NotesDatabaseHelper getInstance(Context context) {
// 如果mInstance为空则创建一个新的NotesDatabaseHelper实例
if (mInstance == null) { if (mInstance == null) {
mInstance = new NotesDatabaseHelper(context); mInstance = new NotesDatabaseHelper(context);
} }
// 返回mInstance实例
return mInstance; return mInstance;
} }
@Override @Override
// 重写onCreate方法当数据库创建时调用
public void onCreate(SQLiteDatabase db) { public void onCreate(SQLiteDatabase db) {
// 创建Note表
createNoteTable(db); createNoteTable(db);
// 创建Data表
createDataTable(db); createDataTable(db);
} }
// 重写onUpgrade方法当数据库版本升级时调用
@Override @Override
public void onUpgrade(SQLiteDatabase db, int oldVersion, int newVersion) { public void onUpgrade(SQLiteDatabase db, int oldVersion, int newVersion) {
// 是否重新创建触发器
boolean reCreateTriggers = false; boolean reCreateTriggers = false;
// 是否跳过V2版本
boolean skipV2 = false; boolean skipV2 = false;
// 如果旧版本为1则升级到v2版本
if (oldVersion == 1) { if (oldVersion == 1) {
upgradeToV2(db); upgradeToV2(db);
skipV2 = true; // this upgrade including the upgrade from v2 to v3 skipV2 = true; // this upgrade including the upgrade from v2 to v3
oldVersion++; oldVersion++;
} }
// 如果旧版本为2且不跳过V2版本则升级到V3版本并重新创建触发器同时旧版本加1
if (oldVersion == 2 && !skipV2) { if (oldVersion == 2 && !skipV2) {
upgradeToV3(db); upgradeToV3(db);
reCreateTriggers = true; reCreateTriggers = true;
oldVersion++; oldVersion++;
} }
// 如果旧版本号为3
if (oldVersion == 3) { if (oldVersion == 3) {
// 升级到版本4
upgradeToV4(db); upgradeToV4(db);
// 版本号加1
oldVersion++; oldVersion++;
} }
// 如果需要重新创建触发器,则执行以下操作
if (reCreateTriggers) { if (reCreateTriggers) {
// 重新创建NoteTable触发器
reCreateNoteTableTriggers(db); reCreateNoteTableTriggers(db);
// 重新创建DataTable触发器
reCreateDataTableTriggers(db); reCreateDataTableTriggers(db);
} }
if (oldVersion != newVersion) { // 如果旧版本不等于新版本,则抛出异常
if (oldVersion != newVersion) {
throw new IllegalStateException("Upgrade notes database to version " + newVersion throw new IllegalStateException("Upgrade notes database to version " + newVersion
+ "fails"); + "fails");
} }
} }
private void upgradeToV2(SQLiteDatabase db) { private void upgradeToV2(SQLiteDatabase db) {
// 删除旧版本的NOTE表
db.execSQL("DROP TABLE IF EXISTS " + TABLE.NOTE); db.execSQL("DROP TABLE IF EXISTS " + TABLE.NOTE);
// 删除旧版本的DATA表
db.execSQL("DROP TABLE IF EXISTS " + TABLE.DATA); db.execSQL("DROP TABLE IF EXISTS " + TABLE.DATA);
// 创建新版本的NOTE表
createNoteTable(db); createNoteTable(db);
// 创建新版本的DATA表
createDataTable(db); createDataTable(db);
} }
// 将数据库升级到V3版本
private void upgradeToV3(SQLiteDatabase db) { private void upgradeToV3(SQLiteDatabase db) {
// drop unused triggers // drop unused triggers
// 删除未使用的触发器
db.execSQL("DROP TRIGGER IF EXISTS update_note_modified_date_on_insert"); db.execSQL("DROP TRIGGER IF EXISTS update_note_modified_date_on_insert");
db.execSQL("DROP TRIGGER IF EXISTS update_note_modified_date_on_delete"); db.execSQL("DROP TRIGGER IF EXISTS update_note_modified_date_on_delete");
db.execSQL("DROP TRIGGER IF EXISTS update_note_modified_date_on_update"); db.execSQL("DROP TRIGGER IF EXISTS update_note_modified_date_on_update");
// add a column for gtask id // add a column for gtask id
// 向数据库中的NOTE表添加一个名为GTASK_ID的列类型为TEXT默认值为空字符串
db.execSQL("ALTER TABLE " + TABLE.NOTE + " ADD COLUMN " + NoteColumns.GTASK_ID db.execSQL("ALTER TABLE " + TABLE.NOTE + " ADD COLUMN " + NoteColumns.GTASK_ID
+ " TEXT NOT NULL DEFAULT ''"); + " TEXT NOT NULL DEFAULT ''");
// add a trash system folder // add a trash system folder
// 创建一个ContentValues对象用于存储要插入的数据
ContentValues values = new ContentValues(); ContentValues values = new ContentValues();
// 将ID_TRASH_FOLER的值放入NoteColumns.ID字段中
values.put(NoteColumns.ID, Notes.ID_TRASH_FOLER); values.put(NoteColumns.ID, Notes.ID_TRASH_FOLER);
// 将TYPE_SYSTEM的值放入NoteColumns.TYPE字段中
values.put(NoteColumns.TYPE, Notes.TYPE_SYSTEM); values.put(NoteColumns.TYPE, Notes.TYPE_SYSTEM);
// 将values中的数据插入到TABLE.NOTE表中
db.insert(TABLE.NOTE, null, values); db.insert(TABLE.NOTE, null, values);
} }
// 将数据库升级到V4版本
private void upgradeToV4(SQLiteDatabase db) { private void upgradeToV4(SQLiteDatabase db) {
// 执行SQL语句向NOTE表中添加VERSION列类型为INTEGER默认值为0
// 向数据库中的NOTE表添加一个名为VERSION的列类型为INTEGER默认值为0
db.execSQL("ALTER TABLE " + TABLE.NOTE + " ADD COLUMN " + NoteColumns.VERSION db.execSQL("ALTER TABLE " + TABLE.NOTE + " ADD COLUMN " + NoteColumns.VERSION
+ " INTEGER NOT NULL DEFAULT 0"); + " INTEGER NOT NULL DEFAULT 0");
} }

@ -14,50 +14,72 @@
* limitations under the License. * limitations under the License.
*/ */
// 定义一个包,用于存放数据相关的类
package net.micode.notes.data; package net.micode.notes.data;
import android.app.SearchManager; import android.app.SearchManager; // 导入SearchManager类
import android.content.ContentProvider; import android.content.ContentProvider; // 导入ContentProvider类
import android.content.ContentUris; import android.content.ContentUris; // 导入ContentUris类
import android.content.ContentValues; import android.content.ContentValues; // 导入ContentValues类
import android.content.Intent; import android.content.Intent; // 导入Intent类
import android.content.UriMatcher; import android.content.UriMatcher;
// UriMatcher用于匹配Uri
import android.database.Cursor; import android.database.Cursor;
// Cursor用于查询数据库
import android.database.sqlite.SQLiteDatabase; import android.database.sqlite.SQLiteDatabase;
// SQLiteDatabase用于操作数据库
import android.net.Uri; import android.net.Uri;
// Uri用于表示数据源
import android.text.TextUtils; import android.text.TextUtils;
import android.util.Log; import android.util.Log;
// 导入NotesDatabaseHelper类中的TABLE常量
import net.micode.notes.R; import net.micode.notes.R;
import net.micode.notes.data.Notes.DataColumns; import net.micode.notes.data.Notes.DataColumns;
// 导入Notes类中的NoteColumns接口
import net.micode.notes.data.Notes.NoteColumns; import net.micode.notes.data.Notes.NoteColumns;
// 导入NotesDatabaseHelper类中的TABLE常量
import net.micode.notes.data.NotesDatabaseHelper.TABLE; import net.micode.notes.data.NotesDatabaseHelper.TABLE;
public class NotesProvider extends ContentProvider { public class NotesProvider extends ContentProvider {
// 定义一个UriMatcher对象用于匹配Uri
private static final UriMatcher mMatcher; private static final UriMatcher mMatcher;
// 定义一个NotesDatabaseHelper对象用于操作数据库
private NotesDatabaseHelper mHelper; private NotesDatabaseHelper mHelper;
// 定义日志标签
private static final String TAG = "NotesProvider"; private static final String TAG = "NotesProvider";
// 定义URI常量
private static final int URI_NOTE = 1; private static final int URI_NOTE = 1;
private static final int URI_NOTE_ITEM = 2; private static final int URI_NOTE_ITEM = 2;
private static final int URI_DATA = 3; private static final int URI_DATA = 3;
private static final int URI_DATA_ITEM = 4; private static final int URI_DATA_ITEM = 4;
// 定义搜索URI常量
private static final int URI_SEARCH = 5; private static final int URI_SEARCH = 5;
private static final int URI_SEARCH_SUGGEST = 6; private static final int URI_SEARCH_SUGGEST = 6;
// 静态代码块用于初始化UriMatcher对象
static { static {
// 创建UriMatcher对象NO_MATCH表示没有匹配的URI
mMatcher = new UriMatcher(UriMatcher.NO_MATCH); mMatcher = new UriMatcher(UriMatcher.NO_MATCH);
// 添加URI匹配规则匹配Notes.AUTHORITY下的note匹配成功返回URI_NOTE
mMatcher.addURI(Notes.AUTHORITY, "note", URI_NOTE); mMatcher.addURI(Notes.AUTHORITY, "note", URI_NOTE);
// 添加URI匹配规则匹配Notes.AUTHORITY下的note/#匹配成功返回URI_NOTE_ITEM
mMatcher.addURI(Notes.AUTHORITY, "note/#", URI_NOTE_ITEM); mMatcher.addURI(Notes.AUTHORITY, "note/#", URI_NOTE_ITEM);
// 添加URI匹配规则匹配Notes.AUTHORITY下的data匹配成功返回URI_DATA
mMatcher.addURI(Notes.AUTHORITY, "data", URI_DATA); mMatcher.addURI(Notes.AUTHORITY, "data", URI_DATA);
// 添加URI匹配规则匹配Notes.AUTHORITY下的data/#匹配成功返回URI_DATA_ITEM
mMatcher.addURI(Notes.AUTHORITY, "data/#", URI_DATA_ITEM); mMatcher.addURI(Notes.AUTHORITY, "data/#", URI_DATA_ITEM);
// 添加URI匹配规则匹配Notes.AUTHORITY下的search匹配成功返回URI_SEARCH
mMatcher.addURI(Notes.AUTHORITY, "search", URI_SEARCH); mMatcher.addURI(Notes.AUTHORITY, "search", URI_SEARCH);
// 添加URI匹配规则匹配Notes.AUTHORITY下的search/*匹配成功返回URI_SEARCH_SUGGEST
mMatcher.addURI(Notes.AUTHORITY, SearchManager.SUGGEST_URI_PATH_QUERY, URI_SEARCH_SUGGEST); mMatcher.addURI(Notes.AUTHORITY, SearchManager.SUGGEST_URI_PATH_QUERY, URI_SEARCH_SUGGEST);
// 添加URI匹配规则匹配Notes.AUTHORITY下的search/*/*匹配成功返回URI_SEARCH_SUGGEST
mMatcher.addURI(Notes.AUTHORITY, SearchManager.SUGGEST_URI_PATH_QUERY + "/*", URI_SEARCH_SUGGEST); mMatcher.addURI(Notes.AUTHORITY, SearchManager.SUGGEST_URI_PATH_QUERY + "/*", URI_SEARCH_SUGGEST);
} }
@ -65,234 +87,346 @@ public class NotesProvider extends ContentProvider {
* x'0A' represents the '\n' character in sqlite. For title and content in the search result, * 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. * we will trim '\n' and white space in order to show more information.
*/ */
// 定义搜索笔记的投影
private static final String NOTES_SEARCH_PROJECTION = NoteColumns.ID + "," private static final String NOTES_SEARCH_PROJECTION = NoteColumns.ID + ","
+ NoteColumns.ID + " AS " + SearchManager.SUGGEST_COLUMN_INTENT_EXTRA_DATA + "," + NoteColumns.ID + " AS " + SearchManager.SUGGEST_COLUMN_INTENT_EXTRA_DATA + ","
// 将NoteColumns.SNIPPET中的换行符替换为空字符串并去除首尾空格作为SearchManager.SUGGEST_COLUMN_TEXT_1的值
+ "TRIM(REPLACE(" + NoteColumns.SNIPPET + ", x'0A','')) AS " + SearchManager.SUGGEST_COLUMN_TEXT_1 + "," + "TRIM(REPLACE(" + NoteColumns.SNIPPET + ", x'0A','')) AS " + SearchManager.SUGGEST_COLUMN_TEXT_1 + ","
// 将NoteColumns.SNIPPET中的换行符替换为空字符串并去除首尾空格作为SearchManager.SUGGEST_COLUMN_TEXT_2的值
+ "TRIM(REPLACE(" + NoteColumns.SNIPPET + ", x'0A','')) AS " + SearchManager.SUGGEST_COLUMN_TEXT_2 + "," + "TRIM(REPLACE(" + NoteColumns.SNIPPET + ", x'0A','')) AS " + SearchManager.SUGGEST_COLUMN_TEXT_2 + ","
// 添加搜索结果图标
+ R.drawable.search_result + " AS " + SearchManager.SUGGEST_COLUMN_ICON_1 + "," + R.drawable.search_result + " AS " + SearchManager.SUGGEST_COLUMN_ICON_1 + ","
// 添加搜索结果意图动作
+ "'" + Intent.ACTION_VIEW + "' AS " + SearchManager.SUGGEST_COLUMN_INTENT_ACTION + "," + "'" + Intent.ACTION_VIEW + "' AS " + SearchManager.SUGGEST_COLUMN_INTENT_ACTION + ","
// 添加搜索结果意图数据
+ "'" + Notes.TextNote.CONTENT_TYPE + "' AS " + SearchManager.SUGGEST_COLUMN_INTENT_DATA; + "'" + Notes.TextNote.CONTENT_TYPE + "' AS " + SearchManager.SUGGEST_COLUMN_INTENT_DATA;
// 定义搜索笔记的查询语句
private static String NOTES_SNIPPET_SEARCH_QUERY = "SELECT " + NOTES_SEARCH_PROJECTION private static String NOTES_SNIPPET_SEARCH_QUERY = "SELECT " + NOTES_SEARCH_PROJECTION
+ " FROM " + TABLE.NOTE + " FROM " + TABLE.NOTE
// 查询表名为NOTE的表
+ " WHERE " + NoteColumns.SNIPPET + " LIKE ?" + " WHERE " + NoteColumns.SNIPPET + " LIKE ?"
// 查询SNIPPET字段中包含指定字符的记录
+ " AND " + NoteColumns.PARENT_ID + "<>" + Notes.ID_TRASH_FOLER + " AND " + NoteColumns.PARENT_ID + "<>" + Notes.ID_TRASH_FOLER
// 查询PARENT_ID字段不等于指定值的记录
+ " AND " + NoteColumns.TYPE + "=" + Notes.TYPE_NOTE; + " AND " + NoteColumns.TYPE + "=" + Notes.TYPE_NOTE;
@Override @Override
public boolean onCreate() { public boolean onCreate() {
// 获取NotesDatabaseHelper的实例
// 获取NotesDatabaseHelper的实例
mHelper = NotesDatabaseHelper.getInstance(getContext()); mHelper = NotesDatabaseHelper.getInstance(getContext());
// 返回true
return true; return true;
} }
@Override @Override
// 根据给定的Uri、投影、选择条件和排序顺序查询数据
public Cursor query(Uri uri, String[] projection, String selection, String[] selectionArgs, public Cursor query(Uri uri, String[] projection, String selection, String[] selectionArgs,
String sortOrder) { String sortOrder) {
// 声明一个Cursor对象
Cursor c = null; Cursor c = null;
// 获取可读的数据库
SQLiteDatabase db = mHelper.getReadableDatabase(); SQLiteDatabase db = mHelper.getReadableDatabase();
// 声明一个id变量
String id = null; String id = null;
// 根据uri匹配对应的操作
switch (mMatcher.match(uri)) { switch (mMatcher.match(uri)) {
case URI_NOTE: case URI_NOTE:
// 查询数据库
c = db.query(TABLE.NOTE, projection, selection, selectionArgs, null, null, c = db.query(TABLE.NOTE, projection, selection, selectionArgs, null, null,
sortOrder); sortOrder);
break; break;
case URI_NOTE_ITEM: case URI_NOTE_ITEM:
// 获取uri路径中的id
id = uri.getPathSegments().get(1); id = uri.getPathSegments().get(1);
// 根据id查询note表
c = db.query(TABLE.NOTE, projection, NoteColumns.ID + "=" + id c = db.query(TABLE.NOTE, projection, NoteColumns.ID + "=" + id
+ parseSelection(selection), selectionArgs, null, null, sortOrder); + parseSelection(selection), selectionArgs, null, null, sortOrder);
break; break;
case URI_DATA: case URI_DATA:
// 查询data表
c = db.query(TABLE.DATA, projection, selection, selectionArgs, null, null, c = db.query(TABLE.DATA, projection, selection, selectionArgs, null, null,
sortOrder); sortOrder);
break; break;
case URI_DATA_ITEM: case URI_DATA_ITEM:
// 获取uri路径中的id
id = uri.getPathSegments().get(1); id = uri.getPathSegments().get(1);
// 根据id查询data表
c = db.query(TABLE.DATA, projection, DataColumns.ID + "=" + id c = db.query(TABLE.DATA, projection, DataColumns.ID + "=" + id
+ parseSelection(selection), selectionArgs, null, null, sortOrder); + parseSelection(selection), selectionArgs, null, null, sortOrder);
break; break;
case URI_SEARCH: case URI_SEARCH:
case URI_SEARCH_SUGGEST: case URI_SEARCH_SUGGEST:
// 如果指定了排序方式、投影、选择条件或选择参数,则抛出异常
if (sortOrder != null || projection != null) { if (sortOrder != null || projection != null) {
throw new IllegalArgumentException( throw new IllegalArgumentException(
"do not specify sortOrder, selection, selectionArgs, or projection" + "with this query"); "do not specify sortOrder, selection, selectionArgs, or projection" + "with this query");
} }
// 定义一个字符串变量searchString初始值为null
String searchString = null; String searchString = null;
// 如果mMatcher.match(uri)等于URI_SEARCH_SUGGEST
if (mMatcher.match(uri) == URI_SEARCH_SUGGEST) { if (mMatcher.match(uri) == URI_SEARCH_SUGGEST) {
// 如果uri的路径段大小大于1
if (uri.getPathSegments().size() > 1) { if (uri.getPathSegments().size() > 1) {
// 将uri的路径段的第二个元素赋值给searchString
searchString = uri.getPathSegments().get(1); searchString = uri.getPathSegments().get(1);
} }
// 否则
} else { } else {
// 将uri的查询参数中名为"pattern"的值赋值给searchString
searchString = uri.getQueryParameter("pattern"); searchString = uri.getQueryParameter("pattern");
} }
// 如果searchString为空
if (TextUtils.isEmpty(searchString)) { if (TextUtils.isEmpty(searchString)) {
// 返回null
return null; return null;
} }
try { try {
// 将搜索字符串格式化为包含通配符的字符串
searchString = String.format("%%%s%%", searchString); searchString = String.format("%%%s%%", searchString);
// 执行数据库查询
c = db.rawQuery(NOTES_SNIPPET_SEARCH_QUERY, c = db.rawQuery(NOTES_SNIPPET_SEARCH_QUERY,
new String[] { searchString }); new String[] { searchString });
} catch (IllegalStateException ex) { } catch (IllegalStateException ex) {
// 捕获异常并打印错误日志
Log.e(TAG, "got exception: " + ex.toString()); Log.e(TAG, "got exception: " + ex.toString());
} }
break; break;
default: default:
// 抛出异常表示未知的URI
throw new IllegalArgumentException("Unknown URI " + uri); throw new IllegalArgumentException("Unknown URI " + uri);
} }
// 如果查询结果不为空则设置通知URI
if (c != null) { if (c != null) {
c.setNotificationUri(getContext().getContentResolver(), uri); c.setNotificationUri(getContext().getContentResolver(), uri);
} }
// 返回查询结果
return c; return c;
} }
@Override @Override
public Uri insert(Uri uri, ContentValues values) { public Uri insert(Uri uri, ContentValues values) {
// 获取可写的数据库
SQLiteDatabase db = mHelper.getWritableDatabase(); SQLiteDatabase db = mHelper.getWritableDatabase();
// 定义变量用于存储插入的数据ID
long dataId = 0, noteId = 0, insertedId = 0; long dataId = 0, noteId = 0, insertedId = 0;
// 根据传入的URI匹配对应的操作
switch (mMatcher.match(uri)) { switch (mMatcher.match(uri)) {
// 如果匹配到的是NOTE表
case URI_NOTE: case URI_NOTE:
// 在NOTE表中插入数据并返回插入的数据ID
insertedId = noteId = db.insert(TABLE.NOTE, null, values); insertedId = noteId = db.insert(TABLE.NOTE, null, values);
break; break;
case URI_DATA: case URI_DATA:
// 如果values中包含NOTE_ID则获取其值否则打印错误日志
if (values.containsKey(DataColumns.NOTE_ID)) { if (values.containsKey(DataColumns.NOTE_ID)) {
noteId = values.getAsLong(DataColumns.NOTE_ID); noteId = values.getAsLong(DataColumns.NOTE_ID);
} else { } else {
Log.d(TAG, "Wrong data format without note id:" + values.toString()); Log.d(TAG, "Wrong data format without note id:" + values.toString());
} }
// 将values插入到数据库中并获取插入的id
insertedId = dataId = db.insert(TABLE.DATA, null, values); insertedId = dataId = db.insert(TABLE.DATA, null, values);
break; break;
default: default:
// 如果uri不匹配则抛出异常
throw new IllegalArgumentException("Unknown URI " + uri); throw new IllegalArgumentException("Unknown URI " + uri);
} }
// Notify the note uri // Notify the note uri
// 如果noteId大于0则通知ContentResolver有数据发生变化
if (noteId > 0) { if (noteId > 0) {
getContext().getContentResolver().notifyChange( getContext().getContentResolver().notifyChange(
// 使用ContentUris.withAppendedId方法将noteId添加到Notes.CONTENT_NOTE_URI中
ContentUris.withAppendedId(Notes.CONTENT_NOTE_URI, noteId), null); ContentUris.withAppendedId(Notes.CONTENT_NOTE_URI, noteId), null);
} }
// Notify the data uri // Notify the data uri
// 如果dataId大于0则通知ContentResolver数据已更改
if (dataId > 0) { if (dataId > 0) {
getContext().getContentResolver().notifyChange( getContext().getContentResolver().notifyChange(
ContentUris.withAppendedId(Notes.CONTENT_DATA_URI, dataId), null); ContentUris.withAppendedId(Notes.CONTENT_DATA_URI, dataId), null);
} }
// 返回插入的ID与uri的拼接结果
return ContentUris.withAppendedId(uri, insertedId); return ContentUris.withAppendedId(uri, insertedId);
} }
@Override @Override
public int delete(Uri uri, String selection, String[] selectionArgs) { public int delete(Uri uri, String selection, String[] selectionArgs) {
// 初始化删除的记录数
int count = 0; int count = 0;
// 初始化id
String id = null; String id = null;
// 获取可写的数据库
SQLiteDatabase db = mHelper.getWritableDatabase(); SQLiteDatabase db = mHelper.getWritableDatabase();
// 标记是否删除数据
boolean deleteData = false; boolean deleteData = false;
// 根据uri匹配的值执行不同的操作
switch (mMatcher.match(uri)) { switch (mMatcher.match(uri)) {
// 如果uri匹配的是URI_NOTE
case URI_NOTE: case URI_NOTE:
// 在selection中添加条件NoteColumns.ID大于0
selection = "(" + selection + ") AND " + NoteColumns.ID + ">0 "; selection = "(" + selection + ") AND " + NoteColumns.ID + ">0 ";
// 执行删除操作,返回删除的行数
count = db.delete(TABLE.NOTE, selection, selectionArgs); count = db.delete(TABLE.NOTE, selection, selectionArgs);
break; break;
// 如果uri匹配的是URI_NOTE_ITEM
case URI_NOTE_ITEM: case URI_NOTE_ITEM:
// 获取uri路径中的第二个参数即id
id = uri.getPathSegments().get(1); id = uri.getPathSegments().get(1);
/** /**
* ID that smaller than 0 is system folder which is not allowed to * ID that smaller than 0 is system folder which is not allowed to
* trash * trash
*/ */
// 将id转换为long类型
long noteId = Long.valueOf(id); long noteId = Long.valueOf(id);
// 如果noteId小于等于0则跳出循环
if (noteId <= 0) { if (noteId <= 0) {
break; break;
} }
// 删除note表中id等于id的记录并返回删除的记录数
count = db.delete(TABLE.NOTE, count = db.delete(TABLE.NOTE,
NoteColumns.ID + "=" + id + parseSelection(selection), selectionArgs); NoteColumns.ID + "=" + id + parseSelection(selection), selectionArgs);
// 跳出循环
break; break;
// 如果uri为URI_DATA则删除data表中满足selection条件的记录并返回删除的记录数
case URI_DATA: case URI_DATA:
count = db.delete(TABLE.DATA, selection, selectionArgs); count = db.delete(TABLE.DATA, selection, selectionArgs);
// 标记删除data表中的记录
deleteData = true; deleteData = true;
break; break;
// 如果uri为URI_DATA_ITEM则获取uri中的第二个路径段作为id删除data表中id等于id的记录并返回删除的记录数
case URI_DATA_ITEM: case URI_DATA_ITEM:
id = uri.getPathSegments().get(1); id = uri.getPathSegments().get(1);
count = db.delete(TABLE.DATA, count = db.delete(TABLE.DATA,
DataColumns.ID + "=" + id + parseSelection(selection), selectionArgs); DataColumns.ID + "=" + id + parseSelection(selection), selectionArgs);
// 标记删除data表中的记录
deleteData = true; deleteData = true;
break; break;
// 如果uri不是以上两种情况则抛出异常
default: default:
throw new IllegalArgumentException("Unknown URI " + uri); throw new IllegalArgumentException("Unknown URI " + uri);
} }
// 如果count大于0
if (count > 0) { if (count > 0) {
// 如果deleteData为true
if (deleteData) { if (deleteData) {
// 通知ContentResolverNotes.CONTENT_NOTE_URI发生了变化
getContext().getContentResolver().notifyChange(Notes.CONTENT_NOTE_URI, null); getContext().getContentResolver().notifyChange(Notes.CONTENT_NOTE_URI, null);
} }
// 通知ContentResolveruri发生了变化
getContext().getContentResolver().notifyChange(uri, null); getContext().getContentResolver().notifyChange(uri, null);
} }
// 返回count的值
return count; return count;
} }
@Override @Override
public int update(Uri uri, ContentValues values, String selection, String[] selectionArgs) { public int update(Uri uri, ContentValues values, String selection, String[] selectionArgs) {
// 定义更新条数
int count = 0; int count = 0;
// 定义id
String id = null; String id = null;
// 获取可写数据库
SQLiteDatabase db = mHelper.getWritableDatabase(); SQLiteDatabase db = mHelper.getWritableDatabase();
// 定义是否更新数据
boolean updateData = false; boolean updateData = false;
// 根据uri匹配对应的操作
switch (mMatcher.match(uri)) { switch (mMatcher.match(uri)) {
case URI_NOTE: case URI_NOTE:
// 增加note版本号
increaseNoteVersion(-1, selection, selectionArgs); increaseNoteVersion(-1, selection, selectionArgs);
// 更新数据
count = db.update(TABLE.NOTE, values, selection, selectionArgs); count = db.update(TABLE.NOTE, values, selection, selectionArgs);
break; break;
case URI_NOTE_ITEM: case URI_NOTE_ITEM:
// 获取URI中的路径段获取id
id = uri.getPathSegments().get(1); id = uri.getPathSegments().get(1);
// 增加笔记版本号
increaseNoteVersion(Long.valueOf(id), selection, selectionArgs); increaseNoteVersion(Long.valueOf(id), selection, selectionArgs);
// 更新数据库中的笔记信息
count = db.update(TABLE.NOTE, values, NoteColumns.ID + "=" + id count = db.update(TABLE.NOTE, values, NoteColumns.ID + "=" + id
+ parseSelection(selection), selectionArgs); + parseSelection(selection), selectionArgs);
break; break;
case URI_DATA: case URI_DATA:
// 更新数据表中的数据
count = db.update(TABLE.DATA, values, selection, selectionArgs); count = db.update(TABLE.DATA, values, selection, selectionArgs);
// 标记更新数据
updateData = true; updateData = true;
break; break;
case URI_DATA_ITEM: case URI_DATA_ITEM:
// 获取URI中的数据项ID
id = uri.getPathSegments().get(1); id = uri.getPathSegments().get(1);
// 更新数据表中的数据项
count = db.update(TABLE.DATA, values, DataColumns.ID + "=" + id count = db.update(TABLE.DATA, values, DataColumns.ID + "=" + id
+ parseSelection(selection), selectionArgs); + parseSelection(selection), selectionArgs);
// 标记更新数据
updateData = true; updateData = true;
break; break;
default: default:
// 抛出异常未知URI
throw new IllegalArgumentException("Unknown URI " + uri); throw new IllegalArgumentException("Unknown URI " + uri);
} }
// 如果count大于0
if (count > 0) { if (count > 0) {
// 如果updateData为true
if (updateData) { if (updateData) {
// 通知ContentResolver更新Notes.CONTENT_NOTE_URI
getContext().getContentResolver().notifyChange(Notes.CONTENT_NOTE_URI, null); getContext().getContentResolver().notifyChange(Notes.CONTENT_NOTE_URI, null);
} }
// 通知ContentResolver更新uri
getContext().getContentResolver().notifyChange(uri, null); getContext().getContentResolver().notifyChange(uri, null);
} }
// 返回count
return count; return count;
} }
// 解析selection字符串
private String parseSelection(String selection) { private String parseSelection(String selection) {
// 如果selection不为空
return (!TextUtils.isEmpty(selection) ? " AND (" + selection + ')' : ""); return (!TextUtils.isEmpty(selection) ? " AND (" + selection + ')' : "");
} }
// 增加笔记版本号
private void increaseNoteVersion(long id, String selection, String[] selectionArgs) { private void increaseNoteVersion(long id, String selection, String[] selectionArgs) {
// 创建一个StringBuilder对象用于拼接SQL语句
StringBuilder sql = new StringBuilder(120); StringBuilder sql = new StringBuilder(120);
// 拼接UPDATE语句
sql.append("UPDATE "); sql.append("UPDATE ");
// 拼接表名
sql.append(TABLE.NOTE); sql.append(TABLE.NOTE);
// 拼接SET语句
sql.append(" SET "); sql.append(" SET ");
// 拼接版本号字段
sql.append(NoteColumns.VERSION); sql.append(NoteColumns.VERSION);
// 拼接版本号增加1的语句
sql.append("=" + NoteColumns.VERSION + "+1 "); sql.append("=" + NoteColumns.VERSION + "+1 ");
// 如果id大于0或者selection不为空则添加WHERE关键字
if (id > 0 || !TextUtils.isEmpty(selection)) { if (id > 0 || !TextUtils.isEmpty(selection)) {
sql.append(" WHERE "); sql.append(" WHERE ");
} }
// 如果id大于0则添加id等于id的语句
if (id > 0) { if (id > 0) {
sql.append(NoteColumns.ID + "=" + String.valueOf(id)); sql.append(NoteColumns.ID + "=" + String.valueOf(id));
} }
// 如果selection不为空则解析selection并添加到sql语句中
if (!TextUtils.isEmpty(selection)) { if (!TextUtils.isEmpty(selection)) {
String selectString = id > 0 ? parseSelection(selection) : selection; String selectString = id > 0 ? parseSelection(selection) : selection;
// 遍历selectionArgs数组中的每一个元素
for (String args : selectionArgs) { for (String args : selectionArgs) {
// 将selectString中的第一个"?"替换为args
selectString = selectString.replaceFirst("\\?", args); selectString = selectString.replaceFirst("\\?", args);
} }
// 将替换后的selectString添加到sql中
sql.append(selectString); sql.append(selectString);
} }
// 获取可写的数据库
mHelper.getWritableDatabase().execSQL(sql.toString()); mHelper.getWritableDatabase().execSQL(sql.toString());
} }

File diff suppressed because it is too large Load Diff
Loading…
Cancel
Save