diff --git a/ActionFailureException.txt b/ActionFailureException.txt new file mode 100644 index 0000000..fad6de8 --- /dev/null +++ b/ActionFailureException.txt @@ -0,0 +1,45 @@ +/* + * 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.exception; +/* + * 自定义异常类，表示操作失败。 + * 继承自RuntimeException，用于在操作失败时抛出异常。 + */ +public class ActionFailureException extends RuntimeException { + private static final long serialVersionUID = 4425249765923293627L; + + public ActionFailureException() { //默认构造函数。 + super(); + } +/* + * 带错误信息的构造函数。 + * @param paramString 错误信息 + */ + public ActionFailureException(String paramString) { + super(paramString); + } +/* + * 带错误信息和原因的构造函数。 + * @param paramString 错误信息 + * @param paramThrowable 原因 + */ + public ActionFailureException(String paramString, Throwable paramThrowable) { + super(paramString, paramThrowable); + } +} diff --git a/Contact.txt b/Contact.txt new file mode 100644 index 0000000..91b2e7e --- /dev/null +++ b/Contact.txt @@ -0,0 +1,81 @@ +/* + * 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.content.Context; +import android.database.Cursor; +import android.provider.ContactsContract.CommonDataKinds.Phone; +import android.provider.ContactsContract.Data; +import android.telephony.PhoneNumberUtils; +import android.util.Log; + +import java.util.HashMap; + +public class Contact { //缓存联系人信息的HashMap，键为电话号码，值为联系人姓名 + private static HashMap 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 " + + "(SELECT raw_contact_id " + + " FROM phone_lookup" + + " WHERE min_match = '+')"; + + /* + * 根据电话号码获取联系人姓名 + * @param context 上下文对象 + * @param phoneNumber 电话号码 + * @return 联系人姓名，如果未找到则返回null + */ + + public static String getContact(Context context, String phoneNumber) { //初始化缓存 + if(sContactCache == null) { + sContactCache = new HashMap(); + } + //如果缓存中存在该电话号码对应的联系人姓名，直接返回 + 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 }, //查询联系人显示名称 + selection, + 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; + } + } +} diff --git a/GTaskASyncTask.txt b/GTaskASyncTask.txt new file mode 100644 index 0000000..97201a8 --- /dev/null +++ b/GTaskASyncTask.txt @@ -0,0 +1,170 @@ + +/* + * 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.remote; + +import android.app.Notification; +import android.app.NotificationManager; +import android.app.PendingIntent; +import android.content.Context; +import android.content.Intent; +import android.os.AsyncTask; + +import net.micode.notes.R; +import net.micode.notes.ui.NotesListActivity; +import net.micode.notes.ui.NotesPreferenceActivity; + +/* + * GTaskASyncTask类是一个异步任务类，用于执行Google任务的同步操作。 + * 该类继承自AsyncTask，并在后台线程中执行同步操作，同时在UI线程中更新进度和结果。 + */ +public class GTaskASyncTask extends AsyncTask { + + private static int GTASK_SYNC_NOTIFICATION_ID = 5234235; + + public interface OnCompleteListener { //定义一个接口，用于在任务完成时通知监听器。 + void onComplete(); + } + + private Context mContext; + + private NotificationManager mNotifiManager; + + private GTaskManager mTaskManager; + + private OnCompleteListener mOnCompleteListener; +/* + * 构造函数，初始化上下文、通知管理器、任务管理器和完成监听器。 + * @param context 上下文 + * @param listener 完成监听器 + */ + public GTaskASyncTask(Context context, OnCompleteListener listener) { + // 初始化上下文 + mContext = context; + // 初始化完成监听器 + mOnCompleteListener = listener; + // 获取通知管理器 + mNotifiManager = (NotificationManager) mContext + .getSystemService(Context.NOTIFICATION_SERVICE); + // 获取任务管理器实例 + mTaskManager = GTaskManager.getInstance(); + } +/* + * 取消同步操作。 + */ + public void cancelSync() { + mTaskManager.cancelSync(); + } +/* + * 发布进度消息。 + */ + public void publishProgess(String message) { + publishProgress(new String[] { + message + }); + } +/* + * 显示通知。 + * @param tickerId 通知的提示文本ID + * @param content 通知的内容 + */ + private void showNotification(int tickerId, String content) { + // 创建一个新的Notification对象 + Notification notification = new Notification(R.drawable.notification, mContext + .getString(tickerId), System.currentTimeMillis()); + // 设置通知的默认灯光效果 + notification.defaults = Notification.DEFAULT_LIGHTS; + // 设置通知的标志，自动取消通知 + notification.flags = Notification.FLAG_AUTO_CANCEL; + // 创建PendingIntent，用于在用户点击通知时启动相应的Activity + PendingIntent pendingIntent; + if (tickerId != R.string.ticker_success) { + // 如果通知不是成功通知，启动NotesPreferenceActivity + pendingIntent = PendingIntent.getActivity(mContext, 0, new Intent(mContext, + NotesPreferenceActivity.class), 0); + + } else { + // 如果通知是成功通知，启动NotesListActivity + pendingIntent = PendingIntent.getActivity(mContext, 0, new Intent(mContext, + NotesListActivity.class), 0); + } + // 设置通知的详细信息 + notification.setLatestEventInfo(mContext, mContext.getString(R.string.app_name), content, + pendingIntent); + // 发送通知 + mNotifiManager.notify(GTASK_SYNC_NOTIFICATION_ID, notification); + } +/* + * 在后台线程中执行同步操作。 + * @param unused 未使用的参数 + * @return 同步结果状态码 + */ + @Override + protected Integer doInBackground(Void... unused) { + // 发布登录进度消息 + publishProgess(mContext.getString(R.string.sync_progress_login, NotesPreferenceActivity + .getSyncAccountName(mContext))); + // 调用任务管理器的同步方法，并返回同步结果状态码 + return mTaskManager.sync(mContext, this); + } +/* + * 在UI线程中更新进度。 + * @param progress 进度消息 + */ + @Override + protected void onProgressUpdate(String... progress) { + // 显示同步进度通知 + showNotification(R.string.ticker_syncing, progress[0]); + // 如果上下文是GTaskSyncService的实例，发送广播 + if (mContext instanceof GTaskSyncService) { + ((GTaskSyncService) mContext).sendBroadcast(progress[0]); + } + } +/* + * 在UI线程中处理同步结果。 + * @param result 同步结果状态码 + */ + @Override + protected void onPostExecute(Integer result) { + // 根据同步结果状态码显示相应的通知 + if (result == GTaskManager.STATE_SUCCESS) { + // 如果同步成功，显示成功通知，并更新最后一次同步时间 + showNotification(R.string.ticker_success, mContext.getString( + R.string.success_sync_account, mTaskManager.getSyncAccount())); + NotesPreferenceActivity.setLastSyncTime(mContext, System.currentTimeMillis()); + } else if (result == GTaskManager.STATE_NETWORK_ERROR) { + // 如果同步失败，显示网络错误通知 + showNotification(R.string.ticker_fail, mContext.getString(R.string.error_sync_network)); + } else if (result == GTaskManager.STATE_INTERNAL_ERROR) { + // 如果同步失败，显示内部错误通知 + showNotification(R.string.ticker_fail, mContext.getString(R.string.error_sync_internal)); + } else if (result == GTaskManager.STATE_SYNC_CANCELLED) { + // 如果同步被取消，显示取消通知 + showNotification(R.string.ticker_cancel, mContext + .getString(R.string.error_sync_cancelled)); + } + // 如果存在完成监听器，启动新线程调用onComplete方法 + if (mOnCompleteListener != null) { + new Thread(new Runnable() { + + public void run() { + mOnCompleteListener.onComplete(); + } + }).start(); + } + } +} diff --git a/GTaskClient.txt b/GTaskClient.txt new file mode 100644 index 0000000..1a886a4 --- /dev/null +++ b/GTaskClient.txt @@ -0,0 +1,807 @@ +/* + * 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.remote; + +import android.accounts.Account; +import android.accounts.AccountManager; +import android.accounts.AccountManagerFuture; +import android.app.Activity; +import android.os.Bundle; +import android.text.TextUtils; +import android.util.Log; + +import net.micode.notes.gtask.data.Node; +import net.micode.notes.gtask.data.Task; +import net.micode.notes.gtask.data.TaskList; +import net.micode.notes.gtask.exception.ActionFailureException; +import net.micode.notes.gtask.exception.NetworkFailureException; +import net.micode.notes.tool.GTaskStringUtils; +import net.micode.notes.ui.NotesPreferenceActivity; + +import org.apache.http.HttpEntity; +import org.apache.http.HttpResponse; +import org.apache.http.client.ClientProtocolException; +import org.apache.http.client.entity.UrlEncodedFormEntity; +import org.apache.http.client.methods.HttpGet; +import org.apache.http.client.methods.HttpPost; +import org.apache.http.cookie.Cookie; +import org.apache.http.impl.client.BasicCookieStore; +import org.apache.http.impl.client.DefaultHttpClient; +import org.apache.http.message.BasicNameValuePair; +import org.apache.http.params.BasicHttpParams; +import org.apache.http.params.HttpConnectionParams; +import org.apache.http.params.HttpParams; +import org.apache.http.params.HttpProtocolParams; +import org.json.JSONArray; +import org.json.JSONException; +import org.json.JSONObject; + +import java.io.BufferedReader; +import java.io.IOException; +import java.io.InputStream; +import java.io.InputStreamReader; +import java.util.LinkedList; +import java.util.List; +import java.util.zip.GZIPInputStream; +import java.util.zip.Inflater; +import java.util.zip.InflaterInputStream; + +/* + * GTaskClient类是一个用于与Google任务服务进行交互的客户端类。 + * 该类提供了登录、创建任务、创建任务列表、更新任务、移动任务、删除任务等功能。 + */ +public class GTaskClient { + private static final String TAG = GTaskClient.class.getSimpleName(); + + private static final String GTASK_URL = "https://mail.google.com/tasks/"; + + private static final String GTASK_GET_URL = "https://mail.google.com/tasks/ig"; + + private static final String GTASK_POST_URL = "https://mail.google.com/tasks/r/ig"; + + private static GTaskClient mInstance = null; + + private DefaultHttpClient mHttpClient; + + private String mGetUrl; + + private String mPostUrl; + + private long mClientVersion; + + private boolean mLoggedin; + + private long mLastLoginTime; + + private int mActionId; + + private Account mAccount; + + private JSONArray mUpdateArray; +/* + * 私有构造函数，初始化成员变量。 + */ + private GTaskClient() { + mHttpClient = null; // 初始化HttpClient为null + mGetUrl = GTASK_GET_URL; // 初始化GET和POST请求的URL + mPostUrl = GTASK_POST_URL; + mClientVersion = -1; // 初始化客户端版本号为-1 + mLoggedin = false; // 初始化登录状态为false + mLastLoginTime = 0; // 初始化最后一次登录时间为0 + mActionId = 1; // 初始化操作ID为1 + mAccount = null; // 初始化账户为null + mUpdateArray = null; // 初始化更新数组为null + } +/* + * 获取GTaskClient的单例实例。 + * @return GTaskClient的单例实例 + */ + public static synchronized GTaskClient getInstance() { + // 如果mInstance为null，创建一个新的GTaskClient实例 + if (mInstance == null) { + mInstance = new GTaskClient(); + } + // 返回GTaskClient的单例实例 + return mInstance; + } +/* + * 登录Google任务服务。 + * @param activity 当前活动 + * @return 是否登录成功 + */ + public boolean login(Activity activity) { + // we suppose that the cookie would expire after 5 minutes + // 假设cookie在5分钟后过期，需要重新登录 + // then we need to re-login + final long interval = 1000 * 60 * 5; + if (mLastLoginTime + interval < System.currentTimeMillis()) { + mLoggedin = false; + } + + // need to re-login after account switch + // 需要重新登录以切换账户 + if (mLoggedin + && !TextUtils.equals(getSyncAccount().name, NotesPreferenceActivity + .getSyncAccountName(activity))) { + mLoggedin = false; + } + // 如果已经登录，直接返回true + if (mLoggedin) { + Log.d(TAG, "already logged in"); + return true; + } + // 更新最后一次登录时间 + mLastLoginTime = System.currentTimeMillis(); + // 登录Google账户 + String authToken = loginGoogleAccount(activity, false); + if (authToken == null) { + Log.e(TAG, "login google account failed"); + return false; + } + + // login with custom domain if necessary + // 如果账户不是gmail.com或googlemail.com，尝试使用自定义域名登录 + if (!(mAccount.name.toLowerCase().endsWith("gmail.com") || mAccount.name.toLowerCase() + .endsWith("googlemail.com"))) { + StringBuilder url = new StringBuilder(GTASK_URL).append("a/"); + int index = mAccount.name.indexOf('@') + 1; + String suffix = mAccount.name.substring(index); + url.append(suffix + "/"); + mGetUrl = url.toString() + "ig"; + mPostUrl = url.toString() + "r/ig"; + + if (tryToLoginGtask(activity, authToken)) { + mLoggedin = true; + } + } + + // try to login with google official url + // 尝试使用Google官方URL登录 + if (!mLoggedin) { + mGetUrl = GTASK_GET_URL; + mPostUrl = GTASK_POST_URL; + if (!tryToLoginGtask(activity, authToken)) { + return false; + } + } + // 登录成功 + mLoggedin = true; + return true; + } +/* + * 登录Google账户并获取授权令牌。 + * @param activity 当前活动 + * @param invalidateToken 是否使授权令牌失效 + * @return 授权令牌，如果登录失败则返回null + */ + private String loginGoogleAccount(Activity activity, boolean invalidateToken) { + String authToken; + // 获取AccountManager实例 + AccountManager accountManager = AccountManager.get(activity); + // 获取所有Google账户 + Account[] accounts = accountManager.getAccountsByType("com.google"); + // 如果没有可用的Google账户，记录错误日志并返回null + if (accounts.length == 0) { + Log.e(TAG, "there is no available google account"); + return null; + } + // 获取设置中的同步账户名称 + String accountName = NotesPreferenceActivity.getSyncAccountName(activity); + Account account = null; + // 遍历所有Google账户，查找与设置中同步账户名称匹配的账户 + for (Account a : accounts) { + if (a.name.equals(accountName)) { + account = a; + break; + } + } + // 如果找到匹配的账户，将其赋值给mAccount + if (account != null) { + mAccount = account; + } else { + // 如果没有找到匹配的账户，记录错误日志并返回null + Log.e(TAG, "unable to get an account with the same name in the settings"); + return null; + } + + // get the token now + // 获取授权令牌 + AccountManagerFuture accountManagerFuture = accountManager.getAuthToken(account, + "goanna_mobile", null, activity, null, null); + try { + // 获取授权令牌的Bundle + Bundle authTokenBundle = accountManagerFuture.getResult(); + // 从Bundle中获取授权令牌 + authToken = authTokenBundle.getString(AccountManager.KEY_AUTHTOKEN); + // 如果需要使授权令牌失效，使令牌失效并重新获取 + if (invalidateToken) { + accountManager.invalidateAuthToken("com.google", authToken); + loginGoogleAccount(activity, false); + } + } catch (Exception e) { + // 如果获取授权令牌失败，记录错误日志并返回null + Log.e(TAG, "get auth token failed"); + authToken = null; + } + + return authToken; // 返回授权令牌 + } +/* + * 尝试登录Google任务服务。 + * @param activity 当前活动 + * @param authToken 授权令牌 + * @return 是否登录成功 + */ + private boolean tryToLoginGtask(Activity activity, String authToken) { + // 尝试使用当前授权令牌登录Google任务服务 + if (!loginGtask(authToken)) { + // maybe the auth token is out of date, now let's invalidate the + // token and try again + // 如果登录失败，可能是授权令牌已过期，使令牌失效并重新获取 + authToken = loginGoogleAccount(activity, true); + if (authToken == null) { + Log.e(TAG, "login google account failed"); + return false; + } + // 使用新的授权令牌再次尝试登录Google任务服务 + if (!loginGtask(authToken)) { + Log.e(TAG, "login gtask failed"); + return false; + } + } + return true; + } +/* + * 使用授权令牌登录Google任务服务。 + * @param authToken 授权令牌 + * @return 是否登录成功 + */ + private boolean loginGtask(String authToken) { + // 设置连接超时和套接字超时 + int timeoutConnection = 10000; + int timeoutSocket = 15000; + HttpParams httpParameters = new BasicHttpParams(); + HttpConnectionParams.setConnectionTimeout(httpParameters, timeoutConnection); + HttpConnectionParams.setSoTimeout(httpParameters, timeoutSocket); + // 创建DefaultHttpClient实例 + mHttpClient = new DefaultHttpClient(httpParameters); + // 创建BasicCookieStore实例并设置到HttpClient中 + BasicCookieStore localBasicCookieStore = new BasicCookieStore(); + mHttpClient.setCookieStore(localBasicCookieStore); + // 设置HttpClient不使用Expect-Continue + HttpProtocolParams.setUseExpectContinue(mHttpClient.getParams(), false); + + // login gtask + // 登录Google任务服务 + try { + // 构建登录URL + String loginUrl = mGetUrl + "?auth=" + authToken; + HttpGet httpGet = new HttpGet(loginUrl); + HttpResponse response = null; + response = mHttpClient.execute(httpGet); + + // get the cookie now + // 获取cookie + List cookies = mHttpClient.getCookieStore().getCookies(); + boolean hasAuthCookie = false; + for (Cookie cookie : cookies) { + if (cookie.getName().contains("GTL")) { + hasAuthCookie = true; + } + } + if (!hasAuthCookie) { + Log.w(TAG, "it seems that there is no auth cookie"); + } + + // get the client version + // 获取客户端版本 + String resString = getResponseContent(response.getEntity()); + String jsBegin = "_setup("; + String jsEnd = ")}"; + int begin = resString.indexOf(jsBegin); + int end = resString.lastIndexOf(jsEnd); + String jsString = null; + if (begin != -1 && end != -1 && begin < end) { + jsString = resString.substring(begin + jsBegin.length(), end); + } + JSONObject js = new JSONObject(jsString); + mClientVersion = js.getLong("v"); + } catch (JSONException e) { + Log.e(TAG, e.toString()); + e.printStackTrace(); + return false; + } catch (Exception e) { + // simply catch all exceptions + // 捕获所有异常 + Log.e(TAG, "httpget gtask_url failed"); + return false; + } + + return true; + } +/* + * 获取操作ID并递增。 + * @return 当前操作ID + */ + private int getActionId() { + // 返回当前操作ID并递增 + return mActionId++; + } +/* + * 创建HttpPost请求。 + * @return 创建的HttpPost请求 + */ + private HttpPost createHttpPost() { + // 创建HttpPost请求，设置请求URL + HttpPost httpPost = new HttpPost(mPostUrl); + // 设置请求头，指定Content-Type为application/x-www-form-urlencoded，字符集为UTF-8 + httpPost.setHeader("Content-Type", "application/x-www-form-urlencoded;charset=utf-8"); + httpPost.setHeader("AT", "1"); + // 设置请求头，指定AT为1 + return httpPost; + // 返回创建的HttpPost请求 + } +/* + * 从HttpEntity中获取响应内容并返回字符串形式。 + * 支持处理gzip和deflate压缩编码。 + * @param entity HTTP响应实体 + * @return 响应内容的字符串形式 + * @throws IOException 如果读取输入流时发生错误 + */ + private String getResponseContent(HttpEntity entity) throws IOException { + String contentEncoding = null; + // 检查HttpEntity是否包含Content-Encoding头部 + if (entity.getContentEncoding() != null) { + // 获取Content-Encoding的值 + contentEncoding = entity.getContentEncoding().getValue(); + // 记录日志，显示当前的Content-Encoding + Log.d(TAG, "encoding: " + contentEncoding); + } + // 获取HttpEntity的原始输入流 + InputStream input = entity.getContent(); + // 如果Content-Encoding是gzip，则使用GZIPInputStream解压缩 + if (contentEncoding != null && contentEncoding.equalsIgnoreCase("gzip")) { + input = new GZIPInputStream(entity.getContent()); + } else if (contentEncoding != null && contentEncoding.equalsIgnoreCase("deflate")) { + // 如果Content-Encoding是deflate，则使用InflaterInputStream解压缩 + Inflater inflater = new Inflater(true); + input = new InflaterInputStream(entity.getContent(), inflater); + } + + try { + // 创建InputStreamReader，用于将字节流转换为字符流 + InputStreamReader isr = new InputStreamReader(input); + // 创建BufferedReader，用于逐行读取字符流 + BufferedReader br = new BufferedReader(isr); + // 创建StringBuilder，用于存储读取到的内容 + StringBuilder sb = new StringBuilder(); + // 循环读取输入流中的每一行 + while (true) { + String buff = br.readLine(); + // 如果读取到null，表示已经到达流的末尾，返回StringBuilder中的内容 + if (buff == null) { + return sb.toString(); + } + // 将读取到的行追加到StringBuilder中 + sb = sb.append(buff); + } + } finally { + // 确保输入流在方法结束时被关闭 + input.close(); + } + } +/* + * 发送POST请求并返回响应的JSONObject。 + * @param js 要发送的请求数据，以JSONObject形式表示 + * @return 服务器响应的JSONObject + * @throws NetworkFailureException 如果网络请求失败 + * @throws ActionFailureException 如果操作失败（例如未登录或响应内容无法转换为JSONObject） + */ + private JSONObject postRequest(JSONObject js) throws NetworkFailureException { + // 检查用户是否已登录，如果未登录则抛出异常 + if (!mLoggedin) { + Log.e(TAG, "please login first"); + throw new ActionFailureException("not logged in"); + } + // 创建HttpPost对象 + HttpPost httpPost = createHttpPost(); + try { + // 创建一个LinkedList来存储请求参数 + LinkedList list = new LinkedList(); + // 将请求数据（JSONObject）转换为字符串，并添加到请求参数列表中 + list.add(new BasicNameValuePair("r", js.toString())); + // 创建UrlEncodedFormEntity对象，用于将请求参数编码为表单格式 + UrlEncodedFormEntity entity = new UrlEncodedFormEntity(list, "UTF-8"); + // 将请求实体设置到HttpPost对象中 + httpPost.setEntity(entity); + // execute the post + // 执行POST请求 + HttpResponse response = mHttpClient.execute(httpPost); + // 获取响应内容并转换为字符串 + String jsString = getResponseContent(response.getEntity()); + // 将响应内容字符串转换为JSONObject并返回 + return new JSONObject(jsString); + + } catch (ClientProtocolException e) { + // 捕获并记录HTTP协议异常 + Log.e(TAG, e.toString()); + e.printStackTrace(); + throw new NetworkFailureException("postRequest failed"); + } catch (IOException e) { + // 捕获并记录IO异常 + Log.e(TAG, e.toString()); + e.printStackTrace(); + throw new NetworkFailureException("postRequest failed"); + } catch (JSONException e) { + // 捕获并记录JSON解析异常 + Log.e(TAG, e.toString()); + e.printStackTrace(); + throw new ActionFailureException("unable to convert response content to jsonobject"); + } catch (Exception e) { + // 捕获并记录其他异常 + Log.e(TAG, e.toString()); + e.printStackTrace(); + throw new ActionFailureException("error occurs when posting request"); + } + } +/* + * 创建一个新的任务，并将其上传到服务器。 + * @param task 要创建的任务对象 + * @throws NetworkFailureException 如果网络请求失败 + * @throws ActionFailureException 如果操作失败（例如JSON处理失败） + */ + public void createTask(Task task) throws NetworkFailureException { + // 提交更新操作 + commitUpdate(); + try { + // 创建一个新的JSONObject，用于存储POST请求的数据 + JSONObject jsPost = new JSONObject(); + // 创建一个JSONArray，用于存储任务的创建操作 + JSONArray actionList = new JSONArray(); + + // action_list + // 将任务的创建操作添加到actionList中 + actionList.put(task.getCreateAction(getActionId())); + // 将actionList添加到jsPost中 + jsPost.put(GTaskStringUtils.GTASK_JSON_ACTION_LIST, actionList); + + // client_version + // 添加客户端版本信息到jsPost中 + jsPost.put(GTaskStringUtils.GTASK_JSON_CLIENT_VERSION, mClientVersion); + + // post + // 发送POST请求，并将响应内容转换为JSONObject + JSONObject jsResponse = postRequest(jsPost); + // 从响应中获取结果数组，并获取第一个结果 + JSONObject jsResult = (JSONObject) jsResponse.getJSONArray( + GTaskStringUtils.GTASK_JSON_RESULTS).get(0); + // 从结果中获取新创建任务的ID，并设置到任务对象中 + task.setGid(jsResult.getString(GTaskStringUtils.GTASK_JSON_NEW_ID)); + + } catch (JSONException e) {、 + // 捕获并记录JSON解析异常 + Log.e(TAG, e.toString()); + e.printStackTrace(); + throw new ActionFailureException("create task: handing jsonobject failed"); + } + } +/* + * 创建一个新的任务列表，并将其上传到服务器。 + * @param tasklist 要创建的任务列表对象 + * @throws NetworkFailureException 如果网络请求失败 + * @throws ActionFailureException 如果操作失败（例如JSON处理失败） + */ + public void createTaskList(TaskList tasklist) throws NetworkFailureException { + // 提交更新操作 + commitUpdate(); + try { + // 创建一个新的JSONObject，用于存储POST请求的数据 + JSONObject jsPost = new JSONObject(); + // 创建一个JSONArray，用于存储任务列表的创建操作 + JSONArray actionList = new JSONArray(); + + // action_list + // 将任务列表的创建操作添加到actionList中 + actionList.put(tasklist.getCreateAction(getActionId())); + // 将actionList添加到jsPost中 + jsPost.put(GTaskStringUtils.GTASK_JSON_ACTION_LIST, actionList); + + // client version + // 添加客户端版本信息到jsPost中 + jsPost.put(GTaskStringUtils.GTASK_JSON_CLIENT_VERSION, mClientVersion); + + // post + // 发送POST请求，并将响应内容转换为JSONObject + JSONObject jsResponse = postRequest(jsPost); + // 从响应中获取结果数组，并获取第一个结果 + JSONObject jsResult = (JSONObject) jsResponse.getJSONArray( + GTaskStringUtils.GTASK_JSON_RESULTS).get(0); + // 从结果中获取新创建任务列表的ID，并设置到任务列表对象中 + tasklist.setGid(jsResult.getString(GTaskStringUtils.GTASK_JSON_NEW_ID)); + + } catch (JSONException e) { + // 捕获并记录JSON解析异常 + Log.e(TAG, e.toString()); + e.printStackTrace(); + throw new ActionFailureException("create tasklist: handing jsonobject failed"); + } + } +/* + * 提交所有未完成的更新操作到服务器。 + * @throws NetworkFailureException 如果网络请求失败 + * @throws ActionFailureException 如果操作失败（例如JSON处理失败） + */ + public void commitUpdate() throws NetworkFailureException { + // 检查是否有未完成的更新操作 + if (mUpdateArray != null) { + try { + // 创建一个新的JSONObject，用于存储POST请求的数据 + JSONObject jsPost = new JSONObject(); + + // action_list + // 将未完成的更新操作数组添加到jsPost中 + jsPost.put(GTaskStringUtils.GTASK_JSON_ACTION_LIST, mUpdateArray); + + // client_version + // 添加客户端版本信息到jsPost中 + jsPost.put(GTaskStringUtils.GTASK_JSON_CLIENT_VERSION, mClientVersion); + // 发送POST请求 + postRequest(jsPost); + // 提交成功后，清空更新操作数组 + mUpdateArray = null; + } catch (JSONException e) { + // 捕获并记录JSON解析异常 + Log.e(TAG, e.toString()); + e.printStackTrace(); + throw new ActionFailureException("commit update: handing jsonobject failed"); + } + } + } +/* + * 将一个节点添加到更新操作数组中，并在必要时提交更新操作。 + * @param node 要添加的节点对象 + * @throws NetworkFailureException 如果网络请求失败 + */ + public void addUpdateNode(Node node) throws NetworkFailureException { + // 检查节点是否为空 + if (node != null) { + // too many update items may result in an error + // set max to 10 items + // 如果更新操作数组中已经有超过10个项目，则提交更新操作 + // 避免过多的更新操作导致错误 + if (mUpdateArray != null && mUpdateArray.length() > 10) { + commitUpdate(); + } + // 如果更新操作数组为空，则创建一个新的JSONArray + if (mUpdateArray == null) + mUpdateArray = new JSONArray(); + // 将节点的更新操作添加到更新操作数组中 + mUpdateArray.put(node.getUpdateAction(getActionId())); + } + } +/* + * 将任务从一个任务列表移动到另一个任务列表。 + * @param task 要移动的任务对象 + * @param preParent 任务的原始父任务列表 + * @param curParent 任务的新父任务列表 + * @throws NetworkFailureException 如果网络请求失败 + * @throws ActionFailureException 如果操作失败（例如JSON处理失败） + */ + public void moveTask(Task task, TaskList preParent, TaskList curParent) + throws NetworkFailureException { + // 提交更新操作 + commitUpdate(); + try { + // 创建一个新的JSONObject，用于存储POST请求的数据 + JSONObject jsPost = new JSONObject(); + // 创建一个JSONArray，用于存储任务的移动操作 + JSONArray actionList = new JSONArray(); + // 创建一个JSONObject，用于存储具体的移动操作 + JSONObject action = new JSONObject(); + + // action_list + // 设置移动操作的类型为"move" + action.put(GTaskStringUtils.GTASK_JSON_ACTION_TYPE, + GTaskStringUtils.GTASK_JSON_ACTION_TYPE_MOVE); + // 设置移动操作的ID + action.put(GTaskStringUtils.GTASK_JSON_ACTION_ID, getActionId()); + // 设置要移动的任务的ID + action.put(GTaskStringUtils.GTASK_JSON_ID, task.getGid()); + // 如果任务在同一个任务列表中移动，并且不是第一个任务，则设置前一个兄弟任务的ID + if (preParent == curParent && task.getPriorSibling() != null) { + // put prioring_sibing_id only if moving within the tasklist and + // it is not the first one + action.put(GTaskStringUtils.GTASK_JSON_PRIOR_SIBLING_ID, task.getPriorSibling()); + } + // 设置任务的原始父任务列表的ID + action.put(GTaskStringUtils.GTASK_JSON_SOURCE_LIST, preParent.getGid()); + // 设置任务的新父任务列表的ID + action.put(GTaskStringUtils.GTASK_JSON_DEST_PARENT, curParent.getGid()); + // 如果任务在不同的任务列表之间移动，则设置目标任务列表的ID + if (preParent != curParent) { + // put the dest_list only if moving between tasklists + action.put(GTaskStringUtils.GTASK_JSON_DEST_LIST, curParent.getGid()); + } + // 将移动操作添加到actionList中 + actionList.put(action); + // 将actionList添加到jsPost中 + jsPost.put(GTaskStringUtils.GTASK_JSON_ACTION_LIST, actionList); + + // client_version + // 添加客户端版本信息到jsPost中 + jsPost.put(GTaskStringUtils.GTASK_JSON_CLIENT_VERSION, mClientVersion); + // 发送POST请求 + postRequest(jsPost); + + } catch (JSONException e) { + // 捕获并记录JSON解析异常 + Log.e(TAG, e.toString()); + e.printStackTrace(); + throw new ActionFailureException("move task: handing jsonobject failed"); + } + } +/* + * 删除一个节点，并将其标记为已删除状态。 + * @param node 要删除的节点对象 + * @throws NetworkFailureException 如果网络请求失败 + * @throws ActionFailureException 如果操作失败（例如JSON处理失败） + */ + public void deleteNode(Node node) throws NetworkFailureException { + // 提交更新操作 + commitUpdate(); + try { + // 创建一个新的JSONObject，用于存储POST请求的数据 + JSONObject jsPost = new JSONObject(); + // 创建一个JSONArray，用于存储节点的删除操作 + JSONArray actionList = new JSONArray(); + + // action_list + // 将节点标记为已删除 + node.setDeleted(true); + // 获取节点的更新操作，并将其添加到actionList中 + actionList.put(node.getUpdateAction(getActionId())); + // 将actionList添加到jsPost中 + jsPost.put(GTaskStringUtils.GTASK_JSON_ACTION_LIST, actionList); + + // client_version + // 添加客户端版本信息到jsPost中 + jsPost.put(GTaskStringUtils.GTASK_JSON_CLIENT_VERSION, mClientVersion); + // 发送POST请求 + postRequest(jsPost); + // 提交成功后，清空更新操作数组 + mUpdateArray = null; + } catch (JSONException e) { + // 捕获并记录JSON解析异常 + Log.e(TAG, e.toString()); + e.printStackTrace(); + throw new ActionFailureException("delete node: handing jsonobject failed"); + } + } +/* + * 获取所有任务列表，并返回一个包含任务列表的JSONArray。 + * @return 包含任务列表的JSONArray + * @throws NetworkFailureException 如果网络请求失败 + * @throws ActionFailureException 如果操作失败（例如未登录或JSON处理失败） + */ + public JSONArray getTaskLists() throws NetworkFailureException { + // 检查用户是否已登录，如果未登录则抛出异常 + if (!mLoggedin) { + Log.e(TAG, "please login first"); + throw new ActionFailureException("not logged in"); + } + + try { + // 创建一个HttpGet对象，用于发送GET请求 + HttpGet httpGet = new HttpGet(mGetUrl); + HttpResponse response = null; + // 执行GET请求，并获取响应 + response = mHttpClient.execute(httpGet); + + // get the task list + // 获取响应内容并转换为字符串 + String resString = getResponseContent(response.getEntity()); + // 从响应内容中提取包含任务列表的JSON字符串 + String jsBegin = "_setup("; + String jsEnd = ")}"; + int begin = resString.indexOf(jsBegin); + int end = resString.lastIndexOf(jsEnd); + String jsString = null; + if (begin != -1 && end != -1 && begin < end) { + jsString = resString.substring(begin + jsBegin.length(), end); + } + // 将提取的JSON字符串转换为JSONObject + JSONObject js = new JSONObject(jsString); + // 从JSONObject中获取任务列表的JSONArray并返回 + return js.getJSONObject("t").getJSONArray(GTaskStringUtils.GTASK_JSON_LISTS); + } catch (ClientProtocolException e) { + // 捕获并记录HTTP协议异常 + Log.e(TAG, e.toString()); + e.printStackTrace(); + throw new NetworkFailureException("gettasklists: httpget failed"); + } catch (IOException e) { + // 捕获并记录IO异常 + Log.e(TAG, e.toString()); + e.printStackTrace(); + throw new NetworkFailureException("gettasklists: httpget failed"); + } catch (JSONException e) { + // 捕获并记录JSON解析异常 + Log.e(TAG, e.toString()); + e.printStackTrace(); + throw new ActionFailureException("get task lists: handing jasonobject failed"); + } + } +/* + * 获取指定任务列表中的所有任务，并返回一个包含任务的JSONArray。 + * @param listGid 任务列表的ID + * @return 包含任务的JSONArray + * @throws NetworkFailureException 如果网络请求失败 + * @throws ActionFailureException 如果操作失败（例如JSON处理失败） + */ + public JSONArray getTaskList(String listGid) throws NetworkFailureException { + // 提交更新操作 + commitUpdate(); + try { + // 创建一个新的JSONObject，用于存储POST请求的数据 + JSONObject jsPost = new JSONObject(); + // 创建一个JSONArray，用于存储获取任务列表的操作 + JSONArray actionList = new JSONArray(); + // 创建一个JSONObject，用于存储具体的获取操作 + JSONObject action = new JSONObject(); + + // action_list + // 设置获取操作的类型为"getall" + action.put(GTaskStringUtils.GTASK_JSON_ACTION_TYPE, + GTaskStringUtils.GTASK_JSON_ACTION_TYPE_GETALL); + // 设置获取操作的ID + action.put(GTaskStringUtils.GTASK_JSON_ACTION_ID, getActionId()); + // 设置要获取的任务列表的ID + action.put(GTaskStringUtils.GTASK_JSON_LIST_ID, listGid); + // 设置是否获取已删除的任务，这里设置为false + action.put(GTaskStringUtils.GTASK_JSON_GET_DELETED, false); + // 将获取操作添加到actionList中 + actionList.put(action); + // 将actionList添加到jsPost中 + jsPost.put(GTaskStringUtils.GTASK_JSON_ACTION_LIST, actionList); + + // client_version + // 添加客户端版本信息到jsPost中 + jsPost.put(GTaskStringUtils.GTASK_JSON_CLIENT_VERSION, mClientVersion); + // 发送POST请求，并将响应内容转换为JSONObject + JSONObject jsResponse = postRequest(jsPost); + // 从响应中获取任务列表的JSONArray并返回 + return jsResponse.getJSONArray(GTaskStringUtils.GTASK_JSON_TASKS); + } catch (JSONException e) { + // 捕获并记录JSON解析异常 + Log.e(TAG, e.toString()); + e.printStackTrace(); + throw new ActionFailureException("get task list: handing jsonobject failed"); + } + } +/* + * 获取当前同步的账户。 + * @return 当前同步的账户对象 + */ + public Account getSyncAccount() { + return mAccount; + } +/* + * 重置更新操作数组。 + */ + public void resetUpdateArray() { + mUpdateArray = null; + } +} diff --git a/GTaskManager.txt b/GTaskManager.txt new file mode 100644 index 0000000..45caf8d --- /dev/null +++ b/GTaskManager.txt @@ -0,0 +1,1065 @@ +/* + * 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. + */ +/* + * GTaskManager 负责管理本地笔记数据库与 Google Tasks 之间的同步过程。 + */ +package net.micode.notes.gtask.remote; + +import android.app.Activity; +import android.content.ContentResolver; +import android.content.ContentUris; +import android.content.ContentValues; +import android.content.Context; +import android.database.Cursor; +import android.util.Log; + +import net.micode.notes.R; +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.data.MetaData; +import net.micode.notes.gtask.data.Node; +import net.micode.notes.gtask.data.SqlNote; +import net.micode.notes.gtask.data.Task; +import net.micode.notes.gtask.data.TaskList; +import net.micode.notes.gtask.exception.ActionFailureException; +import net.micode.notes.gtask.exception.NetworkFailureException; +import net.micode.notes.tool.DataUtils; +import net.micode.notes.tool.GTaskStringUtils; + +import org.json.JSONArray; +import org.json.JSONException; +import org.json.JSONObject; + +import java.util.HashMap; +import java.util.HashSet; +import java.util.Iterator; +import java.util.Map; + +/* + * GTaskManager 负责管理本地笔记数据库与 Google Tasks 之间的同步过程。 + */ +public class GTaskManager { + private static final String TAG = GTaskManager.class.getSimpleName(); + // 同步状态常量 + public static final int STATE_SUCCESS = 0; + + public static final int STATE_NETWORK_ERROR = 1; + + public static final int STATE_INTERNAL_ERROR = 2; + + public static final int STATE_SYNC_IN_PROGRESS = 3; + + public static final int STATE_SYNC_CANCELLED = 4; + // 单例实例 + private static GTaskManager mInstance = null; + // 用于获取认证令牌的活动上下文 + private Activity mActivity; + // 应用程序上下文 + private Context mContext; + // 内容解析器用于数据库操作 + private ContentResolver mContentResolver; + // 同步状态标志 + private boolean mSyncing; + + private boolean mCancelled; + // 用于管理任务列表、节点、元数据和 GID 与 NID 映射的哈希表 + private HashMap mGTaskListHashMap; + + private HashMap mGTaskHashMap; + + private HashMap mMetaHashMap; + + private TaskList mMetaList; + + private HashSet mLocalDeleteIdMap; + + private HashMap mGidToNid; + + private HashMap mNidToGid; + + private GTaskManager() { + // 初始化同步状态标志，表示当前没有正在进行同步 + mSyncing = false; + // 初始化取消同步标志，表示当前没有取消同步 + mCancelled = false; + // 初始化用于存储 Google Task 列表的哈希表 + mGTaskListHashMap = new HashMap();、 + // 初始化用于存储 Google Task 节点的哈希表 + mGTaskHashMap = new HashMap(); + // 初始化用于存储元数据的哈希表 + mMetaHashMap = new HashMap(); + // 初始化元数据列表，初始值为 null + mMetaList = null; + // 初始化用于存储本地删除的笔记 ID 的集合 + mLocalDeleteIdMap = new HashSet(); + // 初始化用于存储 Google Task ID 到本地笔记 ID 映射的哈希表 + mGidToNid = new HashMap(); + // 初始化用于存储本地笔记 ID 到 Google Task ID 映射的哈希表 + mNidToGid = new HashMap(); + } +/* + * 获取 GTaskManager 的单例实例。 + * 该方法使用 synchronized 关键字确保线程安全，防止多个线程同时创建实例。 + * @return GTaskManager 的单例实例 + */ + public static synchronized GTaskManager getInstance() { + // 检查单例实例是否已经创建 + if (mInstance == null) { + // 如果未创建，则创建一个新的 GTaskManager 实例 + mInstance = new GTaskManager(); + } + return mInstance; // 返回单例实例 + } +/* + * 设置活动上下文，用于获取认证令牌。 + * 该方法使用 synchronized 关键字确保线程安全，防止多个线程同时修改 mActivity 变量。 + * @param activity 活动上下文 + */ + public synchronized void setActivityContext(Activity activity) { + // used for getting authtoken + // 将传入的活动上下文赋值给 mActivity 变量 + mActivity = activity; + } +/* + * 同步本地笔记数据库与 Google Tasks。 + * 该方法负责初始化同步过程，处理同步过程中的各种异常，并返回同步结果状态。 + * @param context 应用程序上下文 + * @param asyncTask 异步任务对象，用于发布同步进度 + * @return 同步结果状态，可能的值为 STATE_SUCCESS, STATE_NETWORK_ERROR, STATE_INTERNAL_ERROR, STATE_SYNC_IN_PROGRESS, STATE_SYNC_CANCELLED + */ + public int sync(Context context, GTaskASyncTask asyncTask) { + // 检查是否已经有同步正在进行 + if (mSyncing) { + Log.d(TAG, "Sync is in progress"); + return STATE_SYNC_IN_PROGRESS; + } + // 设置应用程序上下文和内容解析器 + mContext = context; + mContentResolver = mContext.getContentResolver(); + // 标记同步正在进行 + mSyncing = true; + mCancelled = false; + // 清空所有数据结构 + mGTaskListHashMap.clear(); + mGTaskHashMap.clear(); + mMetaHashMap.clear(); + mLocalDeleteIdMap.clear(); + mGidToNid.clear(); + mNidToGid.clear(); + + try { + // 获取 GTaskClient 实例并重置更新数组 + GTaskClient client = GTaskClient.getInstance(); + client.resetUpdateArray(); + + // login google task + // 登录 Google Task + if (!mCancelled) { + if (!client.login(mActivity)) { + throw new NetworkFailureException("login google task failed"); + } + } + + // get the task list from google + // 从 Google 获取任务列表 + asyncTask.publishProgess(mContext.getString(R.string.sync_progress_init_list)); + initGTaskList(); + + // do content sync work + // 执行内容同步工作 + asyncTask.publishProgess(mContext.getString(R.string.sync_progress_syncing)); + syncContent(); + } catch (NetworkFailureException e) { + // 处理网络失败异常 + Log.e(TAG, e.toString()); + return STATE_NETWORK_ERROR; + } catch (ActionFailureException e) { + // 处理操作失败异常 + Log.e(TAG, e.toString()); + return STATE_INTERNAL_ERROR; + } catch (Exception e) { + // 处理其他异常 + Log.e(TAG, e.toString()); + e.printStackTrace(); + return STATE_INTERNAL_ERROR; + } finally { + // 清空所有数据结构并标记同步结束 + mGTaskListHashMap.clear(); + mGTaskHashMap.clear(); + mMetaHashMap.clear(); + mLocalDeleteIdMap.clear(); + mGidToNid.clear(); + mNidToGid.clear(); + mSyncing = false; + } + + return mCancelled ? STATE_SYNC_CANCELLED : STATE_SUCCESS; // 返回同步结果状态 + } +/* + * 初始化 Google Task 列表。 + * 该方法从 Google Task 获取任务列表，并初始化元数据列表和任务列表。 + * @throws NetworkFailureException 如果网络操作失败 + */ + private void initGTaskList() throws NetworkFailureException { + // 检查是否已经取消同步 + if (mCancelled) + return; + // 获取 GTaskClient 实例 + GTaskClient client = GTaskClient.getInstance(); + try { + // 从 Google Task 获取任务列表 + JSONArray jsTaskLists = client.getTaskLists(); + + // init meta list first + // 首先初始化元数据列表 + mMetaList = null; //初始化元数据列表，将其设置为 null。 + for (int i = 0; i < jsTaskLists.length(); i++) { + //遍历任务列表，逐个处理每个任务列表。 + JSONObject object = jsTaskLists.getJSONObject(i); + //获取当前任务列表的 JSONObject + String gid = object.getString(GTaskStringUtils.GTASK_JSON_ID); + //获取当前任务列表的 Google Task ID + //获取当前任务列表的名称。 + String name = object.getString(GTaskStringUtils.GTASK_JSON_NAME); + // 检查是否是元数据列表 + //如果是，则初始化元数据列表并加载元数据。 + if (name + .equals(GTaskStringUtils.MIUI_FOLDER_PREFFIX + GTaskStringUtils.FOLDER_META)) { + mMetaList = new TaskList(); + //创建一个新的 TaskList 对象作为元数据列表。 + mMetaList.setContentByRemoteJSON(object); + //使用远程 JSON 数据设置元数据列表的内容。 + + // load meta data + // 加载元数据 + JSONArray jsMetas = client.getTaskList(gid); + //获取元数据列表中的元数据，返回一个 JSONArray。 + for (int j = 0; j < jsMetas.length(); j++) { + //遍历元数据列表，逐个处理每个元数据。 + object = (JSONObject) jsMetas.getJSONObject(j); + MetaData metaData = new MetaData(); + //创建一个新的 MetaData 对象 + metaData.setContentByRemoteJSON(object); + //使用远程 JSON 数据设置元数据的内容 + if (metaData.isWorthSaving()) { + //检查元数据是否值得保存。如果值得保存，则将其添加到元数据列表中，并更新 mMetaHashMap + mMetaList.addChildTask(metaData); + if (metaData.getGid() != null) { + //检查元数据的 Google Task ID 是否存在。如果存在，则将其添加到 mMetaHashMap 中 + mMetaHashMap.put(metaData.getRelatedGid(), metaData); + } + } + } + } + } + + // create meta list if not existed + // 如果元数据列表不存在，则创建一个新的元数据列表 + if (mMetaList == null) { + //检查元数据列表是否为空。如果为空，则创建一个新的元数据列表并将其添加到 Google Task 中。 + mMetaList = new TaskList(); + mMetaList.setName(GTaskStringUtils.MIUI_FOLDER_PREFFIX + + GTaskStringUtils.FOLDER_META); + //设置元数据列表的名称 + GTaskClient.getInstance().createTaskList(mMetaList); + //将元数据列表添加到 Google Task 中 + } + + // init task list + // 初始化任务列表 + for (int i = 0; i < jsTaskLists.length(); i++) { + //再次遍历任务列表，逐个处理每个任务列表 + JSONObject object = jsTaskLists.getJSONObject(i); + String gid = object.getString(GTaskStringUtils.GTASK_JSON_ID); + String name = object.getString(GTaskStringUtils.GTASK_JSON_NAME); + // 检查是否是 MIUI 文件夹前缀的任务列表 + if (name.startsWith(GTaskStringUtils.MIUI_FOLDER_PREFFIX) + && !name.equals(GTaskStringUtils.MIUI_FOLDER_PREFFIX + + GTaskStringUtils.FOLDER_META)) { + //检查当前任务列表是否是 MIUI 文件夹前缀的任务列表，并且不是元数据列表。如果是，则初始化任务列表并加载任务 + TaskList tasklist = new TaskList(); + tasklist.setContentByRemoteJSON(object); + mGTaskListHashMap.put(gid, tasklist); + mGTaskHashMap.put(gid, tasklist); + + // load tasks + // 加载任务 + JSONArray jsTasks = client.getTaskList(gid); + for (int j = 0; j < jsTasks.length(); j++) { + //遍历任务列表，逐个处理每个任务。 + object = (JSONObject) jsTasks.getJSONObject(j); + gid = object.getString(GTaskStringUtils.GTASK_JSON_ID); + Task task = new Task(); + task.setContentByRemoteJSON(object); + if (task.isWorthSaving()) { + //检查任务是否值得保存。如果值得保存，则将其添加到任务列表中，并更新 mGTaskHashMap。 + task.setMetaInfo(mMetaHashMap.get(gid)); + tasklist.addChildTask(task); + mGTaskHashMap.put(gid, task); + } + } + } + } + } catch (JSONException e) { + // 处理 JSON 解析异常 + Log.e(TAG, e.toString()); + e.printStackTrace(); + throw new ActionFailureException("initGTaskList: handing JSONObject failed"); + } + } +/* + * 同步内容。 + * 该方法负责同步本地数据库中的笔记与 Google Tasks 中的任务。 + * @throws NetworkFailureException 如果网络操作失败 + */ + private void syncContent() throws NetworkFailureException { + int syncType; + Cursor c = null; + String gid; + Node node; + // 清空本地删除的笔记 ID 集合 + mLocalDeleteIdMap.clear(); + // 检查是否已经取消同步。如果 mCancelled 为 true，则直接返回，不执行后续操作。 + if (mCancelled) { + return; + } + + // for local deleted note + // 处理本地删除的笔记 + //使用 try-finally 结构确保在查询结束后关闭游标。 + try { + c = mContentResolver.query(Notes.CONTENT_NOTE_URI, SqlNote.PROJECTION_NOTE, + "(type<>? AND parent_id=?)", new String[] { + String.valueOf(Notes.TYPE_SYSTEM), String.valueOf(Notes.ID_TRASH_FOLER) + }, null); + //查询本地删除的笔记。查询条件为 type 不等于 Notes.TYPE_SYSTEM 且 parent_id 等于 Notes.ID_TRASH_FOLER。 + if (c != null) { + //检查查询结果是否为空。如果不为空，则遍历查询结果。 + while (c.moveToNext()) { + //遍历查询结果，逐个处理每个笔记。 + gid = c.getString(SqlNote.GTASK_ID_COLUMN); + //获取当前笔记的 Google Task ID。 + node = mGTaskHashMap.get(gid); + //从 mGTaskHashMap 中获取对应的节点。 + if (node != null) { + //检查节点是否存在。如果存在，则从 mGTaskHashMap 中移除该节点，并执行远程删除操作。 + mGTaskHashMap.remove(gid); + doContentSync(Node.SYNC_ACTION_DEL_REMOTE, node, c); + //执行远程删除操作。 + } + + mLocalDeleteIdMap.add(c.getLong(SqlNote.ID_COLUMN)); + //将当前笔记的本地 ID 添加到 mLocalDeleteIdMap 中。 + } + } else { + Log.w(TAG, "failed to query trash folder"); + } + } finally { + if (c != null) { + c.close(); + c = null; + } + } + + // sync folder first + syncFolder(); + + // for note existing in database + // 处理数据库中存在的笔记 + try { + c = mContentResolver.query(Notes.CONTENT_NOTE_URI, SqlNote.PROJECTION_NOTE, + "(type=? AND parent_id<>?)", new String[] { + String.valueOf(Notes.TYPE_NOTE), String.valueOf(Notes.ID_TRASH_FOLER) + }, NoteColumns.TYPE + " DESC"); + //查询数据库中存在的笔记。查询条件为 type 等于 Notes.TYPE_NOTE 且 parent_id 不等于 Notes.ID_TRASH_FOLER。 + if (c != null) { + //检查查询结果是否为空。如果不为空，则遍历查询结果。 + while (c.moveToNext()) { + //遍历查询结果，逐个处理每个笔记。 + gid = c.getString(SqlNote.GTASK_ID_COLUMN); + //获取当前笔记的 Google Task ID。 + node = mGTaskHashMap.get(gid); + //从 mGTaskHashMap 中获取对应的节点。 + if (node != null) { + //检查节点是否存在。如果存在，则从 mGTaskHashMap 中移除该节点，并更新 mGidToNid 和 mNidToGid 映射，然后获取同步操作类型。 + mGTaskHashMap.remove(gid); + mGidToNid.put(gid, c.getLong(SqlNote.ID_COLUMN)); + //更新 Google Task ID 到本地笔记 ID 的映射。 + mNidToGid.put(c.getLong(SqlNote.ID_COLUMN), gid); + //更新本地笔记 ID 到 Google Task ID 的映射。 + syncType = node.getSyncAction(c); + //获取当前笔记的同步操作类型。 + } else { + //如果节点不存在，则根据 Google Task ID 是否为空来确定同步操作类型。 + if (c.getString(SqlNote.GTASK_ID_COLUMN).trim().length() == 0) { + // local add + // 本地添加 + //检查 Google Task ID 是否为空。如果为空，则表示本地添加操作。 + syncType = Node.SYNC_ACTION_ADD_REMOTE; + //设置同步操作类型为远程添加。 + } else { + // remote delete + // 远程删除 + syncType = Node.SYNC_ACTION_DEL_LOCAL; + } + } + doContentSync(syncType, node, c);//执行同步操作。 + } + } else { + Log.w(TAG, "failed to query existing note in database"); + } + + } finally { + if (c != null) { + c.close(); + c = null; + } + } + + // go through remaining items + // 处理剩余的项目 + Iterator> iter = mGTaskHashMap.entrySet().iterator(); + //获取 mGTaskHashMap 的迭代器。 + while (iter.hasNext()) { + //遍历 mGTaskHashMap，逐个处理剩余的项目。 + Map.Entry entry = iter.next(); + //获取当前的键值对。 + node = entry.getValue(); + doContentSync(Node.SYNC_ACTION_ADD_LOCAL, node, null); + //执行本地添加操作 + } + + // mCancelled can be set by another thread, so we neet to check one by + // one + // clear local delete table + // 检查是否已经取消同步 + if (!mCancelled) { + // 批量删除本地删除的笔记 + if (!DataUtils.batchDeleteNotes(mContentResolver, mLocalDeleteIdMap)) { + throw new ActionFailureException("failed to batch-delete local deleted notes"); + } + //批量删除本地删除的笔记。如果删除失败，则抛出 ActionFailureException。 + } + + // refresh local sync id + // 刷新本地同步 ID + if (!mCancelled) { + GTaskClient.getInstance().commitUpdate(); + refreshLocalSyncId(); + } + + } +/* + * 同步文件夹。 + * 该方法负责同步本地数据库中的文件夹与 Google Tasks 中的任务列表。 + * @throws NetworkFailureException 如果网络操作失败 + */ + private void syncFolder() throws NetworkFailureException { + Cursor c = null; + String gid; + Node node; + int syncType; + //检查是否已经取消同步。如果 mCancelled 为 true，则直接返回，不执行后续操作。 + if (mCancelled) { + return; + } + + // for root folder + //处理根文件夹。 + try { + c = mContentResolver.query(ContentUris.withAppendedId(Notes.CONTENT_NOTE_URI, + Notes.ID_ROOT_FOLDER), SqlNote.PROJECTION_NOTE, null, null, null); + //查询根文件夹。查询条件为 _id 等于 Notes.ID_ROOT_FOLDER。 + if (c != null) { + //检查查询结果是否为空。如果不为空，则处理查询结果。 + c.moveToNext(); + //移动游标到下一行。 + gid = c.getString(SqlNote.GTASK_ID_COLUMN); + //获取当前文件夹的 Google Task ID。 + node = mGTaskHashMap.get(gid); + //从 mGTaskHashMap 中获取对应的节点。 + if (node != null) { + //检查节点是否存在。如果存在，则从 mGTaskHashMap 中移除该节点，并更新 mGidToNid 和 mNidToGid 映射。 + mGTaskHashMap.remove(gid); + mGidToNid.put(gid, (long) Notes.ID_ROOT_FOLDER); + //更新 Google Task ID 到本地笔记 ID 的映射。 + mNidToGid.put((long) Notes.ID_ROOT_FOLDER, gid); + // for system folder, only update remote name if necessary + //更新本地笔记 ID 到 Google Task ID 的映射。 + if (!node.getName().equals( + GTaskStringUtils.MIUI_FOLDER_PREFFIX + GTaskStringUtils.FOLDER_DEFAULT)) + doContentSync(Node.SYNC_ACTION_UPDATE_REMOTE, node, c); + //检查节点名称是否需要更新。如果需要更新，则执行远程更新操作。 + } else { + doContentSync(Node.SYNC_ACTION_ADD_REMOTE, node, c);//执行远程更新操作。 + } + } else { + Log.w(TAG, "failed to query root folder"); + } + } finally { + if (c != null) { + c.close(); + c = null; + } + } + + // for call-note folder + //处理通话记录文件夹。 + try { + c = mContentResolver.query(Notes.CONTENT_NOTE_URI, SqlNote.PROJECTION_NOTE, "(_id=?)", + new String[] { + String.valueOf(Notes.ID_CALL_RECORD_FOLDER) + }, null); + //查询通话记录文件夹。查询条件为 _id 等于 Notes.ID_CALL_RECORD_FOLDER。 + if (c != null) { + //检查查询结果是否为空。如果不为空，则处理查询结果。 + if (c.moveToNext()) { + gid = c.getString(SqlNote.GTASK_ID_COLUMN); + node = mGTaskHashMap.get(gid); + if (node != null) { + //检查节点是否存在。如果存在，则从 mGTaskHashMap 中移除该节点，并更新 mGidToNid 和 mNidToGid 映射。 + mGTaskHashMap.remove(gid); + mGidToNid.put(gid, (long) Notes.ID_CALL_RECORD_FOLDER); + mNidToGid.put((long) Notes.ID_CALL_RECORD_FOLDER, gid); + // for system folder, only update remote name if + // necessary + if (!node.getName().equals( + GTaskStringUtils.MIUI_FOLDER_PREFFIX + + GTaskStringUtils.FOLDER_CALL_NOTE)) + doContentSync(Node.SYNC_ACTION_UPDATE_REMOTE, node, c); + //检查节点名称是否需要更新。如果需要更新，则执行远程更新操作。 + } else { + //如果节点不存在，则执行远程添加操作。 + doContentSync(Node.SYNC_ACTION_ADD_REMOTE, node, c); + } + } + } else { + Log.w(TAG, "failed to query call note folder"); + } + } finally { + if (c != null) { + c.close(); + c = null; + } + } + + // for local existing folders + //处理本地存在的文件夹。 + try { + c = mContentResolver.query(Notes.CONTENT_NOTE_URI, SqlNote.PROJECTION_NOTE, + "(type=? AND parent_id<>?)", new String[] { + String.valueOf(Notes.TYPE_FOLDER), String.valueOf(Notes.ID_TRASH_FOLER) + }, NoteColumns.TYPE + " DESC"); + //查询本地存在的文件夹。查询条件为 type 等于 Notes.TYPE_FOLDER 且 parent_id 不等于 Notes.ID_TRASH_FOLER。 + if (c != null) { + //检查查询结果是否为空。如果不为空，则遍历查询结果。 + while (c.moveToNext()) { + //遍历查询结果，逐个处理每个文件夹。 + gid = c.getString(SqlNote.GTASK_ID_COLUMN); + node = mGTaskHashMap.get(gid); + if (node != null) { + //检查节点是否存在。如果存在，则从 mGTaskHashMap 中移除该节点，并更新 mGidToNid 和 mNidToGid 映射，然后获取同步操作类型。 + mGTaskHashMap.remove(gid); + mGidToNid.put(gid, c.getLong(SqlNote.ID_COLUMN)); + mNidToGid.put(c.getLong(SqlNote.ID_COLUMN), gid); + syncType = node.getSyncAction(c); + } else { + //如果节点不存在，则根据 Google Task ID 是否为空来确定同步操作类型。 + if (c.getString(SqlNote.GTASK_ID_COLUMN).trim().length() == 0) { + // local add + //检查 Google Task ID 是否为空。如果为空，则表示本地添加操作 + syncType = Node.SYNC_ACTION_ADD_REMOTE; + } else { + //如果 Google Task ID 不为空，则表示远程删除操作。 + // remote delete + syncType = Node.SYNC_ACTION_DEL_LOCAL; + } + } + doContentSync(syncType, node, c); + } + } else { + Log.w(TAG, "failed to query existing folder"); + } + } finally { + if (c != null) { + c.close(); + c = null; + } + } + + // for remote add folders + Iterator> iter = mGTaskListHashMap.entrySet().iterator(); + //获取 mGTaskListHashMap 的迭代器。 + while (iter.hasNext()) { + //遍历 mGTaskListHashMap，逐个处理远程添加的文件夹。 + Map.Entry entry = iter.next(); + //获取当前的键值对 + gid = entry.getKey(); + node = entry.getValue(); + if (mGTaskHashMap.containsKey(gid)) { + //检查 mGTaskHashMap 中是否包含该节点。如果包含，则从 mGTaskHashMap 中移除该节点，并执行本地添加操作。 + mGTaskHashMap.remove(gid); + doContentSync(Node.SYNC_ACTION_ADD_LOCAL, node, null); + } + } + + if (!mCancelled) //检查是否已经取消同步。如果没有取消，则提交更新。 + GTaskClient.getInstance().commitUpdate(); + } +/* + * 执行内容同步操作。 + * 该方法根据同步类型执行相应的同步操作。 + * @param syncType 同步类型 + * @param node 节点对象 + * @param c 游标对象 + * @throws NetworkFailureException 如果网络操作失败 + */ + private void doContentSync(int syncType, Node node, Cursor c) throws NetworkFailureException { + // 检查是否已经取消同步 + if (mCancelled) { + return; + } + + MetaData meta; + //根据同步类型执行相应的同步操作。 + switch (syncType) { + case Node.SYNC_ACTION_ADD_LOCAL: + // 本地添加操作 + addLocalNode(node); + break; + case Node.SYNC_ACTION_ADD_REMOTE: + // 远程添加操作 + addRemoteNode(node, c); + break; + case Node.SYNC_ACTION_DEL_LOCAL: + // 本地删除操作。从 mMetaHashMap 中获取元数据。如果元数据存在，则调用 GTaskClient.getInstance().deleteNode(meta) 方法删除元数据。将本地笔记 ID 添加到 mLocalDeleteIdMap 中。 + meta = mMetaHashMap.get(c.getString(SqlNote.GTASK_ID_COLUMN)); + if (meta != null) { + GTaskClient.getInstance().deleteNode(meta); + } + mLocalDeleteIdMap.add(c.getLong(SqlNote.ID_COLUMN)); + break; + case Node.SYNC_ACTION_DEL_REMOTE: + // 远程删除操作。从 mMetaHashMap 中获取元数据。如果元数据存在，则调用 GTaskClient.getInstance().deleteNode(meta) 方法删除元数据。调用 GTaskClient.getInstance().deleteNode(node) 方法删除节点。 + meta = mMetaHashMap.get(node.getGid()); + if (meta != null) { + GTaskClient.getInstance().deleteNode(meta); + } + GTaskClient.getInstance().deleteNode(node); + break; + case Node.SYNC_ACTION_UPDATE_LOCAL: + // 本地更新操作 + updateLocalNode(node, c); + break; + case Node.SYNC_ACTION_UPDATE_REMOTE: + // 远程更新操作 + updateRemoteNode(node, c); + break; + case Node.SYNC_ACTION_UPDATE_CONFLICT: + // merging both modifications maybe a good idea + // right now just use local update simply + // 更新冲突操作 + // 合并两个修改可能是一个好主意 + // 现在只是简单地使用本地更新 + updateRemoteNode(node, c); + break; + case Node.SYNC_ACTION_NONE: + // 无操作 + break; + case Node.SYNC_ACTION_ERROR: + default: + // 未知同步操作类型 + throw new ActionFailureException("unkown sync action type"); + } + } +/* + * 添加本地节点。 + * 该方法负责将远程节点添加到本地数据库中。 + * @param node 远程节点对象 + * @throws NetworkFailureException 如果网络操作失败 + */ + private void addLocalNode(Node node) throws NetworkFailureException { + if (mCancelled) { + //检查是否已经取消同步。如果 mCancelled 为 true，则直接返回，不执行后续操作。 + return; + } + + SqlNote sqlNote;//声明一个 SqlNote 变量，用于存储本地笔记。 + if (node instanceof TaskList) { + //检查节点是否是任务列表。如果是任务列表，则根据节点的名称创建相应的本地笔记。 + if (node.getName().equals( + GTaskStringUtils.MIUI_FOLDER_PREFFIX + GTaskStringUtils.FOLDER_DEFAULT)) { + //检查节点名称是否是根文件夹。如果是根文件夹，则创建根文件夹的本地笔记。 + sqlNote = new SqlNote(mContext, Notes.ID_ROOT_FOLDER); + } else if (node.getName().equals( + GTaskStringUtils.MIUI_FOLDER_PREFFIX + GTaskStringUtils.FOLDER_CALL_NOTE)) { + //检查节点名称是否是通话记录文件夹。如果是通话记录文件夹，则创建通话记录文件夹的本地笔记。 + sqlNote = new SqlNote(mContext, Notes.ID_CALL_RECORD_FOLDER); + } else { + //其他文件夹。创建新的本地笔记，并设置内容和父节点 ID。 + sqlNote = new SqlNote(mContext); + sqlNote.setContent(node.getLocalJSONFromContent()); + sqlNote.setParentId(Notes.ID_ROOT_FOLDER); + } + } else { + //如果是任务。创建新的本地笔记，并设置内容和父节点 ID。 + sqlNote = new SqlNote(mContext); + JSONObject js = node.getLocalJSONFromContent(); + try { + //处理 JSON 解析异常。 + if (js.has(GTaskStringUtils.META_HEAD_NOTE)) { + //检查是否包含笔记信息。如果包含笔记信息，则检查笔记 ID 是否可用。 + JSONObject note = js.getJSONObject(GTaskStringUtils.META_HEAD_NOTE); + if (note.has(NoteColumns.ID)) { + //检查笔记信息是否包含 ID。如果包含 ID，则检查 ID 是否可用。 + long id = note.getLong(NoteColumns.ID); + if (DataUtils.existInNoteDatabase(mContentResolver, id)) { + // the id is not available, have to create a new one + //检查笔记 ID 是否存在于本地数据库中。如果存在，则移除笔记 ID。 + note.remove(NoteColumns.ID); + } + } + } + + if (js.has(GTaskStringUtils.META_HEAD_DATA)) { + //检查是否包含数据信息。如果包含数据信息，则检查数据 ID 是否可用。 + JSONArray dataArray = js.getJSONArray(GTaskStringUtils.META_HEAD_DATA); + for (int i = 0; i < dataArray.length(); i++) { + //遍历数据信息，逐个处理每个数据。 + JSONObject data = dataArray.getJSONObject(i); + //获取当前数据信息。 + if (data.has(DataColumns.ID)) { + //检查数据信息是否包含 ID。如果包含 ID，则检查 ID 是否可用。 + long dataId = data.getLong(DataColumns.ID); + if (DataUtils.existInDataDatabase(mContentResolver, dataId)) { + // the data id is not available, have to create + // a new one + //检查数据 ID 是否存在于本地数据库中。如果存在，则移除数据 ID。 + data.remove(DataColumns.ID); + } + } + } + + } + } catch (JSONException e) { + Log.w(TAG, e.toString()); + e.printStackTrace(); + } + sqlNote.setContent(js);//设置本地笔记的内容。 + + Long parentId = mGidToNid.get(((Task) node).getParent().getGid()); + //获取父节点的本地 ID。 + if (parentId == null) { + //检查父节点的本地 ID 是否存在。如果不存在，则抛出 ActionFailureException 异常。 + Log.e(TAG, "cannot find task's parent id locally"); + throw new ActionFailureException("cannot add local node"); + } + sqlNote.setParentId(parentId.longValue()); + } + + // create the local node + sqlNote.setGtaskId(node.getGid());//更新 Google Task ID 到本地笔记 ID 的映射。 + sqlNote.commit(false); + + // update gid-nid mapping + mGidToNid.put(node.getGid(), sqlNote.getId());//更新本地笔记 ID 到 Google Task ID 的映射。 + mNidToGid.put(sqlNote.getId(), node.getGid()); + + // update meta + updateRemoteMeta(node.getGid(), sqlNote);//更新元数据。 + } +/* + * 更新本地节点。 + * 该方法负责将远程节点的更新同步到本地数据库中。 + * @param node 远程节点对象 + * @param c 游标对象 + * @throws NetworkFailureException 如果网络操作失败 + */ + private void updateLocalNode(Node node, Cursor c) throws NetworkFailureException { + if (mCancelled) { + //检查是否已经取消同步。如果 mCancelled 为 true，则直接返回，不执行后续操作。 + return; + } + + SqlNote sqlNote; + // update the note locally + //声明一个 SqlNote 变量，用于存储本地笔记。 + sqlNote = new SqlNote(mContext, c); + //创建一个新的 SqlNote 对象，并使用游标 c 初始化。 + sqlNote.setContent(node.getLocalJSONFromContent()); + //设置本地笔记的内容为远程节点的本地 JSON 内容。 + Long parentId = (node instanceof Task) ? mGidToNid.get(((Task) node).getParent().getGid()) + : new Long(Notes.ID_ROOT_FOLDER); + //获取父节点的本地 ID。如果节点是任务，则从 mGidToNid 映射中获取父节点的本地 ID。如果节点不是任务，则将父节点 ID 设置为根文件夹的 ID。 + if (parentId == null) { + //检查父节点的本地 ID 是否存在。如果不存在，则记录错误日志并抛出 ActionFailureException 异常。 + Log.e(TAG, "cannot find task's parent id locally"); + throw new ActionFailureException("cannot update local node"); + } + sqlNote.setParentId(parentId.longValue());//设置本地笔记的父节点 ID。 + sqlNote.commit(true);//提交本地笔记的更新。 + + // update meta info + //更新元数据信息。 + updateRemoteMeta(node.getGid(), sqlNote); + } +/* + * 添加远程节点。 + * 该方法负责将本地笔记添加到 Google Tasks 中。 + * @param node 远程节点对象 + * @param c 游标对象 + * @throws NetworkFailureException 如果网络操作失败 + */ + private void addRemoteNode(Node node, Cursor c) throws NetworkFailureException { + if (mCancelled) { + //检查是否已经取消同步。如果 mCancelled 为 true，则直接返回，不执行后续操作。 + return; + } + + SqlNote sqlNote = new SqlNote(mContext, c); + //创建一个新的 SqlNote 对象，并使用游标 c 初始化。 + Node n; + //声明一个 Node 变量，用于存储远程节点 + + // update remotely + if (sqlNote.isNoteType()) { + //检查本地笔记是否是笔记类型。如果是笔记类型，则创建一个新的 Task 对象，并设置内容。 + Task task = new Task(); + task.setContentByLocalJSON(sqlNote.getContent()); + + String parentGid = mNidToGid.get(sqlNote.getParentId()); + if (parentGid == null) { + //检查父任务列表的 Google Task ID 是否存在。如果不存在，则记录错误日志并抛出 ActionFailureException 异常。 + Log.e(TAG, "cannot find task's parent tasklist"); + throw new ActionFailureException("cannot add remote task"); + } + mGTaskListHashMap.get(parentGid).addChildTask(task); + //将任务添加到父任务列表中。 + + GTaskClient.getInstance().createTask(task); + //创建远程任务。 + n = (Node) task; + //将 Task 对象赋值给 Node 变量。 + + // add meta + //添加元数据。 + updateRemoteMeta(task.getGid(), sqlNote); + } else { + //如果是文件夹类型。创建一个新的 TaskList 对象，并设置内容。 + TaskList tasklist = null; + + // we need to skip folder if it has already existed + String folderName = GTaskStringUtils.MIUI_FOLDER_PREFFIX;//初始化文件夹名称 + if (sqlNote.getId() == Notes.ID_ROOT_FOLDER) + //检查本地笔记的 ID 是否是根文件夹的 ID。如果是根文件夹，则设置文件夹名称为默认文件夹名称。 + folderName += GTaskStringUtils.FOLDER_DEFAULT; + else if (sqlNote.getId() == Notes.ID_CALL_RECORD_FOLDER) + //检查本地笔记的 ID 是否是通话记录文件夹的 ID。如果是通话记录文件夹，则设置文件夹名称为通话记录文件夹名称。 + folderName += GTaskStringUtils.FOLDER_CALL_NOTE; + else + //其他文件夹。设置文件夹名称为本地笔记的片段。 + folderName += sqlNote.getSnippet(); + + Iterator> iter = mGTaskListHashMap.entrySet().iterator(); + while (iter.hasNext()) { + //遍历 mGTaskListHashMap，查找匹配的文件夹。 + Map.Entry entry = iter.next(); + String gid = entry.getKey(); + TaskList list = entry.getValue(); + + if (list.getName().equals(folderName)) { + //检查任务列表的名称是否与文件夹名称匹配。如果匹配，则将任务列表赋值给 tasklist 变量，并从 mGTaskHashMap 中移除该节点。 + tasklist = list; + if (mGTaskHashMap.containsKey(gid)) { + //检查 mGTaskHashMap 中是否包含该节点。如果包含，则从 mGTaskHashMap 中移除该节点。 + mGTaskHashMap.remove(gid); + } + break; + } + } + + // no match we can add now + if (tasklist == null) { + //如果没有匹配的文件夹，则可以添加。创建一个新的 TaskList 对象，并设置内容。 + tasklist = new TaskList(); + tasklist.setContentByLocalJSON(sqlNote.getContent()); + GTaskClient.getInstance().createTaskList(tasklist); + mGTaskListHashMap.put(tasklist.getGid(), tasklist); + } + n = (Node) tasklist;//将 TaskList 对象赋值给 Node 变量。 + } + + // update local note + sqlNote.setGtaskId(n.getGid());//设置本地笔记的 Google Task ID + sqlNote.commit(false);//提交本地笔记的更新。 + sqlNote.resetLocalModified();//重置本地笔记的修改标志。 + sqlNote.commit(true);//重置本地笔记的修改标志。 + + // gid-id mapping + mGidToNid.put(n.getGid(), sqlNote.getId());//更新 Google Task ID 到本地笔记 ID 的映射。 + mNidToGid.put(sqlNote.getId(), n.getGid());//更新本地笔记 ID 到 Google Task ID 的映射。 + } +/* + * 更新远程节点。 + * 该方法负责将本地笔记的更新同步到 Google Tasks 中。 + * @param node 远程节点对象 + * @param c 游标对象 + * @throws NetworkFailureException 如果网络操作失败 + */ + private void updateRemoteNode(Node node, Cursor c) throws NetworkFailureException { + if (mCancelled) { + //检查是否已经取消同步。如果 mCancelled 为 true，则直接返回，不执行后续操作。 + return; + } + + SqlNote sqlNote = new SqlNote(mContext, c);//创建一个新的 SqlNote 对象，并使用游标 c 初始化。 + + // update remotely + //使用本地笔记的内容更新远程节点的内容。 + node.setContentByLocalJSON(sqlNote.getContent()); + GTaskClient.getInstance().addUpdateNode(node); + //将更新后的节点添加到 GTaskClient 的更新列表中。 + + // update meta + //更新元数据。 + updateRemoteMeta(node.getGid(), sqlNote); + + // move task if necessary + if (sqlNote.isNoteType()) { + //检查本地笔记是否是笔记类型。如果是笔记类型，则处理任务的移动 + Task task = (Task) node; + TaskList preParentList = task.getParent(); + + String curParentGid = mNidToGid.get(sqlNote.getParentId()); + if (curParentGid == null) { + //检查父任务列表的 Google Task ID 是否存在。如果不存在，则记录错误日志并抛出 ActionFailureException 异常。 + Log.e(TAG, "cannot find task's parent tasklist"); + throw new ActionFailureException("cannot update remote task"); + } + TaskList curParentList = mGTaskListHashMap.get(curParentGid); + //获取当前父任务列表。 + if (preParentList != curParentList) { + //检查任务的当前父任务列表是否与当前父任务列表不同。如果不同，则从当前父任务列表中移除任务，并将其添加到新的父任务列表中。 + preParentList.removeChildTask(task); + curParentList.addChildTask(task); + GTaskClient.getInstance().moveTask(task, preParentList, curParentList); + } + } + + // clear local modified flag + sqlNote.resetLocalModified();//清除本地笔记的修改标志。 + sqlNote.commit(true);//提交本地笔记的更新。 + } +/* + * 更新远程元数据。 + * 该方法负责将本地笔记的元数据同步到 Google Tasks 中。 + * @param gid Google Task ID + * @param sqlNote 本地笔记对象 + * @throws NetworkFailureException 如果网络操作失败 + */ + private void updateRemoteMeta(String gid, SqlNote sqlNote) throws NetworkFailureException { + // 检查本地笔记是否为空且是笔记类型 + if (sqlNote != null && sqlNote.isNoteType()) { + // 从元数据哈希表中获取元数据 + MetaData metaData = mMetaHashMap.get(gid); + if (metaData != null) { + // 如果元数据存在，则更新元数据 + metaData.setMeta(gid, sqlNote.getContent()); + GTaskClient.getInstance().addUpdateNode(metaData); + } else { + // 如果元数据不存在，则创建新的元数据 + metaData = new MetaData(); + metaData.setMeta(gid, sqlNote.getContent()); + mMetaList.addChildTask(metaData); + mMetaHashMap.put(gid, metaData); + GTaskClient.getInstance().createTask(metaData); + } + } + } +/* + * 刷新本地同步 ID。 + * 该方法负责刷新本地笔记的同步 ID，确保本地笔记的同步 ID 与 Google Tasks 中的最新数据一致。 + * @throws NetworkFailureException 如果网络操作失败 + */ + private void refreshLocalSyncId() throws NetworkFailureException { + // 检查是否已经取消同步。如果 mCancelled 为 true，则直接返回，不执行后续操作。 + if (mCancelled) { + return; + } + + // get the latest gtask list + mGTaskHashMap.clear();//清空 mGTaskHashMap + mGTaskListHashMap.clear();//清空 mGTaskListHashMap。 + mMetaHashMap.clear();//清空 mMetaHashMap。 + initGTaskList();//初始化 Google Task 列表。 + + Cursor c = null;//声明一个游标变量 c，用于存储查询结果。 + try { + c = mContentResolver.query(Notes.CONTENT_NOTE_URI, SqlNote.PROJECTION_NOTE, + "(type<>? AND parent_id<>?)", new String[] { + //查询本地笔记。查询条件为 type 不等于 Notes.TYPE_SYSTEM 且 parent_id 不等于 Notes.ID_TRASH_FOLER。 + String.valueOf(Notes.TYPE_SYSTEM), String.valueOf(Notes.ID_TRASH_FOLER) + }, NoteColumns.TYPE + " DESC"); + if (c != null) { + //检查查询结果是否为空。如果不为空，则遍历查询结果。 + while (c.moveToNext()) { + //遍历查询结果，逐个处理每个笔记。 + String gid = c.getString(SqlNote.GTASK_ID_COLUMN); + Node node = mGTaskHashMap.get(gid); + if (node != null) { + //检查节点是否存在。如果存在，则从 mGTaskHashMap 中移除该节点，并更新本地笔记的同步 ID。 + mGTaskHashMap.remove(gid); + ContentValues values = new ContentValues(); + values.put(NoteColumns.SYNC_ID, node.getLastModified()); + mContentResolver.update(ContentUris.withAppendedId(Notes.CONTENT_NOTE_URI, + c.getLong(SqlNote.ID_COLUMN)), values, null, null); + } else { + //如果节点不存在，则记录错误日志并抛出 ActionFailureException 异常。 + Log.e(TAG, "something is missed"); + throw new ActionFailureException( + "some local items don't have gid after sync"); + } + } + } else { + Log.w(TAG, "failed to query local note to refresh sync id"); + } + } finally { + if (c != null) { + //检查游标是否为空。如果不为空，则关闭游标。 + c.close(); + c = null; + } + } + } +/* + * 获取同步账户名称。 + * 该方法返回当前用于同步的 Google 账户名称。 + * @return 同步账户名称 + */ + public String getSyncAccount() { + // 获取 GTaskClient 的单例实例，并返回同步账户的名称 + return GTaskClient.getInstance().getSyncAccount().name; + } +/* + * 取消同步。 + * 该方法用于设置取消同步标志，以便在同步过程中停止同步操作。 + */ + public void cancelSync() { + // 设置取消同步标志为 true + mCancelled = true; + } +} diff --git a/GTaskSyncService.txt b/GTaskSyncService.txt new file mode 100644 index 0000000..a20653c --- /dev/null +++ b/GTaskSyncService.txt @@ -0,0 +1,198 @@ +/* + * 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.remote; + +import android.app.Activity; +import android.app.Service; +import android.content.Context; +import android.content.Intent; +import android.os.Bundle; +import android.os.IBinder; +/* + * GTaskSyncService类是一个服务类，用于处理Google任务的同步操作。 + * 该类继承自Service，并在后台执行同步任务。 + */ +public class GTaskSyncService extends Service { + public final static String ACTION_STRING_NAME = "sync_action_type"; + + public final static int ACTION_START_SYNC = 0; + + public final static int ACTION_CANCEL_SYNC = 1; + + public final static int ACTION_INVALID = 2; + + public final static String GTASK_SERVICE_BROADCAST_NAME = "net.micode.notes.gtask.remote.gtask_sync_service"; + + public final static String GTASK_SERVICE_BROADCAST_IS_SYNCING = "isSyncing"; + + public final static String GTASK_SERVICE_BROADCAST_PROGRESS_MSG = "progressMsg"; + + private static GTaskASyncTask mSyncTask = null; + + private static String mSyncProgress = ""; +/* + * 启动同步操作。 + */ + private void startSync() { + // 如果同步任务尚未启动 + if (mSyncTask == null) { + // 创建一个新的GTaskASyncTask对象 + mSyncTask = new GTaskASyncTask(this, new GTaskASyncTask.OnCompleteListener() { + public void onComplete() { + // 同步任务完成后，将mSyncTask置为null + mSyncTask = null; + // 发送广播通知同步完成 + sendBroadcast(""); + // 停止服务 + stopSelf(); + } + }); + // 发送广播通知同步开始 + sendBroadcast(""); + // 执行同步任务 + mSyncTask.execute(); + } + } +/* + * 取消同步操作。 + */ + private void cancelSync() { + // 如果同步任务正在执行 + if (mSyncTask != null) { + // 调用cancelSync方法取消同步 + mSyncTask.cancelSync(); + } + } +/* + * 服务创建时调用，初始化同步任务。 + */ + @Override + public void onCreate() { + // 将同步任务置为null + mSyncTask = null; + } +/* + * 服务启动时调用，处理启动和取消同步的命令。 + * @param intent 启动服务的意图 + * @param flags 启动标志 + * @param startId 启动ID + * @return 服务启动模式 + */ + @Override + public int onStartCommand(Intent intent, int flags, int startId) { + // 获取意图中的额外数据 + Bundle bundle = intent.getExtras(); + // 如果额外数据不为空且包含ACTION_STRING_NAME + if (bundle != null && bundle.containsKey(ACTION_STRING_NAME)) { + // 根据ACTION_STRING_NAME的值执行相应的操作 + switch (bundle.getInt(ACTION_STRING_NAME, ACTION_INVALID)) { + case ACTION_START_SYNC: + // 启动同步操作 + startSync(); + break; + case ACTION_CANCEL_SYNC: + // 取消同步操作 + cancelSync(); + break; + default: + break; + } + // 返回START_STICKY，表示服务在异常终止后会自动重启 + return START_STICKY; + } + // 如果额外数据为空或不包含ACTION_STRING_NAME，调用父类的onStartCommand方法 + return super.onStartCommand(intent, flags, startId); + } +/* + * 内存不足时调用，取消同步任务。 + */ + @Override + public void onLowMemory() { + // 如果同步任务正在执行 + if (mSyncTask != null) { + // 调用cancelSync方法取消同步 + mSyncTask.cancelSync(); + } + } +/* + * 绑定服务时调用，返回null。 + * @param intent 绑定服务的意图 + * @return null + */ + public IBinder onBind(Intent intent) { + // 返回null，表示不支持绑定服务 + return null; + } +/* + * 发送广播，通知同步状态和进度。 + * @param msg 进度消息 + */ + public void sendBroadcast(String msg) { + // 更新同步进度字符串 + mSyncProgress = msg; + // 创建一个新的Intent对象，用于发送广播 + Intent intent = new Intent(GTASK_SERVICE_BROADCAST_NAME); + // 添加是否正在同步的标志 + intent.putExtra(GTASK_SERVICE_BROADCAST_IS_SYNCING, mSyncTask != null); + // 添加进度消息 + intent.putExtra(GTASK_SERVICE_BROADCAST_PROGRESS_MSG, msg); + // 发送广播 + sendBroadcast(intent); + } +/* + * 启动同步操作的静态方法。 + * @param activity 启动同步的Activity + */ + public static void startSync(Activity activity) { + // 设置活动上下文 + GTaskManager.getInstance().setActivityContext(activity); + // 创建一个新的Intent对象，用于启动服务 + Intent intent = new Intent(activity, GTaskSyncService.class); + // 添加启动同步的命令 + intent.putExtra(GTaskSyncService.ACTION_STRING_NAME, GTaskSyncService.ACTION_START_SYNC); + // 启动服务 + activity.startService(intent); + } +/* + * 取消同步操作的静态方法。 + * @param context 取消同步的上下文 + */ + public static void cancelSync(Context context) { + // 创建一个新的Intent对象，用于启动服务 + Intent intent = new Intent(context, GTaskSyncService.class); + // 添加取消同步的命令 + intent.putExtra(GTaskSyncService.ACTION_STRING_NAME, GTaskSyncService.ACTION_CANCEL_SYNC); + // 启动服务 + context.startService(intent); + } +/* + * 检查是否正在同步。 + * @return 如果正在同步，返回true；否则返回false + */ + public static boolean isSyncing() { + // 如果mSyncTask不为null，表示正在同步 + return mSyncTask != null; + } +/* + * 获取同步进度字符串。 + * @return 同步进度字符串 + */ + public static String getProgressString() { + // 返回当前的同步进度字符串 + return mSyncProgress; + } +} diff --git a/MetaData.txt b/MetaData.txt new file mode 100644 index 0000000..eb000f7 --- /dev/null +++ b/MetaData.txt @@ -0,0 +1,115 @@ +/* + * 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.database.Cursor; +import android.util.Log; + +import net.micode.notes.tool.GTaskStringUtils; + +import org.json.JSONException; +import org.json.JSONObject; + +/* + *MetaData 类继承自 Task 类，用于处理与 Google Task 相关的元数据。 + * 该类主要用于存储和获取与 Google Task 相关的元数据信息。 + */ +public class MetaData extends Task { + private final static String TAG = MetaData.class.getSimpleName(); + + private String mRelatedGid = null; // 相关 Google Task 的 ID +/* + * 设置元数据信息。 + * 该方法用于将 Google Task 的 ID 和元数据信息存储到任务的备注字段中。 + * @param gid Google Task 的 ID。 + * @param metaInfo 元数据信息的 JSON 对象。 + */ + public void setMeta(String gid, JSONObject metaInfo) { + try { + metaInfo.put(GTaskStringUtils.META_HEAD_GTASK_ID, gid); // 将 Google Task 的 ID 添加到元数据信息中 + } catch (JSONException e) { + Log.e(TAG, "failed to put related gid"); // 记录日志，添加失败 + } + setNotes(metaInfo.toString()); // 将元数据信息存储到任务的备注字段中 + setName(GTaskStringUtils.META_NOTE_NAME); // 设置任务的名称为元数据名称 + } +/* + * 获取相关 Google Task 的 ID。 + * @return 返回相关 Google Task 的 ID。 + */ + public String getRelatedGid() { + return mRelatedGid; + } +/* + * 判断任务是否值得保存。 + * 该方法用于判断任务是否包含有效的备注信息。 + * @return 如果任务包含有效的备注信息，则返回 true，否则返回 false。 + */ + @Override + public boolean isWorthSaving() { + return getNotes() != null; + } +/* + * 根据远程 JSON 对象设置任务内容。 + * 该方法用于从远程 JSON 对象中提取元数据信息，并设置相关 Google Task 的 ID。 + * @param js 远程 JSON 对象。 + */ + @Override + public void setContentByRemoteJSON(JSONObject js) { + super.setContentByRemoteJSON(js); // 调用父类方法设置任务内容 + if (getNotes() != null) { + try { + JSONObject metaInfo = new JSONObject(getNotes().trim()); // 解析备注字段中的元数据信息 + mRelatedGid = metaInfo.getString(GTaskStringUtils.META_HEAD_GTASK_ID); // 获取相关 Google Task 的 ID + } catch (JSONException e) { + Log.w(TAG, "failed to get related gid"); // 记录日志，获取失败 + mRelatedGid = null; + } + } + } +/* + * 根据本地 JSON 对象设置任务内容。 + * 该方法不应被调用，因为元数据任务不应从本地 JSON 对象中设置内容。 + * @param js 本地 JSON 对象。 + */ + @Override + public void setContentByLocalJSON(JSONObject js) { + // this function should not be called + // 该方法不应被调用 + throw new IllegalAccessError("MetaData:setContentByLocalJSON should not be called"); + } +/* + * 从任务内容中获取本地 JSON 对象。 + * 该方法不应被调用，因为元数据任务不应生成本地 JSON 对象。 + * @return 抛出异常，表示该方法不应被调用。 + */ + @Override + public JSONObject getLocalJSONFromContent() { + throw new IllegalAccessError("MetaData:getLocalJSONFromContent should not be called"); + } +/* + * 获取同步操作。 + * 该方法不应被调用，因为元数据任务不应进行同步操作。 + * @param c 数据库游标。 + * @return 抛出异常，表示该方法不应被调用。 + */ + @Override + public int getSyncAction(Cursor c) { + throw new IllegalAccessError("MetaData:getSyncAction should not be called"); + } + +} diff --git a/NetworkFailureException.txt b/NetworkFailureException.txt new file mode 100644 index 0000000..cb7efec --- /dev/null +++ b/NetworkFailureException.txt @@ -0,0 +1,43 @@ +/* + * 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.exception; +/* + * 自定义异常类，表示网络操作失败。 + * 继承自Exception，用于在网络操作失败时抛出异常。 + */ +public class NetworkFailureException extends Exception { + private static final long serialVersionUID = 2107610287180234136L; + + public NetworkFailureException() { //默认构造函数。 + super(); + } +/* + * 带错误信息的构造函数。 + * @param paramString 错误信息 + */ + public NetworkFailureException(String paramString) { + super(paramString); + } +/* + * 带错误信息和原因的构造函数。 + * @param paramString 错误信息 + * @param paramThrowable 原因 + */ + public NetworkFailureException(String paramString, Throwable paramThrowable) { + super(paramString, paramThrowable); + } +} diff --git a/Node.txt b/Node.txt new file mode 100644 index 0000000..4a2683b --- /dev/null +++ b/Node.txt @@ -0,0 +1,158 @@ +/* + * 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.database.Cursor; + +import org.json.JSONObject; +/* + * Node 类是一个抽象类，用于表示 Google Task 中的节点。 + * 该类定义了节点的基本属性和操作，并提供了抽象方法供子类实现。 + */ +public abstract class Node { + // 同步操作常量 + public static final int SYNC_ACTION_NONE = 0; // 无操作 + + public static final int SYNC_ACTION_ADD_REMOTE = 1; // 远程添加 + + public static final int SYNC_ACTION_ADD_LOCAL = 2; // 本地添加 + + public static final int SYNC_ACTION_DEL_REMOTE = 3; // 远程删除 + + public static final int SYNC_ACTION_DEL_LOCAL = 4; // 本地删除 + + public static final int SYNC_ACTION_UPDATE_REMOTE = 5; // 远程更新 + + public static final int SYNC_ACTION_UPDATE_LOCAL = 6; // 本地更新 + + public static final int SYNC_ACTION_UPDATE_CONFLICT = 7; // 更新冲突 + + public static final int SYNC_ACTION_ERROR = 8; // 错误 + + private String mGid; // Google Task 的 ID + + private String mName; // 节点名称 + + private long mLastModified; // 最后修改时间 + + private boolean mDeleted; // 是否已删除 +/* + * 构造函数，初始化节点属性。 + */ + public Node() { + mGid = null; + mName = ""; + mLastModified = 0; + mDeleted = false; + } +/* + * 获取创建操作的 JSON 对象。 + * 该方法用于生成创建操作的 JSON 对象。 + * @param actionId 操作 ID。 + * @return 返回创建操作的 JSON 对象。 + */ + public abstract JSONObject getCreateAction(int actionId); +/* + * 获取更新操作的 JSON 对象。 + * 该方法用于生成更新操作的 JSON 对象。 + * @param actionId 操作 ID。 + * @return 返回更新操作的 JSON 对象。 + */ + public abstract JSONObject getUpdateAction(int actionId); +/* + * 根据远程 JSON 对象设置节点内容。 + * 该方法用于从远程 JSON 对象中提取节点内容。 + * @param js 远程 JSON 对象。 + */ + public abstract void setContentByRemoteJSON(JSONObject js); +/* + * 根据本地 JSON 对象设置节点内容。 + * 该方法用于从本地 JSON 对象中提取节点内容。 + * @param js 本地 JSON 对象。 + */ + public abstract void setContentByLocalJSON(JSONObject js); +/* + *从节点内容中获取本地 JSON 对象。 + * 该方法用于将节点内容转换为本地 JSON 对象。 + * @return 返回本地 JSON 对象。 + */ + public abstract JSONObject getLocalJSONFromContent(); +/* + * 获取同步操作。 + * 该方法用于根据数据库游标获取同步操作。 + * @param c 数据库游标。 + * @return 返回同步操作。 + */ + public abstract int getSyncAction(Cursor c); +/* + * 设置 Google Task 的 ID。 + * @param gid Google Task 的 ID。 + */ + public void setGid(String gid) { + this.mGid = gid; + } +/* + * 设置节点名称。 + * @param name 节点名称。 + */ + public void setName(String name) { + this.mName = name; + } +/* + * 设置最后修改时间。 + * @param lastModified 最后修改时间。 + */ + public void setLastModified(long lastModified) { + this.mLastModified = lastModified; + } +/* + * 设置节点是否已删除。 + * @param deleted 是否已删除。 + */ + public void setDeleted(boolean deleted) { + this.mDeleted = deleted; + } +/* + * 获取 Google Task 的 ID + * @return 返回 Google Task 的 ID。 + */ + public String getGid() { + return this.mGid; + } +/* + * 获取节点名称。 + * @return 返回节点名称。 + */ + public String getName() { + return this.mName; + } +/* + * 获取最后修改时间。 + * @return 返回最后修改时间。 + */ + public long getLastModified() { + return this.mLastModified; + } +/* + * 获取节点是否已删除。 + * @return 返回节点是否已删除。 + */ + public boolean getDeleted() { + return this.mDeleted; + } + +} diff --git a/Note.txt b/Note.txt new file mode 100644 index 0000000..7bcca07 --- /dev/null +++ b/Note.txt @@ -0,0 +1,382 @@ +/* + * 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; +import android.content.ContentValues; +import android.content.Context; +import android.content.OperationApplicationException; +import android.net.Uri; +import android.os.RemoteException; +import android.util.Log; + +import net.micode.notes.data.Notes; +import net.micode.notes.data.Notes.CallNote; +import net.micode.notes.data.Notes.DataColumns; +import net.micode.notes.data.Notes.NoteColumns; +import net.micode.notes.data.Notes.TextNote; + +import java.util.ArrayList; + +/* + * Note 类用于管理笔记的创建、更新和同步。 + * 该类提供了创建新笔记、设置笔记内容、同步笔记等功能。 + */ +public class Note { + private ContentValues mNoteDiffValues; + private NoteData mNoteData; + private static final String TAG = "Note"; + /** + * Create a new note id for adding a new note to databases + */ + /* + * 创建一个新的笔记 ID，用于将新笔记添加到数据库中。 + * + * @param context 应用程序上下文 + * @param folderId 文件夹 ID + * @return 新创建的笔记 ID + */ + public static synchronized long getNewNoteId(Context context, long folderId) { + // Create a new note in the database + // 创建一个新的笔记到数据库中 + ContentValues values = new ContentValues(); + //创建一个新的 ContentValues 对象，用于存储笔记的初始值。 + long createdTime = System.currentTimeMillis(); + //获取当前时间戳，作为笔记的创建时间和修改时间。 + values.put(NoteColumns.CREATED_DATE, createdTime); + //将创建时间存储到 ContentValues 对象中。 + values.put(NoteColumns.MODIFIED_DATE, createdTime); + //将修改时间存储到 ContentValues 对象中。 + values.put(NoteColumns.TYPE, Notes.TYPE_NOTE); + //将笔记类型存储到 ContentValues 对象中。 + values.put(NoteColumns.LOCAL_MODIFIED, 1); + //将本地修改标志设置为 1，表示笔记已被修改。 + values.put(NoteColumns.PARENT_ID, folderId); + //将文件夹 ID 存储到 ContentValues 对象中。 + Uri uri = context.getContentResolver().insert(Notes.CONTENT_NOTE_URI, values); + //将 ContentValues 对象插入到数据库中，并返回新创建笔记的 URI。 + long noteId = 0;//初始化笔记 ID 变量。 + try { + //尝试从 URI 中获取笔记 ID。如果发生 NumberFormatException 异常，则记录错误日志，并将笔记 ID 设置为 0。 + noteId = Long.valueOf(uri.getPathSegments().get(1)); + } catch (NumberFormatException e) { + Log.e(TAG, "Get note id error :" + e.toString()); + noteId = 0; + } + if (noteId == -1) { + //检查笔记 ID 是否为 -1。如果为 -1，则抛出 IllegalStateException 异常。 + throw new IllegalStateException("Wrong note id:" + noteId); + } + return noteId;//返回新创建的笔记 ID。 + } +/* + * 构造函数，初始化笔记的差异值和笔记数据。 + */ + public Note() { + //// 初始化笔记的差异值 + mNoteDiffValues = new ContentValues(); + // // 初始化笔记数据 + mNoteData = new NoteData(); + } +/* + * 设置笔记的差异值。 + * @param key 键 + * @param value 值 + */ + public void setNoteValue(String key, String value) { + // 将键值对存储到笔记的差异值中 + mNoteDiffValues.put(key, value); + // 设置本地修改标志为 1，表示笔记已被修改 + mNoteDiffValues.put(NoteColumns.LOCAL_MODIFIED, 1); + // 设置修改时间为当前时间 + mNoteDiffValues.put(NoteColumns.MODIFIED_DATE, System.currentTimeMillis()); + } +/* + * 设置笔记的文本数据。 + * @param key 键 + * @param value 值 + */ + public void setTextData(String key, String value) { + // 调用 NoteData 类的 setTextData 方法，设置文本数据 + mNoteData.setTextData(key, value); + } +/* + * 设置笔记的文本数据 ID。 + * @param id 文本数据 ID + */ + public void setTextDataId(long id) { + // 调用 NoteData 类的 setTextDataId 方法，设置文本数据 ID + mNoteData.setTextDataId(id); + } +/* + * 获取笔记的文本数据 ID。 + * @return 文本数据 ID + */ + public long getTextDataId() { + // 返回 NoteData 类的 mTextDataId 字段 + return mNoteData.mTextDataId; + } +/* + * 设置笔记的通话数据 ID。 + * @param id 通话数据 ID + */ + public void setCallDataId(long id) { + // 调用 NoteData 类的 setCallDataId 方法，设置通话数据 ID + mNoteData.setCallDataId(id); + } +/* + * 设置调用数据的方法。 + * 该方法接受两个参数：一个键和一个值，并将它们传递给 `mNoteData` 对象的 `setCallData` 方法。 + * @param key 用于存储数据的键。 + * @param value 与键关联的值。 + */ + public void setCallData(String key, String value) { + //调用 `mNoteData` 对象的 `setCallData` 方法，并将 `key` 和 `value` 作为参数传递。 + mNoteData.setCallData(key, value); + } +/* + * 检查是否有本地修改的方法。 + * 该方法返回一个布尔值，指示是否有本地修改。如果有本地修改，则返回 true；否则返回 false。 + * 本地修改的判断基于两个条件： + * 1. `mNoteDiffValues` 集合的大小是否大于 0。 + * 2. `mNoteData` 对象是否报告本地修改。 + * @return 如果有本地修改，则返回 true；否则返回 false。 + */ + public boolean isLocalModified() { + // 检查 `mNoteDiffValues` 集合的大小是否大于 0，或者 `mNoteData` 对象是否报告本地修改。 + return mNoteDiffValues.size() > 0 || mNoteData.isLocalModified(); + } +/* + * 同步笔记的方法。 + * 该方法用于将本地修改的笔记数据同步到内容提供者中。 + * @param context 应用程序上下文。 + * @param noteId 笔记的唯一标识符。 + * @return 如果同步成功，则返回 true；否则返回 false。 + * @throws IllegalArgumentException 如果 noteId 小于或等于 0，则抛出此异常。 + */ + public boolean syncNote(Context context, long noteId) { + /// 检查 noteId 是否有效，如果无效则抛出异常。 + if (noteId <= 0) { + throw new IllegalArgumentException("Wrong note id:" + noteId); + } + // 如果没有本地修改，则直接返回 true。 + if (!isLocalModified()) { + return true; + } + + /** + * 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 + * 理论上，一旦数据发生变化，笔记应该在 {@link NoteColumns#LOCAL_MODIFIED} 和 + * {@link NoteColumns#MODIFIED_DATE} 上更新。为了数据安全，即使更新笔记失败，我们也会更新笔记数据信息。 + */ + // 尝试更新笔记数据。 + if (context.getContentResolver().update( + ContentUris.withAppendedId(Notes.CONTENT_NOTE_URI, noteId), mNoteDiffValues, null, + null) == 0) { + // 如果更新失败，记录错误日志。 + Log.e(TAG, "Update note error, should not happen"); + // Do not return, fall through + // 不返回，继续执行。 + } + // 清空 mNoteDiffValues 集合。 + mNoteDiffValues.clear(); + // 如果 mNoteData 有本地修改，并且推送数据到内容提供者失败，则返回 false。 + if (mNoteData.isLocalModified() + && (mNoteData.pushIntoContentResolver(context, noteId) == null)) { + return false; + } + // 如果所有操作成功，则返回 true。 + return true; + } +/* + * 笔记数据类，用于管理笔记的文本数据和通话数据。 + */ + private class NoteData { + private long mTextDataId;// 文本数据的唯一标识符 + + private ContentValues mTextDataValues;// 文本数据的 ContentValues 对象 + + private long mCallDataId; // 通话数据的唯一标识符 + + private ContentValues mCallDataValues; // 通话数据的 ContentValues 对象 + + private static final String TAG = "NoteData";// 日志标签 +/* + * 构造函数，初始化文本数据和通话数据的 ContentValues 对象，并将数据 ID 设置为 0。 + */ + public NoteData() { + mTextDataValues = new ContentValues(); + mCallDataValues = new ContentValues(); + mTextDataId = 0; + mCallDataId = 0; + } +/* + * 检查是否有本地修改的方法。 + * @return 如果有本地修改，则返回 true；否则返回 false。 + */ + boolean isLocalModified() { + return mTextDataValues.size() > 0 || mCallDataValues.size() > 0; + } +/* + * 设置文本数据的唯一标识符。 + * 该方法用于设置文本数据的唯一标识符。如果传入的 id 小于或等于 0，则抛出 IllegalArgumentException 异常。 + * @param id 文本数据的唯一标识符。 + * @throws IllegalArgumentException 如果 id 小于或等于 0，则抛出此异常。 + */ + void setTextDataId(long id) { + // 检查传入的 id 是否有效，如果无效则抛出异常。 + if(id <= 0) { + throw new IllegalArgumentException("Text data id should larger than 0"); + } + mTextDataId = id;// 设置文本数据的唯一标识符。 + } +/* + * 设置通话数据的唯一标识符。 + * 该方法用于设置通话数据的唯一标识符。如果传入的 id 小于或等于 0，则抛出 IllegalArgumentException 异常。 + * @param id 通话数据的唯一标识符。 + * @throws IllegalArgumentException 如果 id 小于或等于 0，则抛出此异常。 + */ + void setCallDataId(long id) { + // 检查传入的 id 是否有效，如果无效则抛出异常。 + if (id <= 0) { + throw new IllegalArgumentException("Call data id should larger than 0"); + } + mCallDataId = id; // 设置通话数据的唯一标识符。 + } +/* + * 设置通话数据的方法。 + * 该方法用于将给定的键值对存储到通话数据的 ContentValues 对象中，并更新笔记的本地修改状态和修改日期。 + * @param key 通话数据的键。 + * @param value 通话数据的值。 + */ + void setCallData(String key, String value) { + // 将给定的键值对存储到通话数据的 ContentValues 对象中。 + mCallDataValues.put(key, value); + // 更新笔记的本地修改状态为 1，表示有本地修改。 + mNoteDiffValues.put(NoteColumns.LOCAL_MODIFIED, 1); + // 更新笔记的修改日期为当前时间。 + mNoteDiffValues.put(NoteColumns.MODIFIED_DATE, System.currentTimeMillis()); + } +/* + *设置文本数据的方法。 + * 该方法用于将给定的键值对存储到文本数据的 ContentValues 对象中，并更新笔记的本地修改状态和修改日期。 + * @param key 文本数据的键。 + * @param value 文本数据的值。 + */ + void setTextData(String key, String value) { + // 将给定的键值对存储到文本数据的 ContentValues 对象中。 + mTextDataValues.put(key, value); + // 更新笔记的本地修改状态为 1，表示有本地修改。 + mNoteDiffValues.put(NoteColumns.LOCAL_MODIFIED, 1); + // 更新笔记的修改日期为当前时间。 + mNoteDiffValues.put(NoteColumns.MODIFIED_DATE, System.currentTimeMillis()); + } +/* + * 将数据推送到内容提供者的方法。 + * 该方法用于将文本数据和通话数据推送到内容提供者中。如果文本数据或通话数据有修改，则将其插入或更新到内容提供者中。 + * @param context 应用程序上下文。 + * @param noteId 笔记的唯一标识符。 + * @return 如果推送成功，则返回 Uri；否则返回 null。 + * @throws IllegalArgumentException 如果 noteId 小于或等于 0，则抛出此异常。 + */ + Uri pushIntoContentResolver(Context context, long noteId) { + // 这是方法的签名，定义了方法的访问修饰符、返回类型、方法名称和参数列表。 + /** + * Check for safety + */ + //检查 noteId 是否有效，如果无效则抛出 + if (noteId <= 0) { + throw new IllegalArgumentException("Wrong note id:" + noteId); + } + //创建一个操作列表，用于批量操作。 + ArrayList operationList = new ArrayList(); + ContentProviderOperation.Builder builder = null; + //如果文本数据有修改，处理文本数据。 + if(mTextDataValues.size() > 0) { + //将笔记 ID 添加到文本数据的 ContentValues 对象中。 + mTextDataValues.put(DataColumns.NOTE_ID, noteId); + //如果文本数据的 ID 为 0，表示是新数据，插入到内容提供者中。 + if (mTextDataId == 0) { + mTextDataValues.put(DataColumns.MIME_TYPE, TextNote.CONTENT_ITEM_TYPE); + Uri uri = context.getContentResolver().insert(Notes.CONTENT_DATA_URI, + mTextDataValues); + try { + setTextDataId(Long.valueOf(uri.getPathSegments().get(1))); + } catch (NumberFormatException e) { + Log.e(TAG, "Insert new text data fail with noteId" + noteId); + mTextDataValues.clear(); + return null; + } + } //如果文本数据的 ID 不为 0，表示是已有数据，更新到内容提供者中。 + else { + builder = ContentProviderOperation.newUpdate(ContentUris.withAppendedId( + Notes.CONTENT_DATA_URI, mTextDataId)); + builder.withValues(mTextDataValues); + operationList.add(builder.build()); + } + mTextDataValues.clear();// 清空文本数据的 ContentValues 对象。 + } + // 如果通话数据有修改，处理通话数据。 + if(mCallDataValues.size() > 0) { + mCallDataValues.put(DataColumns.NOTE_ID, noteId); + //将笔记 ID 添加到通话数据的 ContentValues 对象中。 + //如果通话数据的 ID 为 0，表示是新数据，插入到内容提供者中。 + 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; + } + } //如果通话数据的 ID 不为 0，表示是已有数据，更新到内容提供者中。 + else { + builder = ContentProviderOperation.newUpdate(ContentUris.withAppendedId( + Notes.CONTENT_DATA_URI, mCallDataId)); + builder.withValues(mCallDataValues); + operationList.add(builder.build()); + } + mCallDataValues.clear();//清空通话数据的 ContentValues 对象。 + } + //如果操作列表中有操作，执行批量操作。 + if (operationList.size() > 0) { + //尝试执行批量操作。 + try { + ContentProviderResult[] results = context.getContentResolver().applyBatch( + Notes.AUTHORITY, operationList); + 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; + } + } + return null; + } + } +} diff --git a/Notes.txt b/Notes.txt new file mode 100644 index 0000000..6bff438 --- /dev/null +++ b/Notes.txt @@ -0,0 +1,441 @@ +/* + * 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.net.Uri; +/* + * 定义了与笔记相关的常量和接口 + */ +public class Notes { //内容提供者的授权名称 + public static final String AUTHORITY = "micode_notes"; //日志标签 + public static final String TAG = "Notes"; //笔记类型的常量定义 + public static final int TYPE_NOTE = 0; //普通笔记 + public static final int TYPE_FOLDER = 1; //文件夹 + public static final int TYPE_SYSTEM = 2; //系统文件夹 + + /** + * Following IDs are system folders' identifiers + * {@link Notes#ID_ROOT_FOLDER } is default folder + * {@link Notes#ID_TEMPARAY_FOLDER } is for notes belonging no folder + * {@link Notes#ID_CALL_RECORD_FOLDER} is to store call records + */ + /* + * 系统文件夹的标识符 + * {@link Notes#ID_ROOT_FOLDER }是默认文件夹 + * {@link Notes#ID_TEMPARAY_FOLDER }是用于没有所属文件夹的笔记 + * {@link Notes#ID_CALL_RECORD_FOLDER}是用于存储通话记录的文件夹 + */ + public static final int ID_ROOT_FOLDER = 0; + public static final int ID_TEMPARAY_FOLDER = -1; + 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"; + public static final String INTENT_EXTRA_WIDGET_TYPE = "net.micode.notes.widget_type"; + 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"; + //小部件类型的常量定义 + public static final int TYPE_WIDGET_INVALIDE = -1; //无效的小部件类 + public static final int TYPE_WIDGET_2X = 0; //2x小部件 + public static final int TYPE_WIDGET_4X = 1; //4x小部件 + /* + * 数据类型的常量定义 + */ + public static class DataConstants { + public static final String NOTE = TextNote.CONTENT_ITEM_TYPE; + public static final String CALL_NOTE = CallNote.CONTENT_ITEM_TYPE; + } + + /** + * Uri to query all notes and folders + */ + /* + * Uri用于查询所有的笔记和文件夹 + */ + public static final Uri CONTENT_NOTE_URI = Uri.parse("content://" + AUTHORITY + "/note"); + + /** + * Uri to query data + */ + /* + * Uri用于查询数据 + */ + public static final Uri CONTENT_DATA_URI = Uri.parse("content://" + AUTHORITY + "/data"); + + /* + * 笔记表的列定义 + */ + public interface NoteColumns { + /** + * The unique ID for a row + *

Type: INTEGER (long)

+ */ + /* + * 行的唯一ID + *

类型：INTEGER(long)

+ */ + public static final String ID = "_id"; + + /** + * The parent's id for note or folder + *

Type: INTEGER (long)

+ */ + /* + * 笔记或文件夹的父ID + *

类型：INTEGER (long)

+ */ + public static final String PARENT_ID = "parent_id"; + + /** + * Created data for note or folder + *

Type: INTEGER (long)

+ */ + /* + * 创建日期 + *

类型：INTEGER (long)

+ */ + public static final String CREATED_DATE = "created_date"; + + /** + * Latest modified date + *

Type: INTEGER (long)

+ */ + /* + * 最后修改日期 + *

类型：INTEGER (long)

+ */ + public static final String MODIFIED_DATE = "modified_date"; + + + /** + * Alert date + *

Type: INTEGER (long)

+ */ + /* + * 提醒日期 + *

类型：INTEGER (long)

+ */ + public static final String ALERTED_DATE = "alert_date"; + + /** + * Folder's name or text content of note + *

Type: TEXT

+ */ + /* + * 文件夹的名称或笔记的文本内容 + *

类型：TEXT

+ */ + public static final String SNIPPET = "snippet"; + + /** + * Note's widget id + *

Type: INTEGER (long)

+ */ + /* + * 笔记的小部件ID + *

类型：INTEGER (long)

+ */ + public static final String WIDGET_ID = "widget_id"; + + /** + * Note's widget type + *

Type: INTEGER (long)

+ */ + /* + * 笔记的小部件类型 + *

类型：INTEGER (long)

+ */ + public static final String WIDGET_TYPE = "widget_type"; + + /** + * Note's background color's id + *

Type: INTEGER (long)

+ */ + /* + * 笔记的背景颜色ID + *

类型：INTEGER (long)

+ */ + public static final String BG_COLOR_ID = "bg_color_id"; + + /** + * For text note, it doesn't has attachment, for multi-media + * note, it has at least one attachment + *

Type: INTEGER

+ */ + /* + * 是否包含组件 + *

类型：INTEGER

+ */ + public static final String HAS_ATTACHMENT = "has_attachment"; + + /** + * Folder's count of notes + *

Type: INTEGER (long)

+ */ + /* + * 文件夹中的笔记数量 + *

类型：INTEGER (long)

+ */ + public static final String NOTES_COUNT = "notes_count"; + + /** + * The file type: folder or note + *

Type: INTEGER

+ */ + /* + * 文件类型：文件夹或笔记 + *

类型：INTEGER

+ */ + public static final String TYPE = "type"; + + /** + * The last sync id + *

Type: INTEGER (long)

+ */ + /* + * 最后一次同步的ID + *

类型：INTEGER (long)

+ */ + public static final String SYNC_ID = "sync_id"; + + /** + * Sign to indicate local modified or not + *

Type: INTEGER

+ */ + /* + * 指示是否在本地被修改 + *

类型：INTEGER

+ */ + public static final String LOCAL_MODIFIED = "local_modified"; + + /** + * Original parent id before moving into temporary folder + *

Type : INTEGER

+ */ + /* + * 移动到临时文件夹之前的原始父ID + *

类型：INTEGER

+ */ + public static final String ORIGIN_PARENT_ID = "origin_parent_id"; + + /** + * The gtask id + *

Type : TEXT

+ */ + /* + * gtask ID + *

类型：TEXT

+ */ + public static final String GTASK_ID = "gtask_id"; + + /** + * The version code + *

Type : INTEGER (long)

+ */ + /* + * 版本号 + *

类型：INTEGER (long)

+ */ + public static final String VERSION = "version"; + } + /* + * 数据表的列定义 + */ + public interface DataColumns { + /** + * The unique ID for a row + *

Type: INTEGER (long)

+ */ + /* + * 行的唯一ID + *

类型：INTEGER (long)

+ */ + public static final String ID = "_id"; + + /** + * The MIME type of the item represented by this row. + *

Type: Text

+ */ + /* + * 该行的MIME类型 + *

类型：TEXT

+ */ + public static final String MIME_TYPE = "mime_type"; + + /** + * The reference id to note that this data belongs to + *

Type: INTEGER (long)

+ */ + /* + * 该数据所属的笔记ID + *

类型：INTEGER (long)

+ */ + public static final String NOTE_ID = "note_id"; + + /** + * Created data for note or folder + *

Type: INTEGER (long)

+ */ + /* + * 创建日期 + *

类型：INTEGER (long)

+ */ + public static final String CREATED_DATE = "created_date"; + + /** + * Latest modified date + *

Type: INTEGER (long)

+ */ + /* + * 最后修改日期 + *

类型：INTEGER (long)

+ */ + public static final String MODIFIED_DATE = "modified_date"; + + /** + * Data's content + *

Type: TEXT

+ */ + /* + * 数据内容 + *

类型：TEXT

+ */ + public static final String CONTENT = "content"; + + + /** + * Generic data column, the meaning is{@link #MIMETYPE} specific, used for + * integer data type + *

Type: INTEGER

+ */ + /* + * 通用数据列，具体含义由{@link #MIMETYPE}决定，用于整数数据类型 + *

类型：INTEGER

+ */ + public static final String DATA1 = "data1"; + + /** + * Generic data column, the meaning is {@link #MIMETYPE} specific, used for + * integer data type + *

Type: INTEGER

+ */ + /* + * 通用数据列，具体含义由{@link #MIMETYPE}决定，用于整数数据类型 + *

类型: INTEGER

+ */ + public static final String DATA2 = "data2"; + + /** + * Generic data column, the meaning is {@link #MIMETYPE} specific, used for + * TEXT data type + *

Type: TEXT

+ */ + /* + * 通用数据列，具体含义由{@link #MIMETYPE}决定，用于TEXT数据类型 + *

类型: TEXT

+ */ + public static final String DATA3 = "data3"; + + /** + * Generic data column, the meaning is {@link #MIMETYPE} specific, used for + * TEXT data type + *

Type: TEXT

+ */ + /* + * 通用数据列，具体含义由{@link #MIMETYPE}决定，用于TEXT数据类型 + *

类型: TEXT

+ */ + public static final String DATA4 = "data4"; + + /** + * Generic data column, the meaning is {@link #MIMETYPE} specific, used for + * TEXT data type + *

Type: TEXT

+ */ + /* + * 通用数据列，具体含义由{@link #MIMETYPE}决定，用于TEXT数据类型 + *

类型: TEXT

+ */ + public static final String DATA5 = "data5"; + } + /* + * 文本笔记的定义 + */ + public static final class TextNote implements DataColumns { + /** + * Mode to indicate the text in check list mode or not + *

Type: Integer 1:check list mode 0: normal mode

+ */ + /* + * 模式，指示文本是否在检查列表模式 + *

类型: INTEGER 1:检查列表模式 0: 正常模式

+ */ + + public static final String MODE = DATA1; + + public static final int MODE_CHECK_LIST = 1; + + public static final String CONTENT_TYPE = "vnd.android.cursor.dir/text_note"; + + public static final String CONTENT_ITEM_TYPE = "vnd.android.cursor.item/text_note"; + + public static final Uri CONTENT_URI = Uri.parse("content://" + AUTHORITY + "/text_note"); + } + /* + * 通话笔记的定义 + */ + public static final class CallNote implements DataColumns { + /** + * Call date for this record + *

Type: INTEGER (long)

+ */ + /* + * 通话日期 + *

类型: INTEGER (long)

+ */ + public static final String CALL_DATE = DATA1; + + /** + * Phone number for this record + *

Type: TEXT

+ */ + /* + * 电话号码 + *

类型: TEXT

+ */ + + public static final String PHONE_NUMBER = DATA3; + + public static final String CONTENT_TYPE = "vnd.android.cursor.dir/call_note"; + + public static final String CONTENT_ITEM_TYPE = "vnd.android.cursor.item/call_note"; + + public static final Uri CONTENT_URI = Uri.parse("content://" + AUTHORITY + "/call_note"); + } +} + +/* + * 版权声明：保留了原有的版权声明，说明代码的许可协议和版权信息。 + + 常量定义：解释了各个常量的用途，如笔记类型、系统文件夹ID、Intent传递的额外数据键等。 + + 接口定义：详细说明了各个接口中的列定义，解释了每个列的用途和数据类型。 + + 类定义：解释了 TextNote 和 CallNote 类的用途，并详细说明了它们的数据列和常量。 + */ diff --git a/NotesDatabaseHelper.txt b/NotesDatabaseHelper.txt new file mode 100644 index 0000000..5900a61 --- /dev/null +++ b/NotesDatabaseHelper.txt @@ -0,0 +1,475 @@ +/* + * 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.content.ContentValues; +import android.content.Context; +import android.database.sqlite.SQLiteDatabase; +import android.database.sqlite.SQLiteOpenHelper; +import android.util.Log; + +import net.micode.notes.data.Notes.DataColumns; +import net.micode.notes.data.Notes.DataConstants; +import net.micode.notes.data.Notes.NoteColumns; + +/* + * NotesDatabaseHelper 类继承自 SQLiteOpenHelper，用于管理 SQLite 数据库的创建和版本升级。 + * 该类负责创建和管理两个主要的数据库表：NOTE 表和 DATA 表，以及相关的触发器和索引。 + */ +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 语句 + /* + * 创建笔记表的 SQL 语句。 + * 该表用于存储笔记的相关信息，包括笔记的 ID、父 ID、提醒日期、背景颜色 ID、创建日期、 + * 是否有附件、修改日期、笔记数量、摘要、类型、小部件 ID、小部件类型、同步 ID、本地修改标志、 + * 原始父 ID、Google 任务 ID 和版本号。 + */ + private static final String CREATE_NOTE_TABLE_SQL = + "CREATE TABLE " + TABLE.NOTE + "(" + + NoteColumns.ID + " INTEGER PRIMARY KEY," + // 笔记的唯一标识符，主键 + NoteColumns.PARENT_ID + " INTEGER NOT NULL DEFAULT 0," + // 父笔记的 ID，默认为 0 + NoteColumns.ALERTED_DATE + " INTEGER NOT NULL DEFAULT 0," + // 提醒日期，默认为 0 + NoteColumns.BG_COLOR_ID + " INTEGER NOT NULL DEFAULT 0," + // 背景颜色 ID，默认为 0 + NoteColumns.CREATED_DATE + " INTEGER NOT NULL DEFAULT (strftime('%s','now') * 1000)," + // 创建日期，默认为当前时间 + NoteColumns.HAS_ATTACHMENT + " INTEGER NOT NULL DEFAULT 0," + // 是否有附件，默认为 0 + NoteColumns.MODIFIED_DATE + " INTEGER NOT NULL DEFAULT (strftime('%s','now') * 1000)," + // 修改日期，默认为当前时间 + NoteColumns.NOTES_COUNT + " INTEGER NOT NULL DEFAULT 0," + // 笔记数量，默认为 0 + NoteColumns.SNIPPET + " TEXT NOT NULL DEFAULT ''," + // 笔记摘要，默认为空字符串 + NoteColumns.TYPE + " INTEGER NOT NULL DEFAULT 0," + // 笔记类型，默认为 0 + NoteColumns.WIDGET_ID + " INTEGER NOT NULL DEFAULT 0," + // 小部件 ID，默认为 0 + NoteColumns.WIDGET_TYPE + " INTEGER NOT NULL DEFAULT -1," + // 小部件类型，默认为 -1 + NoteColumns.SYNC_ID + " INTEGER NOT NULL DEFAULT 0," + // 同步 ID，默认为 0 + NoteColumns.LOCAL_MODIFIED + " INTEGER NOT NULL DEFAULT 0," + // 本地修改标志，默认为 0 + NoteColumns.ORIGIN_PARENT_ID + " INTEGER NOT NULL DEFAULT 0," + // 原始父 ID，默认为 0 + NoteColumns.GTASK_ID + " TEXT NOT NULL DEFAULT ''," + // Google 任务 ID，默认为空字符串 + NoteColumns.VERSION + " INTEGER NOT NULL DEFAULT 0" + // 版本号，默认为 0 + ")"; + // 创建 DATA 表的 SQL 语句 + /* + * 创建数据表的 SQL 语句。 + * 该表用于存储与笔记相关的数据，包括数据的 ID、MIME 类型、所属笔记的 ID、创建日期、 + * 修改日期、内容、以及一些额外的数据字段（DATA1 到 DATA5）。 + */ + private static final String CREATE_DATA_TABLE_SQL = + "CREATE TABLE " + TABLE.DATA + "(" + + DataColumns.ID + " INTEGER PRIMARY KEY," + // 数据的唯一标识符，主键 + DataColumns.MIME_TYPE + " TEXT NOT NULL," + // MIME 类型，不能为空 + DataColumns.NOTE_ID + " INTEGER NOT NULL DEFAULT 0," + // 所属笔记的 ID，默认为 0 + NoteColumns.CREATED_DATE + " INTEGER NOT NULL DEFAULT (strftime('%s','now') * 1000)," + // 创建日期，默认为当前时间（以毫秒为单位） + NoteColumns.MODIFIED_DATE + " INTEGER NOT NULL DEFAULT (strftime('%s','now') * 1000)," + // 修改日期，默认为当前时间（以毫秒为单位） + DataColumns.CONTENT + " TEXT NOT NULL DEFAULT ''," + // 数据内容，默认为空字符串 + DataColumns.DATA1 + " INTEGER," + // 额外数据字段 1，整数类型 + DataColumns.DATA2 + " INTEGER," + // 额外数据字段 2，整数类型 + DataColumns.DATA3 + " TEXT NOT NULL DEFAULT ''," + // 额外数据字段 3，文本类型，默认为空字符串 + DataColumns.DATA4 + " TEXT NOT NULL DEFAULT ''," + // 额外数据字段 4，文本类型，默认为空字符串 + DataColumns.DATA5 + " TEXT NOT NULL DEFAULT ''" + // 额外数据字段 5，文本类型，默认为空字符串 + ")"; + // 创建 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 + ");"; + // 当笔记移动到文件夹时，增加文件夹的笔记计数触发器 + /** + * Increase folder's note count when move note to the folder + */ + /* + * 创建一个触发器，用于在更新笔记的父 ID 时增加父文件夹的笔记数量。 + * 该触发器在笔记表的 PARENT_ID 字段更新后触发，并将父文件夹的 NOTES_COUNT 字段加 1。 + */ + private static final String NOTE_INCREASE_FOLDER_COUNT_ON_UPDATE_TRIGGER = + "CREATE TRIGGER increase_folder_count_on_update "+ + " AFTER UPDATE OF " + NoteColumns.PARENT_ID + " ON " + TABLE.NOTE + + " BEGIN " + + " UPDATE " + TABLE.NOTE + + " SET " + NoteColumns.NOTES_COUNT + "=" + NoteColumns.NOTES_COUNT + " + 1" + + " WHERE " + NoteColumns.ID + "=new." + NoteColumns.PARENT_ID + ";" + + " END"; + // 当笔记从文件夹中移出时，减少文件夹的笔记计数触发器 + /** + * Decrease folder's note count when move note from folder + */ + /* + * 创建一个触发器，用于在更新笔记的父 ID 时减少旧父文件夹的笔记数量。 + * 该触发器在笔记表的 PARENT_ID 字段更新后触发，并将旧父文件夹的 NOTES_COUNT 字段减 1。 + */ + private static final String NOTE_DECREASE_FOLDER_COUNT_ON_UPDATE_TRIGGER = + "CREATE TRIGGER decrease_folder_count_on_update " + + " AFTER UPDATE OF " + NoteColumns.PARENT_ID + " ON " + TABLE.NOTE + + " BEGIN " + + " UPDATE " + TABLE.NOTE + + " SET " + NoteColumns.NOTES_COUNT + "=" + NoteColumns.NOTES_COUNT + "-1" + + " WHERE " + NoteColumns.ID + "=old." + NoteColumns.PARENT_ID + + " AND " + NoteColumns.NOTES_COUNT + ">0" + ";" + + " END"; + // 当插入新笔记到文件夹时，增加文件夹的笔记计数触发器 + /** + * Increase folder's note count when insert new note to the folder + */ + /* + * 创建一个触发器，用于在插入新笔记时增加父文件夹的笔记数量。 + * 该触发器在笔记表插入新记录后触发，并将父文件夹的 NOTES_COUNT 字段加 1。 + */ + private static final String NOTE_INCREASE_FOLDER_COUNT_ON_INSERT_TRIGGER = + "CREATE TRIGGER increase_folder_count_on_insert " + + " AFTER INSERT ON " + TABLE.NOTE + + " BEGIN " + + " UPDATE " + TABLE.NOTE + + " SET " + NoteColumns.NOTES_COUNT + "=" + NoteColumns.NOTES_COUNT + " + 1" + + " WHERE " + NoteColumns.ID + "=new." + NoteColumns.PARENT_ID + ";" + + " END"; + // 当从文件夹中删除笔记时，减少文件夹的笔记计数触发器 + /** + * Decrease folder's note count when delete note from the folder + */ + /* + * 创建一个触发器，用于在删除笔记时减少父文件夹的笔记数量。 + * 该触发器在笔记表删除记录后触发，并将父文件夹的 NOTES_COUNT 字段减 1。 + */ + private static final String NOTE_DECREASE_FOLDER_COUNT_ON_DELETE_TRIGGER = + "CREATE TRIGGER decrease_folder_count_on_delete " + + " AFTER DELETE ON " + TABLE.NOTE + + " BEGIN " + + " UPDATE " + TABLE.NOTE + + " SET " + NoteColumns.NOTES_COUNT + "=" + NoteColumns.NOTES_COUNT + "-1" + + " WHERE " + NoteColumns.ID + "=old." + NoteColumns.PARENT_ID + + " AND " + NoteColumns.NOTES_COUNT + ">0;" + + " END"; + // 当插入类型为 {@link DataConstants#NOTE} 的数据时，更新笔记内容触发器 + /** + * Update note's content when insert data with type {@link DataConstants#NOTE} + */ + /* + * 创建一个触发器，用于在插入新数据时更新笔记的内容摘要。 + * 该触发器在数据表插入新记录后触发，并且仅在插入的数据 MIME 类型为 'NOTE' 时执行。 + * 触发器会将笔记表中对应笔记的 SNIPPET 字段更新为新插入数据的内容。 + */ + private static final String DATA_UPDATE_NOTE_CONTENT_ON_INSERT_TRIGGER = + "CREATE TRIGGER update_note_content_on_insert " + + " AFTER INSERT ON " + TABLE.DATA + + " WHEN new." + DataColumns.MIME_TYPE + "='" + DataConstants.NOTE + "'" + + " BEGIN" + + " UPDATE " + TABLE.NOTE + + " SET " + NoteColumns.SNIPPET + "=new." + DataColumns.CONTENT + + " WHERE " + NoteColumns.ID + "=new." + DataColumns.NOTE_ID + ";" + + " END"; + // 当类型为 {@link DataConstants#NOTE} 的数据更新时，更新笔记内容触发器 + /** + * Update note's content when data with {@link DataConstants#NOTE} type has changed + */ + /* + * 创建一个触发器，用于在更新数据时更新笔记的内容摘要。 + * 该触发器在数据表更新记录后触发，并且仅在更新的数据 MIME 类型为 'NOTE' 时执行。 + * 触发器会将笔记表中对应笔记的 SNIPPET 字段更新为更新后的数据内容。 + */ + private static final String DATA_UPDATE_NOTE_CONTENT_ON_UPDATE_TRIGGER = + "CREATE TRIGGER update_note_content_on_update " + + " AFTER UPDATE ON " + TABLE.DATA + + " WHEN old." + DataColumns.MIME_TYPE + "='" + DataConstants.NOTE + "'" + + " BEGIN" + + " UPDATE " + TABLE.NOTE + + " SET " + NoteColumns.SNIPPET + "=new." + DataColumns.CONTENT + + " WHERE " + NoteColumns.ID + "=new." + DataColumns.NOTE_ID + ";" + + " END"; + // 当类型为 {@link DataConstants#NOTE} 的数据删除时，更新笔记内容触发器 + /** + * Update note's content when data with {@link DataConstants#NOTE} type has deleted + */ + /* + *创建一个触发器，用于在删除数据时更新笔记的内容摘要。 + * 该触发器在数据表删除记录后触发，并且仅在删除的数据 MIME 类型为 'NOTE' 时执行。 + * 触发器会将笔记表中对应笔记的 SNIPPET 字段清空。 + */ + private static final String DATA_UPDATE_NOTE_CONTENT_ON_DELETE_TRIGGER = + "CREATE TRIGGER update_note_content_on_delete " + + " AFTER delete ON " + TABLE.DATA + + " WHEN old." + DataColumns.MIME_TYPE + "='" + DataConstants.NOTE + "'" + + " BEGIN" + + " UPDATE " + TABLE.NOTE + + " SET " + NoteColumns.SNIPPET + "=''" + + " WHERE " + NoteColumns.ID + "=old." + DataColumns.NOTE_ID + ";" + + " END"; + // 当删除笔记时，删除相关数据触发器 + /** + * Delete datas belong to note which has been deleted + */ + /* + * 创建一个触发器，用于在删除笔记时删除与之关联的数据。 + * 该触发器在笔记表删除记录后触发，并将数据表中与被删除笔记关联的所有数据删除。 + */ + private static final String NOTE_DELETE_DATA_ON_DELETE_TRIGGER = + "CREATE TRIGGER delete_data_on_delete " + + " AFTER DELETE ON " + TABLE.NOTE + + " BEGIN" + + " DELETE FROM " + TABLE.DATA + + " WHERE " + DataColumns.NOTE_ID + "=old." + NoteColumns.ID + ";" + + " END"; + // 当删除文件夹时，删除文件夹中的笔记触发器 + /** + * Delete notes belong to folder which has been deleted + */ + /* + *创建一个触发器，用于在删除笔记时删除与之关联的数据。 + * 该触发器在笔记表删除记录后触发，并将数据表中与被删除笔记关联的所有数据删除。 + */ + private static final String NOTE_DELETE_DATA_ON_DELETE_TRIGGER = + "CREATE TRIGGER delete_data_on_delete " + + " AFTER DELETE ON " + TABLE.NOTE + + " BEGIN" + + " DELETE FROM " + TABLE.DATA + + " WHERE " + DataColumns.NOTE_ID + "=old." + NoteColumns.ID + ";" + + " END"; + // 当文件夹移动到回收站时，移动文件夹中的笔记到回收站触发器 + /** + * Move notes belong to folder which has been moved to trash folder + */ + /* + * 创建一个触发器，用于在将文件夹移动到回收站时，将其所有子笔记也移动到回收站。 + * 该触发器在笔记表更新记录后触发，并且仅在更新的笔记的 PARENT_ID 字段值为回收站文件夹 ID 时执行。 + * 触发器会将所有父 ID 为被更新笔记 ID 的笔记的 PARENT_ID 字段值更新为回收站文件夹 ID。 + */ + private static final String FOLDER_MOVE_NOTES_ON_TRASH_TRIGGER = + "CREATE TRIGGER folder_move_notes_on_trash " + + " AFTER UPDATE ON " + TABLE.NOTE + + " WHEN new." + NoteColumns.PARENT_ID + "=" + Notes.ID_TRASH_FOLER + + " BEGIN" + + " UPDATE " + TABLE.NOTE + + " SET " + NoteColumns.PARENT_ID + "=" + Notes.ID_TRASH_FOLER + + " WHERE " + NoteColumns.PARENT_ID + "=old." + NoteColumns.ID + ";" + + " END"; +/* + * 构造函数，初始化数据库 + * 该构造函数用于初始化数据库帮助类，并指定数据库名称和版本号。 + * @param context 上下文 + */ + public NotesDatabaseHelper(Context context) { + super(context, DB_NAME, null, DB_VERSION); + } +/* + * 创建 NOTE 表 + * 创建笔记表及其相关触发器和系统文件夹。 + * 该方法用于在数据库中创建笔记表，并调用相关方法创建触发器和系统文件夹。 + * @param db SQLiteDatabase 实例 + */ + public void createNoteTable(SQLiteDatabase db) { + db.execSQL(CREATE_NOTE_TABLE_SQL); // 执行创建笔记表的 SQL 语句 + reCreateNoteTableTriggers(db); // 重新创建笔记表的触发器 + createSystemFolder(db); // 创建系统文件夹 + Log.d(TAG, "note table has been created"); // 记录日志，表示笔记表已创建 + } +/* + * 重新创建 NOTE 表的触发器 + * 该方法用于删除现有的笔记表触发器，并重新创建它们，以确保触发器与表结构一致。 + * @param db SQLiteDatabase 实例 + */ + 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); + } +/* + * 创建系统文件夹 + * 该方法用于在数据库中创建系统文件夹，包括通话记录文件夹、根文件夹、临时文件夹和回收站文件夹。 + * @param db SQLiteDatabase 实例 + */ + private void createSystemFolder(SQLiteDatabase db) { + ContentValues values = new ContentValues(); + // 创建通话记录文件夹, 通话记录文件夹，用于存储通话笔记。 + /** + * call record foler for call notes + */ + values.put(NoteColumns.ID, Notes.ID_CALL_RECORD_FOLDER); + values.put(NoteColumns.TYPE, Notes.TYPE_SYSTEM); + db.insert(TABLE.NOTE, null, values); + // 创建根文件夹（默认文件夹） + /** + * root folder which is default folder + */ + values.clear(); + values.put(NoteColumns.ID, Notes.ID_ROOT_FOLDER); + values.put(NoteColumns.TYPE, Notes.TYPE_SYSTEM); + db.insert(TABLE.NOTE, null, values); + // 创建临时文件夹（用于移动笔记） + /** + * temporary folder which is used for moving note + */ + values.clear(); + values.put(NoteColumns.ID, Notes.ID_TEMPARAY_FOLDER); + values.put(NoteColumns.TYPE, Notes.TYPE_SYSTEM); + db.insert(TABLE.NOTE, null, values); + // 创建回收站文件夹 + /** + * create trash folder + */ + values.clear(); + values.put(NoteColumns.ID, Notes.ID_TRASH_FOLER); + values.put(NoteColumns.TYPE, Notes.TYPE_SYSTEM); + db.insert(TABLE.NOTE, null, values); + } +/* + * 创建 DATA 表 + * 该方法用于在数据库中创建数据表，并调用相关方法创建触发器和索引。 + * @param db SQLiteDatabase 实例 + */ + public void createDataTable(SQLiteDatabase db) { + db.execSQL(CREATE_DATA_TABLE_SQL); // 执行创建数据表的 SQL 语句 + reCreateDataTableTriggers(db); // 重新创建数据表的触发器 + db.execSQL(CREATE_DATA_NOTE_ID_INDEX_SQL); // 创建数据表的索引 + Log.d(TAG, "data table has been created"); // 记录日志，表示数据表已创建 + } +/* + * 重新创建 DATA 表的触发器 + * 该方法用于删除现有的数据表触发器，并重新创建它们，以确保触发器与表结构一致。 + * @param db SQLiteDatabase 实例 + */ + private void reCreateDataTableTriggers(SQLiteDatabase db) { + // 删除现有的触发器 + db.execSQL("DROP TRIGGER IF EXISTS update_note_content_on_insert"); + db.execSQL("DROP TRIGGER IF EXISTS update_note_content_on_update"); + db.execSQL("DROP TRIGGER IF EXISTS update_note_content_on_delete"); + // 重新创建触发器 + db.execSQL(DATA_UPDATE_NOTE_CONTENT_ON_INSERT_TRIGGER); + db.execSQL(DATA_UPDATE_NOTE_CONTENT_ON_UPDATE_TRIGGER); + db.execSQL(DATA_UPDATE_NOTE_CONTENT_ON_DELETE_TRIGGER); + } +/* + * 获取 NotesDatabaseHelper 的单例实例 + * 该方法使用 synchronized 关键字确保线程安全，并在实例不存在时创建一个新的实例。 + * @param context 上下文 + * @return NotesDatabaseHelper 实例 + */ + static synchronized NotesDatabaseHelper getInstance(Context context) { + if (mInstance == null) { + mInstance = new NotesDatabaseHelper(context); + } + return mInstance; + } +/* + * 当数据库首次创建时调用此方法 + * 该方法在数据库首次创建时被调用，用于创建笔记表和数据表。 + * @param db SQLiteDatabase 实例 + */ + @Override + public void onCreate(SQLiteDatabase db) { + createNoteTable(db); // 创建笔记表及其相关触发器和系统文件夹 + createDataTable(db); // 创建数据表及其相关触发器和索引 + } +/* + *当数据库需要升级时调用此方法 + *该方法在数据库版本升级时被调用，用于执行相应的升级操作。 + * @param db SQLiteDatabase 实例 + * @param oldVersion 旧版本号 + * @param newVersion 新版本号 + */ + @Override + public void onUpgrade(SQLiteDatabase db, int oldVersion, int newVersion) { + boolean reCreateTriggers = false; + boolean skipV2 = false; + // 如果旧版本是 1，执行从版本 1 升级到版本 2 的操作 + if (oldVersion == 1) { + upgradeToV2(db); + skipV2 = true; // // 这个升级包括从 v2 到 v3 的升级 + oldVersion++; + } + // 如果旧版本是 2，并且没有跳过 v2 升级，执行从版本 2 升级到版本 3 的操作 + if (oldVersion == 2 && !skipV2) { + upgradeToV3(db); + reCreateTriggers = true; + oldVersion++; + } + // 如果旧版本是 3，执行从版本 3 升级到版本 4 的操作 + 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"); + } + } +/* + * 升级数据库到版本 2 + * 该方法用于删除现有的笔记表和数据表，并重新创建它们。 + * @param db SQLiteDatabase 实例 + */ + private void upgradeToV2(SQLiteDatabase db) { + db.execSQL("DROP TABLE IF EXISTS " + TABLE.NOTE); // 删除现有的笔记表 + db.execSQL("DROP TABLE IF EXISTS " + TABLE.DATA); // 删除现有的数据表 + createNoteTable(db); // 重新创建笔记表及其相关触发器和系统文件夹 + createDataTable(db); // 重新创建数据表及其相关触发器和索引 + } +/* + * 升级数据库到版本 3 + * @param db SQLiteDatabase 实例 + */ + 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); + } +/* + *升级数据库到版本 4 + * @param db SQLiteDatabase 实例 + */ + private void upgradeToV4(SQLiteDatabase db) { + db.execSQL("ALTER TABLE " + TABLE.NOTE + " ADD COLUMN " + NoteColumns.VERSION + + " INTEGER NOT NULL DEFAULT 0"); + } +} diff --git a/NotesProvider.txt b/NotesProvider.txt new file mode 100644 index 0000000..1688aa4 --- /dev/null +++ b/NotesProvider.txt @@ -0,0 +1,375 @@ +/* + * 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.data.Notes.DataColumns; +import net.micode.notes.data.Notes.NoteColumns; +import net.micode.notes.data.NotesDatabaseHelper.TABLE; + +/* + * NotesProvider 是一个 ContentProvider，用于管理笔记数据的增删改查操作。 + * 它通过 UriMatcher 来匹配不同的 URI，并根据匹配结果执行相应的数据库操作。 + */ +public class NotesProvider extends ContentProvider { + private static final UriMatcher mMatcher; + // UriMatcher 用于匹配不同的 URI + private NotesDatabaseHelper mHelper; + // 数据库帮助类实例 + private static final String TAG = "NotesProvider"; + // 日志标签 + private static final int URI_NOTE = 1; // 匹配笔记表 + private static final int URI_NOTE_ITEM = 2; // 匹配单个笔记项 + private static final int URI_DATA = 3; // 匹配数据表 + private static final int URI_DATA_ITEM = 4; // 匹配单个数据项 + + private static final int URI_SEARCH = 5; // 匹配搜索 + private static final int URI_SEARCH_SUGGEST = 6; // 匹配搜索建议 + // URI 匹配码 + static { // 初始化 UriMatcher + mMatcher = new UriMatcher(UriMatcher.NO_MATCH); + // 匹配笔记表 + mMatcher.addURI(Notes.AUTHORITY, "note", URI_NOTE); + // 匹配单个笔记项 + mMatcher.addURI(Notes.AUTHORITY, "note/#", URI_NOTE_ITEM); + // 匹配数据表 + mMatcher.addURI(Notes.AUTHORITY, "data", URI_DATA); + // 匹配单个数据项 + mMatcher.addURI(Notes.AUTHORITY, "data/#", URI_DATA_ITEM); + // 匹配搜索 + mMatcher.addURI(Notes.AUTHORITY, "search", URI_SEARCH); + // 匹配搜索建议 + mMatcher.addURI(Notes.AUTHORITY, SearchManager.SUGGEST_URI_PATH_QUERY, URI_SEARCH_SUGGEST); + // 匹配带参数的搜索建议 + mMatcher.addURI(Notes.AUTHORITY, SearchManager.SUGGEST_URI_PATH_QUERY + "/*", URI_SEARCH_SUGGEST); + } +/* + * 搜索结果的投影字段，用于构建搜索查询。 + *x'0A' 表示 SQLite 中的换行符 '\n'。 + * 在搜索结果中，标题和内容会去除换行符和空白字符，以便显示更多信息。 + */ + /** + * 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 + "," + + "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 查询语句。 + * 查询条件包括：笔记摘要包含搜索关键字、父 ID 不是回收站文件夹、笔记类型为普通笔记。 + */ + 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 表示初始化成功 + */ + @Override + public boolean onCreate() { + mHelper = NotesDatabaseHelper.getInstance(getContext()); // 获取数据库帮助类的单例实例 + return true; // 返回 true 表示初始化成功 + } +/* + * 查询操作。 + * 该方法根据传入的 URI 执行相应的查询操作，并返回查询结果的 Cursor。 + * @param uri 查询的 URI。 + * @param projection 查询的列。 + * @param selection 查询条件。 + * @param selectionArgs 查询条件的参数。 + * @param sortOrder 排序方式。 + * @return 返回查询结果的 Cursor。 + */ + @Override + public Cursor query(Uri uri, String[] projection, String selection, String[] selectionArgs, + String sortOrder) { + Cursor c = null; + SQLiteDatabase db = mHelper.getReadableDatabase(); // 获取可读的数据库实例 + 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 = uri.getPathSegments().get(1); // 获取 URI 中的笔记 ID + 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 = uri.getPathSegments().get(1); // 获取 URI 中的数据 ID + 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"); + } + + String searchString = null; + if (mMatcher.match(uri) == URI_SEARCH_SUGGEST) { + if (uri.getPathSegments().size() > 1) { + searchString = uri.getPathSegments().get(1); // 获取搜索建议的搜索字符串 + } + } else { + searchString = uri.getQueryParameter("pattern"); // 获取搜索的搜索字符串 + } + + if (TextUtils.isEmpty(searchString)) { + return null; + } + + try { + searchString = String.format("%%%s%%", searchString); // 格式化搜索字符串，用于模糊查询 + c = db.rawQuery(NOTES_SNIPPET_SEARCH_QUERY, + new String[] { searchString }); // 执行搜索查询 + } catch (IllegalStateException ex) { + Log.e(TAG, "got exception: " + ex.toString()); // 记录异常日志 + } + break; + default: + throw new IllegalArgumentException("Unknown URI " + uri); // 抛出未知 URI 异常 + } + if (c != null) { + c.setNotificationUri(getContext().getContentResolver(), uri); // 设置 Cursor 的通知 URI + } + return c; // 返回查询结果的 Cursor + } +/* + * 插入操作。 + * 该方法根据传入的 URI 执行相应的插入操作，并返回插入后的 URI。 + * @param uri 插入的 URI。 + * @param values 插入的数据。 + * @return 返回插入后的 URI。 + */ + @Override + public Uri insert(Uri uri, ContentValues values) { + SQLiteDatabase db = mHelper.getWritableDatabase(); // 获取可写的数据库实例 + long dataId = 0, noteId = 0, insertedId = 0; + 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); // 获取笔记 ID + } else { + Log.d(TAG, "Wrong data format without note id:" + values.toString()); // 记录日志，数据格式错误 + } + insertedId = dataId = db.insert(TABLE.DATA, null, values); // 插入数据 + break; + default: + throw new IllegalArgumentException("Unknown URI " + uri); // 抛出未知 URI 异常 + } + // Notify the note uri + // 通知笔记 URI 变化 + if (noteId > 0) { + getContext().getContentResolver().notifyChange( + ContentUris.withAppendedId(Notes.CONTENT_NOTE_URI, noteId), null); + } + + // Notify the data uri + // 通知数据 URI 变化 + if (dataId > 0) { + getContext().getContentResolver().notifyChange( + ContentUris.withAppendedId(Notes.CONTENT_DATA_URI, dataId), null); + } + + return ContentUris.withAppendedId(uri, insertedId); // 返回插入后的 URI + } +/* + * 删除操作。 + * 该方法根据传入的 URI 执行相应的删除操作，并返回删除的行数。 + * @param uri 删除的 URI。 + * @param selection 删除条件。 + * @param selectionArgs 删除条件的参数。 + * @return 返回删除的行数。 + */ + @Override + public int delete(Uri uri, String selection, String[] selectionArgs) { + int count = 0; + String id = null; + SQLiteDatabase db = mHelper.getWritableDatabase(); // 获取可写的数据库实例 + boolean deleteData = false; + switch (mMatcher.match(uri)) { + case URI_NOTE: + selection = "(" + selection + ") AND " + NoteColumns.ID + ">0 "; // 添加删除条件，ID 大于 0 + count = db.delete(TABLE.NOTE, selection, selectionArgs); // 删除笔记表中的数据 + break; + case URI_NOTE_ITEM: + id = uri.getPathSegments().get(1); // 获取 URI 中的笔记 ID + /** + * ID that smaller than 0 is system folder which is not allowed to + * trash + */ + /* + * ID 小于等于 0 的是系统文件夹，不允许删除 + */ + long noteId = Long.valueOf(id); + if (noteId <= 0) { + break; + } + count = db.delete(TABLE.NOTE, + NoteColumns.ID + "=" + id + parseSelection(selection), selectionArgs); // 删除单个笔记项 + break; + case URI_DATA: + count = db.delete(TABLE.DATA, selection, selectionArgs); // 删除数据表中的数据 + deleteData = true; + break; + case URI_DATA_ITEM: + id = uri.getPathSegments().get(1); // 获取 URI 中的数据 ID + count = db.delete(TABLE.DATA, + DataColumns.ID + "=" + id + parseSelection(selection), selectionArgs); // 删除单个数据项 + deleteData = true; + break; + default: + throw new IllegalArgumentException("Unknown URI " + uri); // 抛出未知 URI 异常 + } + if (count > 0) { + if (deleteData) { + getContext().getContentResolver().notifyChange(Notes.CONTENT_NOTE_URI, null); // 通知笔记 URI 变化 + } + getContext().getContentResolver().notifyChange(uri, null); // 通知 URI 变化 + } + return count; // 返回删除的行数 + } +/* + * 更新操作。 + * 该方法根据传入的 URI 执行相应的更新操作，并返回更新的行数。 + * @param uri 更新的 URI。 + * @param values 更新的数据。 + * @param selection 更新条件。 + * @param selectionArgs 更新条件的参数。 + * @return 返回更新的行数。 + */ + @Override + public int update(Uri uri, ContentValues values, String selection, String[] selectionArgs) { + int count = 0; + String id = null; + SQLiteDatabase db = mHelper.getWritableDatabase(); // 获取可写的数据库实例 + boolean updateData = false; + switch (mMatcher.match(uri)) { + case URI_NOTE: + increaseNoteVersion(-1, selection, selectionArgs); // 增加笔记版本号 + count = db.update(TABLE.NOTE, values, selection, selectionArgs); // 更新笔记表中的数据 + break; + case URI_NOTE_ITEM: + id = uri.getPathSegments().get(1); // 获取 URI 中的笔记 ID + increaseNoteVersion(Long.valueOf(id), selection, selectionArgs); // 增加笔记版本号 + count = db.update(TABLE.NOTE, values, NoteColumns.ID + "=" + id + + parseSelection(selection), selectionArgs); // 更新单个笔记项 + break; + case URI_DATA: + count = db.update(TABLE.DATA, values, selection, selectionArgs); // 更新数据表中的数据 + updateData = true; + break; + case URI_DATA_ITEM: + id = uri.getPathSegments().get(1); // 获取 URI 中的数据 ID + count = db.update(TABLE.DATA, values, DataColumns.ID + "=" + id + + parseSelection(selection), selectionArgs); // 更新单个数据项 + updateData = true; + break; + default: + throw new IllegalArgumentException("Unknown URI " + uri); // 抛出未知 URI 异常 + } + + if (count > 0) { + if (updateData) { + getContext().getContentResolver().notifyChange(Notes.CONTENT_NOTE_URI, null); // 通知笔记 URI 变化 + } + getContext().getContentResolver().notifyChange(uri, null); // 通知 URI 变化 + } + return count; // 返回更新的行数 + } +/* + * 解析选择条件，用于在查询或更新时附加额外的条件。 + * @param selection 原始选择条件。 + * @return 返回附加了额外条件的字符串。 + */ + private String parseSelection(String selection) { + return (!TextUtils.isEmpty(selection) ? " AND (" + selection + ')' : ""); + } +/* + * 增加笔记版本号。 + *该方法用于增加指定笔记的版本号，或者根据选择条件增加符合条件的笔记的版本号。 + * @param id 笔记 ID，如果为 -1 则表示更新所有符合条件的笔记。 + * @param selection 更新条件。 + * @param selectionArgs 更新条件的参数。 + */ + private void increaseNoteVersion(long id, String selection, String[] selectionArgs) { + StringBuilder sql = new StringBuilder(120); // 创建 StringBuilder 对象，用于构建 SQL 语句 + sql.append("UPDATE "); + sql.append(TABLE.NOTE); + sql.append(" SET "); + sql.append(NoteColumns.VERSION); + sql.append("=" + NoteColumns.VERSION + "+1 "); // 增加版本号 + + if (id > 0 || !TextUtils.isEmpty(selection)) { + sql.append(" WHERE "); + } + if (id > 0) { + sql.append(NoteColumns.ID + "=" + String.valueOf(id)); // 根据笔记 ID 更新 + } + if (!TextUtils.isEmpty(selection)) { + String selectString = id > 0 ? parseSelection(selection) : selection; + for (String args : selectionArgs) { + selectString = selectString.replaceFirst("\\?", args); // 替换选择条件中的占位符 + } + sql.append(selectString); + } + + mHelper.getWritableDatabase().execSQL(sql.toString()); // 执行 SQL 语句 + } +/* + * 获取 MIME 类型。 + * @param uri 查询的 URI。 + * @return 返回 MIME 类型。 + */ + @Override + public String getType(Uri uri) { + // TODO Auto-generated method stub + return null; + } + +} diff --git a/SqlData.txt b/SqlData.txt new file mode 100644 index 0000000..210fe1b --- /dev/null +++ b/SqlData.txt @@ -0,0 +1,243 @@ +/* + * 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.content.ContentResolver; +import android.content.ContentUris; +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.DataConstants; +import net.micode.notes.data.Notes.NoteColumns; +import net.micode.notes.data.NotesDatabaseHelper.TABLE; +import net.micode.notes.gtask.exception.ActionFailureException; + +import org.json.JSONException; +import org.json.JSONObject; + +/* + * SqlData 类用于处理与数据库相关的数据操作。 + * 该类主要用于加载、设置、获取和提交数据。 + */ +public class SqlData { + private static final String TAG = SqlData.class.getSimpleName(); + + private static final int INVALID_ID = -99999; // 无效的 ID + // 数据表的投影字段 + public static final String[] PROJECTION_DATA = new String[] { + DataColumns.ID, DataColumns.MIME_TYPE, DataColumns.CONTENT, DataColumns.DATA1, + DataColumns.DATA3 + }; + // 数据表的列索引 + public static final int DATA_ID_COLUMN = 0; + + public static final int DATA_MIME_TYPE_COLUMN = 1; + + public static final int DATA_CONTENT_COLUMN = 2; + + public static final int DATA_CONTENT_DATA_1_COLUMN = 3; + + public static final int DATA_CONTENT_DATA_3_COLUMN = 4; + + private ContentResolver mContentResolver; // 内容解析器 + + private boolean mIsCreate; // 是否为创建操作 + + private long mDataId; // 数据 ID + + private String mDataMimeType; // 数据 MIME 类型 + + private String mDataContent; // 数据内容 + + private long mDataContentData1; // 数据内容数据 1 + + private String mDataContentData3; // 数据内容数据 3 + + private ContentValues mDiffDataValues; // 差异数据值 +/* + * 构造函数，用于创建新的数据对象。 + * 该构造函数初始化数据对象的各个属性，并设置为创建操作。 + * @param context 应用程序上下文。 + */ + public SqlData(Context context) { + mContentResolver = context.getContentResolver(); // 获取内容解析器 + mIsCreate = true; // 设置为创建操作 + mDataId = INVALID_ID; // 初始化数据 ID 为无效值 + mDataMimeType = DataConstants.NOTE; // 初始化数据 MIME 类型为笔记类型 + mDataContent = ""; // 初始化数据内容为空字符串 + mDataContentData1 = 0; // 初始化数据内容数据 1 为 0 + mDataContentData3 = ""; // 初始化数据内容数据 3 为空字符串 + mDiffDataValues = new ContentValues(); // 初始化差异数据值 + } +/* + * 构造函数，用于从数据库游标加载数据对象。 + * 该构造函数初始化数据对象的各个属性，并设置为非创建操作。 + * @param context 应用程序上下文。 + * @param c 数据库游标。 + */ + public SqlData(Context context, Cursor c) { + mContentResolver = context.getContentResolver(); // 获取内容解析器 + mIsCreate = false; // 设置为非创建操作 + loadFromCursor(c); // 从数据库游标加载数据 + mDiffDataValues = new ContentValues(); // 初始化差异数据值 + } +/* + * 从数据库游标加载数据。 + * 该方法从数据库游标中提取数据，并初始化数据对象的各个属性。 + * @param c 数据库游标。 + */ + private void loadFromCursor(Cursor c) { + mDataId = c.getLong(DATA_ID_COLUMN); // 获取数据 ID + mDataMimeType = c.getString(DATA_MIME_TYPE_COLUMN); // 获取数据 MIME 类型 + mDataContent = c.getString(DATA_CONTENT_COLUMN); // 获取数据内容 + mDataContentData1 = c.getLong(DATA_CONTENT_DATA_1_COLUMN); // 获取数据内容数据 1 + mDataContentData3 = c.getString(DATA_CONTENT_DATA_3_COLUMN); // 获取数据内容数据 3 + } +/* + * 设置数据内容。 + * 该方法从 JSON 对象中提取数据，并更新数据对象的各个属性。 + * 如果数据对象是新创建的，或者 JSON 对象中的数据与当前数据对象的数据不同，则更新差异数据值。 + * @param js JSON 对象，包含数据内容。 + * @throws JSONException 如果解析 JSON 对象时发生异常。 + */ + public void setContent(JSONObject js) throws JSONException { + // 从 JSON 对象中获取数据 ID，如果 JSON 对象中没有数据 ID，则使用无效 ID + long dataId = js.has(DataColumns.ID) ? js.getLong(DataColumns.ID) : INVALID_ID; + // 如果数据对象是新创建的，或者数据 ID 不同，则更新差异数据值 + if (mIsCreate || mDataId != dataId) { + mDiffDataValues.put(DataColumns.ID, dataId); + } + mDataId = dataId; // 更新数据 ID + // 从 JSON 对象中获取数据 MIME 类型，如果 JSON 对象中没有数据 MIME 类型，则使用默认的笔记类型 + String dataMimeType = js.has(DataColumns.MIME_TYPE) ? js.getString(DataColumns.MIME_TYPE) + : DataConstants.NOTE; + // 如果数据对象是新创建的，或者数据 MIME 类型不同，则更新差异数据值 + if (mIsCreate || !mDataMimeType.equals(dataMimeType)) { + mDiffDataValues.put(DataColumns.MIME_TYPE, dataMimeType); + } + mDataMimeType = dataMimeType; // 更新数据 MIME 类型 + // 从 JSON 对象中获取数据内容，如果 JSON 对象中没有数据内容，则使用空字符串 + String dataContent = js.has(DataColumns.CONTENT) ? js.getString(DataColumns.CONTENT) : ""; + // 如果数据对象是新创建的，或者数据内容不同，则更新差异数据值 + if (mIsCreate || !mDataContent.equals(dataContent)) { + mDiffDataValues.put(DataColumns.CONTENT, dataContent); + } + mDataContent = dataContent; // 更新数据内容 + // 从 JSON 对象中获取数据内容数据 1，如果 JSON 对象中没有数据内容数据 1，则使用 0 + long dataContentData1 = js.has(DataColumns.DATA1) ? js.getLong(DataColumns.DATA1) : 0; + // 如果数据对象是新创建的，或者数据内容数据 1 不同，则更新差异数据值 + if (mIsCreate || mDataContentData1 != dataContentData1) { + mDiffDataValues.put(DataColumns.DATA1, dataContentData1); + } + mDataContentData1 = dataContentData1; // 更新数据内容数据 1 + // 从 JSON 对象中获取数据内容数据 3，如果 JSON 对象中没有数据内容数据 3，则使用空字符串 + String dataContentData3 = js.has(DataColumns.DATA3) ? js.getString(DataColumns.DATA3) : ""; + // 如果数据对象是新创建的，或者数据内容数据 3 不同，则更新差异数据值 + if (mIsCreate || !mDataContentData3.equals(dataContentData3)) { + mDiffDataValues.put(DataColumns.DATA3, dataContentData3); + } + mDataContentData3 = dataContentData3; // 更新数据内容数据 3 + } +/* + * 获取数据内容。 + * 该方法将数据对象的各个属性转换为 JSON 对象，并返回该 JSON 对象。 + * @return 返回包含数据内容的 JSON 对象。 + * @throws JSONException 如果生成 JSON 对象时发生异常。 + */ + public JSONObject getContent() throws JSONException { + // 如果数据对象是新创建的，则记录错误日志并返回 null + if (mIsCreate) { + Log.e(TAG, "it seems that we haven't created this in database yet"); + return null; + } + JSONObject js = new JSONObject(); // 创建一个新的 JSON 对象 + js.put(DataColumns.ID, mDataId); // 将数据 ID 添加到 JSON 对象中 + js.put(DataColumns.MIME_TYPE, mDataMimeType); // 将数据 MIME 类型添加到 JSON 对象中 + js.put(DataColumns.CONTENT, mDataContent); // 将数据内容添加到 JSON 对象中 + js.put(DataColumns.DATA1, mDataContentData1); // 将数据内容数据 1 添加到 JSON 对象中 + js.put(DataColumns.DATA3, mDataContentData3); // 将数据内容数据 3 添加到 JSON 对象中 + return js; // 返回 JSON 对象 + } +/* + * 提交数据。 + * 该方法根据数据对象的状态（创建或更新）执行相应的数据库操作。 + * 如果是创建操作，则插入数据到数据库中；如果是更新操作，则更新数据库中的数据。 + * @param noteId 笔记 ID。 + * @param validateVersion 是否验证版本。 + * @param version 版本号。 + */ + public void commit(long noteId, boolean validateVersion, long version) { + // 如果是创建操作 + if (mIsCreate) { + // 如果数据 ID 是无效的，并且差异数据值中包含数据 ID，则移除数据 ID + if (mDataId == INVALID_ID && mDiffDataValues.containsKey(DataColumns.ID)) { + mDiffDataValues.remove(DataColumns.ID); + } + // 将笔记 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 + + " WHERE " + NoteColumns.VERSION + "=?)", new String[] { + String.valueOf(noteId), String.valueOf(version) + }); + } + // 如果没有更新，则记录警告日志 + if (result == 0) { + Log.w(TAG, "there is no update. maybe user updates note when syncing"); + } + } + } + // 清空差异数据值 + mDiffDataValues.clear(); + mIsCreate = false; // 设置为非创建操作 + } +/* + * 获取数据 ID。 + * 该方法返回数据对象的数据 ID。 + * @return 返回数据 ID。 + */ + public long getId() { + return mDataId; + } +} \ No newline at end of file diff --git a/SqlNote.txt b/SqlNote.txt new file mode 100644 index 0000000..2469f48 --- /dev/null +++ b/SqlNote.txt @@ -0,0 +1,618 @@ +/* + * 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(); + + private static final int INVALID_ID = -99999; // 无效的 ID + // 笔记表的投影字段 + 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 + }; + // 笔记表的列索引 + public static final int ID_COLUMN = 0; + + public static final int ALERTED_DATE_COLUMN = 1; + + 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; + + public static final int PARENT_ID_COLUMN = 7; + + public static final int SNIPPET_COLUMN = 8; + + public static final int TYPE_COLUMN = 9; + + public static final int WIDGET_ID_COLUMN = 10; + + public static final int WIDGET_TYPE_COLUMN = 11; + + public static final int SYNC_ID_COLUMN = 12; + + public static final int LOCAL_MODIFIED_COLUMN = 13; + + public static final int ORIGIN_PARENT_ID_COLUMN = 14; + + 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; // 笔记 ID + + private long mAlertDate; // 提醒日期 + + private int mBgColorId; // 背景颜色 ID + + private long mCreatedDate; // 创建日期 + + private int mHasAttachment; // 是否有附件 + + private long mModifiedDate; // 修改日期 + + private long mParentId; // 父笔记 ID + + private String mSnippet; // 笔记摘要 + + private int mType; // 笔记类型 + + private int mWidgetId; // 小部件 ID + + private int mWidgetType; // 小部件类型 + + private long mOriginParent; // 原始父笔记 ID + + private long mVersion; // 版本号 + + private ContentValues mDiffNoteValues; // 差异笔记值 + + private ArrayList mDataList; // 数据列表 +/* + * 构造函数，用于创建新的笔记对象。 + * 该构造函数初始化笔记对象的各个属性，并设置为创建操作。 + * @param context 应用程序上下文。 + */ + public SqlNote(Context context) { + mContext = context; // 设置应用程序上下文 + mContentResolver = context.getContentResolver(); // 获取内容解析器 + mIsCreate = true; // 设置为创建操作 + mId = INVALID_ID; // 初始化笔记 ID 为无效值 + mAlertDate = 0; // 初始化提醒日期为 0 + mBgColorId = ResourceParser.getDefaultBgId(context); // 初始化背景颜色 ID 为默认值 + mCreatedDate = System.currentTimeMillis(); // 初始化创建日期为当前时间 + mHasAttachment = 0; // 初始化是否有附件为 0 + mModifiedDate = System.currentTimeMillis(); // 初始化修改日期为当前时间 + mParentId = 0; // 初始化父笔记 ID 为 0 + mSnippet = ""; // 初始化笔记摘要为空字符串 + mType = Notes.TYPE_NOTE; // 初始化笔记类型为普通笔记 + mWidgetId = AppWidgetManager.INVALID_APPWIDGET_ID; // 初始化小部件 ID 为无效值 + mWidgetType = Notes.TYPE_WIDGET_INVALIDE; // 初始化小部件类型为无效值 + mOriginParent = 0; // 初始化原始父笔记 ID 为 0 + mVersion = 0; // 初始化版本号为 0 + mDiffNoteValues = new ContentValues(); // 初始化差异笔记值 + mDataList = new ArrayList(); // 初始化数据列表 + } +/* + * 构造函数，用于从数据库游标加载笔记对象。 + * 该构造函数初始化笔记对象的各个属性，并设置为非创建操作。 + * @param context 应用程序上下文。 + * @param c 数据库游标。 + */ + 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 的笔记对象。 + * 该构造函数初始化笔记对象的各个属性，并设置为非创建操作。 + * @param context 应用程序上下文。 + * @param id 笔记 ID。 + */ + public SqlNote(Context context, long id) { + mContext = context; // 设置应用程序上下文 + mContentResolver = context.getContentResolver(); // 获取内容解析器 + mIsCreate = false; // 设置为非创建操作 + loadFromCursor(id); // 从数据库中加载指定 ID 的笔记对象 + mDataList = new ArrayList(); // 初始化数据列表 + if (mType == Notes.TYPE_NOTE) // 如果笔记类型为普通笔记 + loadDataContent(); // 加载笔记的数据内容 + mDiffNoteValues = new ContentValues(); // 初始化差异笔记值 + + } +/* + * 从数据库中加载指定 ID 的笔记对象。 + * 该方法从数据库中查询指定 ID 的笔记数据，并调用 `loadFromCursor(Cursor c)` 方法加载笔记对象。 + * @param id 笔记 ID。 + */ + private void loadFromCursor(long id) { + Cursor c = null; + try { + // 查询指定 ID 的笔记数据 + 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(); // 关闭游标 + } + } +/* + * 从数据库游标加载笔记对象。 + * 该方法从数据库游标中提取笔记数据，并初始化笔记对象的各个属性。 + * @param c 数据库游标。 + */ + private void loadFromCursor(Cursor c) { + mId = c.getLong(ID_COLUMN); // 获取笔记 ID + mAlertDate = c.getLong(ALERTED_DATE_COLUMN); // 获取提醒日期 + mBgColorId = c.getInt(BG_COLOR_ID_COLUMN); // 获取背景颜色 ID + mCreatedDate = c.getLong(CREATED_DATE_COLUMN); // 获取创建日期 + mHasAttachment = c.getInt(HAS_ATTACHMENT_COLUMN); // 获取是否有附件 + mModifiedDate = c.getLong(MODIFIED_DATE_COLUMN); // 获取修改日期 + mParentId = c.getLong(PARENT_ID_COLUMN); // 获取父笔记 ID + mSnippet = c.getString(SNIPPET_COLUMN); // 获取笔记摘要 + mType = c.getInt(TYPE_COLUMN); // 获取笔记类型 + mWidgetId = c.getInt(WIDGET_ID_COLUMN); // 获取小部件 ID + 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 data = new SqlData(mContext, c); // 从游标中加载数据 + mDataList.add(data); // 将数据内容添加到数据列表中 + } + } else { + Log.w(TAG, "loadDataContent: cursor = null"); // 记录警告日志，游标为空 + } + } finally { + if (c != null) + c.close(); // 关闭游标 + } + } +/* + * 设置内容的方法，接受一个JSONObject作为参数，并根据其中的数据更新当前对象的属性。 + * @param js 包含笔记信息的JSONObject + * @return 如果设置成功返回true，否则返回false + */ + public boolean setContent(JSONObject js) { + try { + // 从JSONObject中获取笔记的元数据 + 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) { + // 如果是文件夹类型，则只能更新摘要和类型 + // for folder we can only update the snnipet and type + // 获取摘要，如果未提供则默认为空字符串 + 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); + // 获取笔记ID，如果未提供则默认为无效ID + long id = note.has(NoteColumns.ID) ? note.getLong(NoteColumns.ID) : INVALID_ID; + // 如果是新建笔记或ID有变化，则更新ID + if (mIsCreate || mId != id) { + mDiffNoteValues.put(NoteColumns.ID, id); + } + mId = id; + // 获取提醒日期，如果未提供则默认为0 + 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); + // 如果是新建笔记或背景颜色ID有变化，则更新背景颜色ID + 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; + // 获取是否有附件，如果未提供则默认为0（无附件） + 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，如果未提供则默认为0 + long parentId = note.has(NoteColumns.PARENT_ID) ? note + .getLong(NoteColumns.PARENT_ID) : 0; + // 如果是新建笔记或父ID有变化，则更新父ID + 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; + // 如果是新建笔记或小部件ID有变化，则更新小部件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; + // 获取原始父ID，如果未提供则默认为0 + long originParent = note.has(NoteColumns.ORIGIN_PARENT_ID) ? note + .getLong(NoteColumns.ORIGIN_PARENT_ID) : 0; + // 如果是新建笔记或原始父ID有变化，则更新原始父ID + if (mIsCreate || mOriginParent != originParent) { + mDiffNoteValues.put(NoteColumns.ORIGIN_PARENT_ID, originParent); + } + mOriginParent = originParent; + // 遍历数据数组，更新数据列表 + for (int i = 0; i < dataArray.length(); i++) { + JSONObject data = dataArray.getJSONObject(i); + SqlData sqlData = null; + // 如果数据对象包含ID，则在现有数据列表中查找匹配的SqlData对象 + 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对象的内容 + sqlData.setContent(data); + } + } + } catch (JSONException e) { + // 捕获JSON异常并记录错误日志 + Log.e(TAG, e.toString()); + e.printStackTrace(); + return false; + } + return true; + } +/* + * 获取当前对象的内容，并将其封装为一个JSONObject返回。 + * @return 包含当前对象内容的JSONObject，如果发生错误则返回null + */ + public JSONObject getContent() { + try { + // 创建一个新的JSONObject用于存储内容 + JSONObject js = new JSONObject(); + // 如果当前对象尚未在数据库中创建，记录错误日志并返回null + 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 JSONObject中 + 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); + // 将note JSONObject添加到js JSONObject中 + js.put(GTaskStringUtils.META_HEAD_NOTE, note); + // 创建一个新的JSONArray用于存储数据列表 + JSONArray dataArray = new JSONArray(); + // 遍历数据列表，将每个SqlData对象的内容添加到dataArray中 + for (SqlData sqlData : mDataList) { + JSONObject data = sqlData.getContent(); + if (data != null) { + dataArray.put(data); + } + } + // 将dataArray添加到js JSONObject中 + js.put(GTaskStringUtils.META_HEAD_DATA, dataArray); + } else if (mType == Notes.TYPE_FOLDER || mType == Notes.TYPE_SYSTEM) { + // 如果当前对象是文件夹或系统文件夹类型 + // 将笔记的ID、类型和摘要添加到note JSONObject中 + note.put(NoteColumns.ID, mId); + note.put(NoteColumns.TYPE, mType); + note.put(NoteColumns.SNIPPET, mSnippet); + // 将note JSONObject添加到js JSONObject中 + js.put(GTaskStringUtils.META_HEAD_NOTE, note); + } + // 返回包含内容的JSONObject + return js; + } catch (JSONException e) { + // 捕获JSON异常并记录错误日志 + Log.e(TAG, e.toString()); + e.printStackTrace(); + } + return null; + } +/* + * 设置父ID，并将其添加到差异值中。 + * @param id 新的父ID + */ + public void setParentId(long id) { + mParentId = id; + mDiffNoteValues.put(NoteColumns.PARENT_ID, id); + } +/* + * 设置Google任务ID，并将其添加到差异值中。 + * @param gid 新的Google任务ID + */ + public void setGtaskId(String gid) { + mDiffNoteValues.put(NoteColumns.GTASK_ID, gid); + } +/* + * 设置同步ID，并将其添加到差异值中。 + * @param syncId 新的同步ID + */ + public void setSyncId(long syncId) { + mDiffNoteValues.put(NoteColumns.SYNC_ID, syncId); + } +/* + * 重置本地修改标志，将其设置为0。 + */ + public void resetLocalModified() { + mDiffNoteValues.put(NoteColumns.LOCAL_MODIFIED, 0); + } +/* + * 获取当前笔记的ID。 + * @return 当前笔记的ID + */ + public long getId() { + return mId; + } +/* + * 获取当前笔记的父ID。 + * @return 当前笔记的父ID + */ + public long getParentId() { + return mParentId; + } +/* + * 获取当前笔记的摘要。 + * @return 当前笔记的摘要 + */ + public String getSnippet() { + return mSnippet; + } +/* + * 判断当前笔记是否为普通笔记类型。 + * @return 如果当前笔记是普通笔记类型，返回true；否则返回false + */ + public boolean isNoteType() { + return mType == Notes.TYPE_NOTE; + } +/* + * 提交更改，将当前对象的差异值保存到数据库中。 + * @param validateVersion 是否验证版本号 + */ + public void commit(boolean validateVersion) { + // 如果是新建笔记 + if (mIsCreate) { + // 如果ID无效且差异值中包含ID，则移除ID + if (mId == INVALID_ID && mDiffNoteValues.containsKey(NoteColumns.ID)) { + mDiffNoteValues.remove(NoteColumns.ID); + } + // 插入笔记到数据库，并获取插入后的URI + Uri uri = mContentResolver.insert(Notes.CONTENT_NOTE_URI, mDiffNoteValues); + try { + // 从URI中提取新插入笔记的ID + mId = Long.valueOf(uri.getPathSegments().get(1)); + } catch (NumberFormatException e) { + // 如果提取ID失败，记录错误日志并抛出异常 + Log.e(TAG, "Get note id error :" + e.toString()); + throw new ActionFailureException("create note failed"); + } + // 如果ID为0，表示插入失败，抛出异常 + if (mId == 0) { + throw new IllegalStateException("Create thread id failed"); + } + // 如果当前笔记是普通笔记类型 + if (mType == Notes.TYPE_NOTE) { + // 遍历数据列表，提交每个SqlData对象的更改 + for (SqlData sqlData : mDataList) { + sqlData.commit(mId, false, -1); + } + } + } else { + // 如果不是新建笔记 + // 如果ID无效且不是根文件夹或通话记录文件夹，记录错误日志并抛出异常 + 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) + }); + } + // 如果没有更新内容，记录警告日志 + if (result == 0) { + Log.w(TAG, "there is no update. maybe user updates note when syncing"); + } + } + // 如果当前笔记是普通笔记类型 + if (mType == Notes.TYPE_NOTE) { + // 遍历数据列表，提交每个SqlData对象的更改 + for (SqlData sqlData : mDataList) { + sqlData.commit(mId, validateVersion, mVersion); + } + } + } + + // refresh local info + // 刷新本地信息 + loadFromCursor(mId); + if (mType == Notes.TYPE_NOTE) + loadDataContent(); + // 清空差异值并设置为非新建状态 + mDiffNoteValues.clear(); + mIsCreate = false; + } +} diff --git a/Task.txt b/Task.txt new file mode 100644 index 0000000..c4a736c --- /dev/null +++ b/Task.txt @@ -0,0 +1,454 @@ +/* + * 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.database.Cursor; +import android.text.TextUtils; +import android.util.Log; + +import net.micode.notes.data.Notes; +import net.micode.notes.data.Notes.DataColumns; +import net.micode.notes.data.Notes.DataConstants; +import net.micode.notes.data.Notes.NoteColumns; +import net.micode.notes.gtask.exception.ActionFailureException; +import net.micode.notes.tool.GTaskStringUtils; + +import org.json.JSONArray; +import org.json.JSONException; +import org.json.JSONObject; + +/* + * Task类表示一个任务，继承自Node类。 + * 该类包含了任务的各种属性和操作方法，如创建、更新、设置内容等。 + */ +public class Task extends Node { + private static final String TAG = Task.class.getSimpleName(); + + private boolean mCompleted; // 任务是否已完成 + + private String mNotes; // 任务的备注 + + private JSONObject mMetaInfo; // 任务的元数据信息 + + private Task mPriorSibling; // 前一个兄弟任务 + + private TaskList mParent; // 父任务列表 +/* + * 构造函数，初始化任务对象。 + * 初始化任务的完成状态、备注、前一个兄弟任务、父任务列表和元数据信息。 + */ + public Task() { + super(); // 调用父类Node的构造函数 + mCompleted = false; // 初始化任务为未完成状态 + mNotes = null; // 初始化备注为空 + mPriorSibling = null; // 初始化前一个兄弟任务为空 + mParent = null; // 初始化父任务列表为空 + mMetaInfo = null; // 初始化元数据信息为空 + } +/* + *生成创建任务的JSON对象。 + * @param actionId 操作ID + * @return 包含创建任务信息的JSONObject + */ + public JSONObject getCreateAction(int actionId) { + JSONObject js = new JSONObject(); + + try { + // action_type + // 设置操作类型为创建 + js.put(GTaskStringUtils.GTASK_JSON_ACTION_TYPE, + GTaskStringUtils.GTASK_JSON_ACTION_TYPE_CREATE); + + // action_id + // 设置操作ID + js.put(GTaskStringUtils.GTASK_JSON_ACTION_ID, actionId); + + // index + // 设置任务在父任务列表中的索引 + js.put(GTaskStringUtils.GTASK_JSON_INDEX, mParent.getChildTaskIndex(this)); + + // entity_delta + // 设置任务的实体信息 + JSONObject entity = new JSONObject(); + entity.put(GTaskStringUtils.GTASK_JSON_NAME, getName()); + entity.put(GTaskStringUtils.GTASK_JSON_CREATOR_ID, "null"); + entity.put(GTaskStringUtils.GTASK_JSON_ENTITY_TYPE, + GTaskStringUtils.GTASK_JSON_TYPE_TASK); + if (getNotes() != null) { + entity.put(GTaskStringUtils.GTASK_JSON_NOTES, getNotes()); + } + js.put(GTaskStringUtils.GTASK_JSON_ENTITY_DELTA, entity); + + // parent_id + // 设置父任务列表的ID + js.put(GTaskStringUtils.GTASK_JSON_PARENT_ID, mParent.getGid()); + + // dest_parent_type + // 设置目标父类型 + js.put(GTaskStringUtils.GTASK_JSON_DEST_PARENT_TYPE, + GTaskStringUtils.GTASK_JSON_TYPE_GROUP); + + // list_id + // 设置任务列表的ID + js.put(GTaskStringUtils.GTASK_JSON_LIST_ID, mParent.getGid()); + + // prior_sibling_id + // 设置前一个兄弟任务的ID + if (mPriorSibling != null) { + js.put(GTaskStringUtils.GTASK_JSON_PRIOR_SIBLING_ID, mPriorSibling.getGid()); + } + + } catch (JSONException e) { + // 捕获JSON异常并记录错误日志 + Log.e(TAG, e.toString()); + e.printStackTrace(); + // 抛出自定义异常，表示生成JSON对象失败 + throw new ActionFailureException("fail to generate task-create jsonobject"); + } + + return js; // 返回包含创建任务信息的JSONObject + } +/* + * 生成更新任务的JSON对象。 + * @param actionId 操作ID + * @return 包含更新任务信息的JSONObject + */ + public JSONObject getUpdateAction(int actionId) { + JSONObject js = new JSONObject(); + + try { + // action_type + // 设置操作类型为更新 + js.put(GTaskStringUtils.GTASK_JSON_ACTION_TYPE, + GTaskStringUtils.GTASK_JSON_ACTION_TYPE_UPDATE); + + // action_id + // 设置操作ID + js.put(GTaskStringUtils.GTASK_JSON_ACTION_ID, actionId); + + // id + // 设置任务的ID + js.put(GTaskStringUtils.GTASK_JSON_ID, getGid()); + + // entity_delta + // 设置任务的实体信息 + JSONObject entity = new JSONObject(); + entity.put(GTaskStringUtils.GTASK_JSON_NAME, getName()); + if (getNotes() != null) { + entity.put(GTaskStringUtils.GTASK_JSON_NOTES, getNotes()); + } + entity.put(GTaskStringUtils.GTASK_JSON_DELETED, getDeleted()); + js.put(GTaskStringUtils.GTASK_JSON_ENTITY_DELTA, entity); + + } catch (JSONException e) { + // 捕获JSON异常并记录错误日志 + Log.e(TAG, e.toString()); + e.printStackTrace(); + // 抛出自定义异常，表示生成JSON对象失败 + throw new ActionFailureException("fail to generate task-update jsonobject"); + } + + return js; // 返回包含更新任务信息的JSONObject + } +/* + * 根据远程JSON对象设置任务的内容。 + * @param js 包含任务信息的远程JSON对象 + */ + public void setContentByRemoteJSON(JSONObject js) { + if (js != null) { + try { + // id + // 如果JSON对象中包含ID字段，则设置任务的ID + if (js.has(GTaskStringUtils.GTASK_JSON_ID)) { + setGid(js.getString(GTaskStringUtils.GTASK_JSON_ID)); + } + + // last_modified + // 如果JSON对象中包含最后修改时间字段，则设置任务的最后修改时间 + if (js.has(GTaskStringUtils.GTASK_JSON_LAST_MODIFIED)) { + setLastModified(js.getLong(GTaskStringUtils.GTASK_JSON_LAST_MODIFIED)); + } + + // name + // 如果JSON对象中包含名称字段，则设置任务的名称 + if (js.has(GTaskStringUtils.GTASK_JSON_NAME)) { + setName(js.getString(GTaskStringUtils.GTASK_JSON_NAME)); + } + + // notes + // 如果JSON对象中包含备注字段，则设置任务的备注 + if (js.has(GTaskStringUtils.GTASK_JSON_NOTES)) { + setNotes(js.getString(GTaskStringUtils.GTASK_JSON_NOTES)); + } + + // deleted + // 如果JSON对象中包含删除状态字段，则设置任务的删除状态 + if (js.has(GTaskStringUtils.GTASK_JSON_DELETED)) { + setDeleted(js.getBoolean(GTaskStringUtils.GTASK_JSON_DELETED)); + } + + // completed + // 如果JSON对象中包含完成状态字段，则设置任务的完成状态 + if (js.has(GTaskStringUtils.GTASK_JSON_COMPLETED)) { + setCompleted(js.getBoolean(GTaskStringUtils.GTASK_JSON_COMPLETED)); + } + } catch (JSONException e) { + // 捕获JSON异常并记录错误日志 + Log.e(TAG, e.toString()); + e.printStackTrace(); + // 抛出自定义异常，表示从JSON对象获取任务内容失败 + throw new ActionFailureException("fail to get task content from jsonobject"); + } + } + } +/* + * 根据本地JSON对象设置任务的内容。 + * @param js 包含任务信息的本地JSON对象 + */ + public void setContentByLocalJSON(JSONObject js) { + // 检查JSON对象是否为空或是否包含必要的字段 + if (js == null || !js.has(GTaskStringUtils.META_HEAD_NOTE) + || !js.has(GTaskStringUtils.META_HEAD_DATA)) { + Log.w(TAG, "setContentByLocalJSON: nothing is avaiable"); + } + + try { + // 获取笔记的元数据 + JSONObject note = js.getJSONObject(GTaskStringUtils.META_HEAD_NOTE); + // 获取数据数组 + JSONArray dataArray = js.getJSONArray(GTaskStringUtils.META_HEAD_DATA); + // 检查笔记的类型是否为普通笔记类型 + if (note.getInt(NoteColumns.TYPE) != Notes.TYPE_NOTE) { + Log.e(TAG, "invalid type"); + return; + } + // 遍历数据数组，查找MIME类型为DataConstants.NOTE的数据 + for (int i = 0; i < dataArray.length(); i++) { + JSONObject data = dataArray.getJSONObject(i); + if (TextUtils.equals(data.getString(DataColumns.MIME_TYPE), DataConstants.NOTE)) { + // 设置任务的名称 + setName(data.getString(DataColumns.CONTENT)); + break; + } + } + + } catch (JSONException e) { + // 捕获JSON异常并记录错误日志 + Log.e(TAG, e.toString()); + e.printStackTrace(); + } + } +/* + * 根据任务内容生成本地JSON对象。 + * @return 包含任务内容的本地JSON对象，如果发生错误则返回null + */ + public JSONObject getLocalJSONFromContent() { + String name = getName(); + try { + if (mMetaInfo == null) { + // new task created from web + // 如果是从网页创建的新任务 + if (name == null) { + Log.w(TAG, "the note seems to be an empty one"); + return null; + } + // 创建一个新的JSON对象 + JSONObject js = new JSONObject(); + JSONObject note = new JSONObject(); + JSONArray dataArray = new JSONArray(); + JSONObject data = new JSONObject(); + data.put(DataColumns.CONTENT, name); + dataArray.put(data); + js.put(GTaskStringUtils.META_HEAD_DATA, dataArray); + note.put(NoteColumns.TYPE, Notes.TYPE_NOTE); + js.put(GTaskStringUtils.META_HEAD_NOTE, note); + return js; + } else { + // synced task + // 如果是已同步的任务 + JSONObject note = mMetaInfo.getJSONObject(GTaskStringUtils.META_HEAD_NOTE); + JSONArray dataArray = mMetaInfo.getJSONArray(GTaskStringUtils.META_HEAD_DATA); + // 遍历数据数组，更新任务名称 + for (int i = 0; i < dataArray.length(); i++) { + JSONObject data = dataArray.getJSONObject(i); + if (TextUtils.equals(data.getString(DataColumns.MIME_TYPE), DataConstants.NOTE)) { + data.put(DataColumns.CONTENT, getName()); + break; + } + } + + note.put(NoteColumns.TYPE, Notes.TYPE_NOTE); + return mMetaInfo; + } + } catch (JSONException e) { + // 捕获JSON异常并记录错误日志 + Log.e(TAG, e.toString()); + e.printStackTrace(); + return null; + } + } +/* + * 设置任务的元数据信息。 + * @param metaData 包含元数据信息的MetaData对象 + */ + public void setMetaInfo(MetaData metaData) { + // 检查MetaData对象是否为空，并且是否包含笔记信息 + if (metaData != null && metaData.getNotes() != null) { + try { + // 将笔记信息转换为JSONObject对象 + mMetaInfo = new JSONObject(metaData.getNotes()); + } catch (JSONException e) { + // 捕获JSON异常并记录警告日志 + Log.w(TAG, e.toString()); + mMetaInfo = null; + // 如果转换失败，将mMetaInfo设置为null + } + } + } +/* + * 获取同步操作类型。 + * @param c 包含本地笔记信息的Cursor对象 + * @return 同步操作类型 + */ + public int getSyncAction(Cursor c) { + try { + JSONObject noteInfo = null; + // 如果元数据信息不为空且包含笔记信息，则获取笔记信息 + if (mMetaInfo != null && mMetaInfo.has(GTaskStringUtils.META_HEAD_NOTE)) { + noteInfo = mMetaInfo.getJSONObject(GTaskStringUtils.META_HEAD_NOTE); + } + // 如果笔记信息为空，表示笔记元数据已被删除 + if (noteInfo == null) { + Log.w(TAG, "it seems that note meta has been deleted"); + return SYNC_ACTION_UPDATE_REMOTE; + } + // 如果笔记信息中不包含ID字段，表示远程笔记ID已被删除 + if (!noteInfo.has(NoteColumns.ID)) { + Log.w(TAG, "remote note id seems to be deleted"); + return SYNC_ACTION_UPDATE_LOCAL; + } + + // validate the note id now + // 验证笔记ID是否匹配 + if (c.getLong(SqlNote.ID_COLUMN) != noteInfo.getLong(NoteColumns.ID)) { + Log.w(TAG, "note id doesn't match"); + return SYNC_ACTION_UPDATE_LOCAL; + } + + if (c.getInt(SqlNote.LOCAL_MODIFIED_COLUMN) == 0) { + // there is no local update + // 如果本地没有修改 + if (c.getLong(SqlNote.SYNC_ID_COLUMN) == getLastModified()) { + // no update both side + // 如果没有更新，返回SYNC_ACTION_NONE + return SYNC_ACTION_NONE; + } else { + // apply remote to local + // 应用远程更新到本地 + return SYNC_ACTION_UPDATE_LOCAL; + } + } else { + // validate gtask id + // 验证Google任务ID是否匹配 + if (!c.getString(SqlNote.GTASK_ID_COLUMN).equals(getGid())) { + Log.e(TAG, "gtask id doesn't match"); + return SYNC_ACTION_ERROR; + } + // 如果同步ID与最后修改时间匹配，表示只有本地修改 + if (c.getLong(SqlNote.SYNC_ID_COLUMN) == getLastModified()) { + // local modification only + return SYNC_ACTION_UPDATE_REMOTE; + } else { + // 返回冲突更新 + return SYNC_ACTION_UPDATE_CONFLICT; + } + } + } catch (Exception e) { + // 捕获异常并记录错误日志 + Log.e(TAG, e.toString()); + e.printStackTrace(); + } + + return SYNC_ACTION_ERROR; // 默认返回SYNC_ACTION_ERROR + } +/* + * 判断任务是否值得保存。 + * @return 如果任务值得保存，返回true；否则返回false + */ + public boolean isWorthSaving() { + // 检查元数据信息是否存在，或者任务名称和备注是否不为空且不为空白字符串 + return mMetaInfo != null || (getName() != null && getName().trim().length() > 0) + || (getNotes() != null && getNotes().trim().length() > 0); + } +/* + * 设置任务的完成状态。 + * @param completed 任务的完成状态，true表示已完成，false表示未完成 + */ + public void setCompleted(boolean completed) { + this.mCompleted = completed; + } +/* + * 设置任务的备注。 + * @param notes 任务的备注 + */ + public void setNotes(String notes) { + this.mNotes = notes; + } +/* + * 设置前一个兄弟任务。 + * @param priorSibling 前一个兄弟任务 + */ + public void setPriorSibling(Task priorSibling) { + this.mPriorSibling = priorSibling; + } +/* + * 设置父任务列表。 + * @param parent 父任务列表 + */ + public void setParent(TaskList parent) { + this.mParent = parent; + } +/* + * 获取任务的完成状态。 + * @return 任务的完成状态，true表示已完成，false表示未完成 + */ + public boolean getCompleted() { + return this.mCompleted; + } +/* + * 获取任务的备注。 + * @return 任务的备注 + */ + public String getNotes() { + return this.mNotes; + } +/* + * 获取前一个兄弟任务。 + * @return 前一个兄弟任务 + */ + public Task getPriorSibling() { + return this.mPriorSibling; + } +/* + * 获取父任务列表。 + * @return 父任务列表 + */ + public TaskList getParent() { + return this.mParent; + } + +} diff --git a/TaskList.txt b/TaskList.txt new file mode 100644 index 0000000..96f681a --- /dev/null +++ b/TaskList.txt @@ -0,0 +1,465 @@ +/* + * 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.database.Cursor; +import android.util.Log; + +import net.micode.notes.data.Notes; +import net.micode.notes.data.Notes.NoteColumns; +import net.micode.notes.gtask.exception.ActionFailureException; +import net.micode.notes.tool.GTaskStringUtils; + +import org.json.JSONException; +import org.json.JSONObject; + +import java.util.ArrayList; + +/* + * TaskList类表示一个任务列表，继承自Node类。 + * 该类包含了任务列表的各种属性和操作方法，如创建、更新、设置内容等。 + */ +public class TaskList extends Node { + private static final String TAG = TaskList.class.getSimpleName(); + + private int mIndex; // 任务列表的索引 + + private ArrayList mChildren; // 子任务列表 +/* + * 构造函数，初始化任务列表对象。 + */ + public TaskList() { + super(); + mChildren = new ArrayList(); + mIndex = 1; + } +/* + * 生成创建任务列表的JSON对象。 + * @param actionId 操作ID + * @return 包含创建任务列表信息的JSONObject + */ + public JSONObject getCreateAction(int actionId) { + JSONObject js = new JSONObject(); + + try { + // action_type + // 设置操作类型为创建 + js.put(GTaskStringUtils.GTASK_JSON_ACTION_TYPE, + GTaskStringUtils.GTASK_JSON_ACTION_TYPE_CREATE); + + // action_id + // 设置操作ID + js.put(GTaskStringUtils.GTASK_JSON_ACTION_ID, actionId); + + // index + // 设置索引 + js.put(GTaskStringUtils.GTASK_JSON_INDEX, mIndex); + + // entity_delta + // 设置实体信息 + JSONObject entity = new JSONObject(); + entity.put(GTaskStringUtils.GTASK_JSON_NAME, getName()); + entity.put(GTaskStringUtils.GTASK_JSON_CREATOR_ID, "null"); + entity.put(GTaskStringUtils.GTASK_JSON_ENTITY_TYPE, + GTaskStringUtils.GTASK_JSON_TYPE_GROUP); + js.put(GTaskStringUtils.GTASK_JSON_ENTITY_DELTA, entity); + + } catch (JSONException e) { + Log.e(TAG, e.toString()); + e.printStackTrace(); + throw new ActionFailureException("fail to generate tasklist-create jsonobject"); + } + + return js; + } +/* + * 生成更新任务列表的JSON对象。 + * @param actionId 操作ID + * @return 包含更新任务列表信息的JSONObject + */ + public JSONObject getUpdateAction(int actionId) { + JSONObject js = new JSONObject(); + + try { + // action_type + // 设置操作类型为更新 + js.put(GTaskStringUtils.GTASK_JSON_ACTION_TYPE, + GTaskStringUtils.GTASK_JSON_ACTION_TYPE_UPDATE); + + // action_id + // 设置操作ID + js.put(GTaskStringUtils.GTASK_JSON_ACTION_ID, actionId); + + // id + // 设置任务列表的ID + js.put(GTaskStringUtils.GTASK_JSON_ID, getGid()); + + // entity_delta + // 设置任务列表的实体信息 + JSONObject entity = new JSONObject(); + entity.put(GTaskStringUtils.GTASK_JSON_NAME, getName()); + entity.put(GTaskStringUtils.GTASK_JSON_DELETED, getDeleted()); + js.put(GTaskStringUtils.GTASK_JSON_ENTITY_DELTA, entity); + + } catch (JSONException e) { + // 捕获JSON异常并记录错误日志 + Log.e(TAG, e.toString()); + e.printStackTrace(); + // 抛出自定义异常，表示生成JSON对象失败 + throw new ActionFailureException("fail to generate tasklist-update jsonobject"); + } + + return js; // 返回包含更新任务列表信息的JSONObject + } +/* + * 根据远程JSON对象设置任务列表的内容。 + * @param js 包含任务列表信息的远程JSON对象 + */ + public void setContentByRemoteJSON(JSONObject js) { + if (js != null) { + try { + // id + // 如果JSON对象中包含ID字段，则设置任务列表的ID + if (js.has(GTaskStringUtils.GTASK_JSON_ID)) { + setGid(js.getString(GTaskStringUtils.GTASK_JSON_ID)); + } + + // last_modified + // 如果JSON对象中包含最后修改时间字段，则设置任务列表的最后修改时间 + if (js.has(GTaskStringUtils.GTASK_JSON_LAST_MODIFIED)) { + setLastModified(js.getLong(GTaskStringUtils.GTASK_JSON_LAST_MODIFIED)); + } + + // name + // 如果JSON对象中包含名称字段，则设置任务列表的名称 + if (js.has(GTaskStringUtils.GTASK_JSON_NAME)) { + setName(js.getString(GTaskStringUtils.GTASK_JSON_NAME)); + } + + } catch (JSONException e) { + // 捕获JSON异常并记录错误日志 + Log.e(TAG, e.toString()); + e.printStackTrace(); + // 抛出自定义异常，表示从JSON对象获取任务列表内容失败 + throw new ActionFailureException("fail to get tasklist content from jsonobject"); + } + } + } +/* + * 根据本地JSON对象设置任务列表的内容。 + * @param js 包含任务列表信息的本地JSON对象 + */ + public void setContentByLocalJSON(JSONObject js) { + // 检查JSON对象是否为空或是否包含必要的字段 + if (js == null || !js.has(GTaskStringUtils.META_HEAD_NOTE)) { + Log.w(TAG, "setContentByLocalJSON: nothing is avaiable"); + } + + try { + // 获取文件夹的元数据 + JSONObject folder = js.getJSONObject(GTaskStringUtils.META_HEAD_NOTE); + // 检查文件夹的类型 + if (folder.getInt(NoteColumns.TYPE) == Notes.TYPE_FOLDER) { + // 如果是普通文件夹类型，获取文件夹名称并设置任务列表名称 + String name = folder.getString(NoteColumns.SNIPPET); + setName(GTaskStringUtils.MIUI_FOLDER_PREFFIX + name); + } else if (folder.getInt(NoteColumns.TYPE) == Notes.TYPE_SYSTEM) { + // 如果是系统文件夹类型，根据文件夹ID设置任务列表名称 + if (folder.getLong(NoteColumns.ID) == Notes.ID_ROOT_FOLDER) + setName(GTaskStringUtils.MIUI_FOLDER_PREFFIX + GTaskStringUtils.FOLDER_DEFAULT); + else if (folder.getLong(NoteColumns.ID) == Notes.ID_CALL_RECORD_FOLDER) + setName(GTaskStringUtils.MIUI_FOLDER_PREFFIX + + GTaskStringUtils.FOLDER_CALL_NOTE); + else + Log.e(TAG, "invalid system folder"); + } else { + // 如果文件夹类型无效，记录错误日志 + Log.e(TAG, "error type"); + } + } catch (JSONException e) { + // 捕获JSON异常并记录错误日志 + Log.e(TAG, e.toString()); + e.printStackTrace(); + } + } +/* + * 根据任务列表内容生成本地JSON对象。 + * @return 包含任务列表内容的本地JSON对象，如果发生错误则返回null + */ + public JSONObject getLocalJSONFromContent() { + try { + // 创建一个新的JSON对象 + JSONObject js = new JSONObject(); + JSONObject folder = new JSONObject(); + // 获取任务列表的名称 + String folderName = getName(); + // 如果名称以GTaskStringUtils.MIUI_FOLDER_PREFFIX开头，则去掉前缀 + if (getName().startsWith(GTaskStringUtils.MIUI_FOLDER_PREFFIX)) + folderName = folderName.substring(GTaskStringUtils.MIUI_FOLDER_PREFFIX.length(), + folderName.length()); + // 设置文件夹名称 + folder.put(NoteColumns.SNIPPET, folderName); + // 根据文件夹名称设置文件夹类型 + if (folderName.equals(GTaskStringUtils.FOLDER_DEFAULT) + || folderName.equals(GTaskStringUtils.FOLDER_CALL_NOTE)) + folder.put(NoteColumns.TYPE, Notes.TYPE_SYSTEM); + else + folder.put(NoteColumns.TYPE, Notes.TYPE_FOLDER); + // 将文件夹信息添加到JSON对象中 + js.put(GTaskStringUtils.META_HEAD_NOTE, folder); + // 返回包含任务列表内容的本地JSON对象 + return js; + } catch (JSONException e) { + // 捕获JSON异常并记录错误日志 + Log.e(TAG, e.toString()); + e.printStackTrace(); + // 如果发生错误，返回null + return null; + } + } +/* + * 获取同步操作类型。 + * @param c 包含本地笔记信息的Cursor对象 + * @return 同步操作类型 + */ + public int getSyncAction(Cursor c) { + try { + // 如果本地没有修改 + if (c.getInt(SqlNote.LOCAL_MODIFIED_COLUMN) == 0) { + // there is no local update + // 如果没有更新，返回SYNC_ACTION_NONE + if (c.getLong(SqlNote.SYNC_ID_COLUMN) == getLastModified()) { + // no update both side + return SYNC_ACTION_NONE; + } else { + // 应用远程更新到本地 + // apply remote to local + return SYNC_ACTION_UPDATE_LOCAL; + } + } else { + // 验证Google任务ID是否匹配 + // validate gtask id + if (!c.getString(SqlNote.GTASK_ID_COLUMN).equals(getGid())) { + Log.e(TAG, "gtask id doesn't match"); + return SYNC_ACTION_ERROR; + } + // 如果同步ID与最后修改时间匹配，表示只有本地修改 + if (c.getLong(SqlNote.SYNC_ID_COLUMN) == getLastModified()) { + // local modification only + return SYNC_ACTION_UPDATE_REMOTE; + } else { + // for folder conflicts, just apply local modification + // 对于文件夹冲突，直接应用本地修改 + return SYNC_ACTION_UPDATE_REMOTE; + } + } + } catch (Exception e) { + Log.e(TAG, e.toString()); + // 捕获异常并记录错误日志 + e.printStackTrace(); + } + + return SYNC_ACTION_ERROR; // 默认返回SYNC_ACTION_ERROR + } +/* + * 获取子任务的数量。 + * @return 子任务的数量 + */ + public int getChildTaskCount() { + return mChildren.size(); + } +/* + * 添加子任务到任务列表中。 + * @param task 要添加的子任务 + * @return 如果成功添加子任务，返回true；否则返回false + */ + public boolean addChildTask(Task task) { + boolean ret = false; + // 检查任务是否为空且是否已存在于子任务列表中 + if (task != null && !mChildren.contains(task)) { + // 将任务添加到子任务列表中 + ret = mChildren.add(task); + if (ret) { + // need to set prior sibling and parent + // 需要设置前一个兄弟任务和父任务 + task.setPriorSibling(mChildren.isEmpty() ? null : mChildren + .get(mChildren.size() - 1)); + task.setParent(this); + } + } + return ret; + } +/* + * 在指定索引位置添加子任务到任务列表中。 + * @param task 要添加的子任务 + * @param index 要添加的索引位置 + * @return 如果成功添加子任务，返回true；否则返回false + */ + public boolean addChildTask(Task task, int index) { + // 检查索引是否有效 + if (index < 0 || index > mChildren.size()) { + Log.e(TAG, "add child task: invalid index"); + return false; + } + // 检查任务是否为空且是否已存在于子任务列表中 + int pos = mChildren.indexOf(task); + if (task != null && pos == -1) { + // 在指定索引位置添加任务 + mChildren.add(index, task); + + // update the task list + // 更新任务列表 + Task preTask = null; + Task afterTask = null; + if (index != 0) + preTask = mChildren.get(index - 1); + if (index != mChildren.size() - 1) + afterTask = mChildren.get(index + 1); + // 设置任务的前一个兄弟任务 + task.setPriorSibling(preTask); + // 如果存在后一个兄弟任务，则更新其后一个兄弟任务的前一个兄弟任务 + if (afterTask != null) + afterTask.setPriorSibling(task); + } + + return true; + } +/* + * 从任务列表中移除指定的子任务。 + * @param task 要移除的子任务 + * @return 如果成功移除子任务，返回true；否则返回false + */ + public boolean removeChildTask(Task task) { + boolean ret = false; + // 获取任务在子任务列表中的索引 + int index = mChildren.indexOf(task); + if (index != -1) { + // 从子任务列表中移除任务 + ret = mChildren.remove(task); + + if (ret) { + // reset prior sibling and parent + // 重置任务的前一个兄弟任务和父任务 + task.setPriorSibling(null); + task.setParent(null); + + // update the task list + // 更新任务列表 + if (index != mChildren.size()) { + // 如果移除的任务不是最后一个任务，则更新其后一个任务的前一个兄弟任务 + mChildren.get(index).setPriorSibling( + index == 0 ? null : mChildren.get(index - 1)); + } + } + } + return ret; + } +/* + * 将子任务移动到指定索引位置。 + * @param task 要移动的子任务 + * @param index 目标索引位置 + * @return 如果成功移动子任务，返回true；否则返回false + */ + public boolean moveChildTask(Task task, int index) { + // 检查目标索引是否有效 + if (index < 0 || index >= mChildren.size()) { + Log.e(TAG, "move child task: invalid index"); + return false; + } + // 获取任务在子任务列表中的当前位置 + int pos = mChildren.indexOf(task); + if (pos == -1) { + Log.e(TAG, "move child task: the task should in the list"); + return false; + } + // 如果目标索引与当前位置相同，则无需移动 + if (pos == index) + return true; + // 先移除任务，然后将其添加到目标索引位置 + return (removeChildTask(task) && addChildTask(task, index)); + } +/* + * 根据任务的全局唯一标识符（GID）查找子任务。 + * @param gid 任务的全局唯一标识符 + * @return 找到的子任务，如果未找到则返回null + */ + public Task findChildTaskByGid(String gid) { + // 遍历子任务列表 + for (int i = 0; i < mChildren.size(); i++) { + Task t = mChildren.get(i); + // 如果任务的GID与传入的GID匹配，则返回该任务 + if (t.getGid().equals(gid)) { + return t; + } + } + // 如果未找到匹配的任务，返回null + return null; + } +/* + * 获取子任务在任务列表中的索引。 + * @param task 子任务 + * @return 子任务在任务列表中的索引，如果未找到则返回-1 + */ + public int getChildTaskIndex(Task task) { + return mChildren.indexOf(task); + } +/* + * 根据索引获取子任务。 + * @param index 子任务的索引 + * @return 指定索引位置的子任务，如果索引无效则返回null + */ + public Task getChildTaskByIndex(int index) { + if (index < 0 || index >= mChildren.size()) { + Log.e(TAG, "getTaskByIndex: invalid index"); + return null; + } + return mChildren.get(index); + } +/* + * 根据任务的全局唯一标识符（GID）获取子任务。 + * @param gid 任务的全局唯一标识符 + * @return 找到的子任务，如果未找到则返回null + */ + public Task getChilTaskByGid(String gid) { + for (Task task : mChildren) { + if (task.getGid().equals(gid)) + return task; + } + return null; + } +/* + * 获取子任务列表。 + * @return 子任务列表 + */ + public ArrayList getChildTaskList() { + return this.mChildren; + } +/* + * 设置任务列表的索引。 + * @param index 任务列表的索引 + */ + public void setIndex(int index) { + this.mIndex = index; + } +/* + * 获取任务列表的索引。 + * @return 任务列表的索引 + */ + public int getIndex() { + return this.mIndex; + } +} diff --git a/WorkingNote.txt b/WorkingNote.txt new file mode 100644 index 0000000..8e7a29c --- /dev/null +++ b/WorkingNote.txt @@ -0,0 +1,532 @@ +/* + * 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.appwidget.AppWidgetManager; +import android.content.ContentUris; +import android.content.Context; +import android.database.Cursor; +import android.text.TextUtils; +import android.util.Log; + +import net.micode.notes.data.Notes; +import net.micode.notes.data.Notes.CallNote; +import net.micode.notes.data.Notes.DataColumns; +import net.micode.notes.data.Notes.DataConstants; +import net.micode.notes.data.Notes.NoteColumns; +import net.micode.notes.data.Notes.TextNote; +import net.micode.notes.tool.ResourceParser.NoteBgResources; + +/* + * WorkingNote 类用于管理笔记的创建、加载、保存和设置。 + */ +public class WorkingNote { + // Note for the working note + // 当前工作笔记的 Note 对象 + private Note mNote; + // Note Id + // 笔记的唯一标识符 + private long mNoteId; + // Note content + // 笔记内容 + private String mContent; + // Note mode + // 笔记模式 + private int mMode; + // 提醒日期 + private long mAlertDate; + // 修改日期 + private long mModifiedDate; + // 背景颜色 ID + private int mBgColorId; + // 小部件 ID + private int mWidgetId; + // 小部件类型 + private int mWidgetType; + // 文件夹 ID + private long mFolderId; + // 应用程序上下文 + private Context mContext; + // 日志标签 + private static final String TAG = "WorkingNote"; + // 是否已删除 + private boolean mIsDeleted; + // 笔记设置状态监听器 + private NoteSettingChangedListener mNoteSettingStatusListener; +/* + * 数据查询投影。 + * 该常量定义了在查询数据时需要返回的列。 + */ + public static final String[] DATA_PROJECTION = new String[] { + DataColumns.ID, // 数据的唯一标识符 + DataColumns.CONTENT, // 数据内容 + DataColumns.MIME_TYPE,// 数据的 MIME 类型 + DataColumns.DATA1,// 数据字段 1 + DataColumns.DATA2, // 数据字段 2 + DataColumns.DATA3, // 数据字段 3 + DataColumns.DATA4, // 数据字段 4 + }; +/* + * 笔记查询投影。 + * 该常量定义了在查询笔记时需要返回的列。 + * @see NoteColumns + */ + public static final String[] NOTE_PROJECTION = new String[] { + NoteColumns.PARENT_ID, // 笔记的父 ID（文件夹 ID） + NoteColumns.ALERTED_DATE, // 笔记的提醒日期 + NoteColumns.BG_COLOR_ID, // 笔记的背景颜色 ID + NoteColumns.WIDGET_ID, // 笔记的小部件 ID + NoteColumns.WIDGET_TYPE, // 笔记的小部件类型 + NoteColumns.MODIFIED_DATE // 笔记的修改日期 + }; + // 数据列索引 + private static final int DATA_ID_COLUMN = 0; + + private static final int DATA_CONTENT_COLUMN = 1; + + private static final int DATA_MIME_TYPE_COLUMN = 2; + + private static final int DATA_MODE_COLUMN = 3; + // 笔记列索引 + private static final int NOTE_PARENT_ID_COLUMN = 0; + + private static final int NOTE_ALERTED_DATE_COLUMN = 1; + + private static final int NOTE_BG_COLOR_ID_COLUMN = 2; + + private static final int NOTE_WIDGET_ID_COLUMN = 3; + + private static final int NOTE_WIDGET_TYPE_COLUMN = 4; + + private static final int NOTE_MODIFIED_DATE_COLUMN = 5; + + // New note construct + /* + * 创建一个新的空笔记。 + * 该构造函数用于初始化一个新的空笔记对象。 + * @param context 应用程序上下文。 + * @param folderId 文件夹 ID。 + */ + private WorkingNote(Context context, long folderId) { + // 设置应用程序上下文 + mContext = context; + mAlertDate = 0; // 初始化提醒日期为 0 + mModifiedDate = System.currentTimeMillis();// 设置修改日期为当前时间 + mFolderId = folderId;// 设置文件夹 ID + mNote = new Note();// 创建一个新的 Note 对象 + mNoteId = 0;// 初始化笔记 ID 为 0 + mIsDeleted = false;// 初始化删除状态为 false + mMode = 0;// 初始化笔记模式为 0 + mWidgetType = Notes.TYPE_WIDGET_INVALIDE;// 初始化小部件类型为无效类型 + } + + // Existing note construct + /* + * 加载现有的笔记 + * 该构造函数用于加载现有的笔记对象。 + * @param context 应用程序上下文。 + * @param noteId 笔记的唯一标识符。 + * @param folderId 文件夹 ID。 + */ + private WorkingNote(Context context, long noteId, long folderId) { + mContext = context;// 设置应用程序上下文 + mNoteId = noteId;// 设置笔记的唯一标识符 + mFolderId = folderId;// 设置文件夹 ID + mIsDeleted = false;// 初始化删除状态为 false + mNote = new Note(); // 创建一个新的 Note 对象 + loadNote();// 加载笔记数据 + } +/* + * 加载笔记数据。 + * 该方法用于从内容提供者中加载笔记数据，并将其设置到当前的 WorkingNote 对象中。 + */ + private void loadNote() { + // 查询笔记数据 + Cursor cursor = mContext.getContentResolver().query( + ContentUris.withAppendedId(Notes.CONTENT_NOTE_URI, mNoteId), NOTE_PROJECTION, null, + null, null); // 检查游标是否为空 + + if (cursor != null) { // 移动游标到第一行 + if (cursor.moveToFirst()) { + mFolderId = cursor.getLong(NOTE_PARENT_ID_COLUMN); // 获取文件夹 ID + mBgColorId = cursor.getInt(NOTE_BG_COLOR_ID_COLUMN); // 获取背景颜色 ID + mWidgetId = cursor.getInt(NOTE_WIDGET_ID_COLUMN);// 获取小部件 ID + mWidgetType = cursor.getInt(NOTE_WIDGET_TYPE_COLUMN); // 获取小部件类型 + mAlertDate = cursor.getLong(NOTE_ALERTED_DATE_COLUMN);// 获取提醒日期 + mModifiedDate = cursor.getLong(NOTE_MODIFIED_DATE_COLUMN);// 获取修改日期 + } + cursor.close(); // 关闭游标 + } else { // 记录错误日志 + Log.e(TAG, "No note with id:" + mNoteId); + // 抛出异常 + throw new IllegalArgumentException("Unable to find note with id " + mNoteId); + } + loadNoteData();// 加载笔记数据 + } +/* + * 加载笔记数据。 + * 该方法用于从内容提供者中加载笔记的具体数据，并将其设置到当前的 WorkingNote 对象中。 + */ + private void loadNoteData() {// 查询笔记数据 + Cursor cursor = mContext.getContentResolver().query(Notes.CONTENT_DATA_URI, DATA_PROJECTION, + DataColumns.NOTE_ID + "=?", new String[] { + String.valueOf(mNoteId) + }, null); // 检查游标是否为空 + + if (cursor != null) { // 移动游标到第一行 + if (cursor.moveToFirst()) { + do { // 获取数据的 MIME 类型 + String type = cursor.getString(DATA_MIME_TYPE_COLUMN); + if (DataConstants.NOTE.equals(type)) {// 根据 MIME 类型处理数据 + mContent = cursor.getString(DATA_CONTENT_COLUMN); // 如果是文本笔记，获取内容和模式 + mMode = cursor.getInt(DATA_MODE_COLUMN); + mNote.setTextDataId(cursor.getLong(DATA_ID_COLUMN)); + } else if (DataConstants.CALL_NOTE.equals(type)) { + mNote.setCallDataId(cursor.getLong(DATA_ID_COLUMN)); // 如果是通话笔记，获取通话数据 ID + } else { + Log.d(TAG, "Wrong note type with type:" + type); // 记录错误日志 + } + } while (cursor.moveToNext());// 移动到下一行 + } + cursor.close(); // 关闭游标 + } else { + Log.e(TAG, "No data with id:" + mNoteId); // 记录错误日志 + // 抛出异常 + throw new IllegalArgumentException("Unable to find note's data with id " + mNoteId); + } + } +/* + * 创建一个新的空笔记。 + * 该方法用于创建一个新的空笔记对象，并设置其背景颜色、小部件 ID 和小部件类型。 + * @param context 应用程序上下文。 + * @param folderId 文件夹 ID。 + * @param widgetId 小部件 ID。 + * @param widgetType 小部件类型。 + * @param defaultBgColorId 默认背景颜色 ID。 + * @return 新的 WorkingNote 对象。 + */ + public static WorkingNote createEmptyNote(Context context, long folderId, int widgetId, + int widgetType, int defaultBgColorId) { + WorkingNote note = new WorkingNote(context, folderId);// 创建一个新的空笔记对象 + note.setBgColorId(defaultBgColorId); // 设置背景颜色 ID + note.setWidgetId(widgetId);// 设置小部件 ID + note.setWidgetType(widgetType); // 设置小部件类型 + return note;// 返回新的 WorkingNote 对象 + } +/* + *加载现有的笔记。 + * 该方法用于加载现有的笔记对象。 + * @param context 应用程序上下文。 + * @param id 笔记的唯一标识符。 + * @return 加载的 WorkingNote 对象。 + */ + public static WorkingNote load(Context context, long id) { + return new WorkingNote(context, id, 0); // 返回一个新的 WorkingNote 对象，使用指定的上下文和笔记 ID + } +/* + * 保存笔记。 + * 该方法用于保存当前的笔记对象。如果笔记值得保存，则将其同步到数据库中，并更新小部件内容（如果存在小部件）。 + * @return 如果保存成功，则返回 true；否则返回 false。 + */ + public synchronized boolean saveNote() { + if (isWorthSaving()) { // 检查笔记是否值得保存 + if (!existInDatabase()) { // 如果笔记不存在于数据库中 + if ((mNoteId = Note.getNewNoteId(mContext, mFolderId)) == 0) { + // 获取新的笔记 ID + Log.e(TAG, "Create new note fail with id:" + mNoteId);// 记录错误日志 + return false; + } + } + + mNote.syncNote(mContext, mNoteId);// 同步笔记到数据库 + + /** + * Update widget content if there exist any widget of this note + * 如果存在该笔记的小部件，更新小部件内容。 + */ + if (mWidgetId != AppWidgetManager.INVALID_APPWIDGET_ID + && mWidgetType != Notes.TYPE_WIDGET_INVALIDE + && mNoteSettingStatusListener != null) { + mNoteSettingStatusListener.onWidgetChanged(); + } + return true; + } else { + return false; + } + } +/* + * 检查笔记是否存在于数据库中。 + * 该方法用于检查当前笔记对象是否已经存在于数据库中。 + * @return 如果笔记存在于数据库中，则返回 true；否则返回 false。 + */ + public boolean existInDatabase() {// 如果笔记 ID 大于 0，表示笔记存在于数据库中 + return mNoteId > 0; + } +/* + * 检查笔记是否值得保存。 + * 该方法用于检查当前笔记对象是否值得保存。如果笔记已被删除、内容为空且不存在于数据库中，或者笔记存在于数据库中但没有本地修改，则不值得保存。 + * @return 如果笔记值得保存，则返回 true；否则返回 false。 + */ + private boolean isWorthSaving() { + // 如果笔记已被删除，或者内容为空且不存在于数据库中，或者笔记存在于数据库中但没有本地修改，则不值得保存 + if (mIsDeleted || (!existInDatabase() && TextUtils.isEmpty(mContent)) + || (existInDatabase() && !mNote.isLocalModified())) { + return false; + } else { + return true; + } + } +/* + * 设置笔记设置状态监听器。 + * 该方法用于设置笔记设置状态的监听器，以便在笔记设置状态发生变化时通知监听器。 + * @param l 笔记设置状态监听器。 + */ + public void setOnSettingStatusChangedListener(NoteSettingChangedListener l) { + mNoteSettingStatusListener = l; // 设置笔记设置状态监听器 + } +/* + * 设置提醒日期。 + * 该方法用于设置笔记的提醒日期。如果新的提醒日期与当前提醒日期不同，则更新提醒日期，并通知笔记设置状态监听器。 + * @param date 提醒日期。 + * @param set 是否设置提醒。 + */ + public void setAlertDate(long date, boolean set) { + if (date != mAlertDate) { // 如果新的提醒日期与当前提醒日期不同 + mAlertDate = date;// 更新提醒日期 + mNote.setNoteValue(NoteColumns.ALERTED_DATE, String.valueOf(mAlertDate));// 设置笔记的提醒日期 + } + if (mNoteSettingStatusListener != null) {// 如果笔记设置状态监听器不为空 + mNoteSettingStatusListener.onClockAlertChanged(date, set); // 通知笔记设置状态监听器提醒日期已更改 + } + } +/* + * 标记笔记为已删除或未删除。 + * 该方法用于标记笔记为已删除或未删除。如果笔记存在小部件，并且笔记设置状态监听器不为空，则通知笔记设置状态监听器小部件已更改。 + * @param mark 是否标记为已删除。 + */ + public void markDeleted(boolean mark) { + mIsDeleted = mark; // 标记笔记为已删除或未删除 + if (mWidgetId != AppWidgetManager.INVALID_APPWIDGET_ID // 如果笔记存在小部件，并且笔记设置状态监听器不为空 + && mWidgetType != Notes.TYPE_WIDGET_INVALIDE && mNoteSettingStatusListener != null) { + // 通知笔记设置状态监听器小部件已更改 + mNoteSettingStatusListener.onWidgetChanged(); + } + } +/* + * 设置背景颜色 ID。 + * 该方法用于设置笔记的背景颜色 ID。如果新的背景颜色 ID 与当前背景颜色 ID 不同，则更新背景颜色 ID，并通知笔记设置状态监听器背景颜色已更改。 + * @param id 背景颜色 ID。 + */ + public void setBgColorId(int id) { + if (id != mBgColorId) { // 如果新的背景颜色 ID 与当前背景颜色 ID 不同 + mBgColorId = id;// 更新背景颜色 ID + if (mNoteSettingStatusListener != null) { // 如果笔记设置状态监听器不为空 + mNoteSettingStatusListener.onBackgroundColorChanged(); // 通知笔记设置状态监听器背景颜色已更改 + } + mNote.setNoteValue(NoteColumns.BG_COLOR_ID, String.valueOf(id)); // 设置笔记的背景颜色 ID + } + } +/* + * 设置检查列表模式。 + * 该方法用于设置笔记的检查列表模式。如果新的模式与当前模式不同，则更新模式，并通知笔记设置状态监听器检查列表模式已更改。 + * @param mode 检查列表模式。 + */ + public void setCheckListMode(int mode) {// 如果新的模式与当前模式不同 + if (mMode != mode) { // 如果笔记设置状态监听器不为空 + if (mNoteSettingStatusListener != null) { // 通知笔记设置状态监听器检查列表模式已更改 + mNoteSettingStatusListener.onCheckListModeChanged(mMode, mode); + } + mMode = mode;// 更新模式 + mNote.setTextData(TextNote.MODE, String.valueOf(mMode)); // 设置笔记的检查列表模式 + } + } +/* + * 设置小部件类型。 + * 该方法用于设置笔记的小部件类型。如果新的类型与当前类型不同，则更新小部件类型，并将其保存到笔记数据中。 + * @param type 小部件类型。 + */ + public void setWidgetType(int type) { // 如果新的类型与当前类型不同 + if (type != mWidgetType) { // 更新小部件类型 + mWidgetType = type; + mNote.setNoteValue(NoteColumns.WIDGET_TYPE, String.valueOf(mWidgetType)); // 设置笔记的小部件类型 + } + } +/* + * 设置小部件 ID。 + * 该方法用于设置笔记的小部件 ID。如果新的 ID 与当前 ID 不同，则更新小部件 ID，并将其保存到笔记数据中。 + * @param id 小部件 ID。 + */ + public void setWidgetId(int id) { // 如果新的 ID 与当前 ID 不同 + if (id != mWidgetId) { // 更新小部件 ID + mWidgetId = id; + mNote.setNoteValue(NoteColumns.WIDGET_ID, String.valueOf(mWidgetId)); // 设置笔记的小部件 ID + } + } +/* + * 设置工作文本。 + * 该方法用于设置笔记的工作文本。如果新的文本与当前文本不同，则更新工作文本，并将其保存到笔记数据中。 + * @param text 工作文本。 + */ + public void setWorkingText(String text) { // 如果新的文本与当前文本不同 + if (!TextUtils.equals(mContent, text)) { // 更新工作文本 + mContent = text; + mNote.setTextData(DataColumns.CONTENT, mContent);// 设置笔记的工作文本 + } + } +/* + * 将笔记转换为通话笔记。 + * 该方法用于将笔记转换为通话笔记。它设置通话日期、电话号码和父文件夹 ID。 + * @param phoneNumber 电话号码。 + * @param callDate 通话日期。 + */ + public void convertToCallNote(String phoneNumber, long callDate) { + mNote.setCallData(CallNote.CALL_DATE, String.valueOf(callDate)); // 设置通话日期 + mNote.setCallData(CallNote.PHONE_NUMBER, phoneNumber);// 设置电话号码 + mNote.setNoteValue(NoteColumns.PARENT_ID, String.valueOf(Notes.ID_CALL_RECORD_FOLDER)); // 设置父文件夹 ID + } +/* + * 检查是否有提醒。 + * 该方法用于检查笔记是否有提醒。如果提醒日期大于 0，则表示有提醒。 + * @return 如果有提醒，则返回 true；否则返回 false。 + */ + public boolean hasClockAlert() { + return (mAlertDate > 0 ? true : false); + } +/* + * 获取笔记内容。 + * 该方法用于获取笔记的内容。 + * @return 笔记内容。 + */ + public String getContent() { + return mContent; + } +/* + * 获取提醒日期。 + * 该方法用于获取笔记的提醒日期。 + * @return 提醒日期。 + */ + public long getAlertDate() { + return mAlertDate; + } +/* + * 获取修改日期。 + * 该方法用于获取笔记的修改日期。 + * @return 修改日期。 + */ + public long getModifiedDate() { + return mModifiedDate; + } +/* + * 获取背景颜色资源 ID。 + * 该方法用于获取笔记的背景颜色资源 ID。 + * @return 背景颜色资源 ID。 + */ + public int getBgColorResId() { + return NoteBgResources.getNoteBgResource(mBgColorId); + } +/* + * 获取背景颜色 ID。 + * 该方法用于获取笔记的背景颜色 ID。 + * @return 背景颜色 ID。 + */ + public int getBgColorId() { + return mBgColorId; + } +/* + * 获取标题背景资源 ID。 + * 该方法用于获取笔记的标题背景资源 ID。 + * @return 标题背景资源 ID。 + */ + public int getTitleBgResId() { + return NoteBgResources.getNoteTitleBgResource(mBgColorId); + } +/* + * 获取检查列表模式。 + * 该方法用于获取笔记的检查列表模式。 + * @return 检查列表模式。 + */ + public int getCheckListMode() { + return mMode; + } +/* + * 获取笔记 ID。 + * 该方法用于获取笔记的唯一标识符。 + * @return 笔记 ID。 + */ + public long getNoteId() { + return mNoteId; + } +/* + * 获取文件夹 ID。 + * 该方法用于获取笔记所属的文件夹 ID。 + * @return 文件夹 ID。 + */ + public long getFolderId() { + return mFolderId; + } +/* + * 获取小部件 ID。 + * 该方法用于获取笔记的小部件 ID。 + * @return 小部件 ID。 + */ + public int getWidgetId() { + return mWidgetId; + } +/* + * 获取小部件类型。 + * 该方法用于获取笔记的小部件类型。 + * @return 小部件类型。 + */ + public int getWidgetType() { + return mWidgetType; + } +/* + * 笔记设置状态监听器接口。 + * 该接口定义了笔记设置状态发生变化时的回调方法。 + */ + public interface NoteSettingChangedListener { + /** + * Called when the background color of current note has just changed + * 当当前笔记的背景颜色发生变化时调用。 + */ + void onBackgroundColorChanged(); + + /** + * Called when user set clock + * 当用户设置提醒时调用。 + * @param date 提醒日期。 + * @param set 是否设置提醒 + */ + void onClockAlertChanged(long date, boolean set); + + /** + * Call when user create note from widget + * 当用户从小部件创建笔记时调用。 + */ + void onWidgetChanged(); + + /** + * Call when switch between check list mode and normal mode + * @param oldMode is previous mode before change + * @param newMode is new mode + * 当用户在检查列表模式和普通模式之间切换时调用。 + * @param oldMode 之前的模式。 + * @param newMode 新的模式。 + */ + void onCheckListModeChanged(int oldMode, int newMode); + } +} diff --git a/fandubaogao.docx b/fandubaogao.docx new file mode 100644 index 0000000..5c0fe80 Binary files /dev/null and b/fandubaogao.docx differ diff --git a/zhiliangfenxibaogao.docx b/zhiliangfenxibaogao.docx new file mode 100644 index 0000000..12ce26d Binary files /dev/null and b/zhiliangfenxibaogao.docx differ