devbox
weixin_40725706
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

小米便签源码分析——gtask包_micode notes源码

作者：weixin_40725706 | 2024-05-08 04:29:43

赞

踩

micode notes源码

目录

一、data包

1、MetaData.java

2、Node.java

3、SqlData.java

4、SqlNote.java

5、Task.java

6、TaskList.java

二、exception包

1、ActionFailureException.java

2、NetworkFailureException.java

三、remote包

1、GTaskASyncTask.java

2、GTaskClient.java

3、GTaskManager.java

4、GTaskSyncService.java

一、data包

1、MetaData.java

  1. package net.micode.notes.gtask.data;
  2.  
  3. public class MetaData extends Task {
  4. 	/*
  5. 	 * 功能描述：得到类的简写名称存入字符串TAG中
  6. 	 * 实现过程：调用getSimpleName ()函数
  7. 	 */
  8.     private final static String TAG = MetaData.class.getSimpleName();
  9.     private String mRelatedGid = null;
  10.     /*
  11.      * 功能描述：设置数据，即生成元数据库
  12.      * 实现过程：调用JSONObject库函数put ()，Task类中的setNotes ()和setName ()函数
  13.      * 参数注解：
  14.      */
  15.     public void setMeta(String gid, JSONObject metaInfo) 
  16.     {
  17.     	//对函数块进行注释
  18.         try {
  19.             metaInfo.put(GTaskStringUtils.META_HEAD_GTASK_ID, gid);
  20.             /*
  21.              * 将这对键值放入metaInfo这个jsonobject对象中
  22.              */
  23.         } catch (JSONException e) {
  24.             Log.e(TAG, "failed to put related gid");
  25.             /*
  26.              * 输出错误信息
  27.              */
  28.         }
  29.         setNotes(metaInfo.toString());
  30.         setName(GTaskStringUtils.META_NOTE_NAME);
  31.     }
  32.     /*
  33.      * 功能描述：获取相关联的Gid
  34.      */
  35.     public String getRelatedGid() {
  36.         return mRelatedGid;
  37.     }
  38.     /*
  39.      * 功能描述：判断当前数据是否为空，若为空则返回真即值得保存
  40.      * Made By CuiCan
  41.      */
  42.     @Override
  43.     public boolean isWorthSaving() {
  44.         return getNotes() != null;
  45.     }
  46.     /*
  47.      * 功能描述：使用远程json数据对象设置元数据内容
  48.      * 实现过程：调用父类Task中的setContentByRemoteJSON ()函数，并
  49.      * 参数注解： 
  50.      */
  51.     @Override
  52.     public void setContentByRemoteJSON(JSONObject js) {
  53.         super.setContentByRemoteJSON(js);
  54.         if (getNotes() != null) {
  55.             try {
  56.                 JSONObject metaInfo = new JSONObject(getNotes().trim());
  57.                 mRelatedGid = metaInfo.getString(GTaskStringUtils.META_HEAD_GTASK_ID);
  58.             } catch (JSONException e) {
  59.                 Log.w(TAG, "failed to get related gid");
  60.                 /*
  61.                  * 输出警告信息
  62.                  */
  63.                 mRelatedGid = null;
  64.             }
  65.         }
  66.     }
  67.     /*
  68.      * 功能描述：使用本地json数据对象设置元数据内容，一般不会用到，若用到，则抛出异常
  69.      * Made By CuiCan
  70.      */
  71.     @Override
  72.     public void setContentByLocalJSON(JSONObject js) {
  73.         // this function should not be called
  74.         throw new IllegalAccessError("MetaData:setContentByLocalJSON should not be called");
  75.         /*
  76.          * 传递非法参数异常
  77.          */
  78.     }
  79.     /*
  80.      * 功能描述：从元数据内容中获取本地json对象，一般不会用到，若用到，则抛出异常
  81.      * Made By CuiCan
  82.      */
  83.     @Override
  84.     public JSONObject getLocalJSONFromContent() {
  85.         throw new IllegalAccessError("MetaData:getLocalJSONFromContent should not be called");
  86.         /*
  87.          * 传递非法参数异常
  88.          * Made By Cui Can
  89.          */
  90.     }
  91.     /*
  92.      * 功能描述：获取同步动作状态，一般不会用到，若用到，则抛出异常
  93.      * Made By CuiCan
  94.      */
  95.     @Override
  96.     public int getSyncAction(Cursor c) {
  97.         throw new IllegalAccessError("MetaData:getSyncAction should not be called");
  98.         /*
  99.          * 传递非法参数异常
  100.          * Made By Cui Can
  101.          */
  102.     }
  103.  
  104. }

2、Node.java

  1. package net.micode.notes.gtask.data;
  2.  
  3. import android.database.Cursor;
  4.  
  5. import org.json.JSONObject;
  6.  
  7. /**
  8.  * 应该是同步操作的基础数据类型，定义了相关指示同步操作的常量
  9.  * 关键字：abstract
  10.  */
  11. public abstract class Node {
  12. 	//定义了各种用于表征同步状态的常量
  13.     public static final int SYNC_ACTION_NONE = 0;// 本地和云端都无可更新内容（即本地和云端内容一致）
  14.     
  15.     public static final int SYNC_ACTION_ADD_REMOTE = 1;// 需要在远程云端增加内容
  16.  
  17.     public static final int SYNC_ACTION_ADD_LOCAL = 2;// 需要在本地增加内容
  18.  
  19.     public static final int SYNC_ACTION_DEL_REMOTE = 3;// 需要在远程云端删除内容
  20.  
  21.     public static final int SYNC_ACTION_DEL_LOCAL = 4;// 需要在本地删除内容
  22.  
  23.     public static final int SYNC_ACTION_UPDATE_REMOTE = 5;// 需要将本地内容更新到远程云端
  24.  
  25.     public static final int SYNC_ACTION_UPDATE_LOCAL = 6;// 需要将远程云端内容更新到本地
  26.  
  27.     public static final int SYNC_ACTION_UPDATE_CONFLICT = 7;// 同步出现冲突
  28.  
  29.     public static final int SYNC_ACTION_ERROR = 8;// 同步出现错误
  30.  
  31.     private String mGid;
  32.  
  33.     private String mName;
  34.  
  35.     private long mLastModified;//记录最后一次修改时间
  36.  
  37.     private boolean mDeleted;//表征是否被删除
  38.  
  39.     public Node() {
  40.         mGid = null;
  41.         mName = "";
  42.         mLastModified = 0;
  43.         mDeleted = false;
  44.     }
  45.  
  46.     public abstract JSONObject getCreateAction(int actionId);
  47.  
  48.     public abstract JSONObject getUpdateAction(int actionId);
  49.  
  50.     public abstract void setContentByRemoteJSON(JSONObject js);
  51.  
  52.     public abstract void setContentByLocalJSON(JSONObject js);
  53.  
  54.     public abstract JSONObject getLocalJSONFromContent();
  55.  
  56.     public abstract int getSyncAction(Cursor c);
  57.  
  58.     public void setGid(String gid) {
  59.         this.mGid = gid;
  60.     }
  61.  
  62.     public void setName(String name) {
  63.         this.mName = name;
  64.     }
  65.  
  66.     public void setLastModified(long lastModified) {
  67.         this.mLastModified = lastModified;
  68.     }
  69.  
  70.     public void setDeleted(boolean deleted) {
  71.         this.mDeleted = deleted;
  72.     }
  73.  
  74.     public String getGid() {
  75.         return this.mGid;
  76.     }
  77.  
  78.     public String getName() {
  79.         return this.mName;
  80.     }
  81.  
  82.     public long getLastModified() {
  83.         return this.mLastModified;
  84.     }
  85.  
  86.     public boolean getDeleted() {
  87.         return this.mDeleted;
  88.     }
  89.  
  90. }

3、SqlData.java

  1. /*
  2.  * Description：用于支持小米便签最底层的数据库相关操作，和sqlnote的关系上是子集关系，即data是note的子集（节点）。
  3.  * SqlData其实就是也就是所谓数据中的数据
  4.  */
  5.  
  6. package net.micode.notes.gtask.data;
  7. /*
  8.  * 功能描述：
  9.  * 实现过程：
  10.  * 参数注解： 
  11.  * Made By CuiCan
  12.  */
  13.  
  14. public class SqlData {
  15. 	/*
  16. 	 * 功能描述：得到类的简写名称存入字符串TAG中
  17. 	 * 实现过程：调用getSimpleName ()函数
  18. 	 * Made By CuiCan
  19. 	 */
  20.     private static final String TAG = SqlData.class.getSimpleName();
  21.  
  22.     private static final int INVALID_ID = -99999;//为mDataId置初始值-99999
  23.  
  24.  
  25.     /**
  26.      * 来自Notes类中定义的DataColumn中的一些常量
  27.      */
  28.  
  29.     // 集合了interface DataColumns中所有SF常量
  30.     public static final String[] PROJECTION_DATA = new String[] {
  31.             DataColumns.ID, DataColumns.MIME_TYPE, DataColumns.CONTENT, DataColumns.DATA1,
  32.             DataColumns.DATA3
  33.     };
  34.  
  35.     /**
  36.      * 以下五个变量作为sql表中5列的编号
  37.      */
  38.     public static final int DATA_ID_COLUMN = 0;
  39.  
  40.     public static final int DATA_MIME_TYPE_COLUMN = 1;
  41.  
  42.     public static final int DATA_CONTENT_COLUMN = 2;
  43.  
  44.     public static final int DATA_CONTENT_DATA_1_COLUMN = 3;
  45.  
  46.     public static final int DATA_CONTENT_DATA_3_COLUMN = 4;
  47.  
  48.     private ContentResolver mContentResolver;
  49.     //判断是否直接用Content生成，是为true，否则为false
  50.     private boolean mIsCreate;
  51.  
  52.     private long mDataId;
  53.  
  54.     private String mDataMimeType;
  55.  
  56.     private String mDataContent;
  57.  
  58.     private long mDataContentData1;
  59.  
  60.     private String mDataContentData3;
  61.  
  62.     private ContentValues mDiffDataValues;
  63.  
  64. 	/*
  65. 	 * 功能描述：构造函数，用于初始化数据
  66.      * 参数注解：mContentResolver用于获取ContentProvider提供的数据
  67.      * 参数注解： mIsCreate表征当前数据是用哪种方式创建（两种构造函数的参数不同）
  68.      * 参数注解： 
  69. 	 * Made By CuiCan
  70. 	 */
  71.     public SqlData(Context context) {
  72.         mContentResolver = context.getContentResolver();
  73.         mIsCreate = true;
  74.         mDataId = INVALID_ID;//mDataId置初始值-99999
  75.         mDataMimeType = DataConstants.NOTE;
  76.         mDataContent = "";
  77.         mDataContentData1 = 0;
  78.         mDataContentData3 = "";
  79.         mDiffDataValues = new ContentValues();
  80.     }
  81.  
  82.  
  83. 	/*
  84. 	 * 功能描述：构造函数，初始化数据
  85.      * 参数注解：mContentResolver用于获取ContentProvider提供的数据
  86.      * 参数注解： mIsCreate表征当前数据是用哪种方式创建（两种构造函数的参数不同）
  87.      * 参数注解： 
  88. 	 * Made By CuiCan
  89. 	 */
  90.     public SqlData(Context context, Cursor c) {
  91.         mContentResolver = context.getContentResolver();
  92.         mIsCreate = false;
  93.         loadFromCursor(c);
  94.         mDiffDataValues = new ContentValues();
  95.     }
  96.  
  97.     /*
  98.      * 功能描述：从光标处加载数据
  99.      * 从当前的光标处将五列的数据加载到该类的对象
  100.      * Made By CuiCan
  101.      */
  102.     private void loadFromCursor(Cursor c) {
  103.         mDataId = c.getLong(DATA_ID_COLUMN);
  104.         mDataMimeType = c.getString(DATA_MIME_TYPE_COLUMN);
  105.         mDataContent = c.getString(DATA_CONTENT_COLUMN);
  106.         mDataContentData1 = c.getLong(DATA_CONTENT_DATA_1_COLUMN);
  107.         mDataContentData3 = c.getString(DATA_CONTENT_DATA_3_COLUMN);
  108.     }
  109.  
  110.  
  111. 	/*
  112. 	 * 功能描述：设置用于共享的数据，并提供异常抛出与处理机制
  113. 	 * 参数注解： 
  114. 	 * Made By CuiCan
  115. 	 */
  116.     public void setContent(JSONObject js) throws JSONException {
  117.         //如果传入的JSONObject对象中有DataColumns.ID这一项，则设置，否则设为INVALID_ID
  118.         long dataId = js.has(DataColumns.ID) ? js.getLong(DataColumns.ID) : INVALID_ID;
  119.         if (mIsCreate || mDataId != dataId) {
  120.             mDiffDataValues.put(DataColumns.ID, dataId);
  121.         }
  122.         mDataId = dataId;
  123.  
  124.         String dataMimeType = js.has(DataColumns.MIME_TYPE) ? js.getString(DataColumns.MIME_TYPE)
  125.                 : DataConstants.NOTE;
  126.         if (mIsCreate || !mDataMimeType.equals(dataMimeType)) {
  127.             mDiffDataValues.put(DataColumns.MIME_TYPE, dataMimeType);
  128.         }
  129.         mDataMimeType = dataMimeType;
  130.  
  131.         String dataContent = js.has(DataColumns.CONTENT) ? js.getString(DataColumns.CONTENT) : "";
  132.         if (mIsCreate || !mDataContent.equals(dataContent)) {
  133.             mDiffDataValues.put(DataColumns.CONTENT, dataContent);
  134.         }
  135.         mDataContent = dataContent;
  136.  
  137.         long dataContentData1 = js.has(DataColumns.DATA1) ? js.getLong(DataColumns.DATA1) : 0;
  138.         if (mIsCreate || mDataContentData1 != dataContentData1) {
  139.             mDiffDataValues.put(DataColumns.DATA1, dataContentData1);
  140.         }
  141.         mDataContentData1 = dataContentData1;
  142.  
  143.         String dataContentData3 = js.has(DataColumns.DATA3) ? js.getString(DataColumns.DATA3) : "";
  144.         if (mIsCreate || !mDataContentData3.equals(dataContentData3)) {
  145.             mDiffDataValues.put(DataColumns.DATA3, dataContentData3);
  146.         }
  147.         mDataContentData3 = dataContentData3;
  148.     }
  149.  
  150.  
  151. 	/*
  152. 	 * 功能描述：获取共享的数据内容，并提供异常抛出与处理机制
  153. 	 * 参数注解： 
  154. 	 * Made By CuiCan
  155. 	 */
  156.     public JSONObject getContent() throws JSONException {
  157.         if (mIsCreate) {
  158.             Log.e(TAG, "it seems that we haven't created this in database yet");
  159.             return null;
  160.         }
  161.         //创建JSONObject对象。并将相关数据放入其中，并返回。
  162.         JSONObject js = new JSONObject();
  163.         js.put(DataColumns.ID, mDataId);
  164.         js.put(DataColumns.MIME_TYPE, mDataMimeType);
  165.         js.put(DataColumns.CONTENT, mDataContent);
  166.         js.put(DataColumns.DATA1, mDataContentData1);
  167.         js.put(DataColumns.DATA3, mDataContentData3);
  168.         return js;
  169.     }
  170.  
  171. 	/*
  172. 	 * 功能描述：commit函数用于把当前造作所做的修改保存到数据库
  173. 	 * 参数注解： 
  174. 	 * Made By CuiCan
  175. 	 */
  176.     public void commit(long noteId, boolean validateVersion, long version) {
  177.  
  178.         if (mIsCreate) {
  179.             if (mDataId == INVALID_ID && mDiffDataValues.containsKey(DataColumns.ID)) {
  180.                 mDiffDataValues.remove(DataColumns.ID);
  181.             }
  182.  
  183.             mDiffDataValues.put(DataColumns.NOTE_ID, noteId);
  184.             Uri uri = mContentResolver.insert(Notes.CONTENT_DATA_URI, mDiffDataValues);
  185.             try {
  186.                 mDataId = Long.valueOf(uri.getPathSegments().get(1));
  187.             } catch (NumberFormatException e) {
  188.                 Log.e(TAG, "Get note id error :" + e.toString());
  189.                 throw new ActionFailureException("create note failed");
  190.             }
  191.         } else {
  192.             if (mDiffDataValues.size() > 0) {
  193.                 int result = 0;
  194.                 if (!validateVersion) {
  195.                     result = mContentResolver.update(ContentUris.withAppendedId(
  196.                             Notes.CONTENT_DATA_URI, mDataId), mDiffDataValues, null, null);
  197.                 } else {
  198.                     result = mContentResolver.update(ContentUris.withAppendedId(
  199.                             Notes.CONTENT_DATA_URI, mDataId), mDiffDataValues,
  200.                             " ? in (SELECT " + NoteColumns.ID + " FROM " + TABLE.NOTE
  201.                                     + " WHERE " + NoteColumns.VERSION + "=?)", new String[] {
  202.                                     String.valueOf(noteId), String.valueOf(version)
  203.                             });
  204.                 }
  205.                 if (result == 0) {
  206.                     Log.w(TAG, "there is no update. maybe user updates note when syncing");
  207.                 }
  208.             }
  209.         }
  210.  
  211.         mDiffDataValues.clear();
  212.         mIsCreate = false;
  213.     }
  214.  
  215.     /*
  216.      * 功能描述：获取当前id
  217.      * 实现过程：
  218.      * 参数注解： 
  219.      * Made By CuiCan
  220.      */
  221.     public long getId() {
  222.         return mDataId;
  223.     }
  224. }

4、SqlNote.java

  1. /*
  2.  * Description：用于支持小米便签最底层的数据库相关操作，和sqldata的关系上是父集关系，即note是data的子父集。
  3.  * 和SqlData相比，SqlNote算是真正意义上的数据了。
  4.  */
  5.  
  6. package net.micode.notes.gtask.data;
  7. /*
  8.  * 功能描述：
  9.  * 实现过程：
  10.  * 参数注解： 
  11.  * Made By CuiCan
  12.  */
  13.  
  14. public class SqlNote {
  15. 	/*
  16. 	 * 功能描述：得到类的简写名称存入字符串TAG中
  17. 	 * 实现过程：调用getSimpleName ()函数
  18. 	 * Made By CuiCan
  19. 	 */
  20.     private static final String TAG = SqlNote.class.getSimpleName();
  21.  
  22.     private static final int INVALID_ID = -99999;
  23.     // 集合了interface NoteColumns中所有SF常量（17个）
  24.     public static final String[] PROJECTION_NOTE = new String[] {
  25.             NoteColumns.ID, NoteColumns.ALERTED_DATE, NoteColumns.BG_COLOR_ID,
  26.             NoteColumns.CREATED_DATE, NoteColumns.HAS_ATTACHMENT, NoteColumns.MODIFIED_DATE,
  27.             NoteColumns.NOTES_COUNT, NoteColumns.PARENT_ID, NoteColumns.SNIPPET, NoteColumns.TYPE,
  28.             NoteColumns.WIDGET_ID, NoteColumns.WIDGET_TYPE, NoteColumns.SYNC_ID,
  29.             NoteColumns.LOCAL_MODIFIED, NoteColumns.ORIGIN_PARENT_ID, NoteColumns.GTASK_ID,
  30.             NoteColumns.VERSION
  31.     };
  32.  
  33.     //以下设置17个列的编号
  34.     public static final int ID_COLUMN = 0;
  35.  
  36.     public static final int ALERTED_DATE_COLUMN = 1;
  37.  
  38.     public static final int BG_COLOR_ID_COLUMN = 2;
  39.  
  40.     public static final int CREATED_DATE_COLUMN = 3;
  41.  
  42.     public static final int HAS_ATTACHMENT_COLUMN = 4;
  43.  
  44.     public static final int MODIFIED_DATE_COLUMN = 5;
  45.  
  46.     public static final int NOTES_COUNT_COLUMN = 6;
  47.  
  48.     public static final int PARENT_ID_COLUMN = 7;
  49.  
  50.     public static final int SNIPPET_COLUMN = 8;
  51.  
  52.     public static final int TYPE_COLUMN = 9;
  53.  
  54.     public static final int WIDGET_ID_COLUMN = 10;
  55.  
  56.     public static final int WIDGET_TYPE_COLUMN = 11;
  57.  
  58.     public static final int SYNC_ID_COLUMN = 12;
  59.  
  60.     public static final int LOCAL_MODIFIED_COLUMN = 13;
  61.  
  62.     public static final int ORIGIN_PARENT_ID_COLUMN = 14;
  63.  
  64.     public static final int GTASK_ID_COLUMN = 15;
  65.  
  66.     public static final int VERSION_COLUMN = 16;
  67.  
  68.     //一下定义了17个内部的变量，其中12个可以由content中获得，5个需要初始化为0或者new
  69.     private Context mContext;
  70.  
  71.     private ContentResolver mContentResolver;
  72.  
  73.     private boolean mIsCreate;
  74.  
  75.     private long mId;
  76.  
  77.     private long mAlertDate;
  78.  
  79.     private int mBgColorId;
  80.  
  81.     private long mCreatedDate;
  82.  
  83.     private int mHasAttachment;
  84.  
  85.     private long mModifiedDate;
  86.  
  87.     private long mParentId;
  88.  
  89.     private String mSnippet;
  90.  
  91.     private int mType;
  92.  
  93.     private int mWidgetId;
  94.  
  95.     private int mWidgetType;
  96.  
  97.     private long mOriginParent;
  98.  
  99.     private long mVersion;
  100.  
  101.     private ContentValues mDiffNoteValues;
  102.  
  103.     private ArrayList<SqlData> mDataList;
  104.  
  105.     /*
  106.      * 功能描述：构造函数
  107.      * 参数注解： mIsCreate用于标示构造方式
  108.      * 参数注解： 
  109.      * Made By CuiCan
  110.      */
  111.     //构造函数只有context，对所有的变量进行初始化
  112.     public SqlNote(Context context) {
  113.         mContext = context;
  114.         mContentResolver = context.getContentResolver();
  115.         mIsCreate = true;
  116.         mId = INVALID_ID;
  117.         mAlertDate = 0;
  118.         mBgColorId = ResourceParser.getDefaultBgId(context);
  119.         mCreatedDate = System.currentTimeMillis();//调用系统函数获得创建时间
  120.         mHasAttachment = 0;
  121.         mModifiedDate = System.currentTimeMillis();//最后一次修改时间初始化为创建时间
  122.         mParentId = 0;
  123.         mSnippet = "";
  124.         mType = Notes.TYPE_NOTE;
  125.         mWidgetId = AppWidgetManager.INVALID_APPWIDGET_ID;
  126.         mWidgetType = Notes.TYPE_WIDGET_INVALIDE;
  127.         mOriginParent = 0;
  128.         mVersion = 0;
  129.         mDiffNoteValues = new ContentValues();
  130.         mDataList = new ArrayList<SqlData>();
  131.     }
  132.  
  133.  
  134.     /*
  135.      * 功能描述：构造函数
  136.      * 参数注解： mIsCreate用于标示构造方式
  137.      * 参数注解： 
  138.      * Made By CuiCan
  139.      */
  140.     //构造函数有context和一个数据库的cursor，多数变量通过cursor指向的一条记录直接进行初始化
  141.     public SqlNote(Context context, Cursor c) {
  142.         mContext = context;
  143.         mContentResolver = context.getContentResolver();
  144.         mIsCreate = false;
  145.         loadFromCursor(c);
  146.         mDataList = new ArrayList<SqlData>();
  147.         //
  148.         if (mType == Notes.TYPE_NOTE)
  149.             loadDataContent();
  150.         mDiffNoteValues = new ContentValues();
  151.     }
  152.  
  153.  
  154.     /*
  155.      * 功能描述：构造函数
  156.      * 参数注解： mIsCreate用于标示构造方式
  157.      * 参数注解： 
  158.      * Made By CuiCan
  159.      */
  160.     public SqlNote(Context context, long id) {
  161.         mContext = context;
  162.         mContentResolver = context.getContentResolver();
  163.         mIsCreate = false;
  164.         loadFromCursor(id);
  165.         mDataList = new ArrayList<SqlData>();
  166.         if (mType == Notes.TYPE_NOTE)
  167.             loadDataContent();
  168.         mDiffNoteValues = new ContentValues();
  169.  
  170.     }
  171.  
  172.     /*
  173.      * 功能描述：通过id从光标处加载数据
  174.      * Made By CuiCan
  175.      */
  176.     private void loadFromCursor(long id) {
  177.         Cursor c = null;
  178.         try {
  179.             c = mContentResolver.query(Notes.CONTENT_NOTE_URI, PROJECTION_NOTE, "(_id=?)",
  180.                     new String[] {
  181.                         String.valueOf(id)
  182.                     }, null);//通过id获得对应的ContentResolver中的cursor
  183.             if (c != null) {
  184.                 c.moveToNext();
  185.                 loadFromCursor(c);//然后加载数据进行初始化，这样函数
  186.                 //SqlNote(Context context, long id)与SqlNote(Context context, long id)的实现方式基本相同
  187.             } else {
  188.                 Log.w(TAG, "loadFromCursor: cursor = null");
  189.             }
  190.         } finally {
  191.             if (c != null)
  192.                 c.close();
  193.         }
  194.     }
  195.  
  196.     /*
  197.      * 功能描述：通过游标从光标处加载数据
  198.      * Made By CuiCan
  199.      */
  200.     private void loadFromCursor(Cursor c) {
  201.     	//直接从一条记录中的获得以下变量的初始值
  202.         mId = c.getLong(ID_COLUMN);
  203.         mAlertDate = c.getLong(ALERTED_DATE_COLUMN);
  204.         mBgColorId = c.getInt(BG_COLOR_ID_COLUMN);
  205.         mCreatedDate = c.getLong(CREATED_DATE_COLUMN);
  206.         mHasAttachment = c.getInt(HAS_ATTACHMENT_COLUMN);
  207.         mModifiedDate = c.getLong(MODIFIED_DATE_COLUMN);
  208.         mParentId = c.getLong(PARENT_ID_COLUMN);
  209.         mSnippet = c.getString(SNIPPET_COLUMN);
  210.         mType = c.getInt(TYPE_COLUMN);
  211.         mWidgetId = c.getInt(WIDGET_ID_COLUMN);
  212.         mWidgetType = c.getInt(WIDGET_TYPE_COLUMN);
  213.         mVersion = c.getLong(VERSION_COLUMN);
  214.     }
  215.  
  216.     /*
  217.      * 功能描述：通过content机制获取共享数据并加载到数据库当前游标处
  218.      * 参数注解： 
  219.      * Made By CuiCan
  220.      */
  221.     private void loadDataContent() {
  222.         Cursor c = null;
  223.         mDataList.clear();
  224.         try {
  225.             c = mContentResolver.query(Notes.CONTENT_DATA_URI, SqlData.PROJECTION_DATA,
  226.                     "(note_id=?)", new String[] {
  227.                         String.valueOf(mId)
  228.                     }, null);
  229.             if (c != null) {
  230.                 if (c.getCount() == 0) {
  231.                     Log.w(TAG, "it seems that the note has not data");
  232.                     return;
  233.                 }
  234.                 while (c.moveToNext()) {
  235.                     SqlData data = new SqlData(mContext, c);
  236.                     mDataList.add(data);
  237.                 }
  238.             } else {
  239.                 Log.w(TAG, "loadDataContent: cursor = null");
  240.             }
  241.         } finally {
  242.             if (c != null)
  243.                 c.close();
  244.         }
  245.     }
  246.  
  247.     /*
  248.      * 功能描述：设置通过content机制用于共享的数据信息
  249.      * 参数注解： 
  250.      * Made By CuiCan
  251.      */
  252.     public boolean setContent(JSONObject js) {
  253.         try {
  254.             JSONObject note = js.getJSONObject(GTaskStringUtils.META_HEAD_NOTE);
  255.             if (note.getInt(NoteColumns.TYPE) == Notes.TYPE_SYSTEM) {
  256.                 Log.w(TAG, "cannot set system folder");
  257.             } else if (note.getInt(NoteColumns.TYPE) == Notes.TYPE_FOLDER) {
  258.                 // for folder we can only update the snnipet and type
  259.                 String snippet = note.has(NoteColumns.SNIPPET) ? note
  260.                         .getString(NoteColumns.SNIPPET) : "";
  261.                 if (mIsCreate || !mSnippet.equals(snippet)) {
  262.                     mDiffNoteValues.put(NoteColumns.SNIPPET, snippet);
  263.                 }
  264.                 mSnippet = snippet;
  265.  
  266.                 int type = note.has(NoteColumns.TYPE) ? note.getInt(NoteColumns.TYPE)
  267.                         : Notes.TYPE_NOTE;
  268.                 if (mIsCreate || mType != type) {
  269.                     mDiffNoteValues.put(NoteColumns.TYPE, type);
  270.                 }
  271.                 mType = type;
  272.             } else if (note.getInt(NoteColumns.TYPE) == Notes.TYPE_NOTE) {
  273.                 JSONArray dataArray = js.getJSONArray(GTaskStringUtils.META_HEAD_DATA);
  274.                 long id = note.has(NoteColumns.ID) ? note.getLong(NoteColumns.ID) : INVALID_ID;
  275.                 if (mIsCreate || mId != id) {
  276.                     mDiffNoteValues.put(NoteColumns.ID, id);
  277.                 }
  278.                 mId = id;
  279.  
  280.                 long alertDate = note.has(NoteColumns.ALERTED_DATE) ? note
  281.                         .getLong(NoteColumns.ALERTED_DATE) : 0;
  282.                 if (mIsCreate || mAlertDate != alertDate) {
  283.                     mDiffNoteValues.put(NoteColumns.ALERTED_DATE, alertDate);
  284.                 }
  285.                 mAlertDate = alertDate;
  286.  
  287.                 int bgColorId = note.has(NoteColumns.BG_COLOR_ID) ? note
  288.                         .getInt(NoteColumns.BG_COLOR_ID) : ResourceParser.getDefaultBgId(mContext);
  289.                 if (mIsCreate || mBgColorId != bgColorId) {
  290.                     mDiffNoteValues.put(NoteColumns.BG_COLOR_ID, bgColorId);
  291.                 }
  292.                 mBgColorId = bgColorId;
  293.                 long createDate = note.has(NoteColumns.CREATED_DATE) ? note
  294.                         .getLong(NoteColumns.CREATED_DATE) : System.currentTimeMillis();
  295.                 if (mIsCreate || mCreatedDate != createDate) {
  296.                     mDiffNoteValues.put(NoteColumns.CREATED_DATE, createDate);
  297.                 }
  298.                 mCreatedDate = createDate;
  299.  
  300.                 int hasAttachment = note.has(NoteColumns.HAS_ATTACHMENT) ? note
  301.                         .getInt(NoteColumns.HAS_ATTACHMENT) : 0;
  302.                 if (mIsCreate || mHasAttachment != hasAttachment) {
  303.                     mDiffNoteValues.put(NoteColumns.HAS_ATTACHMENT, hasAttachment);
  304.                 }
  305.                 mHasAttachment = hasAttachment;
  306.  
  307.                 long modifiedDate = note.has(NoteColumns.MODIFIED_DATE) ? note
  308.                         .getLong(NoteColumns.MODIFIED_DATE) : System.currentTimeMillis();
  309.                 if (mIsCreate || mModifiedDate != modifiedDate) {
  310.                     mDiffNoteValues.put(NoteColumns.MODIFIED_DATE, modifiedDate);
  311.                 }
  312.                 mModifiedDate = modifiedDate;
  313.  
  314.                 long parentId = note.has(NoteColumns.PARENT_ID) ? note
  315.                         .getLong(NoteColumns.PARENT_ID) : 0;
  316.                 if (mIsCreate || mParentId != parentId) {
  317.                     mDiffNoteValues.put(NoteColumns.PARENT_ID, parentId);
  318.                 }
  319.                 mParentId = parentId;
  320.  
  321.                 String snippet = note.has(NoteColumns.SNIPPET) ? note
  322.                         .getString(NoteColumns.SNIPPET) : "";
  323.                 if (mIsCreate || !mSnippet.equals(snippet)) {
  324.                     mDiffNoteValues.put(NoteColumns.SNIPPET, snippet);
  325.                 }
  326.                 mSnippet = snippet;
  327.  
  328.                 int type = note.has(NoteColumns.TYPE) ? note.getInt(NoteColumns.TYPE)
  329.                         : Notes.TYPE_NOTE;
  330.                 if (mIsCreate || mType != type) {
  331.                     mDiffNoteValues.put(NoteColumns.TYPE, type);
  332.                 }
  333.                 mType = type;
  334.  
  335.                 int widgetId = note.has(NoteColumns.WIDGET_ID) ? note.getInt(NoteColumns.WIDGET_ID)
  336.                         : AppWidgetManager.INVALID_APPWIDGET_ID;
  337.                 if (mIsCreate || mWidgetId != widgetId) {
  338.                     mDiffNoteValues.put(NoteColumns.WIDGET_ID, widgetId);
  339.                 }
  340.                 mWidgetId = widgetId;
  341.  
  342.                 int widgetType = note.has(NoteColumns.WIDGET_TYPE) ? note
  343.                         .getInt(NoteColumns.WIDGET_TYPE) : Notes.TYPE_WIDGET_INVALIDE;
  344.                 if (mIsCreate || mWidgetType != widgetType) {
  345.                     mDiffNoteValues.put(NoteColumns.WIDGET_TYPE, widgetType);
  346.                 }
  347.                 mWidgetType = widgetType;
  348.  
  349.                 long originParent = note.has(NoteColumns.ORIGIN_PARENT_ID) ? note
  350.                         .getLong(NoteColumns.ORIGIN_PARENT_ID) : 0;
  351.                 if (mIsCreate || mOriginParent != originParent) {
  352.                     mDiffNoteValues.put(NoteColumns.ORIGIN_PARENT_ID, originParent);
  353.                 }
  354.                 mOriginParent = originParent;
  355.  
  356.                 for (int i = 0; i < dataArray.length(); i++) {
  357.                     JSONObject data = dataArray.getJSONObject(i);
  358.                     SqlData sqlData = null;
  359.                     if (data.has(DataColumns.ID)) {
  360.                         long dataId = data.getLong(DataColumns.ID);
  361.                         for (SqlData temp : mDataList) {
  362.                             if (dataId == temp.getId()) {
  363.                                 sqlData = temp;
  364.                             }
  365.                         }
  366.                     }
  367.  
  368.                     if (sqlData == null) {
  369.                         sqlData = new SqlData(mContext);
  370.                         mDataList.add(sqlData);
  371.                     }
  372.  
  373.                     sqlData.setContent(data);
  374.                 }
  375.             }
  376.         } catch (JSONException e) {
  377.             Log.e(TAG, e.toString());
  378.             e.printStackTrace();
  379.             return false;
  380.         }
  381.         return true;
  382.     }
  383.  
  384.     /*
  385.      * 功能描述：获取content机制提供的数据并加载到note中
  386.      * 参数注解： 
  387.      * Made By CuiCan
  388.      */
  389.     public JSONObject getContent() {
  390.         try {
  391.             JSONObject js = new JSONObject();
  392.  
  393.             if (mIsCreate) {
  394.                 Log.e(TAG, "it seems that we haven't created this in database yet");
  395.                 return null;
  396.             }
  397.  
  398.             JSONObject note = new JSONObject();
  399.             if (mType == Notes.TYPE_NOTE) {//类型为note时
  400.                 note.put(NoteColumns.ID, mId);
  401.                 note.put(NoteColumns.ALERTED_DATE, mAlertDate);
  402.                 note.put(NoteColumns.BG_COLOR_ID, mBgColorId);
  403.                 note.put(NoteColumns.CREATED_DATE, mCreatedDate);
  404.                 note.put(NoteColumns.HAS_ATTACHMENT, mHasAttachment);
  405.                 note.put(NoteColumns.MODIFIED_DATE, mModifiedDate);
  406.                 note.put(NoteColumns.PARENT_ID, mParentId);
  407.                 note.put(NoteColumns.SNIPPET, mSnippet);
  408.                 note.put(NoteColumns.TYPE, mType);
  409.                 note.put(NoteColumns.WIDGET_ID, mWidgetId);
  410.                 note.put(NoteColumns.WIDGET_TYPE, mWidgetType);
  411.                 note.put(NoteColumns.ORIGIN_PARENT_ID, mOriginParent);
  412.                 js.put(GTaskStringUtils.META_HEAD_NOTE, note);
  413.  
  414.                 JSONArray dataArray = new JSONArray();
  415.                 for (SqlData sqlData : mDataList) {
  416.                     JSONObject data = sqlData.getContent();
  417.                     if (data != null) {
  418.                         dataArray.put(data);
  419.                     }
  420.                 }
  421.                 js.put(GTaskStringUtils.META_HEAD_DATA, dataArray);
  422.             } else if (mType == Notes.TYPE_FOLDER || mType == Notes.TYPE_SYSTEM) {//类型为文件夹或者
  423.                 note.put(NoteColumns.ID, mId);
  424.                 note.put(NoteColumns.TYPE, mType);
  425.                 note.put(NoteColumns.SNIPPET, mSnippet);
  426.                 js.put(GTaskStringUtils.META_HEAD_NOTE, note);
  427.             }
  428.  
  429.             return js;
  430.         } catch (JSONException e) {
  431.             Log.e(TAG, e.toString());
  432.             e.printStackTrace();
  433.         }
  434.         return null;
  435.     }
  436.  
  437.     /*
  438.      * 功能描述：给当前id设置父id
  439.      * 参数注解： 
  440.      * Made By CuiCan
  441.      */
  442.     public void setParentId(long id) {
  443.         mParentId = id;
  444.         mDiffNoteValues.put(NoteColumns.PARENT_ID, id);
  445.     }
  446.  
  447.     /*
  448.      * 功能描述：给当前id设置Gtaskid
  449.      * 参数注解： 
  450.      * Made By CuiCan
  451.      */
  452.     public void setGtaskId(String gid) {
  453.         mDiffNoteValues.put(NoteColumns.GTASK_ID, gid);
  454.     }
  455.  
  456.     /*
  457.      * 功能描述：给当前id设置同步id
  458.      * 参数注解： 
  459.      * Made By CuiCan
  460.      */
  461.     public void setSyncId(long syncId) {
  462.         mDiffNoteValues.put(NoteColumns.SYNC_ID, syncId);
  463.     }
  464.  
  465.     /*
  466.      * 功能描述：初始化本地修改，即撤销所有当前修改
  467.      * 参数注解： 
  468.      * Made By CuiCan
  469.      */
  470.     public void resetLocalModified() {
  471.         mDiffNoteValues.put(NoteColumns.LOCAL_MODIFIED, 0);
  472.     }
  473.  
  474.     /*
  475.      * 功能描述：获得当前id
  476.      * 参数注解： 
  477.      * Made By CuiCan
  478.      */
  479.     public long getId() {
  480.         return mId;
  481.     }
  482.  
  483.     /*
  484.      * 功能描述：获得当前id的父id
  485.      * 参数注解： 
  486.      * Made By CuiCan
  487.      */
  488.     public long getParentId() {
  489.         return mParentId;
  490.     }
  491.  
  492.     /*
  493.      * 功能描述：获取小片段即用于显示的部分便签内容
  494.      * 参数注解： 
  495.      * Made By CuiCan
  496.      */
  497.     public String getSnippet() {
  498.         return mSnippet;
  499.     }
  500.  
  501.     /*
  502.      * 功能描述：判断是否为便签类型
  503.      * 参数注解： 
  504.      * Made By CuiCan
  505.      */
  506.     public boolean isNoteType() {
  507.         return mType == Notes.TYPE_NOTE;
  508.     }
  509.  
  510.     /*
  511.      * 功能描述：commit函数用于把当前造作所做的修改保存到数据库
  512.      * 参数注解： 
  513.      * Made By CuiCan
  514.      */
  515.     public void commit(boolean validateVersion) {
  516.         if (mIsCreate) {
  517.             if (mId == INVALID_ID && mDiffNoteValues.containsKey(NoteColumns.ID)) {
  518.                 mDiffNoteValues.remove(NoteColumns.ID);
  519.             }
  520.  
  521.             Uri uri = mContentResolver.insert(Notes.CONTENT_NOTE_URI, mDiffNoteValues);
  522.             try {
  523.                 mId = Long.valueOf(uri.getPathSegments().get(1));
  524.             } catch (NumberFormatException e) {
  525.                 Log.e(TAG, "Get note id error :" + e.toString());
  526.                 throw new ActionFailureException("create note failed");
  527.             }
  528.             if (mId == 0) {
  529.                 throw new IllegalStateException("Create thread id failed");
  530.             }
  531.  
  532.             if (mType == Notes.TYPE_NOTE) {
  533.                 for (SqlData sqlData : mDataList) {//直接使用sqldata中的实现
  534.                     sqlData.commit(mId, false, -1);
  535.                 }
  536.             }
  537.         } else {
  538.             if (mId <= 0 && mId != Notes.ID_ROOT_FOLDER && mId != Notes.ID_CALL_RECORD_FOLDER) {
  539.                 Log.e(TAG, "No such note");
  540.                 throw new IllegalStateException("Try to update note with invalid id");
  541.             }
  542.             if (mDiffNoteValues.size() > 0) {
  543.                 mVersion ++;
  544.                 int result = 0;
  545.                 if (!validateVersion) {//构造字符串
  546.                     result = mContentResolver.update(Notes.CONTENT_NOTE_URI, mDiffNoteValues, "("
  547.                             + NoteColumns.ID + "=?)", new String[] {
  548.                         String.valueOf(mId)
  549.                     });
  550.                 } else {
  551.                     result = mContentResolver.update(Notes.CONTENT_NOTE_URI, mDiffNoteValues, "("
  552.                             + NoteColumns.ID + "=?) AND (" + NoteColumns.VERSION + "<=?)",
  553.                             new String[] {
  554.                                     String.valueOf(mId), String.valueOf(mVersion)
  555.                             });
  556.                 }
  557.                 if (result == 0) {
  558.                     Log.w(TAG, "there is no update. maybe user updates note when syncing");
  559.                 }
  560.             }
  561.  
  562.             if (mType == Notes.TYPE_NOTE) {
  563.                 for (SqlData sqlData : mDataList) {
  564.                     sqlData.commit(mId, validateVersion, mVersion);
  565.                 }
  566.             }
  567.         }
  568.  
  569.         // refresh local info
  570.         loadFromCursor(mId);
  571.         if (mType == Notes.TYPE_NOTE)
  572.             loadDataContent();
  573.  
  574.         mDiffNoteValues.clear();
  575.         mIsCreate = false;
  576.     }
  577. }

5、Task.java

  1. package net.micode.notes.gtask.data;
  2.  
  3. public class Task extends Node {
  4.     private static final String TAG = Task.class.getSimpleName();
  5.  
  6.     private boolean mCompleted;//是否完成
  7.  
  8.     private String mNotes;
  9.  
  10.     private JSONObject mMetaInfo;//将在实例中存储数据的类型
  11.  
  12.     private Task mPriorSibling;//对应的优先兄弟Task的指针（待完善）
  13.  
  14.     private TaskList mParent;//所在的任务列表的指针
  15.  
  16.     public Task() {
  17.         super();
  18.         mCompleted = false;
  19.         mNotes = null;
  20.         mPriorSibling = null;//TaskList中当前Task前面的Task的指针
  21.         mParent = null;//当前Task所在的TaskList
  22.         mMetaInfo = null;
  23.     }
  24.  
  25.     public JSONObject getCreateAction(int actionId) {
  26.         JSONObject js = new JSONObject();
  27.  
  28.         try {
  29.             // action_type
  30.             js.put(GTaskStringUtils.GTASK_JSON_ACTION_TYPE,
  31.                     GTaskStringUtils.GTASK_JSON_ACTION_TYPE_CREATE);
  32.  
  33.             // action_id
  34.             js.put(GTaskStringUtils.GTASK_JSON_ACTION_ID, actionId);
  35.  
  36.             // index
  37.             js.put(GTaskStringUtils.GTASK_JSON_INDEX, mParent.getChildTaskIndex(this));
  38.  
  39.             // entity_delta
  40.             JSONObject entity = new JSONObject();
  41.             entity.put(GTaskStringUtils.GTASK_JSON_NAME, getName());
  42.             entity.put(GTaskStringUtils.GTASK_JSON_CREATOR_ID, "null");
  43.             entity.put(GTaskStringUtils.GTASK_JSON_ENTITY_TYPE,
  44.                     GTaskStringUtils.GTASK_JSON_TYPE_TASK);
  45.             if (getNotes() != null) {
  46.                 entity.put(GTaskStringUtils.GTASK_JSON_NOTES, getNotes());
  47.             }
  48.             js.put(GTaskStringUtils.GTASK_JSON_ENTITY_DELTA, entity);
  49.  
  50.             // parent_id
  51.             if (mParent!= null) {
  52.             js.put(GTaskStringUtils.GTASK_JSON_PARENT_ID, mParent.getGid());
  53.             }
  54.  
  55.             // dest_parent_type
  56.             js.put(GTaskStringUtils.GTASK_JSON_DEST_PARENT_TYPE,
  57.                     GTaskStringUtils.GTASK_JSON_TYPE_GROUP);
  58.  
  59.             // list_id
  60.             if (mParent!= null) {
  61.             js.put(GTaskStringUtils.GTASK_JSON_LIST_ID, mParent.getGid());
  62.             }
  63.  
  64.             // prior_sibling_id
  65.             if (mPriorSibling != null) {
  66.                 js.put(GTaskStringUtils.GTASK_JSON_PRIOR_SIBLING_ID, mPriorSibling.getGid());
  67.             }
  68.  
  69.         } catch (JSONException e) {
  70.             Log.e(TAG, e.toString());
  71.             e.printStackTrace();
  72.             throw new ActionFailureException("fail to generate task-create jsonobject");
  73.         }
  74.  
  75.         return js;
  76.     }
  77.  
  78.     public JSONObject getUpdateAction(int actionId) {
  79.         JSONObject js = new JSONObject();
  80.  
  81.         try {
  82.             // action_type
  83.             js.put(GTaskStringUtils.GTASK_JSON_ACTION_TYPE,
  84.                     GTaskStringUtils.GTASK_JSON_ACTION_TYPE_UPDATE);
  85.  
  86.             // action_id
  87.             js.put(GTaskStringUtils.GTASK_JSON_ACTION_ID, actionId);
  88.  
  89.             // id
  90.             js.put(GTaskStringUtils.GTASK_JSON_ID, getGid());
  91.  
  92.             // entity_delta
  93.             JSONObject entity = new JSONObject();
  94.             entity.put(GTaskStringUtils.GTASK_JSON_NAME, getName());
  95.             if (getNotes() != null) {
  96.                 entity.put(GTaskStringUtils.GTASK_JSON_NOTES, getNotes());
  97.             }
  98.             entity.put(GTaskStringUtils.GTASK_JSON_DELETED, getDeleted());
  99.             js.put(GTaskStringUtils.GTASK_JSON_ENTITY_DELTA, entity);
  100.  
  101.         } catch (JSONException e) {
  102.             Log.e(TAG, e.toString());
  103.             e.printStackTrace();
  104.             throw new ActionFailureException("fail to generate task-update jsonobject");
  105.         }
  106.  
  107.         return js;
  108.     }
  109.  
  110.     public void setContentByRemoteJSON(JSONObject js) {
  111.         if (js != null) {
  112.             try {
  113.                 // id
  114.                 if (js.has(GTaskStringUtils.GTASK_JSON_ID)) {
  115.                     setGid(js.getString(GTaskStringUtils.GTASK_JSON_ID));
  116.                 }
  117.  
  118.                 // last_modified
  119.                 if (js.has(GTaskStringUtils.GTASK_JSON_LAST_MODIFIED)) {
  120.                     setLastModified(js.getLong(GTaskStringUtils.GTASK_JSON_LAST_MODIFIED));
  121.                 }
  122.  
  123.                 // name
  124.                 if (js.has(GTaskStringUtils.GTASK_JSON_NAME)) {
  125.                     setName(js.getString(GTaskStringUtils.GTASK_JSON_NAME));
  126.                 }
  127.  
  128.                 // notes
  129.                 if (js.has(GTaskStringUtils.GTASK_JSON_NOTES)) {
  130.                     setNotes(js.getString(GTaskStringUtils.GTASK_JSON_NOTES));
  131.                 }
  132.  
  133.                 // deleted
  134.                 if (js.has(GTaskStringUtils.GTASK_JSON_DELETED)) {
  135.                     setDeleted(js.getBoolean(GTaskStringUtils.GTASK_JSON_DELETED));
  136.                 }
  137.  
  138.                 // completed
  139.                 if (js.has(GTaskStringUtils.GTASK_JSON_COMPLETED)) {
  140.                     setCompleted(js.getBoolean(GTaskStringUtils.GTASK_JSON_COMPLETED));
  141.                 }
  142.             } catch (JSONException e) {
  143.                 Log.e(TAG, e.toString());
  144.                 e.printStackTrace();
  145.                 throw new ActionFailureException("fail to get task content from jsonobject");
  146.             }
  147.         }
  148.     }
  149.  
  150.     public void setContentByLocalJSON(JSONObject js) {    //��metadata����ʵʩ
  151.         if (js == null || !js.has(GTaskStringUtils.META_HEAD_NOTE)
  152.                 || !js.has(GTaskStringUtils.META_HEAD_DATA)) {
  153.             Log.w(TAG, "setContentByLocalJSON: nothing is avaiable");
  154.         }
  155.  
  156.         try {
  157.             JSONObject note = js.getJSONObject(GTaskStringUtils.META_HEAD_NOTE);
  158.             JSONArray dataArray = js.getJSONArray(GTaskStringUtils.META_HEAD_DATA);
  159.  
  160.             if (note.getInt(NoteColumns.TYPE) != Notes.TYPE_NOTE) {
  161.                 Log.e(TAG, "invalid type"); 
  162.                 return;
  163.             }
  164.  
  165.             for (int i = 0; i < dataArray.length(); i++) {
  166.                 JSONObject data = dataArray.getJSONObject(i);
  167.                 if (TextUtils.equals(data.getString(DataColumns.MIME_TYPE), DataConstants.NOTE)) {
  168.                     setName(data.getString(DataColumns.CONTENT));
  169.                     break;
  170.                 }
  171.             }
  172.  
  173.         } catch (JSONException e) {
  174.             Log.e(TAG, e.toString());
  175.             e.printStackTrace();
  176.         }
  177.     }
  178.  
  179.     public JSONObject getLocalJSONFromContent() {
  180.         String name = getName();
  181.         try {
  182.             if (mMetaInfo == null) {
  183.                 // new task created from web
  184.                 if (name == null) {
  185.                     Log.w(TAG, "the note seems to be an empty one");
  186.                     return null;
  187.                 }
  188.  
  189.                 JSONObject js = new JSONObject();
  190.                 JSONObject note = new JSONObject();
  191.                 JSONArray dataArray = new JSONArray();
  192.                 JSONObject data = new JSONObject();
  193.                 data.put(DataColumns.CONTENT, name);
  194.                 dataArray.put(data);
  195.                 js.put(GTaskStringUtils.META_HEAD_DATA, dataArray);
  196.                 note.put(NoteColumns.TYPE, Notes.TYPE_NOTE);
  197.                 js.put(GTaskStringUtils.META_HEAD_NOTE, note);
  198.                 return js;
  199.             } else {
  200.                 // synced task
  201.                 JSONObject note = mMetaInfo.getJSONObject(GTaskStringUtils.META_HEAD_NOTE);
  202.                 JSONArray dataArray = mMetaInfo.getJSONArray(GTaskStringUtils.META_HEAD_DATA);
  203.  
  204.                 for (int i = 0; i < dataArray.length(); i++) {
  205.                     JSONObject data = dataArray.getJSONObject(i);
  206.                     if (TextUtils.equals(data.getString(DataColumns.MIME_TYPE), DataConstants.NOTE)) {
  207.                         data.put(DataColumns.CONTENT, getName());
  208.                         break;
  209.                     }
  210.                 }
  211.  
  212.                 note.put(NoteColumns.TYPE, Notes.TYPE_NOTE);
  213.                 return mMetaInfo;
  214.             }
  215.         } catch (JSONException e) {
  216.             Log.e(TAG, e.toString());
  217.             e.printStackTrace();
  218.             return null;
  219.         }
  220.     }
  221.  
  222.     public void setMetaInfo(MetaData metaData) {
  223.         if (metaData != null && metaData.getNotes() != null) {
  224.             try {
  225.                 mMetaInfo = new JSONObject(metaData.getNotes());
  226.             } catch (JSONException e) {
  227.                 Log.w(TAG, e.toString());
  228.                 mMetaInfo = null;
  229.             }
  230.         }
  231.     }
  232.  
  233.     public int getSyncAction(Cursor c) {
  234.         try {
  235.             JSONObject noteInfo = null;
  236.             if (mMetaInfo != null && mMetaInfo.has(GTaskStringUtils.META_HEAD_NOTE)) {
  237.                 noteInfo = mMetaInfo.getJSONObject(GTaskStringUtils.META_HEAD_NOTE);
  238.             }
  239.  
  240.             if (noteInfo == null) {
  241.                 Log.w(TAG, "it seems that note meta has been deleted");
  242.                 return SYNC_ACTION_UPDATE_REMOTE;
  243.             }
  244.  
  245.             if (!noteInfo.has(NoteColumns.ID)) {
  246.                 Log.w(TAG, "remote note id seems to be deleted");
  247.                 return SYNC_ACTION_UPDATE_LOCAL;
  248.             }
  249.  
  250.             // validate the note id now
  251.             if (c.getLong(SqlNote.ID_COLUMN) != noteInfo.getLong(NoteColumns.ID)) {
  252.                 Log.w(TAG, "note id doesn't match");
  253.                 return SYNC_ACTION_UPDATE_LOCAL;
  254.             }
  255.  
  256.             if (c.getInt(SqlNote.LOCAL_MODIFIED_COLUMN) == 0) {
  257.                 // there is no local update
  258.                 if (c.getLong(SqlNote.SYNC_ID_COLUMN) == getLastModified()) {
  259.                     // no update both side
  260.                     return SYNC_ACTION_NONE;
  261.                 } else {
  262.                     // apply remote to local
  263.                     return SYNC_ACTION_UPDATE_LOCAL;
  264.                 }
  265.             } else {
  266.                 // validate gtask id
  267.                 if (!c.getString(SqlNote.GTASK_ID_COLUMN).equals(getGid())) {
  268.                     Log.e(TAG, "gtask id doesn't match");
  269.                     return SYNC_ACTION_ERROR;
  270.                 }
  271.                 if (c.getLong(SqlNote.SYNC_ID_COLUMN) == getLastModified()) {
  272.                     // local modification only
  273.                     return SYNC_ACTION_UPDATE_REMOTE;
  274.                 } else {
  275.                     return SYNC_ACTION_UPDATE_CONFLICT;
  276.                 }
  277.             }
  278.         } catch (Exception e) {
  279.             Log.e(TAG, e.toString());
  280.             e.printStackTrace();
  281.         }
  282.  
  283.         return SYNC_ACTION_ERROR;
  284.     }
  285.  
  286.     public boolean isWorthSaving() {
  287.         return mMetaInfo != null || (getName() != null && getName().trim().length() > 0)
  288.                 || (getNotes() != null && getNotes().trim().length() > 0);
  289.     }
  290.  
  291.     public void setCompleted(boolean completed) {
  292.         this.mCompleted = completed;
  293.     }
  294.  
  295.     public void setNotes(String notes) {
  296.         this.mNotes = notes;
  297.     }
  298.  
  299.     public void setPriorSibling(Task priorSibling) {
  300.         this.mPriorSibling = priorSibling;
  301.     }
  302.  
  303.     public void setParent(TaskList parent) {
  304.         this.mParent = parent;
  305.     }
  306.  
  307.     public boolean getCompleted() {
  308.         return this.mCompleted;
  309.     }
  310.  
  311.     public String getNotes() {
  312.         return this.mNotes;
  313.     }
  314.  
  315.     public Task getPriorSibling() {
  316.         return this.mPriorSibling;
  317.     }
  318.  
  319.     public TaskList getParent() {
  320.         return this.mParent;
  321.     }
  322.  
  323. }

6、TaskList.java

  1. package net.micode.notes.gtask.data;
  2.  
  3. public class TaskList extends Node {
  4.     private static final String TAG = TaskList.class.getSimpleName();//tag标记
  5.  
  6.     private int mIndex;//当前TaskList的指针
  7.  
  8.     private ArrayList<Task> mChildren;//类中主要的保存数据的单元，用来实现一个以Task为元素的ArrayList
  9.  
  10.     public TaskList() {
  11.         super();
  12.         mChildren = new ArrayList<Task>();
  13.         mIndex = 1;
  14.     }
  15.  
  16.     /* (non-Javadoc)
  17.      * @see net.micode.notes.gtask.data.Node#getCreateAction(int)
  18.      * 生成并返回一个包含了一定数据的JSONObject实体
  19.      */
  20.     public JSONObject getCreateAction(int actionId) {
  21.         JSONObject js = new JSONObject();
  22.  
  23.         try {
  24.             // action_type
  25.             js.put(GTaskStringUtils.GTASK_JSON_ACTION_TYPE,
  26.                     GTaskStringUtils.GTASK_JSON_ACTION_TYPE_CREATE);
  27.  
  28.             // action_id
  29.             js.put(GTaskStringUtils.GTASK_JSON_ACTION_ID, actionId);
  30.  
  31.             // index
  32.             js.put(GTaskStringUtils.GTASK_JSON_INDEX, mIndex);
  33.  
  34.             // entity_delta
  35.             JSONObject entity = new JSONObject();//entity实体
  36.             entity.put(GTaskStringUtils.GTASK_JSON_NAME, getName());
  37.             entity.put(GTaskStringUtils.GTASK_JSON_CREATOR_ID, "null");
  38.             entity.put(GTaskStringUtils.GTASK_JSON_ENTITY_TYPE,
  39.                     GTaskStringUtils.GTASK_JSON_TYPE_GROUP);
  40.             js.put(GTaskStringUtils.GTASK_JSON_ENTITY_DELTA, entity);
  41.  
  42.         } catch (JSONException e) {
  43.             Log.e(TAG, e.toString());
  44.             e.printStackTrace();
  45.             throw new ActionFailureException("fail to generate tasklist-create jsonobject");
  46.         }
  47.  
  48.         return js;
  49.     }
  50.  
  51.     /* (non-Javadoc)
  52.      * @see net.micode.notes.gtask.data.Node#getUpdateAction(int)
  53.      * 生成并返回一个包含了一定数据的JSONObject实体
  54.      */
  55.     public JSONObject getUpdateAction(int actionId) {
  56.         JSONObject js = new JSONObject();
  57.  
  58.         try {
  59.             // action_type
  60.             js.put(GTaskStringUtils.GTASK_JSON_ACTION_TYPE,
  61.                     GTaskStringUtils.GTASK_JSON_ACTION_TYPE_UPDATE);
  62.  
  63.             // action_id
  64.             js.put(GTaskStringUtils.GTASK_JSON_ACTION_ID, actionId);
  65.  
  66.             // id
  67.             js.put(GTaskStringUtils.GTASK_JSON_ID, getGid());
  68.  
  69.             // entity_delta
  70.             JSONObject entity = new JSONObject();
  71.             entity.put(GTaskStringUtils.GTASK_JSON_NAME, getName());
  72.             entity.put(GTaskStringUtils.GTASK_JSON_DELETED, getDeleted());
  73.             js.put(GTaskStringUtils.GTASK_JSON_ENTITY_DELTA, entity);
  74.  
  75.         } catch (JSONException e) {
  76.             Log.e(TAG, e.toString());
  77.             e.printStackTrace();
  78.             throw new ActionFailureException("fail to generate tasklist-update jsonobject");
  79.         }
  80.  
  81.         return js;
  82.     }
  83.  
  84.     public void setContentByRemoteJSON(JSONObject js) {
  85.         if (js != null) {
  86.             try {
  87.                 // id
  88.                 if (js.has(GTaskStringUtils.GTASK_JSON_ID)) {
  89.                     setGid(js.getString(GTaskStringUtils.GTASK_JSON_ID));
  90.                 }
  91.  
  92.                 // last_modified
  93.                 if (js.has(GTaskStringUtils.GTASK_JSON_LAST_MODIFIED)) {
  94.                     setLastModified(js.getLong(GTaskStringUtils.GTASK_JSON_LAST_MODIFIED));
  95.                 }
  96.  
  97.                 // name
  98.                 if (js.has(GTaskStringUtils.GTASK_JSON_NAME)) {
  99.                     setName(js.getString(GTaskStringUtils.GTASK_JSON_NAME));
  100.                 }
  101.  
  102.             } catch (JSONException e) {
  103.                 Log.e(TAG, e.toString());
  104.                 e.printStackTrace();
  105.                 throw new ActionFailureException("fail to get tasklist content from jsonobject");
  106.             }
  107.         }
  108.     }
  109.  
  110.     public void setContentByLocalJSON(JSONObject js) {
  111.         if (js == null || !js.has(GTaskStringUtils.META_HEAD_NOTE)) {
  112.             Log.w(TAG, "setContentByLocalJSON: nothing is avaiable");
  113.         }
  114.  
  115.         try {
  116.             JSONObject folder = js.getJSONObject(GTaskStringUtils.META_HEAD_NOTE);
  117.  
  118.             if (folder.getInt(NoteColumns.TYPE) == Notes.TYPE_FOLDER) {
  119.                 String name = folder.getString(NoteColumns.SNIPPET);
  120.                 setName(GTaskStringUtils.MIUI_FOLDER_PREFFIX + name);
  121.             } else if (folder.getInt(NoteColumns.TYPE) == Notes.TYPE_SYSTEM) {
  122.                 if (folder.getLong(NoteColumns.ID) == Notes.ID_ROOT_FOLDER)
  123.                     setName(GTaskStringUtils.MIUI_FOLDER_PREFFIX + GTaskStringUtils.FOLDER_DEFAULT);
  124.                 else if (folder.getLong(NoteColumns.ID) == Notes.ID_CALL_RECORD_FOLDER)
  125.                     setName(GTaskStringUtils.MIUI_FOLDER_PREFFIX
  126.                             + GTaskStringUtils.FOLDER_CALL_NOTE);
  127.                 else
  128.                     Log.e(TAG, "invalid system folder");
  129.             } else {
  130.                 Log.e(TAG, "error type");
  131.             }
  132.         } catch (JSONException e) {
  133.             Log.e(TAG, e.toString());
  134.             e.printStackTrace();
  135.         }
  136.     }
  137.  
  138.     public JSONObject getLocalJSONFromContent() {
  139.         try {
  140.             JSONObject js = new JSONObject();
  141.             JSONObject folder = new JSONObject();
  142.  
  143.             String folderName = getName();
  144.             if (getName().startsWith(GTaskStringUtils.MIUI_FOLDER_PREFFIX))
  145.                 folderName = folderName.substring(GTaskStringUtils.MIUI_FOLDER_PREFFIX.length(),
  146.                         folderName.length());
  147.             folder.put(NoteColumns.SNIPPET, folderName);
  148.             if (folderName.equals(GTaskStringUtils.FOLDER_DEFAULT)
  149.                     || folderName.equals(GTaskStringUtils.FOLDER_CALL_NOTE))
  150.                 folder.put(NoteColumns.TYPE, Notes.TYPE_SYSTEM);
  151.             else
  152.                 folder.put(NoteColumns.TYPE, Notes.TYPE_FOLDER);
  153.  
  154.             js.put(GTaskStringUtils.META_HEAD_NOTE, folder);
  155.  
  156.             return js;
  157.         } catch (JSONException e) {
  158.             Log.e(TAG, e.toString());
  159.             e.printStackTrace();
  160.             return null;
  161.         }
  162.     }
  163.  
  164.     public int getSyncAction(Cursor c) {
  165.         try {
  166.             if (c.getInt(SqlNote.LOCAL_MODIFIED_COLUMN) == 0) {
  167.                 // there is no local update
  168.                 if (c.getLong(SqlNote.SYNC_ID_COLUMN) == getLastModified()) {
  169.                     // no update both side
  170.                     return SYNC_ACTION_NONE;
  171.                 } else {
  172.                     // apply remote to local
  173.                     return SYNC_ACTION_UPDATE_LOCAL;
  174.                 }
  175.             } else {
  176.                 // validate gtask id
  177.                 if (!c.getString(SqlNote.GTASK_ID_COLUMN).equals(getGid())) {
  178.                     Log.e(TAG, "gtask id doesn't match");
  179.                     return SYNC_ACTION_ERROR;
  180.                 }
  181.                 if (c.getLong(SqlNote.SYNC_ID_COLUMN) == getLastModified()) {
  182.                     // local modification only
  183.                     return SYNC_ACTION_UPDATE_REMOTE;
  184.                 } else {
  185.                     // for folder conflicts, just apply local modification
  186.                     return SYNC_ACTION_UPDATE_REMOTE;
  187.                 }
  188.             }
  189.         } catch (Exception e) {
  190.             Log.e(TAG, e.toString());
  191.             e.printStackTrace();
  192.         }
  193.  
  194.         return SYNC_ACTION_ERROR;
  195.     }
  196.  
  197.     /**
  198.      * @return
  199.      * 功能：获得TaskList的大小，即mChildren的大小
  200.      */
  201.     public int getChildTaskCount() {
  202.         return mChildren.size();
  203.     }
  204.  
  205.     /**
  206.      * @param task
  207.      * @return 返回值为是否成功添加任务。
  208.      * 功能：在当前任务表末尾添加新的任务。
  209.      */
  210.     public boolean addChildTask(Task task) {
  211.         boolean ret = false;
  212.         if (task != null && !mChildren.contains(task)) {
  213.             ret = mChildren.add(task);
  214.             if (ret) {
  215.                 // need to set prior sibling and parent
  216.                 task.setPriorSibling(mChildren.isEmpty() ? null : mChildren
  217.                         .get(mChildren.size() - 1));
  218.                 task.setParent(this);
  219.                 //注意：每一次ArrayList的变化都要紧跟相关Task中PriorSibling的更改
  220.                 //，接下来几个函数都有相关操作
  221.             }
  222.         }
  223.         return ret;
  224.     }
  225.  
  226.     /**
  227.      * @param task
  228.      * @param index
  229.      * @return
  230.      * 功能：在当前任务表的指定位置添加新的任务。
  231.      */
  232.     public boolean addChildTask(Task task, int index) {
  233.         if (index < 0 || index > mChildren.size()) {
  234.             Log.e(TAG, "add child task: invalid index");
  235.             return false;
  236.         }
  237.  
  238.         int pos = mChildren.indexOf(task);
  239.         if (task != null && pos == -1) {
  240.             mChildren.add(index, task);
  241.  
  242.             // update the task list
  243.             Task preTask = null;
  244.             Task afterTask = null;
  245.             if (index != 0)
  246.                 preTask = mChildren.get(index - 1);
  247.             if (index != mChildren.size() - 1)
  248.                 afterTask = mChildren.get(index + 1);
  249.  
  250.             task.setPriorSibling(preTask);
  251.             if (afterTask != null)
  252.                 afterTask.setPriorSibling(task);
  253.         }
  254.  
  255.         return true;
  256.     }
  257.  
  258.     /**
  259.      * @param task
  260.      * @return 返回删除是否成功
  261.      * 功能：删除TaskList中的一个Task
  262.      */
  263.     public boolean removeChildTask(Task task) {
  264.         boolean ret = false;
  265.         int index = mChildren.indexOf(task);
  266.         if (index != -1) {
  267.             ret = mChildren.remove(task);
  268.  
  269.             if (ret) {
  270.                 // reset prior sibling and parent
  271.                 task.setPriorSibling(null);
  272.                 task.setParent(null);
  273.  
  274.                 // update the task list
  275.                 if (index != mChildren.size()) {
  276.                     mChildren.get(index).setPriorSibling(
  277.                             index == 0 ? null : mChildren.get(index - 1));
  278.                 }
  279.             }
  280.         }
  281.         return ret;
  282.     }
  283.  
  284.     /**
  285.      * @param task
  286.      * @param index
  287.      * @return
  288.      * 功能：将当前TaskList中含有的某个Task移到index位置
  289.      */
  290.     public boolean moveChildTask(Task task, int index) {
  291.  
  292.         if (index < 0 || index >= mChildren.size()) {
  293.             Log.e(TAG, "move child task: invalid index");
  294.             return false;
  295.         }
  296.  
  297.         int pos = mChildren.indexOf(task);
  298.         if (pos == -1) {
  299.             Log.e(TAG, "move child task: the task should in the list");
  300.             return false;
  301.         }
  302.  
  303.         if (pos == index)
  304.             return true;
  305.         return (removeChildTask(task) && addChildTask(task, index));
  306.         //利用已实现好的功能完成当下功能；
  307.     }
  308.  
  309.     /**
  310.      * @param gid
  311.      * @return返回寻找结果
  312.      * 功能：按gid寻找Task
  313.      */
  314.     public Task findChildTaskByGid(String gid) {
  315.         for (int i = 0; i < mChildren.size(); i++) {
  316.             Task t = mChildren.get(i);
  317.             if (t.getGid().equals(gid)) {
  318.                 return t;
  319.             }
  320.         }
  321.         return null;
  322.     }
  323.  
  324.     /**
  325.      * @param task
  326.      * @return
  327.      * 功能：返回指定Task的index
  328.      */
  329.     public int getChildTaskIndex(Task task) {
  330.         return mChildren.indexOf(task);
  331.     }
  332.  
  333.     /**
  334.      * @param index
  335.      * @return
  336.      * 功能：返回指定index的Task
  337.      */
  338.     public Task getChildTaskByIndex(int index) {
  339.         if (index < 0 || index >= mChildren.size()) {
  340.             Log.e(TAG, "getTaskByIndex: invalid index");
  341.             return null;
  342.         }
  343.         return mChildren.get(index);
  344.     }
  345.  
  346.     /**
  347.      * @param gid
  348.      * @return
  349.      * 功能：返回指定gid的Task
  350.      */
  351.     public Task getChilTaskByGid(String gid) {
  352.         for (Task task : mChildren) {//一种常见的ArrayList的遍历方法（四种，见精读笔记）
  353.             if (task.getGid().equals(gid))
  354.                 return task;
  355.         }
  356.         return null;
  357.     }
  358.  
  359.     public ArrayList<Task> getChildTaskList() {
  360.         return this.mChildren;
  361.     }
  362.  
  363.     public void setIndex(int index) {
  364.         this.mIndex = index;
  365.     }
  366.  
  367.     public int getIndex() {
  368.         return this.mIndex;
  369.     }
  370. }

二、exception包

1、ActionFailureException.java

  1. /*
  2.  * Description：支持小米便签运行过程中的运行异常处理。
  3.  */
  4.  
  5. package net.micode.notes.gtask.exception;
  6.  
  7. public class ActionFailureException extends RuntimeException {
  8.     private static final long serialVersionUID = 4425249765923293627L;
  9.     /*
  10.      * serialVersionUID相当于java类的身份证。主要用于版本控制。
  11.      * serialVersionUID作用是序列化时保持版本的兼容性，即在版本升级时反序列化仍保持对象的唯一性。
  12.      * Made By Cuican
  13.      */
  14.     
  15.     public ActionFailureException() {
  16.         super();
  17.     }
  18.     /*
  19.      * 在JAVA类中使用super来引用父类的成分，用this来引用当前对象.
  20.      * 如果一个类从另外一个类继承，我们new这个子类的实例对象的时候，这个子类对象里面会有一个父类对象。
  21.      * 怎么去引用里面的父类对象呢？使用super来引用
  22.      * 也就是说，此处super()以及super (paramString)可认为是Exception ()和Exception (paramString)
  23.      * Made By Cuican
  24.      */
  25.     public ActionFailureException(String paramString) {
  26.         super(paramString);
  27.     }
  28.  
  29.     public ActionFailureException(String paramString, Throwable paramThrowable) {
  30.         super(paramString, paramThrowable);
  31.     }
  32. }

2、NetworkFailureException.java

  1. /*
  2.  * Description：支持小米便签运行过程中的网络异常处理。
  3.  */
  4.  
  5. package net.micode.notes.gtask.exception;
  6.  
  7. public class NetworkFailureException extends Exception {
  8.     private static final long serialVersionUID = 2107610287180234136L;
  9.     /*
  10.      * serialVersionUID相当于java类的身份证。主要用于版本控制。
  11.      * serialVersionUID作用是序列化时保持版本的兼容性，即在版本升级时反序列化仍保持对象的唯一性。
  12.      * Made By Cuican
  13.      */
  14.  
  15.     public NetworkFailureException() {
  16.         super();
  17.     }
  18.  
  19.     /*
  20.      * 在JAVA类中使用super来引用父类的成分，用this来引用当前对象.
  21.      * 如果一个类从另外一个类继承，我们new这个子类的实例对象的时候，这个子类对象里面会有一个父类对象。
  22.      * 怎么去引用里面的父类对象呢？使用super来引用
  23.      * 也就是说，此处super()以及super (paramString)可认为是Exception ()和Exception (paramString)
  24.      * Made By Cuican
  25.      */
  26.     public NetworkFailureException(String paramString) {
  27.         super(paramString);
  28.     }
  29.  
  30.     public NetworkFailureException(String paramString, Throwable paramThrowable) {
  31.         super(paramString, paramThrowable);
  32.     }
  33. }

三、remote包

1、GTaskASyncTask.java

  1. package net.micode.notes.gtask.remote;
  2.  
  3. /*异步操作类，实现GTask的异步操作过程
  4.  * 主要方法：
  5.  * private void showNotification(int tickerId, String content) 向用户提示当前同步的状态，是一个用于交互的方法
  6.  * protected Integer doInBackground(Void... unused) 此方法在后台线程执行，完成任务的主要工作，通常需要较长的时间
  7.  * protected void onProgressUpdate(String... progress)  可以使用进度条增加用户体验度。 此方法在主线程执行，用于显示任务执行的进度。
  8.  * protected void onPostExecute(Integer result)  相当于Handler 处理UI的方式，在这里面可以使用在doInBackground 得到的结果处理操作UI
  9.  */
  10. public class GTaskASyncTask extends AsyncTask<Void, String, Integer> {
  11.  
  12.  
  13.     private static int GTASK_SYNC_NOTIFICATION_ID = 5234235;
  14.  
  15.     public interface OnCompleteListener {
  16.         void onComplete();
  17.     }
  18.  
  19.     private Context mContext;
  20.  
  21.     private NotificationManager mNotifiManager;
  22.  
  23.     private GTaskManager mTaskManager;
  24.  
  25.     private OnCompleteListener mOnCompleteListener;
  26.  
  27.     public GTaskASyncTask(Context context, OnCompleteListener listener) {
  28.         mContext = context;
  29.         mOnCompleteListener = listener;
  30.         mNotifiManager = (NotificationManager) mContext
  31.                 .getSystemService(Context.NOTIFICATION_SERVICE);
  32.         mTaskManager = GTaskManager.getInstance();
  33.     }
  34.  
  35.     public void cancelSync() {
  36.         mTaskManager.cancelSync();
  37.     }
  38.  
  39.     public void publishProgess(String message) { // 发布进度单位，系统将会调用onProgressUpdate()方法更新这些值
  40.         publishProgress(new String[] {
  41.             message
  42.         });
  43.     }
  44.  
  45.     private void showNotification(int tickerId, String content) {
  46.         Notification notification = new Notification(R.drawable.notification, mContext
  47.                 .getString(tickerId), System.currentTimeMillis());
  48.         notification.defaults = Notification.DEFAULT_LIGHTS; // 调用系统自带灯光
  49.         notification.flags = Notification.FLAG_AUTO_CANCEL;  // 点击清除按钮或点击通知后会自动消失
  50.         PendingIntent pendingIntent;  //一个描述了想要启动一个Activity、Broadcast或是Service的意图
  51.         if (tickerId != R.string.ticker_success) {
  52.             pendingIntent = PendingIntent.getActivity(mContext, 0, new Intent(mContext,
  53.                     NotesPreferenceActivity.class), 0);  //如果同步不成功，那么从系统取得一个用于启动一个NotesPreferenceActivity的PendingIntent对象
  54.  
  55.         } else {
  56.             pendingIntent = PendingIntent.getActivity(mContext, 0, new Intent(mContext,
  57.                     NotesListActivity.class), 0); //如果同步成功，那么从系统取得一个用于启动一个NotesListActivity的PendingIntent对象
  58.         }
  59.         notification.setLatestEventInfo(mContext, mContext.getString(R.string.app_name), content,
  60.                 pendingIntent);
  61.         mNotifiManager.notify(GTASK_SYNC_NOTIFICATION_ID, notification);//通过NotificationManager对象的notify（）方法来执行一个notification的消息
  62.     }
  63.  
  64.     @Override
  65.     protected Integer doInBackground(Void... unused) {
  66.         publishProgess(mContext.getString(R.string.sync_progress_login, NotesPreferenceActivity
  67.                 .getSyncAccountName(mContext)));  //利用getString,将把 NotesPreferenceActivity.getSyncAccountName(mContext))的字符串内容传进sync_progress_login中
  68.         return mTaskManager.sync(mContext, this);    //进行后台同步具体操作
  69.     }
  70.  
  71.     @Override
  72.     protected void onProgressUpdate(String... progress) {
  73.         showNotification(R.string.ticker_syncing, progress[0]);
  74.         if (mContext instanceof GTaskSyncService) {  //instanceof 判断mContext是否是GTaskSyncService的实例
  75.             ((GTaskSyncService) mContext).sendBroadcast(progress[0]);
  76.         }
  77.     }
  78.  
  79.     @Override
  80.     protected void onPostExecute(Integer result) {  //用于在执行完后台任务后更新UI,显示结果 
  81.         if (result == GTaskManager.STATE_SUCCESS) {
  82.             showNotification(R.string.ticker_success, mContext.getString(
  83.                     R.string.success_sync_account, mTaskManager.getSyncAccount()));
  84.             NotesPreferenceActivity.setLastSyncTime(mContext, System.currentTimeMillis());  //设置最新同步的时间
  85.         } else if (result == GTaskManager.STATE_NETWORK_ERROR) {
  86.             showNotification(R.string.ticker_fail, mContext.getString(R.string.error_sync_network));
  87.         } else if (result == GTaskManager.STATE_INTERNAL_ERROR) {
  88.             showNotification(R.string.ticker_fail, mContext.getString(R.string.error_sync_internal));
  89.         } else if (result == GTaskManager.STATE_SYNC_CANCELLED) {
  90.             showNotification(R.string.ticker_cancel, mContext
  91.                     .getString(R.string.error_sync_cancelled));
  92.         } //几种不同情况下的结果显示
  93.         if (mOnCompleteListener != null) {
  94.             new Thread(new Runnable() {  //这里好像是方法内的一个线程，但是并不太懂什么意思
  95.  
  96.                 public void run() {   //完成后的操作，使用onComplete()将所有值都重新初始化，相当于完成一次操作
  97.                     mOnCompleteListener.onComplete();    
  98.                 }
  99.             }).start();
  100.         }
  101.     }
  102. }

2、GTaskClient.java

  1. package net.micode.notes.gtask.remote;
  2.  
  3. /*
  4.  * 主要功能：实现GTASK的登录操作，进行GTASK任务的创建，创建任务列表，从网络上获取任务和任务列表的内容
  5.  * 主要使用类或技术：accountManager JSONObject HttpParams authToken Gid
  6.  */ 
  7. public class GTaskClient {
  8.     private static final String TAG = GTaskClient.class.getSimpleName();
  9.  
  10.     private static final String GTASK_URL = "https://mail.google.com/tasks/"; //这个是指定的URL
  11.  
  12.     private static final String GTASK_GET_URL = "https://mail.google.com/tasks/ig";
  13.  
  14.     private static final String GTASK_POST_URL = "https://mail.google.com/tasks/r/ig";
  15.  
  16.     private static GTaskClient mInstance = null;
  17.  
  18.     private DefaultHttpClient mHttpClient;
  19.  
  20.     private String mGetUrl;
  21.  
  22.     private String mPostUrl;
  23.  
  24.     private long mClientVersion;
  25.  
  26.     private boolean mLoggedin;
  27.  
  28.     private long mLastLoginTime;
  29.  
  30.     private int mActionId;
  31.  
  32.     private Account mAccount;
  33.  
  34.     private JSONArray mUpdateArray;
  35.     
  36.     private GTaskClient() {
  37.         mHttpClient = null;
  38.         mGetUrl = GTASK_GET_URL;
  39.         mPostUrl = GTASK_POST_URL;
  40.         mClientVersion = -1;
  41.         mLoggedin = false;
  42.         mLastLoginTime = 0;
  43.         mActionId = 1;
  44.         mAccount = null;
  45.         mUpdateArray = null;
  46.     }
  47.     
  48.     /*用来获取的实例化对象
  49.      * 使用 getInstance()
  50.      * 返回mInstance这个实例化对象
  51.      */
  52.     public static synchronized GTaskClient getInstance() {
  53.         if (mInstance == null) {
  54.             mInstance = new GTaskClient();
  55.         }
  56.         return mInstance;
  57.     }
  58.     
  59.     /*用来实现登录操作的函数，传入的参数是一个Activity
  60.      * 设置登录操作限制时间，如果超时则需要重新登录
  61.      * 有两种登录方式，使用用户自己的URL登录或者使用谷歌官方的URL登录
  62.      * 返回true或者false，即最后是否登陆成功
  63.      */
  64.     public boolean login(Activity activity) {
  65.         // we suppose that the cookie would expire after 5 minutes
  66.         // then we need to re-login
  67.     	//判断距离最后一次登录操作是否超过5分钟
  68.         final long interval = 1000 * 60 * 5;
  69.         if (mLastLoginTime + interval < System.currentTimeMillis()) {
  70.             mLoggedin = false;
  71.         }
  72.  
  73.         // need to re-login after account switch  重新登录操作
  74.         if (mLoggedin
  75.                 && !TextUtils.equals(getSyncAccount().name, NotesPreferenceActivity
  76.                         .getSyncAccountName(activity))) {
  77.             mLoggedin = false;
  78.         }
  79.         
  80.         //如果没超过时间，则不需要重新登录
  81.         if (mLoggedin) {
  82.             Log.d(TAG, "already logged in");
  83.             return true;
  84.         }
  85.         
  86.         mLastLoginTime = System.currentTimeMillis();//更新最后登录时间，改为系统当前的时间
  87.         String authToken = loginGoogleAccount(activity, false);//判断是否登录到谷歌账户
  88.         if (authToken == null) {
  89.             Log.e(TAG, "login google account failed");
  90.             return false;
  91.         }
  92.  
  93.         // login with custom domain if necessary
  94.         //尝试使用用户自己的域名登录
  95.         if (!(mAccount.name.toLowerCase().endsWith("gmail.com") || mAccount.name.toLowerCase() //将用户账号名改为统一格式（小写）后判断是否为一个谷歌账号地址
  96.                 .endsWith("googlemail.com"))) {
  97.             StringBuilder url = new StringBuilder(GTASK_URL).append("a/");
  98.             int index = mAccount.name.indexOf('@') + 1;
  99.             String suffix = mAccount.name.substring(index);
  100.             url.append(suffix + "/");
  101.             mGetUrl = url.toString() + "ig";  //设置用户对应的getUrl
  102.             mPostUrl = url.toString() + "r/ig";  //设置用户对应的postUrl
  103.  
  104.             if (tryToLoginGtask(activity, authToken)) {
  105.                 mLoggedin = true;
  106.             }
  107.         }
  108.  
  109.         // try to login with google official url
  110.         //如果用户账户无法登录，则使用谷歌官方的URI进行登录
  111.         if (!mLoggedin) {
  112.             mGetUrl = GTASK_GET_URL; 
  113.             mPostUrl = GTASK_POST_URL;
  114.             if (!tryToLoginGtask(activity, authToken)) {
  115.                 return false;
  116.             }
  117.         }
  118.  
  119.         mLoggedin = true;
  120.         return true;
  121.     }
  122.     
  123.     /*具体实现登录谷歌账户的方法
  124.      * 使用令牌机制
  125.      * 使用AccountManager来管理注册账号
  126.      * 返回值是账号的令牌
  127.      */
  128.     private String loginGoogleAccount(Activity activity, boolean invalidateToken) {
  129.         String authToken;  //令牌，是登录操作保证安全性的一个方法
  130.         AccountManager accountManager = AccountManager.get(activity);//AccountManager这个类给用户提供了集中注册账号的接口
  131.         Account[] accounts = accountManager.getAccountsByType("com.google");//获取全部以com.google结尾的account
  132.  
  133.         if (accounts.length == 0) {
  134.             Log.e(TAG, "there is no available google account");
  135.             return null;
  136.         }
  137.  
  138.         String accountName = NotesPreferenceActivity.getSyncAccountName(activity);
  139.         Account account = null;
  140.         //遍历获得的accounts信息，寻找已经记录过的账户信息
  141.         for (Account a : accounts) {
  142.             if (a.name.equals(accountName)) {
  143.                 account = a;
  144.                 break;
  145.             }
  146.         }
  147.         if (account != null) {
  148.             mAccount = account;
  149.         } else {
  150.             Log.e(TAG, "unable to get an account with the same name in the settings");
  151.             return null;
  152.         }
  153.  
  154.         // get the token now
  155.         //获取选中账号的令牌
  156.         AccountManagerFuture<Bundle> accountManagerFuture = accountManager.getAuthToken(account,
  157.                 "goanna_mobile", null, activity, null, null);
  158.         try {
  159.             Bundle authTokenBundle = accountManagerFuture.getResult();
  160.             authToken = authTokenBundle.getString(AccountManager.KEY_AUTHTOKEN);
  161.             //如果是invalidateToken，那么需要调用invalidateAuthToken(String, String)方法废除这个无效token
  162.             if (invalidateToken) {
  163.                 accountManager.invalidateAuthToken("com.google", authToken);
  164.                 loginGoogleAccount(activity, false);
  165.             }
  166.         } catch (Exception e) {
  167.             Log.e(TAG, "get auth token failed");
  168.             authToken = null;
  169.         }
  170.  
  171.         return authToken;
  172.     }
  173.     
  174.     //尝试登陆Gtask，这只是一个预先判断令牌是否是有效以及是否能登上GTask的方法,而不是具体实现登陆的方法
  175.     private boolean tryToLoginGtask(Activity activity, String authToken) {
  176.         if (!loginGtask(authToken)) {  
  177.             // maybe the auth token is out of authTokedate, now let's invalidate the
  178.             // token and try again
  179.         	//删除过一个无效的authToken，申请一个新的后再次尝试登陆
  180.             authToken = loginGoogleAccount(activity, true);
  181.             if (authToken == null) {
  182.                 Log.e(TAG, "login google account failed");
  183.                 return false;
  184.             }
  185.  
  186.             if (!loginGtask(authToken)) {
  187.                 Log.e(TAG, "login gtask failed");
  188.                 return false;
  189.             }
  190.         }
  191.         return true;
  192.     }
  193.     
  194.     //实现登录GTask的具体操作
  195.     private boolean loginGtask(String authToken) {
  196.         int timeoutConnection = 10000;
  197.         int timeoutSocket = 15000;  //socket是一种通信连接实现数据的交换的端口
  198.         HttpParams httpParameters = new BasicHttpParams(); //实例化一个新的HTTP参数类
  199.         HttpConnectionParams.setConnectionTimeout(httpParameters, timeoutConnection);//设置连接超时时间
  200.         HttpConnectionParams.setSoTimeout(httpParameters, timeoutSocket);//设置设置端口超时时间
  201.         mHttpClient = new DefaultHttpClient(httpParameters);
  202.         BasicCookieStore localBasicCookieStore = new BasicCookieStore(); //设置本地cookie
  203.         mHttpClient.setCookieStore(localBasicCookieStore);
  204.         HttpProtocolParams.setUseExpectContinue(mHttpClient.getParams(), false);
  205.  
  206.         // login gtask
  207.         try {
  208.             String loginUrl = mGetUrl + "?auth=" + authToken;  //设置登录的url
  209.             HttpGet httpGet = new HttpGet(loginUrl);  //通过登录的uri实例化网页上资源的查找
  210.             HttpResponse response = null;
  211.             response = mHttpClient.execute(httpGet);
  212.  
  213.             // get the cookie now
  214.             //获取CookieStore里存放的cookie,看如果存有“GTL(不知道什么意思)”，则说明有验证成功的有效的cookie
  215.             List<Cookie> cookies = mHttpClient.getCookieStore().getCookies();
  216.             boolean hasAuthCookie = false;
  217.             for (Cookie cookie : cookies) {
  218.                 if (cookie.getName().contains("GTL")) {
  219.                     hasAuthCookie = true;
  220.                 }
  221.             }
  222.             if (!hasAuthCookie) {
  223.                 Log.w(TAG, "it seems that there is no auth cookie");
  224.             }
  225.  
  226.             // get the client version
  227.             //获取client的内容，具体操作是在返回的Content中截取从_setup(开始到)}</script>中间的字符串内容，也就是gtask_url的内容
  228.             String resString = getResponseContent(response.getEntity());
  229.             String jsBegin = "_setup(";
  230.             String jsEnd = ")}</script>";
  231.             int begin = resString.indexOf(jsBegin);
  232.             int end = resString.lastIndexOf(jsEnd);
  233.             String jsString = null;
  234.             if (begin != -1 && end != -1 && begin < end) {
  235.                 jsString = resString.substring(begin + jsBegin.length(), end);
  236.             }
  237.             JSONObject js = new JSONObject(jsString);
  238.             mClientVersion = js.getLong("v");
  239.         } catch (JSONException e) {
  240.             Log.e(TAG, e.toString());
  241.             e.printStackTrace();
  242.             return false;
  243.         } catch (Exception e) {
  244.             // simply catch all exceptions
  245.             Log.e(TAG, "httpget gtask_url failed");
  246.             return false;
  247.         }
  248.  
  249.         return true;
  250.     }
  251.  
  252.     private int getActionId() {
  253.         return mActionId++;
  254.     }
  255.     
  256.     /*实例化创建一个用于向网络传输数据的对象
  257.      * 使用HttpPost类
  258.      * 返回一个httpPost实例化对象，但里面还没有内容
  259.      */
  260.     private HttpPost createHttpPost() {
  261.         HttpPost httpPost = new HttpPost(mPostUrl);
  262.         httpPost.setHeader("Content-Type", "application/x-www-form-urlencoded;charset=utf-8");
  263.         httpPost.setHeader("AT", "1");
  264.         return httpPost;
  265.     }
  266.     
  267.     /*通过URL获取响应后返回的数据，也就是网络上的数据和资源
  268.      * 使用getContentEncoding()获取网络上的资源和数据
  269.      * 返回值就是获取到的资源
  270.      */
  271.     private String getResponseContent(HttpEntity entity) throws IOException {
  272.         String contentEncoding = null;
  273.         if (entity.getContentEncoding() != null) {//通过URL得到HttpEntity对象，如果不为空则使用getContent（）方法创建一个流将数据从网络都过来
  274.             contentEncoding = entity.getContentEncoding().getValue();
  275.             Log.d(TAG, "encoding: " + contentEncoding);
  276.         }
  277.  
  278.         InputStream input = entity.getContent();
  279.         if (contentEncoding != null && contentEncoding.equalsIgnoreCase("gzip")) {//GZIP是使用DEFLATE进行压缩数据的另一个压缩库
  280.             input = new GZIPInputStream(entity.getContent());
  281.         } else if (contentEncoding != null && contentEncoding.equalsIgnoreCase("deflate")) {//DEFLATE是一个无专利的压缩算法，它可以实现无损数据压缩
  282.             Inflater inflater = new Inflater(true);
  283.             input = new InflaterInputStream(entity.getContent(), inflater);
  284.         }
  285.  
  286.         try {
  287.             InputStreamReader isr = new InputStreamReader(input);
  288.             BufferedReader br = new BufferedReader(isr);//是一个包装类，它可以包装字符流，将字符流放入缓存里，先把字符读到缓存里，到缓存满了时候，再读入内存，是为了提供读的效率而设计的
  289.             StringBuilder sb = new StringBuilder();
  290.  
  291.             while (true) {
  292.                 String buff = br.readLine();
  293.                 if (buff == null) {
  294.                     return sb.toString();
  295.                 }
  296.                 sb = sb.append(buff);
  297.             }
  298.         } finally {
  299.             input.close();
  300.         }
  301.     }
  302.     
  303.   /*通过JSON发送请求
  304.    * 请求的具体内容在json的实例化对象js中然后传入
  305.    * 利用UrlEncodedFormEntity entity和httpPost.setEntity(entity)方法把js中的内容放置到httpPost中
  306.    * 执行请求后使用getResponseContent方法得到返回的数据和资源
  307.    * 将资源再次放入json后返回
  308.    */
  309.     private JSONObject postRequest(JSONObject js) throws NetworkFailureException {
  310.         if (!mLoggedin) {//未登录
  311.             Log.e(TAG, "please login first");
  312.             throw new ActionFailureException("not logged in");
  313.         }
  314.         
  315.         //实例化一个httpPost的对象用来向服务器传输数据，在这里就是发送请求，而请求的内容在js里
  316.         HttpPost httpPost = createHttpPost();
  317.         try {
  318.             LinkedList<BasicNameValuePair> list = new LinkedList<BasicNameValuePair>();
  319.             list.add(new BasicNameValuePair("r", js.toString()));
  320.             UrlEncodedFormEntity entity = new UrlEncodedFormEntity(list, "UTF-8"); //UrlEncodedFormEntity()的形式比较单一，是普通的键值对
  321.             httpPost.setEntity(entity);
  322.  
  323.             // execute the post
  324.             //执行这个请求
  325.             HttpResponse response = mHttpClient.execute(httpPost);
  326.             String jsString = getResponseContent(response.getEntity());
  327.             return new JSONObject(jsString);
  328.  
  329.         } catch (ClientProtocolException e) {
  330.             Log.e(TAG, e.toString());
  331.             e.printStackTrace();
  332.             throw new NetworkFailureException("postRequest failed");
  333.         } catch (IOException e) {
  334.             Log.e(TAG, e.toString());
  335.             e.printStackTrace();
  336.             throw new NetworkFailureException("postRequest failed");
  337.         } catch (JSONException e) {
  338.             Log.e(TAG, e.toString());
  339.             e.printStackTrace();
  340.             throw new ActionFailureException("unable to convert response content to jsonobject");
  341.         } catch (Exception e) {
  342.             Log.e(TAG, e.toString());
  343.             e.printStackTrace();
  344.             throw new ActionFailureException("error occurs when posting request");
  345.         }
  346.     }
  347.     
  348.     /*创建单个任务
  349.      * 传入参数是一个.gtask.data.Task包里Task类的对象
  350.      * 利用json获取Task里的内容,并且创建相应的jsPost
  351.      * 利用postRequest得到任务的返回信息
  352.      * 使用task.setGid设置task的new_ID
  353.      */
  354.     public void createTask(Task task) throws NetworkFailureException {
  355.         commitUpdate();
  356.         try {
  357.             JSONObject jsPost = new JSONObject();
  358.             JSONArray actionList = new JSONArray();
  359.  
  360.             // action_list
  361.             actionList.put(task.getCreateAction(getActionId()));
  362.             jsPost.put(GTaskStringUtils.GTASK_JSON_ACTION_LIST, actionList);
  363.  
  364.             // client_version
  365.             jsPost.put(GTaskStringUtils.GTASK_JSON_CLIENT_VERSION, mClientVersion);
  366.  
  367.             // post
  368.             JSONObject jsResponse = postRequest(jsPost);
  369.             JSONObject jsResult = (JSONObject) jsResponse.getJSONArray(
  370.                     GTaskStringUtils.GTASK_JSON_RESULTS).get(0);
  371.             task.setGid(jsResult.getString(GTaskStringUtils.GTASK_JSON_NEW_ID));
  372.  
  373.         } catch (JSONException e) {
  374.             Log.e(TAG, e.toString());
  375.             e.printStackTrace();
  376.             throw new ActionFailureException("create task: handing jsonobject failed");
  377.         }
  378.     }
  379.     
  380.     /*
  381.      * 创建一个任务列表，与createTask几乎一样，区别就是最后设置的是tasklist的gid
  382.      */
  383.     public void createTaskList(TaskList tasklist) throws NetworkFailureException {
  384.         commitUpdate();
  385.         try {
  386.             JSONObject jsPost = new JSONObject();
  387.             JSONArray actionList = new JSONArray();
  388.  
  389.             // action_list
  390.             actionList.put(tasklist.getCreateAction(getActionId()));
  391.             jsPost.put(GTaskStringUtils.GTASK_JSON_ACTION_LIST, actionList);
  392.  
  393.             // client version
  394.             jsPost.put(GTaskStringUtils.GTASK_JSON_CLIENT_VERSION, mClientVersion);
  395.  
  396.             // post
  397.             JSONObject jsResponse = postRequest(jsPost);
  398.             JSONObject jsResult = (JSONObject) jsResponse.getJSONArray(
  399.                     GTaskStringUtils.GTASK_JSON_RESULTS).get(0);
  400.             tasklist.setGid(jsResult.getString(GTaskStringUtils.GTASK_JSON_NEW_ID));
  401.  
  402.         } catch (JSONException e) {
  403.             Log.e(TAG, e.toString());
  404.             e.printStackTrace();
  405.             throw new ActionFailureException("create tasklist: handing jsonobject failed");
  406.         }
  407.     }
  408.     
  409.     /*
  410.      * 同步更新操作
  411.      * 使用JSONObject进行数据存储，使用jsPost.put，Put的信息包括UpdateArray和ClientVersion
  412.      * 使用postRequest发送这个jspost,进行处理
  413.      */
  414.     public void commitUpdate() throws NetworkFailureException {
  415.         if (mUpdateArray != null) {
  416.             try {
  417.                 JSONObject jsPost = new JSONObject();
  418.  
  419.                 // action_list
  420.                 jsPost.put(GTaskStringUtils.GTASK_JSON_ACTION_LIST, mUpdateArray);
  421.  
  422.                 // client_version
  423.                 jsPost.put(GTaskStringUtils.GTASK_JSON_CLIENT_VERSION, mClientVersion);
  424.  
  425.                 postRequest(jsPost);
  426.                 mUpdateArray = null;
  427.             } catch (JSONException e) {
  428.                 Log.e(TAG, e.toString());
  429.                 e.printStackTrace();
  430.                 throw new ActionFailureException("commit update: handing jsonobject failed");
  431.             }
  432.         }
  433.     }
  434.     
  435.     /*
  436.      * 添加更新的事项
  437.      * 调用commitUpdate()实现
  438.      */
  439.     public void addUpdateNode(Node node) throws NetworkFailureException {
  440.         if (node != null) {
  441.             // too many update items may result in an error
  442.             // set max to 10 items
  443.             if (mUpdateArray != null && mUpdateArray.length() > 10) {
  444.                 commitUpdate();
  445.             }
  446.  
  447.             if (mUpdateArray == null)
  448.                 mUpdateArray = new JSONArray();
  449.             mUpdateArray.put(node.getUpdateAction(getActionId()));
  450.         }
  451.     }
  452.     
  453.     /*
  454.      * 移动task,比如讲task移动到不同的task列表中去
  455.      * 通过getGid获取task所属列表的gid
  456.      * 通过JSONObject.put(String name, Object value)函数设置移动后的task的相关属性值，从而达到移动的目的
  457.      * 最后还是通过postRequest进行更新后的发送
  458.      */
  459.     public void moveTask(Task task, TaskList preParent, TaskList curParent)
  460.             throws NetworkFailureException {
  461.         commitUpdate();
  462.         try {
  463.             JSONObject jsPost = new JSONObject();
  464.             JSONArray actionList = new JSONArray();
  465.             JSONObject action = new JSONObject();
  466.  
  467.             // action_list
  468.             action.put(GTaskStringUtils.GTASK_JSON_ACTION_TYPE,
  469.                     GTaskStringUtils.GTASK_JSON_ACTION_TYPE_MOVE);
  470.             action.put(GTaskStringUtils.GTASK_JSON_ACTION_ID, getActionId());
  471.             action.put(GTaskStringUtils.GTASK_JSON_ID, task.getGid());
  472.             if (preParent == curParent && task.getPriorSibling() != null) {
  473.                 // put prioring_sibing_id only if moving within the tasklist and
  474.                 // it is not the first one
  475.             	//设置优先级ID，只有当移动是发生在文件中
  476.                 action.put(GTaskStringUtils.GTASK_JSON_PRIOR_SIBLING_ID, task.getPriorSibling());
  477.             }
  478.             action.put(GTaskStringUtils.GTASK_JSON_SOURCE_LIST, preParent.getGid());  //设置移动前所属列表
  479.             action.put(GTaskStringUtils.GTASK_JSON_DEST_PARENT, curParent.getGid());  //设置当前所属列表
  480.             if (preParent != curParent) {
  481.                 // put the dest_list only if moving between tasklists
  482.                 action.put(GTaskStringUtils.GTASK_JSON_DEST_LIST, curParent.getGid());
  483.             }
  484.             actionList.put(action);
  485.             //最后将ACTION_LIST加入到jsPost中
  486.             jsPost.put(GTaskStringUtils.GTASK_JSON_ACTION_LIST, actionList);
  487.  
  488.             // client_version
  489.             jsPost.put(GTaskStringUtils.GTASK_JSON_CLIENT_VERSION, mClientVersion);
  490.  
  491.             postRequest(jsPost);
  492.  
  493.         } catch (JSONException e) {
  494.             Log.e(TAG, e.toString());
  495.             e.printStackTrace();
  496.             throw new ActionFailureException("move task: handing jsonobject failed");
  497.         }
  498.     }
  499.     
  500.     /*
  501.      * 删除操作节点
  502.      * 还是利用JSON
  503.      * 删除过后使用postRequest发送删除后的结果
  504.      */
  505.     public void deleteNode(Node node) throws NetworkFailureException {
  506.         commitUpdate();
  507.         try {
  508.             JSONObject jsPost = new JSONObject();
  509.             JSONArray actionList = new JSONArray();
  510.  
  511.             // action_list
  512.             node.setDeleted(true);
  513.             actionList.put(node.getUpdateAction(getActionId()));  //这里会获取到删除操作的ID，加入到actionLiast中
  514.             jsPost.put(GTaskStringUtils.GTASK_JSON_ACTION_LIST, actionList);
  515.  
  516.             // client_version
  517.             jsPost.put(GTaskStringUtils.GTASK_JSON_CLIENT_VERSION, mClientVersion);
  518.  
  519.             postRequest(jsPost);
  520.             mUpdateArray = null;
  521.         } catch (JSONException e) {
  522.             Log.e(TAG, e.toString());
  523.             e.printStackTrace();
  524.             throw new ActionFailureException("delete node: handing jsonobject failed");
  525.         }
  526.     }
  527.     
  528.     /*
  529.      * 获取任务列表
  530.      * 首先通过GetURI使用getResponseContent从网上获取数据
  531.      * 然后筛选出"_setup("到)}</script>的部分，并且从中获取GTASK_JSON_LISTS的内容返回
  532.      */
  533.     public JSONArray getTaskLists() throws NetworkFailureException {
  534.         if (!mLoggedin) {
  535.             Log.e(TAG, "please login first");
  536.             throw new ActionFailureException("not logged in");
  537.         }
  538.  
  539.         try {
  540.             HttpGet httpGet = new HttpGet(mGetUrl);
  541.             HttpResponse response = null;
  542.             response = mHttpClient.execute(httpGet);
  543.  
  544.             // get the task list
  545.             //筛选工作，把筛选出的字符串放入jsString
  546.             String resString = getResponseContent(response.getEntity());
  547.             String jsBegin = "_setup(";
  548.             String jsEnd = ")}</script>";
  549.             int begin = resString.indexOf(jsBegin);
  550.             int end = resString.lastIndexOf(jsEnd);
  551.             String jsString = null;
  552.             if (begin != -1 && end != -1 && begin < end) {
  553.                 jsString = resString.substring(begin + jsBegin.length(), end);
  554.             }
  555.             JSONObject js = new JSONObject(jsString);
  556.             //获取GTASK_JSON_LISTS
  557.             return js.getJSONObject("t").getJSONArray(GTaskStringUtils.GTASK_JSON_LISTS);
  558.         } catch (ClientProtocolException e) {
  559.             Log.e(TAG, e.toString());
  560.             e.printStackTrace();
  561.             throw new NetworkFailureException("gettasklists: httpget failed");
  562.         } catch (IOException e) {
  563.             Log.e(TAG, e.toString());
  564.             e.printStackTrace();
  565.             throw new NetworkFailureException("gettasklists: httpget failed");
  566.         } catch (JSONException e) {
  567.             Log.e(TAG, e.toString());
  568.             e.printStackTrace();
  569.             throw new ActionFailureException("get task lists: handing jasonobject failed");
  570.         }
  571.     }
  572.     
  573.     /*
  574.      * 通过传入的TASKList的gid,从网络上获取相应属于这个任务列表的任务
  575.      */
  576.     public JSONArray getTaskList(String listGid) throws NetworkFailureException {
  577.         commitUpdate();
  578.         try {
  579.             JSONObject jsPost = new JSONObject();
  580.             JSONArray actionList = new JSONArray();
  581.             JSONObject action = new JSONObject();
  582.  
  583.             // action_list
  584.             action.put(GTaskStringUtils.GTASK_JSON_ACTION_TYPE,
  585.                     GTaskStringUtils.GTASK_JSON_ACTION_TYPE_GETALL);
  586.             action.put(GTaskStringUtils.GTASK_JSON_ACTION_ID, getActionId());  
  587.             action.put(GTaskStringUtils.GTASK_JSON_LIST_ID, listGid);    //这里设置为传入的listGid
  588.             action.put(GTaskStringUtils.GTASK_JSON_GET_DELETED, false);
  589.             actionList.put(action);
  590.             jsPost.put(GTaskStringUtils.GTASK_JSON_ACTION_LIST, actionList);
  591.  
  592.             // client_version
  593.             jsPost.put(GTaskStringUtils.GTASK_JSON_CLIENT_VERSION, mClientVersion);
  594.  
  595.             JSONObject jsResponse = postRequest(jsPost);
  596.             return jsResponse.getJSONArray(GTaskStringUtils.GTASK_JSON_TASKS);
  597.         } catch (JSONException e) {
  598.             Log.e(TAG, e.toString());
  599.             e.printStackTrace();
  600.             throw new ActionFailureException("get task list: handing jsonobject failed");
  601.         }
  602.     }
  603.  
  604.     public Account getSyncAccount() {
  605.         return mAccount;
  606.     }
  607.     
  608.     //重置更新的内容
  609.     public void resetUpdateArray() {
  610.         mUpdateArray = null;
  611.     }
  612. }

3、GTaskManager.java

  1. package net.micode.notes.gtask.remote;
  2.  
  3. public class GTaskManager {
  4.     private static final String TAG = GTaskManager.class.getSimpleName();
  5.     public static final int STATE_SUCCESS = 0;
  6.     public static final int STATE_NETWORK_ERROR = 1;
  7.     public static final int STATE_INTERNAL_ERROR = 2;
  8.     public static final int STATE_SYNC_IN_PROGRESS = 3;
  9.     public static final int STATE_SYNC_CANCELLED = 4; 
  10.     private static GTaskManager mInstance = null;
  11.  
  12.     private Activity mActivity;
  13.     private Context mContext;
  14.     private ContentResolver mContentResolver;
  15.     private boolean mSyncing;
  16.     private boolean mCancelled;
  17.     private HashMap<String, TaskList> mGTaskListHashMap;
  18.     private HashMap<String, Node> mGTaskHashMap;
  19.     private HashMap<String, MetaData> mMetaHashMap;
  20.     private TaskList mMetaList;
  21.     private HashSet<Long> mLocalDeleteIdMap;   
  22.     private HashMap<String, Long> mGidToNid;
  23.     private HashMap<Long, String> mNidToGid;
  24.  
  25.     private GTaskManager() {                                   //对象初始化函数
  26.         mSyncing = false;                                      //正在同步,flase代表未执行
  27.         mCancelled = false;                                    //全局标识，flase代表可以执行
  28.         mGTaskListHashMap = new HashMap<String, TaskList>();   //<>代表Java的泛型,就是创建一个用类型作为参数的类。
  29.         mGTaskHashMap = new HashMap<String, Node>();
  30.         mMetaHashMap = new HashMap<String, MetaData>();
  31.         mMetaList = null;
  32.         mLocalDeleteIdMap = new HashSet<Long>();
  33.         mGidToNid = new HashMap<String, Long>();    //GoogleID to NodeID??
  34.         mNidToGid = new HashMap<Long, String>();    //NodeID to GoogleID???通过hashmap散列表建立映射
  35.     }
  36.  
  37.     /**
  38.      * 包含关键字synchronized，语言级同步，指明该函数可能运行在多线程的环境下。
  39.      * 功能：类初始化函数
  40.      * @author TTS
  41.      * @return GtaskManger
  42.      */
  43.     public static synchronized GTaskManager getInstance() {    //可能运行在多线程环境下，使用语言级同步--synchronized
  44.         if (mInstance == null) {
  45.             mInstance = new GTaskManager();
  46.         }
  47.         return mInstance;
  48.     }
  49.  
  50.     /**
  51.      * 包含关键字synchronized，语言级同步，指明该函数可能运行在多线程的环境下。
  52.      * @author TTS
  53.      * @param activity
  54.      */
  55.     public synchronized void setActivityContext(Activity activity) {
  56.         // used for getting auth token
  57.         mActivity = activity;
  58.     }
  59.  
  60.     /**
  61.      * 核心函数
  62.      * 功能：实现了本地同步操作和远端同步操作
  63.      * @author TTS
  64.      * @param context-----获取上下文
  65.      * @param asyncTask-------用于同步的异步操作类
  66.      * @return int
  67.      */
  68.     public int sync(Context context, GTaskASyncTask asyncTask) {           //核心函数
  69.         if (mSyncing) {
  70.             Log.d(TAG, "Sync is in progress");                       //创建日志文件（调试信息），debug
  71.             return STATE_SYNC_IN_PROGRESS;
  72.         }
  73.         mContext = context;
  74.         mContentResolver = mContext.getContentResolver();
  75.         mSyncing = true;
  76.         mCancelled = false;
  77.         mGTaskListHashMap.clear();
  78.         mGTaskHashMap.clear();
  79.         mMetaHashMap.clear();
  80.         mLocalDeleteIdMap.clear();
  81.         mGidToNid.clear();
  82.         mNidToGid.clear();
  83.  
  84.         try {
  85.             GTaskClient client = GTaskClient.getInstance();    //getInstance即为创建一个实例,client--客户机
  86.             client.resetUpdateArray();     //JSONArray类型，reset即置为NULL
  87.  
  88.             // login google task
  89.             if (!mCancelled) {
  90.                 if (!client.login(mActivity)) {
  91.                     throw new NetworkFailureException("login google task failed");
  92.                 }
  93.             }
  94.  
  95.             // get the task list from google
  96.             asyncTask.publishProgess(mContext.getString(R.string.sync_progress_init_list));
  97.             initGTaskList();                                 //获取Google上的JSONtasklist转为本地TaskList
  98.  
  99.             // do content sync work
  100.             asyncTask.publishProgess(mContext.getString(R.string.sync_progress_syncing));
  101.             syncContent();
  102.         } catch (NetworkFailureException e) {                       //分为两种异常，此类异常为网络异常
  103.             Log.e(TAG, e.toString());                             //创建日志文件（调试信息），error
  104.             return STATE_NETWORK_ERROR;
  105.         } catch (ActionFailureException e) {                        //此类异常为操作异常
  106.             Log.e(TAG, e.toString());
  107.             return STATE_INTERNAL_ERROR;
  108.         } catch (Exception e) {
  109.             Log.e(TAG, e.toString());
  110.             e.printStackTrace();
  111.             return STATE_INTERNAL_ERROR;
  112.         } finally {
  113.             mGTaskListHashMap.clear();
  114.             mGTaskHashMap.clear();
  115.             mMetaHashMap.clear();
  116.             mLocalDeleteIdMap.clear();
  117.             mGidToNid.clear();
  118.             mNidToGid.clear();
  119.             mSyncing = false;
  120.         }
  121.  
  122.         return mCancelled ? STATE_SYNC_CANCELLED : STATE_SUCCESS;
  123.     }
  124.  
  125.     /**
  126.      *功能：初始化GtaskList，获取Google上的JSONtasklist转为本地TaskList。
  127.      *获得的数据存储在mMetaList，mGTaskListHashMap，mGTaskHashMap
  128.      *@author TTS
  129.      *@exception NetworkFailureException
  130.      *@return void
  131.      */
  132.     private void initGTaskList() throws NetworkFailureException {
  133.         if (mCancelled)
  134.             return;
  135.         GTaskClient client = GTaskClient.getInstance();    //getInstance即为创建一个实例，client应指远端客户机
  136.         try {
  137.         	//Json对象是Name Value对(即子元素)的无序集合，相当于一个Map对象。JsonObject类是bantouyan-json库对Json对象的抽象，提供操纵Json对象的各种方法。
  138.         	//其格式为{"key1":value1,"key2",value2....};key 必须是字符串。
  139.         	//因为ajax请求不刷新页面，但配合js可以实现局部刷新，因此json常常被用来作为异步请求的返回对象使用。
  140.             JSONArray jsTaskLists = client.getTaskLists();     //原注释为get task list------lists？？？
  141.  
  142.             // init meta list first
  143.             mMetaList = null;                                       //TaskList类型
  144.             for (int i = 0; i < jsTaskLists.length(); i++) {
  145.                 JSONObject object = jsTaskLists.getJSONObject(i);  //JSONObject与JSONArray一个为对象，一个为数组。此处取出单个JASONObject
  146.                 String gid = object.getString(GTaskStringUtils.GTASK_JSON_ID);
  147.                 String name = object.getString(GTaskStringUtils.GTASK_JSON_NAME);
  148.  
  149.                 if (name.equals(GTaskStringUtils.MIUI_FOLDER_PREFFIX + GTaskStringUtils.FOLDER_META)) {
  150.                     mMetaList = new TaskList();                    //MetaList意为元表,Tasklist类型，此处为初始化
  151.                     mMetaList.setContentByRemoteJSON(object);      //将JSON中部分数据复制到自己定义的对象中相对应的数据：name->mname...
  152.  
  153.                     // load meta data
  154.                     JSONArray jsMetas = client.getTaskList(gid);   //原注释为get action_list------list？？？
  155.                     for (int j = 0; j < jsMetas.length(); j++) {
  156.                         object = (JSONObject) jsMetas.getJSONObject(j);
  157.                         MetaData metaData = new MetaData();            //继承自Node
  158.                         metaData.setContentByRemoteJSON(object);
  159.                         if (metaData.isWorthSaving()) {                             //if not worth to save，metadata将不加入mMetaList
  160.                             mMetaList.addChildTask(metaData);
  161.                             if (metaData.getGid() != null) {
  162.                                 mMetaHashMap.put(metaData.getRelatedGid(), metaData);
  163.                             }
  164.                         }
  165.                     }
  166.                 }
  167.             }
  168.  
  169.             // create meta list if not existed
  170.             if (mMetaList == null) {
  171.                 mMetaList = new TaskList();
  172.                 mMetaList.setName(GTaskStringUtils.MIUI_FOLDER_PREFFIX
  173.                         + GTaskStringUtils.FOLDER_META);
  174.                 GTaskClient.getInstance().createTaskList(mMetaList);
  175.             }
  176.  
  177.             // init task list
  178.             for (int i = 0; i < jsTaskLists.length(); i++) {
  179.                 JSONObject object = jsTaskLists.getJSONObject(i);
  180.                 String gid = object.getString(GTaskStringUtils.GTASK_JSON_ID);  //通过getString函数传入本地某个标志数据的名称，获取其在远端的名称。
  181.                 String name = object.getString(GTaskStringUtils.GTASK_JSON_NAME);
  182.  
  183.                 if (name.startsWith(GTaskStringUtils.MIUI_FOLDER_PREFFIX)
  184.                         && !name.equals(GTaskStringUtils.MIUI_FOLDER_PREFFIX
  185.                                 + GTaskStringUtils.FOLDER_META)) {
  186.                     TaskList tasklist = new TaskList();     //继承自Node
  187.                     tasklist.setContentByRemoteJSON(object);
  188.                     mGTaskListHashMap.put(gid, tasklist);       
  189.                     mGTaskHashMap.put(gid, tasklist);          //为什么加两遍？？？
  190.  
  191.                     // load tasks
  192.                     JSONArray jsTasks = client.getTaskList(gid);
  193.                     for (int j = 0; j < jsTasks.length(); j++) {
  194.                         object = (JSONObject) jsTasks.getJSONObject(j);
  195.                         gid = object.getString(GTaskStringUtils.GTASK_JSON_ID);
  196.                         Task task = new Task();
  197.                         task.setContentByRemoteJSON(object);
  198.                         if (task.isWorthSaving()) {
  199.                             task.setMetaInfo(mMetaHashMap.get(gid));
  200.                             tasklist.addChildTask(task);
  201.                             mGTaskHashMap.put(gid, task);
  202.                         }
  203.                     }
  204.                 }
  205.             }
  206.         } catch (JSONException e) {
  207.             Log.e(TAG, e.toString());
  208.             e.printStackTrace();
  209.             throw new ActionFailureException("initGTaskList: handing JSONObject failed");
  210.         }
  211.     }
  212.  
  213.     /**
  214.      * 功能：本地内容同步操作
  215.      * @throws NetworkFailureException
  216.      * @return 无返回值
  217.      */
  218.     private void syncContent() throws NetworkFailureException {    //本地内容同步操作
  219.         int syncType;
  220.         Cursor c = null;                                           //数据库指针
  221.         String gid;                                                //GoogleID??
  222.         Node node;                                                 //Node包含Sync_Action的不同类型
  223.  
  224.         mLocalDeleteIdMap.clear();                                 //HashSet<Long>类型
  225.  
  226.         if (mCancelled) {
  227.             return;
  228.         }
  229.  
  230.         // for local deleted note
  231.         try {
  232.             c = mContentResolver.query(Notes.CONTENT_NOTE_URI, SqlNote.PROJECTION_NOTE,
  233.                     "(type<>? AND parent_id=?)", new String[] {
  234.                             String.valueOf(Notes.TYPE_SYSTEM), String.valueOf(Notes.ID_TRASH_FOLER)
  235.                     }, null);
  236.             if (c != null) {
  237.                 while (c.moveToNext()) {
  238.                     gid = c.getString(SqlNote.GTASK_ID_COLUMN);
  239.                     node = mGTaskHashMap.get(gid);
  240.                     if (node != null) {
  241.                         mGTaskHashMap.remove(gid);
  242.                         doContentSync(Node.SYNC_ACTION_DEL_REMOTE, node, c);
  243.                     }
  244.  
  245.                     mLocalDeleteIdMap.add(c.getLong(SqlNote.ID_COLUMN));
  246.                 }
  247.             } else {
  248.                 Log.w(TAG, "failed to query trash folder");
  249.             }
  250.         } finally {
  251.             if (c != null) {
  252.                 c.close();
  253.                 c = null;
  254.             }
  255.         }
  256.  
  257.         // sync folder first
  258.         syncFolder();
  259.  
  260.         // for note existing in database
  261.         try {
  262.             c = mContentResolver.query(Notes.CONTENT_NOTE_URI, SqlNote.PROJECTION_NOTE,
  263.                     "(type=? AND parent_id<>?)", new String[] {
  264.                             String.valueOf(Notes.TYPE_NOTE), String.valueOf(Notes.ID_TRASH_FOLER)
  265.                     }, NoteColumns.TYPE + " DESC");
  266.             if (c != null) {
  267.                 while (c.moveToNext()) {
  268.                     gid = c.getString(SqlNote.GTASK_ID_COLUMN);
  269.                     node = mGTaskHashMap.get(gid);
  270.                     if (node != null) {
  271.                         mGTaskHashMap.remove(gid);
  272.                         mGidToNid.put(gid, c.getLong(SqlNote.ID_COLUMN));   //通过hashmap建立联系
  273.                         mNidToGid.put(c.getLong(SqlNote.ID_COLUMN), gid);   //通过hashmap建立联系
  274.                         syncType = node.getSyncAction(c);
  275.                     } else {
  276.                         if (c.getString(SqlNote.GTASK_ID_COLUMN).trim().length() == 0) {
  277.                             // local add
  278.                             syncType = Node.SYNC_ACTION_ADD_REMOTE;
  279.                         } else {
  280.                             // remote delete
  281.                             syncType = Node.SYNC_ACTION_DEL_LOCAL;
  282.                         }
  283.                     }
  284.                     doContentSync(syncType, node, c);
  285.                 }
  286.             } else {
  287.                 Log.w(TAG, "failed to query existing note in database");
  288.             }
  289.  
  290.         } finally {
  291.             if (c != null) {
  292.                 c.close();
  293.                 c = null;
  294.             }
  295.         }
  296.  
  297.         // go through remaining items
  298.         Iterator<Map.Entry<String, Node>> iter = mGTaskHashMap.entrySet().iterator();   //Iterator迭代器
  299.         while (iter.hasNext()) {
  300.             Map.Entry<String, Node> entry = iter.next();
  301.             node = entry.getValue();
  302.             doContentSync(Node.SYNC_ACTION_ADD_LOCAL, node, null);
  303.         }
  304.  
  305.         // mCancelled can be set by another thread, so we neet to check one by    //thread----线程
  306.         // one
  307.         // clear local delete table
  308.         if (!mCancelled) {
  309.             if (!DataUtils.batchDeleteNotes(mContentResolver, mLocalDeleteIdMap)) {
  310.                 throw new ActionFailureException("failed to batch-delete local deleted notes");
  311.             }
  312.         }
  313.  
  314.         // refresh local sync id
  315.         if (!mCancelled) {
  316.             GTaskClient.getInstance().commitUpdate();
  317.             refreshLocalSyncId();
  318.         }
  319.  
  320.     }
  321.  
  322.     /**
  323.      * 功能：
  324.      * @author TTS
  325.      * @throws NetworkFailureException
  326.      */
  327.     private void syncFolder() throws NetworkFailureException {
  328.         Cursor c = null;
  329.         String gid;
  330.         Node node;
  331.         int syncType;
  332.  
  333.         if (mCancelled) {
  334.             return;
  335.         }
  336.  
  337.         // for root folder
  338.         try {
  339.             c = mContentResolver.query(ContentUris.withAppendedId(Notes.CONTENT_NOTE_URI,
  340.                     Notes.ID_ROOT_FOLDER), SqlNote.PROJECTION_NOTE, null, null, null);
  341.             if (c != null) {
  342.                 c.moveToNext();
  343.                 gid = c.getString(SqlNote.GTASK_ID_COLUMN);
  344.                 node = mGTaskHashMap.get(gid);
  345.                 if (node != null) {
  346.                     mGTaskHashMap.remove(gid);
  347.                     mGidToNid.put(gid, (long) Notes.ID_ROOT_FOLDER);
  348.                     mNidToGid.put((long) Notes.ID_ROOT_FOLDER, gid);
  349.                     // for system folder, only update remote name if necessary
  350.                     if (!node.getName().equals(
  351.                             GTaskStringUtils.MIUI_FOLDER_PREFFIX + GTaskStringUtils.FOLDER_DEFAULT))
  352.                         doContentSync(Node.SYNC_ACTION_UPDATE_REMOTE, node, c);
  353.                 } else {
  354.                     doContentSync(Node.SYNC_ACTION_ADD_REMOTE, node, c);
  355.                 }
  356.             } else {
  357.                 Log.w(TAG, "failed to query root folder");
  358.             }
  359.         } finally {
  360.             if (c != null) {
  361.                 c.close();
  362.                 c = null;
  363.             }
  364.         }
  365.  
  366.         // for call-note folder
  367.         try {
  368.             c = mContentResolver.query(Notes.CONTENT_NOTE_URI, SqlNote.PROJECTION_NOTE, "(_id=?)",
  369.                     new String[] {
  370.                         String.valueOf(Notes.ID_CALL_RECORD_FOLDER)
  371.                     }, null);
  372.             if (c != null) {
  373.                 if (c.moveToNext()) {
  374.                     gid = c.getString(SqlNote.GTASK_ID_COLUMN);
  375.                     node = mGTaskHashMap.get(gid);
  376.                     if (node != null) {
  377.                         mGTaskHashMap.remove(gid);
  378.                         mGidToNid.put(gid, (long) Notes.ID_CALL_RECORD_FOLDER);
  379.                         mNidToGid.put((long) Notes.ID_CALL_RECORD_FOLDER, gid);
  380.                         // for system folder, only update remote name if
  381.                         // necessary
  382.                         if (!node.getName().equals(
  383.                                 GTaskStringUtils.MIUI_FOLDER_PREFFIX
  384.                                         + GTaskStringUtils.FOLDER_CALL_NOTE))
  385.                             doContentSync(Node.SYNC_ACTION_UPDATE_REMOTE, node, c);
  386.                     } else {
  387.                         doContentSync(Node.SYNC_ACTION_ADD_REMOTE, node, c);
  388.                     }
  389.                 }
  390.             } else {
  391.                 Log.w(TAG, "failed to query call note folder");
  392.             }
  393.         } finally {
  394.             if (c != null) {
  395.                 c.close();
  396.                 c = null;
  397.             }
  398.         }
  399.  
  400.         // for local existing folders
  401.         try {
  402.             c = mContentResolver.query(Notes.CONTENT_NOTE_URI, SqlNote.PROJECTION_NOTE,
  403.                     "(type=? AND parent_id<>?)", new String[] {
  404.                             String.valueOf(Notes.TYPE_FOLDER), String.valueOf(Notes.ID_TRASH_FOLER)
  405.                     }, NoteColumns.TYPE + " DESC");
  406.             if (c != null) {
  407.                 while (c.moveToNext()) {
  408.                     gid = c.getString(SqlNote.GTASK_ID_COLUMN);
  409.                     node = mGTaskHashMap.get(gid);
  410.                     if (node != null) {
  411.                         mGTaskHashMap.remove(gid);
  412.                         mGidToNid.put(gid, c.getLong(SqlNote.ID_COLUMN));
  413.                         mNidToGid.put(c.getLong(SqlNote.ID_COLUMN), gid);
  414.                         syncType = node.getSyncAction(c);
  415.                     } else {
  416.                         if (c.getString(SqlNote.GTASK_ID_COLUMN).trim().length() == 0) {
  417.                             // local add
  418.                             syncType = Node.SYNC_ACTION_ADD_REMOTE;
  419.                         } else {
  420.                             // remote delete
  421.                             syncType = Node.SYNC_ACTION_DEL_LOCAL;
  422.                         }
  423.                     }
  424.                     doContentSync(syncType, node, c);
  425.                 }
  426.             } else {
  427.                 Log.w(TAG, "failed to query existing folder");
  428.             }
  429.         } finally {
  430.             if (c != null) {
  431.                 c.close();
  432.                 c = null;
  433.             }
  434.         }
  435.  
  436.         // for remote add folders
  437.         Iterator<Map.Entry<String, TaskList>> iter = mGTaskListHashMap.entrySet().iterator();
  438.         while (iter.hasNext()) {
  439.             Map.Entry<String, TaskList> entry = iter.next();
  440.             gid = entry.getKey();
  441.             node = entry.getValue();
  442.             if (mGTaskHashMap.containsKey(gid)) {
  443.                 mGTaskHashMap.remove(gid);
  444.                 doContentSync(Node.SYNC_ACTION_ADD_LOCAL, node, null);
  445.             }
  446.         }
  447.  
  448.         if (!mCancelled)
  449.             GTaskClient.getInstance().commitUpdate();
  450.     }
  451.  
  452.     /**
  453.      * 功能：syncType分类，addLocalNode，addRemoteNode，deleteNode，updateLocalNode，updateRemoteNode
  454.      * @author TTS
  455.      * @param syncType
  456.      * @param node
  457.      * @param c
  458.      * @throws NetworkFailureException
  459.      */
  460.     private void doContentSync(int syncType, Node node, Cursor c) throws NetworkFailureException {
  461.         if (mCancelled) {
  462.             return;
  463.         }
  464.  
  465.         MetaData meta;
  466.         switch (syncType) {
  467.             case Node.SYNC_ACTION_ADD_LOCAL:
  468.                 addLocalNode(node);
  469.                 break;
  470.             case Node.SYNC_ACTION_ADD_REMOTE:
  471.                 addRemoteNode(node, c);
  472.                 break;
  473.             case Node.SYNC_ACTION_DEL_LOCAL:
  474.                 meta = mMetaHashMap.get(c.getString(SqlNote.GTASK_ID_COLUMN));
  475.                 if (meta != null) {
  476.                     GTaskClient.getInstance().deleteNode(meta);
  477.                 }
  478.                 mLocalDeleteIdMap.add(c.getLong(SqlNote.ID_COLUMN));
  479.                 break;
  480.             case Node.SYNC_ACTION_DEL_REMOTE:
  481.                 meta = mMetaHashMap.get(node.getGid());
  482.                 if (meta != null) {
  483.                     GTaskClient.getInstance().deleteNode(meta);
  484.                 }
  485.                 GTaskClient.getInstance().deleteNode(node);
  486.                 break;
  487.             case Node.SYNC_ACTION_UPDATE_LOCAL:
  488.                 updateLocalNode(node, c);
  489.                 break;
  490.             case Node.SYNC_ACTION_UPDATE_REMOTE:
  491.                 updateRemoteNode(node, c);
  492.                 break;
  493.             case Node.SYNC_ACTION_UPDATE_CONFLICT:
  494.                 // merging both modifications maybe a good idea
  495.                 // right now just use local update simply
  496.                 updateRemoteNode(node, c);
  497.                 break;
  498.             case Node.SYNC_ACTION_NONE:
  499.                 break;
  500.             case Node.SYNC_ACTION_ERROR:
  501.             default:
  502.                 throw new ActionFailureException("unkown sync action type");
  503.         }
  504.     }
  505.  
  506.     /**
  507.      * 功能：本地增加Node
  508.      * @author TTS
  509.      * @param node
  510.      * @throws NetworkFailureException
  511.      */
  512.     private void addLocalNode(Node node) throws NetworkFailureException {
  513.         if (mCancelled) {
  514.             return;
  515.         }
  516.  
  517.         SqlNote sqlNote;
  518.         if (node instanceof TaskList) {
  519.             if (node.getName().equals(
  520.                     GTaskStringUtils.MIUI_FOLDER_PREFFIX + GTaskStringUtils.FOLDER_DEFAULT)) {
  521.                 sqlNote = new SqlNote(mContext, Notes.ID_ROOT_FOLDER);
  522.             } else if (node.getName().equals(
  523.                     GTaskStringUtils.MIUI_FOLDER_PREFFIX + GTaskStringUtils.FOLDER_CALL_NOTE)) {
  524.                 sqlNote = new SqlNote(mContext, Notes.ID_CALL_RECORD_FOLDER);
  525.             } else {
  526.                 sqlNote = new SqlNote(mContext);
  527.                 sqlNote.setContent(node.getLocalJSONFromContent());
  528.                 sqlNote.setParentId(Notes.ID_ROOT_FOLDER);
  529.             }
  530.         } else {
  531.             sqlNote = new SqlNote(mContext);
  532.             JSONObject js = node.getLocalJSONFromContent();
  533.             try {
  534.                 if (js.has(GTaskStringUtils.META_HEAD_NOTE)) {
  535.                     JSONObject note = js.getJSONObject(GTaskStringUtils.META_HEAD_NOTE);
  536.                     if (note.has(NoteColumns.ID)) {
  537.                         long id = note.getLong(NoteColumns.ID);
  538.                         if (DataUtils.existInNoteDatabase(mContentResolver, id)) {
  539.                             // the id is not available, have to create a new one
  540.                             note.remove(NoteColumns.ID);
  541.                         }
  542.                     }
  543.                 }
  544.  
  545.                 if (js.has(GTaskStringUtils.META_HEAD_DATA)) {
  546.                     JSONArray dataArray = js.getJSONArray(GTaskStringUtils.META_HEAD_DATA);
  547.                     for (int i = 0; i < dataArray.length(); i++) {
  548.                         JSONObject data = dataArray.getJSONObject(i);
  549.                         if (data.has(DataColumns.ID)) {
  550.                             long dataId = data.getLong(DataColumns.ID);
  551.                             if (DataUtils.existInDataDatabase(mContentResolver, dataId)) {
  552.                                 // the data id is not available, have to create
  553.                                 // a new one
  554.                                 data.remove(DataColumns.ID);
  555.                             }
  556.                         }
  557.                     }
  558.  
  559.                 }
  560.             } catch (JSONException e) {
  561.                 Log.w(TAG, e.toString());
  562.                 e.printStackTrace();
  563.             }
  564.             sqlNote.setContent(js);
  565.  
  566.             Long parentId = mGidToNid.get(((Task) node).getParent().getGid());
  567.             if (parentId == null) {
  568.                 Log.e(TAG, "cannot find task's parent id locally");
  569.                 throw new ActionFailureException("cannot add local node");
  570.             }
  571.             sqlNote.setParentId(parentId.longValue());
  572.         }
  573.  
  574.         // create the local node
  575.         sqlNote.setGtaskId(node.getGid());
  576.         sqlNote.commit(false);
  577.  
  578.         // update gid-nid mapping
  579.         mGidToNid.put(node.getGid(), sqlNote.getId());
  580.         mNidToGid.put(sqlNote.getId(), node.getGid());
  581.  
  582.         // update meta
  583.         updateRemoteMeta(node.getGid(), sqlNote);
  584.     }
  585.  
  586.     /**
  587.      * 功能：update本地node
  588.      * @author TTS
  589.      * @param node
  590.      * ----同步操作的基础数据类型
  591.      * @param c
  592.      * ----Cursor
  593.      * @throws NetworkFailureException
  594.      */
  595.     private void updateLocalNode(Node node, Cursor c) throws NetworkFailureException {
  596.         if (mCancelled) {
  597.             return;
  598.         }
  599.  
  600.         SqlNote sqlNote;
  601.         // update the note locally
  602.         sqlNote = new SqlNote(mContext, c);
  603.         sqlNote.setContent(node.getLocalJSONFromContent());
  604.  
  605.         Long parentId = (node instanceof Task) ? mGidToNid.get(((Task) node).getParent().getGid())
  606.                 : new Long(Notes.ID_ROOT_FOLDER);
  607.         if (parentId == null) {
  608.             Log.e(TAG, "cannot find task's parent id locally");
  609.             throw new ActionFailureException("cannot update local node");
  610.         }
  611.         sqlNote.setParentId(parentId.longValue());
  612.         sqlNote.commit(true);
  613.  
  614.         // update meta info
  615.         updateRemoteMeta(node.getGid(), sqlNote);
  616.     }
  617.  
  618.     /**
  619.      * 功能：远程增加Node
  620.      * 需要updateRemoteMeta
  621.      * @author TTS
  622.      * @param node
  623.      * ----同步操作的基础数据类型
  624.      * @param c
  625.      * --Cursor
  626.      * @throws NetworkFailureException
  627.      */
  628.     private void addRemoteNode(Node node, Cursor c) throws NetworkFailureException {
  629.         if (mCancelled) {
  630.             return;
  631.         }
  632.  
  633.         SqlNote sqlNote = new SqlNote(mContext, c);     //从本地mContext中获取内容
  634.         Node n;
  635.  
  636.         // update remotely
  637.         if (sqlNote.isNoteType()) {
  638.             Task task = new Task();
  639.             task.setContentByLocalJSON(sqlNote.getContent());
  640.  
  641.             String parentGid = mNidToGid.get(sqlNote.getParentId());
  642.             if (parentGid == null) {
  643.                 Log.e(TAG, "cannot find task's parent tasklist");           //调试信息
  644.                 throw new ActionFailureException("cannot add remote task");
  645.             }
  646.             mGTaskListHashMap.get(parentGid).addChildTask(task);            //在本地生成的GTaskList中增加子结点
  647.  
  648.             //登录远程服务器，创建Task
  649.             GTaskClient.getInstance().createTask(task); 
  650.             n = (Node) task;
  651.  
  652.             // add meta
  653.             updateRemoteMeta(task.getGid(), sqlNote);
  654.         } else {
  655.             TaskList tasklist = null;
  656.  
  657.             // we need to skip folder if it has already existed
  658.             String folderName = GTaskStringUtils.MIUI_FOLDER_PREFFIX;
  659.             if (sqlNote.getId() == Notes.ID_ROOT_FOLDER)
  660.                 folderName += GTaskStringUtils.FOLDER_DEFAULT;
  661.             else if (sqlNote.getId() == Notes.ID_CALL_RECORD_FOLDER)
  662.                 folderName += GTaskStringUtils.FOLDER_CALL_NOTE;
  663.             else
  664.                 folderName += sqlNote.getSnippet();
  665.  
  666.             //iterator迭代器，通过统一的接口迭代所有的map元素
  667.             Iterator<Map.Entry<String, TaskList>> iter = mGTaskListHashMap.entrySet().iterator(); 
  668.             while (iter.hasNext()) {
  669.                 Map.Entry<String, TaskList> entry = iter.next();
  670.                 String gid = entry.getKey();
  671.                 TaskList list = entry.getValue();
  672.  
  673.                 if (list.getName().equals(folderName)) {
  674.                     tasklist = list;
  675.                     if (mGTaskHashMap.containsKey(gid)) {
  676.                         mGTaskHashMap.remove(gid);
  677.                     }
  678.                     break;
  679.                 }
  680.             }
  681.  
  682.             // no match we can add now
  683.             if (tasklist == null) {
  684.                 tasklist = new TaskList();
  685.                 tasklist.setContentByLocalJSON(sqlNote.getContent());
  686.                 GTaskClient.getInstance().createTaskList(tasklist);
  687.                 mGTaskListHashMap.put(tasklist.getGid(), tasklist);
  688.             }
  689.             n = (Node) tasklist;
  690.         }
  691.  
  692.         // update local note
  693.         sqlNote.setGtaskId(n.getGid());
  694.         sqlNote.commit(false);
  695.         sqlNote.resetLocalModified();
  696.         sqlNote.commit(true);
  697.  
  698.         // gid-id mapping                                             //创建id间的映射
  699.         mGidToNid.put(n.getGid(), sqlNote.getId());
  700.         mNidToGid.put(sqlNote.getId(), n.getGid());
  701.     }
  702.  
  703.     /**
  704.      * 功能：更新远端的Node，包含meta更新(updateRemoteMeta)
  705.      * @author TTS
  706.      * @param node
  707.      * ----同步操作的基础数据类型
  708.      * @param c
  709.      *  --Cursor
  710.      * @throws NetworkFailureException
  711.      */
  712.     private void updateRemoteNode(Node node, Cursor c) throws NetworkFailureException {
  713.         if (mCancelled) {
  714.             return;
  715.         }
  716.  
  717.         SqlNote sqlNote = new SqlNote(mContext, c);
  718.  
  719.         // update remotely
  720.         node.setContentByLocalJSON(sqlNote.getContent());
  721.         GTaskClient.getInstance().addUpdateNode(node);                                //GTaskClient用途为从本地登陆远端服务器 
  722.  
  723.         // update meta
  724.         updateRemoteMeta(node.getGid(), sqlNote);
  725.  
  726.         // move task if necessary
  727.         if (sqlNote.isNoteType()) {
  728.             Task task = (Task) node;
  729.             TaskList preParentList = task.getParent(); 
  730.             //preParentList为通过node获取的父节点列表
  731.             
  732.             String curParentGid = mNidToGid.get(sqlNote.getParentId());
  733.             //curParentGid为通过光标在数据库中找到sqlNote的mParentId，再通过mNidToGid由long类型转为String类型的Gid
  734.             
  735.             if (curParentGid == null) {
  736.                 Log.e(TAG, "cannot find task's parent tasklist");
  737.                 throw new ActionFailureException("cannot update remote task");
  738.             }
  739.             TaskList curParentList = mGTaskListHashMap.get(curParentGid);
  740.             //通过HashMap找到对应Gid的TaskList
  741.  
  742.             if (preParentList != curParentList) {                                          //?????????????
  743.                 preParentList.removeChildTask(task);
  744.                 curParentList.addChildTask(task);
  745.                 GTaskClient.getInstance().moveTask(task, preParentList, curParentList);
  746.             }
  747.         }
  748.  
  749.         // clear local modified flag
  750.         sqlNote.resetLocalModified();
  751.         //commit到本地数据库
  752.         sqlNote.commit(true); 
  753.     }
  754.  
  755.     /**
  756.      * 功能：升级远程meta。  meta---元数据----计算机文件系统管理数据---管理数据的数据。
  757.      * @author TTS
  758.      * @param gid
  759.      * ---GoogleID为String类型
  760.      * @param sqlNote
  761.      * ---同步前的数据库操作，故使用类SqlNote
  762.      * @throws NetworkFailureException
  763.      */
  764.     private void updateRemoteMeta(String gid, SqlNote sqlNote) throws NetworkFailureException {
  765.         if (sqlNote != null && sqlNote.isNoteType()) {
  766.             MetaData metaData = mMetaHashMap.get(gid);
  767.             if (metaData != null) {
  768.                 metaData.setMeta(gid, sqlNote.getContent());
  769.                 GTaskClient.getInstance().addUpdateNode(metaData);
  770.             } else {
  771.                 metaData = new MetaData();
  772.                 metaData.setMeta(gid, sqlNote.getContent());
  773.                 mMetaList.addChildTask(metaData);
  774.                 mMetaHashMap.put(gid, metaData);
  775.                 GTaskClient.getInstance().createTask(metaData);
  776.             }
  777.         }
  778.     }
  779.  
  780.     /**
  781.      * 功能：刷新本地，给sync的ID对应上最后更改过的对象
  782.      * @author TTS
  783.      * @return void
  784.      * @throws NetworkFailureException
  785.      */
  786.     private void refreshLocalSyncId() throws NetworkFailureException {
  787.         if (mCancelled) {
  788.             return;
  789.         }
  790.  
  791.         // get the latest gtask list                                               //获取最近的（最晚的）gtask list
  792.         mGTaskHashMap.clear();
  793.         mGTaskListHashMap.clear();
  794.         mMetaHashMap.clear();
  795.         initGTaskList();
  796.  
  797.         Cursor c = null;
  798.         try {
  799.             c = mContentResolver.query(Notes.CONTENT_NOTE_URI, SqlNote.PROJECTION_NOTE,
  800.                     "(type<>? AND parent_id<>?)", new String[] {
  801.                             String.valueOf(Notes.TYPE_SYSTEM), String.valueOf(Notes.ID_TRASH_FOLER)
  802.                     }, 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
  803.             if (c != null) {
  804.                 while (c.moveToNext()) {
  805.                     String gid = c.getString(SqlNote.GTASK_ID_COLUMN);
  806.                     Node node = mGTaskHashMap.get(gid);
  807.                     if (node != null) {
  808.                         mGTaskHashMap.remove(gid);
  809.                         ContentValues values = new ContentValues();                     //在ContentValues中创建键值对。准备通过contentResolver写入数据
  810.                         values.put(NoteColumns.SYNC_ID, node.getLastModified());
  811.                         mContentResolver.update(ContentUris.withAppendedId(Notes.CONTENT_NOTE_URI,   //进行批量更改，选择参数为NULL，应该可以用insert替换，参数分别为表名和需要更新的value对象。
  812.                                 c.getLong(SqlNote.ID_COLUMN)), values, null, null);
  813.                     } else {
  814.                         Log.e(TAG, "something is missed");
  815.                         throw new ActionFailureException(
  816.                                 "some local items don't have gid after sync");
  817.                     }
  818.                 }
  819.             } else {
  820.                 Log.w(TAG, "failed to query local note to refresh sync id");
  821.             }
  822.         } finally {
  823.             if (c != null) {
  824.                 c.close();
  825.                 c = null;
  826.             }
  827.         }
  828.     }
  829.  
  830.     /**
  831.      * 功能：获取同步账号,mAccount.name
  832.      * @author TTS
  833.      * @return String
  834.      */
  835.     public String getSyncAccount() {
  836.         return GTaskClient.getInstance().getSyncAccount().name;
  837.     }
  838.  
  839.     /**
  840.      * 功能：取消同步，置mCancelled为true
  841.      * @author TTS
  842.      */
  843.     public void cancelSync() {
  844.         mCancelled = true;
  845.     }
  846. }

4、GTaskSyncService.java

  1. package net.micode.notes.gtask.remote;
  2.  
  3. /*
  4.  * Service是在一段不定的时间运行在后台，不和用户交互的应用组件
  5.  * 主要方法：
  6.  * private void startSync()  启动一个同步工作
  7.  * private void cancelSync() 取消同步
  8.  * public void onCreate()
  9.  * public int onStartCommand(Intent intent, int flags, int startId)  service生命周期的组成部分，相当于重启service（比如在被暂停之后），而不是创建一个新的service
  10.  * public void onLowMemory()  在没有内存的情况下如果存在service则结束掉这的service
  11.  * public IBinder onBind()
  12.  * public void sendBroadcast(String msg)   发送同步的相关通知
  13.  * public static void startSync(Activity activity)
  14.  * public static void cancelSync(Context context) 
  15.  * public static boolean isSyncing()  判读是否在进行同步
  16.  * public static String getProgressString()  获取当前进度的信息
  17.  */
  18.  
  19. public class GTaskSyncService extends Service {
  20.     public final static String ACTION_STRING_NAME = "sync_action_type";
  21.  
  22.     public final static int ACTION_START_SYNC = 0;
  23.  
  24.     public final static int ACTION_CANCEL_SYNC = 1;
  25.  
  26.     public final static int ACTION_INVALID = 2;
  27.  
  28.     public final static String GTASK_SERVICE_BROADCAST_NAME = "net.micode.notes.gtask.remote.gtask_sync_service";
  29.  
  30.     public final static String GTASK_SERVICE_BROADCAST_IS_SYNCING = "isSyncing";
  31.  
  32.     public final static String GTASK_SERVICE_BROADCAST_PROGRESS_MSG = "progressMsg";
  33.  
  34.     private static GTaskASyncTask mSyncTask = null;
  35.  
  36.     private static String mSyncProgress = "";
  37.     
  38.     //开始一个同步的工作
  39.     private void startSync() {
  40.         if (mSyncTask == null) {
  41.             mSyncTask = new GTaskASyncTask(this, new GTaskASyncTask.OnCompleteListener() {
  42.                 public void onComplete() {
  43.                     mSyncTask = null;
  44.                     sendBroadcast("");
  45.                     stopSelf();  
  46.                 }
  47.             });
  48.             sendBroadcast("");
  49.             mSyncTask.execute(); //这个函数让任务是以单线程队列方式或线程池队列方式运行
  50.         }
  51.     }
  52.     
  53.     
  54.     private void cancelSync() {
  55.         if (mSyncTask != null) {
  56.             mSyncTask.cancelSync();
  57.         }
  58.     }
  59.  
  60.     @Override
  61.     public void onCreate() {  //初始化一个service
  62.         mSyncTask = null;
  63.     }
  64.  
  65.     @Override
  66.     public int onStartCommand(Intent intent, int flags, int startId) {
  67.         Bundle bundle = intent.getExtras();
  68.         if (bundle != null && bundle.containsKey(ACTION_STRING_NAME)) {
  69.             switch (bundle.getInt(ACTION_STRING_NAME, ACTION_INVALID)) {
  70.             //两种情况，开始同步或者取消同步
  71.                 case ACTION_START_SYNC:
  72.                     startSync();
  73.                     break;
  74.                 case ACTION_CANCEL_SYNC:
  75.                     cancelSync();
  76.                     break;
  77.                 default:
  78.                     break;
  79.             }
  80.             return START_STICKY; //等待新的intent来是这个service继续运行
  81.         }
  82.         return super.onStartCommand(intent, flags, startId);
  83.     }
  84.  
  85.     @Override
  86.     public void onLowMemory() {
  87.         if (mSyncTask != null) {
  88.             mSyncTask.cancelSync();
  89.         }
  90.     }
  91.  
  92.     public IBinder onBind(Intent intent) {  //不知道干吗用的
  93.         return null;
  94.     }
  95.  
  96.     public void sendBroadcast(String msg) {
  97.         mSyncProgress = msg;
  98.         Intent intent = new Intent(GTASK_SERVICE_BROADCAST_NAME);  //创建一个新的Intent
  99.         intent.putExtra(GTASK_SERVICE_BROADCAST_IS_SYNCING, mSyncTask != null); //附加INTENT中的相应参数的值
  100.         intent.putExtra(GTASK_SERVICE_BROADCAST_PROGRESS_MSG, msg);
  101.         sendBroadcast(intent);   //发送这个通知
  102.     }
  103.  
  104.     public static void startSync(Activity activity) {//执行一个service，service的内容里的同步动作就是开始同步
  105.         GTaskManager.getInstance().setActivityContext(activity);
  106.         Intent intent = new Intent(activity, GTaskSyncService.class);
  107.         intent.putExtra(GTaskSyncService.ACTION_STRING_NAME, GTaskSyncService.ACTION_START_SYNC);
  108.         activity.startService(intent);
  109.     }
  110.  
  111.     public static void cancelSync(Context context) {//执行一个service，service的内容里的同步动作就是取消同步
  112.         Intent intent = new Intent(context, GTaskSyncService.class);
  113.         intent.putExtra(GTaskSyncService.ACTION_STRING_NAME, GTaskSyncService.ACTION_CANCEL_SYNC);
  114.         context.startService(intent);
  115.     }
  116.  
  117.     public static boolean isSyncing() {
  118.         return mSyncTask != null;
  119.     }
  120.  
  121.     public static String getProgressString() {
  122.         return mSyncProgress;
  123.     }
  124. }

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/weixin_40725706/article/detail/552828
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号