|
|
/*
|
|
|
* 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.gtask.data;//包名：net.micode.notes.gtask.data；”。
|
|
|
|
|
|
import android.content.ContentResolver;//“导入安卓内容解析器类；”
|
|
|
import android.content.ContentUris;//“导入安卓内容 URI 工具类；”
|
|
|
import android.content.ContentValues;//导入安卓内容值类；”
|
|
|
import android.content.Context;//导入安卓上下文类；”。
|
|
|
import android.database.Cursor;//导入安卓数据库游标类；”。
|
|
|
import android.net.Uri;//导入安卓统一资源标识符类；”。
|
|
|
import android.util.Log;//“导入安卓日志工具类；”。
|
|
|
|
|
|
import net.micode.notes.data.Notes;//“导入 net.micode.notes.data 包下的 Notes 类；”。
|
|
|
import net.micode.notes.data.Notes.DataColumns;//“导入 net.micode.notes.data.Notes 类中的 DataColumns 内部类；”。
|
|
|
import net.micode.notes.data.Notes.DataConstants;//导入 net.micode.notes.data.Notes 类中的 DataConstants 内部类；”。
|
|
|
import net.micode.notes.data.Notes.NoteColumns;//导入 net.micode.notes.data.Notes 类中的 NoteColumns 内部类；”。
|
|
|
import net.micode.notes.data.NotesDatabaseHelper.TABLE;//导入 net.micode.notes.data.NotesDatabaseHelper 类中的 TABLE 内部类；”。
|
|
|
import net.micode.notes.gtask.exception.ActionFailureException;//导入 net.micode.notes.gtask.exception 包下的 ActionFailureException 类；”
|
|
|
|
|
|
import org.json.JSONException;//导入 JSON 异常类；”。
|
|
|
import org.json.JSONObject;//导入 JSON 异常类；”。
|
|
|
|
|
|
|
|
|
public class SqlData {//“公共类 SqlData。”
|
|
|
private static final String TAG = SqlData.class.getSimpleName();//“私有静态最终字符串变量 TAG 被赋值为 SqlData 类的简单名称。”
|
|
|
|
|
|
private static final int INVALID_ID = -99999;//“私有静态最终整数变量 INVALID_ID 被赋值为 -99999。”
|
|
|
|
|
|
public static final String[] PROJECTION_DATA = new String[] {
|
|
|
DataColumns.ID, DataColumns.MIME_TYPE, DataColumns.CONTENT, DataColumns.DATA1,
|
|
|
DataColumns.DATA3
|
|
|
};//“公共静态最终字符串数组变量 PROJECTION_DATA 被赋值为包含 DataColumns 类中的 ID、MIME_TYPE、CONTENT、DATA1 和 DATA3 的字符串数组。”
|
|
|
|
|
|
public static final int DATA_ID_COLUMN = 0;//“公共静态最终字符串数组变量 PROJECTION_DATA 被赋值为包含 DataColumns 类中的 ID、MIME_TYPE、CONTENT、DATA1 和 DATA3 的字符串数组。”
|
|
|
|
|
|
public static final int DATA_MIME_TYPE_COLUMN = 1;//“公共静态最终整数变量 DATA_MIME_TYPE_COLUMN 被赋值为 1。”
|
|
|
|
|
|
public static final int DATA_CONTENT_COLUMN = 2;//“公共静态最终整数变量 DATA_CONTENT_COLUMN 被赋值为 2。”
|
|
|
|
|
|
public static final int DATA_CONTENT_DATA_1_COLUMN = 3;//“公共静态最终整数变量 DATA_CONTENT_DATA_1_COLUMN 被赋值为 3。”
|
|
|
|
|
|
public static final int DATA_CONTENT_DATA_3_COLUMN = 4;//公共静态最终整数变量 DATA_CONTENT_DATA_3_COLUMN 被赋值为 4。”
|
|
|
|
|
|
private ContentResolver mContentResolver;//“私有 ContentResolver 类型变量 mContentResolver。”
|
|
|
|
|
|
private boolean mIsCreate;//私有布尔类型变量 mIsCreate。”
|
|
|
|
|
|
private long mDataId;//“私有长整型变量 mDataId。”
|
|
|
|
|
|
private String mDataMimeType;//私有字符串类型变量 mDataMimeType。”
|
|
|
|
|
|
private String mDataContent;//“私有字符串类型变量 mDataContent。”
|
|
|
|
|
|
private long mDataContentData1;//“私有长整型变量 mDataContentData1。”
|
|
|
|
|
|
private String mDataContentData3;//“私有字符串类型变量 mDataContentData3。”
|
|
|
|
|
|
private ContentValues mDiffDataValues;//“私有 ContentValues 类型变量 mDiffDataValues。”
|
|
|
|
|
|
public SqlData(Context context) {//“公共的 SqlData 构造方法，接收一个 Context 参数。”
|
|
|
mContentResolver = context.getContentResolver();//“将成员变量 mContentResolver 赋值为传入的 context 的内容解析器。”
|
|
|
mIsCreate = true;//“将成员变量 mIsCreate 赋值为 true。”
|
|
|
mDataId = INVALID_ID;//“将成员变量 mIsCreate 赋值为 true。”
|
|
|
mDataMimeType = DataConstants.NOTE;//“将成员变量 mIsCreate 赋值为 true。”
|
|
|
mDataContent = "";//“将成员变量 mDataContent 赋值为空字符串。
|
|
|
mDataContentData1 = 0;//“将成员变量 mDataContentData1 赋值为 0。”
|
|
|
mDataContentData3 = "";//将成员变量 mDataContentData3 赋值为空字符串。”
|
|
|
mDiffDataValues = new ContentValues();//将成员变量 mDataContentData3 赋值为空字符串。”
|
|
|
}
|
|
|
|
|
|
public SqlData(Context context, Cursor c) {//将成员变量 mDataContentData3 赋值为空字符串。”
|
|
|
mContentResolver = context.getContentResolver();//将成员变量 mDataContentData3 赋值为空字符串。”
|
|
|
mIsCreate = false;//将成员变量 mIsCreate 赋值为 false。”
|
|
|
loadFromCursor(c);//调用 loadFromCursor 方法，传入 Cursor 参数 c。”
|
|
|
mDiffDataValues = new ContentValues();//“将成员变量 mDiffDataValues 赋值为一个新的 ContentValues 对象。”
|
|
|
}
|
|
|
|
|
|
private void loadFromCursor(Cursor c) {//“私有方法 loadFromCursor，接收一个 Cursor 参数。”
|
|
|
mDataId = c.getLong(DATA_ID_COLUMN);//“将成员变量 mDataId 赋值为 Cursor 中对应 DATA_ID_COLUMN 列的长整型值。”
|
|
|
mDataMimeType = c.getString(DATA_MIME_TYPE_COLUMN);//将成员变量 mDataMimeType 赋值为 Cursor 中对应 DATA_MIME_TYPE_COLUMN 列的字符串值。”
|
|
|
mDataContent = c.getString(DATA_CONTENT_COLUMN);//“将成员变量 mDataContent 赋值为 Cursor 中对应 DATA_CONTENT_COLUMN 列的字符串值。”
|
|
|
mDataContentData1 = c.getLong(DATA_CONTENT_DATA_1_COLUMN);//将成员变量 mDataContentData1 赋值为 Cursor 中对应 DATA_CONTENT_DATA_1_COLUMN 列的长整型值。”
|
|
|
|
|
|
mDataContentData3 = c.getString(DATA_CONTENT_DATA_3_COLUMN);//“将成员变量 mDataContentData3 赋值为 Cursor 中对应 DATA_CONTENT_DATA_3_COLUMN 列的字符串值。”
|
|
|
}
|
|
|
|
|
|
public void setContent(JSONObject js) throws JSONException {//“公共方法 setContent，接收一个 JSON 对象参数 js，可能抛出 JSON 异常。”
|
|
|
long dataId = js.has(DataColumns.ID) ? js.getLong(DataColumns.ID) : INVALID_ID;//“如果 JSON 对象 js 包含键为 DataColumns.ID 的值，则将 dataId 赋值为该值的长整型，否则赋值为无效 ID（INVALID_ID）。”
|
|
|
if (mIsCreate || mDataId != dataId) {//“如果 JSON 对象 js 包含键为 DataColumns.ID 的值，则将 dataId 赋值为该值的长整型，否则赋值为无效 ID（INVALID_ID）。”
|
|
|
mDiffDataValues.put(DataColumns.ID, dataId);//将 dataId 放入成员变量 mDiffDataValues 的键为 DataColumns.ID 的位置。”
|
|
|
}
|
|
|
mDataId = dataId;//“将成员变量 mDataId 赋值为 dataId。”
|
|
|
|
|
|
String dataMimeType = js.has(DataColumns.MIME_TYPE) ? js.getString(DataColumns.MIME_TYPE)
|
|
|
: DataConstants.NOTE;//“如果 JSON 对象 js 包含键为 DataColumns.MIME_TYPE 的值，则将 dataMimeType 赋值为该值的字符串，否则赋值为常量 NOTE。”
|
|
|
if (mIsCreate || !mDataMimeType.equals(dataMimeType)) {//如果是创建状态或者成员变量 mDataMimeType 不等于 dataMimeType。”
|
|
|
mDiffDataValues.put(DataColumns.MIME_TYPE, dataMimeType);//将 dataMimeType 放入成员变量 mDiffDataValues 的键为 DataColumns.MIME_TYPE 的位置。”
|
|
|
}
|
|
|
mDataMimeType = dataMimeType;//“将成员变量 mDataMimeType 赋值为 dataMimeType。”
|
|
|
|
|
|
String dataContent = js.has(DataColumns.CONTENT) ? js.getString(DataColumns.CONTENT) : "";//如果 JSON 对象 js 包含键为 DataColumns.CONTENT 的值，则将 dataContent 赋值为该值的字符串，否则赋值为空字符串。”
|
|
|
if (mIsCreate || !mDataContent.equals(dataContent)) {//“如果是创建状态或者成员变量 mDataContent 不等于 dataContent。”
|
|
|
mDiffDataValues.put(DataColumns.CONTENT, dataContent);//“将 dataContent 放入成员变量 mDiffDataValues 的键为 DataColumns.CONTENT 的位置。”
|
|
|
}
|
|
|
mDataContent = dataContent;//“将成员变量 mDataContent 赋值为 dataContent。”
|
|
|
|
|
|
long dataContentData1 = js.has(DataColumns.DATA1) ? js.getLong(DataColumns.DATA1) : 0;//“如果 JSON 对象 js 包含键为 DataColumns.DATA1 的值，则将 dataContentData1 赋值为该值的长整型，否则赋值为 0。”
|
|
|
if (mIsCreate || mDataContentData1 != dataContentData1) {//“如果是创建状态或者成员变量 mDataContentData1 不等于 dataContentData1。”
|
|
|
mDiffDataValues.put(DataColumns.DATA1, dataContentData1);//将 dataContentData1 放入成员变量 mDiffDataValues 的键为 DataColumns.DATA1 的位置。”
|
|
|
}
|
|
|
mDataContentData1 = dataContentData1;//将成员变量 mDataContentData1 赋值为 dataContentData1。”
|
|
|
|
|
|
String dataContentData3 = js.has(DataColumns.DATA3) ? js.getString(DataColumns.DATA3) : "";//“如果 JSON 对象 js 包含键为 DataColumns.DATA3 的值，则将 dataContentData3 赋值为该值的字符串，否则赋值为空字符串。”
|
|
|
if (mIsCreate || !mDataContentData3.equals(dataContentData3)) {//如果是创建状态或者成员变量 mDataContentData3 不等于 dataContentData3。”
|
|
|
mDiffDataValues.put(DataColumns.DATA3, dataContentData3);//将 dataContentData3 放入成员变量 mDiffDataValues 的键为 DataColumns.DATA3 的位置。”
|
|
|
}
|
|
|
mDataContentData3 = dataContentData3;//“将成员变量 mDataContentData3 赋值为 dataContentData3。”
|
|
|
}
|
|
|
|
|
|
public JSONObject getContent() throws JSONException {//“公共方法 getContent，返回一个 JSON 对象，可能抛出 JSON 异常。”
|
|
|
if (mIsCreate) {//“如果是创建状态。”
|
|
|
Log.e(TAG, "it seems that we haven't created this in database yet");//使用错误级别记录日志，TAG 为标识，信息为‘it seems that we haven't created this in database yet’（看起来我们还没有在数据库中创建这个）。”
|
|
|
return null;//“返回 null。
|
|
|
}
|
|
|
JSONObject js = new JSONObject();//“返回 null。
|
|
|
js.put(DataColumns.ID, mDataId);//“将成员变量 mDataId 放入 JSON 对象 js 的键为 DataColumns.ID 的位置。”
|
|
|
js.put(DataColumns.MIME_TYPE, mDataMimeType);//将成员变量 mDataMimeType 放入 JSON 对象 js 的键为 DataColumns.MIME_TYPE 的位置。”
|
|
|
js.put(DataColumns.CONTENT, mDataContent);//“将成员变量 mDataContent 放入 JSON 对象 js 的键为 DataColumns.CONTENT 的位置。”
|
|
|
js.put(DataColumns.DATA1, mDataContentData1);//“将成员变量 mDataContentData1 放入 JSON 对象 js 的键为 DataColumns.DATA1 的位置。”
|
|
|
js.put(DataColumns.DATA3, mDataContentData3);//“将成员变量 mDataContentData3 放入 JSON 对象 js 的键为 DataColumns.DATA3 的位置。”
|
|
|
return js;//“返回 JSON 对象 js。”
|
|
|
}
|
|
|
|
|
|
public void commit(long noteId, boolean validateVersion, long version) {//“公共方法 commit，接收一个长整型 noteId、一个布尔型 validateVersion 和一个长整型 version。”
|
|
|
|
|
|
if (mIsCreate) {//“如果是创建状态。”
|
|
|
if (mDataId == INVALID_ID && mDiffDataValues.containsKey(DataColumns.ID)) {//“如果数据 ID 为无效值且差异数据值（mDiffDataValues）中包含键为 DataColumns.ID。”
|
|
|
mDiffDataValues.remove(DataColumns.ID);//从差异数据值中移除键为 DataColumns.ID 的数据。
|
|
|
}
|
|
|
|
|
|
mDiffDataValues.put(DataColumns.NOTE_ID, noteId);//“将 noteId 放入差异数据值的键为 DataColumns.NOTE_ID 的位置。”
|
|
|
Uri uri = mContentResolver.insert(Notes.CONTENT_DATA_URI, mDiffDataValues);//“使用内容解析器插入数据到 Notes 的 CONTENT_DATA_URI，并将返回的 Uri 赋值给 uri。”
|
|
|
try {//“尝试执行以下代码块。”
|
|
|
mDataId = Long.valueOf(uri.getPathSegments().get(1));//“将 uri 的路径片段中的第二个值转换为长整型并赋值给数据 ID（mDataId）。”
|
|
|
} catch (NumberFormatException e) {//“捕获数字格式异常，如果发生异常执行以下代码块。”
|
|
|
Log.e(TAG, "Get note id error :" + e.toString());//“使用错误级别记录日志，TAG 为标识，信息为‘Get note id error :’加上异常信息。”
|
|
|
throw new ActionFailureException("create note failed");//抛出创建笔记失败的异常。”
|
|
|
}
|
|
|
} else {//“如果不是创建状态。
|
|
|
if (mDiffDataValues.size() > 0) {//如果差异数据值的大小大于 0。”
|
|
|
int result = 0;//初始化结果变量为 0。”
|
|
|
if (!validateVersion) {//“如果不验证版本。”
|
|
|
result = mContentResolver.update(ContentUris.withAppendedId(
|
|
|
Notes.CONTENT_DATA_URI, mDataId), mDiffDataValues, null, null);//使用内容解析器更新数据，将结果赋值给 result。
|
|
|
} else {//“如果验证版本。”
|
|
|
result = mContentResolver.update(ContentUris.withAppendedId(
|
|
|
Notes.CONTENT_DATA_URI, mDataId), mDiffDataValues,
|
|
|
" ? in (SELECT " + NoteColumns.ID + " FROM " + TABLE.NOTE
|
|
|
+ " WHERE " + NoteColumns.VERSION + "=?)", new String[] {
|
|
|
String.valueOf(noteId), String.valueOf(version)
|
|
|
});//“使用内容解析器更新数据，带有版本验证，将结果赋值给 result。”
|
|
|
}
|
|
|
if (result == 0) {//“使用内容解析器更新数据，带有版本验证，将结果赋值给 result。”
|
|
|
Log.w(TAG, "there is no update. maybe user updates note when syncing");//“使用警告级别记录日志，TAG 为标识，信息为‘there is no update. maybe user updates note when syncing’（没有更新。可能用户在同步时更新了笔记）。”
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
|
|
|
mDiffDataValues.clear();//“清空差异数据值。”
|
|
|
mIsCreate = false;//将创建状态设置为 false。”
|
|
|
}
|
|
|
|
|
|
public long getId() {//公共方法 getId，返回一个长整型。”
|
|
|
return mDataId;//返回数据 ID（mDataId）。”
|
|
|
}
|
|
|
}
|
