|
|
/*
|
|
|
* Copyright (c) 2010-2011, The MiCode Open Source Community (www.micode.net)
|
|
|
*
|
|
|
* Licensed under the Apache License, Version 2.0 (the "License");
|
|
|
* you may not use this file except in compliance with the License.
|
|
|
* You may obtain a copy of the License at
|
|
|
*
|
|
|
* http://www.apache.org/licenses/LICENSE-2.0
|
|
|
*
|
|
|
* Unless required by applicable law or agreed to in writing, software
|
|
|
* distributed under the License is distributed on an "AS IS" BASIS,
|
|
|
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
|
* See the License for the specific language governing permissions and
|
|
|
* limitations under the License.
|
|
|
*/
|
|
|
|
|
|
package net.micode.notes.data;
|
|
|
|
|
|
|
|
|
import android.app.SearchManager;
|
|
|
import android.content.ContentProvider;
|
|
|
import android.content.ContentUris;
|
|
|
import android.content.ContentValues;
|
|
|
import android.content.Intent;
|
|
|
import android.content.UriMatcher;
|
|
|
import android.database.Cursor;
|
|
|
import android.database.sqlite.SQLiteDatabase;
|
|
|
import android.net.Uri;
|
|
|
import android.text.TextUtils;
|
|
|
import android.util.Log;
|
|
|
|
|
|
import net.micode.notes.R;
|
|
|
import net.micode.notes.tool.SearchHistoryManager;
|
|
|
import net.micode.notes.data.Notes.DataColumns;
|
|
|
import net.micode.notes.data.Notes.NoteColumns;
|
|
|
import net.micode.notes.data.NotesDatabaseHelper.TABLE;
|
|
|
|
|
|
/**
|
|
|
* 笔记应用的ContentProvider实现类，继承自Android的ContentProvider
|
|
|
* 核心功能：
|
|
|
* 1. 作为应用数据的对外统一访问接口，封装SQLite数据库的CRUD（增删改查）操作；
|
|
|
* 2. 通过UriMatcher匹配不同的Uri，处理note表、data表的单条/多条数据操作；
|
|
|
* 3. 支持安卓系统的搜索框架，提供笔记搜索和搜索建议功能；
|
|
|
* 4. 数据变更时发送通知（notifyChange），让UI组件同步更新数据；
|
|
|
* 5. 更新笔记时自动增加版本号，用于数据同步的版本控制。
|
|
|
*
|
|
|
* ContentProvider是安卓四大组件之一，用于跨应用/进程的数据共享，本类也是应用内部数据访问的统一入口。
|
|
|
*
|
|
|
* @author MiCode Open Source Community
|
|
|
* @date 2010-2011
|
|
|
*/
|
|
|
public class NotesProvider extends ContentProvider {
|
|
|
/**
|
|
|
* Uri匹配器，用于将外部传入的Uri匹配为对应的操作类型（如查询所有笔记、查询单条数据、搜索等）
|
|
|
* 静态常量，类加载时初始化，全局唯一
|
|
|
*/
|
|
|
private static final UriMatcher mMatcher;
|
|
|
|
|
|
/**
|
|
|
* 数据库帮助类实例，用于获取SQLiteDatabase对象执行数据库操作
|
|
|
*/
|
|
|
private NotesDatabaseHelper mHelper;
|
|
|
|
|
|
/**
|
|
|
* 日志标签，用于Logcat输出时标识当前类，方便调试定位问题
|
|
|
*/
|
|
|
private static final String TAG = "NotesProvider";
|
|
|
|
|
|
// ====================== Uri匹配类型常量 ======================
|
|
|
/**
|
|
|
* Uri匹配类型：查询/操作note表的所有数据
|
|
|
*/
|
|
|
private static final int URI_NOTE = 1;
|
|
|
/**
|
|
|
* Uri匹配类型：查询/操作note表的单条数据（通过ID，如note/1）
|
|
|
*/
|
|
|
private static final int URI_NOTE_ITEM = 2;
|
|
|
/**
|
|
|
* Uri匹配类型：查询/操作data表的所有数据
|
|
|
*/
|
|
|
private static final int URI_DATA = 3;
|
|
|
/**
|
|
|
* Uri匹配类型：查询/操作data表的单条数据（通过ID，如data/1）
|
|
|
*/
|
|
|
private static final int URI_DATA_ITEM = 4;
|
|
|
/**
|
|
|
* Uri匹配类型：执行笔记搜索操作
|
|
|
*/
|
|
|
private static final int URI_SEARCH = 5;
|
|
|
/**
|
|
|
* Uri匹配类型：提供搜索建议（适配安卓SearchManager）
|
|
|
*/
|
|
|
private static final int URI_SEARCH_SUGGEST = 6;
|
|
|
|
|
|
|
|
|
/**
|
|
|
* 静态代码块：初始化UriMatcher，添加Uri匹配规则
|
|
|
* 规则格式：authority（授权名） + path（路径） -> 匹配类型常量
|
|
|
*/
|
|
|
static {
|
|
|
// 初始化UriMatcher，默认匹配失败返回UriMatcher.NO_MATCH
|
|
|
mMatcher = new UriMatcher(UriMatcher.NO_MATCH);
|
|
|
// 匹配note表所有数据：content://micode_notes/note -> URI_NOTE
|
|
|
mMatcher.addURI(Notes.AUTHORITY, "note", URI_NOTE);
|
|
|
// 匹配note表单条数据：content://micode_notes/note/#（#表示数字ID） -> URI_NOTE_ITEM
|
|
|
mMatcher.addURI(Notes.AUTHORITY, "note/#", URI_NOTE_ITEM);
|
|
|
// 匹配data表所有数据：content://micode_notes/data -> URI_DATA
|
|
|
mMatcher.addURI(Notes.AUTHORITY, "data", URI_DATA);
|
|
|
// 匹配data表单条数据：content://micode_notes/data/# -> URI_DATA_ITEM
|
|
|
mMatcher.addURI(Notes.AUTHORITY, "data/#", URI_DATA_ITEM);
|
|
|
// 匹配搜索操作：content://micode_notes/search -> URI_SEARCH
|
|
|
mMatcher.addURI(Notes.AUTHORITY, "search", URI_SEARCH);
|
|
|
// 匹配搜索建议（空查询）：content://micode_notes/suggestions/query -> URI_SEARCH_SUGGEST
|
|
|
mMatcher.addURI(Notes.AUTHORITY, SearchManager.SUGGEST_URI_PATH_QUERY, URI_SEARCH_SUGGEST);
|
|
|
// 匹配搜索建议（带关键词）：content://micode_notes/suggestions/query/关键词 -> URI_SEARCH_SUGGEST
|
|
|
mMatcher.addURI(Notes.AUTHORITY, SearchManager.SUGGEST_URI_PATH_QUERY + "/*", URI_SEARCH_SUGGEST);
|
|
|
|
|
|
}
|
|
|
|
|
|
/**
|
|
|
* 笔记搜索的投影（Projection）字符串，定义了搜索结果需要返回的列
|
|
|
* 适配安卓SearchManager的搜索建议列名，核心处理逻辑：
|
|
|
* 1. x'0A'是SQLite中的换行符\n，替换并修剪空格，让搜索结果显示更整洁；
|
|
|
* 2. 映射SearchManager的标准列名（如SUGGEST_COLUMN_TEXT_1、SUGGEST_COLUMN_ICON_1），供搜索框架使用；
|
|
|
* 3. 包含笔记ID、内容、图标、意图动作等信息，用于搜索建议的展示和跳转。
|
|
|
*/
|
|
|
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 + ","
|
|
|
+ "TRIM(REPLACE(" + NoteColumns.SNIPPET + ", x'0A','')) AS " + SearchManager.SUGGEST_COLUMN_TEXT_2 + ","
|
|
|
+ R.drawable.search_result + " AS " + SearchManager.SUGGEST_COLUMN_ICON_1 + ","
|
|
|
+ "'" + Intent.ACTION_VIEW + "' AS " + SearchManager.SUGGEST_COLUMN_INTENT_ACTION + ","
|
|
|
+ "'" + Notes.TextNote.CONTENT_TYPE + "' AS " + SearchManager.SUGGEST_COLUMN_INTENT_DATA;
|
|
|
|
|
|
/**
|
|
|
* 笔记搜索的SQL查询语句，逻辑：
|
|
|
* 1. 选择NOTES_SEARCH_PROJECTION定义的列；
|
|
|
* 2. 从note表查询；
|
|
|
* 3. 条件：摘要包含搜索关键词（LIKE ?）、不在回收站（PARENT_ID != 回收站ID）、类型为普通笔记（TYPE=NOTE）。
|
|
|
*/
|
|
|
private static String NOTES_SNIPPET_SEARCH_QUERY = "SELECT " + NOTES_SEARCH_PROJECTION
|
|
|
+ " FROM " + TABLE.NOTE
|
|
|
+ " WHERE " + NoteColumns.SNIPPET + " LIKE ?"
|
|
|
+ " AND " + NoteColumns.PARENT_ID + "<>" + Notes.ID_TRASH_FOLER
|
|
|
+ " AND " + NoteColumns.TYPE + "=" + Notes.TYPE_NOTE;
|
|
|
|
|
|
/**
|
|
|
* ContentProvider创建时调用的方法，初始化数据库帮助类实例
|
|
|
* @return true表示ContentProvider创建成功，false表示失败
|
|
|
*/
|
|
|
@Override
|
|
|
public boolean onCreate() {
|
|
|
// 获取NotesDatabaseHelper的单例实例，上下文使用ContentProvider的上下文
|
|
|
mHelper = NotesDatabaseHelper.getInstance(getContext());
|
|
|
return true;
|
|
|
}
|
|
|
|
|
|
/**
|
|
|
* 处理数据查询请求，是ContentProvider的核心方法之一
|
|
|
* 根据Uri匹配的类型，执行不同的数据库查询逻辑，返回Cursor对象
|
|
|
*
|
|
|
* @param uri 要查询的Uri
|
|
|
* @param projection 要返回的列（投影），null表示返回所有列
|
|
|
* @param selection 查询条件（WHERE子句），?作为占位符
|
|
|
* @param selectionArgs 查询条件的参数，替换selection中的?
|
|
|
* @param sortOrder 排序规则（ORDER BY子句）
|
|
|
* @return 查询结果的Cursor对象，若查询失败返回null
|
|
|
*/
|
|
|
@Override
|
|
|
public Cursor query(Uri uri, String[] projection, String selection, String[] selectionArgs,
|
|
|
String sortOrder) {
|
|
|
Cursor c = null;
|
|
|
// 获取只读的SQLiteDatabase对象（查询操作使用只读数据库，提升性能）
|
|
|
SQLiteDatabase db = mHelper.getReadableDatabase();
|
|
|
String id = null; // 存储Uri中的ID（如note/1中的1）
|
|
|
|
|
|
// 根据Uri匹配的类型执行不同的查询逻辑
|
|
|
switch (mMatcher.match(uri)) {
|
|
|
case URI_NOTE:
|
|
|
// 查询note表的所有数据
|
|
|
c = db.query(TABLE.NOTE, projection, selection, selectionArgs, null, null,
|
|
|
sortOrder);
|
|
|
break;
|
|
|
case URI_NOTE_ITEM:
|
|
|
// 获取Uri中的ID（路径的第二个分段，如note/1的路径分段是["note", "1"]）
|
|
|
id = uri.getPathSegments().get(1);
|
|
|
// 查询note表的单条数据，条件：ID=id + 传入的selection
|
|
|
c = db.query(TABLE.NOTE, projection, NoteColumns.ID + "=" + id
|
|
|
+ parseSelection(selection), selectionArgs, null, null, sortOrder);
|
|
|
break;
|
|
|
case URI_DATA:
|
|
|
// 查询data表的所有数据
|
|
|
c = db.query(TABLE.DATA, projection, selection, selectionArgs, null, null,
|
|
|
sortOrder);
|
|
|
break;
|
|
|
case URI_DATA_ITEM:
|
|
|
// 获取Uri中的ID
|
|
|
id = uri.getPathSegments().get(1);
|
|
|
// 查询data表的单条数据，条件：ID=id + 传入的selection
|
|
|
c = db.query(TABLE.DATA, projection, DataColumns.ID + "=" + id
|
|
|
+ parseSelection(selection), selectionArgs, null, null, sortOrder);
|
|
|
break;
|
|
|
case URI_SEARCH:
|
|
|
case URI_SEARCH_SUGGEST:
|
|
|
// 搜索操作不允许指定sortOrder和projection，否则抛出异常
|
|
|
if (sortOrder != null || projection != null) {
|
|
|
throw new IllegalArgumentException(
|
|
|
"do not specify sortOrder, selection, selectionArgs, or projection" + "with this query");
|
|
|
}
|
|
|
|
|
|
// 获取搜索关键词：搜索建议从路径获取，普通搜索从查询参数获取
|
|
|
String searchString = null;
|
|
|
if (mMatcher.match(uri) == URI_SEARCH_SUGGEST) {
|
|
|
// 搜索建议：路径分段大于1时，第二个分段是关键词（如query/笔记）
|
|
|
if (uri.getPathSegments().size() > 1) {
|
|
|
searchString = uri.getPathSegments().get(1);
|
|
|
}
|
|
|
} else {
|
|
|
// 普通搜索：从查询参数"pattern"中获取关键词
|
|
|
searchString = uri.getQueryParameter("pattern");
|
|
|
}
|
|
|
|
|
|
// 如果是搜索建议类型，且搜索关键词不为空，返回合并结果
|
|
|
if (mMatcher.match(uri) == URI_SEARCH_SUGGEST && !TextUtils.isEmpty(searchString)) {
|
|
|
try {
|
|
|
// 1. 获取搜索历史记录
|
|
|
SearchHistoryManager historyManager = SearchHistoryManager.getInstance(getContext());
|
|
|
java.util.List<String> historyList = historyManager.getSearchHistoryList();
|
|
|
|
|
|
// 2. 获取便签搜索结果
|
|
|
String likeSearchString = String.format("%%%s%%", searchString);
|
|
|
Cursor noteCursor = db.rawQuery(NOTES_SNIPPET_SEARCH_QUERY, new String[] { likeSearchString });
|
|
|
|
|
|
// 3. 创建矩阵游标，用于合并结果
|
|
|
String[] columns = { NoteColumns.ID, SearchManager.SUGGEST_COLUMN_INTENT_EXTRA_DATA,
|
|
|
SearchManager.SUGGEST_COLUMN_TEXT_1, SearchManager.SUGGEST_COLUMN_TEXT_2,
|
|
|
SearchManager.SUGGEST_COLUMN_ICON_1, SearchManager.SUGGEST_COLUMN_INTENT_ACTION,
|
|
|
SearchManager.SUGGEST_COLUMN_INTENT_DATA };
|
|
|
android.database.MatrixCursor matrixCursor = new android.database.MatrixCursor(columns);
|
|
|
|
|
|
// 4. 添加搜索历史记录（只添加匹配的历史）
|
|
|
for (String history : historyList) {
|
|
|
if (history.toLowerCase().contains(searchString.toLowerCase())) {
|
|
|
matrixCursor.addRow(new Object[] {
|
|
|
-1, // ID为-1表示是历史记录
|
|
|
history, // 历史记录作为Intent Extra数据
|
|
|
history, // 显示的文本1
|
|
|
getContext().getString(R.string.search_history), // 显示的文本2
|
|
|
R.drawable.search_result, // 图标
|
|
|
Intent.ACTION_SEARCH, // Intent动作
|
|
|
Notes.TextNote.CONTENT_TYPE // Intent数据类型
|
|
|
});
|
|
|
}
|
|
|
}
|
|
|
|
|
|
// 5. 添加便签搜索结果
|
|
|
if (noteCursor != null && noteCursor.moveToFirst()) {
|
|
|
do {
|
|
|
// 从便签搜索结果中获取列数据
|
|
|
long noteId = noteCursor.getLong(noteCursor.getColumnIndexOrThrow(NoteColumns.ID));
|
|
|
String extraData = noteCursor.getString(noteCursor.getColumnIndexOrThrow(SearchManager.SUGGEST_COLUMN_INTENT_EXTRA_DATA));
|
|
|
String text1 = noteCursor.getString(noteCursor.getColumnIndexOrThrow(SearchManager.SUGGEST_COLUMN_TEXT_1));
|
|
|
String text2 = noteCursor.getString(noteCursor.getColumnIndexOrThrow(SearchManager.SUGGEST_COLUMN_TEXT_2));
|
|
|
int icon = noteCursor.getInt(noteCursor.getColumnIndexOrThrow(SearchManager.SUGGEST_COLUMN_ICON_1));
|
|
|
String action = noteCursor.getString(noteCursor.getColumnIndexOrThrow(SearchManager.SUGGEST_COLUMN_INTENT_ACTION));
|
|
|
String data = noteCursor.getString(noteCursor.getColumnIndexOrThrow(SearchManager.SUGGEST_COLUMN_INTENT_DATA));
|
|
|
|
|
|
matrixCursor.addRow(new Object[] { noteId, extraData, text1, text2, icon, action, data });
|
|
|
} while (noteCursor.moveToNext());
|
|
|
}
|
|
|
|
|
|
// 6. 关闭便签搜索结果游标
|
|
|
if (noteCursor != null) {
|
|
|
noteCursor.close();
|
|
|
}
|
|
|
|
|
|
// 7. 设置矩阵游标为结果
|
|
|
c = matrixCursor;
|
|
|
} catch (IllegalStateException ex) {
|
|
|
// 捕获异常，输出错误日志
|
|
|
Log.e(TAG, "got exception: " + ex.toString());
|
|
|
}
|
|
|
} else if (!TextUtils.isEmpty(searchString)) {
|
|
|
// 普通搜索或搜索建议但关键词为空，只返回便签搜索结果
|
|
|
try {
|
|
|
// 拼接SQL的LIKE关键词（%表示任意字符，如%笔记%）
|
|
|
searchString = String.format("%%%s%%", searchString);
|
|
|
// 执行原生SQL查询，获取搜索结果
|
|
|
c = db.rawQuery(NOTES_SNIPPET_SEARCH_QUERY,
|
|
|
new String[] { searchString });
|
|
|
} catch (IllegalStateException ex) {
|
|
|
// 捕获异常，输出错误日志
|
|
|
Log.e(TAG, "got exception: " + ex.toString());
|
|
|
}
|
|
|
}
|
|
|
break;
|
|
|
|
|
|
default:
|
|
|
// 未知Uri，抛出异常
|
|
|
throw new IllegalArgumentException("Unknown URI " + uri);
|
|
|
}
|
|
|
|
|
|
// 为Cursor设置通知Uri，当数据变更时，Cursor会收到通知并更新
|
|
|
if (c != null) {
|
|
|
c.setNotificationUri(getContext().getContentResolver(), uri);
|
|
|
}
|
|
|
return c;
|
|
|
}
|
|
|
|
|
|
/**
|
|
|
* 处理数据插入请求，向note表或data表插入数据
|
|
|
*
|
|
|
* @param uri 要插入的Uri
|
|
|
* @param values 要插入的数据（ContentValues键值对）
|
|
|
* @return 插入数据后的新Uri（包含插入的ID，如content://micode_notes/note/1）
|
|
|
*/
|
|
|
@Override
|
|
|
public Uri insert(Uri uri, ContentValues values) {
|
|
|
// 获取可写的SQLiteDatabase对象（插入操作需要写权限）
|
|
|
SQLiteDatabase db = mHelper.getWritableDatabase();
|
|
|
long dataId = 0, noteId = 0, insertedId = 0; // 存储插入的ID
|
|
|
|
|
|
// 根据Uri匹配的类型执行插入逻辑
|
|
|
switch (mMatcher.match(uri)) {
|
|
|
case URI_NOTE:
|
|
|
// 插入note表，获取插入的ID
|
|
|
insertedId = noteId = db.insert(TABLE.NOTE, null, values);
|
|
|
break;
|
|
|
case URI_DATA:
|
|
|
// 插入data表时，先获取关联的noteId（必须包含NOTE_ID列）
|
|
|
if (values.containsKey(DataColumns.NOTE_ID)) {
|
|
|
noteId = values.getAsLong(DataColumns.NOTE_ID);
|
|
|
} else {
|
|
|
// 无NOTE_ID时输出调试日志
|
|
|
Log.d(TAG, "Wrong data format without note id:" + values.toString());
|
|
|
}
|
|
|
// 插入data表，获取插入的ID
|
|
|
insertedId = dataId = db.insert(TABLE.DATA, null, values);
|
|
|
break;
|
|
|
|
|
|
default:
|
|
|
// 未知Uri，抛出异常
|
|
|
throw new IllegalArgumentException("Unknown URI " + uri);
|
|
|
}
|
|
|
|
|
|
// 发送通知：note表数据变更，通知对应的Uri
|
|
|
if (noteId > 0) {
|
|
|
getContext().getContentResolver().notifyChange(
|
|
|
ContentUris.withAppendedId(Notes.CONTENT_NOTE_URI, noteId), null);
|
|
|
}
|
|
|
|
|
|
// 发送通知：data表数据变更，通知对应的Uri
|
|
|
if (dataId > 0) {
|
|
|
getContext().getContentResolver().notifyChange(
|
|
|
ContentUris.withAppendedId(Notes.CONTENT_DATA_URI, dataId), null);
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
// 返回包含插入ID的新Uri
|
|
|
return ContentUris.withAppendedId(uri, insertedId);
|
|
|
}
|
|
|
|
|
|
/**
|
|
|
* 处理数据删除请求，从note表或data表删除数据
|
|
|
*
|
|
|
* @param uri 要删除的Uri
|
|
|
* @param selection 删除条件（WHERE子句）
|
|
|
* @param selectionArgs 删除条件的参数
|
|
|
* @return 删除的行数
|
|
|
*/
|
|
|
@Override
|
|
|
public int delete(Uri uri, String selection, String[] selectionArgs) {
|
|
|
int count = 0; // 存储删除的行数
|
|
|
String id = null; // 存储Uri中的ID
|
|
|
// 获取可写的SQLiteDatabase对象
|
|
|
SQLiteDatabase db = mHelper.getWritableDatabase();
|
|
|
boolean deleteData = false; // 标记是否删除的是data表数据
|
|
|
long noteId = 0; // 用于存储便签ID，以便发送通知
|
|
|
|
|
|
// 根据Uri匹配的类型执行删除逻辑
|
|
|
switch (mMatcher.match(uri)) {
|
|
|
case URI_NOTE:
|
|
|
// 直接删除便签，条件：传入的selection + 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小于等于0的是系统文件夹，不允许删除
|
|
|
*/
|
|
|
noteId = Long.valueOf(id);
|
|
|
if (noteId <= 0) {
|
|
|
break;
|
|
|
}
|
|
|
// 直接删除便签，条件：ID=id + 传入的selection
|
|
|
count = db.delete(TABLE.NOTE, NoteColumns.ID + "=" + id + parseSelection(selection), selectionArgs);
|
|
|
break;
|
|
|
case URI_DATA:
|
|
|
// 删除data表数据
|
|
|
count = db.delete(TABLE.DATA, selection, selectionArgs);
|
|
|
deleteData = true;
|
|
|
break;
|
|
|
case URI_DATA_ITEM:
|
|
|
// 获取Uri中的ID，删除data表单条数据
|
|
|
id = uri.getPathSegments().get(1);
|
|
|
count = db.delete(TABLE.DATA,
|
|
|
DataColumns.ID + "=" + id + parseSelection(selection), selectionArgs);
|
|
|
deleteData = true;
|
|
|
break;
|
|
|
|
|
|
|
|
|
|
|
|
default:
|
|
|
throw new IllegalArgumentException("Unknown URI " + uri);
|
|
|
}
|
|
|
|
|
|
// 数据删除成功时，发送通知更新UI
|
|
|
if (count > 0) {
|
|
|
// 删除data表数据时，同时通知note表的Uri（因为data表变更会影响note表的摘要）
|
|
|
if (deleteData) {
|
|
|
getContext().getContentResolver().notifyChange(Notes.CONTENT_NOTE_URI, null);
|
|
|
}
|
|
|
// 如果是便签相关操作，通知对应的便签Uri
|
|
|
if (noteId > 0) {
|
|
|
getContext().getContentResolver().notifyChange(
|
|
|
ContentUris.withAppendedId(Notes.CONTENT_NOTE_URI, noteId), null);
|
|
|
}
|
|
|
// 通知当前Uri的数据变更
|
|
|
getContext().getContentResolver().notifyChange(uri, null);
|
|
|
}
|
|
|
return count;
|
|
|
}
|
|
|
|
|
|
/**
|
|
|
* 处理数据更新请求，更新note表或data表的数据
|
|
|
*
|
|
|
* @param uri 要更新的Uri
|
|
|
* @param values 要更新的数据（ContentValues键值对）
|
|
|
* @param selection 更新条件（WHERE子句）
|
|
|
* @param selectionArgs 更新条件的参数
|
|
|
* @return 更新的行数
|
|
|
*/
|
|
|
@Override
|
|
|
public int update(Uri uri, ContentValues values, String selection, String[] selectionArgs) {
|
|
|
int count = 0; // 存储更新的行数
|
|
|
String id = null; // 存储Uri中的ID
|
|
|
// 获取可写的SQLiteDatabase对象
|
|
|
SQLiteDatabase db = mHelper.getWritableDatabase();
|
|
|
boolean updateData = false; // 标记是否更新的是data表数据
|
|
|
long noteId = 0; // 用于存储便签ID，以便发送通知
|
|
|
|
|
|
// 根据Uri匹配的类型执行更新逻辑
|
|
|
switch (mMatcher.match(uri)) {
|
|
|
case URI_NOTE:
|
|
|
// 更新note表前，增加笔记的版本号
|
|
|
increaseNoteVersion(-1, selection, selectionArgs);
|
|
|
count = db.update(TABLE.NOTE, values, selection, selectionArgs);
|
|
|
break;
|
|
|
case URI_NOTE_ITEM:
|
|
|
// 获取Uri中的ID
|
|
|
id = uri.getPathSegments().get(1);
|
|
|
// 更新note表单条数据前，增加版本号
|
|
|
increaseNoteVersion(Long.valueOf(id), selection, selectionArgs);
|
|
|
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);
|
|
|
updateData = true;
|
|
|
break;
|
|
|
case URI_DATA_ITEM:
|
|
|
// 获取Uri中的ID，更新data表单条数据
|
|
|
id = uri.getPathSegments().get(1);
|
|
|
count = db.update(TABLE.DATA, values, DataColumns.ID + "=" + id
|
|
|
+ parseSelection(selection), selectionArgs);
|
|
|
updateData = true;
|
|
|
break;
|
|
|
|
|
|
|
|
|
|
|
|
default:
|
|
|
throw new IllegalArgumentException("Unknown URI " + uri);
|
|
|
}
|
|
|
|
|
|
// 数据更新成功时，发送通知更新UI
|
|
|
if (count > 0) {
|
|
|
// 更新data表数据时，同时通知note表的Uri
|
|
|
if (updateData) {
|
|
|
getContext().getContentResolver().notifyChange(Notes.CONTENT_NOTE_URI, null);
|
|
|
}
|
|
|
// 如果是便签相关操作，通知对应的便签Uri
|
|
|
if (noteId > 0) {
|
|
|
getContext().getContentResolver().notifyChange(
|
|
|
ContentUris.withAppendedId(Notes.CONTENT_NOTE_URI, noteId), null);
|
|
|
}
|
|
|
// 通知当前Uri的数据变更
|
|
|
getContext().getContentResolver().notifyChange(uri, null);
|
|
|
}
|
|
|
return count;
|
|
|
}
|
|
|
|
|
|
/**
|
|
|
* 辅助方法：处理选择条件，拼接AND和括号
|
|
|
* 若selection不为空，返回" AND (selection)"；否则返回空字符串
|
|
|
* 用于将Uri的ID条件和传入的selection条件拼接，避免SQL语法错误
|
|
|
*
|
|
|
* @param selection 传入的选择条件
|
|
|
* @return 处理后的选择条件字符串
|
|
|
*/
|
|
|
private String parseSelection(String selection) {
|
|
|
return (!TextUtils.isEmpty(selection) ? " AND (" + selection + ')' : "");
|
|
|
}
|
|
|
|
|
|
/**
|
|
|
* 辅助方法：增加笔记的版本号（VERSION列）
|
|
|
* 执行SQL语句将VERSION列加1，用于数据同步的版本控制，标记数据已修改
|
|
|
*
|
|
|
* @param id 笔记的ID（-1表示更新多条数据）
|
|
|
* @param selection 更新条件
|
|
|
* @param selectionArgs 更新条件的参数
|
|
|
*/
|
|
|
private void increaseNoteVersion(long id, String selection, String[] selectionArgs) {
|
|
|
StringBuilder sql = new StringBuilder(120); // 构建SQL语句的字符串构建器
|
|
|
// 拼接UPDATE语句：UPDATE note SET VERSION=VERSION+1 [WHERE 条件]
|
|
|
sql.append("UPDATE ");
|
|
|
sql.append(TABLE.NOTE);
|
|
|
sql.append(" SET ");
|
|
|
sql.append(NoteColumns.VERSION);
|
|
|
sql.append("=" + NoteColumns.VERSION + "+1 ");
|
|
|
|
|
|
// 添加WHERE子句（ID>0或selection不为空时）
|
|
|
if (id > 0 || !TextUtils.isEmpty(selection)) {
|
|
|
sql.append(" WHERE ");
|
|
|
}
|
|
|
// 添加ID条件（id>0时）
|
|
|
if (id > 0) {
|
|
|
sql.append(NoteColumns.ID + "=" + String.valueOf(id));
|
|
|
}
|
|
|
// 添加传入的selection条件（替换占位符?为实际参数）
|
|
|
if (!TextUtils.isEmpty(selection)) {
|
|
|
// 处理selection：已有ID时拼接，否则直接使用
|
|
|
String selectString = id > 0 ? parseSelection(selection) : selection;
|
|
|
// 替换selection中的?为selectionArgs的参数（简单替换，适用于基础场景）
|
|
|
for (String args : selectionArgs) {
|
|
|
selectString = selectString.replaceFirst("\\?", args);
|
|
|
}
|
|
|
sql.append(selectString);
|
|
|
}
|
|
|
|
|
|
// 执行SQL语句
|
|
|
mHelper.getWritableDatabase().execSQL(sql.toString());
|
|
|
}
|
|
|
|
|
|
/**
|
|
|
* 获取Uri对应的MIME类型，适配ContentProvider的规范
|
|
|
* 本类暂未实现该方法，返回null
|
|
|
*
|
|
|
* @param uri 要查询的Uri
|
|
|
* @return Uri对应的MIME类型
|
|
|
*/
|
|
|
@Override
|
|
|
public String getType(Uri uri) {
|
|
|
// TODO Auto-generated method stub
|
|
|
return null;
|
|
|
}
|
|
|
|
|
|
} |
