pi9s7qa6c
/
MiNotesPlusDemo
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

提交gtask注释

Browse Source
master
qw1ko 2 years ago
parent 13cae3279f
commit 2239c8b40b
6 changed files with 162 additions and 80 deletions
Show Stats Download Patch File Download Diff File

67
Notes-master2/src/net/micode/notes/gtask/data/TaskList.java
Unescape View File

@ -29,20 +29,26 @@ import org.json.JSONObject;
import java.util.ArrayList;
//定义了一个名为TaskList的类，并继承自Node类
public class TaskList extends Node {
//定义了一个名为TAG的静态字符串变量，用于在日志中标记该类
private static final String TAG = TaskList.class.getSimpleName();
//定义了一个名为mIndex的整型变量，用于表示任务列表的索引
private int mIndex;
//定义了一个名为mChildren的Task类型的ArrayList变量，用于存储该任务列表的子任务。
private ArrayList<Task> mChildren;
//定义了一个无参构造函数，初始化了mChildren变量和mIndex变量
public TaskList() {
super();
mChildren = new ArrayList<Task>();
mIndex = 1;
}
/* 定义了一个名为getCreateAction的方法，该方法返回一个JSONObject对象，用于表示任务列表的创建动作。
该方法需要传入一个actionId参数，用于标识该动作。在方法中，首先创建了一个名为js的空的JSONObject对象。
然后，该方法按照特定的格式设置了js对象的各个字段，如action_type、action_id、index和entity_delta等。
其中，entity_delta字段包含了一些有关任务列表的具体信息，如name、creator_id和entity_type等。
如果在设置js对象的过程中发生了异常，则该方法将抛出一个ActionFailureException异常。最后，该方法返回了生成的js对象。
*/
public JSONObject getCreateAction(int actionId) {
JSONObject js = new JSONObject();
@ -128,7 +134,15 @@ public class TaskList extends Node {
}
}
}
/*setContentByLocalJSON(JSONObject js)方法根据传入的本地JSON数据来设置任务列表的内容。
首先判断传入的JSON对象是否为空或者不包含GTaskStringUtils.META_HEAD_NOTE，如果是，则记录一个警告日志。
如果不是，则从JSON对象中获取名为GTaskStringUtils.META_HEAD_NOTE的JSONObject。
判断该JSONObject中的NoteColumns.TYPE字段的值是否为Notes.TYPE_FOLDER，如果是，
则从NoteColumns.SNIPPET字段中获取任务列表的名称并通过setName()方法来设置任务列表的名称；
如果该字段的值为Notes.TYPE_SYSTEM，则进一步判断其NoteColumns.ID字段的值，如果其值为Notes.ID_ROOT_FOLDER，
则设置任务列表的名称为默认名称，如果其值为Notes.ID_CALL_RECORD_FOLDER，则设置任务列表的名称为通话笔记的名称。
如果该字段的值不是上述两种情况，则记录一个错误日志。如果在处理过程中出现异常，则记录一个错误日志并打印异常信息。
*/
public void setContentByLocalJSON(JSONObject js) {
if (js == null || !js.has(GTaskStringUtils.META_HEAD_NOTE)) {
Log.w(TAG, "setContentByLocalJSON: nothing is avaiable");
@ -156,7 +170,13 @@ public class TaskList extends Node {
e.printStackTrace();
}
}
/*getLocalJSONFromContent()方法返回一个本地JSON对象。该方法首先创建一个新的JSONObject对象，并创建一个名为folder的子对象。
然后从任务列表的名称中获取名称字符串，如果名称以GTaskStringUtils.MIUI_FOLDER_PREFFIX开头，
则截取该字符串后面的部分作为文件夹的名称。将名称字符串设置为NoteColumns.SNIPPET字段的值，
如果名称字符串是默认名称或者通话笔记名称，则将NoteColumns.TYPE字段的值设置为Notes.TYPE_SYSTEM，
否则设置为Notes.TYPE_FOLDER。将folder对象设置为META_HEAD_NOTE字段的值并返回JSONObject对象。
如果在处理过程中出现异常，则记录一个错误日志并打印异常信息。
*/
public JSONObject getLocalJSONFromContent() {
try {
JSONObject js = new JSONObject();
@ -182,7 +202,14 @@ public class TaskList extends Node {
return null;
}
}
/*getSyncAction(Cursor c)方法返回一个整型值，表示需要执行的同步操作。该方法首先判断是否存在本地更新，
如果不存在本地更新，则判断同步ID是否等于最后修改时间。如果同步ID等于最后修改时间，则说明本地和远程都没有更新，
返回SYNC_ACTION_NONE。如果同步ID不等于最后修改时间，则说明远程有更新，返回SYNC_ACTION_UPDATE_LOCAL。
如果存在本地更新，则校验gtask id字段是否和本地ID一致，如果不一致，则记录一个错误日志并返回SYNC_ACTION_ERROR。
如果gtask id和本地ID一致，则判断同步ID是否等于最后修改时间。
如果同步ID等于最后修改时间，则说明只有本地有修改，返回SYNC_ACTION_UPDATE_REMOTE。
如果同步ID不等于最后修改时间，则返回SYNC_ACTION_UPDATE_REMOTE。如果在处理过程中出现异常，则记录一个错误日志并打印异常信息。
*/
public int getSyncAction(Cursor c) {
try {
if (c.getInt(SqlNote.LOCAL_MODIFIED_COLUMN) == 0) {
@ -215,11 +242,11 @@ public class TaskList extends Node {
return SYNC_ACTION_ERROR;
}
//getChildTaskCount(): 返回子任务的数量。
public int getChildTaskCount() {
return mChildren.size();
}
//addChildTask(Task task): 添加一个子任务。如果任务不为null且不在子任务列表中，则添加到列表中，并设置前一个兄弟和父任务。
public boolean addChildTask(Task task) {
boolean ret = false;
if (task != null && !mChildren.contains(task)) {
@ -233,7 +260,7 @@ public class TaskList extends Node {
}
return ret;
}
//添加一个子任务到特定的位置。如果位置无效，则返回false。如果任务不为null且不在子任务列表中，则添加到列表中并设置前一个
public boolean addChildTask(Task task, int index) {
if (index < 0 || index > mChildren.size()) {
Log.e(TAG, "add child task: invalid index");
@ -259,7 +286,7 @@ public class TaskList extends Node {
return true;
}
//从子任务列表中移除一个任务。如果任务不在列表中，则返回false。否则从列表中移除任务，并重置前一个兄弟和父任务。如果任务后面有其他任务，则将它们的前一个兄弟设置为它的前一个兄弟。
public boolean removeChildTask(Task task) {
boolean ret = false;
int index = mChildren.indexOf(task);
@ -280,7 +307,7 @@ public class TaskList extends Node {
}
return ret;
}
// 移动一个任务到一个新的位置。如果索引无效，则返回false。如果任务不在列表中，则返回false。如果任务已经在目标位置，则返回true。否则，将任务从当前位置移除，并添加到新位置。
public boolean moveChildTask(Task task, int index) {
if (index < 0 || index >= mChildren.size()) {
@ -298,7 +325,7 @@ public class TaskList extends Node {
return true;
return (removeChildTask(task) && addChildTask(task, index));
}
//根据GID查找一个子任务。如果找到则返回该任务，否则返回null。
public Task findChildTaskByGid(String gid) {
for (int i = 0; i < mChildren.size(); i++) {
Task t = mChildren.get(i);
@ -308,11 +335,11 @@ public class TaskList extends Node {
}
return null;
}
//获取一个任务的索引。如果任务不在列表中，则返回-1。
public int getChildTaskIndex(Task task) {
return mChildren.indexOf(task);
}
//根据索引获取一个任务。如果索引无效，则返回null。
public Task getChildTaskByIndex(int index) {
if (index < 0 || index >= mChildren.size()) {
Log.e(TAG, "getTaskByIndex: invalid index");
@ -320,7 +347,7 @@ public class TaskList extends Node {
}
return mChildren.get(index);
}
//根据GID获取一个任务。如果找到则返回该任务，否则返回null。
public Task getChilTaskByGid(String gid) {
for (Task task : mChildren) {
if (task.getGid().equals(gid))
@ -328,15 +355,15 @@ public class TaskList extends Node {
}
return null;
}
//获取子任务列表。
public ArrayList<Task> getChildTaskList() {
return this.mChildren;
}
//设置任务的索引
public void setIndex(int index) {
this.mIndex = index;
}
//设置任务的索引
public int getIndex() {
return this.mIndex;
}

2
Notes-master2/src/net/micode/notes/gtask/exception/ActionFailureException.java
Unescape View File

@ -15,7 +15,7 @@
*/
package net.micode.notes.gtask.exception;
//ActionFailureException 继承自 RuntimeException，通常用于表示在执行某个操作时发生了异常或错误
public class ActionFailureException extends RuntimeException {
private static final long serialVersionUID = 4425249765923293627L;

2
Notes-master2/src/net/micode/notes/gtask/exception/NetworkFailureException.java
Unescape View File

@ -15,7 +15,7 @@
*/
package net.micode.notes.gtask.exception;
//NetworkFailureException 继承自 Exception，通常用于表示网络相关的异常或错误。
public class NetworkFailureException extends Exception {
private static final long serialVersionUID = 2107610287180234136L;

25
Notes-master2/src/net/micode/notes/gtask/remote/GTaskASyncTask.java
Unescape View File

@ -28,15 +28,15 @@ import net.micode.notes.R;
import net.micode.notes.ui.NotesListActivity;
import net.micode.notes.ui.NotesPreferenceActivity;
//定义了一个类GTaskASyncTask，继承自AsyncTask类。AsyncTask是一个抽象类，定义了异步任务的处理流程，开发者需要实现其抽象方法来处理具体的任务。
public class GTaskASyncTask extends AsyncTask<Void, String, Integer> {
//定义一个静态的通知ID
private static int GTASK_SYNC_NOTIFICATION_ID = 5234235;
//定义一个接口OnCompleteListener，包含一个方法onComplete()。在任务完成时，调用该接口的onComplete()方法，通知任务执行完毕。
public interface OnCompleteListener {
void onComplete();
}
//定义了一些成员变量，包括上下文、通知管理器、任务管理器和任务完成的监听器。
private Context mContext;
private NotificationManager mNotifiManager;
@ -44,7 +44,7 @@ public class GTaskASyncTask extends AsyncTask<Void, String, Integer> {
private GTaskManager mTaskManager;
private OnCompleteListener mOnCompleteListener;
//构造函数，初始化类中的成员变量。
public GTaskASyncTask(Context context, OnCompleteListener listener) {
mContext = context;
mOnCompleteListener = listener;
@ -52,17 +52,20 @@ public class GTaskASyncTask extends AsyncTask<Void, String, Integer> {
.getSystemService(Context.NOTIFICATION_SERVICE);
mTaskManager = GTaskManager.getInstance();
}
//定义了cancelSync()方法，用于取消同步任务
public void cancelSync() {
mTaskManager.cancelSync();
}
//定义了publishProgess()方法，用于发布同步进度。
public void publishProgess(String message) {
publishProgress(new String[] {
message
});
}
/*定义了showNotification()方法，用于显示同步任务的通知。该方法接受两个参数，第一个参数tickerId用于标识通知的类型，
第二个参数content用于显示通知内容。在该方法中，首先创建一个Notification对象，然后设置一些通知属性，例如图标、默认的提示灯等。
接下来，根据tickerId的值，创建一个PendingIntent对象，分别对应同步成功和同步失败的情况，最后调用NotificationManager的notify()方法，将通知发送到通知栏中。
*/
private void showNotification(int tickerId, String content) {
Notification notification = new Notification(R.drawable.notification, mContext
.getString(tickerId), System.currentTimeMillis());
@ -83,6 +86,7 @@ public class GTaskASyncTask extends AsyncTask<Void, String, Integer> {
}
@Override
//doInBackground() 方法是在新的线程中执行的，主要是用来执行耗时操作。在这里，它调用了 publishProgress() 方法来通知 UI 线程更新进度，然后调用了 mTaskManager.sync() 方法来进行同步操作。
protected Integer doInBackground(Void... unused) {
publishProgess(mContext.getString(R.string.sync_progress_login, NotesPreferenceActivity
.getSyncAccountName(mContext)));
@ -90,6 +94,7 @@ public class GTaskASyncTask extends AsyncTask<Void, String, Integer> {
}
@Override
//onProgressUpdate() 方法在 UI 线程中执行，它用来更新 UI。在这里，它调用了 showNotification() 方法来显示通知，并且如果当前的 mContext 对象是 GTaskSyncService 的实例，它还会发送一个广播
protected void onProgressUpdate(String... progress) {
showNotification(R.string.ticker_syncing, progress[0]);
if (mContext instanceof GTaskSyncService) {
@ -98,6 +103,10 @@ public class GTaskASyncTask extends AsyncTask<Void, String, Integer> {
}
@Override
/*onPostExecute() 方法在 UI 线程中执行，它用来处理异步任务执行完毕后的结果。
根据 mTaskManager.sync() 的返回值，它会调用 showNotification() 方法来显示不同的通知。如果 mOnCompleteListener 不为 null，
它还会在一个新线程中执行 mOnCompleteListener.onComplete() 方法
*/
protected void onPostExecute(Integer result) {
if (result == GTaskManager.STATE_SUCCESS) {
showNotification(R.string.ticker_success, mContext.getString(

121
Notes-master2/src/net/micode/notes/gtask/remote/GTaskClient.java
Unescape View File

@ -64,30 +64,40 @@ import java.util.zip.InflaterInputStream;
public class GTaskClient {
private static final String TAG = GTaskClient.class.getSimpleName();
// Google任务的URL
private static final String GTASK_URL = "https://mail.google.com/tasks/";
// Google任务的获取URL
private static final String GTASK_GET_URL = "https://mail.google.com/tasks/ig";
// Google任务的发布URL
private static final String GTASK_POST_URL = "https://mail.google.com/tasks/r/ig";
private static GTaskClient mInstance = null;
// Http客户端
private DefaultHttpClient mHttpClient;
private String mGetUrl;
private String mPostUrl;
// 客户端版本号
private long mClientVersion;
// 是否已登录
private boolean mLoggedin;
// 上次登录时间
private long mLastLoginTime;
// 操作ID
private int mActionId;
// 账户信息
private Account mAccount;
// 更新任务的JSONArray
private JSONArray mUpdateArray;
private GTaskClient() {
@ -110,14 +120,13 @@ public class GTaskClient {
}
public boolean login(Activity activity) {
// we suppose that the cookie would expire after 5 minutes
// then we need to re-login
// cookie过期时间为5分钟
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))) {
@ -129,14 +138,17 @@ public class GTaskClient {
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
// 如果有自定义域名，则使用该域名登录
if (!(mAccount.name.toLowerCase().endsWith("gmail.com") || mAccount.name.toLowerCase()
.endsWith("googlemail.com"))) {
StringBuilder url = new StringBuilder(GTASK_URL).append("a/");
@ -151,7 +163,7 @@ public class GTaskClient {
}
}
// try to login with google official url
// 尝试使用Google官方URL登录
if (!mLoggedin) {
mGetUrl = GTASK_GET_URL;
mPostUrl = GTASK_POST_URL;
@ -159,24 +171,27 @@ public class GTaskClient {
return false;
}
}
mLoggedin = true;
return true;
}
private String loginGoogleAccount(Activity activity, boolean invalidateToken) {
String authToken;
// 从 Google 帐户管理器中获取指定类型的所有帐户
AccountManager accountManager = AccountManager.get(activity);
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;
for (Account a : accounts) {
// 如果帐户名与应用程序设置中的帐户名称匹配，则使用该帐户
if (a.name.equals(accountName)) {
account = a;
break;
@ -185,38 +200,44 @@ public class GTaskClient {
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<Bundle> accountManagerFuture = accountManager.getAuthToken(account,
"goanna_mobile", null, activity, null, null);
try {
Bundle authTokenBundle = accountManagerFuture.getResult();
// 获取令牌字符串
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;
}
// 尝试使用给定的令牌登录到 Gtask
private boolean tryToLoginGtask(Activity activity, String authToken) {
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;
}
// 如果新的令牌也无法登录，则返回 false
if (!loginGtask(authToken)) {
Log.e(TAG, "login gtask failed");
return false;
@ -225,7 +246,9 @@ public class GTaskClient {
return true;
}
// 使用给定的令牌登录到 Gtask
private boolean loginGtask(String authToken) {
// 设置 HTTP 连接和套接字超时时间
int timeoutConnection = 10000;
int timeoutSocket = 15000;
HttpParams httpParameters = new BasicHttpParams();
@ -238,12 +261,14 @@ public class GTaskClient {
// login gtask
try {
// 构造登录URL
String loginUrl = mGetUrl + "?auth=" + authToken;
// 创建一个 HTTP GET 请求
HttpGet httpGet = new HttpGet(loginUrl);
HttpResponse response = null;
response = mHttpClient.execute(httpGet);
// 发送请求并获取响应
HttpResponse response = mHttpClient.execute(httpGet);
// get the cookie now
// 获取响应中的 cookie
List<Cookie> cookies = mHttpClient.getCookieStore().getCookies();
boolean hasAuthCookie = false;
for (Cookie cookie : cookies) {
@ -255,7 +280,7 @@ public class GTaskClient {
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 = ")}</script>";
@ -277,20 +302,21 @@ public class GTaskClient {
return false;
}
// 返回值为 true 表示请求成功
return true;
}
//这是一个私有方法，返回一个自增的整数值，即操作ID。在应用程序中，每个HTTP请求都有一个唯一的操作ID，用于跟踪该请求。
private int getActionId() {
return mActionId++;
}
//这个方法返回一个HttpPost对象，该对象具有两个请求头：Content-Type和AT。Content-Type指定请求正文的媒体类型，AT是一个自定义请求头，表示访问令牌
private HttpPost createHttpPost() {
HttpPost httpPost = new HttpPost(mPostUrl);
httpPost.setHeader("Content-Type", "application/x-www-form-urlencoded;charset=utf-8");
httpPost.setHeader("AT", "1");
return httpPost;
}
//这个方法返回HTTP响应实体的内容。它首先检查响应实体的内容编码是否为gzip或deflate，并相应地创建一个解压缩输入流。然后，它使用InputStreamReader和BufferedReader逐行读取响应实体的内容，并将其添加到StringBuilder中。最后，返回StringBuilder的字符串表示形式
private String getResponseContent(HttpEntity entity) throws IOException {
String contentEncoding = null;
if (entity.getContentEncoding() != null) {
@ -323,23 +349,30 @@ public class GTaskClient {
}
}
/**
* 发送HTTP POST请求以向Google任务API提交JSON数据
*
* @param js 包含JSON数据的JSONObject对象
* @return 响应数据的JSONObject对象
* @throws NetworkFailureException 如果发送请求失败，则抛出NetworkFailureException异常
*/
private JSONObject postRequest(JSONObject js) throws NetworkFailureException {
if (!mLoggedin) {
if (!mLoggedin) { // 如果未登录，则抛出异常
Log.e(TAG, "please login first");
throw new ActionFailureException("not logged in");
}
HttpPost httpPost = createHttpPost();
HttpPost httpPost = createHttpPost(); // 创建HttpPost对象
try {
LinkedList<BasicNameValuePair> list = new LinkedList<BasicNameValuePair>();
list.add(new BasicNameValuePair("r", js.toString()));
list.add(new BasicNameValuePair("r", js.toString())); // 将JSON数据作为参数添加到HttpPost对象中
UrlEncodedFormEntity entity = new UrlEncodedFormEntity(list, "UTF-8");
httpPost.setEntity(entity);
httpPost.setEntity(entity); // 设置HttpPost对象的实体
// execute the post
HttpResponse response = mHttpClient.execute(httpPost);
String jsString = getResponseContent(response.getEntity());
return new JSONObject(jsString);
// 执行HttpPost请求
HttpResponse response = mHttpClient.execute(httpPost); // 发送HttpPost请求并接收响应
String jsString = getResponseContent(response.getEntity()); // 获取响应的实体内容
return new JSONObject(jsString); // 将响应的实体内容转换为JSONObject对象并返回
} catch (ClientProtocolException e) {
Log.e(TAG, e.toString());
@ -360,20 +393,26 @@ public class GTaskClient {
}
}
/**
* 创建新任务
*
* @param task 新任务
* @throws NetworkFailureException 如果发送请求失败，则抛出NetworkFailureException异常
*/
public void createTask(Task task) throws NetworkFailureException {
commitUpdate();
commitUpdate(); // 提交更改
try {
JSONObject jsPost = new JSONObject();
JSONArray actionList = new JSONArray();
// action_list
// 添加“创建任务”操作到操作列表中
actionList.put(task.getCreateAction(getActionId()));
jsPost.put(GTaskStringUtils.GTASK_JSON_ACTION_LIST, actionList);
// client_version
// 将操作列表和客户端版本添加到jsPost对象中
jsPost.put(GTaskStringUtils.GTASK_JSON_ACTION_LIST, actionList);
jsPost.put(GTaskStringUtils.GTASK_JSON_CLIENT_VERSION, mClientVersion);
// post
// 发送HttpPost请求，并从响应中获取新任务的ID并将其设置到任务对象中
JSONObject jsResponse = postRequest(jsPost);
JSONObject jsResult = (JSONObject) jsResponse.getJSONArray(
GTaskStringUtils.GTASK_JSON_RESULTS).get(0);
@ -385,10 +424,10 @@ public class GTaskClient {
throw new ActionFailureException("create task: handing jsonobject failed");
}
}
//createTaskList 方法创建一个新的任务列表
public void createTaskList(TaskList tasklist) throws NetworkFailureException {
commitUpdate();
try {
try {//JSONObject 和 JSONArray 是 Java 中的 JSON 对象和数组，getActionId() 方法返回任务的 ID。
JSONObject jsPost = new JSONObject();
JSONArray actionList = new JSONArray();
@ -400,21 +439,25 @@ public class GTaskClient {
jsPost.put(GTaskStringUtils.GTASK_JSON_CLIENT_VERSION, mClientVersion);
// post
//postRequest 方法向服务器发送请求并返回响应的 JSON 对象。
JSONObject jsResponse = postRequest(jsPost);
JSONObject jsResult = (JSONObject) jsResponse.getJSONArray(
GTaskStringUtils.GTASK_JSON_RESULTS).get(0);
tasklist.setGid(jsResult.getString(GTaskStringUtils.GTASK_JSON_NEW_ID));
} catch (JSONException e) {
//JSONException 是在处理 JSON 时可能出现的异常。
Log.e(TAG, e.toString());
e.printStackTrace();
throw new ActionFailureException("create tasklist: handing jsonobject failed");
}
}
}//JSONException 是在处理 JSON 时可能出现的异常。
//commitUpdate 方法提交之前对任务列表的修改
public void commitUpdate() throws NetworkFailureException {
if (mUpdateArray != null) {
//if 语句检查是否存在要提交的更新
try {
//mUpdateArray 是一个 JSONArray 对象，包含要提交的更新操作。
JSONObject jsPost = new JSONObject();
// action_list
@ -423,7 +466,7 @@ public class GTaskClient {
// client_version
jsPost.put(GTaskStringUtils.GTASK_JSON_CLIENT_VERSION, mClientVersion);
postRequest(jsPost);
postRequest(jsPost);//postRequest 方法向服务器发送请求并返回响应的 JSON 对象
mUpdateArray = null;
} catch (JSONException e) {
Log.e(TAG, e.toString());
@ -432,13 +475,13 @@ public class GTaskClient {
}
}
}
//addUpdateNode 方法向任务列表中添加一个更新操作。
public void addUpdateNode(Node node) throws NetworkFailureException {
if (node != null) {
// too many update items may result in an error
// set max to 10 items
// set max to 10 itemsmUpdateArray.length() > 10 判断要提交的更新操作数量是否超过 10 个。
if (mUpdateArray != null && mUpdateArray.length() > 10) {
commitUpdate();
commitUpdate();//commitUpdate() 方法提交之前对任务列表的修改。
}
if (mUpdateArray == null)
@ -446,7 +489,7 @@ public class GTaskClient {
mUpdateArray.put(node.getUpdateAction(getActionId()));
}
}
//在 moveTask 方法中，首先调用了 commitUpdate 方法，然后创建了一个 JSON 对象 jsPost，它包含一个 JSON 数组 actionList
public void moveTask(Task task, TaskList preParent, TaskList curParent)
throws NetworkFailureException {
commitUpdate();
@ -485,7 +528,7 @@ public class GTaskClient {
throw new ActionFailureException("move task: handing jsonobject failed");
}
}
//在 deleteNode 方法中，也调用了 commitUpdate 方法，然后创建了一个 JSON 对象 jsPost，它包含一个 JSON 数组 actionList。然后将 node 对象的 deleted 属性设置为 true，并将其 updateAction 添加到 actionList 中。最后，将客户端版本设置为 jsPost 对象的属性，并使用 postRequest 方法将其发送到 Google Tasks API。如果出现任何异常，则会抛出 ActionFailureException
public void deleteNode(Node node) throws NetworkFailureException {
commitUpdate();
try {

25
Notes-master2/src/net/micode/notes/gtask/remote/GTaskSyncService.java
Unescape View File

@ -22,8 +22,9 @@ import android.content.Context;
import android.content.Intent;
import android.os.Bundle;
import android.os.IBinder;
//定义一个继承自 Service 的服务类 GTaskSyncService
public class GTaskSyncService extends Service {
//定义一些常量，其中 ACTION_STRING_NAME 是字符串类型的常量，表示同步操作的类型；ACTION_START_SYNC 和 ACTION_CANCEL_SYNC 是整型常量，分别表示开始同步和取消同步操作的类型；ACTION_INVALID 表示无效操作的类型。
public final static String ACTION_STRING_NAME = "sync_action_type";
public final static int ACTION_START_SYNC = 0;
@ -37,11 +38,11 @@ public class GTaskSyncService extends Service {
public final static String GTASK_SERVICE_BROADCAST_IS_SYNCING = "isSyncing";
public final static String GTASK_SERVICE_BROADCAST_PROGRESS_MSG = "progressMsg";
//定义静态变量 mSyncTask 和 mSyncProgress，分别表示当前的同步任务和同步进度。
private static GTaskASyncTask mSyncTask = null;
private static String mSyncProgress = "";
//定义 startSync 方法，用于开始同步任务。如果当前没有正在运行的同步任务，那么创建一个新的 GTaskASyncTask 异步任务并执行，执行完成后发送广播并停止当前服务。
private void startSync() {
if (mSyncTask == null) {
mSyncTask = new GTaskASyncTask(this, new GTaskASyncTask.OnCompleteListener() {
@ -55,19 +56,20 @@ public class GTaskSyncService extends Service {
mSyncTask.execute();
}
}
//取消正在运行的同步任务
private void cancelSync() {
if (mSyncTask != null) {
mSyncTask.cancelSync();
}
}
//重写 onCreate 方法，在服务创建时将 mSyncTask 置为 null
@Override
public void onCreate() {
mSyncTask = null;
}
@Override
//重写 onStartCommand 方法，处理服务的启动命令。如果启动命令中包含同步操作的类型，
public int onStartCommand(Intent intent, int flags, int startId) {
Bundle bundle = intent.getExtras();
if (bundle != null && bundle.containsKey(ACTION_STRING_NAME)) {
@ -87,16 +89,17 @@ public class GTaskSyncService extends Service {
}
@Override
//onLowMemory() 方法在系统内存不足时被调用，可以在此方法中释放一些占用内存的资源。在这里，如果 mSyncTask 不为空，则调用其 cancelSync() 方法取消同步任务。
public void onLowMemory() {
if (mSyncTask != null) {
mSyncTask.cancelSync();
}
}
//onBind(Intent intent) 方法是 Service 的一个回调方法，用于绑定服务。这个方法的实现在本例中返回 null，表示这个 Service 不支持绑定。
public IBinder onBind(Intent intent) {
return null;
}
//sendBroadcast(String msg) 方法将同步进度信息通过广播的形式发送出去。这里将 mSyncProgress 赋值为 msg，并创建一个 Intent 对象，设置 action 为 GTASK_SERVICE_BROADCAST_NAME 常量。然后将 mSyncTask 是否为空和 mSyncProgress 信息放到 Intent 中，调用 sendBroadcast() 方法发送广播
public void sendBroadcast(String msg) {
mSyncProgress = msg;
Intent intent = new Intent(GTASK_SERVICE_BROADCAST_NAME);
@ -104,24 +107,24 @@ public class GTaskSyncService extends Service {
intent.putExtra(GTASK_SERVICE_BROADCAST_PROGRESS_MSG, msg);
sendBroadcast(intent);
}
//startSync(Activity activity) 方法用于启动同步任务。首先通过 GTaskManager.getInstance() 获取 GTaskManager 实例，然后设置其 ActivityContext 为传入的 activity 参数。接着创建一个 Intent 对象，设置其目标服务为 GTaskSyncService，并将 ACTION_STRING_NAME 常量和 ACTION_START_SYNC 常量放到 Intent 中。最后调用 activity 的 startService() 方法启动服务。
public static void startSync(Activity activity) {
GTaskManager.getInstance().setActivityContext(activity);
Intent intent = new Intent(activity, GTaskSyncService.class);
intent.putExtra(GTaskSyncService.ACTION_STRING_NAME, GTaskSyncService.ACTION_START_SYNC);
activity.startService(intent);
}
//cancelSync(Context context) 方法用于取消同步任务。创建一个 Intent 对象，设置其目标服务为 GTaskSyncService，并将 ACTION_STRING_NAME 常量和 ACTION_CANCEL_SYNC 常量放到 Intent 中。最后调用 context 的 startService() 方法启动服务。
public static void cancelSync(Context context) {
Intent intent = new Intent(context, GTaskSyncService.class);
intent.putExtra(GTaskSyncService.ACTION_STRING_NAME, GTaskSyncService.ACTION_CANCEL_SYNC);
context.startService(intent);
}
//isSyncing() 方法用于判断是否正在进行同步任务。直接返回 mSyncTask 是否为空的结果。
public static boolean isSyncing() {
return mSyncTask != null;
}
//isSyncing() 方法用于判断是否正在进行同步任务。直接返回 mSyncTask 是否为空的结果。
public static String getProgressString() {
return mSyncProgress;
}

Write Preview
Loading…
Cancel
Save