main
pzvjlefpx 2 months ago
parent c59ba63fe5
commit 0348938fc0

@ -26,9 +26,12 @@ import android.util.Log;
import java.util.HashMap;
public class Contact {
// 定义一个静态的HashMap用于缓存联系人信息
private static HashMap<String, String> sContactCache;
// 定义一个静态的字符串,用于标记日志信息
private static final String TAG = "Contact";
// 定义一个静态的字符串用于查询联系人信息的SQL语句
private static final String CALLER_ID_SELECTION = "PHONE_NUMBERS_EQUAL(" + Phone.NUMBER
+ ",?) AND " + Data.MIMETYPE + "='" + Phone.CONTENT_ITEM_TYPE + "'"
+ " AND " + Data.RAW_CONTACT_ID + " IN "
@ -36,17 +39,22 @@ public class Contact {
+ " FROM phone_lookup"
+ " WHERE min_match = '+')";
// 根据电话号码获取联系人信息
public static String getContact(Context context, String phoneNumber) {
// 如果缓存为空则创建一个新的HashMap
if(sContactCache == null) {
sContactCache = new HashMap<String, String>();
}
// 如果缓存中已经存在该电话号码的联系人信息,则直接返回
if(sContactCache.containsKey(phoneNumber)) {
return sContactCache.get(phoneNumber);
}
// 替换SQL语句中的占位符生成最终的查询语句
String selection = CALLER_ID_SELECTION.replace("+",
PhoneNumberUtils.toCallerIDMinMatch(phoneNumber));
// 执行查询操作
Cursor cursor = context.getContentResolver().query(
Data.CONTENT_URI,
new String [] { Phone.DISPLAY_NAME },
@ -54,18 +62,22 @@ public class Contact {
new String[] { phoneNumber },
null);
// 如果查询结果不为空,则获取联系人信息并缓存
if (cursor != null && cursor.moveToFirst()) {
try {
String name = cursor.getString(0);
sContactCache.put(phoneNumber, name);
return name;
} catch (IndexOutOfBoundsException e) {
// 如果获取联系人信息失败,则打印错误日志
Log.e(TAG, " Cursor get string error " + e.toString());
return null;
} finally {
// 关闭查询结果
cursor.close();
}
} else {
// 如果没有匹配的联系人信息,则打印日志
Log.d(TAG, "No contact matched with number:" + phoneNumber);
return null;
}

@ -18,6 +18,7 @@ package net.micode.notes.data;
import android.net.Uri;
public class Notes {
// 定义Notes类的常量
public static final String AUTHORITY = "micode_notes";
public static final String TAG = "Notes";
public static final int TYPE_NOTE = 0;
@ -35,6 +36,7 @@ public class Notes {
public static final int ID_CALL_RECORD_FOLDER = -2;
public static final int ID_TRASH_FOLER = -3;
// 定义Intent的额外参数
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";
@ -42,10 +44,12 @@ 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";
// 定义Widget的类型
public static final int TYPE_WIDGET_INVALIDE = -1;
public static final int TYPE_WIDGET_2X = 0;
public static final int TYPE_WIDGET_4X = 1;
// 定义DataConstants类
public static class DataConstants {
public static final String NOTE = TextNote.CONTENT_ITEM_TYPE;
public static final String CALL_NOTE = CallNote.CONTENT_ITEM_TYPE;
@ -61,6 +65,7 @@ public class Notes {
*/
public static final Uri CONTENT_DATA_URI = Uri.parse("content://" + AUTHORITY + "/data");
// 定义NoteColumns接口
public interface NoteColumns {
/**
* The unique ID for a row
@ -167,6 +172,7 @@ public class Notes {
public static final String VERSION = "version";
}
// 定义DataColumns接口
public interface DataColumns {
/**
* The unique ID for a row
@ -241,6 +247,7 @@ public class Notes {
public static final String DATA5 = "data5";
}
// 定义TextNote类
public static final class TextNote implements DataColumns {
/**
* Mode to indicate the text in check list mode or not
@ -257,6 +264,7 @@ public class Notes {
public static final Uri CONTENT_URI = Uri.parse("content://" + AUTHORITY + "/text_note");
}
// 定义CallNote类
public static final class CallNote implements DataColumns {
/**
* Call date for this record

@ -28,20 +28,26 @@ 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;
// 表名接口
public interface TABLE {
public static final String NOTE = "note";
public static final String DATA = "data";
}
// 日志标签
private static final String TAG = "NotesDatabaseHelper";
// 单例模式
private static NotesDatabaseHelper mInstance;
// 创建note表的SQL语句
private static final String CREATE_NOTE_TABLE_SQL =
"CREATE TABLE " + TABLE.NOTE + "(" +
NoteColumns.ID + " INTEGER PRIMARY KEY," +
@ -63,6 +69,7 @@ public class NotesDatabaseHelper extends SQLiteOpenHelper {
NoteColumns.VERSION + " INTEGER NOT NULL DEFAULT 0" +
")";
// 创建data表的SQL语句
private static final String CREATE_DATA_TABLE_SQL =
"CREATE TABLE " + TABLE.DATA + "(" +
DataColumns.ID + " INTEGER PRIMARY KEY," +
@ -78,6 +85,7 @@ public class NotesDatabaseHelper extends SQLiteOpenHelper {
DataColumns.DATA5 + " TEXT NOT NULL DEFAULT ''" +
")";
// 创建data_note_id索引的SQL语句
private static final String CREATE_DATA_NOTE_ID_INDEX_SQL =
"CREATE INDEX IF NOT EXISTS note_id_index ON " +
TABLE.DATA + "(" + DataColumns.NOTE_ID + ");";
@ -206,32 +214,54 @@ public class NotesDatabaseHelper extends SQLiteOpenHelper {
" WHERE " + NoteColumns.PARENT_ID + "=old." + NoteColumns.ID + ";" +
" END";
// 构造函数用于初始化NotesDatabaseHelper对象
public NotesDatabaseHelper(Context context) {
// 调用父类的构造函数,传入上下文、数据库名称、游标工厂、数据库版本号
super(context, DB_NAME, null, DB_VERSION);
}
// 创建note表
public void createNoteTable(SQLiteDatabase db) {
// 执行创建note表的SQL语句
db.execSQL(CREATE_NOTE_TABLE_SQL);
// 重新创建note表的触发器
reCreateNoteTableTriggers(db);
// 创建系统文件夹
createSystemFolder(db);
// 打印日志note表已创建
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");
// 删除减少文件夹计数触发器
db.execSQL("DROP TRIGGER IF EXISTS decrease_folder_count_on_delete");
// 删除删除数据触发器
db.execSQL("DROP TRIGGER IF EXISTS delete_data_on_delete");
// 删除增加文件夹计数触发器
db.execSQL("DROP TRIGGER IF EXISTS increase_folder_count_on_insert");
// 删除文件夹删除笔记触发器
db.execSQL("DROP TRIGGER IF EXISTS folder_delete_notes_on_delete");
// 删除文件夹移动笔记触发器
db.execSQL("DROP TRIGGER IF EXISTS folder_move_notes_on_trash");
// 创建增加文件夹计数触发器
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_DELETE_TRIGGER);
// 创建删除数据触发器
db.execSQL(NOTE_DELETE_DATA_ON_DELETE_TRIGGER);
// 创建增加文件夹计数触发器
db.execSQL(NOTE_INCREASE_FOLDER_COUNT_ON_INSERT_TRIGGER);
// 创建文件夹删除笔记触发器
db.execSQL(FOLDER_DELETE_NOTES_ON_DELETE_TRIGGER);
// 创建文件夹移动笔记触发器
db.execSQL(FOLDER_MOVE_NOTES_ON_TRASH_TRIGGER);
}
@ -270,92 +300,126 @@ 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);
// 执行创建数据表索引的SQL语句
db.execSQL(CREATE_DATA_NOTE_ID_INDEX_SQL);
// 打印日志,表示数据表已经创建
Log.d(TAG, "data table has been created");
}
// 重新创建数据表触发器
private void reCreateDataTableTriggers(SQLiteDatabase db) {
// 删除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");
// 删除update_note_content_on_delete触发器
db.execSQL("DROP TRIGGER IF EXISTS update_note_content_on_delete");
// 创建update_note_content_on_insert触发器
db.execSQL(DATA_UPDATE_NOTE_CONTENT_ON_INSERT_TRIGGER);
// 创建update_note_content_on_update触发器
db.execSQL(DATA_UPDATE_NOTE_CONTENT_ON_UPDATE_TRIGGER);
// 创建update_note_content_on_delete触发器
db.execSQL(DATA_UPDATE_NOTE_CONTENT_ON_DELETE_TRIGGER);
}
// 获取NotesDatabaseHelper实例
static synchronized NotesDatabaseHelper getInstance(Context context) {
// 如果mInstance为空则创建一个新的NotesDatabaseHelper实例
if (mInstance == null) {
mInstance = new NotesDatabaseHelper(context);
}
// 返回mInstance
return mInstance;
}
@Override
public void onCreate(SQLiteDatabase db) {
// 创建Note表
createNoteTable(db);
// 创建Data表
createDataTable(db);
}
@Override
public void onUpgrade(SQLiteDatabase db, int oldVersion, int newVersion) {
// 定义两个布尔变量用于判断是否需要重新创建触发器和是否跳过v2版本
boolean reCreateTriggers = false;
boolean skipV2 = false;
// 如果旧版本是1则升级到v2版本并跳过v2版本
if (oldVersion == 1) {
upgradeToV2(db);
skipV2 = true; // this upgrade including the upgrade from v2 to v3
oldVersion++;
}
// 如果旧版本是2且没有跳过v2版本则升级到v3版本并重新创建触发器
if (oldVersion == 2 && !skipV2) {
upgradeToV3(db);
reCreateTriggers = true;
oldVersion++;
}
// 如果旧版本是3则升级到v4版本
if (oldVersion == 3) {
upgradeToV4(db);
oldVersion++;
}
// 如果需要重新创建触发器,则重新创建触发器
if (reCreateTriggers) {
reCreateNoteTableTriggers(db);
reCreateDataTableTriggers(db);
}
// 如果旧版本不等于新版本,则抛出异常
if (oldVersion != newVersion) {
throw new IllegalStateException("Upgrade notes database to version " + newVersion
+ "fails");
}
}
// 升级数据库到V2版本
private void upgradeToV2(SQLiteDatabase db) {
// 删除旧版本的NOTE表
db.execSQL("DROP TABLE IF EXISTS " + TABLE.NOTE);
// 删除旧版本的DATA表
db.execSQL("DROP TABLE IF EXISTS " + TABLE.DATA);
// 创建新版本的NOTE表
createNoteTable(db);
// 创建新版本的DATA表
createDataTable(db);
}
// 升级到V3版本
private void upgradeToV3(SQLiteDatabase db) {
// drop unused triggers
// 删除更新笔记修改日期的触发器
db.execSQL("DROP TRIGGER IF EXISTS update_note_modified_date_on_insert");
db.execSQL("DROP TRIGGER IF EXISTS update_note_modified_date_on_delete");
db.execSQL("DROP TRIGGER IF EXISTS update_note_modified_date_on_update");
// add a column for gtask id
// 在笔记表中添加GTASK_ID列
db.execSQL("ALTER TABLE " + TABLE.NOTE + " ADD COLUMN " + NoteColumns.GTASK_ID
+ " TEXT NOT NULL DEFAULT ''");
// add a trash system folder
// 创建一个垃圾桶文件夹
ContentValues values = new ContentValues();
values.put(NoteColumns.ID, Notes.ID_TRASH_FOLER);
values.put(NoteColumns.TYPE, Notes.TYPE_SYSTEM);
db.insert(TABLE.NOTE, null, values);
}
// 将数据库升级到V4版本
private void upgradeToV4(SQLiteDatabase db) {
// 执行SQL语句向NOTE表中添加VERSION列类型为INTEGER默认值为0
db.execSQL("ALTER TABLE " + TABLE.NOTE + " ADD COLUMN " + NoteColumns.VERSION
+ " INTEGER NOT NULL DEFAULT 0");
}

@ -36,12 +36,16 @@ import net.micode.notes.data.NotesDatabaseHelper.TABLE;
public class NotesProvider extends ContentProvider {
// 定义UriMatcher
private static final UriMatcher mMatcher;
// 定义数据库帮助类
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;
@ -50,6 +54,7 @@ public class NotesProvider extends ContentProvider {
private static final int URI_SEARCH = 5;
private static final int URI_SEARCH_SUGGEST = 6;
// 静态代码块初始化UriMatcher
static {
mMatcher = new UriMatcher(UriMatcher.NO_MATCH);
mMatcher.addURI(Notes.AUTHORITY, "note", URI_NOTE);
@ -65,6 +70,7 @@ 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.
*/
// 定义搜索结果投影
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 + ","
@ -73,6 +79,7 @@ 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 ?"
@ -81,6 +88,7 @@ public class NotesProvider extends ContentProvider {
@Override
public boolean onCreate() {
// 初始化数据库帮助类
mHelper = NotesDatabaseHelper.getInstance(getContext());
return true;
}
@ -93,25 +101,30 @@ public class NotesProvider extends ContentProvider {
String id = null;
switch (mMatcher.match(uri)) {
case URI_NOTE:
// 查询所有笔记
c = db.query(TABLE.NOTE, projection, selection, selectionArgs, null, null,
sortOrder);
break;
case URI_NOTE_ITEM:
// 根据id查询笔记
id = uri.getPathSegments().get(1);
c = db.query(TABLE.NOTE, projection, NoteColumns.ID + "=" + id
+ parseSelection(selection), selectionArgs, null, null, sortOrder);
break;
case URI_DATA:
// 查询所有数据
c = db.query(TABLE.DATA, projection, selection, selectionArgs, null, null,
sortOrder);
break;
case URI_DATA_ITEM:
// 根据id查询数据
id = uri.getPathSegments().get(1);
c = db.query(TABLE.DATA, projection, DataColumns.ID + "=" + id
+ parseSelection(selection), selectionArgs, null, null, sortOrder);
break;
case URI_SEARCH:
case URI_SEARCH_SUGGEST:
// 搜索
if (sortOrder != null || projection != null) {
throw new IllegalArgumentException(
"do not specify sortOrder, selection, selectionArgs, or projection" + "with this query");
@ -149,13 +162,17 @@ public class NotesProvider extends ContentProvider {
@Override
public Uri insert(Uri uri, ContentValues values) {
// 获取可写的数据库
SQLiteDatabase db = mHelper.getWritableDatabase();
long dataId = 0, noteId = 0, insertedId = 0;
// 根据传入的uri匹配对应的操作
switch (mMatcher.match(uri)) {
case URI_NOTE:
// 插入笔记
insertedId = noteId = db.insert(TABLE.NOTE, null, values);
break;
case URI_DATA:
// 插入数据
if (values.containsKey(DataColumns.NOTE_ID)) {
noteId = values.getAsLong(DataColumns.NOTE_ID);
} else {
@ -183,16 +200,24 @@ public class NotesProvider extends ContentProvider {
@Override
public int delete(Uri uri, String selection, String[] selectionArgs) {
// 初始化删除计数器
int count = 0;
// 初始化ID
String id = null;
// 获取可写数据库
SQLiteDatabase db = mHelper.getWritableDatabase();
// 初始化删除数据标志
boolean deleteData = false;
// 根据URI匹配删除操作
switch (mMatcher.match(uri)) {
case URI_NOTE:
// 添加ID大于0的条件
selection = "(" + selection + ") AND " + NoteColumns.ID + ">0 ";
// 删除符合条件的记录
count = db.delete(TABLE.NOTE, selection, selectionArgs);
break;
case URI_NOTE_ITEM:
// 获取URI中的ID
id = uri.getPathSegments().get(1);
/**
* ID that smaller than 0 is system folder which is not allowed to
@ -229,76 +254,114 @@ public class NotesProvider extends ContentProvider {
@Override
public int update(Uri uri, ContentValues values, String selection, String[] selectionArgs) {
// 定义更新条数
int count = 0;
// 定义id
String id = null;
// 获取可写数据库
SQLiteDatabase db = mHelper.getWritableDatabase();
// 定义是否更新数据
boolean updateData = false;
// 根据uri匹配对应的操作
switch (mMatcher.match(uri)) {
case URI_NOTE:
// 增加note版本号
increaseNoteVersion(-1, selection, selectionArgs);
// 更新note表
count = db.update(TABLE.NOTE, values, selection, selectionArgs);
break;
case URI_NOTE_ITEM:
// 获取id
id = uri.getPathSegments().get(1);
// 增加note版本号
increaseNoteVersion(Long.valueOf(id), selection, selectionArgs);
// 更新note表
count = db.update(TABLE.NOTE, values, NoteColumns.ID + "=" + id
+ parseSelection(selection), selectionArgs);
break;
case URI_DATA:
// 更新data表
count = db.update(TABLE.DATA, values, selection, selectionArgs);
// 设置更新数据为true
updateData = true;
break;
case URI_DATA_ITEM:
// 获取id
id = uri.getPathSegments().get(1);
// 更新data表
count = db.update(TABLE.DATA, values, DataColumns.ID + "=" + id
+ parseSelection(selection), selectionArgs);
// 设置更新数据为true
updateData = true;
break;
default:
// 抛出异常
throw new IllegalArgumentException("Unknown URI " + uri);
}
// 如果更新条数大于0
if (count > 0) {
// 如果更新数据为true
if (updateData) {
// 通知note表改变
getContext().getContentResolver().notifyChange(Notes.CONTENT_NOTE_URI, null);
}
// 通知uri改变
getContext().getContentResolver().notifyChange(uri, null);
}
// 返回更新条数
return count;
}
// 解析selection字符串
private String parseSelection(String selection) {
// 如果selection不为空则返回" AND (" + selection + ')',否则返回空字符串
return (!TextUtils.isEmpty(selection) ? " AND (" + selection + ')' : "");
}
// 增加笔记版本号
private void increaseNoteVersion(long id, String selection, String[] selectionArgs) {
// 创建一个StringBuilder对象用于拼接SQL语句
StringBuilder sql = new StringBuilder(120);
// 拼接UPDATE语句
sql.append("UPDATE ");
// 拼接表名
sql.append(TABLE.NOTE);
// 拼接SET语句
sql.append(" SET ");
// 拼接版本号字段
sql.append(NoteColumns.VERSION);
// 拼接版本号增加1的语句
sql.append("=" + NoteColumns.VERSION + "+1 ");
// 如果id大于0或者selection不为空则拼接WHERE语句
if (id > 0 || !TextUtils.isEmpty(selection)) {
sql.append(" WHERE ");
}
// 如果id大于0则拼接id条件
if (id > 0) {
sql.append(NoteColumns.ID + "=" + String.valueOf(id));
}
// 如果selection不为空则拼接selection条件
if (!TextUtils.isEmpty(selection)) {
// 如果id大于0则解析selection
String selectString = id > 0 ? parseSelection(selection) : selection;
// 遍历selectionArgs替换selection中的占位符
for (String args : selectionArgs) {
selectString = selectString.replaceFirst("\\?", args);
}
// 拼接selection条件
sql.append(selectString);
}
// 执行SQL语句
mHelper.getWritableDatabase().execSQL(sql.toString());
}
@Override
public String getType(Uri uri) {
// TODO Auto-generated method stub
// 获取Uri的类型
return null;
}

@ -26,54 +26,71 @@ import org.json.JSONObject;
public class MetaData extends Task {
// 定义一个常量,用于日志输出
private final static String TAG = MetaData.class.getSimpleName();
// 定义一个私有变量用于存储相关任务ID
private String mRelatedGid = null;
// 设置元数据
public void setMeta(String gid, JSONObject metaInfo) {
try {
// 将相关任务ID添加到元数据中
metaInfo.put(GTaskStringUtils.META_HEAD_GTASK_ID, gid);
} catch (JSONException e) {
// 日志输出错误信息
Log.e(TAG, "failed to put related gid");
}
// 设置备注
setNotes(metaInfo.toString());
// 设置名称
setName(GTaskStringUtils.META_NOTE_NAME);
}
// 获取相关任务ID
public String getRelatedGid() {
return mRelatedGid;
}
// 判断是否需要保存
@Override
public boolean isWorthSaving() {
return getNotes() != null;
}
// 根据远程JSON设置内容
@Override
public void setContentByRemoteJSON(JSONObject js) {
super.setContentByRemoteJSON(js);
if (getNotes() != null) {
try {
// 将备注转换为JSON对象
JSONObject metaInfo = new JSONObject(getNotes().trim());
// 获取相关任务ID
mRelatedGid = metaInfo.getString(GTaskStringUtils.META_HEAD_GTASK_ID);
} catch (JSONException e) {
// 日志输出警告信息
Log.w(TAG, "failed to get related gid");
// 将相关任务ID设置为null
mRelatedGid = null;
}
}
}
// 根据本地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");

@ -47,10 +47,15 @@ public abstract class Node {
private boolean mDeleted;
// 构造函数初始化Node对象
public Node() {
// 初始化mGid为null
mGid = null;
// 初始化mName为空字符串
mName = "";
// 初始化mLastModified为0
mLastModified = 0;
// 初始化mDeleted为false
mDeleted = false;
}

@ -36,41 +36,58 @@ import org.json.JSONObject;
public class SqlData {
// 定义一个常量,用于标识类的简单名称
private static final String TAG = SqlData.class.getSimpleName();
// 定义一个常量用于标识无效的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
};
// 定义一个常量用于标识数据的ID列
public static final int DATA_ID_COLUMN = 0;
// 定义一个常量用于标识数据的MIME类型列
public static final int DATA_MIME_TYPE_COLUMN = 1;
// 定义一个常量用于标识数据的CONTENT列
public static final int DATA_CONTENT_COLUMN = 2;
// 定义一个常量用于标识数据的DATA1列
public static final int DATA_CONTENT_DATA_1_COLUMN = 3;
// 定义一个常量用于标识数据的DATA3列
public static final int DATA_CONTENT_DATA_3_COLUMN = 4;
// 定义一个ContentResolver对象用于访问内容提供者
private ContentResolver mContentResolver;
// 定义一个布尔值,用于标识是否创建
private boolean mIsCreate;
// 定义一个长整型变量用于存储数据的ID
private long mDataId;
// 定义一个字符串变量用于存储数据的MIME类型
private String mDataMimeType;
// 定义一个字符串变量用于存储数据的CONTENT
private String mDataContent;
// 定义一个长整型变量用于存储数据的DATA1
private long mDataContentData1;
// 定义一个字符串变量用于存储数据的DATA3
private String mDataContentData3;
// 定义一个ContentValues对象用于存储数据的差异
private ContentValues mDiffDataValues;
// 构造函数用于创建一个新的SqlData对象
public SqlData(Context context) {
mContentResolver = context.getContentResolver();
mIsCreate = true;
@ -82,6 +99,7 @@ public class SqlData {
mDiffDataValues = new ContentValues();
}
// 构造函数用于从Cursor中加载数据
public SqlData(Context context, Cursor c) {
mContentResolver = context.getContentResolver();
mIsCreate = false;
@ -89,6 +107,7 @@ public class SqlData {
mDiffDataValues = new ContentValues();
}
// 从Cursor中加载数据
private void loadFromCursor(Cursor c) {
mDataId = c.getLong(DATA_ID_COLUMN);
mDataMimeType = c.getString(DATA_MIME_TYPE_COLUMN);
@ -97,6 +116,7 @@ public class SqlData {
mDataContentData3 = c.getString(DATA_CONTENT_DATA_3_COLUMN);
}
// 设置数据
public void setContent(JSONObject js) throws JSONException {
long dataId = js.has(DataColumns.ID) ? js.getLong(DataColumns.ID) : INVALID_ID;
if (mIsCreate || mDataId != dataId) {
@ -130,6 +150,7 @@ public class SqlData {
mDataContentData3 = dataContentData3;
}
// 获取数据
public JSONObject getContent() throws JSONException {
if (mIsCreate) {
Log.e(TAG, "it seems that we haven't created this in database yet");
@ -144,28 +165,43 @@ public class SqlData {
return js;
}
// 提交数据
// 提交数据
public void commit(long noteId, boolean validateVersion, long version) {
// 如果是创建
if (mIsCreate) {
// 如果数据ID无效且数据值中包含ID列
if (mDataId == INVALID_ID && mDiffDataValues.containsKey(DataColumns.ID)) {
// 移除ID列
mDiffDataValues.remove(DataColumns.ID);
}
// 添加NOTE_ID列
mDiffDataValues.put(DataColumns.NOTE_ID, noteId);
// 插入数据
Uri uri = mContentResolver.insert(Notes.CONTENT_DATA_URI, mDiffDataValues);
try {
// 获取数据ID
mDataId = Long.valueOf(uri.getPathSegments().get(1));
} catch (NumberFormatException e) {
// 打印错误日志
Log.e(TAG, "Get note id error :" + e.toString());
// 抛出异常
throw new ActionFailureException("create note failed");
}
} else {
// 如果数据值不为空
if (mDiffDataValues.size() > 0) {
// 更新结果
int result = 0;
// 如果不验证版本
if (!validateVersion) {
// 更新数据
result = mContentResolver.update(ContentUris.withAppendedId(
Notes.CONTENT_DATA_URI, mDataId), mDiffDataValues, null, null);
} else {
// 更新数据,验证版本
result = mContentResolver.update(ContentUris.withAppendedId(
Notes.CONTENT_DATA_URI, mDataId), mDiffDataValues,
" ? in (SELECT " + NoteColumns.ID + " FROM " + TABLE.NOTE
@ -173,16 +209,21 @@ public class SqlData {
String.valueOf(noteId), String.valueOf(version)
});
}
// 如果更新结果为0
if (result == 0) {
// 打印警告日志
Log.w(TAG, "there is no update. maybe user updates note when syncing");
}
}
}
// 清空数据值
mDiffDataValues.clear();
// 设置为非创建
mIsCreate = false;
}
// 获取数据的ID
public long getId() {
return mDataId;
}

@ -122,105 +122,173 @@ public class SqlNote {
private ArrayList<SqlData> mDataList;
// 构造函数初始化SqlNote对象
public SqlNote(Context context) {
// 保存上下文
mContext = context;
// 获取ContentResolver
mContentResolver = context.getContentResolver();
// 标记为创建
mIsCreate = true;
// 初始化ID为无效ID
mId = INVALID_ID;
// 初始化提醒日期为0
mAlertDate = 0;
// 获取默认背景颜色ID
mBgColorId = ResourceParser.getDefaultBgId(context);
// 获取当前时间作为创建日期
mCreatedDate = System.currentTimeMillis();
// 初始化是否有附件为0
mHasAttachment = 0;
// 获取当前时间作为修改日期
mModifiedDate = System.currentTimeMillis();
// 初始化父ID为0
mParentId = 0;
// 初始化片段为空字符串
mSnippet = "";
// 初始化类型为笔记
mType = Notes.TYPE_NOTE;
// 初始化小部件ID为无效ID
mWidgetId = AppWidgetManager.INVALID_APPWIDGET_ID;
// 初始化小部件类型为无效类型
mWidgetType = Notes.TYPE_WIDGET_INVALIDE;
// 初始化原始父ID为0
mOriginParent = 0;
// 初始化版本号为0
mVersion = 0;
// 初始化ContentValues对象
mDiffNoteValues = new ContentValues();
// 初始化数据列表
mDataList = new ArrayList<SqlData>();
}
// 构造函数用于从Cursor中加载SqlNote对象
public SqlNote(Context context, Cursor c) {
// 保存上下文
mContext = context;
// 获取ContentResolver
mContentResolver = context.getContentResolver();
// 标记为未创建
mIsCreate = false;
// 从Cursor中加载SqlNote对象
loadFromCursor(c);
// 初始化数据列表
mDataList = new ArrayList<SqlData>();
// 如果类型为Notes.TYPE_NOTE则加载内容
if (mType == Notes.TYPE_NOTE)
loadDataContent();
// 初始化ContentValues
mDiffNoteValues = new ContentValues();
}
// 构造函数传入上下文和id
public SqlNote(Context context, long id) {
// 保存上下文
mContext = context;
// 获取内容解析器
mContentResolver = context.getContentResolver();
// 标记为未创建
mIsCreate = false;
// 从游标中加载
loadFromCursor(id);
// 创建数据列表
mDataList = new ArrayList<SqlData>();
// 如果类型为笔记,则加载内容
if (mType == Notes.TYPE_NOTE)
loadDataContent();
// 创建内容值
mDiffNoteValues = new ContentValues();
}
// 从游标中加载数据
private void loadFromCursor(long id) {
// 声明游标变量
Cursor c = null;
try {
// 从ContentResolver中查询数据
c = mContentResolver.query(Notes.CONTENT_NOTE_URI, PROJECTION_NOTE, "(_id=?)",
new String[] {
String.valueOf(id)
}, null);
// 如果游标不为空
if (c != null) {
// 将游标移动到下一行
c.moveToNext();
// 从游标中加载数据
loadFromCursor(c);
} else {
// 如果游标为空,则输出警告日志
Log.w(TAG, "loadFromCursor: cursor = null");
}
} finally {
// 关闭游标
if (c != null)
c.close();
}
}
// 从游标中加载数据
private void loadFromCursor(Cursor c) {
// 获取ID
mId = c.getLong(ID_COLUMN);
// 获取提醒日期
mAlertDate = c.getLong(ALERTED_DATE_COLUMN);
// 获取背景颜色ID
mBgColorId = c.getInt(BG_COLOR_ID_COLUMN);
// 获取创建日期
mCreatedDate = c.getLong(CREATED_DATE_COLUMN);
// 获取是否有附件
mHasAttachment = c.getInt(HAS_ATTACHMENT_COLUMN);
// 获取修改日期
mModifiedDate = c.getLong(MODIFIED_DATE_COLUMN);
// 获取父ID
mParentId = c.getLong(PARENT_ID_COLUMN);
// 获取片段
mSnippet = c.getString(SNIPPET_COLUMN);
// 获取类型
mType = c.getInt(TYPE_COLUMN);
// 获取小部件ID
mWidgetId = c.getInt(WIDGET_ID_COLUMN);
// 获取小部件类型
mWidgetType = c.getInt(WIDGET_TYPE_COLUMN);
// 获取版本
mVersion = c.getLong(VERSION_COLUMN);
}
// 加载数据内容
private void loadDataContent() {
// 声明游标
Cursor c = null;
// 清空数据列表
mDataList.clear();
try {
// 查询数据
c = mContentResolver.query(Notes.CONTENT_DATA_URI, SqlData.PROJECTION_DATA,
"(note_id=?)", new String[] {
String.valueOf(mId)
}, null);
// 如果游标不为空
if (c != null) {
// 如果游标中没有数据
if (c.getCount() == 0) {
// 打印警告日志
Log.w(TAG, "it seems that the note has not data");
return;
}
// 遍历游标
while (c.moveToNext()) {
// 创建SqlData对象
SqlData data = new SqlData(mContext, c);
// 将数据添加到数据列表中
mDataList.add(data);
}
} else {
// 打印警告日志
Log.w(TAG, "loadDataContent: cursor = null");
}
} finally {
// 关闭游标
if (c != null)
c.close();
}
@ -228,7 +296,9 @@ public class SqlNote {
public boolean setContent(JSONObject js) {
try {
// 获取note对象
JSONObject note = js.getJSONObject(GTaskStringUtils.META_HEAD_NOTE);
// 如果note的类型是系统文件夹则不能设置
if (note.getInt(NoteColumns.TYPE) == Notes.TYPE_SYSTEM) {
Log.w(TAG, "cannot set system folder");
} else if (note.getInt(NoteColumns.TYPE) == Notes.TYPE_FOLDER) {
@ -359,51 +429,82 @@ public class SqlNote {
return true;
}
// 获取内容
public JSONObject getContent() {
try {
// 创建一个JSONObject对象
JSONObject js = new JSONObject();
// 如果mIsCreate为true说明还没有在数据库中创建
if (mIsCreate) {
Log.e(TAG, "it seems that we haven't created this in database yet");
return null;
}
// 创建一个JSONObject对象
JSONObject note = new JSONObject();
// 如果mType为Notes.TYPE_NOTE
if (mType == Notes.TYPE_NOTE) {
// 将mId放入note中
note.put(NoteColumns.ID, mId);
// 将mAlertDate放入note中
note.put(NoteColumns.ALERTED_DATE, mAlertDate);
// 将mBgColorId放入note中
note.put(NoteColumns.BG_COLOR_ID, mBgColorId);
// 将mCreatedDate放入note中
note.put(NoteColumns.CREATED_DATE, mCreatedDate);
// 将mHasAttachment放入note中
note.put(NoteColumns.HAS_ATTACHMENT, mHasAttachment);
// 将mModifiedDate放入note中
note.put(NoteColumns.MODIFIED_DATE, mModifiedDate);
// 将mParentId放入note中
note.put(NoteColumns.PARENT_ID, mParentId);
// 将mSnippet放入note中
note.put(NoteColumns.SNIPPET, mSnippet);
// 将mType放入note中
note.put(NoteColumns.TYPE, mType);
// 将mWidgetId放入note中
note.put(NoteColumns.WIDGET_ID, mWidgetId);
// 将mWidgetType放入note中
note.put(NoteColumns.WIDGET_TYPE, mWidgetType);
// 将mOriginParent放入note中
note.put(NoteColumns.ORIGIN_PARENT_ID, mOriginParent);
// 将note放入js中
js.put(GTaskStringUtils.META_HEAD_NOTE, note);
// 创建一个JSONArray对象
JSONArray dataArray = new JSONArray();
// 遍历mDataList
for (SqlData sqlData : mDataList) {
// 获取sqlData的内容
JSONObject data = sqlData.getContent();
// 如果data不为空
if (data != null) {
// 将data放入dataArray中
dataArray.put(data);
}
}
// 将dataArray放入js中
js.put(GTaskStringUtils.META_HEAD_DATA, dataArray);
// 如果mType为Notes.TYPE_FOLDER或Notes.TYPE_SYSTEM
} else if (mType == Notes.TYPE_FOLDER || mType == Notes.TYPE_SYSTEM) {
// 将mId放入note中
note.put(NoteColumns.ID, mId);
// 将mType放入note中
note.put(NoteColumns.TYPE, mType);
// 将mSnippet放入note中
note.put(NoteColumns.SNIPPET, mSnippet);
// 将note放入js中
js.put(GTaskStringUtils.META_HEAD_NOTE, note);
}
// 返回js
return js;
} catch (JSONException e) {
Log.e(TAG, e.toString());
e.printStackTrace();
}
// 返回null
return null;
}
@ -441,53 +542,72 @@ public class SqlNote {
}
public void commit(boolean validateVersion) {
// 如果是创建
if (mIsCreate) {
// 如果id为无效id且mDiffNoteValues中包含NoteColumns.ID
if (mId == INVALID_ID && mDiffNoteValues.containsKey(NoteColumns.ID)) {
// 从mDiffNoteValues中移除NoteColumns.ID
mDiffNoteValues.remove(NoteColumns.ID);
}
// 插入数据到Notes.CONTENT_NOTE_URI返回uri
Uri uri = mContentResolver.insert(Notes.CONTENT_NOTE_URI, mDiffNoteValues);
try {
// 从uri中获取id
mId = Long.valueOf(uri.getPathSegments().get(1));
} catch (NumberFormatException e) {
// 如果获取id失败打印错误日志抛出ActionFailureException
Log.e(TAG, "Get note id error :" + e.toString());
throw new ActionFailureException("create note failed");
}
// 如果id为0抛出IllegalStateException
if (mId == 0) {
throw new IllegalStateException("Create thread id failed");
}
// 如果类型为Notes.TYPE_NOTE
if (mType == Notes.TYPE_NOTE) {
// 遍历mDataList调用commit方法
for (SqlData sqlData : mDataList) {
sqlData.commit(mId, false, -1);
}
}
} else {
// 如果id小于等于0且id不是Notes.ID_ROOT_FOLDER和Notes.ID_CALL_RECORD_FOLDER
if (mId <= 0 && mId != Notes.ID_ROOT_FOLDER && mId != Notes.ID_CALL_RECORD_FOLDER) {
// 打印错误日志抛出IllegalStateException
Log.e(TAG, "No such note");
throw new IllegalStateException("Try to update note with invalid id");
}
// 如果mDiffNoteValues不为空
if (mDiffNoteValues.size() > 0) {
// 版本号加1
mVersion ++;
int result = 0;
// 如果不验证版本号
if (!validateVersion) {
// 更新数据
result = mContentResolver.update(Notes.CONTENT_NOTE_URI, mDiffNoteValues, "("
+ NoteColumns.ID + "=?)", new String[] {
String.valueOf(mId)
});
} else {
// 更新数据,验证版本号
result = mContentResolver.update(Notes.CONTENT_NOTE_URI, mDiffNoteValues, "("
+ NoteColumns.ID + "=?) AND (" + NoteColumns.VERSION + "<=?)",
new String[] {
String.valueOf(mId), String.valueOf(mVersion)
});
}
// 如果没有更新,打印警告日志
if (result == 0) {
Log.w(TAG, "there is no update. maybe user updates note when syncing");
}
}
// 如果类型为Notes.TYPE_NOTE
if (mType == Notes.TYPE_NOTE) {
// 遍历mDataList调用commit方法
for (SqlData sqlData : mDataList) {
sqlData.commit(mId, validateVersion, mVersion);
}

@ -33,18 +33,25 @@ import org.json.JSONObject;
public class Task extends Node {
// 定义一个常量,用于打印日志
private static final String TAG = Task.class.getSimpleName();
// 定义一个布尔变量,表示任务是否完成
private boolean mCompleted;
// 定义一个字符串变量,用于存储任务的备注
private String mNotes;
// 定义一个JSONObject变量用于存储任务的元信息
private JSONObject mMetaInfo;
// 定义一个Task变量用于存储任务的前一个兄弟任务
private Task mPriorSibling;
// 定义一个TaskList变量用于存储任务的父任务列表
private TaskList mParent;
// 构造函数,初始化任务
public Task() {
super();
mCompleted = false;
@ -54,6 +61,7 @@ public class Task extends Node {
mMetaInfo = null;
}
// 获取创建任务的JSON对象
public JSONObject getCreateAction(int actionId) {
JSONObject js = new JSONObject();
@ -103,6 +111,7 @@ public class Task extends Node {
return js;
}
// 获取更新任务的JSON对象
public JSONObject getUpdateAction(int actionId) {
JSONObject js = new JSONObject();
@ -135,6 +144,7 @@ public class Task extends Node {
return js;
}
// 根据远程JSON设置任务内容
public void setContentByRemoteJSON(JSONObject js) {
if (js != null) {
try {
@ -175,6 +185,7 @@ public class Task extends Node {
}
}
// 根据本地JSON设置任务内容
public void setContentByLocalJSON(JSONObject js) {
if (js == null || !js.has(GTaskStringUtils.META_HEAD_NOTE)
|| !js.has(GTaskStringUtils.META_HEAD_DATA)) {
@ -204,6 +215,7 @@ public class Task extends Node {
}
}
// 获取本地JSON对象
public JSONObject getLocalJSONFromContent() {
String name = getName();
try {
@ -247,6 +259,7 @@ public class Task extends Node {
}
}
// 设置任务的元信息
public void setMetaInfo(MetaData metaData) {
if (metaData != null && metaData.getNotes() != null) {
try {
@ -258,6 +271,7 @@ public class Task extends Node {
}
}
// 获取同步动作
public int getSyncAction(Cursor c) {
try {
JSONObject noteInfo = null;
@ -311,39 +325,48 @@ public class Task extends Node {
return SYNC_ACTION_ERROR;
}
// 判断任务是否值得保存
public boolean isWorthSaving() {
return mMetaInfo != null || (getName() != null && getName().trim().length() > 0)
|| (getNotes() != null && getNotes().trim().length() > 0);
}
// 设置任务是否完成
public void setCompleted(boolean completed) {
this.mCompleted = completed;
}
// 设置任务的备注
public void setNotes(String notes) {
this.mNotes = notes;
}
// 设置任务的前一个兄弟任务
public void setPriorSibling(Task priorSibling) {
this.mPriorSibling = priorSibling;
}
// 设置任务的父任务列表
public void setParent(TaskList parent) {
this.mParent = parent;
}
// 获取任务是否完成
public boolean getCompleted() {
return this.mCompleted;
}
// 获取任务的备注
public String getNotes() {
return this.mNotes;
}
// 获取任务的前一个兄弟任务
public Task getPriorSibling() {
return this.mPriorSibling;
}
// 获取任务的父任务列表
public TaskList getParent() {
return this.mParent;
}

Loading…
Cancel
Save