/* * 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; import android.appwidget.AppWidgetManager; import android.content.ContentResolver; 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; import net.micode.notes.data.Notes.DataColumns; import net.micode.notes.data.Notes.NoteColumns; import net.micode.notes.gtask.exception.ActionFailureException; import net.micode.notes.tool.GTaskStringUtils; import net.micode.notes.tool.ResourceParser; import org.json.JSONArray; import org.json.JSONException; import org.json.JSONObject; import java.util.ArrayList; //定义一个类，类名为SqlNote，作用：处理便签数据 public class SqlNote { //定义一个字符串，表示类名 private static final String TAG = SqlNote.class.getSimpleName(); //定义一个整型变量，表示无效ID private static final int INVALID_ID = -99999; //定义一个字符串数组，表示便签的列名 public static final String[] PROJECTION_NOTE = new String[] { NoteColumns.ID, NoteColumns.ALERTED_DATE, NoteColumns.BG_COLOR_ID, NoteColumns.CREATED_DATE, NoteColumns.HAS_ATTACHMENT, NoteColumns.MODIFIED_DATE, NoteColumns.NOTES_COUNT, NoteColumns.PARENT_ID, NoteColumns.SNIPPET, NoteColumns.TYPE, NoteColumns.WIDGET_ID, NoteColumns.WIDGET_TYPE, NoteColumns.SYNC_ID, NoteColumns.LOCAL_MODIFIED, NoteColumns.ORIGIN_PARENT_ID, NoteColumns.GTASK_ID, NoteColumns.VERSION }; //定义一个整型变量，表示ID列 public static final int ID_COLUMN = 0; //定义一个整型变量，表示提醒日期列 public static final int ALERTED_DATE_COLUMN = 1; // 定义一个整型变量，表示背景颜色ID列 public static final int BG_COLOR_ID_COLUMN = 2; //定义一个整型变量，表示创建日期列 public static final int CREATED_DATE_COLUMN = 3; //定义一个整型变量，表示是否有附件列 public static final int HAS_ATTACHMENT_COLUMN = 4; //定义一个整型变量，表示修改日期列 public static final int MODIFIED_DATE_COLUMN = 5; //定义一个整型变量，表示便签数量列 public static final int NOTES_COUNT_COLUMN = 6; //定义一个整型变量，表示父ID列 public static final int PARENT_ID_COLUMN = 7; //定义一个整型变量，表示摘要列 public static final int SNIPPET_COLUMN = 8; //定义一个整型变量，表示类型列 public static final int TYPE_COLUMN = 9; //定义一个整型变量，表示小部件ID列 public static final int WIDGET_ID_COLUMN = 10; //定义一个整型变量，表示小部件类型列 public static final int WIDGET_TYPE_COLUMN = 11; //定义一个整型变量，表示同步ID列 public static final int SYNC_ID_COLUMN = 12; //定义一个整型变量，表示本地修改列 public static final int LOCAL_MODIFIED_COLUMN = 13; //定义一个整型变量，表示原始父ID列 public static final int ORIGIN_PARENT_ID_COLUMN = 14; //定义一个整型变量，表示GTask ID列 public static final int GTASK_ID_COLUMN = 15; //定义一个整型变量，表示版本列 public static final int VERSION_COLUMN = 16; //定义一个上下文对象 private Context mContext; //定义一个内容解析器对象 private ContentResolver mContentResolver; //定义一个布尔型变量，表示是否创建 private boolean mIsCreate; private long mId; private long mAlertDate; private int mBgColorId; private long mCreatedDate; private int mHasAttachment; private long mModifiedDate; private long mParentId; private String mSnippet; private int mType; private int mWidgetId; private int mWidgetType; private long mOriginParent; private long mVersion; private ContentValues mDiffNoteValues; private ArrayList mDataList; //定义一个构造函数，参数为上下文对象 作用：初始化便签数据 public SqlNote(Context context) { mContext = context; mContentResolver = context.getContentResolver(); mIsCreate = true; mId = INVALID_ID; mAlertDate = 0; mBgColorId = ResourceParser.getDefaultBgId(context); mCreatedDate = System.currentTimeMillis(); mHasAttachment = 0; mModifiedDate = System.currentTimeMillis(); mParentId = 0; mSnippet = ""; mType = Notes.TYPE_NOTE; mWidgetId = AppWidgetManager.INVALID_APPWIDGET_ID; mWidgetType = Notes.TYPE_WIDGET_INVALIDE; mOriginParent = 0; mVersion = 0; mDiffNoteValues = new ContentValues(); mDataList = new ArrayList(); } //定义一个构造函数，参数为上下文对象和游标对象 作用：初始化便签数据 public SqlNote(Context context, Cursor c) { mContext = context; mContentResolver = context.getContentResolver(); mIsCreate = false; loadFromCursor(c); mDataList = new ArrayList(); if (mType == Notes.TYPE_NOTE) loadDataContent(); mDiffNoteValues = new ContentValues(); } //定义一个构造函数，参数为上下文对象和ID 作用：初始化便签数据 public SqlNote(Context context, long id) { mContext = context; mContentResolver = context.getContentResolver(); mIsCreate = false; loadFromCursor(id); mDataList = new ArrayList(); if (mType == Notes.TYPE_NOTE) loadDataContent(); mDiffNoteValues = new ContentValues(); } //定义一个方法，参数为JSONObject对象，返回值为布尔型 作用：设置便签内容 private void loadFromCursor(long id) { Cursor c = null; try { 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) { mId = c.getLong(ID_COLUMN); mAlertDate = c.getLong(ALERTED_DATE_COLUMN); 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); mParentId = c.getLong(PARENT_ID_COLUMN); mSnippet = c.getString(SNIPPET_COLUMN); mType = c.getInt(TYPE_COLUMN); 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; }//如果游标的数量为0，则打印日志信息 while (c.moveToNext()) { SqlData data = new SqlData(mContext, c); mDataList.add(data); } } else { //如果游标为空，则打印日志信息 Log.w(TAG, "loadDataContent: cursor = null"); } } finally {//关闭游标 if (c != null) c.close(); } } //定义一个方法，参数为JSONObject对象，返回值为布尔型 作用：设置内容 public boolean setContent(JSONObject js) { try {//捕获异常 JSONObject note = js.getJSONObject(GTaskStringUtils.META_HEAD_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) { //对于文件夹，我们只能更新 snnipet 并键入 String snippet = note.has(NoteColumns.SNIPPET) ? note .getString(NoteColumns.SNIPPET) : ""; if (mIsCreate || !mSnippet.equals(snippet)) { mDiffNoteValues.put(NoteColumns.SNIPPET, snippet); } mSnippet = snippet; //对于文件夹，我们只能更新类型 int type = note.has(NoteColumns.TYPE) ? note.getInt(NoteColumns.TYPE) : Notes.TYPE_NOTE; //如果是创建或者类型不同，则将类型放入差异便签值中 if (mIsCreate || mType != type) { mDiffNoteValues.put(NoteColumns.TYPE, type); } mType = type; //对于文件夹，我们只能更新小部件类型 } else if (note.getInt(NoteColumns.TYPE) == Notes.TYPE_NOTE) { JSONArray dataArray = js.getJSONArray(GTaskStringUtils.META_HEAD_DATA); long id = note.has(NoteColumns.ID) ? note.getLong(NoteColumns.ID) : INVALID_ID; if (mIsCreate || mId != id) { mDiffNoteValues.put(NoteColumns.ID, id); } mId = id; //如果是创建或者提醒日期不同，则将提醒日期放入差异便签值中 long alertDate = note.has(NoteColumns.ALERTED_DATE) ? note .getLong(NoteColumns.ALERTED_DATE) : 0; if (mIsCreate || mAlertDate != alertDate) { mDiffNoteValues.put(NoteColumns.ALERTED_DATE, alertDate); } mAlertDate = alertDate; //如果是创建或者背景颜色ID不同，则将背景颜色ID放入差异便签值中 int bgColorId = note.has(NoteColumns.BG_COLOR_ID) ? note .getInt(NoteColumns.BG_COLOR_ID) : ResourceParser.getDefaultBgId(mContext); if (mIsCreate || mBgColorId != bgColorId) { mDiffNoteValues.put(NoteColumns.BG_COLOR_ID, bgColorId); } mBgColorId = bgColorId; //如果是创建或者创建日期不同，则将创建日期放入差异便签值中 long createDate = note.has(NoteColumns.CREATED_DATE) ? note .getLong(NoteColumns.CREATED_DATE) : System.currentTimeMillis(); if (mIsCreate || mCreatedDate != createDate) {//如果是创建或者创建日期不同，则将创建日期放入差异便签值中 mDiffNoteValues.put(NoteColumns.CREATED_DATE, createDate); } mCreatedDate = createDate; //如果是创建或者是否有附件不同，则将是否有附件放入差异便签值中 int hasAttachment = note.has(NoteColumns.HAS_ATTACHMENT) ? note .getInt(NoteColumns.HAS_ATTACHMENT) : 0; if (mIsCreate || mHasAttachment != hasAttachment) { mDiffNoteValues.put(NoteColumns.HAS_ATTACHMENT, hasAttachment); } mHasAttachment = hasAttachment; //如果是创建或者修改日期不同，则将修改日期放入差异便签值中 long modifiedDate = note.has(NoteColumns.MODIFIED_DATE) ? note .getLong(NoteColumns.MODIFIED_DATE) : System.currentTimeMillis(); if (mIsCreate || mModifiedDate != modifiedDate) { mDiffNoteValues.put(NoteColumns.MODIFIED_DATE, modifiedDate); } mModifiedDate = modifiedDate; //如果是创建或者父ID不同，则将父ID放入差异便签值中 long parentId = note.has(NoteColumns.PARENT_ID) ? note .getLong(NoteColumns.PARENT_ID) : 0; if (mIsCreate || mParentId != parentId) { mDiffNoteValues.put(NoteColumns.PARENT_ID, parentId); } mParentId = parentId; //如果是创建或者摘要不同，则将摘要放入差异便签值中 String snippet = note.has(NoteColumns.SNIPPET) ? note .getString(NoteColumns.SNIPPET) : ""; if (mIsCreate || !mSnippet.equals(snippet)) { mDiffNoteValues.put(NoteColumns.SNIPPET, snippet); } mSnippet = snippet; //如果是创建或者类型不同，则将类型放入差异便签值中 int type = note.has(NoteColumns.TYPE) ? note.getInt(NoteColumns.TYPE) : Notes.TYPE_NOTE; if (mIsCreate || mType != type) { mDiffNoteValues.put(NoteColumns.TYPE, type); } mType = type; //如果是创建或者小部件ID不同，则将小部件ID放入差异便签值中 int widgetId = note.has(NoteColumns.WIDGET_ID) ? note.getInt(NoteColumns.WIDGET_ID) : AppWidgetManager.INVALID_APPWIDGET_ID; if (mIsCreate || mWidgetId != widgetId) { mDiffNoteValues.put(NoteColumns.WIDGET_ID, widgetId); } mWidgetId = widgetId; //如果是创建或者小部件类型不同，则将小部件类型放入差异便签值中 int widgetType = note.has(NoteColumns.WIDGET_TYPE) ? note .getInt(NoteColumns.WIDGET_TYPE) : Notes.TYPE_WIDGET_INVALIDE; if (mIsCreate || mWidgetType != widgetType) { mDiffNoteValues.put(NoteColumns.WIDGET_TYPE, widgetType); } mWidgetType = widgetType; long originParent = note.has(NoteColumns.ORIGIN_PARENT_ID) ? note .getLong(NoteColumns.ORIGIN_PARENT_ID) : 0; if (mIsCreate || mOriginParent != originParent) { mDiffNoteValues.put(NoteColumns.ORIGIN_PARENT_ID, originParent); } mOriginParent = originParent; //如果是创建或者GTask ID不同，则将GTask ID放入差异便签值中，否则将GTask ID放入差异便签值中 for (int i = 0; i < dataArray.length(); i++) { JSONObject data = dataArray.getJSONObject(i); SqlData sqlData = null; if (data.has(DataColumns.ID)) { long dataId = data.getLong(DataColumns.ID); for (SqlData temp : mDataList) { if (dataId == temp.getId()) { sqlData = temp; } } } //如果sqlData为空，则创建一个新的SqlData对象 if (sqlData == null) { sqlData = new SqlData(mContext); mDataList.add(sqlData); } sqlData.setContent(data); } } //捕获异常，打印异常信息作用：设置内容 } catch (JSONException e) { Log.e(TAG, e.toString()); e.printStackTrace(); return false; } return true; } //定义一个方法，返回JSONObject对象 作用：获取内容 public JSONObject getContent() { try { JSONObject js = new JSONObject(); //如果是创建，则打印日志信息 if (mIsCreate) { Log.e(TAG, "it seems that we haven't created this in database yet"); return null; } //创建一个JSONObject对象 JSONObject note = new JSONObject(); if (mType == Notes.TYPE_NOTE) { note.put(NoteColumns.ID, mId); note.put(NoteColumns.ALERTED_DATE, mAlertDate); note.put(NoteColumns.BG_COLOR_ID, mBgColorId); note.put(NoteColumns.CREATED_DATE, mCreatedDate); note.put(NoteColumns.HAS_ATTACHMENT, mHasAttachment); note.put(NoteColumns.MODIFIED_DATE, mModifiedDate); note.put(NoteColumns.PARENT_ID, mParentId); note.put(NoteColumns.SNIPPET, mSnippet); note.put(NoteColumns.TYPE, mType); note.put(NoteColumns.WIDGET_ID, mWidgetId); note.put(NoteColumns.WIDGET_TYPE, mWidgetType); note.put(NoteColumns.ORIGIN_PARENT_ID, mOriginParent); js.put(GTaskStringUtils.META_HEAD_NOTE, note); JSONArray dataArray = new JSONArray(); for (SqlData sqlData : mDataList) { JSONObject data = sqlData.getContent(); if (data != null) { dataArray.put(data); } } js.put(GTaskStringUtils.META_HEAD_DATA, dataArray); //如果是文件夹，则打印日志信息 } else if (mType == Notes.TYPE_FOLDER || mType == Notes.TYPE_SYSTEM) { note.put(NoteColumns.ID, mId); note.put(NoteColumns.TYPE, mType); note.put(NoteColumns.SNIPPET, mSnippet); js.put(GTaskStringUtils.META_HEAD_NOTE, note); } return js; //捕获异常，打印异常信息 } catch (JSONException e) { Log.e(TAG, e.toString()); e.printStackTrace(); } return null; } //定义一个方法，返回JSONObject对象 作用：获取内容 public void setParentId(long id) { mParentId = id; mDiffNoteValues.put(NoteColumns.PARENT_ID, id); } //定义一个方法，返回JSONObject对象 作用：获取内容 public void setGtaskId(String gid) { mDiffNoteValues.put(NoteColumns.GTASK_ID, gid); } //定义一个方法，返回JSONObject对象 作用：获取内容 public void setSyncId(long syncId) { mDiffNoteValues.put(NoteColumns.SYNC_ID, syncId); } //定义一个方法，返回JSONObject对象 作用：获取内容 public void resetLocalModified() { mDiffNoteValues.put(NoteColumns.LOCAL_MODIFIED, 0); } public long getId() { return mId; } public long getParentId() { return mParentId; } public String getSnippet() { return mSnippet; } public boolean isNoteType() { return mType == Notes.TYPE_NOTE; } //定义一个方法，返回布尔型 作用：是否是文件夹类型 public void commit(boolean validateVersion) { if (mIsCreate) {//如果是创建，则打印日志信息 if (mId == INVALID_ID && mDiffNoteValues.containsKey(NoteColumns.ID)) { mDiffNoteValues.remove(NoteColumns.ID); } //如果是创建，则插入数据 Uri uri = mContentResolver.insert(Notes.CONTENT_NOTE_URI, mDiffNoteValues); try {//捕获异常，打印异常信息 mId = Long.valueOf(uri.getPathSegments().get(1)); } catch (NumberFormatException e) { Log.e(TAG, "Get note id error :" + e.toString()); throw new ActionFailureException("create note failed"); } if (mId == 0) { throw new IllegalStateException("Create thread id failed"); } //如果是便签类型，则插入数据 if (mType == Notes.TYPE_NOTE) { for (SqlData sqlData : mDataList) { sqlData.commit(mId, false, -1); } } //如果是文件夹类型，则打印日志信息 } else { if (mId <= 0 && mId != Notes.ID_ROOT_FOLDER && mId != Notes.ID_CALL_RECORD_FOLDER) { Log.e(TAG, "No such note"); throw new IllegalStateException("Try to update note with invalid id"); } //如果是便签类型，则更新数据 if (mDiffNoteValues.size() > 0) { 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) }); } //如果结果为0，则打印日志信息 if (result == 0) { Log.w(TAG, "there is no update. maybe user updates note when syncing"); } } //如果是便签类型，则更新数据 if (mType == Notes.TYPE_NOTE) { for (SqlData sqlData : mDataList) { sqlData.commit(mId, validateVersion, mVersion); } } } //如果是便签类型，则打印日志信息 // refresh local info loadFromCursor(mId); if (mType == Notes.TYPE_NOTE) loadDataContent(); //如果是便签类型，则清空差异便签值 mDiffNoteValues.clear(); mIsCreate = false; } }