diff --git a/src/app/src/main/java/net/micode/notes/gtask/remote/GTaskASyncTask.java b/src/app/src/main/java/net/micode/notes/gtask/remote/GTaskASyncTask.java index 0e5f458..1b6234e 100644 --- a/src/app/src/main/java/net/micode/notes/gtask/remote/GTaskASyncTask.java +++ b/src/app/src/main/java/net/micode/notes/gtask/remote/GTaskASyncTask.java @@ -17,6 +17,14 @@ package net.micode.notes.gtask.remote; + +/*异步操作类，实现GTask的异步操作过程 + * 主要方法： + * private void showNotification(int tickerId, String content) 向用户提示当前同步的状态，是一个用于交互的方法 + * protected Integer doInBackground(Void... unused) 此方法在后台线程执行，完成任务的主要工作，通常需要较长的时间 + * protected void onProgressUpdate(String... progress) 可以使用进度条增加用户体验度。 此方法在主线程执行，用于显示任务执行的进度。 + * protected void onPostExecute(Integer result) 相当于Handler 处理UI的方式，在这里面可以使用在doInBackground 得到的结果处理操作UI +*/ import android.app.Notification; import android.app.NotificationManager; import android.app.PendingIntent; @@ -57,7 +65,7 @@ public class GTaskASyncTask extends AsyncTask { mTaskManager.cancelSync(); } - public void publishProgess(String message) { + public void publishProgess(String message) { // 发布进度单位，系统将会调用onProgressUpdate()方法更新这些值 publishProgress(new String[] { message }); @@ -67,42 +75,45 @@ public class GTaskASyncTask extends AsyncTask { Notification notification = new Notification(R.drawable.notification, mContext .getString(tickerId), System.currentTimeMillis()); notification.defaults = Notification.DEFAULT_LIGHTS; - notification.flags = Notification.FLAG_AUTO_CANCEL; - PendingIntent pendingIntent; + notification.flags = Notification.FLAG_AUTO_CANCEL;// 调用系统自带灯光 + notification.flags = Notification.FLAG_AUTO_CANCEL; // 点击清除按钮或点击通知后会自动消失 + PendingIntent pendingIntent; //一个描述了想要启动一个Activity、Broadcast或是Service的意图 + if (tickerId != R.string.ticker_success) { pendingIntent = PendingIntent.getActivity(mContext, 0, new Intent(mContext, - NotesPreferenceActivity.class), 0); + NotesPreferenceActivity.class), 0); //如果同步不成功，那么从系统取得一个用于启动一个NotesPreferenceActivity的PendingIntent对象 } else { pendingIntent = PendingIntent.getActivity(mContext, 0, new Intent(mContext, - NotesListActivity.class), 0); + NotesListActivity.class), 0);//如果同步成功，那么从系统取得一个用于启动一个NotesListActivity的PendingIntent对象 } - /* notification.setLatestEventInfo(mContext, mContext.getString(R.string.app_name), content, + notification.setLatestEventInfo(mContext, mContext.getString(R.string.app_name), content, pendingIntent); - mNotifiManager.notify(GTASK_SYNC_NOTIFICATION_ID, notification);*/ + mNotifiManager.notify(GTASK_SYNC_NOTIFICATION_ID, notification);//通过NotificationManager对象的notify（）方法来执行一个notification的消息 } @Override protected Integer doInBackground(Void... unused) { publishProgess(mContext.getString(R.string.sync_progress_login, NotesPreferenceActivity - .getSyncAccountName(mContext))); - return mTaskManager.sync(mContext, this); + .getSyncAccountName(mContext))); //利用getString,将把 NotesPreferenceActivity.getSyncAccountName(mContext))的字符串内容传进sync_progress_login中 + return mTaskManager.sync(mContext, this); //进行后台同步具体操作 + } @Override protected void onProgressUpdate(String... progress) { showNotification(R.string.ticker_syncing, progress[0]); - if (mContext instanceof GTaskSyncService) { + if (mContext instanceof GTaskSyncService) {//instanceof 判断mContext是否是GTaskSyncService的实例 ((GTaskSyncService) mContext).sendBroadcast(progress[0]); } } @Override - protected void onPostExecute(Integer result) { + protected void onPostExecute(Integer result) {//用于在执行完后台任务后更新UI,显示结果 if (result == GTaskManager.STATE_SUCCESS) { showNotification(R.string.ticker_success, mContext.getString( R.string.success_sync_account, mTaskManager.getSyncAccount())); - NotesPreferenceActivity.setLastSyncTime(mContext, System.currentTimeMillis()); + 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) { @@ -111,10 +122,10 @@ public class GTaskASyncTask extends AsyncTask { showNotification(R.string.ticker_cancel, mContext .getString(R.string.error_sync_cancelled)); } + //几种不同情况下的结果显示 if (mOnCompleteListener != null) { - new Thread(new Runnable() { - - public void run() { + new Thread(new Runnable() { //这里是方法内的一个线程 + public void run() { //完成后的操作，使用onComplete()将所有值都重新初始化，相当于完成一次操作 mOnCompleteListener.onComplete(); } }).start(); diff --git a/src/app/src/main/java/net/micode/notes/gtask/remote/GTaskClient.java b/src/app/src/main/java/net/micode/notes/gtask/remote/GTaskClient.java index ff184f5..fea7ddf 100644 --- a/src/app/src/main/java/net/micode/notes/gtask/remote/GTaskClient.java +++ b/src/app/src/main/java/net/micode/notes/gtask/remote/GTaskClient.java @@ -15,7 +15,10 @@ */ package net.micode.notes.gtask.remote; - +/* + * 主要功能：实现GTASK的登录操作，进行GTASK任务的创建，创建任务列表，从网络上获取任务和任务列表的内容 + * 主要使用类或技术：accountManager JSONObject HttpParams authToken Gid + */ import android.accounts.Account; import android.accounts.AccountManager; import android.accounts.AccountManagerFuture; @@ -60,14 +63,11 @@ import java.util.zip.GZIPInputStream; import java.util.zip.Inflater; import java.util.zip.InflaterInputStream; -/* - * 主要功能：实现GTASK的登录操作，进行GTASK任务的创建，创建任务列表，从网络上获取任务和任务列表的内容 - * 主要使用类或技术：accountManager JSONObject HttpParams authToken Gid - */ + 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_URL = "https://mail.google.com/tasks/";//这个是指定的URL private static final String GTASK_GET_URL = "https://mail.google.com/tasks/ig"; @@ -104,7 +104,8 @@ public class GTaskClient { mAccount = null; mUpdateArray = null; } - /*用来获取的实例化对象 + + /*用来获取的实例化对象 * 使用 getInstance() * 返回mInstance这个实例化对象 */ @@ -114,67 +115,59 @@ public class GTaskClient { } return mInstance; } + /*用来实现登录操作的函数，传入的参数是一个Activity - 设置登录操作限制时间，如果超时则需要重新登录 - 有两种登录方式，使用用户自己的URL登录或者使用谷歌官方的URL登录 - 返回true或者false，即最后是否登陆成功 + * 设置登录操作限制时间，如果超时则需要重新登录 + * 有两种登录方式，使用用户自己的URL登录或者使用谷歌官方的URL登录 + * 返回true或者false，即最后是否登陆成功 */ - public boolean login(Activity activity) { + + public boolean login(Activity activity) { // we suppose that the cookie would expire after 5 minutes // then we need to re-login - //判断距离最后一次登录操作是否超过5分钟 + //判断距离最后一次登录操作是否超过5分钟 final long interval = 1000 * 60 * 5; if (mLastLoginTime + interval < System.currentTimeMillis()) { mLoggedin = false; } - // need to re-login after account switch - + // need to re-login after account switch 重新登录操作 if (mLoggedin && !TextUtils.equals(getSyncAccount().name, NotesPreferenceActivity .getSyncAccountName(activity))) { mLoggedin = false; } - //如果没超过时间，则不需要重新登录 + if (mLoggedin) { Log.d(TAG, "already logged in"); return true; } - //更新最后登录时间，改为系统当前的时间 - mLastLoginTime = System.currentTimeMillis(); - //判断是否登录到谷歌账户 - String authToken = loginGoogleAccount(activity, false); + + mLastLoginTime = System.currentTimeMillis();//更新最后登录时间，改为系统当前的时间 + 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"))) - //将用户账号名改为统一格式（小写）后判断是否为一个谷歌账号地址 - { + //尝试使用用户自己的域名登录 + 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 + "/"); - //设置用户对应的getUrl - mGetUrl = url.toString() + "ig"; - //设置用户对应的postUrl - mPostUrl = url.toString() + "r/ig"; - //如果用户账户无法登录，则使用谷歌官方的URI进行登录 + mGetUrl = url.toString() + "ig";//设置用户对应的getUrl + mPostUrl = url.toString() + "r/ig"; //设置用户对应的postUrl + if (tryToLoginGtask(activity, authToken)) { mLoggedin = true; } } + // try to login with google official url + //如果用户账户无法登录，则使用谷歌官方的URI进行登录 - // try to login with google official url - //用户未登录 - /*这段代码首先检查用户是否已经登录。如果没有登录， - 它会设置GET和POST的URL，并尝试使用Google进行登录。 - 如果登录失败，它会返回false - */ if (!mLoggedin) { mGetUrl = GTASK_GET_URL; mPostUrl = GTASK_POST_URL; @@ -186,18 +179,16 @@ public class GTaskClient { mLoggedin = true; return true; } - /*具体实现登录谷歌账户的方法 - 使用令牌机制 - 使用AccountManager来管理注册账号 - 返回值是账号的令牌 + /*具体实现登录谷歌账户的方法 + * 使用令牌机制 + * 使用AccountManager来管理注册账号 + * 返回值是账号的令牌 */ + private String loginGoogleAccount(Activity activity, boolean invalidateToken) { - //令牌，是登录操作保证安全性的一个方法 - String authToken; - //AccountManager这个类给用户提供了集中注册账号的接口 - AccountManager accountManager = AccountManager.get(activity); - //获取全部以com.google结尾的account - Account[] accounts = accountManager.getAccountsByType("com.google"); + String authToken;//令牌，是登录操作保证安全性的一个方法 + AccountManager accountManager = AccountManager.get(activity);//AccountManager这个类给用户提供了集中注册账号的接口 + Account[] accounts = accountManager.getAccountsByType("com.google");//获取全部以com.google结尾的account if (accounts.length == 0) { Log.e(TAG, "there is no available google account"); @@ -205,18 +196,13 @@ public class GTaskClient { } String accountName = NotesPreferenceActivity.getSyncAccountName(activity); - Account account = null; - //遍历获得的accounts信息，寻找已经记录过的账户信息 + Account account = null;//遍历获得的accounts信息，寻找已经记录过的账户信息 for (Account a : accounts) { if (a.name.equals(accountName)) { account = a; break; } } - /** - * 如果account变量为null，记录一个错误日志并返回null。 - */ - if (account != null) { mAccount = account; } else { @@ -224,15 +210,14 @@ public class GTaskClient { return null; } - // get the token now - + // get the token now //获取选中账号的令牌 AccountManagerFuture accountManagerFuture = accountManager.getAuthToken(account, "goanna_mobile", null, activity, null, null); try { Bundle authTokenBundle = accountManagerFuture.getResult(); authToken = authTokenBundle.getString(AccountManager.KEY_AUTHTOKEN); - //如果是invalidateToken，那么需要调用invalidateAuthToken(String, String)方法废除这个无效token + //如果是invalidateToken，那么需要调用invalidateAuthToken(String, String)方法废除这个无效token if (invalidateToken) { accountManager.invalidateAuthToken("com.google", authToken); loginGoogleAccount(activity, false); @@ -244,12 +229,13 @@ public class GTaskClient { return authToken; } - //尝试登陆Gtask，这只是一个预先判断令牌是否是有效以及是否能登上GTask的方法,而不是具体实现登陆的方法 + + //尝试登陆Gtask，这只是一个预先判断令牌是否是有效以及是否能登上GTask的方法,而不是具体实现登陆的方法 private boolean tryToLoginGtask(Activity activity, String authToken) { - if (!loginGtask(authToken)) { - // maybe the auth token is out of date, now let's invalidate the + if (!loginGtask(authToken)) { + // maybe the auth token is out of authTokedate, now let's invalidate the // token and try again - //删除过一个无效的authToken，申请一个新的后再次尝试登陆 + //删除过一个无效的authToken，申请一个新的后再次尝试登陆 authToken = loginGoogleAccount(activity, true); if (authToken == null) { Log.e(TAG, "login google account failed"); @@ -263,32 +249,26 @@ public class GTaskClient { } return true; } - //实现登录GTask的具体操作 + + //实现登录GTask的具体操作 private boolean loginGtask(String authToken) { int timeoutConnection = 10000; - //socket是一种通信连接实现数据的交换的端口 - int timeoutSocket = 15000; - //实例化一个新的HTTP参数类 - HttpParams httpParameters = new BasicHttpParams(); - //设置连接超时时间 - HttpConnectionParams.setConnectionTimeout(httpParameters, timeoutConnection); - //设置设置端口超时时间 - HttpConnectionParams.setSoTimeout(httpParameters, timeoutSocket); + int timeoutSocket = 15000; //socket是一种通信连接实现数据的交换的端口 + HttpParams httpParameters = new BasicHttpParams(); //实例化一个新的HTTP参数类 + HttpConnectionParams.setConnectionTimeout(httpParameters, timeoutConnection);//设置连接超时时间 + HttpConnectionParams.setSoTimeout(httpParameters, timeoutSocket);//设置设置端口超时时间 mHttpClient = new DefaultHttpClient(httpParameters); - BasicCookieStore localBasicCookieStore = new BasicCookieStore(); - //设置本地cookie + BasicCookieStore localBasicCookieStore = new BasicCookieStore(); //设置本地cookie mHttpClient.setCookieStore(localBasicCookieStore); HttpProtocolParams.setUseExpectContinue(mHttpClient.getParams(), false); - + // login gtask try { - //设置登录的url - String loginUrl = mGetUrl + "?auth=" + authToken; - //通过登录的uri实例化网页上资源的查找 - HttpGet httpGet = new HttpGet(loginUrl); + String loginUrl = mGetUrl + "?auth=" + authToken; //设置登录的url + HttpGet httpGet = new HttpGet(loginUrl); //通过登录的uri实例化网页上资源的查找 HttpResponse response = null; response = mHttpClient.execute(httpGet); - + // get the cookie now //获取CookieStore里存放的cookie,看如果存有“GTL(不知道什么意思)”，则说明有验证成功的有效的cookie List cookies = mHttpClient.getCookieStore().getCookies(); @@ -303,7 +283,7 @@ public class GTaskClient { } // get the client version - //获取client的内容，具体操作是在返回的Content中截取从_setup(开始到)}中间的字符串内容，也就是gtask_url的内容 + //获取client的内容，具体操作是在返回的Content中截取从_setup(开始到)}中间的字符串内容，也就是gtask_url的内容 String resString = getResponseContent(response.getEntity()); String jsBegin = "_setup("; String jsEnd = ")}"; @@ -331,9 +311,9 @@ public class GTaskClient { private int getActionId() { return mActionId++; } - /*实例化创建一个用于向网络传输数据的对象 - 使用HttpPost类 - 返回一个httpPost实例化对象，但里面还没有内容 + /*实例化创建一个用于向网络传输数据的对象 + * 使用HttpPost类 + * 返回一个httpPost实例化对象，但里面还没有内容 */ private HttpPost createHttpPost() { HttpPost httpPost = new HttpPost(mPostUrl); @@ -341,33 +321,28 @@ public class GTaskClient { httpPost.setHeader("AT", "1"); return httpPost; } - /*通过URL获取响应后返回的数据，也就是网络上的数据和资源 + /*通过URL获取响应后返回的数据，也就是网络上的数据和资源 * 使用getContentEncoding()获取网络上的资源和数据 * 返回值就是获取到的资源 */ private String getResponseContent(HttpEntity entity) throws IOException { - //通过URL得到HttpEntity对象，如果不为空则使用getContent（）方法创建一个流将数据从网络都过来 String contentEncoding = null; - if (entity.getContentEncoding() != null) { + if (entity.getContentEncoding() != null) {//通过URL得到HttpEntity对象，如果不为空则使用getContent（）方法创建一个流将数据从网络都过来 contentEncoding = entity.getContentEncoding().getValue(); Log.d(TAG, "encoding: " + contentEncoding); } InputStream input = entity.getContent(); - if (contentEncoding != null && contentEncoding.equalsIgnoreCase("gzip")) { - //GZIP是使用DEFLATE进行压缩数据的另一个压缩库 + if (contentEncoding != null && contentEncoding.equalsIgnoreCase("gzip")) {//GZIP是使用DEFLATE进行压缩数据的另一个压缩库 input = new GZIPInputStream(entity.getContent()); - } else if (contentEncoding != null && contentEncoding.equalsIgnoreCase("deflate")) - //DEFLATE是一个无专利的压缩算法，它可以实现无损数据压缩 - { + } else if (contentEncoding != null && contentEncoding.equalsIgnoreCase("deflate")) {//DEFLATE是一个无专利的压缩算法，它可以实现无损数据压缩 Inflater inflater = new Inflater(true); input = new InflaterInputStream(entity.getContent(), inflater); } try { - //是一个包装类，它可以包装字符流，将字符流放入缓存里，先把字符读到缓存里，到缓存满了时候，再读入内存，是为了提供读的效率而设计的 InputStreamReader isr = new InputStreamReader(input); - BufferedReader br = new BufferedReader(isr); + BufferedReader br = new BufferedReader(isr);//是一个包装类，它可以包装字符流，将字符流放入缓存里，先把字符读到缓存里，到缓存满了时候，再读入内存，是为了提供读的效率而设计的 StringBuilder sb = new StringBuilder(); while (true) { @@ -381,29 +356,29 @@ public class GTaskClient { input.close(); } } - /*通过JSON发送请求 - * 请求的具体内容在json的实例化对象js中然后传入 - * 利用UrlEncodedFormEntity entity和httpPost.setEntity(entity)方法把js中的内容放置到httpPost中 - * 执行请求后使用getResponseContent方法得到返回的数据和资源 - * 将资源再次放入json后返回 - */ + + /*通过JSON发送请求 + * 请求的具体内容在json的实例化对象js中然后传入 + * 利用UrlEncodedFormEntity entity和httpPost.setEntity(entity)方法把js中的内容放置到httpPost中 + * 执行请求后使用getResponseContent方法得到返回的数据和资源 + * 将资源再次放入json后返回 private JSONObject postRequest(JSONObject js) throws NetworkFailureException { - if (!mLoggedin) //未登录 - { + if (!mLoggedin) { Log.e(TAG, "please login first"); throw new ActionFailureException("not logged in"); } - //实例化一个httpPost的对象用来向服务器传输数据，在这里就是发送请求，而请求的内容在js里 + //实例化一个httpPost的对象用来向服务器传输数据，在这里就是发送请求，而请求的内容在js里 HttpPost httpPost = createHttpPost(); try { LinkedList list = new LinkedList(); list.add(new BasicNameValuePair("r", js.toString())); - UrlEncodedFormEntity entity = new UrlEncodedFormEntity(list, "UTF-8");//UrlEncodedFormEntity()的形式比较单一，是普通的键值对 + UrlEncodedFormEntity entity = new UrlEncodedFormEntity(list, "UTF-8"); //UrlEncodedFormEntity()的形式比较单一，是普通的键值对 httpPost.setEntity(entity); - + // execute the post //执行这个请求 + HttpResponse response = mHttpClient.execute(httpPost); String jsString = getResponseContent(response.getEntity()); return new JSONObject(jsString); @@ -426,6 +401,7 @@ public class GTaskClient { throw new ActionFailureException("error occurs when posting request"); } } + /*创建单个任务 * 传入参数是一个.gtask.data.Task包里Task类的对象 * 利用json获取Task里的内容,并且创建相应的jsPost @@ -458,7 +434,10 @@ public class GTaskClient { throw new ActionFailureException("create task: handing jsonobject failed"); } } -//创建一个任务列表，与createTask几乎一样，区别就是最后设置的是tasklist的gid + + /* + * 创建一个任务列表，与createTask几乎一样，区别就是最后设置的是tasklist的gid + */ public void createTaskList(TaskList tasklist) throws NetworkFailureException { commitUpdate(); try { @@ -484,7 +463,8 @@ public class GTaskClient { throw new ActionFailureException("create tasklist: handing jsonobject failed"); } } - /* + + /* * 同步更新操作 * 使用JSONObject进行数据存储，使用jsPost.put，Put的信息包括UpdateArray和ClientVersion * 使用postRequest发送这个jspost,进行处理 @@ -509,10 +489,11 @@ public class GTaskClient { } } } - /* + + /* * 添加更新的事项 * 调用commitUpdate()实现 - */ +*/ public void addUpdateNode(Node node) throws NetworkFailureException { if (node != null) { // too many update items may result in an error @@ -526,13 +507,13 @@ public class GTaskClient { mUpdateArray.put(node.getUpdateAction(getActionId())); } } - /* + + /* * 移动task,比如讲task移动到不同的task列表中去 * 通过getGid获取task所属列表的gid * 通过JSONObject.put(String name, Object value)函数设置移动后的task的相关属性值，从而达到移动的目的 * 最后还是通过postRequest进行更新后的发送 - */ - +*/ public void moveTask(Task task, TaskList preParent, TaskList curParent) throws NetworkFailureException { commitUpdate(); @@ -549,18 +530,17 @@ public class GTaskClient { if (preParent == curParent && task.getPriorSibling() != null) { // put prioring_sibing_id only if moving within the tasklist and // it is not the first one - - //设置优先级ID，只有当移动是发生在文件中 + //设置优先级ID，只有当移动是发生在文件中 action.put(GTaskStringUtils.GTASK_JSON_PRIOR_SIBLING_ID, task.getPriorSibling()); } - action.put(GTaskStringUtils.GTASK_JSON_SOURCE_LIST, preParent.getGid()); - action.put(GTaskStringUtils.GTASK_JSON_DEST_PARENT, curParent.getGid()); + action.put(GTaskStringUtils.GTASK_JSON_SOURCE_LIST, preParent.getGid());//设置移动前所属列表 + action.put(GTaskStringUtils.GTASK_JSON_DEST_PARENT, curParent.getGid()); //设置当前所属列表 if (preParent != curParent) { // put the dest_list only if moving between tasklists action.put(GTaskStringUtils.GTASK_JSON_DEST_LIST, curParent.getGid()); } actionList.put(action); - //最后将ACTION_LIST加入到jsPost中 + //最后将ACTION_LIST加入到jsPost中 jsPost.put(GTaskStringUtils.GTASK_JSON_ACTION_LIST, actionList); // client_version @@ -574,11 +554,12 @@ public class GTaskClient { throw new ActionFailureException("move task: handing jsonobject failed"); } } - /* + + /* * 删除操作节点 * 还是利用JSON * 删除过后使用postRequest发送删除后的结果 - */ +*/ public void deleteNode(Node node) throws NetworkFailureException { commitUpdate(); try { @@ -587,7 +568,7 @@ public class GTaskClient { // action_list node.setDeleted(true); - actionList.put(node.getUpdateAction(getActionId())); + actionList.put(node.getUpdateAction(getActionId())); //这里会获取到删除操作的ID，加入到actionLiast中 jsPost.put(GTaskStringUtils.GTASK_JSON_ACTION_LIST, actionList); // client_version @@ -601,7 +582,8 @@ public class GTaskClient { throw new ActionFailureException("delete node: handing jsonobject failed"); } } - /* + +/* * 获取任务列表 * 首先通过GetURI使用getResponseContent从网上获取数据 * 然后筛选出"_setup("到)}的部分，并且从中获取GTASK_JSON_LISTS的内容返回 @@ -629,7 +611,6 @@ public class GTaskClient { jsString = resString.substring(begin + jsBegin.length(), end); } JSONObject js = new JSONObject(jsString); - //获取GTASK_JSON_LISTS return js.getJSONObject("t").getJSONArray(GTaskStringUtils.GTASK_JSON_LISTS); } catch (ClientProtocolException e) { Log.e(TAG, e.toString()); @@ -645,7 +626,8 @@ public class GTaskClient { throw new ActionFailureException("get task lists: handing jasonobject failed"); } } - /* + + /* * 通过传入的TASKList的gid,从网络上获取相应属于这个任务列表的任务 */ public JSONArray getTaskList(String listGid) throws NetworkFailureException { @@ -659,8 +641,7 @@ public class GTaskClient { action.put(GTaskStringUtils.GTASK_JSON_ACTION_TYPE, GTaskStringUtils.GTASK_JSON_ACTION_TYPE_GETALL); action.put(GTaskStringUtils.GTASK_JSON_ACTION_ID, getActionId()); - //这里设置为传入的listGid - action.put(GTaskStringUtils.GTASK_JSON_LIST_ID, listGid); + action.put(GTaskStringUtils.GTASK_JSON_LIST_ID, listGid);//这里设置为传入的listGid action.put(GTaskStringUtils.GTASK_JSON_GET_DELETED, false); actionList.put(action); jsPost.put(GTaskStringUtils.GTASK_JSON_ACTION_LIST, actionList); @@ -681,7 +662,7 @@ public class GTaskClient { return mAccount; } - //重置更新的内容 +//重置更新的内容 public void resetUpdateArray() { mUpdateArray = null; } diff --git a/src/app/src/main/java/net/micode/notes/gtask/remote/GTaskManager.java b/src/app/src/main/java/net/micode/notes/gtask/remote/GTaskManager.java index fd14474..ae3207a 100644 --- a/src/app/src/main/java/net/micode/notes/gtask/remote/GTaskManager.java +++ b/src/app/src/main/java/net/micode/notes/gtask/remote/GTaskManager.java @@ -49,9 +49,8 @@ import java.util.Map; public class GTaskManager { - // TAG用于日志输出时的标识 private static final String TAG = GTaskManager.class.getSimpleName(); - // 不同状态的常量定义 + public static final int STATE_SUCCESS = 0; public static final int STATE_NETWORK_ERROR = 1; @@ -61,77 +60,82 @@ public class GTaskManager { 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; - // 任务列表、任务和元数据的哈希映射 + private HashMap mGTaskListHashMap; private HashMap mGTaskHashMap; private HashMap mMetaHashMap; - // 元数据列表 + private TaskList mMetaList; - // 本地删除ID的集合 + private HashSet mLocalDeleteIdMap; - // GID到NID、NID到GID的映射 + private HashMap mGidToNid; private HashMap mNidToGid; - // 私有构造方法，初始化各个成员变量 - private GTaskManager() { //对象初始化函数 - mSyncing = false; //正在同步,flase代表未执行 - mCancelled = false; //全局标识，flase代表可以执行 - mGTaskListHashMap = new HashMap(); //<>代表Java的泛型,就是创建一个用类型作为参数的类。 + + private GTaskManager() { //对象初始化函数 + mSyncing = false; //正在同步,flase代表未执行 + mCancelled = false; //全局标识，flase代表可以执行 + mGTaskListHashMap = new HashMap(); //<>代表Java的泛型,就是创建一个用类型作为参数的类。 mGTaskHashMap = new HashMap(); mMetaHashMap = new HashMap(); mMetaList = null; mLocalDeleteIdMap = new HashSet(); - mGidToNid = new HashMap(); - mNidToGid = new HashMap(); + mGidToNid = new HashMap(); //GoogleID to NodeID?? + mNidToGid = new HashMap(); //NodeID to GoogleID???通过hashmap散列表建立映射 } + /** - * 获取GTaskManager的单例实例 - * @return GTaskManager的单例实例 + * 包含关键字synchronized，语言级同步，指明该函数可能运行在多线程的环境下。 + * 功能：类初始化函数 + * @author TTS + * @return GtaskManger */ - public static synchronized GTaskManager getInstance() { - // 获取单例实例，如果为空则创建新实例 + + public static synchronized GTaskManager getInstance() { //可能运行在多线程环境下，使用语言级同步--synchronized if (mInstance == null) { mInstance = new GTaskManager(); } return mInstance; } + /** - * 设置活动上下文 - * @param activity 活动上下文 + * 包含关键字synchronized，语言级同步，指明该函数可能运行在多线程的环境下。 + * @author TTS + * @param activity */ public synchronized void setActivityContext(Activity activity) { - // used for getting authtoken - // 设置活动上下文，用于获取认证令牌 + // used for getting auth token mActivity = activity; } - /** - * 实现了本地同步操作和远端同步操作 - * @param context 上下文 - * @param asyncTask 异步任务 - * @return 同步操作的状态 + /** + * 核心函数 + * 功能：实现了本地同步操作和远端同步操作 + * @author TTS + * @param context-----获取上下文 + * @param asyncTask-------用于同步的异步操作类 + * @return int */ - public int sync(Context context, GTaskASyncTask asyncTask) { - // 检查是否正在同步中 + + public int sync(Context context, GTaskASyncTask asyncTask) {//核心函数 if (mSyncing) { - Log.d(TAG, "Sync is in progress"); + Log.d(TAG, "Sync is in progress"); //创建日志文件（调试信息），debug return STATE_SYNC_IN_PROGRESS; } - // 初始化同步环境 mContext = context; mContentResolver = mContext.getContentResolver(); mSyncing = true; @@ -144,30 +148,27 @@ public class GTaskManager { mNidToGid.clear(); try { - GTaskClient client = GTaskClient.getInstance(); - client.resetUpdateArray(); - + GTaskClient client = GTaskClient.getInstance(); //getInstance即为创建一个实例,client--客户机 + client.resetUpdateArray(); //JSONArray类型，reset即置为NULL + // login google task - // 登录Google任务 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(); //获取Google上的JSONtasklist转为本地TaskList + initGTaskList(); //获取Google上的JSONtasklist转为本地TaskLis // do content sync work - // 执行内容同步工作 asyncTask.publishProgess(mContext.getString(R.string.sync_progress_syncing)); syncContent(); - } catch (NetworkFailureException e) { - Log.e(TAG, e.toString()); + } catch (NetworkFailureException e) { //分为两种异常，此类异常为网络异常 + Log.e(TAG, e.toString()); //创建日志文件（调试信息），error return STATE_NETWORK_ERROR; - } catch (ActionFailureException e) { + } catch (ActionFailureException e) { //此类异常为操作异常 Log.e(TAG, e.toString()); return STATE_INTERNAL_ERROR; } catch (Exception e) { @@ -175,7 +176,6 @@ public class GTaskManager { e.printStackTrace(); return STATE_INTERNAL_ERROR; } finally { - // 清空各个哈希映射，重置同步状态 mGTaskListHashMap.clear(); mGTaskHashMap.clear(); mMetaHashMap.clear(); @@ -184,47 +184,45 @@ public class GTaskManager { mNidToGid.clear(); mSyncing = false; } - // 返回同步结果状态 + return mCancelled ? STATE_SYNC_CANCELLED : STATE_SUCCESS; } - /** - * 初始化Google任务列表 - * @throws NetworkFailureException 网络错误异常 +/** + *功能：初始化GtaskList，获取Google上的JSONtasklist转为本地TaskList。 + *获得的数据存储在mMetaList，mGTaskListHashMap，mGTaskHashMap + *@author TTS + *@exception NetworkFailureException + *@return void */ private void initGTaskList() throws NetworkFailureException { - // 检查是否取消同步 if (mCancelled) return; - // 获取GTaskClient实例 GTaskClient client = GTaskClient.getInstance(); +//getInstance即为创建一个实例，client应指远端客户机 try { - //Json对象是Name Value对(即子元素)的无序集合，相当于一个Map对象。JsonObject类是bantouyan-json库对Json对象的抽象，提供操纵Json对象的各种方法。 - //其格式为{"key1":value1,"key2",value2....};key 必须是字符串。 - //因为ajax请求不刷新页面，但配合js可以实现局部刷新，因此json常常被用来作为异步请求的返回对象使用。 - // 获取任务列表数据 - JSONArray jsTaskLists = client.getTaskLists(); - + //Json对象是Name Value对(即子元素)的无序集合，相当于一个Map对象。JsonObject类是bantouyan-json库对Json对象的抽象，提供操纵Json对象的各种方法。 + //其格式为{"key1":value1,"key2",value2....};key 必须是字符串。 + //因为ajax请求不刷新页面，但配合js可以实现局部刷新，因此json常常被用来作为异步请求的返回对象使用。 + JSONArray jsTaskLists = client.getTaskLists(); //原注释为get task list------lists？？？ + // init meta list first - // 初始化元数据列表 - mMetaList = null; + mMetaList = null; //TaskList类型 for (int i = 0; i < jsTaskLists.length(); i++) { - JSONObject object = jsTaskLists.getJSONObject(i); + JSONObject object = jsTaskLists.getJSONObject(i); //JSONObject与JSONArray一个为对象，一个为数组。此处取出单个JASONObject String gid = object.getString(GTaskStringUtils.GTASK_JSON_ID); String name = object.getString(GTaskStringUtils.GTASK_JSON_NAME); - // 初始化元数据列表 - if (name - .equals(GTaskStringUtils.MIUI_FOLDER_PREFFIX + GTaskStringUtils.FOLDER_META)) { - mMetaList = new TaskList(); - mMetaList.setContentByRemoteJSON(object); //将JSON中部分数据复制到自己定义的对象中相对应的数据：name->mname... + + if (name.equals(GTaskStringUtils.MIUI_FOLDER_PREFFIX + GTaskStringUtils.FOLDER_META)) { + mMetaList = new TaskList(); //MetaList意为元表,Tasklist类型，此处为初始化 + mMetaList.setContentByRemoteJSON(object); //将JSON中部分数据复制到自己定义的对象中相对应的数据：name->mname... // load meta data - // 加载元数据 JSONArray jsMetas = client.getTaskList(gid); for (int j = 0; j < jsMetas.length(); j++) { object = (JSONObject) jsMetas.getJSONObject(j); - MetaData metaData = new MetaData(); + MetaData metaData = new MetaData(); //继承自Node metaData.setContentByRemoteJSON(object); - if (metaData.isWorthSaving()) { //if not worth to save，metadata将不加入mMetaList + if (metaData.isWorthSaving()) { //if not worth to save，metadata将不加入mMetaList mMetaList.addChildTask(metaData); if (metaData.getGid() != null) { mMetaHashMap.put(metaData.getRelatedGid(), metaData); @@ -235,7 +233,6 @@ public class GTaskManager { } // create meta list if not existed - // 如果元数据列表不存在，则创建 if (mMetaList == null) { mMetaList = new TaskList(); mMetaList.setName(GTaskStringUtils.MIUI_FOLDER_PREFFIX @@ -244,20 +241,19 @@ public class GTaskManager { } // init task list - // 初始化任务列表 for (int i = 0; i < jsTaskLists.length(); i++) { JSONObject object = jsTaskLists.getJSONObject(i); String gid = object.getString(GTaskStringUtils.GTASK_JSON_ID); //通过getString函数传入本地某个标志数据的名称，获取其在远端的名称。 String name = object.getString(GTaskStringUtils.GTASK_JSON_NAME); - // 初始化任务列表 + if (name.startsWith(GTaskStringUtils.MIUI_FOLDER_PREFFIX) && !name.equals(GTaskStringUtils.MIUI_FOLDER_PREFFIX + GTaskStringUtils.FOLDER_META)) { - TaskList tasklist = new TaskList(); + TaskList tasklist = new TaskList(); //继承自Node 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++) { @@ -274,31 +270,29 @@ public class GTaskManager { } } } catch (JSONException e) { - // 打印异常信息 Log.e(TAG, e.toString()); e.printStackTrace(); - // 抛出自定义异常 throw new ActionFailureException("initGTaskList: handing JSONObject failed"); } } - /** - * 同步内容 - * @throws NetworkFailureException 网络错误异常 + /** + * 功能：本地内容同步操作 + * @throws NetworkFailureException + * @return 无返回值 */ - private void syncContent() throws NetworkFailureException { - int syncType; // 同步类型 - Cursor c = null; // 游标 - String gid; // GTask ID - Node node; // 节点 + private void syncContent() throws NetworkFailureException { //本地内容同步操作 + int syncType; + Cursor c = null; //数据库指针 + String gid; //GoogleID + Node node; //Node包含Sync_Action的不同类型 + + mLocalDeleteIdMap.clear(); //HashSet类型 - mLocalDeleteIdMap.clear(); // 清空本地删除ID映射表 - - if (mCancelled) { // 如果取消同步，则直接返回 + if (mCancelled) { return; } // for local deleted note - // 处理本地已删除的笔记 try { c = mContentResolver.query(Notes.CONTENT_NOTE_URI, SqlNote.PROJECTION_NOTE, "(type<>? AND parent_id=?)", new String[] { @@ -310,13 +304,13 @@ public class GTaskManager { node = mGTaskHashMap.get(gid); if (node != null) { mGTaskHashMap.remove(gid); - doContentSync(Node.SYNC_ACTION_DEL_REMOTE, node, c); // 执行远程删除同步操作 + doContentSync(Node.SYNC_ACTION_DEL_REMOTE, node, c); } - mLocalDeleteIdMap.add(c.getLong(SqlNote.ID_COLUMN)); // 将本地已删除笔记的ID添加到本地删除ID映射表中 + mLocalDeleteIdMap.add(c.getLong(SqlNote.ID_COLUMN)); } } else { - Log.w(TAG, "failed to query trash folder"); // 查询回收站文件夹失败 + Log.w(TAG, "failed to query trash folder"); } } finally { if (c != null) { @@ -326,11 +320,9 @@ public class GTaskManager { } // 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[] { @@ -342,21 +334,18 @@ public class GTaskManager { node = mGTaskHashMap.get(gid); if (node != null) { mGTaskHashMap.remove(gid); - mGidToNid.put(gid, c.getLong(SqlNote.ID_COLUMN)); //通过hashmap建立联系 - mNidToGid.put(c.getLong(SqlNote.ID_COLUMN), gid); - syncType = node.getSyncAction(c); // 获取同步操作类型 + mGidToNid.put(gid, c.getLong(SqlNote.ID_COLUMN));//通过hashmap建立联系 + mNidToGid.put(c.getLong(SqlNote.ID_COLUMN), gid); //通过hashmap建立联系 + syncType = node.getSyncAction(c); } else { if (c.getString(SqlNote.GTASK_ID_COLUMN).trim().length() == 0) { // local add - // 本地新增 syncType = Node.SYNC_ACTION_ADD_REMOTE; } else { // remote delete - // 远程删除 syncType = Node.SYNC_ACTION_DEL_LOCAL; } } - // 执行内容同步操作 doContentSync(syncType, node, c); } } else { @@ -371,7 +360,6 @@ public class GTaskManager { } // go through remaining items - // 处理剩余项 Iterator> iter = mGTaskHashMap.entrySet().iterator(); while (iter.hasNext()) { Map.Entry entry = iter.next(); @@ -382,8 +370,6 @@ public class GTaskManager { // 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"); @@ -392,26 +378,32 @@ public class GTaskManager { // refresh local sync id if (!mCancelled) { - GTaskClient.getInstance().commitUpdate(); // 提交更新操作 - refreshLocalSyncId(); // 刷新本地同步ID + GTaskClient.getInstance().commitUpdate(); + refreshLocalSyncId(); } } - /* - 同步所有文件夹的方法 - */ + +/** + * 功能：syncType分类，addLocalNode，addRemoteNode，deleteNode，updateLocalNode，updateRemoteNode + * @author TTS + * @param syncType + * @param node + * @param c + * @throws NetworkFailureException + */ + private void syncFolder() throws NetworkFailureException { - Cursor c = null; // 用于数据库查询的 Cursor - String gid; // Google 任务的 ID - Node node; // 代表文件夹的 Node 对象 - int syncType; // 同步操作类型 + Cursor c = null; + String gid; + Node node; + int syncType; - if (mCancelled) { // 检查同步是否被取消 + 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); @@ -424,7 +416,6 @@ public class GTaskManager { mGidToNid.put(gid, (long) Notes.ID_ROOT_FOLDER); mNidToGid.put((long) Notes.ID_ROOT_FOLDER, gid); // for system folder, only update remote name if necessary - // 如果需要，更新系统文件夹的远程名称 if (!node.getName().equals( GTaskStringUtils.MIUI_FOLDER_PREFFIX + GTaskStringUtils.FOLDER_DEFAULT)) doContentSync(Node.SYNC_ACTION_UPDATE_REMOTE, node, c); @@ -442,7 +433,6 @@ public class GTaskManager { } // for call-note folder - // 同步通话记录文件夹 try { c = mContentResolver.query(Notes.CONTENT_NOTE_URI, SqlNote.PROJECTION_NOTE, "(_id=?)", new String[] { @@ -457,7 +447,6 @@ public class GTaskManager { 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 @@ -478,7 +467,6 @@ public class GTaskManager { } // for local existing folders - // 同步本地已存在的文件夹 try { c = mContentResolver.query(Notes.CONTENT_NOTE_URI, SqlNote.PROJECTION_NOTE, "(type=? AND parent_id<>?)", new String[] { @@ -496,11 +484,9 @@ public class GTaskManager { } else { if (c.getString(SqlNote.GTASK_ID_COLUMN).trim().length() == 0) { // local add - // 本地新增 syncType = Node.SYNC_ACTION_ADD_REMOTE; } else { // remote delete - // 远程删除 syncType = Node.SYNC_ACTION_DEL_LOCAL; } } @@ -517,7 +503,6 @@ public class GTaskManager { } // for remote add folders - // 同步远程新增的文件夹 Iterator> iter = mGTaskListHashMap.entrySet().iterator(); while (iter.hasNext()) { Map.Entry entry = iter.next(); @@ -529,17 +514,10 @@ public class GTaskManager { } } - if (!mCancelled) // 如果未取消，则提交更新 + 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; @@ -548,15 +526,12 @@ public class GTaskManager { 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: - // 执行删除本地节点的操作 meta = mMetaHashMap.get(c.getString(SqlNote.GTASK_ID_COLUMN)); if (meta != null) { GTaskClient.getInstance().deleteNode(meta); @@ -564,7 +539,6 @@ public class GTaskManager { mLocalDeleteIdMap.add(c.getLong(SqlNote.ID_COLUMN)); break; case Node.SYNC_ACTION_DEL_REMOTE: - // 执行删除远程节点的操作 meta = mMetaHashMap.get(node.getGid()); if (meta != null) { GTaskClient.getInstance().deleteNode(meta); @@ -572,18 +546,14 @@ public class GTaskManager { 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: @@ -593,11 +563,12 @@ public class GTaskManager { throw new ActionFailureException("unkown sync action type"); } } - /** - * 将本地节点添加到系统中。 - * - * @param node 要在本地添加的节点对象 - * @throws NetworkFailureException 如果发生网络故障 + + /** + * 功能：本地增加Node + * @author TTS + * @param node + * @throws NetworkFailureException */ private void addLocalNode(Node node) throws NetworkFailureException { if (mCancelled) { @@ -608,24 +579,19 @@ public class GTaskManager { 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 { - // 其他情况创建默认文件夹 sqlNote = new SqlNote(mContext); sqlNote.setContent(node.getLocalJSONFromContent()); sqlNote.setParentId(Notes.ID_ROOT_FOLDER); } } else { - // 创建任务节点 sqlNote = new SqlNote(mContext); JSONObject js = node.getLocalJSONFromContent(); try { - // 处理ID和数据ID的存在性检查 if (js.has(GTaskStringUtils.META_HEAD_NOTE)) { JSONObject note = js.getJSONObject(GTaskStringUtils.META_HEAD_NOTE); if (note.has(NoteColumns.ID)) { @@ -667,25 +633,25 @@ public class GTaskManager { } // create the local node - // 创建本地节点 sqlNote.setGtaskId(node.getGid()); sqlNote.commit(false); // update gid-nid mapping - // 更新GID-NID映射 mGidToNid.put(node.getGid(), sqlNote.getId()); mNidToGid.put(sqlNote.getId(), node.getGid()); // update meta - // 更新元数据 updateRemoteMeta(node.getGid(), sqlNote); } - /** - * 更新本地节点信息。 - * - * @param node 要更新的节点对象 - * @param c 游标对象 - * @throws NetworkFailureException 如果发生网络故障 + +/** + * 功能：update本地node + * @author TTS + * @param node + * ----同步操作的基础数据类型 + * @param c + * ----Cursor + * @throws NetworkFailureException */ private void updateLocalNode(Node node, Cursor c) throws NetworkFailureException { if (mCancelled) { @@ -694,7 +660,6 @@ public class GTaskManager { SqlNote sqlNote; // update the note locally - // 在本地更新笔记 sqlNote = new SqlNote(mContext, c); sqlNote.setContent(node.getLocalJSONFromContent()); @@ -708,48 +673,49 @@ public class GTaskManager { sqlNote.commit(true); // update meta info - // 更新元数据信息 updateRemoteMeta(node.getGid(), sqlNote); } - /** - * 添加远程节点。 - * - * @param node 要添加的节点对象 - * @param c 游标对象 - * @throws NetworkFailureException 如果发生网络故障 + +/** + * 功能：远程增加Node + * 需要updateRemoteMeta + * @author TTS + * @param node + * ----同步操作的基础数据类型 + * @param c + * --Cursor + * @throws NetworkFailureException */ private void addRemoteNode(Node node, Cursor c) throws NetworkFailureException { if (mCancelled) { return; } - SqlNote sqlNote = new SqlNote(mContext, c); //从本地mContext中获取内容 + SqlNote sqlNote = new SqlNote(mContext, c);//从本地mContext中获取内容 Node n; // update remotely - // 远程更新 if (sqlNote.isNoteType()) { Task task = new Task(); task.setContentByLocalJSON(sqlNote.getContent()); - + String parentGid = mNidToGid.get(sqlNote.getParentId()); if (parentGid == null) { - Log.e(TAG, "cannot find task's parent tasklist"); + Log.e(TAG, "cannot find task's parent tasklist"); //调试信息 throw new ActionFailureException("cannot add remote task"); } - mGTaskListHashMap.get(parentGid).addChildTask(task); //在本地生成的GTaskList中增加子结点 + mGTaskListHashMap.get(parentGid).addChildTask(task); //在本地生成的GTaskList中增加子结点 + //登录远程服务器，创建Task GTaskClient.getInstance().createTask(task); n = (Node) task; // add meta - // 添加元数据 updateRemoteMeta(task.getGid(), sqlNote); } else { 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) folderName += GTaskStringUtils.FOLDER_DEFAULT; @@ -757,7 +723,8 @@ public class GTaskManager { folderName += GTaskStringUtils.FOLDER_CALL_NOTE; else folderName += sqlNote.getSnippet(); - //iterator迭代器，通过统一的接口迭代所有的map元素 + + //iterator迭代器，通过统一的接口迭代所有的map元素 Iterator> iter = mGTaskListHashMap.entrySet().iterator(); while (iter.hasNext()) { Map.Entry entry = iter.next(); @@ -774,7 +741,6 @@ public class GTaskManager { } // no match we can add now - // 如果没有匹配项，则现在可以添加 if (tasklist == null) { tasklist = new TaskList(); tasklist.setContentByLocalJSON(sqlNote.getContent()); @@ -785,23 +751,24 @@ public class GTaskManager { } // update local note - // 更新本地笔记 sqlNote.setGtaskId(n.getGid()); sqlNote.commit(false); sqlNote.resetLocalModified(); sqlNote.commit(true); - // gid-id mapping - // GID-ID映射 + // gid-id mapping //创建id间的映射 mGidToNid.put(n.getGid(), sqlNote.getId()); mNidToGid.put(sqlNote.getId(), n.getGid()); } - /** - * 更新远程节点信息。 - * - * @param node 要更新的节点对象 - * @param c 游标对象 - * @throws NetworkFailureException 如果发生网络故障 +、 + /** + * 功能：更新远端的Node，包含meta更新(updateRemoteMeta) + * @author TTS + * @param node + * ----同步操作的基础数据类型 + * @param c + * --Cursor + * @throws NetworkFailureException */ private void updateRemoteNode(Node node, Cursor c) throws NetworkFailureException { if (mCancelled) { @@ -811,26 +778,27 @@ public class GTaskManager { SqlNote sqlNote = new SqlNote(mContext, c); // update remotely - // 在远程更新 node.setContentByLocalJSON(sqlNote.getContent()); - GTaskClient.getInstance().addUpdateNode(node); + 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(); - + TaskList preParentList = task.getParent(); + //preParentList为通过node获取的父节点列表 + String curParentGid = mNidToGid.get(sqlNote.getParentId()); + //curParentGid为通过光标在数据库中找到sqlNote的mParentId，再通过mNidToGid由long类型转为String类型的Gid + if (curParentGid == null) { Log.e(TAG, "cannot find task's parent tasklist"); throw new ActionFailureException("cannot update remote task"); } TaskList curParentList = mGTaskListHashMap.get(curParentGid); + //通过HashMap找到对应Gid的TaskLis if (preParentList != curParentList) { preParentList.removeChildTask(task); @@ -840,16 +808,18 @@ public class GTaskManager { } // clear local modified flag - // 清除本地修改标志 sqlNote.resetLocalModified(); sqlNote.commit(true); } - /** - * 更新远程元数据。 - * - * @param gid 节点的GID - * @param sqlNote SqlNote对象 - * @throws NetworkFailureException 如果发生网络故障 + + /** + * 功能：升级远程meta。 meta---元数据----计算机文件系统管理数据---管理数据的数据。 + * @author TTS + * @param gid + * ---GoogleID为String类型 + * @param sqlNote + * ---同步前的数据库操作，故使用类SqlNote + * @throws NetworkFailureException */ private void updateRemoteMeta(String gid, SqlNote sqlNote) throws NetworkFailureException { if (sqlNote != null && sqlNote.isNoteType()) { @@ -866,11 +836,7 @@ public class GTaskManager { } } } - /** - * 刷新本地同步ID。 - * - * @throws NetworkFailureException 如果发生网络故障 - */ + private void refreshLocalSyncId() throws NetworkFailureException { if (mCancelled) { return; @@ -887,8 +853,7 @@ public class GTaskManager { 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) - }, NoteColumns.TYPE + " DESC"); //query语句：五个参数，NoteColumns.TYPE + " DESC"-----为按类型递减顺序返回查询结果。new String[] {String.valueOf(Notes.TYPE_SYSTEM), String.valueOf(Notes.ID_TRASH_FOLER)}------为选择参数。"(type<>? AND parent_id<>?)"-------指明返回行过滤器。SqlNote.PROJECTION_NOTE--------应返回的数据列的名字。Notes.CONTENT_NOTE_URI--------contentProvider包含所有数据集所对应的uri - + }, NoteColumns.TYPE + " DESC"); if (c != null) { while (c.moveToNext()) { String gid = c.getString(SqlNote.GTASK_ID_COLUMN); @@ -896,8 +861,8 @@ public class GTaskManager { if (node != null) { mGTaskHashMap.remove(gid); ContentValues values = new ContentValues(); - values.put(NoteColumns.SYNC_ID, node.getLastModified()); //在ContentValues中创建键值对。准备通过contentResolver写入数据 - mContentResolver.update(ContentUris.withAppendedId(Notes.CONTENT_NOTE_URI, //进行批量更改，选择参数为NULL，应该可以用insert替换，参数分别为表名和需要更新的value对象。 + values.put(NoteColumns.SYNC_ID, node.getLastModified()); + mContentResolver.update(ContentUris.withAppendedId(Notes.CONTENT_NOTE_URI, c.getLong(SqlNote.ID_COLUMN)), values, null, null); } else { Log.e(TAG, "something is missed"); @@ -915,16 +880,23 @@ public class GTaskManager { } } } - /** - * 获取同步账户。 - * - * @return 同步账户名称 + + public String getSyncAccount() { + return GTaskClient.getInstance().getSyncAccount().name; + } + +/** + * 功能：获取同步账号,mAccount.name + * @author TTS + * @return String */ public String getSyncAccount() { return GTaskClient.getInstance().getSyncAccount().name; } + /** - * 取消同步操作。 + * 功能：取消同步，置mCancelled为true + * @author TTS */ public void cancelSync() { mCancelled = true; diff --git a/src/app/src/main/java/net/micode/notes/gtask/remote/GTaskSyncService.java b/src/app/src/main/java/net/micode/notes/gtask/remote/GTaskSyncService.java index cca36f7..16ef061 100644 --- a/src/app/src/main/java/net/micode/notes/gtask/remote/GTaskSyncService.java +++ b/src/app/src/main/java/net/micode/notes/gtask/remote/GTaskSyncService.java @@ -16,6 +16,22 @@ package net.micode.notes.gtask.remote; +/* + * Service是在一段不定的时间运行在后台，不和用户交互的应用组件 + * 主要方法： + * private void startSync() 启动一个同步工作 + * private void cancelSync() 取消同步 + * public void onCreate() + * public int onStartCommand(Intent intent, int flags, int startId) service生命周期的组成部分，相当于重启service（比如在被暂停之后），而不是创建一个新的service + * public void onLowMemory() 在没有内存的情况下如果存在service则结束掉这的service + * public IBinder onBind() + * public void sendBroadcast(String msg) 发送同步的相关通知 + * public static void startSync(Activity activity) + * public static void cancelSync(Context context) + * public static boolean isSyncing() 判读是否在进行同步 + * public static String getProgressString() 获取当前进度的信息 +*/ + import android.app.Activity; import android.app.Service; import android.content.Context; @@ -42,20 +58,22 @@ public class GTaskSyncService extends Service { private static String mSyncProgress = ""; + //开始一个同步的工作 private void startSync() { if (mSyncTask == null) { mSyncTask = new GTaskASyncTask(this, new GTaskASyncTask.OnCompleteListener() { public void onComplete() { mSyncTask = null; sendBroadcast(""); - stopSelf(); + stopSelf(); } }); sendBroadcast(""); - mSyncTask.execute(); + mSyncTask.execute(); //这个函数让任务是以单线程队列方式或线程池队列方式运行 } } + private void cancelSync() { if (mSyncTask != null) { mSyncTask.cancelSync(); @@ -63,15 +81,16 @@ public class GTaskSyncService extends Service { } @Override - public void onCreate() { + public void onCreate() {//初始化一个service mSyncTask = null; } - + @Override public int onStartCommand(Intent intent, int flags, int startId) { Bundle bundle = intent.getExtras(); if (bundle != null && bundle.containsKey(ACTION_STRING_NAME)) { switch (bundle.getInt(ACTION_STRING_NAME, ACTION_INVALID)) { + //两种情况，开始同步或者取消同步 case ACTION_START_SYNC: startSync(); break; @@ -81,7 +100,8 @@ public class GTaskSyncService extends Service { default: break; } - return START_STICKY; + return START_STICKY;//等待新的intent来是这个service继续运行 + } return super.onStartCommand(intent, flags, startId); } @@ -99,20 +119,20 @@ public class GTaskSyncService extends Service { public void sendBroadcast(String msg) { mSyncProgress = msg; - Intent intent = new Intent(GTASK_SERVICE_BROADCAST_NAME); - intent.putExtra(GTASK_SERVICE_BROADCAST_IS_SYNCING, mSyncTask != null); + Intent intent = new Intent(GTASK_SERVICE_BROADCAST_NAME); //创建一个新的Intent + intent.putExtra(GTASK_SERVICE_BROADCAST_IS_SYNCING, mSyncTask != null); //附加INTENT中的相应参数的值 intent.putExtra(GTASK_SERVICE_BROADCAST_PROGRESS_MSG, msg); - sendBroadcast(intent); + sendBroadcast(intent); //发送这个通知 } - - public static void startSync(Activity activity) { + + public static void startSync(Activity activity) {//执行一个service，service的内容里的同步动作就是开始同步 GTaskManager.getInstance().setActivityContext(activity); Intent intent = new Intent(activity, GTaskSyncService.class); intent.putExtra(GTaskSyncService.ACTION_STRING_NAME, GTaskSyncService.ACTION_START_SYNC); activity.startService(intent); } - - public static void cancelSync(Context context) { + + public static void cancelSync(Context context) {//执行一个service，service的内容里的同步动作就是取消同步 Intent intent = new Intent(context, GTaskSyncService.class); intent.putExtra(GTaskSyncService.ACTION_STRING_NAME, GTaskSyncService.ACTION_CANCEL_SYNC); context.startService(intent);