|
|
/*
|
|
|
* 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.model; // 声明当前类所在的包
|
|
|
|
|
|
import android.content.ContentProviderOperation; // 导入用于构建批量数据库操作的类
|
|
|
import android.content.ContentProviderResult; // 导入用于接收批量操作结果的类
|
|
|
import android.content.ContentUris; // 导入用于生成URI的类，这些URI指向数据库中的特定行
|
|
|
import android.content.ContentValues; // 导入用于存储一组键值对的类，这些键值对将被插入到数据库表中
|
|
|
import android.content.Context; // 导入Android应用上下文类
|
|
|
import android.content.OperationApplicationException; // 导入表示操作应用异常的类
|
|
|
import android.net.Uri; // 导入表示统一资源标识符的类
|
|
|
import android.os.RemoteException; // 导入表示远程过程调用异常的类
|
|
|
import android.util.Log; // 导入用于打印日志的类
|
|
|
|
|
|
import net.micode.notes.data.Notes; // 导入应用自定义的Notes类，可能是一个包含多个内部类的数据库模型
|
|
|
import net.micode.notes.data.Notes.CallNote; // 导入Notes类中的CallNote内部类，可能代表电话笔记
|
|
|
import net.micode.notes.data.Notes.DataColumns; // 导入Notes类中的DataColumns内部类，可能包含数据表的列定义
|
|
|
import net.micode.notes.data.Notes.NoteColumns; // 导入Notes类中的NoteColumns内部类，可能包含笔记表的列定义
|
|
|
import net.micode.notes.data.Notes.TextNote; // 导入Notes类中的TextNote内部类，可能代表文本笔记
|
|
|
*//1
|
|
|
|
|
|
|
|
|
import java.util.ArrayList; // 导入ArrayList类
|
|
|
|
|
|
public class Note { // 声明一个名为Note的公共类
|
|
|
// 类的成员变量定义（在此代码段中未展示）
|
|
|
private ContentValues mNoteDiffValues; // 用于存储笔记的差异数据，以便后续更新数据库
|
|
|
private NoteData mNoteData; // 可能用于存储笔记的详细数据
|
|
|
private static final String TAG = "Note"; // 用于日志记录的标签
|
|
|
|
|
|
/**
|
|
|
* 创建一个新的笔记ID，用于向数据库添加新笔记
|
|
|
*/
|
|
|
public static synchronized long getNewNoteId(Context context, long folderId) {
|
|
|
// 声明一个ContentValues对象，用于存储要插入数据库的新笔记的数据
|
|
|
ContentValues values = new ContentValues();
|
|
|
// 获取当前系统时间（毫秒为单位），作为笔记的创建和修改时间
|
|
|
long createdTime = System.currentTimeMillis();
|
|
|
// 向values中添加笔记的创建日期
|
|
|
values.put(NoteColumns.CREATED_DATE, createdTime);
|
|
|
// 向values中添加笔记的修改日期（初始时与创建日期相同）
|
|
|
values.put(NoteColumns.MODIFIED_DATE, createdTime);
|
|
|
// 向values中添加笔记的类型（此处假设Notes.TYPE_NOTE是一个预定义的常量，表示笔记类型）
|
|
|
values.put(NoteColumns.TYPE, Notes.TYPE_NOTE);
|
|
|
// 向values中添加一个标记，表示笔记是否在本地被修改过（初始化为1，可能表示已修改）
|
|
|
values.put(NoteColumns.LOCAL_MODIFIED, 1);
|
|
|
// 向values中添加笔记的父ID，即它所属的文件夹ID
|
|
|
values.put(NoteColumns.PARENT_ID, folderId);
|
|
|
// 使用ContentResolver向数据库的Notes.CONTENT_NOTE_URI插入新笔记的数据，并返回新插入笔记的URI
|
|
|
Uri uri = context.getContentResolver().insert(Notes.CONTENT_NOTE_URI, values);
|
|
|
|
|
|
// 初始化noteId为0，用于存储从URI解析出的新笔记ID
|
|
|
long noteId = 0;
|
|
|
try {
|
|
|
// 从返回的URI的路径段中获取第二个元素（索引为1，因为索引从0开始），并将其转换为long类型，作为新笔记的ID
|
|
|
noteId = Long.valueOf(uri.getPathSegments().get(1));
|
|
|
} catch (NumberFormatException e) {
|
|
|
// 如果转换过程中发生数字格式异常，则记录错误日志，并将noteId保持为0
|
|
|
Log.e(TAG, "Get note id error :" + e.toString());
|
|
|
noteId = 0;
|
|
|
}
|
|
|
// 检查noteId是否为-1（虽然在此处不太可能，因为Long.valueOf不会返回-1）
|
|
|
// 但为了代码的健壮性，还是进行了检查
|
|
|
if (noteId == -1) {
|
|
|
// 如果noteId为-1，则抛出IllegalStateException异常，表示获得了错误的笔记ID
|
|
|
throw new IllegalStateException("Wrong note id:" + noteId);
|
|
|
}
|
|
|
// 返回解析出的新笔记ID
|
|
|
return noteId;
|
|
|
}
|
|
|
}*//2
|
|
|
|
|
|
|
|
|
// Note类的构造方法
|
|
|
public Note() {
|
|
|
// 初始化mNoteDiffValues，用于存储笔记的差异数据，这些数据通常用于更新数据库中的笔记
|
|
|
mNoteDiffValues = new ContentValues();
|
|
|
// 初始化mNoteData，可能用于存储笔记的详细数据，如文本、语音等
|
|
|
mNoteData = new NoteData();
|
|
|
}
|
|
|
|
|
|
// 设置笔记的某个键值对数据
|
|
|
public void setNoteValue(String key, String value) {
|
|
|
// 将键值对存储到mNoteDiffValues中，准备用于更新数据库
|
|
|
mNoteDiffValues.put(key, value);
|
|
|
// 标记笔记为已本地修改
|
|
|
mNoteDiffValues.put(NoteColumns.LOCAL_MODIFIED, 1);
|
|
|
// 更新笔记的修改日期
|
|
|
mNoteDiffValues.put(NoteColumns.MODIFIED_DATE, System.currentTimeMillis());
|
|
|
}
|
|
|
|
|
|
// 设置笔记的文本数据
|
|
|
public void setTextData(String key, String value) {
|
|
|
// 调用mNoteData的setTextData方法，将文本数据存储到mNoteData中
|
|
|
mNoteData.setTextData(key, value);
|
|
|
}
|
|
|
|
|
|
// 设置文本数据的ID
|
|
|
public void setTextDataId(long id) {
|
|
|
// 调用mNoteData的setTextDataId方法，设置文本数据的ID
|
|
|
mNoteData.setTextDataId(id);
|
|
|
}
|
|
|
|
|
|
// 获取文本数据的ID
|
|
|
public long getTextDataId() {
|
|
|
// 返回mNoteData中存储的文本数据ID
|
|
|
return mNoteData.mTextDataId;
|
|
|
}
|
|
|
|
|
|
// 设置通话数据的ID
|
|
|
public void setCallDataId(long id) {
|
|
|
// 调用mNoteData的setCallDataId方法，设置通话数据的ID
|
|
|
mNoteData.setCallDataId(id);
|
|
|
}
|
|
|
|
|
|
// 设置通话数据的某个键值对数据
|
|
|
public void setCallData(String key, String value) {
|
|
|
// 调用mNoteData的setCallData方法，将通话数据存储到mNoteData中
|
|
|
mNoteData.setCallData(key, value);
|
|
|
}
|
|
|
|
|
|
// 检查笔记是否已本地修改
|
|
|
public boolean isLocalModified() {
|
|
|
// 如果mNoteDiffValues中有数据，或者mNoteData标记为已修改，则返回true
|
|
|
return mNoteDiffValues.size() > 0 || mNoteData.isLocalModified();
|
|
|
}
|
|
|
|
|
|
// 同步笔记到服务器或数据库
|
|
|
public boolean syncNote(Context context, long noteId) {
|
|
|
// 检查传入的noteId是否有效，如果小于等于0，则抛出异常
|
|
|
if (noteId <= 0) {
|
|
|
throw new IllegalArgumentException("Wrong note id:" + noteId);
|
|
|
}
|
|
|
|
|
|
// 如果笔记没有本地修改，则不需要同步，直接返回true
|
|
|
if (!isLocalModified()) {
|
|
|
return true;
|
|
|
}
|
|
|
*//3
|
|
|
|
|
|
|
|
|
/**
|
|
|
* In theory, once data changed, the note should be updated on {@link NoteColumns#LOCAL_MODIFIED} and
|
|
|
* {@link NoteColumns#MODIFIED_DATE}. For data safety, though update note fails, we also update the
|
|
|
* note data info
|
|
|
*/
|
|
|
if (context.getContentResolver().update(
|
|
|
ContentUris.withAppendedId(Notes.CONTENT_NOTE_URI, noteId), mNoteDiffValues, null,
|
|
|
null) == 0) {
|
|
|
// 如果更新返回0，表示没有更新任何行，这通常不应该发生
|
|
|
Log.e(TAG, "Update note error, should not happen");
|
|
|
// 不要返回，继续执行后续代码
|
|
|
}
|
|
|
// 清除mNoteDiffValues中的数据，因为已经尝试更新到数据库
|
|
|
mNoteDiffValues.clear();
|
|
|
|
|
|
// 检查mNoteData是否标记为已修改，并尝试将其推送到ContentResolver
|
|
|
if (mNoteData.isLocalModified()
|
|
|
&& (mNoteData.pushIntoContentResolver(context, noteId) == null)) {
|
|
|
// 如果mNoteData标记为已修改但推送失败，则返回false
|
|
|
return false;
|
|
|
}
|
|
|
|
|
|
// 如果所有操作都成功，则返回true
|
|
|
return true;
|
|
|
}
|
|
|
|
|
|
// NoteData内部类定义开始
|
|
|
private class NoteData {
|
|
|
// 存储文本数据的ID
|
|
|
private long mTextDataId;
|
|
|
// 存储文本数据的ContentValues
|
|
|
private ContentValues mTextDataValues;
|
|
|
// 存储通话数据的ID
|
|
|
private long mCallDataId;
|
|
|
// 存储通话数据的ContentValues
|
|
|
private ContentValues mCallDataValues;
|
|
|
// 用于日志记录的TAG
|
|
|
private static final String TAG = "NoteData";
|
|
|
|
|
|
// NoteData的构造方法
|
|
|
public NoteData() {
|
|
|
// 初始化ContentValues对象
|
|
|
mTextDataValues = new ContentValues();
|
|
|
mCallDataValues = new ContentValues();
|
|
|
// 初始化数据ID为0，表示还没有关联的数据
|
|
|
mTextDataId = 0;
|
|
|
mCallDataId = 0;
|
|
|
}
|
|
|
|
|
|
// 检查NoteData是否已修改
|
|
|
boolean isLocalModified() {
|
|
|
// 如果mTextDataValues或mCallDataValues中有数据，则返回true
|
|
|
return mTextDataValues.size() > 0 || mCallDataValues.size() > 0;
|
|
|
}
|
|
|
|
|
|
// 设置文本数据的ID
|
|
|
void setTextDataId(long id) {
|
|
|
// 检查ID是否有效
|
|
|
if(id <= 0) {
|
|
|
throw new IllegalArgumentException("Text data id should larger than 0");
|
|
|
}
|
|
|
mTextDataId = id;
|
|
|
}
|
|
|
|
|
|
// 设置通话数据的ID
|
|
|
void setCallDataId(long id) {
|
|
|
// 检查ID是否有效
|
|
|
if (id <= 0) {
|
|
|
throw new IllegalArgumentException("Call data id should larger than 0");
|
|
|
}
|
|
|
mCallDataId = id;
|
|
|
}
|
|
|
|
|
|
// 设置通话数据
|
|
|
void setCallData(String key, String value) {
|
|
|
// 将键值对存储到mCallDataValues中
|
|
|
mCallDataValues.put(key, value);
|
|
|
// 标记笔记为已本地修改，并更新修改日期
|
|
|
mNoteDiffValues.put(NoteColumns.LOCAL_MODIFIED, 1);
|
|
|
mNoteDiffValues.put(NoteColumns.MODIFIED_DATE, System.currentTimeMillis());
|
|
|
}
|
|
|
|
|
|
// 设置文本数据
|
|
|
void setTextData(String key, String value) {
|
|
|
// 将键值对存储到mTextDataValues中
|
|
|
mTextDataValues.put(key, value);
|
|
|
// 标记笔记为已本地修改，并更新修改日期
|
|
|
mNoteDiffValues.put(NoteColumns.LOCAL_MODIFIED, 1);
|
|
|
mNoteDiffValues.put(NoteColumns.MODIFIED_DATE, System.currentTimeMillis());
|
|
|
}
|
|
|
|
|
|
// 将NoteData推送到ContentResolver
|
|
|
Uri pushIntoContentResolver(Context context, long noteId) {
|
|
|
// 检查noteId是否有效
|
|
|
if (noteId <= 0) {
|
|
|
throw new IllegalArgumentException("Wrong note id:" + noteId);
|
|
|
}
|
|
|
|
|
|
// 创建用于批量操作的内容提供者操作列表
|
|
|
ArrayList<ContentProviderOperation> operationList = new ArrayList<>();
|
|
|
ContentProviderOperation.Builder builder = null;
|
|
|
|
|
|
// 如果mTextDataValues中有数据
|
|
|
if(mTextDataValues.size() > 0) {
|
|
|
// 添加noteId到mTextDataValues中
|
|
|
mTextDataValues.put(DataColumns.NOTE_ID, noteId);
|
|
|
// 如果mTextDataId为0，表示是新的文本数据
|
|
|
if (mTextDataId == 0) {
|
|
|
// 插入新的文本数据到ContentResolver
|
|
|
Uri uri = context.getContentResolver().insert(Notes.CONTENT_DATA_URI,
|
|
|
mTextDataValues);
|
|
|
try {
|
|
|
// 从返回的Uri中提取新的文本数据ID
|
|
|
setTextDataId(Long.valueOf(uri.getPathSegments().get(1)));
|
|
|
} catch (NumberFormatException e) {
|
|
|
// 如果提取ID失败，则记录错误并清除mTextDataValues
|
|
|
Log.e(TAG, "Insert new text data fail with noteId" + noteId);
|
|
|
mTextDataValues.clear();
|
|
|
return null;
|
|
|
}
|
|
|
} else {
|
|
|
// 如果mTextDataId不为0，表示是更新现有的文本数据
|
|
|
builder = ContentProviderOperation.newUpdate(ContentUris.withAppendedId(
|
|
|
Notes.CONTENT_DATA_URI, mTextDataId));
|
|
|
builder.withValues(mTextDataValues);
|
|
|
operationList.add(builder.build());
|
|
|
}
|
|
|
// 清除mTextDataValues中的数据，因为已经尝试更新或插入到数据库
|
|
|
mTextDataValues.clear();
|
|
|
}
|
|
|
|
|
|
// 如果mCallDataValues中有数据，处理逻辑与mTextDataValues相同
|
|
|
if(mCallDataValues.size() > 0) {
|
|
|
mCallDataValues.put(DataColumns.NOTE_ID, noteId);
|
|
|
if (mCallDataId == 0) {
|
|
|
mCallDataValues.put(DataColumns.MIME_TYPE, CallNote.CONTENT_ITEM_TYPE);
|
|
|
Uri uri = context.getContentResolver().insert(Notes.CONTENT_DATA_URI,
|
|
|
mCallDataValues);
|
|
|
try {
|
|
|
setCallDataId(Long.valueOf(uri.getPathSegments().get(1)));
|
|
|
} catch (NumberFormatException e) {
|
|
|
Log.e(TAG, "Insert new call data fail with noteId" + noteId);
|
|
|
mCallDataValues.clear();
|
|
|
return null;
|
|
|
}
|
|
|
} else {
|
|
|
builder = ContentProviderOperation.newUpdate(ContentUris.withAppendedId(
|
|
|
Notes.CONTENT_DATA_URI, mCallDataId));
|
|
|
builder.withValues(mCallDataValues);
|
|
|
operationList.add(builder.build());
|
|
|
}
|
|
|
mCallDataValues.clear();
|
|
|
}
|
|
|
|
|
|
// 如果操作列表不为空，则执行批量操作
|
|
|
if (operationList.size() > 0) {
|
|
|
try {
|
|
|
// 执行批量操作，并返回结果
|
|
|
ContentProviderResult[] results = context.getContentResolver().applyBatch(
|
|
|
Notes.AUTHORITY, operationList);
|
|
|
// 检查结果是否有效，并返回相应的Uri或null
|
|
|
return (results == null || results.length == 0 || results[0] == null) ? null
|
|
|
: ContentUris.withAppendedId(Notes.CONTENT_NOTE_URI, noteId);
|
|
|
} catch (RemoteException e) {
|
|
|
// 记录远程异常
|
|
|
Log.e(TAG, String.format("%s: %s", e.toString(), e.getMessage()));
|
|
|
return null;
|
|
|
} catch (OperationApplicationException e) {
|
|
|
// 记录操作应用异常
|
|
|
Log.e(TAG, String.format("%s: %s", e.toString(), e.getMessage()));
|
|
|
return null;
|
|
|
}
|
|
|
}
|
|
|
// 如果没有任何操作要执行，则返回null
|
|
|
return null;
|
|
|
}
|
|
|
}
|
|
|
// Note类定义结束
|
|
|
}
|
