注释

package net.micode.notes.gtask.data;  //指定了该类所在的java包为gtask.data

import android.database.Cursor;          //导入了 Android 框架中的 Cursor 类，用于在数据库中进行数据检索。

import org.json.JSONObject;      //导入了 JSON 库中的 JSONObject 类，用于处理 JSON 数据。

public abstract class Node {        //定义了一个抽象类 Node，表示一个节点。
    public static final int SYNC_ACTION_NONE = 0;
//定义了一个名为 SYNC_ACTION_NONE 的常量，值为 0，表示同步操作为无。

    public static final int SYNC_ACTION_ADD_REMOTE = 1; //定义常量，表示远程添加同步操作。

    public static final int SYNC_ACTION_ADD_LOCAL = 2;  //表示本地添加同步操作。

    public static final int SYNC_ACTION_DEL_REMOTE = 3;//表示远程删除同步操作。

    public static final int SYNC_ACTION_DEL_LOCAL = 4;  //表示本地删除同步操作。

    public static final int SYNC_ACTION_UPDATE_REMOTE = 5; //表示远程更新同步操作。

    public static final int SYNC_ACTION_UPDATE_LOCAL = 6;  //表示本地更新同步操作。

    public static final int SYNC_ACTION_UPDATE_CONFLICT = 7; //表示更新冲突同步操作。

    public static final int SYNC_ACTION_ERROR = 8;  //表示同步操作错误。

    private String mGid;    //声明了一个私有成员变量 mGid，用于存储节点的全局唯一标识符。

    private String mName; //声明了一个私有成员变量 mName，用于存储节点的名称。

    private long mLastModified; //声明了一个私有成员变量 mLastModified，用于存储节点的最后修改时间。

    private boolean mDeleted;   //声明了一个私有成员变量 mDeleted，用于表示节点是否被删除。

    public Node() {    //定义了 Node 类的构造函数，初始化成员变量。
        mGid = null;
        mName = "";
        mLastModified = 0;
        mDeleted = false;
    }

    public abstract JSONObject getCreateAction(int actionId);
//声明了一个抽象方法 getCreateAction()，用于获取创建节点的同步操作。

    public abstract JSONObject getUpdateAction(int actionId);
//声明 getUpdateAction()，用于获取更新节点的同步操作。

    public abstract void setContentByRemoteJSON(JSONObject js);
//声明 setContentByRemoteJSON()，用于根据远程 JSON 数据设置节点内容。

    public abstract void setContentByLocalJSON(JSONObject js);
//声明了 setContentByLocalJSON()，用于根据本地 JSON 数据设置节点内容。

    public abstract JSONObject getLocalJSONFromContent();
//声明了一个抽象方法 getLocalJSONFromContent()，用于从节点内容获取本地 JSON 数据。

    public abstract int getSyncAction(Cursor c);
//声明了一个抽象方法 getSyncAction()，用于从 Cursor 中获取同步操作。

    public void setGid(String gid) {   //定义了一个公有方法 setGid()，用于设置节点的全局唯一标识符。
        this.mGid = gid;
    }

    public void setName(String name) {  //定义了一个公有方法 setName()，用于设置节点的名称。
        this.mName = name;
    }

    public void setLastModified(long lastModified) {   //定义了一个公有方法 setLastModified()，用于设置节点的最后修改时间。
        this.mLastModified = lastModified;
    }

    public void setDeleted(boolean deleted) {   //定义了一个公有方法 setDeleted()，用于设置节点是否被删除。
        this.mDeleted = deleted;
    }

    public String getGid() {                              //定义了一个公有方法 getGid()，用于获取节点的全局唯一标识符。
        return this.mGid;
    }

    public String getName() {                             //定义了一个公有方法 getName()，用于获取节点的名称。
        return this.mName;
    }

    public long getLastModified() {                    //定义了一个公有方法 getLastModified()，用于获取节点的最后修改时间。
        return this.mLastModified;
    }

    public boolean getDeleted() {                     //定义了一个公有方法 getDeleted()，用于获取节点是否被删除。
        return this.mDeleted;
    }

}

package net.micode.notes.gtask.data;

import android.content.ContentResolver;
import android.content.ContentUris;
import android.content.ContentValues;
import android.content.Context;
import android.database.Cursor;
import android.net.Uri;
import android.util.Log;

import net.micode.notes.data.Notes;
import net.micode.notes.data.Notes.DataColumns;
import net.micode.notes.data.Notes.DataConstants;
import net.micode.notes.data.Notes.NoteColumns;
import net.micode.notes.data.NotesDatabaseHelper.TABLE;
import net.micode.notes.gtask.exception.ActionFailureException;

import org.json.JSONException;
import org.json.JSONObject;
//以上import导入了所需的Android类和自定义异常，以及用于处理JSON数据的类。

public class SqlData {  //定义了一个名为 SqlData 的类。
private static final String TAG = SqlData.class.getSimpleName();
//声明了一个私有静态常量 TAG，用于在日志中标识类的名称。

    private static final int INVALID_ID = -99999;
//声明了一个私有静态常量 INVALID_ID，用于表示无效的ID值。

    public static final String[] PROJECTION_DATA = new String[] {
            DataColumns.ID, DataColumns.MIME_TYPE, DataColumns.CONTENT, DataColumns.DATA1,
            DataColumns.DATA3
    };  //这是一个字符串数组 PROJECTION_DATA，用于指定要在查询数据时返回的列。

    public static final int DATA_ID_COLUMN = 0;

    public static final int DATA_MIME_TYPE_COLUMN = 1;

    public static final int DATA_CONTENT_COLUMN = 2;

    public static final int DATA_CONTENT_DATA_1_COLUMN = 3;

    public static final int DATA_CONTENT_DATA_3_COLUMN = 4;
//以上声明了一组公有静态常量，表示数据列在查询结果中的索引。

    private ContentResolver mContentResolver;

    private boolean mIsCreate;

    private long mDataId;

    private String mDataMimeType;

    private String mDataContent;

    private long mDataContentData1;

    private String mDataContentData3;

    private ContentValues mDiffDataValues;   //声明了一些私有成员变量，用于存储数据的相关信息。

    public SqlData(Context context) {    //定义了 SqlData 类的构造函数，接受一个 Context 参数。
        mContentResolver = context.getContentResolver();
        mIsCreate = true;
        mDataId = INVALID_ID;
        mDataMimeType = DataConstants.NOTE;
        mDataContent = "";
        mDataContentData1 = 0;
        mDataContentData3 = "";
        mDiffDataValues = new ContentValues();
    }  //在构造函数中对成员变量进行初始化

    public SqlData(Context context, Cursor c) {   //定义了另一个构造函数，接受一个 Context 和一个 Cursor 参数。
        mContentResolver = context.getContentResolver();
        mIsCreate = false;
        loadFromCursor(c);
        mDiffDataValues = new ContentValues();
    }   //在第二个构造函数中对成员变量进行初始化，并调用 loadFromCursor() 方法加载数据。

    private void loadFromCursor(Cursor c) {    //定义了一个私有方法 loadFromCursor()，接受一个 Cursor 参数。
        mDataId = c.getLong(DATA_ID_COLUMN);
        mDataMimeType = c.getString(DATA_MIME_TYPE_COLUMN);
        mDataContent = c.getString(DATA_CONTENT_COLUMN);
        mDataContentData1 = c.getLong(DATA_CONTENT_DATA_1_COLUMN);
        mDataContentData3 = c.getString(DATA_CONTENT_DATA_3_COLUMN);
    }  //从 Cursor 中读取数据，并将其存储到相应的成员变量中。

    public void setContent(JSONObject js) throws JSONException {
 //定义了一个公有方法 setContent()，接受一个 JSONObject 参数，并可能抛出 JSONException 异常。

        long dataId = js.has(DataColumns.ID) ? js.getLong(DataColumns.ID) : INVALID_ID;
        if (mIsCreate || mDataId != dataId) {
            mDiffDataValues.put(DataColumns.ID, dataId);
        }
        mDataId = dataId;
   //从 JSON 对象中读取数据，并将其存储到相应的成员变量中。

        String dataMimeType = js.has(DataColumns.MIME_TYPE) ? js.getString(DataColumns.MIME_TYPE)
                : DataConstants.NOTE;
        if (mIsCreate || !mDataMimeType.equals(dataMimeType)) {
            mDiffDataValues.put(DataColumns.MIME_TYPE, dataMimeType);
        }
        mDataMimeType = dataMimeType;

        String dataContent = js.has(DataColumns.CONTENT) ? js.getString(DataColumns.CONTENT) : "";
        if (mIsCreate || !mDataContent.equals(dataContent)) {
            mDiffDataValues.put(DataColumns.CONTENT, dataContent);
        }
        mDataContent = dataContent;

        long dataContentData1 = js.has(DataColumns.DATA1) ? js.getLong(DataColumns.DATA1) : 0;
        if (mIsCreate || mDataContentData1 != dataContentData1) {
            mDiffDataValues.put(DataColumns.DATA1, dataContentData1);
        }
        mDataContentData1 = dataContentData1;

        String dataContentData3 = js.has(DataColumns.DATA3) ? js.getString(DataColumns.DATA3) : "";
        if (mIsCreate || !mDataContentData3.equals(dataContentData3)) {
            mDiffDataValues.put(DataColumns.DATA3, dataContentData3);
        }
        mDataContentData3 = dataContentData3;
    }   //从 JSON 对象中读取数据，并将其存储到相应的成员变量中。

    public JSONObject getContent() throws JSONException {  //定义了一个公有方法 getContent()，可能抛出 JSONException 异常。
        if (mIsCreate) {
            Log.e(TAG, "it seems that we haven't created this in database yet");
            return null;
        }
        JSONObject js = new JSONObject();
        js.put(DataColumns.ID, mDataId);
        js.put(DataColumns.MIME_TYPE, mDataMimeType);
        js.put(DataColumns.CONTENT, mDataContent);
        js.put(DataColumns.DATA1, mDataContentData1);
        js.put(DataColumns.DATA3, mDataContentData3);
        return js;
    }  //根据成员变量的值创建一个 JSON 对象，并返回

    public void commit(long noteId, boolean validateVersion, long version) {  //定义了一个公有方法 commit()，接受三个参数。

        if (mIsCreate) {
            if (mDataId == INVALID_ID && mDiffDataValues.containsKey(DataColumns.ID)) {
                mDiffDataValues.remove(DataColumns.ID);
            }

            mDiffDataValues.put(DataColumns.NOTE_ID, noteId);
            Uri uri = mContentResolver.insert(Notes.CONTENT_DATA_URI, mDiffDataValues);
            try {
                mDataId = Long.valueOf(uri.getPathSegments().get(1));
            } catch (NumberFormatException e) {
                Log.e(TAG, "Get note id error :" + e.toString());
                throw new ActionFailureException("create note failed");
            }
        } else {
            if (mDiffDataValues.size() > 0) {
                int result = 0;
                if (!validateVersion) {
                    result = mContentResolver.update(ContentUris.withAppendedId(
                            Notes.CONTENT_DATA_URI, mDataId), mDiffDataValues, null, null);
                } else {
                    result = mContentResolver.update(ContentUris.withAppendedId(
                            Notes.CONTENT_DATA_URI, mDataId), mDiffDataValues,
                            " ? in (SELECT " + NoteColumns.ID + " FROM " + TABLE.NOTE
                                    + " WHERE " + NoteColumns.VERSION + "=?)", new String[] {
                                    String.valueOf(noteId), String.valueOf(version)
                            });
                }
                if (result == 0) {
                    Log.w(TAG, "there is no update. maybe user updates note when syncing");
                }
            }
        }
//根据条件执行插入或更新操作。
        mDiffDataValues.clear();
        mIsCreate = false;
    }
//清除变更数据并将 mIsCreate 设置为 false。
    public long getId() {
        return mDataId;
    }
}

.gitignore

@@ -1,29 +0,0 @@
-### IntelliJ IDEA ###
-out/
-!**/src/main/**/out/
-!**/src/test/**/out/
-
-### Eclipse ###
-.apt_generated
-.classpath
-.factorypath
-.project
-.settings
-.springBeans
-.sts4-cache
-bin/
-!**/src/main/**/bin/
-!**/src/test/**/bin/
-
-### NetBeans ###
-/nbproject/private/
-/nbbuild/
-/dist/
-/nbdist/
-/.nb-gradle/
-
-### VS Code ###
-.vscode/
-
-### Mac OS ###
-.DS_Store

.idea/.gitignore

@@ -1,8 +0,0 @@
-# 默认忽略的文件
-/shelf/
-/workspace.xml
-# 基于编辑器的 HTTP 客户端请求
-/httpRequests/
-# Datasource local storage ignored files
-/dataSources/
-/dataSources.local.xml

.idea/.name

@@ -1 +0,0 @@
-NotesDatabaseHelper_structure.puml

.idea/misc.xml

@@ -1,5 +0,0 @@
-<project version="4">
-  <component name="ProjectRootManager" version="2" languageLevel="JDK_X" default="true" project-jdk-name="21" project-jdk-type="JavaSDK">
-    <output url="file://$PROJECT_DIR$/out" />
-  </component>
-</project>

.idea/modules.xml

@@ -1,8 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<project version="4">
-  <component name="ProjectModuleManager">
-    <modules>
-      <module fileurl="file://$PROJECT_DIR$/untitled.iml" filepath="$PROJECT_DIR$/untitled.iml" />
-    </modules>
-  </component>
-</project>

.idea/sonarlint/issuestore/index.pb

@@ -1,5 +0,0 @@
-
-9
-	README.md,8\e\8ec9a00bfd09b3190ac6b22251dbb1aa95a0579d
-º

-‰
å°<C3A5>米标签å<C2BE>Šæ¡ˆä¾‹/æº<C3A6>程åº<C3A5>代ç <C3A7>-å°<C3A5>米便签-Notes-master/Notes-master/src/net/micode/notes/data/NotesDatabaseHelper_structure.puml,a\3\a3aa9b757da57524f6cc0195e900fcc2bf62363b

.idea/sonarlint/securityhotspotstore/index.pb

@@ -1,5 +0,0 @@
-
-9
-	README.md,8\e\8ec9a00bfd09b3190ac6b22251dbb1aa95a0579d
-º

-‰
å°<C3A5>米标签å<C2BE>Šæ¡ˆä¾‹/æº<C3A6>程åº<C3A5>代ç <C3A7>-å°<C3A5>米便签-Notes-master/Notes-master/src/net/micode/notes/data/NotesDatabaseHelper_structure.puml,a\3\a3aa9b757da57524f6cc0195e900fcc2bf62363b

.idea/vcs.xml

@@ -1,7 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<project version="4">
-  <component name="VcsDirectoryMappings">
-    <mapping directory="" vcs="Git" />
-    <mapping directory="$PROJECT_DIR$/小米标签及案例/源程序代码-小米便签-Notes-master/1_tu/untitled" vcs="Git" />
-  </component>
-</project>

123.txt

@@ -0,0 +1,3 @@
+123
+branch01
+hahaha

TaskList.txt

@@ -0,0 +1,373 @@
+/*
+ * Copyright (c) 2010-2011, The MiCode Open Source Community (www.micode.net)
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *        http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+//这段代码是一个Java类，它定义了一个TaskList类这段代码是一个Java类，它定义了一个TaskList类
+
+package net.micode.notes.gtask.data;  //这行代码指定了类所在的包
+
+import android.database.Cursor;
+import android.util.Log;
+
+import net.micode.notes.data.Notes;
+import net.micode.notes.data.Notes.NoteColumns;
+import net.micode.notes.gtask.exception.ActionFailureException;
+import net.micode.notes.tool.GTaskStringUtils;
+
+import org.json.JSONException;
+import org.json.JSONObject;
+
+import java.util.ArrayList;
+//这些是所需的导入语句，用于引入需要的类和库。
+
+public class TaskList extends Node {
+//这行代码定义了一个名为TaskList的类，它扩展自Node类，表明TaskList是一个节点，可能是树形结构中的一部分。
+    private static final String TAG = TaskList.class.getSimpleName();
+ //这行代码声明了一个私有静态常量TAG，用于在日志中标识当前类。
+    private int mIndex;
+
+    private ArrayList<Task> mChildren;
+//这两行声明了私有变量mIndex和mChildren，分别表示任务列表的索引和子任务列表。mChildren是一个ArrayList，其中的元素类型是Task。
+    public TaskList() {
+        super();
+        mChildren = new ArrayList<Task>();
+        mIndex = 1;
+    }
+//这是类的构造函数，初始化了mChildren为一个新的空ArrayList，并将mIndex设置为1。
+
+    public JSONObject getCreateAction(int actionId) {
+//这是一个公共方法，用于生成创建操作的JSON对象。它接受一个actionId作为参数。
+        JSONObject js = new JSONObject();
+
+        try {
+            // action_type
+            js.put(GTaskStringUtils.GTASK_JSON_ACTION_TYPE,
+                    GTaskStringUtils.GTASK_JSON_ACTION_TYPE_CREATE);
+
+            // action_id
+            js.put(GTaskStringUtils.GTASK_JSON_ACTION_ID, actionId);
+
+            // index
+            js.put(GTaskStringUtils.GTASK_JSON_INDEX, mIndex);
+
+            // entity_delta
+            JSONObject entity = new JSONObject();
+            entity.put(GTaskStringUtils.GTASK_JSON_NAME, getName());
+            entity.put(GTaskStringUtils.GTASK_JSON_CREATOR_ID, "null");
+            entity.put(GTaskStringUtils.GTASK_JSON_ENTITY_TYPE,
+                    GTaskStringUtils.GTASK_JSON_TYPE_GROUP);
+            js.put(GTaskStringUtils.GTASK_JSON_ENTITY_DELTA, entity);
+
+        } catch (JSONException e) {
+            Log.e(TAG, e.toString());
+            e.printStackTrace();
+            throw new ActionFailureException("fail to generate tasklist-create jsonobject");
+        }
+
+        return js;
+    }
+
+    public JSONObject getUpdateAction(int actionId) {
+//这是另一个公共方法，用于生成更新操作的JSON对象。同样接受一个actionId参数。
+        JSONObject js = new JSONObject();
+
+        try {
+            // action_type
+            js.put(GTaskStringUtils.GTASK_JSON_ACTION_TYPE,
+                    GTaskStringUtils.GTASK_JSON_ACTION_TYPE_UPDATE);
+
+            // action_id
+            js.put(GTaskStringUtils.GTASK_JSON_ACTION_ID, actionId);
+
+            // id
+            js.put(GTaskStringUtils.GTASK_JSON_ID, getGid());
+
+            // entity_delta
+            JSONObject entity = new JSONObject();
+            entity.put(GTaskStringUtils.GTASK_JSON_NAME, getName());
+            entity.put(GTaskStringUtils.GTASK_JSON_DELETED, getDeleted());
+            js.put(GTaskStringUtils.GTASK_JSON_ENTITY_DELTA, entity);
+
+        } catch (JSONException e) {
+            Log.e(TAG, e.toString());
+            e.printStackTrace();
+            throw new ActionFailureException("fail to generate tasklist-update jsonobject");
+        }
+
+        return js;
+    }
+
+    public void setContentByRemoteJSON(JSONObject js) {
+//这是一个公共方法，用于从远程JSON对象设置任务列表的内容。
+
+        if (js != null) {
+            try {
+                // id
+                if (js.has(GTaskStringUtils.GTASK_JSON_ID)) {
+                    setGid(js.getString(GTaskStringUtils.GTASK_JSON_ID));
+                }
+
+                // last_modified
+                if (js.has(GTaskStringUtils.GTASK_JSON_LAST_MODIFIED)) {
+                    setLastModified(js.getLong(GTaskStringUtils.GTASK_JSON_LAST_MODIFIED));
+                }
+
+                // name
+                if (js.has(GTaskStringUtils.GTASK_JSON_NAME)) {
+                    setName(js.getString(GTaskStringUtils.GTASK_JSON_NAME));
+                }
+
+            } catch (JSONException e) {
+                Log.e(TAG, e.toString());
+                e.printStackTrace();
+                throw new ActionFailureException("fail to get tasklist content from jsonobject");
+            }
+        }
+    }
+
+    public void setContentByLocalJSON(JSONObject js) {
+//这是另一个公共方法，用于从本地JSON对象设置任务列表的内容。
+
+        if (js == null || !js.has(GTaskStringUtils.META_HEAD_NOTE)) {
+            Log.w(TAG, "setContentByLocalJSON: nothing is avaiable");
+        }
+
+        try {
+            JSONObject folder = js.getJSONObject(GTaskStringUtils.META_HEAD_NOTE);
+
+            if (folder.getInt(NoteColumns.TYPE) == Notes.TYPE_FOLDER) {
+                String name = folder.getString(NoteColumns.SNIPPET);
+                setName(GTaskStringUtils.MIUI_FOLDER_PREFFIX + name);
+            } else if (folder.getInt(NoteColumns.TYPE) == Notes.TYPE_SYSTEM) {
+                if (folder.getLong(NoteColumns.ID) == Notes.ID_ROOT_FOLDER)
+                    setName(GTaskStringUtils.MIUI_FOLDER_PREFFIX + GTaskStringUtils.FOLDER_DEFAULT);
+                else if (folder.getLong(NoteColumns.ID) == Notes.ID_CALL_RECORD_FOLDER)
+                    setName(GTaskStringUtils.MIUI_FOLDER_PREFFIX
+                            + GTaskStringUtils.FOLDER_CALL_NOTE);
+                else
+                    Log.e(TAG, "invalid system folder");
+            } else {
+                Log.e(TAG, "error type");
+            }
+        } catch (JSONException e) {
+            Log.e(TAG, e.toString());
+            e.printStackTrace();
+        }
+    }
+
+    public JSONObject getLocalJSONFromContent() {
+//这是一个公共方法，用于从任务列表内容生成本地JSON对象。
+        try {
+            JSONObject js = new JSONObject();
+            JSONObject folder = new JSONObject();
+
+            String folderName = getName();
+            if (getName().startsWith(GTaskStringUtils.MIUI_FOLDER_PREFFIX))
+                folderName = folderName.substring(GTaskStringUtils.MIUI_FOLDER_PREFFIX.length(),
+                        folderName.length());
+            folder.put(NoteColumns.SNIPPET, folderName);
+            if (folderName.equals(GTaskStringUtils.FOLDER_DEFAULT)
+                    || folderName.equals(GTaskStringUtils.FOLDER_CALL_NOTE))
+                folder.put(NoteColumns.TYPE, Notes.TYPE_SYSTEM);
+            else
+                folder.put(NoteColumns.TYPE, Notes.TYPE_FOLDER);
+
+            js.put(GTaskStringUtils.META_HEAD_NOTE, folder);
+
+            return js;
+        } catch (JSONException e) {
+            Log.e(TAG, e.toString());
+            e.printStackTrace();
+            return null;
+        }
+    }
+
+    public int getSyncAction(Cursor c) {
+//这是一个公共方法，用于根据游标中的数据确定同步操作。
+
+        try {
+            if (c.getInt(SqlNote.LOCAL_MODIFIED_COLUMN) == 0) {
+                // there is no local update
+                if (c.getLong(SqlNote.SYNC_ID_COLUMN) == getLastModified()) {
+                    // no update both side
+                    return SYNC_ACTION_NONE;
+                } else {
+                    // apply remote to local
+                    return SYNC_ACTION_UPDATE_LOCAL;
+                }
+            } else {
+                // validate gtask id
+                if (!c.getString(SqlNote.GTASK_ID_COLUMN).equals(getGid())) {
+                    Log.e(TAG, "gtask id doesn't match");
+                    return SYNC_ACTION_ERROR;
+                }
+                if (c.getLong(SqlNote.SYNC_ID_COLUMN) == getLastModified()) {
+                    // local modification only
+                    return SYNC_ACTION_UPDATE_REMOTE;
+                } else {
+                    // for folder conflicts, just apply local modification
+                    return SYNC_ACTION_UPDATE_REMOTE;
+                }
+            }
+        } catch (Exception e) {
+            Log.e(TAG, e.toString());
+            e.printStackTrace();
+        }
+
+        return SYNC_ACTION_ERROR;
+    }
+
+    public int getChildTaskCount() {
+//这是一个公共方法，用于获取子任务数量。
+
+        return mChildren.size();
+    }
+
+    public boolean addChildTask(Task task) {
+//这是一个公共方法，用于添加子任务。
+
+        boolean ret = false;
+        if (task != null && !mChildren.contains(task)) {
+            ret = mChildren.add(task);
+            if (ret) {
+                // need to set prior sibling and parent
+                task.setPriorSibling(mChildren.isEmpty() ? null : mChildren
+                        .get(mChildren.size() - 1));
+                task.setParent(this);
+            }
+        }
+        return ret;
+    }
+
+    public boolean addChildTask(Task task, int index) {
+//这是另一个公共方法，用于在指定位置添加子任务。
+        if (index < 0 || index > mChildren.size()) {
+            Log.e(TAG, "add child task: invalid index");
+            return false;
+        }
+
+        int pos = mChildren.indexOf(task);
+        if (task != null && pos == -1) {
+            mChildren.add(index, task);
+
+            // update the task list
+            Task preTask = null;
+            Task afterTask = null;
+            if (index != 0)
+                preTask = mChildren.get(index - 1);
+            if (index != mChildren.size() - 1)
+                afterTask = mChildren.get(index + 1);
+
+            task.setPriorSibling(preTask);
+            if (afterTask != null)
+                afterTask.setPriorSibling(task);
+        }
+
+        return true;
+    }
+
+    public boolean removeChildTask(Task task) {
+//这是一个公共方法，用于移除指定子任务。
+
+        boolean ret = false;
+        int index = mChildren.indexOf(task);
+        if (index != -1) {
+            ret = mChildren.remove(task);
+
+            if (ret) {
+                // reset prior sibling and parent
+                task.setPriorSibling(null);
+                task.setParent(null);
+
+                // update the task list
+                if (index != mChildren.size()) {
+                    mChildren.get(index).setPriorSibling(
+                            index == 0 ? null : mChildren.get(index - 1));
+                }
+            }
+        }
+        return ret;
+    }
+
+    public boolean moveChildTask(Task task, int index) {
+//这是一个公共方法，用于移动指定子任务到新的位置。
+
+        if (index < 0 || index >= mChildren.size()) {
+            Log.e(TAG, "move child task: invalid index");
+            return false;
+        }
+
+        int pos = mChildren.indexOf(task);
+        if (pos == -1) {
+            Log.e(TAG, "move child task: the task should in the list");
+            return false;
+        }
+
+        if (pos == index)
+            return true;
+        return (removeChildTask(task) && addChildTask(task, index));
+    }
+
+    public Task findChildTaskByGid(String gid) {
+//这是一个公共方法，用于根据全局ID查找子任务。
+
+        for (int i = 0; i < mChildren.size(); i++) {
+            Task t = mChildren.get(i);
+            if (t.getGid().equals(gid)) {
+                return t;
+            }
+        }
+        return null;
+    }
+
+    public int getChildTaskIndex(Task task) {
+//这是一个公共方法，用于获取子任务的索引。
+        return mChildren.indexOf(task);
+    }
+
+    public Task getChildTaskByIndex(int index) {
+//这是一个公共方法，用于根据索引获取子任务。
+        if (index < 0 || index >= mChildren.size()) {
+            Log.e(TAG, "getTaskByIndex: invalid index");
+            return null;
+        }
+        return mChildren.get(index);
+    }
+
+    public Task getChilTaskByGid(String gid) {
+//这是一个公共方法，用于根据全局ID获取子任务。
+
+        for (Task task : mChildren) {
+            if (task.getGid().equals(gid))
+                return task;
+        }
+        return null;
+    }
+
+    public ArrayList<Task> getChildTaskList() {
+//这是一个公共方法，用于获取子任务列表。
+
+        return this.mChildren;
+    }
+
+    public void setIndex(int index) {//这是一个公共方法，用于设置索引。
+        this.mIndex = index;
+    }
+
+    public int getIndex() {  //这是一个公共方法，用于获取索引
+        return this.mIndex;
+    }
+//这段代码定义了一个任务列表类，提供了一系列方法用于管理任务列表及其子任务。
+}

gtask.data.Node&Sqldata.txt

@@ -0,0 +1,284 @@
+这段代码主要是定义了一个节点类 Node，其中包含了一些常量、成员变量和方法，用于表示节点的属性和同步操作。
+
+package net.micode.notes.gtask.data;  //指定了该类所在的java包为gtask.data
+
+import android.database.Cursor;          //导入了 Android 框架中的 Cursor 类，用于在数据库中进行数据检索。
+
+import org.json.JSONObject;      //导入了 JSON 库中的 JSONObject 类，用于处理 JSON 数据。
+
+
+public abstract class Node {        //定义了一个抽象类 Node，表示一个节点。
+    public static final int SYNC_ACTION_NONE = 0;  
+//定义了一个名为 SYNC_ACTION_NONE 的常量，值为 0，表示同步操作为无。
+
+    public static final int SYNC_ACTION_ADD_REMOTE = 1; //定义常量，表示远程添加同步操作。
+
+    public static final int SYNC_ACTION_ADD_LOCAL = 2;  //表示本地添加同步操作。
+
+    public static final int SYNC_ACTION_DEL_REMOTE = 3;//表示远程删除同步操作。
+
+    public static final int SYNC_ACTION_DEL_LOCAL = 4;  //表示本地删除同步操作。
+
+    public static final int SYNC_ACTION_UPDATE_REMOTE = 5; //表示远程更新同步操作。
+
+    public static final int SYNC_ACTION_UPDATE_LOCAL = 6;  //表示本地更新同步操作。
+
+    public static final int SYNC_ACTION_UPDATE_CONFLICT = 7; //表示更新冲突同步操作。
+
+    public static final int SYNC_ACTION_ERROR = 8;  //表示同步操作错误。
+
+    private String mGid;    //声明了一个私有成员变量 mGid，用于存储节点的全局唯一标识符。
+
+    private String mName; //声明了一个私有成员变量 mName，用于存储节点的名称。
+
+    private long mLastModified; //声明了一个私有成员变量 mLastModified，用于存储节点的最后修改时间。
+
+    private boolean mDeleted;   //声明了一个私有成员变量 mDeleted，用于表示节点是否被删除。
+
+    public Node() {    //定义了 Node 类的构造函数，初始化成员变量。
+        mGid = null;
+        mName = "";
+        mLastModified = 0;
+        mDeleted = false;
+    }
+
+    public abstract JSONObject getCreateAction(int actionId); 
+//声明了一个抽象方法 getCreateAction()，用于获取创建节点的同步操作。
+
+    public abstract JSONObject getUpdateAction(int actionId); 
+//声明 getUpdateAction()，用于获取更新节点的同步操作。
+
+    public abstract void setContentByRemoteJSON(JSONObject js);
+//声明 setContentByRemoteJSON()，用于根据远程 JSON 数据设置节点内容。
+
+    public abstract void setContentByLocalJSON(JSONObject js); 
+//声明了 setContentByLocalJSON()，用于根据本地 JSON 数据设置节点内容。
+
+    public abstract JSONObject getLocalJSONFromContent();
+//声明了一个抽象方法 getLocalJSONFromContent()，用于从节点内容获取本地 JSON 数据。
+
+    public abstract int getSyncAction(Cursor c);
+//声明了一个抽象方法 getSyncAction()，用于从 Cursor 中获取同步操作。
+
+    public void setGid(String gid) {   //定义了一个公有方法 setGid()，用于设置节点的全局唯一标识符。
+        this.mGid = gid;
+    }
+
+    public void setName(String name) {  //定义了一个公有方法 setName()，用于设置节点的名称。
+        this.mName = name;
+    }
+
+    public void setLastModified(long lastModified) {   //定义了一个公有方法 setLastModified()，用于设置节点的最后修改时间。
+        this.mLastModified = lastModified;
+    }
+
+    public void setDeleted(boolean deleted) {   //定义了一个公有方法 setDeleted()，用于设置节点是否被删除。
+        this.mDeleted = deleted; 
+    }
+
+    public String getGid() {                              //定义了一个公有方法 getGid()，用于获取节点的全局唯一标识符。
+        return this.mGid;
+    }
+
+    public String getName() {                             //定义了一个公有方法 getName()，用于获取节点的名称。
+        return this.mName;
+    }
+
+    public long getLastModified() {                    //定义了一个公有方法 getLastModified()，用于获取节点的最后修改时间。
+        return this.mLastModified;
+    }
+
+    public boolean getDeleted() {                     //定义了一个公有方法 getDeleted()，用于获取节点是否被删除。
+        return this.mDeleted;
+    }
+
+}
+
+
+
+
+
+
+
+
+
+package net.micode.notes.gtask.data;
+
+import android.content.ContentResolver;
+import android.content.ContentUris;
+import android.content.ContentValues;
+import android.content.Context;
+import android.database.Cursor;
+import android.net.Uri;
+import android.util.Log;
+
+import net.micode.notes.data.Notes;
+import net.micode.notes.data.Notes.DataColumns;
+import net.micode.notes.data.Notes.DataConstants;
+import net.micode.notes.data.Notes.NoteColumns;
+import net.micode.notes.data.NotesDatabaseHelper.TABLE;
+import net.micode.notes.gtask.exception.ActionFailureException;
+
+import org.json.JSONException;
+import org.json.JSONObject;
+//以上import导入了所需的Android类和自定义异常，以及用于处理JSON数据的类。
+
+public class SqlData {  //定义了一个名为 SqlData 的类。
+private static final String TAG = SqlData.class.getSimpleName(); 
+//声明了一个私有静态常量 TAG，用于在日志中标识类的名称。
+
+    private static final int INVALID_ID = -99999;
+//声明了一个私有静态常量 INVALID_ID，用于表示无效的ID值。
+
+    public static final String[] PROJECTION_DATA = new String[] {
+            DataColumns.ID, DataColumns.MIME_TYPE, DataColumns.CONTENT, DataColumns.DATA1,
+            DataColumns.DATA3
+    };  //这是一个字符串数组 PROJECTION_DATA，用于指定要在查询数据时返回的列。
+
+    public static final int DATA_ID_COLUMN = 0;
+
+    public static final int DATA_MIME_TYPE_COLUMN = 1;
+
+    public static final int DATA_CONTENT_COLUMN = 2;
+
+    public static final int DATA_CONTENT_DATA_1_COLUMN = 3;
+
+    public static final int DATA_CONTENT_DATA_3_COLUMN = 4;
+//以上声明了一组公有静态常量，表示数据列在查询结果中的索引。
+
+    private ContentResolver mContentResolver;  
+
+    private boolean mIsCreate;
+
+    private long mDataId;
+
+    private String mDataMimeType;
+
+    private String mDataContent;
+
+    private long mDataContentData1;
+
+    private String mDataContentData3;
+
+    private ContentValues mDiffDataValues;   //声明了一些私有成员变量，用于存储数据的相关信息。
+
+    public SqlData(Context context) {    //定义了 SqlData 类的构造函数，接受一个 Context 参数。
+        mContentResolver = context.getContentResolver();
+        mIsCreate = true;
+        mDataId = INVALID_ID;
+        mDataMimeType = DataConstants.NOTE;
+        mDataContent = "";
+        mDataContentData1 = 0;
+        mDataContentData3 = "";
+        mDiffDataValues = new ContentValues();
+    }  //在构造函数中对成员变量进行初始化
+
+    public SqlData(Context context, Cursor c) {   //定义了另一个构造函数，接受一个 Context 和一个 Cursor 参数。
+        mContentResolver = context.getContentResolver();
+        mIsCreate = false;
+        loadFromCursor(c);
+        mDiffDataValues = new ContentValues();
+    }   //在第二个构造函数中对成员变量进行初始化，并调用 loadFromCursor() 方法加载数据。
+
+    private void loadFromCursor(Cursor c) {    //定义了一个私有方法 loadFromCursor()，接受一个 Cursor 参数。
+        mDataId = c.getLong(DATA_ID_COLUMN);
+        mDataMimeType = c.getString(DATA_MIME_TYPE_COLUMN);
+        mDataContent = c.getString(DATA_CONTENT_COLUMN);
+        mDataContentData1 = c.getLong(DATA_CONTENT_DATA_1_COLUMN);
+        mDataContentData3 = c.getString(DATA_CONTENT_DATA_3_COLUMN);
+    }  //从 Cursor 中读取数据，并将其存储到相应的成员变量中。
+
+    public void setContent(JSONObject js) throws JSONException { 
+ //定义了一个公有方法 setContent()，接受一个 JSONObject 参数，并可能抛出 JSONException 异常。
+
+        long dataId = js.has(DataColumns.ID) ? js.getLong(DataColumns.ID) : INVALID_ID;
+        if (mIsCreate || mDataId != dataId) {
+            mDiffDataValues.put(DataColumns.ID, dataId);
+        }
+        mDataId = dataId;
+   //从 JSON 对象中读取数据，并将其存储到相应的成员变量中。
+
+        String dataMimeType = js.has(DataColumns.MIME_TYPE) ? js.getString(DataColumns.MIME_TYPE)
+                : DataConstants.NOTE;
+        if (mIsCreate || !mDataMimeType.equals(dataMimeType)) {
+            mDiffDataValues.put(DataColumns.MIME_TYPE, dataMimeType);
+        }
+        mDataMimeType = dataMimeType;
+
+        String dataContent = js.has(DataColumns.CONTENT) ? js.getString(DataColumns.CONTENT) : "";
+        if (mIsCreate || !mDataContent.equals(dataContent)) {
+            mDiffDataValues.put(DataColumns.CONTENT, dataContent);
+        }
+        mDataContent = dataContent;
+
+        long dataContentData1 = js.has(DataColumns.DATA1) ? js.getLong(DataColumns.DATA1) : 0;
+        if (mIsCreate || mDataContentData1 != dataContentData1) {
+            mDiffDataValues.put(DataColumns.DATA1, dataContentData1);
+        }
+        mDataContentData1 = dataContentData1;
+
+        String dataContentData3 = js.has(DataColumns.DATA3) ? js.getString(DataColumns.DATA3) : "";
+        if (mIsCreate || !mDataContentData3.equals(dataContentData3)) {
+            mDiffDataValues.put(DataColumns.DATA3, dataContentData3);
+        }
+        mDataContentData3 = dataContentData3;
+    }   //从 JSON 对象中读取数据，并将其存储到相应的成员变量中。
+
+    public JSONObject getContent() throws JSONException {  //定义了一个公有方法 getContent()，可能抛出 JSONException 异常。
+        if (mIsCreate) {
+            Log.e(TAG, "it seems that we haven't created this in database yet");
+            return null;
+        }
+        JSONObject js = new JSONObject();
+        js.put(DataColumns.ID, mDataId);
+        js.put(DataColumns.MIME_TYPE, mDataMimeType);
+        js.put(DataColumns.CONTENT, mDataContent);
+        js.put(DataColumns.DATA1, mDataContentData1);
+        js.put(DataColumns.DATA3, mDataContentData3);
+        return js;
+    }  //根据成员变量的值创建一个 JSON 对象，并返回
+
+    public void commit(long noteId, boolean validateVersion, long version) {  //定义了一个公有方法 commit()，接受三个参数。
+
+        if (mIsCreate) {
+            if (mDataId == INVALID_ID && mDiffDataValues.containsKey(DataColumns.ID)) {
+                mDiffDataValues.remove(DataColumns.ID);
+            }
+
+            mDiffDataValues.put(DataColumns.NOTE_ID, noteId);
+            Uri uri = mContentResolver.insert(Notes.CONTENT_DATA_URI, mDiffDataValues);
+            try {
+                mDataId = Long.valueOf(uri.getPathSegments().get(1));
+            } catch (NumberFormatException e) {
+                Log.e(TAG, "Get note id error :" + e.toString());
+                throw new ActionFailureException("create note failed");
+            }
+        } else {
+            if (mDiffDataValues.size() > 0) {
+                int result = 0;
+                if (!validateVersion) {
+                    result = mContentResolver.update(ContentUris.withAppendedId(
+                            Notes.CONTENT_DATA_URI, mDataId), mDiffDataValues, null, null);
+                } else {
+                    result = mContentResolver.update(ContentUris.withAppendedId(
+                            Notes.CONTENT_DATA_URI, mDataId), mDiffDataValues,
+                            " ? in (SELECT " + NoteColumns.ID + " FROM " + TABLE.NOTE
+                                    + " WHERE " + NoteColumns.VERSION + "=?)", new String[] {
+                                    String.valueOf(noteId), String.valueOf(version)
+                            });
+                }
+                if (result == 0) {
+                    Log.w(TAG, "there is no update. maybe user updates note when syncing");
+                }
+            }
+        }
+//根据条件执行插入或更新操作。
+        mDiffDataValues.clear();
+        mIsCreate = false;
+    }
+//清除变更数据并将 mIsCreate 设置为 false。
+    public long getId() {
+        return mDataId;
+    }
+}
+

gtask.data.task.txt

@@ -0,0 +1,358 @@
+package net.micode.notes.gtask.data;
+//这行代码指定了 Task 类所在的包路径。
+
+import android.database.Cursor;
+import android.text.TextUtils;
+import android.util.Log;
+
+import net.micode.notes.data.Notes;
+import net.micode.notes.data.Notes.DataColumns;
+import net.micode.notes.data.Notes.DataConstants;
+import net.micode.notes.data.Notes.NoteColumns;
+import net.micode.notes.gtask.exception.ActionFailureException;
+import net.micode.notes.tool.GTaskStringUtils;
+
+import org.json.JSONArray;
+import org.json.JSONException;
+import org.json.JSONObject;
+//这些是所需的导入语句，用于引入所需的类和接口。
+
+
+public class Task extends Node { //这行代码定义了一个名为 Task 的类，继承自 Node 类，表示GTask中的任务。
+    private static final String TAG = Task.class.getSimpleName();
+
+    private boolean mCompleted;
+
+    private String mNotes;
+
+    private JSONObject mMetaInfo;
+
+    private Task mPriorSibling;
+
+    private TaskList mParent;
+//这些是 Task 类的成员变量：
+
+TAG: 用于日志记录的标签。
+mCompleted: 表示任务是否已完成。
+mNotes: 存储任务的备注信息。
+mMetaInfo: 存储任务的元信息。
+mPriorSibling: 任务的前一个兄弟任务。
+mParent: 任务的父任务列表。
+
+    public Task() {
+        super();
+        mCompleted = false;
+        mNotes = null;
+        mPriorSibling = null;
+        mParent = null;
+        mMetaInfo = null;
+    }
+//这是 Task 类的构造函数，用于初始化成员变量。
+
+    public JSONObject getCreateAction(int actionId) {
+//这个方法用于生成创建任务的操作所需的 JSON 对象。它接受一个操作 ID 参数，并返回一个包含创建任务所需信息的 JSON 对象。
+        JSONObject js = new JSONObject();
+
+        try {
+            // action_type
+            js.put(GTaskStringUtils.GTASK_JSON_ACTION_TYPE,
+                    GTaskStringUtils.GTASK_JSON_ACTION_TYPE_CREATE);
+
+            // action_id
+            js.put(GTaskStringUtils.GTASK_JSON_ACTION_ID, actionId);
+
+            // index
+            js.put(GTaskStringUtils.GTASK_JSON_INDEX, mParent.getChildTaskIndex(this));
+
+            // entity_delta
+            JSONObject entity = new JSONObject();
+            entity.put(GTaskStringUtils.GTASK_JSON_NAME, getName());
+            entity.put(GTaskStringUtils.GTASK_JSON_CREATOR_ID, "null");
+            entity.put(GTaskStringUtils.GTASK_JSON_ENTITY_TYPE,
+                    GTaskStringUtils.GTASK_JSON_TYPE_TASK);
+            if (getNotes() != null) {
+                entity.put(GTaskStringUtils.GTASK_JSON_NOTES, getNotes());
+            }
+            js.put(GTaskStringUtils.GTASK_JSON_ENTITY_DELTA, entity);
+
+            // parent_id
+            js.put(GTaskStringUtils.GTASK_JSON_PARENT_ID, mParent.getGid());
+
+            // dest_parent_type
+            js.put(GTaskStringUtils.GTASK_JSON_DEST_PARENT_TYPE,
+                    GTaskStringUtils.GTASK_JSON_TYPE_GROUP);
+
+            // list_id
+            js.put(GTaskStringUtils.GTASK_JSON_LIST_ID, mParent.getGid());
+
+            // prior_sibling_id
+            if (mPriorSibling != null) {
+                js.put(GTaskStringUtils.GTASK_JSON_PRIOR_SIBLING_ID, mPriorSibling.getGid());
+            }
+
+        } catch (JSONException e) {
+            Log.e(TAG, e.toString());
+            e.printStackTrace();
+            throw new ActionFailureException("fail to generate task-create jsonobject");
+        }
+
+        return js;
+    }
+
+    public JSONObject getUpdateAction(int actionId) {
+//这个方法用于生成更新任务的操作所需的 JSON 对象。它接受一个操作 ID 参数，并返回一个包含更新任务所需信息的 JSON 对象。
+        JSONObject js = new JSONObject();
+
+        try {
+            // action_type
+            js.put(GTaskStringUtils.GTASK_JSON_ACTION_TYPE,
+                    GTaskStringUtils.GTASK_JSON_ACTION_TYPE_UPDATE);
+
+            // action_id
+            js.put(GTaskStringUtils.GTASK_JSON_ACTION_ID, actionId);
+
+            // id
+            js.put(GTaskStringUtils.GTASK_JSON_ID, getGid());
+
+            // entity_delta
+            JSONObject entity = new JSONObject();
+            entity.put(GTaskStringUtils.GTASK_JSON_NAME, getName());
+            if (getNotes() != null) {
+                entity.put(GTaskStringUtils.GTASK_JSON_NOTES, getNotes());
+            }
+            entity.put(GTaskStringUtils.GTASK_JSON_DELETED, getDeleted());
+            js.put(GTaskStringUtils.GTASK_JSON_ENTITY_DELTA, entity);
+
+        } catch (JSONException e) {
+            Log.e(TAG, e.toString());
+            e.printStackTrace();
+            throw new ActionFailureException("fail to generate task-update jsonobject");
+        }
+
+        return js;
+    }
+
+    public void setContentByRemoteJSON(JSONObject js) {
+//这个方法用于根据从远程获取的 JSON 对象设置任务的内容。它接受一个 JSON 对象作为参数，从中提取任务的相关信息，并设置到任务对象的相应属性中。
+        if (js != null) {
+            try {
+                // id
+                if (js.has(GTaskStringUtils.GTASK_JSON_ID)) {
+                    setGid(js.getString(GTaskStringUtils.GTASK_JSON_ID));
+                }
+
+                // last_modified
+                if (js.has(GTaskStringUtils.GTASK_JSON_LAST_MODIFIED)) {
+                    setLastModified(js.getLong(GTaskStringUtils.GTASK_JSON_LAST_MODIFIED));
+                }
+
+                // name
+                if (js.has(GTaskStringUtils.GTASK_JSON_NAME)) {
+                    setName(js.getString(GTaskStringUtils.GTASK_JSON_NAME));
+                }
+
+                // notes
+                if (js.has(GTaskStringUtils.GTASK_JSON_NOTES)) {
+                    setNotes(js.getString(GTaskStringUtils.GTASK_JSON_NOTES));
+                }
+
+                // deleted
+                if (js.has(GTaskStringUtils.GTASK_JSON_DELETED)) {
+                    setDeleted(js.getBoolean(GTaskStringUtils.GTASK_JSON_DELETED));
+                }
+
+                // completed
+                if (js.has(GTaskStringUtils.GTASK_JSON_COMPLETED)) {
+                    setCompleted(js.getBoolean(GTaskStringUtils.GTASK_JSON_COMPLETED));
+                }
+            } catch (JSONException e) {
+                Log.e(TAG, e.toString());
+                e.printStackTrace();
+                throw new ActionFailureException("fail to get task content from jsonobject");
+            }
+        }
+    }
+
+    public void setContentByLocalJSON(JSONObject js) {
+//这个方法用于根据本地的 JSON 对象设置任务的内容。它接受一个 JSON 对象作为参数，从中提取任务的相关信息，并设置到任务对象的相应属性中。
+        if (js == null || !js.has(GTaskStringUtils.META_HEAD_NOTE)
+                || !js.has(GTaskStringUtils.META_HEAD_DATA)) {
+            Log.w(TAG, "setContentByLocalJSON: nothing is avaiable");
+        }
+
+        try {
+            JSONObject note = js.getJSONObject(GTaskStringUtils.META_HEAD_NOTE);
+            JSONArray dataArray = js.getJSONArray(GTaskStringUtils.META_HEAD_DATA);
+
+            if (note.getInt(NoteColumns.TYPE) != Notes.TYPE_NOTE) {
+                Log.e(TAG, "invalid type");
+                return;
+            }
+
+            for (int i = 0; i < dataArray.length(); i++) {
+                JSONObject data = dataArray.getJSONObject(i);
+                if (TextUtils.equals(data.getString(DataColumns.MIME_TYPE), DataConstants.NOTE)) {
+                    setName(data.getString(DataColumns.CONTENT));
+                    break;
+                }
+            }
+
+        } catch (JSONException e) {
+            Log.e(TAG, e.toString());
+            e.printStackTrace();
+        }
+    }
+
+    public JSONObject getLocalJSONFromContent() {
+//这个方法用于根据任务的内容生成本地 JSON 对象。根据任务的元信息和备注信息，它返回一个包含任务内容的 JSON 对象。
+        String name = getName();
+        try {
+            if (mMetaInfo == null) {
+                // new task created from web
+                if (name == null) {
+                    Log.w(TAG, "the note seems to be an empty one");
+                    return null;
+                }
+
+                JSONObject js = new JSONObject();
+                JSONObject note = new JSONObject();
+                JSONArray dataArray = new JSONArray();
+                JSONObject data = new JSONObject();
+                data.put(DataColumns.CONTENT, name);
+                dataArray.put(data);
+                js.put(GTaskStringUtils.META_HEAD_DATA, dataArray);
+                note.put(NoteColumns.TYPE, Notes.TYPE_NOTE);
+                js.put(GTaskStringUtils.META_HEAD_NOTE, note);
+                return js;
+            } else {
+                // synced task
+                JSONObject note = mMetaInfo.getJSONObject(GTaskStringUtils.META_HEAD_NOTE);
+                JSONArray dataArray = mMetaInfo.getJSONArray(GTaskStringUtils.META_HEAD_DATA);
+
+                for (int i = 0; i < dataArray.length(); i++) {
+                    JSONObject data = dataArray.getJSONObject(i);
+                    if (TextUtils.equals(data.getString(DataColumns.MIME_TYPE), DataConstants.NOTE)) {
+                        data.put(DataColumns.CONTENT, getName());
+                        break;
+                    }
+                }
+
+                note.put(NoteColumns.TYPE, Notes.TYPE_NOTE);
+                return mMetaInfo;
+            }
+        } catch (JSONException e) {
+            Log.e(TAG, e.toString());
+            e.printStackTrace();
+            return null;
+        }
+    }
+
+    public void setMetaInfo(MetaData metaData) { 
+//这个方法用于设置任务的元信息。它接受一个 MetaData 对象作为参数，从中提取任务的元信息，并设置到任务对象的 mMetaInfo 属性中。
+        if (metaData != null && metaData.getNotes() != null) {
+            try {
+                mMetaInfo = new JSONObject(metaData.getNotes());
+            } catch (JSONException e) {
+                Log.w(TAG, e.toString());
+                mMetaInfo = null;
+            }
+        }
+    }
+
+    public int getSyncAction(Cursor c) {
+//这个方法用于确定任务的同步操作类型。它接受一个数据库游标作为参数，根据游标中的信息和任务对象的信息，确定需要执行的同步操作类型，并返回相应的整数值。
+        try {
+            JSONObject noteInfo = null;
+            if (mMetaInfo != null && mMetaInfo.has(GTaskStringUtils.META_HEAD_NOTE)) {
+                noteInfo = mMetaInfo.getJSONObject(GTaskStringUtils.META_HEAD_NOTE);
+            }
+
+            if (noteInfo == null) {
+                Log.w(TAG, "it seems that note meta has been deleted");
+                return SYNC_ACTION_UPDATE_REMOTE;
+            }
+
+            if (!noteInfo.has(NoteColumns.ID)) {
+                Log.w(TAG, "remote note id seems to be deleted");
+                return SYNC_ACTION_UPDATE_LOCAL;
+            }
+
+            // validate the note id now
+            if (c.getLong(SqlNote.ID_COLUMN) != noteInfo.getLong(NoteColumns.ID)) {
+                Log.w(TAG, "note id doesn't match");
+                return SYNC_ACTION_UPDATE_LOCAL;
+            }
+
+            if (c.getInt(SqlNote.LOCAL_MODIFIED_COLUMN) == 0) {
+                // there is no local update
+                if (c.getLong(SqlNote.SYNC_ID_COLUMN) == getLastModified()) {
+                    // no update both side
+                    return SYNC_ACTION_NONE;
+                } else {
+                    // apply remote to local
+                    return SYNC_ACTION_UPDATE_LOCAL;
+                }
+            } else {
+                // validate gtask id
+                if (!c.getString(SqlNote.GTASK_ID_COLUMN).equals(getGid())) {
+                    Log.e(TAG, "gtask id doesn't match");
+                    return SYNC_ACTION_ERROR;
+                }
+                if (c.getLong(SqlNote.SYNC_ID_COLUMN) == getLastModified()) {
+                    // local modification only
+                    return SYNC_ACTION_UPDATE_REMOTE;
+                } else {
+                    return SYNC_ACTION_UPDATE_CONFLICT;
+                }
+            }
+        } catch (Exception e) {
+            Log.e(TAG, e.toString());
+            e.printStackTrace();
+        }
+
+        return SYNC_ACTION_ERROR;
+    }
+
+    public boolean isWorthSaving() { 
+//这个方法用于判断任务是否值得保存。如果任务的元信息不为空，或者任务名称和备注信息不为空，则返回 true，表示任务值得保存；否则返回 false。
+        return mMetaInfo != null || (getName() != null && getName().trim().length() > 0)
+                || (getNotes() != null && getNotes().trim().length() > 0);
+    }
+
+    public void setCompleted(boolean completed) { 
+//这个方法用于设置任务的完成状态。它接受一个布尔值作为参数，表示任务是否已完成，并将其设置到任务对象的 mCompleted 属性中。
+        this.mCompleted = completed;
+    }
+
+    public void setNotes(String notes) {
+//这个方法用于设置任务的备注信息。它接受一个字符串作为参数，表示任务的备注信息，并将其设置到任务对象的 mNotes 属性中。
+        this.mNotes = notes;
+    }
+
+    public void setPriorSibling(Task priorSibling) {
+//这个方法用于设置任务的前一个兄弟任务。它接受一个 Task 对象作为参数，表示任务的前一个兄弟任务，并将其设置到任务对象的 mPriorSibling 属性中。
+        this.mPriorSibling = priorSibling;
+    }
+
+    public void setParent(TaskList parent) {
+//这个方法用于设置任务的父任务列表。它接受一个 TaskList 对象作为参数，表示任务的父任务列表，并将其设置到任务对象的 mParent 属性中。
+        this.mParent = parent;
+    }
+
+    public boolean getCompleted() {
+        return this.mCompleted;
+    }
+
+    public String getNotes() {
+        return this.mNotes;
+    }
+
+    public Task getPriorSibling() {
+        return this.mPriorSibling;
+    }
+
+    public TaskList getParent() {
+        return this.mParent;
+    }
+
+}

gtask.data.txt

@@ -0,0 +1,96 @@
+**********************MetaData***********
+/*
+ * Copyright (c) 2010-2011, The MiCode Open Source Community (www.micode.net)
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *        http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package net.micode.notes.gtask.data; //包
+
+//导入所需的类
+import android.database.Cursor;        //处理数据库查询的Cursor类
+import android.util.Log;                      //日志记录类Log
+
+import net.micode.notes.tool.GTaskStringUtils;
+
+import org.json.JSONException;
+import org.json.JSONObject;
+
+
+public class MetaData extends Task    //声明MetaData类，这个类extends了Task类，即继承了Task类的所有属性和方法
+{
+    private final static String TAG = MetaData.class.getSimpleName(); 
+ //定义了一个私有静态常量字符串 TAG，用于标识日志记录的来源。TAG 的值是 MetaData 类的简单名称
+
+    private String mRelatedGid = null;
+ //声明了一个私有字符串变量 mRelatedGid，用于存储关联的 GID（Google 任务 ID）
+
+    public void setMeta(String gid, JSONObject metaInfo) {
+ //定义了一个公共方法 setMeta，接受两个参数：一个字符串 gid 和一个 JSONObject metaInfo
+        try {
+            metaInfo.put(GTaskStringUtils.META_HEAD_GTASK_ID, gid);
+        } catch (JSONException e) {
+            Log.e(TAG, "failed to put related gid");
+        }
+ //通过调用 JSONObject 的 put 方法，将 GID 存储到传入的 metaInfo 中。如果出现 JSON 解析异常，则记录错误日志，failed to put related gid
+
+        setNotes(metaInfo.toString());
+        setName(GTaskStringUtils.META_NOTE_NAME);
+    }
+ //然后，将转换后的 metaInfo 对象转换为字符串，并将其设置为任务的注释（notes），同时设置任务的名称为预定义的 META_NOTE_NAME。
+
+    public String getRelatedGid() {
+        return mRelatedGid;    //定义公共方法 getRelatedGid，用于获取关联的 GID
+    }
+
+    @Override
+    public boolean isWorthSaving() {
+        return getNotes() != null;
+    }
+  //重写了父类的方法 isWorthSaving，用于判断任务是否值得保存。如果任务的注释不为 null，则返回 true
+
+    @Override
+    public void setContentByRemoteJSON(JSONObject js) { 
+ //重写了父类的方法 setContentByRemoteJSON，用于从远程 JSON 数据设置任务的内容
+
+        super.setContentByRemoteJSON(js);   //首先调用父类的方法来设置任务的内容
+        if (getNotes() != null) {
+            try {
+                JSONObject metaInfo = new JSONObject(getNotes().trim());
+                mRelatedGid = metaInfo.getString(GTaskStringUtils.META_HEAD_GTASK_ID);
+            } catch (JSONException e) {
+                Log.w(TAG, "failed to get related gid");
+                mRelatedGid = null;
+            }
+        }  //然后，从任务的注释中提取关联的 GID，如果提取失败则记录警告日志"failed to get related gid"
+    }
+
+    @Override
+    public void setContentByLocalJSON(JSONObject js) {
+        // this function should not be called
+        throw new IllegalAccessError("MetaData:setContentByLocalJSON should not be called");
+    }    
+   //重写了父类的方法 setContentByLocalJSON，但是抛出了一个非法访问错误，表示这个方法不应该被调用
+
+    @Override
+    public JSONObject getLocalJSONFromContent() {
+        throw new IllegalAccessError("MetaData:getLocalJSONFromContent should not be called");
+    }
+//重写了父类的方法 getLocalJSONFromContent，也抛出了一个非法访问错误。
+
+    @Override
+    public int getSyncAction(Cursor c) {
+        throw new IllegalAccessError("MetaData:getSyncAction should not be called");
+    }
+//重写了父类的方法 getSyncAction，同样抛出了一个非法访问错误。
+}

gtasksqlnote.txt

@@ -0,0 +1,674 @@
+//这段代码是一个用于操作笔记数据的类 SqlNote，它包含了对笔记数据进行增、删、改、查等操作的方法
+package net.micode.notes.gtask.data;
+//这是Java代码的包声明，表示该类所在的包路径
+
+import android.appwidget.AppWidgetManager;
+import android.content.ContentResolver;
+import android.content.ContentValues;
+import android.content.Context;
+import android.database.Cursor;
+import android.net.Uri;
+import android.util.Log;
+
+import net.micode.notes.data.Notes;
+import net.micode.notes.data.Notes.DataColumns;
+import net.micode.notes.data.Notes.NoteColumns;
+import net.micode.notes.gtask.exception.ActionFailureException;
+import net.micode.notes.tool.GTaskStringUtils;
+import net.micode.notes.tool.ResourceParser;
+
+import org.json.JSONArray;
+import org.json.JSONException;
+import org.json.JSONObject;
+
+import java.util.ArrayList;
+//这里是导入所需的Android和Java类。
+
+
+public class SqlNote { //定义了一个名为 SqlNote 的Java类，用于操作笔记数据
+    private static final String TAG = SqlNote.class.getSimpleName();
+//定义了一个私有静态常量字符串 TAG，用于在日志中标识类名。
+
+    private static final int INVALID_ID = -99999;
+//定义了一个私有静态常量整数 INVALID_ID，表示无效的笔记ID
+
+    public static final String[] PROJECTION_NOTE = new String[] {
+            NoteColumns.ID, NoteColumns.ALERTED_DATE, NoteColumns.BG_COLOR_ID,
+            NoteColumns.CREATED_DATE, NoteColumns.HAS_ATTACHMENT, NoteColumns.MODIFIED_DATE,
+            NoteColumns.NOTES_COUNT, NoteColumns.PARENT_ID, NoteColumns.SNIPPET, NoteColumns.TYPE,
+            NoteColumns.WIDGET_ID, NoteColumns.WIDGET_TYPE, NoteColumns.SYNC_ID,
+            NoteColumns.LOCAL_MODIFIED, NoteColumns.ORIGIN_PARENT_ID, NoteColumns.GTASK_ID,
+            NoteColumns.VERSION
+    };
+//定义了一个公共静态常量字符串数组 PROJECTION_NOTE，包含了笔记数据表中的各列名。
+
+    public static final int ID_COLUMN = 0; 
+
+    public static final int ALERTED_DATE_COLUMN = 1;
+
+    public static final int BG_COLOR_ID_COLUMN = 2;
+
+    public static final int CREATED_DATE_COLUMN = 3;
+
+    public static final int HAS_ATTACHMENT_COLUMN = 4;
+
+    public static final int MODIFIED_DATE_COLUMN = 5;
+
+    public static final int NOTES_COUNT_COLUMN = 6;
+
+    public static final int PARENT_ID_COLUMN = 7;
+
+    public static final int SNIPPET_COLUMN = 8;
+
+    public static final int TYPE_COLUMN = 9;
+
+    public static final int WIDGET_ID_COLUMN = 10;
+
+    public static final int WIDGET_TYPE_COLUMN = 11;
+
+    public static final int SYNC_ID_COLUMN = 12;
+
+    public static final int LOCAL_MODIFIED_COLUMN = 13;
+
+    public static final int ORIGIN_PARENT_ID_COLUMN = 14;
+
+    public static final int GTASK_ID_COLUMN = 15;
+
+    public static final int VERSION_COLUMN = 16;
+ //定义了一系列公共静态常量整数，用于表示 PROJECTION_NOTE 中各列的索引。
+
+    private Context mContext;
+
+    private ContentResolver mContentResolver;
+
+    private boolean mIsCreate;
+
+    private long mId;
+
+    private long mAlertDate;
+
+    private int mBgColorId;
+
+    private long mCreatedDate;
+
+    private int mHasAttachment;
+
+    private long mModifiedDate;
+
+    private long mParentId;
+
+    private String mSnippet;
+
+    private int mType;
+
+    private int mWidgetId;
+
+    private int mWidgetType;
+
+    private long mOriginParent;
+
+    private long mVersion;
+
+    private ContentValues mDiffNoteValues;
+
+    private ArrayList<SqlData> mDataList;
+//这段代码定义了 SqlNote 类中的一系列私有成员变量，用于存储笔记的各种属性和状态信息。
+
+mContext: 用于存储上下文对象。
+mContentResolver: 用于访问内容提供者，进行数据库操作。
+mIsCreate: 标识当前笔记是否为新创建的。
+mId: 笔记的ID。
+mAlertDate: 提醒日期。
+mBgColorId: 背景颜色ID。
+mCreatedDate: 创建日期。
+mHasAttachment: 是否有附件。
+mModifiedDate: 修改日期。
+mParentId: 父笔记ID。
+mSnippet: 笔记摘要。
+mType: 笔记类型。
+mWidgetId: 小部件ID。
+mWidgetType: 小部件类型。
+mOriginParent: 原始父笔记ID。
+mVersion: 笔记版本。
+mDiffNoteValues: 用于存储笔记属性变化的 ContentValues 对象。
+mDataList: 存储笔记的数据内容。
+
+    public SqlNote(Context context) {  //这是 SqlNote 类的构造函数，接受一个 Context 对象作为参数，在构造对象时初始化成员变量。
+        mContext = context;
+        mContentResolver = context.getContentResolver();
+        mIsCreate = true;
+        mId = INVALID_ID;
+        mAlertDate = 0;
+        mBgColorId = ResourceParser.getDefaultBgId(context);
+        mCreatedDate = System.currentTimeMillis();
+        mHasAttachment = 0;
+        mModifiedDate = System.currentTimeMillis();
+        mParentId = 0;
+        mSnippet = "";
+        mType = Notes.TYPE_NOTE;
+        mWidgetId = AppWidgetManager.INVALID_APPWIDGET_ID;
+        mWidgetType = Notes.TYPE_WIDGET_INVALIDE;
+        mOriginParent = 0;
+        mVersion = 0;
+        mDiffNoteValues = new ContentValues();
+        mDataList = new ArrayList<SqlData>();
+    }
+
+    public SqlNote(Context context, Cursor c) {  //这是另一个构造函数，接受一个 Context 对象和一个 Cursor 对象作为参数，从游标中加载笔记信息。
+        mContext = context;
+        mContentResolver = context.getContentResolver();
+        mIsCreate = false;
+        loadFromCursor(c);
+        mDataList = new ArrayList<SqlData>();
+        if (mType == Notes.TYPE_NOTE)
+            loadDataContent();
+        mDiffNoteValues = new ContentValues();
+    }
+
+    public SqlNote(Context context, long id) {  //这是第三个构造函数，接受一个 Context 对象和一个笔记ID作为参数，从数据库中加载指定ID的笔记信息。
+        mContext = context;
+        mContentResolver = context.getContentResolver();
+        mIsCreate = false;
+        loadFromCursor(id);
+        mDataList = new ArrayList<SqlData>();
+        if (mType == Notes.TYPE_NOTE)
+            loadDataContent();
+        mDiffNoteValues = new ContentValues();
+
+    }
+
+    private void loadFromCursor(long id) {  //这是一个私有方法，用于从数据库中加载指定ID的笔记信息。
+        Cursor c = null;
+        try {
+            c = mContentResolver.query(Notes.CONTENT_NOTE_URI, PROJECTION_NOTE, "(_id=?)",
+                    new String[] {
+                        String.valueOf(id)
+                    }, null);
+            if (c != null) {
+                c.moveToNext();
+                loadFromCursor(c);
+            } else {
+                Log.w(TAG, "loadFromCursor: cursor = null");
+            }
+        } finally {
+            if (c != null)
+                c.close();
+        }
+    }
+
+    private void loadFromCursor(Cursor c) {  //这是另一个私有方法，用于从游标中加载笔记信息。
+        mId = c.getLong(ID_COLUMN);
+        mAlertDate = c.getLong(ALERTED_DATE_COLUMN);
+        mBgColorId = c.getInt(BG_COLOR_ID_COLUMN);
+        mCreatedDate = c.getLong(CREATED_DATE_COLUMN);
+        mHasAttachment = c.getInt(HAS_ATTACHMENT_COLUMN);
+        mModifiedDate = c.getLong(MODIFIED_DATE_COLUMN);
+        mParentId = c.getLong(PARENT_ID_COLUMN);
+        mSnippet = c.getString(SNIPPET_COLUMN);
+        mType = c.getInt(TYPE_COLUMN);
+        mWidgetId = c.getInt(WIDGET_ID_COLUMN);
+        mWidgetType = c.getInt(WIDGET_TYPE_COLUMN);
+        mVersion = c.getLong(VERSION_COLUMN);
+    }
+
+    private void loadDataContent() {   //这是一个私有方法，用于加载笔记的数据内容。
+        Cursor c = null;
+        mDataList.clear();
+        try {
+            c = mContentResolver.query(Notes.CONTENT_DATA_URI, SqlData.PROJECTION_DATA,
+                    "(note_id=?)", new String[] {
+                        String.valueOf(mId)
+                    }, null);
+            if (c != null) {
+                if (c.getCount() == 0) {
+                    Log.w(TAG, "it seems that the note has not data");
+                    return;
+                }
+                while (c.moveToNext()) {
+                    SqlData data = new SqlData(mContext, c);
+                    mDataList.add(data);
+                }
+            } else {
+                Log.w(TAG, "loadDataContent: cursor = null");
+            }
+        } finally {
+            if (c != null)
+                c.close();
+        }
+    }
+
+    public boolean setContent(JSONObject js) {  //这是一个公共方法，用于设置笔记的内容，接受一个 JSONObject 对象作为参数，从中解析出笔记信息。
+        try {
+            JSONObject note = js.getJSONObject(GTaskStringUtils.META_HEAD_NOTE);
+            if (note.getInt(NoteColumns.TYPE) == Notes.TYPE_SYSTEM) {
+                Log.w(TAG, "cannot set system folder");
+            } else if (note.getInt(NoteColumns.TYPE) == Notes.TYPE_FOLDER) {
+                // for folder we can only update the snnipet and type
+                String snippet = note.has(NoteColumns.SNIPPET) ? note
+                        .getString(NoteColumns.SNIPPET) : "";
+                if (mIsCreate || !mSnippet.equals(snippet)) {
+                    mDiffNoteValues.put(NoteColumns.SNIPPET, snippet);
+                }
+                mSnippet = snippet;
+
+                int type = note.has(NoteColumns.TYPE) ? note.getInt(NoteColumns.TYPE)
+                        : Notes.TYPE_NOTE;
+                if (mIsCreate || mType != type) {
+                    mDiffNoteValues.put(NoteColumns.TYPE, type);
+                }
+                mType = type;
+            } else if (note.getInt(NoteColumns.TYPE) == Notes.TYPE_NOTE) {
+                JSONArray dataArray = js.getJSONArray(GTaskStringUtils.META_HEAD_DATA);
+                long id = note.has(NoteColumns.ID) ? note.getLong(NoteColumns.ID) : INVALID_ID;
+                if (mIsCreate || mId != id) {
+                    mDiffNoteValues.put(NoteColumns.ID, id);
+                }
+                mId = id;
+
+                long alertDate = note.has(NoteColumns.ALERTED_DATE) ? note
+                        .getLong(NoteColumns.ALERTED_DATE) : 0;
+                if (mIsCreate || mAlertDate != alertDate) {
+                    mDiffNoteValues.put(NoteColumns.ALERTED_DATE, alertDate);
+                }
+                mAlertDate = alertDate;
+
+                int bgColorId = note.has(NoteColumns.BG_COLOR_ID) ? note
+                        .getInt(NoteColumns.BG_COLOR_ID) : ResourceParser.getDefaultBgId(mContext);
+                if (mIsCreate || mBgColorId != bgColorId) {
+                    mDiffNoteValues.put(NoteColumns.BG_COLOR_ID, bgColorId);
+                }
+                mBgColorId = bgColorId;
+
+                long createDate = note.has(NoteColumns.CREATED_DATE) ? note
+                        .getLong(NoteColumns.CREATED_DATE) : System.currentTimeMillis();
+                if (mIsCreate || mCreatedDate != createDate) {
+                    mDiffNoteValues.put(NoteColumns.CREATED_DATE, createDate);
+                }
+                mCreatedDate = createDate;
+
+                int hasAttachment = note.has(NoteColumns.HAS_ATTACHMENT) ? note
+                        .getInt(NoteColumns.HAS_ATTACHMENT) : 0;
+                if (mIsCreate || mHasAttachment != hasAttachment) {
+                    mDiffNoteValues.put(NoteColumns.HAS_ATTACHMENT, hasAttachment);
+                }
+                mHasAttachment = hasAttachment;
+
+                long modifiedDate = note.has(NoteColumns.MODIFIED_DATE) ? note
+                        .getLong(NoteColumns.MODIFIED_DATE) : System.currentTimeMillis();
+                if (mIsCreate || mModifiedDate != modifiedDate) {
+                    mDiffNoteValues.put(NoteColumns.MODIFIED_DATE, modifiedDate);
+                }
+                mModifiedDate = modifiedDate;
+
+                long parentId = note.has(NoteColumns.PARENT_ID) ? note
+                        .getLong(NoteColumns.PARENT_ID) : 0;
+                if (mIsCreate || mParentId != parentId) {
+                    mDiffNoteValues.put(NoteColumns.PARENT_ID, parentId);
+                }
+                mParentId = parentId;
+
+                String snippet = note.has(NoteColumns.SNIPPET) ? note
+                        .getString(NoteColumns.SNIPPET) : "";
+                if (mIsCreate || !mSnippet.equals(snippet)) {
+                    mDiffNoteValues.put(NoteColumns.SNIPPET, snippet);
+                }
+                mSnippet = snippet;
+
+                int type = note.has(NoteColumns.TYPE) ? note.getInt(NoteColumns.TYPE)
+                        : Notes.TYPE_NOTE;
+                if (mIsCreate || mType != type) {
+                    mDiffNoteValues.put(NoteColumns.TYPE, type);
+                }
+                mType = type;
+
+                int widgetId = note.has(NoteColumns.WIDGET_ID) ? note.getInt(NoteColumns.WIDGET_ID)
+                        : AppWidgetManager.INVALID_APPWIDGET_ID;
+                if (mIsCreate || mWidgetId != widgetId) {
+                    mDiffNoteValues.put(NoteColumns.WIDGET_ID, widgetId);
+                }
+                mWidgetId = widgetId;
+
+                int widgetType = note.has(NoteColumns.WIDGET_TYPE) ? note
+                        .getInt(NoteColumns.WIDGET_TYPE) : Notes.TYPE_WIDGET_INVALIDE;
+                if (mIsCreate || mWidgetType != widgetType) {
+                    mDiffNoteValues.put(NoteColumns.WIDGET_TYPE, widgetType);
+                }
+                mWidgetType = widgetType;
+
+                long originParent = note.has(NoteColumns.ORIGIN_PARENT_ID) ? note
+                        .getLong(NoteColumns.ORIGIN_PARENT_ID) : 0;
+                if (mIsCreate || mOriginParent != originParent) {
+                    mDiffNoteValues.put(NoteColumns.ORIGIN_PARENT_ID, originParent);
+                }
+                mOriginParent = originParent;
+
+                for (int i = 0; i < dataArray.length(); i++) {
+                    JSONObject data = dataArray.getJSONObject(i);
+                    SqlData sqlData = null;
+                    if (data.has(DataColumns.ID)) {
+                        long dataId = data.getLong(DataColumns.ID);
+                        for (SqlData temp : mDataList) {
+                            if (dataId == temp.getId()) {
+                                sqlData = temp;
+                            }
+                        }
+                    }
+
+                    if (sqlData == null) {
+                        sqlData = new SqlData(mContext);
+                        mDataList.add(sqlData);
+                    }
+
+                    sqlData.setContent(data);
+                }
+            }
+        } catch (JSONException e) {
+            Log.e(TAG, e.toString());
+            e.printStackTrace();
+            return false;
+        }
+        return true;
+    }
+
+    public JSONObject getContent() {  这是一个公共方法，用于获取笔记的内容，返回一个 JSONObject 对象，其中包含了笔记的各种属性信息。
+        try {
+            JSONObject js = new JSONObject();
+
+            if (mIsCreate) {
+                Log.e(TAG, "it seems that we haven't created this in database yet");
+                return null;
+            }
+
+            JSONObject note = new JSONObject();
+            if (mType == Notes.TYPE_NOTE) {
+                note.put(NoteColumns.ID, mId);
+                note.put(NoteColumns.ALERTED_DATE, mAlertDate);
+                note.put(NoteColumns.BG_COLOR_ID, mBgColorId);
+                note.put(NoteColumns.CREATED_DATE, mCreatedDate);
+                note.put(NoteColumns.HAS_ATTACHMENT, mHasAttachment);
+                note.put(NoteColumns.MODIFIED_DATE, mModifiedDate);
+                note.put(NoteColumns.PARENT_ID, mParentId);
+                note.put(NoteColumns.SNIPPET, mSnippet);
+                note.put(NoteColumns.TYPE, mType);
+                note.put(NoteColumns.WIDGET_ID, mWidgetId);
+                note.put(NoteColumns.WIDGET_TYPE, mWidgetType);
+                note.put(NoteColumns.ORIGIN_PARENT_ID, mOriginParent);
+                js.put(GTaskStringUtils.META_HEAD_NOTE, note);
+
+                JSONArray dataArray = new JSONArray();
+                for (SqlData sqlData : mDataList) {
+                    JSONObject data = sqlData.getContent();
+                    if (data != null) {
+                        dataArray.put(data);
+                    }
+                }
+                js.put(GTaskStringUtils.META_HEAD_DATA, dataArray);
+            } else if (mType == Notes.TYPE_FOLDER || mType == Notes.TYPE_SYSTEM) {
+                note.put(NoteColumns.ID, mId);
+                note.put(NoteColumns.TYPE, mType);
+                note.put(NoteColumns.SNIPPET, mSnippet);
+                js.put(GTaskStringUtils.META_HEAD_NOTE, note);
+            }
+
+            return js;
+        } catch (JSONException e) {
+            Log.e(TAG, e.toString());
+            e.printStackTrace();
+        }
+        return null;
+    }
+
+    public void setParentId(long id) {   //这是一个公共方法，用于设置笔记的父ID。
+        mParentId = id;
+        mDiffNoteValues.put(NoteColumns.PARENT_ID, id);
+    }
+
+    public void setGtaskId(String gid) {  //这是一个公共方法，用于设置GTask的ID。
+        mDiffNoteValues.put(NoteColumns.GTASK_ID, gid);
+    }
+
+    public void setSyncId(long syncId) {  //这是一个公共方法，用于设置同步ID。
+        mDiffNoteValues.put(NoteColumns.SYNC_ID, syncId);
+    }
+
+    public void resetLocalModified() {  //这是一个公共方法，用于重置本地修改。
+        mDiffNoteValues.put(NoteColumns.LOCAL_MODIFIED, 0);
+    }
+
+    public long getId() {  //这是一个公共方法，用于获取笔记ID。
+        return mId;
+    }
+
+    public long getParentId() {  //这是一个公共方法，用于获取笔记的父ID。
+        return mParentId;
+    }
+
+    public String getSnippet() {  //这是一个公共方法，用于获取笔记的摘要
+        return mSnippet;
+    }
+
+    public boolean isNoteType() {  //这是一个公共方法，用于判断笔记是否为笔记类型
+        return mType == Notes.TYPE_NOTE;
+    }
+
+    public void commit(boolean validateVersion) {  //
+java
+Copy code
+private Context mContext;
+private ContentResolver mContentResolver;
+private boolean mIsCreate;
+private long mId;
+private long mAlertDate;
+private int mBgColorId;
+private long mCreatedDate;
+private int mHasAttachment;
+private long mModifiedDate;
+private long mParentId;
+private String mSnippet;
+private int mType;
+private int mWidgetId;
+private int mWidgetType;
+private long mOriginParent;
+private long mVersion;
+private ContentValues mDiffNoteValues;
+private ArrayList<SqlData> mDataList;
+这段代码定义了 SqlNote 类中的一系列私有成员变量，用于存储笔记的各种属性和状态信息。
+
+mContext: 用于存储上下文对象。
+mContentResolver: 用于访问内容提供者，进行数据库操作。
+mIsCreate: 标识当前笔记是否为新创建的。
+mId: 笔记的ID。
+mAlertDate: 提醒日期。
+mBgColorId: 背景颜色ID。
+mCreatedDate: 创建日期。
+mHasAttachment: 是否有附件。
+mModifiedDate: 修改日期。
+mParentId: 父笔记ID。
+mSnippet: 笔记摘要。
+mType: 笔记类型。
+mWidgetId: 小部件ID。
+mWidgetType: 小部件类型。
+mOriginParent: 原始父笔记ID。
+mVersion: 笔记版本。
+mDiffNoteValues: 用于存储笔记属性变化的 ContentValues 对象。
+mDataList: 存储笔记的数据内容。
+java
+Copy code
+public SqlNote(Context context) {
+    // 构造函数，初始化成员变量。
+}
+这是 SqlNote 类的构造函数，接受一个 Context 对象作为参数，在构造对象时初始化成员变量。
+
+java
+Copy code
+public SqlNote(Context context, Cursor c) {
+    // 另一个构造函数，接受上下文对象和一个游标对象作为参数，从游标中加载笔记信息。
+}
+这是另一个构造函数，接受一个 Context 对象和一个 Cursor 对象作为参数，从游标中加载笔记信息。
+
+java
+Copy code
+public SqlNote(Context context, long id) {
+    // 第三个构造函数，接受上下文对象和笔记ID作为参数，从数据库中加载指定ID的笔记信息。
+}
+这是第三个构造函数，接受一个 Context 对象和一个笔记ID作为参数，从数据库中加载指定ID的笔记信息。
+
+java
+Copy code
+private void loadFromCursor(long id) {
+    // 从数据库中加载指定ID的笔记信息。
+}
+这是一个私有方法，用于从数据库中加载指定ID的笔记信息。
+
+java
+Copy code
+private void loadFromCursor(Cursor c) {
+    // 从游标中加载笔记信息。
+}
+这是另一个私有方法，用于从游标中加载笔记信息。
+
+java
+Copy code
+private void loadDataContent() {
+    // 加载笔记的数据内容。
+}
+这是一个私有方法，用于加载笔记的数据内容。
+
+java
+Copy code
+public boolean setContent(JSONObject js) {
+    // 设置笔记内容。
+}
+这是一个公共方法，用于设置笔记的内容，接受一个 JSONObject 对象作为参数，从中解析出笔记信息。
+
+java
+Copy code
+public JSONObject getContent() {
+    // 获取笔记内容。
+}
+这是一个公共方法，用于获取笔记的内容，返回一个 JSONObject 对象，其中包含了笔记的各种属性信息。
+
+java
+Copy code
+public void setParentId(long id) {
+    // 设置笔记的父ID。
+}
+这是一个公共方法，用于设置笔记的父ID。
+
+java
+Copy code
+public void setGtaskId(String gid) {
+    // 设置GTask ID。
+}
+这是一个公共方法，用于设置GTask的ID。
+
+java
+Copy code
+public void setSyncId(long syncId) {
+    // 设置同步ID。
+}
+这是一个公共方法，用于设置同步ID。
+
+java
+Copy code
+public void resetLocalModified() {
+    // 重置本地修改。
+}
+这是一个公共方法，用于重置本地修改。
+
+java
+Copy code
+public long getId() {
+    // 获取笔记ID。
+}
+这是一个公共方法，用于获取笔记ID。
+
+java
+Copy code
+public long getParentId() {
+    // 获取笔记的父ID。
+}
+这是一个公共方法，用于获取笔记的父ID。
+
+java
+Copy code
+public String getSnippet() {
+    // 获取笔记的摘要。
+}
+这是一个公共方法，用于获取笔记的摘要。
+
+java
+Copy code
+public boolean isNoteType() {
+    // 判断是否为笔记类型。
+}
+这是一个公共方法，用于判断笔记是否为笔记类型。
+
+java
+Copy code
+public void commit(boolean validateVersion) {
+    // 提交笔记。
+}
+这是一个公共方法，用于提交笔记的更改。
+        if (mIsCreate) {
+            if (mId == INVALID_ID && mDiffNoteValues.containsKey(NoteColumns.ID)) {
+                mDiffNoteValues.remove(NoteColumns.ID);
+            }
+
+            Uri uri = mContentResolver.insert(Notes.CONTENT_NOTE_URI, mDiffNoteValues);
+            try {
+                mId = Long.valueOf(uri.getPathSegments().get(1));
+            } catch (NumberFormatException e) {
+                Log.e(TAG, "Get note id error :" + e.toString());
+                throw new ActionFailureException("create note failed");
+            }
+            if (mId == 0) {
+                throw new IllegalStateException("Create thread id failed");
+            }
+
+            if (mType == Notes.TYPE_NOTE) {
+                for (SqlData sqlData : mDataList) {
+                    sqlData.commit(mId, false, -1);
+                }
+            }
+        } else {
+            if (mId <= 0 && mId != Notes.ID_ROOT_FOLDER && mId != Notes.ID_CALL_RECORD_FOLDER) {
+                Log.e(TAG, "No such note");
+                throw new IllegalStateException("Try to update note with invalid id");
+            }
+            if (mDiffNoteValues.size() > 0) {
+                mVersion ++;
+                int result = 0;
+                if (!validateVersion) {
+                    result = mContentResolver.update(Notes.CONTENT_NOTE_URI, mDiffNoteValues, "("
+                            + NoteColumns.ID + "=?)", new String[] {
+                        String.valueOf(mId)
+                    });
+                } else {
+                    result = mContentResolver.update(Notes.CONTENT_NOTE_URI, mDiffNoteValues, "("
+                            + NoteColumns.ID + "=?) AND (" + NoteColumns.VERSION + "<=?)",
+                            new String[] {
+                                    String.valueOf(mId), String.valueOf(mVersion)
+                            });
+                }
+                if (result == 0) {
+                    Log.w(TAG, "there is no update. maybe user updates note when syncing");
+                }
+            }
+
+            if (mType == Notes.TYPE_NOTE) {
+                for (SqlData sqlData : mDataList) {
+                    sqlData.commit(mId, validateVersion, mVersion);
+                }
+            }
+        }
+
+        // refresh local info
+        loadFromCursor(mId);
+        if (mType == Notes.TYPE_NOTE)
+            loadDataContent();
+
+        mDiffNoteValues.clear();
+        mIsCreate = false;
+    }
+//以上这些是 SqlNote 类的主要方法和成员变量，它们组成了对笔记数据进行操作和管理的功能。

小米标签及案例/源程序代码-小米便签-Notes-master/1_tu/untitled

@@ -1 +0,0 @@
-Subproject commit f965e1a75d1f90ea64340ae6c4276571c0710940

小米标签及案例/源程序代码-小米便签-Notes-master/Notes-master/Notes-master.iml

@@ -8,7 +8,4 @@
     <orderEntry type="inheritedJdk" />
     <orderEntry type="sourceFolder" forTests="false" />
   </component>
-  <component name="SonarLintModuleSettings">
-    <option name="uniqueId" value="2a5a6da1-3c6a-4858-a781-ab7547af5410" />
-  </component>
 </module>

小米标签及案例/源程序代码-小米便签-Notes-master/Notes-master/src/net/micode/notes/data/Contact.java

@@ -14,11 +14,10 @@
  * limitations under the License.
  */
 
-package net.micode.notes.data;//包
+package net.micode.notes.data;
 
-//导入所需的类
-import android.database.Cursor;        //处理数据库查询的Cursor类
-import android.util.Log;                      //日志记录类Log
+import android.content.Context;
+import android.database.Cursor;
 import android.provider.ContactsContract.CommonDataKinds.Phone;
 import android.provider.ContactsContract.Data;
 import android.telephony.PhoneNumberUtils;
@@ -27,9 +26,6 @@ import android.util.Log;
 import java.util.HashMap;
 
 public class Contact {
-    private Contact() {
-        throw new IllegalStateException("Utility class");
-    }
 
     // 缓存联系人信息，键为电话号码，值为联系人姓名
     private static HashMap<String, String> sContactCache;
@@ -49,7 +45,7 @@ public class Contact {
 
         // 如果联系人缓存为空，进行初始化
         if(sContactCache == null) {
-            sContactCache = new HashMap<>();
+            sContactCache = new HashMap<String, String>();
         }
 
         // 如果缓存中已包含该电话号码对应的联系人姓名，则直接返回姓名

小米标签及案例/源程序代码-小米便签-Notes-master/Notes-master/src/net/micode/notes/data/Contact_0_getContact_calls.puml

@@ -1,123 +0,0 @@
-@startuml
-
-/' diagram meta data start
-config=CallConfiguration;
-{
-  "rootMethod": "net.micode.notes.data.Contact#getContact(Context,String)",
-  "projectClassification": {
-    "searchMode": "OpenProject", // OpenProject, AllProjects
-    "includedProjects": "",
-    "pathEndKeywords": "*.impl",
-    "isClientPath": "",
-    "isClientName": "",
-    "isTestPath": "",
-    "isTestName": "",
-    "isMappingPath": "",
-    "isMappingName": "",
-    "isDataAccessPath": "",
-    "isDataAccessName": "",
-    "isDataStructurePath": "",
-    "isDataStructureName": "",
-    "isInterfaceStructuresPath": "",
-    "isInterfaceStructuresName": "",
-    "isEntryPointPath": "",
-    "isEntryPointName": "",
-    "treatFinalFieldsAsMandatory": false
-  },
-  "graphRestriction": {
-    "classPackageExcludeFilter": "",
-    "classPackageIncludeFilter": "",
-    "classNameExcludeFilter": "",
-    "classNameIncludeFilter": "",
-    "methodNameExcludeFilter": "",
-    "methodNameIncludeFilter": "",
-    "removeByInheritance": "", // inheritance/annotation based filtering is done in a second step
-    "removeByAnnotation": "",
-    "removeByClassPackage": "", // cleanup the graph after inheritance/annotation based filtering is done
-    "removeByClassName": "",
-    "cutMappings": false,
-    "cutEnum": true,
-    "cutTests": true,
-    "cutClient": true,
-    "cutDataAccess": true,
-    "cutInterfaceStructures": true,
-    "cutDataStructures": true,
-    "cutGetterAndSetter": true,
-    "cutConstructors": true
-  },
-  "graphTraversal": {
-    "forwardDepth": 3,
-    "backwardDepth": 3,
-    "classPackageExcludeFilter": "",
-    "classPackageIncludeFilter": "",
-    "classNameExcludeFilter": "",
-    "classNameIncludeFilter": "",
-    "methodNameExcludeFilter": "",
-    "methodNameIncludeFilter": "",
-    "hideMappings": false,
-    "hideDataStructures": false,
-    "hidePrivateMethods": true,
-    "hideInterfaceCalls": true, // indirection: implementation -> interface (is hidden) -> implementation
-    "onlyShowApplicationEntryPoints": false, // root node is included
-    "useMethodCallsForStructureDiagram": "ForwardOnly" // ForwardOnly, BothDirections, No
-  },
-  "details": {
-    "aggregation": "GroupByClass", // ByClass, GroupByClass, None
-    "showMethodParametersTypes": false,
-    "showMethodParametersNames": false,
-    "showMethodReturnType": false,
-    "showPackageLevels": 2,
-    "showCallOrder": false,
-    "edgeMode": "MethodsOnly", // TypesOnly, MethodsOnly, TypesAndMethods, MethodsAndDirectTypeUsage
-    "showDetailedClassStructure": false
-  },
-  "rootClass": "net.micode.notes.data.Contact",
-  "extensionCallbackMethod": "" // qualified.class.name#methodName - signature: public static String method(String)
-}
-diagram meta data end '/
-
-
-
-digraph g {
-    rankdir="LR"
-    splines=polyline
-    
-
-'nodes 
-subgraph cluster_1074360951 { 
-   	label=micode
-	labeljust=l
-	fillcolor="#ececec"
-	style=filled
-   
-   subgraph cluster_502284772 { 
-   	label=notes
-	labeljust=l
-	fillcolor="#d8d8d8"
-	style=filled
-   
-   subgraph cluster_67220675 { 
-   	label=Contact
-	labeljust=l
-	fillcolor=white
-	style=filled
-   
-   Contact896280021XXXgetContact406701772[
-	label="+ getContact()"
-	style=filled
-	fillcolor=white
-	tooltip="Contact
-
-null"
-	penwidth=4
-	fontcolor=darkgreen
-];
-} 
-} 
-} 
-
-'edges    
-
-    
-}
-@enduml

小米标签及案例/源程序代码-小米便签-Notes-master/Notes-master/src/net/micode/notes/data/Contact_structure.puml

@@ -1,116 +0,0 @@
-@startuml
-
-/' diagram meta data start
-config=StructureConfiguration;
-{
-  "projectClassification": {
-    "searchMode": "OpenProject", // OpenProject, AllProjects
-    "includedProjects": "",
-    "pathEndKeywords": "*.impl",
-    "isClientPath": "",
-    "isClientName": "",
-    "isTestPath": "",
-    "isTestName": "",
-    "isMappingPath": "",
-    "isMappingName": "",
-    "isDataAccessPath": "",
-    "isDataAccessName": "",
-    "isDataStructurePath": "",
-    "isDataStructureName": "",
-    "isInterfaceStructuresPath": "",
-    "isInterfaceStructuresName": "",
-    "isEntryPointPath": "",
-    "isEntryPointName": "",
-    "treatFinalFieldsAsMandatory": false
-  },
-  "graphRestriction": {
-    "classPackageExcludeFilter": "",
-    "classPackageIncludeFilter": "",
-    "classNameExcludeFilter": "",
-    "classNameIncludeFilter": "",
-    "methodNameExcludeFilter": "",
-    "methodNameIncludeFilter": "",
-    "removeByInheritance": "", // inheritance/annotation based filtering is done in a second step
-    "removeByAnnotation": "",
-    "removeByClassPackage": "", // cleanup the graph after inheritance/annotation based filtering is done
-    "removeByClassName": "",
-    "cutMappings": false,
-    "cutEnum": true,
-    "cutTests": true,
-    "cutClient": true,
-    "cutDataAccess": false,
-    "cutInterfaceStructures": false,
-    "cutDataStructures": false,
-    "cutGetterAndSetter": true,
-    "cutConstructors": true
-  },
-  "graphTraversal": {
-    "forwardDepth": 6,
-    "backwardDepth": 6,
-    "classPackageExcludeFilter": "",
-    "classPackageIncludeFilter": "",
-    "classNameExcludeFilter": "",
-    "classNameIncludeFilter": "",
-    "methodNameExcludeFilter": "",
-    "methodNameIncludeFilter": "",
-    "hideMappings": false,
-    "hideDataStructures": false,
-    "hidePrivateMethods": true,
-    "hideInterfaceCalls": true, // indirection: implementation -> interface (is hidden) -> implementation
-    "onlyShowApplicationEntryPoints": false, // root node is included
-    "useMethodCallsForStructureDiagram": "ForwardOnly" // ForwardOnly, BothDirections, No
-  },
-  "details": {
-    "aggregation": "GroupByClass", // ByClass, GroupByClass, None
-    "showClassGenericTypes": true,
-    "showMethods": true,
-    "showMethodParameterNames": true,
-    "showMethodParameterTypes": true,
-    "showMethodReturnType": true,
-    "showPackageLevels": 2,
-    "showDetailedClassStructure": true
-  },
-  "rootClass": "net.micode.notes.data.Contact",
-  "extensionCallbackMethod": "" // qualified.class.name#methodName - signature: public static String method(String)
-}
-diagram meta data end '/
-
-
-
-digraph g {
-    rankdir="TB"
-    splines=polyline
-    
-
-'nodes 
-subgraph cluster_1074360951 { 
-   	label=micode
-	labeljust=l
-	fillcolor="#ececec"
-	style=filled
-   
-   subgraph cluster_502284772 { 
-   	label=notes
-	labeljust=l
-	fillcolor="#d8d8d8"
-	style=filled
-   
-   Contact896280021[
-	label=<<TABLE BORDER="1" CELLBORDER="0" CELLPADDING="4" CELLSPACING="0">
-<TR><TD ALIGN="LEFT" >(C)Contact</TD></TR>
-<HR/>
-<TR><TD ALIGN="LEFT" >+ getContact(context: Context, phoneNumber: String): String</TD></TR>
-</TABLE>>
-	style=filled
-	margin=0
-	shape=plaintext
-	fillcolor="#FFFFFF"
-];
-} 
-} 
-
-'edges    
-
-    
-}
-@enduml

小米标签及案例/源程序代码-小米便签-Notes-master/Notes-master/src/net/micode/notes/data/Notes.java

@@ -18,8 +18,6 @@ package net.micode.notes.data;
 
 import android.net.Uri;
 
-import java.util.PrimitiveIterator;
-
 // Notes 类中定义了很多常量，这些常量大多是int型和string型
 public class Notes {
     // 权限
@@ -57,9 +55,6 @@ public class Notes {
 
     // 数据类型常量
     public static class DataConstants {
-        private DataConstants() {
-            throw new IllegalStateException("Utility class");
-        }
         public static final String NOTE = TextNote.CONTENT_ITEM_TYPE;
         public static final String CALL_NOTE = CallNote.CONTENT_ITEM_TYPE;
     }
@@ -68,14 +63,14 @@ public class Notes {
     /**
      * Uri to query all notes and folders
      */
-    public static final Uri CONTENT_NOTE_URI = Uri.parse(content + AUTHORITY + "/note");
+    public static final Uri CONTENT_NOTE_URI = Uri.parse("content://" + AUTHORITY + "/note");
 //定义查询便签和文件夹的指针
 
 
     /**
      * Uri to query data
      */
-    public static final Uri CONTENT_DATA_URI = Uri.parse(content + AUTHORITY + "/data");
+    public static final Uri CONTENT_DATA_URI = Uri.parse("content://" + AUTHORITY + "/data");
     //定义查找数据的指针
 
 
@@ -299,9 +294,6 @@ public class Notes {
          * Mode to indicate the text in check list mode or not
          * <P> Type: Integer 1:check list mode 0: normal mode </P>
          */
-        private TextNote() {
-            throw new IllegalStateException("Utility class");
-        }
         // 表示文本为检查列表模式或非检查列表模式的模式
         public static final String MODE = DATA1;
 
@@ -320,9 +312,6 @@ public class Notes {
          * Call date for this record
          * <P> Type: INTEGER (long) </P>
          */
-        private CallNote() {
-            throw new IllegalStateException("Utility class");
-        }
         // 记录的通话日期
         public static final String CALL_DATE = DATA1;
 

小米标签及案例/源程序代码-小米便签-Notes-master/Notes-master/src/net/micode/notes/data/NotesDatabaseHelper_0_NotesDatabaseHelper_calls.puml

@@ -1,140 +0,0 @@
-@startuml
-
-/' diagram meta data start
-config=CallConfiguration;
-{
-  "rootMethod": "net.micode.notes.data.NotesDatabaseHelper#NotesDatabaseHelper(Context)",
-  "projectClassification": {
-    "searchMode": "OpenProject", // OpenProject, AllProjects
-    "includedProjects": "",
-    "pathEndKeywords": "*.impl",
-    "isClientPath": "",
-    "isClientName": "",
-    "isTestPath": "",
-    "isTestName": "",
-    "isMappingPath": "",
-    "isMappingName": "",
-    "isDataAccessPath": "",
-    "isDataAccessName": "",
-    "isDataStructurePath": "",
-    "isDataStructureName": "",
-    "isInterfaceStructuresPath": "",
-    "isInterfaceStructuresName": "",
-    "isEntryPointPath": "",
-    "isEntryPointName": "",
-    "treatFinalFieldsAsMandatory": false
-  },
-  "graphRestriction": {
-    "classPackageExcludeFilter": "",
-    "classPackageIncludeFilter": "",
-    "classNameExcludeFilter": "",
-    "classNameIncludeFilter": "",
-    "methodNameExcludeFilter": "",
-    "methodNameIncludeFilter": "",
-    "removeByInheritance": "", // inheritance/annotation based filtering is done in a second step
-    "removeByAnnotation": "",
-    "removeByClassPackage": "", // cleanup the graph after inheritance/annotation based filtering is done
-    "removeByClassName": "",
-    "cutMappings": false,
-    "cutEnum": true,
-    "cutTests": true,
-    "cutClient": true,
-    "cutDataAccess": true,
-    "cutInterfaceStructures": true,
-    "cutDataStructures": true,
-    "cutGetterAndSetter": true,
-    "cutConstructors": true
-  },
-  "graphTraversal": {
-    "forwardDepth": 3,
-    "backwardDepth": 3,
-    "classPackageExcludeFilter": "",
-    "classPackageIncludeFilter": "",
-    "classNameExcludeFilter": "",
-    "classNameIncludeFilter": "",
-    "methodNameExcludeFilter": "",
-    "methodNameIncludeFilter": "",
-    "hideMappings": false,
-    "hideDataStructures": false,
-    "hidePrivateMethods": true,
-    "hideInterfaceCalls": true, // indirection: implementation -> interface (is hidden) -> implementation
-    "onlyShowApplicationEntryPoints": false, // root node is included
-    "useMethodCallsForStructureDiagram": "ForwardOnly" // ForwardOnly, BothDirections, No
-  },
-  "details": {
-    "aggregation": "GroupByClass", // ByClass, GroupByClass, None
-    "showMethodParametersTypes": false,
-    "showMethodParametersNames": false,
-    "showMethodReturnType": false,
-    "showPackageLevels": 2,
-    "showCallOrder": false,
-    "edgeMode": "MethodsOnly", // TypesOnly, MethodsOnly, TypesAndMethods, MethodsAndDirectTypeUsage
-    "showDetailedClassStructure": false
-  },
-  "rootClass": "net.micode.notes.data.NotesDatabaseHelper",
-  "extensionCallbackMethod": "" // qualified.class.name#methodName - signature: public static String method(String)
-}
-diagram meta data end '/
-
-
-
-digraph g {
-    rankdir="LR"
-    splines=polyline
-    
-
-'nodes 
-subgraph cluster_1074360951 { 
-   	label=micode
-	labeljust=l
-	fillcolor="#ececec"
-	style=filled
-   
-   subgraph cluster_502284772 { 
-   	label=notes
-	labeljust=l
-	fillcolor="#d8d8d8"
-	style=filled
-   
-   subgraph cluster_1870275129 { 
-   	label=NotesDatabaseHelper
-	labeljust=l
-	fillcolor=white
-	style=filled
-   
-   NotesDatabaseHelper896280021XXXNotesDatabaseHelper1678783089[
-	label="+ NotesDatabaseHelper()"
-	style=filled
-	fillcolor=white
-	tooltip="NotesDatabaseHelper
-
-null"
-	penwidth=4
-	fontcolor=darkgreen
-];
-} 
-
-subgraph cluster_298648879 { 
-   	label=NotesProvider
-	labeljust=l
-	fillcolor=white
-	style=filled
-   
-   NotesProvider896280021XXXonCreate0[
-	label="+ onCreate()"
-	style=filled
-	fillcolor=white
-	tooltip="NotesProvider
-
-null"
-	fontcolor=darkgreen
-];
-} 
-} 
-} 
-
-'edges    
-NotesProvider896280021XXXonCreate0 -> NotesDatabaseHelper896280021XXXNotesDatabaseHelper1678783089;
-    
-}
-@enduml

小米标签及案例/源程序代码-小米便签-Notes-master/Notes-master/src/net/micode/notes/data/NotesDatabaseHelper_1_createNoteTable_calls.puml

@@ -1,144 +0,0 @@
-@startuml
-
-/' diagram meta data start
-config=CallConfiguration;
-{
-  "rootMethod": "net.micode.notes.data.NotesDatabaseHelper#createNoteTable(SQLiteDatabase)",
-  "projectClassification": {
-    "searchMode": "OpenProject", // OpenProject, AllProjects
-    "includedProjects": "",
-    "pathEndKeywords": "*.impl",
-    "isClientPath": "",
-    "isClientName": "",
-    "isTestPath": "",
-    "isTestName": "",
-    "isMappingPath": "",
-    "isMappingName": "",
-    "isDataAccessPath": "",
-    "isDataAccessName": "",
-    "isDataStructurePath": "",
-    "isDataStructureName": "",
-    "isInterfaceStructuresPath": "",
-    "isInterfaceStructuresName": "",
-    "isEntryPointPath": "",
-    "isEntryPointName": "",
-    "treatFinalFieldsAsMandatory": false
-  },
-  "graphRestriction": {
-    "classPackageExcludeFilter": "",
-    "classPackageIncludeFilter": "",
-    "classNameExcludeFilter": "",
-    "classNameIncludeFilter": "",
-    "methodNameExcludeFilter": "",
-    "methodNameIncludeFilter": "",
-    "removeByInheritance": "", // inheritance/annotation based filtering is done in a second step
-    "removeByAnnotation": "",
-    "removeByClassPackage": "", // cleanup the graph after inheritance/annotation based filtering is done
-    "removeByClassName": "",
-    "cutMappings": false,
-    "cutEnum": true,
-    "cutTests": true,
-    "cutClient": true,
-    "cutDataAccess": true,
-    "cutInterfaceStructures": true,
-    "cutDataStructures": true,
-    "cutGetterAndSetter": true,
-    "cutConstructors": true
-  },
-  "graphTraversal": {
-    "forwardDepth": 3,
-    "backwardDepth": 3,
-    "classPackageExcludeFilter": "",
-    "classPackageIncludeFilter": "",
-    "classNameExcludeFilter": "",
-    "classNameIncludeFilter": "",
-    "methodNameExcludeFilter": "",
-    "methodNameIncludeFilter": "",
-    "hideMappings": false,
-    "hideDataStructures": false,
-    "hidePrivateMethods": true,
-    "hideInterfaceCalls": true, // indirection: implementation -> interface (is hidden) -> implementation
-    "onlyShowApplicationEntryPoints": false, // root node is included
-    "useMethodCallsForStructureDiagram": "ForwardOnly" // ForwardOnly, BothDirections, No
-  },
-  "details": {
-    "aggregation": "GroupByClass", // ByClass, GroupByClass, None
-    "showMethodParametersTypes": false,
-    "showMethodParametersNames": false,
-    "showMethodReturnType": false,
-    "showPackageLevels": 2,
-    "showCallOrder": false,
-    "edgeMode": "MethodsOnly", // TypesOnly, MethodsOnly, TypesAndMethods, MethodsAndDirectTypeUsage
-    "showDetailedClassStructure": false
-  },
-  "rootClass": "net.micode.notes.data.NotesDatabaseHelper",
-  "extensionCallbackMethod": "" // qualified.class.name#methodName - signature: public static String method(String)
-}
-diagram meta data end '/
-
-
-
-digraph g {
-    rankdir="LR"
-    splines=polyline
-    
-
-'nodes 
-subgraph cluster_1074360951 { 
-   	label=micode
-	labeljust=l
-	fillcolor="#ececec"
-	style=filled
-   
-   subgraph cluster_502284772 { 
-   	label=notes
-	labeljust=l
-	fillcolor="#d8d8d8"
-	style=filled
-   
-   subgraph cluster_1870275129 { 
-   	label=NotesDatabaseHelper
-	labeljust=l
-	fillcolor=white
-	style=filled
-   
-   NotesDatabaseHelper896280021XXXcreateNoteTable1414374969[
-	label="+ createNoteTable()"
-	style=filled
-	fillcolor=white
-	tooltip="NotesDatabaseHelper
-
-null"
-	penwidth=4
-	fontcolor=darkgreen
-];
-
-NotesDatabaseHelper896280021XXXonCreate1414374969[
-	label="+ onCreate()"
-	style=filled
-	fillcolor=white
-	tooltip="NotesDatabaseHelper
-
-null"
-	fontcolor=darkgreen
-];
-
-NotesDatabaseHelper896280021XXXonUpgrade419598823[
-	label="+ onUpgrade()"
-	style=filled
-	fillcolor=white
-	tooltip="NotesDatabaseHelper
-
-null"
-	fontcolor=darkgreen
-];
-} 
-} 
-} 
-
-'edges    
-NotesDatabaseHelper896280021XXXonCreate1414374969 -> NotesDatabaseHelper896280021XXXcreateNoteTable1414374969;
-NotesDatabaseHelper896280021XXXonUpgrade419598823 -> NotesDatabaseHelper896280021XXXcreateNoteTable1414374969;
-    
-}
-@enduml

小米标签及案例/源程序代码-小米便签-Notes-master/Notes-master/src/net/micode/notes/data/NotesDatabaseHelper_2_createDataTable_calls.puml

@@ -1,144 +0,0 @@
-@startuml
-
-/' diagram meta data start
-config=CallConfiguration;
-{
-  "rootMethod": "net.micode.notes.data.NotesDatabaseHelper#createDataTable(SQLiteDatabase)",
-  "projectClassification": {
-    "searchMode": "OpenProject", // OpenProject, AllProjects
-    "includedProjects": "",
-    "pathEndKeywords": "*.impl",
-    "isClientPath": "",
-    "isClientName": "",
-    "isTestPath": "",
-    "isTestName": "",
-    "isMappingPath": "",
-    "isMappingName": "",
-    "isDataAccessPath": "",
-    "isDataAccessName": "",
-    "isDataStructurePath": "",
-    "isDataStructureName": "",
-    "isInterfaceStructuresPath": "",
-    "isInterfaceStructuresName": "",
-    "isEntryPointPath": "",
-    "isEntryPointName": "",
-    "treatFinalFieldsAsMandatory": false
-  },
-  "graphRestriction": {
-    "classPackageExcludeFilter": "",
-    "classPackageIncludeFilter": "",
-    "classNameExcludeFilter": "",
-    "classNameIncludeFilter": "",
-    "methodNameExcludeFilter": "",
-    "methodNameIncludeFilter": "",
-    "removeByInheritance": "", // inheritance/annotation based filtering is done in a second step
-    "removeByAnnotation": "",
-    "removeByClassPackage": "", // cleanup the graph after inheritance/annotation based filtering is done
-    "removeByClassName": "",
-    "cutMappings": false,
-    "cutEnum": true,
-    "cutTests": true,
-    "cutClient": true,
-    "cutDataAccess": true,
-    "cutInterfaceStructures": true,
-    "cutDataStructures": true,
-    "cutGetterAndSetter": true,
-    "cutConstructors": true
-  },
-  "graphTraversal": {
-    "forwardDepth": 3,
-    "backwardDepth": 3,
-    "classPackageExcludeFilter": "",
-    "classPackageIncludeFilter": "",
-    "classNameExcludeFilter": "",
-    "classNameIncludeFilter": "",
-    "methodNameExcludeFilter": "",
-    "methodNameIncludeFilter": "",
-    "hideMappings": false,
-    "hideDataStructures": false,
-    "hidePrivateMethods": true,
-    "hideInterfaceCalls": true, // indirection: implementation -> interface (is hidden) -> implementation
-    "onlyShowApplicationEntryPoints": false, // root node is included
-    "useMethodCallsForStructureDiagram": "ForwardOnly" // ForwardOnly, BothDirections, No
-  },
-  "details": {
-    "aggregation": "GroupByClass", // ByClass, GroupByClass, None
-    "showMethodParametersTypes": false,
-    "showMethodParametersNames": false,
-    "showMethodReturnType": false,
-    "showPackageLevels": 2,
-    "showCallOrder": false,
-    "edgeMode": "MethodsOnly", // TypesOnly, MethodsOnly, TypesAndMethods, MethodsAndDirectTypeUsage
-    "showDetailedClassStructure": false
-  },
-  "rootClass": "net.micode.notes.data.NotesDatabaseHelper",
-  "extensionCallbackMethod": "" // qualified.class.name#methodName - signature: public static String method(String)
-}
-diagram meta data end '/
-
-
-
-digraph g {
-    rankdir="LR"
-    splines=polyline
-    
-
-'nodes 
-subgraph cluster_1074360951 { 
-   	label=micode
-	labeljust=l
-	fillcolor="#ececec"
-	style=filled
-   
-   subgraph cluster_502284772 { 
-   	label=notes
-	labeljust=l
-	fillcolor="#d8d8d8"
-	style=filled
-   
-   subgraph cluster_1870275129 { 
-   	label=NotesDatabaseHelper
-	labeljust=l
-	fillcolor=white
-	style=filled
-   
-   NotesDatabaseHelper896280021XXXcreateDataTable1414374969[
-	label="+ createDataTable()"
-	style=filled
-	fillcolor=white
-	tooltip="NotesDatabaseHelper
-
-null"
-	penwidth=4
-	fontcolor=darkgreen
-];
-
-NotesDatabaseHelper896280021XXXonCreate1414374969[
-	label="+ onCreate()"
-	style=filled
-	fillcolor=white
-	tooltip="NotesDatabaseHelper
-
-null"
-	fontcolor=darkgreen
-];
-
-NotesDatabaseHelper896280021XXXonUpgrade419598823[
-	label="+ onUpgrade()"
-	style=filled
-	fillcolor=white
-	tooltip="NotesDatabaseHelper
-
-null"
-	fontcolor=darkgreen
-];
-} 
-} 
-} 
-
-'edges    
-NotesDatabaseHelper896280021XXXonCreate1414374969 -> NotesDatabaseHelper896280021XXXcreateDataTable1414374969;
-NotesDatabaseHelper896280021XXXonUpgrade419598823 -> NotesDatabaseHelper896280021XXXcreateDataTable1414374969;
-    
-}
-@enduml

小米标签及案例/源程序代码-小米便签-Notes-master/Notes-master/src/net/micode/notes/data/NotesDatabaseHelper_3_onCreate_calls.puml

@@ -1,144 +0,0 @@
-@startuml
-
-/' diagram meta data start
-config=CallConfiguration;
-{
-  "rootMethod": "net.micode.notes.data.NotesDatabaseHelper#onCreate(SQLiteDatabase)",
-  "projectClassification": {
-    "searchMode": "OpenProject", // OpenProject, AllProjects
-    "includedProjects": "",
-    "pathEndKeywords": "*.impl",
-    "isClientPath": "",
-    "isClientName": "",
-    "isTestPath": "",
-    "isTestName": "",
-    "isMappingPath": "",
-    "isMappingName": "",
-    "isDataAccessPath": "",
-    "isDataAccessName": "",
-    "isDataStructurePath": "",
-    "isDataStructureName": "",
-    "isInterfaceStructuresPath": "",
-    "isInterfaceStructuresName": "",
-    "isEntryPointPath": "",
-    "isEntryPointName": "",
-    "treatFinalFieldsAsMandatory": false
-  },
-  "graphRestriction": {
-    "classPackageExcludeFilter": "",
-    "classPackageIncludeFilter": "",
-    "classNameExcludeFilter": "",
-    "classNameIncludeFilter": "",
-    "methodNameExcludeFilter": "",
-    "methodNameIncludeFilter": "",
-    "removeByInheritance": "", // inheritance/annotation based filtering is done in a second step
-    "removeByAnnotation": "",
-    "removeByClassPackage": "", // cleanup the graph after inheritance/annotation based filtering is done
-    "removeByClassName": "",
-    "cutMappings": false,
-    "cutEnum": true,
-    "cutTests": true,
-    "cutClient": true,
-    "cutDataAccess": true,
-    "cutInterfaceStructures": true,
-    "cutDataStructures": true,
-    "cutGetterAndSetter": true,
-    "cutConstructors": true
-  },
-  "graphTraversal": {
-    "forwardDepth": 3,
-    "backwardDepth": 3,
-    "classPackageExcludeFilter": "",
-    "classPackageIncludeFilter": "",
-    "classNameExcludeFilter": "",
-    "classNameIncludeFilter": "",
-    "methodNameExcludeFilter": "",
-    "methodNameIncludeFilter": "",
-    "hideMappings": false,
-    "hideDataStructures": false,
-    "hidePrivateMethods": true,
-    "hideInterfaceCalls": true, // indirection: implementation -> interface (is hidden) -> implementation
-    "onlyShowApplicationEntryPoints": false, // root node is included
-    "useMethodCallsForStructureDiagram": "ForwardOnly" // ForwardOnly, BothDirections, No
-  },
-  "details": {
-    "aggregation": "GroupByClass", // ByClass, GroupByClass, None
-    "showMethodParametersTypes": false,
-    "showMethodParametersNames": false,
-    "showMethodReturnType": false,
-    "showPackageLevels": 2,
-    "showCallOrder": false,
-    "edgeMode": "MethodsOnly", // TypesOnly, MethodsOnly, TypesAndMethods, MethodsAndDirectTypeUsage
-    "showDetailedClassStructure": false
-  },
-  "rootClass": "net.micode.notes.data.NotesDatabaseHelper",
-  "extensionCallbackMethod": "" // qualified.class.name#methodName - signature: public static String method(String)
-}
-diagram meta data end '/
-
-
-
-digraph g {
-    rankdir="LR"
-    splines=polyline
-    
-
-'nodes 
-subgraph cluster_1074360951 { 
-   	label=micode
-	labeljust=l
-	fillcolor="#ececec"
-	style=filled
-   
-   subgraph cluster_502284772 { 
-   	label=notes
-	labeljust=l
-	fillcolor="#d8d8d8"
-	style=filled
-   
-   subgraph cluster_1870275129 { 
-   	label=NotesDatabaseHelper
-	labeljust=l
-	fillcolor=white
-	style=filled
-   
-   NotesDatabaseHelper896280021XXXcreateDataTable1414374969[
-	label="+ createDataTable()"
-	style=filled
-	fillcolor=white
-	tooltip="NotesDatabaseHelper
-
-null"
-	fontcolor=darkgreen
-];
-
-NotesDatabaseHelper896280021XXXcreateNoteTable1414374969[
-	label="+ createNoteTable()"
-	style=filled
-	fillcolor=white
-	tooltip="NotesDatabaseHelper
-
-null"
-	fontcolor=darkgreen
-];
-
-NotesDatabaseHelper896280021XXXonCreate1414374969[
-	label="+ onCreate()"
-	style=filled
-	fillcolor=white
-	tooltip="NotesDatabaseHelper
-
-null"
-	penwidth=4
-	fontcolor=darkgreen
-];
-} 
-} 
-} 
-
-'edges    
-NotesDatabaseHelper896280021XXXonCreate1414374969 -> NotesDatabaseHelper896280021XXXcreateDataTable1414374969;
-NotesDatabaseHelper896280021XXXonCreate1414374969 -> NotesDatabaseHelper896280021XXXcreateNoteTable1414374969;
-    
-}
-@enduml

小米标签及案例/源程序代码-小米便签-Notes-master/Notes-master/src/net/micode/notes/data/NotesDatabaseHelper_4_onUpgrade_calls.puml

@@ -1,144 +0,0 @@
-@startuml
-
-/' diagram meta data start
-config=CallConfiguration;
-{
-  "rootMethod": "net.micode.notes.data.NotesDatabaseHelper#onUpgrade(SQLiteDatabase,int,int)",
-  "projectClassification": {
-    "searchMode": "OpenProject", // OpenProject, AllProjects
-    "includedProjects": "",
-    "pathEndKeywords": "*.impl",
-    "isClientPath": "",
-    "isClientName": "",
-    "isTestPath": "",
-    "isTestName": "",
-    "isMappingPath": "",
-    "isMappingName": "",
-    "isDataAccessPath": "",
-    "isDataAccessName": "",
-    "isDataStructurePath": "",
-    "isDataStructureName": "",
-    "isInterfaceStructuresPath": "",
-    "isInterfaceStructuresName": "",
-    "isEntryPointPath": "",
-    "isEntryPointName": "",
-    "treatFinalFieldsAsMandatory": false
-  },
-  "graphRestriction": {
-    "classPackageExcludeFilter": "",
-    "classPackageIncludeFilter": "",
-    "classNameExcludeFilter": "",
-    "classNameIncludeFilter": "",
-    "methodNameExcludeFilter": "",
-    "methodNameIncludeFilter": "",
-    "removeByInheritance": "", // inheritance/annotation based filtering is done in a second step
-    "removeByAnnotation": "",
-    "removeByClassPackage": "", // cleanup the graph after inheritance/annotation based filtering is done
-    "removeByClassName": "",
-    "cutMappings": false,
-    "cutEnum": true,
-    "cutTests": true,
-    "cutClient": true,
-    "cutDataAccess": true,
-    "cutInterfaceStructures": true,
-    "cutDataStructures": true,
-    "cutGetterAndSetter": true,
-    "cutConstructors": true
-  },
-  "graphTraversal": {
-    "forwardDepth": 3,
-    "backwardDepth": 3,
-    "classPackageExcludeFilter": "",
-    "classPackageIncludeFilter": "",
-    "classNameExcludeFilter": "",
-    "classNameIncludeFilter": "",
-    "methodNameExcludeFilter": "",
-    "methodNameIncludeFilter": "",
-    "hideMappings": false,
-    "hideDataStructures": false,
-    "hidePrivateMethods": true,
-    "hideInterfaceCalls": true, // indirection: implementation -> interface (is hidden) -> implementation
-    "onlyShowApplicationEntryPoints": false, // root node is included
-    "useMethodCallsForStructureDiagram": "ForwardOnly" // ForwardOnly, BothDirections, No
-  },
-  "details": {
-    "aggregation": "GroupByClass", // ByClass, GroupByClass, None
-    "showMethodParametersTypes": false,
-    "showMethodParametersNames": false,
-    "showMethodReturnType": false,
-    "showPackageLevels": 2,
-    "showCallOrder": false,
-    "edgeMode": "MethodsOnly", // TypesOnly, MethodsOnly, TypesAndMethods, MethodsAndDirectTypeUsage
-    "showDetailedClassStructure": false
-  },
-  "rootClass": "net.micode.notes.data.NotesDatabaseHelper",
-  "extensionCallbackMethod": "" // qualified.class.name#methodName - signature: public static String method(String)
-}
-diagram meta data end '/
-
-
-
-digraph g {
-    rankdir="LR"
-    splines=polyline
-    
-
-'nodes 
-subgraph cluster_1074360951 { 
-   	label=micode
-	labeljust=l
-	fillcolor="#ececec"
-	style=filled
-   
-   subgraph cluster_502284772 { 
-   	label=notes
-	labeljust=l
-	fillcolor="#d8d8d8"
-	style=filled
-   
-   subgraph cluster_1870275129 { 
-   	label=NotesDatabaseHelper
-	labeljust=l
-	fillcolor=white
-	style=filled
-   
-   NotesDatabaseHelper896280021XXXcreateDataTable1414374969[
-	label="+ createDataTable()"
-	style=filled
-	fillcolor=white
-	tooltip="NotesDatabaseHelper
-
-null"
-	fontcolor=darkgreen
-];
-
-NotesDatabaseHelper896280021XXXcreateNoteTable1414374969[
-	label="+ createNoteTable()"
-	style=filled
-	fillcolor=white
-	tooltip="NotesDatabaseHelper
-
-null"
-	fontcolor=darkgreen
-];
-
-NotesDatabaseHelper896280021XXXonUpgrade419598823[
-	label="+ onUpgrade()"
-	style=filled
-	fillcolor=white
-	tooltip="NotesDatabaseHelper
-
-null"
-	penwidth=4
-	fontcolor=darkgreen
-];
-} 
-} 
-} 
-
-'edges    
-NotesDatabaseHelper896280021XXXonUpgrade419598823 -> NotesDatabaseHelper896280021XXXcreateDataTable1414374969;
-NotesDatabaseHelper896280021XXXonUpgrade419598823 -> NotesDatabaseHelper896280021XXXcreateNoteTable1414374969;
-    
-}
-@enduml

小米标签及案例/源程序代码-小米便签-Notes-master/Notes-master/src/net/micode/notes/data/NotesDatabaseHelper_onCreate_flow.puml

@@ -1,83 +0,0 @@
-@startuml
-
-/' diagram meta data start
-config=FlowConfiguration;
-{
-  "rootMethod": "net.micode.notes.data.NotesDatabaseHelper#onCreate(SQLiteDatabase)",
-  "projectClassification": {
-    "searchMode": "OpenProject", // OpenProject, AllProjects
-    "includedProjects": "",
-    "pathEndKeywords": "*.impl",
-    "isClientPath": "",
-    "isClientName": "",
-    "isTestPath": "",
-    "isTestName": "",
-    "isMappingPath": "",
-    "isMappingName": "",
-    "isDataAccessPath": "",
-    "isDataAccessName": "",
-    "isDataStructurePath": "",
-    "isDataStructureName": "",
-    "isInterfaceStructuresPath": "",
-    "isInterfaceStructuresName": "",
-    "isEntryPointPath": "",
-    "isEntryPointName": "",
-    "treatFinalFieldsAsMandatory": false
-  },
-  "graphRestriction": {
-    "classPackageExcludeFilter": "",
-    "classPackageIncludeFilter": "",
-    "classNameExcludeFilter": "",
-    "classNameIncludeFilter": "",
-    "methodNameExcludeFilter": "",
-    "methodNameIncludeFilter": "",
-    "removeByInheritance": "", // inheritance/annotation based filtering is done in a second step
-    "removeByAnnotation": "",
-    "removeByClassPackage": "", // cleanup the graph after inheritance/annotation based filtering is done
-    "removeByClassName": "",
-    "cutMappings": false,
-    "cutEnum": false,
-    "cutTests": true,
-    "cutClient": true,
-    "cutDataAccess": false,
-    "cutInterfaceStructures": false,
-    "cutDataStructures": false,
-    "cutGetterAndSetter": false,
-    "cutConstructors": false
-  },
-  "graphTraversal": {
-    "forwardDepth": 999,
-    "backwardDepth": 0,
-    "classPackageExcludeFilter": "",
-    "classPackageIncludeFilter": "",
-    "classNameExcludeFilter": "",
-    "classNameIncludeFilter": "",
-    "methodNameExcludeFilter": "",
-    "methodNameIncludeFilter": "",
-    "hideMappings": false,
-    "hideDataStructures": false,
-    "hidePrivateMethods": false,
-    "hideInterfaceCalls": false, // indirection: implementation -> interface (is hidden) -> implementation
-    "onlyShowApplicationEntryPoints": false, // root node is included
-    "useMethodCallsForStructureDiagram": "ForwardOnly" // ForwardOnly, BothDirections, No
-  },
-  "rootClass": "net.micode.notes.data.NotesDatabaseHelper",
-  "extensionCallbackMethod": "" // qualified.class.name#methodName - signature: public static String method(String)
-}
-diagram meta data end '/
-
-
-
-digraph g {
-    rankdir="TB"
-    splines=polyline
-    
-
-'nodes 
-
-
-'edges    
-
-    
-}
-@enduml

小米标签及案例/源程序代码-小米便签-Notes-master/Notes-master/src/net/micode/notes/data/NotesDatabaseHelper_onUpgrade_flow.puml

@@ -1,83 +0,0 @@
-@startuml
-
-/' diagram meta data start
-config=FlowConfiguration;
-{
-  "rootMethod": "net.micode.notes.data.NotesDatabaseHelper#onUpgrade(SQLiteDatabase,int,int)",
-  "projectClassification": {
-    "searchMode": "OpenProject", // OpenProject, AllProjects
-    "includedProjects": "",
-    "pathEndKeywords": "*.impl",
-    "isClientPath": "",
-    "isClientName": "",
-    "isTestPath": "",
-    "isTestName": "",
-    "isMappingPath": "",
-    "isMappingName": "",
-    "isDataAccessPath": "",
-    "isDataAccessName": "",
-    "isDataStructurePath": "",
-    "isDataStructureName": "",
-    "isInterfaceStructuresPath": "",
-    "isInterfaceStructuresName": "",
-    "isEntryPointPath": "",
-    "isEntryPointName": "",
-    "treatFinalFieldsAsMandatory": false
-  },
-  "graphRestriction": {
-    "classPackageExcludeFilter": "",
-    "classPackageIncludeFilter": "",
-    "classNameExcludeFilter": "",
-    "classNameIncludeFilter": "",
-    "methodNameExcludeFilter": "",
-    "methodNameIncludeFilter": "",
-    "removeByInheritance": "", // inheritance/annotation based filtering is done in a second step
-    "removeByAnnotation": "",
-    "removeByClassPackage": "", // cleanup the graph after inheritance/annotation based filtering is done
-    "removeByClassName": "",
-    "cutMappings": false,
-    "cutEnum": false,
-    "cutTests": true,
-    "cutClient": true,
-    "cutDataAccess": false,
-    "cutInterfaceStructures": false,
-    "cutDataStructures": false,
-    "cutGetterAndSetter": false,
-    "cutConstructors": false
-  },
-  "graphTraversal": {
-    "forwardDepth": 999,
-    "backwardDepth": 0,
-    "classPackageExcludeFilter": "",
-    "classPackageIncludeFilter": "",
-    "classNameExcludeFilter": "",
-    "classNameIncludeFilter": "",
-    "methodNameExcludeFilter": "",
-    "methodNameIncludeFilter": "",
-    "hideMappings": false,
-    "hideDataStructures": false,
-    "hidePrivateMethods": false,
-    "hideInterfaceCalls": false, // indirection: implementation -> interface (is hidden) -> implementation
-    "onlyShowApplicationEntryPoints": false, // root node is included
-    "useMethodCallsForStructureDiagram": "ForwardOnly" // ForwardOnly, BothDirections, No
-  },
-  "rootClass": "net.micode.notes.data.NotesDatabaseHelper",
-  "extensionCallbackMethod": "" // qualified.class.name#methodName - signature: public static String method(String)
-}
-diagram meta data end '/
-
-
-
-digraph g {
-    rankdir="TB"
-    splines=polyline
-    
-
-'nodes 
-
-
-'edges    
-
-    
-}
-@enduml

小米标签及案例/源程序代码-小米便签-Notes-master/Notes-master/src/net/micode/notes/data/NotesDatabaseHelper_structure.puml

@@ -1,148 +0,0 @@
-@startuml
-
-/' diagram meta data start
-config=StructureConfiguration;
-{
-  "projectClassification": {
-    "searchMode": "OpenProject", // OpenProject, AllProjects
-    "includedProjects": "",
-    "pathEndKeywords": "*.impl",
-    "isClientPath": "",
-    "isClientName": "",
-    "isTestPath": "",
-    "isTestName": "",
-    "isMappingPath": "",
-    "isMappingName": "",
-    "isDataAccessPath": "",
-    "isDataAccessName": "",
-    "isDataStructurePath": "",
-    "isDataStructureName": "",
-    "isInterfaceStructuresPath": "",
-    "isInterfaceStructuresName": "",
-    "isEntryPointPath": "",
-    "isEntryPointName": "",
-    "treatFinalFieldsAsMandatory": false
-  },
-  "graphRestriction": {
-    "classPackageExcludeFilter": "",
-    "classPackageIncludeFilter": "",
-    "classNameExcludeFilter": "",
-    "classNameIncludeFilter": "",
-    "methodNameExcludeFilter": "",
-    "methodNameIncludeFilter": "",
-    "removeByInheritance": "", // inheritance/annotation based filtering is done in a second step
-    "removeByAnnotation": "",
-    "removeByClassPackage": "", // cleanup the graph after inheritance/annotation based filtering is done
-    "removeByClassName": "",
-    "cutMappings": false,
-    "cutEnum": true,
-    "cutTests": true,
-    "cutClient": true,
-    "cutDataAccess": false,
-    "cutInterfaceStructures": false,
-    "cutDataStructures": false,
-    "cutGetterAndSetter": true,
-    "cutConstructors": true
-  },
-  "graphTraversal": {
-    "forwardDepth": 6,
-    "backwardDepth": 6,
-    "classPackageExcludeFilter": "",
-    "classPackageIncludeFilter": "",
-    "classNameExcludeFilter": "",
-    "classNameIncludeFilter": "",
-    "methodNameExcludeFilter": "",
-    "methodNameIncludeFilter": "",
-    "hideMappings": false,
-    "hideDataStructures": false,
-    "hidePrivateMethods": true,
-    "hideInterfaceCalls": true, // indirection: implementation -> interface (is hidden) -> implementation
-    "onlyShowApplicationEntryPoints": false, // root node is included
-    "useMethodCallsForStructureDiagram": "ForwardOnly" // ForwardOnly, BothDirections, No
-  },
-  "details": {
-    "aggregation": "GroupByClass", // ByClass, GroupByClass, None
-    "showClassGenericTypes": true,
-    "showMethods": true,
-    "showMethodParameterNames": true,
-    "showMethodParameterTypes": true,
-    "showMethodReturnType": true,
-    "showPackageLevels": 2,
-    "showDetailedClassStructure": true
-  },
-  "rootClass": "net.micode.notes.data.NotesDatabaseHelper",
-  "extensionCallbackMethod": "" // qualified.class.name#methodName - signature: public static String method(String)
-}
-diagram meta data end '/
-
-
-
-digraph g {
-    rankdir="TB"
-    splines=polyline
-    
-
-'nodes 
-subgraph cluster_1074360951 { 
-   	label=micode
-	labeljust=l
-	fillcolor="#ececec"
-	style=filled
-   
-   subgraph cluster_502284772 { 
-   	label=notes
-	labeljust=l
-	fillcolor="#d8d8d8"
-	style=filled
-   
-   NotesDatabaseHelper896280021[
-	label=<<TABLE BORDER="1" CELLBORDER="0" CELLPADDING="4" CELLSPACING="0">
-<TR><TD ALIGN="LEFT" >(C)NotesDatabaseHelper</TD></TR>
-<HR/>
-<TR><TD ALIGN="LEFT" >+ createDataTable(db: SQLiteDatabase)</TD></TR>
-<TR><TD ALIGN="LEFT" >+ createNoteTable(db: SQLiteDatabase)</TD></TR>
-<TR><TD ALIGN="LEFT" >- createSystemFolder(db: SQLiteDatabase)</TD></TR>
-<TR><TD ALIGN="LEFT" ># getInstance(context: Context): NotesDatabaseHelper</TD></TR>
-<TR><TD ALIGN="LEFT" >+ onCreate(db: SQLiteDatabase)</TD></TR>
-<TR><TD ALIGN="LEFT" >+ onUpgrade(db: SQLiteDatabase, oldVersion: int, newVersion: int)</TD></TR>
-<TR><TD ALIGN="LEFT" >- reCreateDataTableTriggers(db: SQLiteDatabase)</TD></TR>
-<TR><TD ALIGN="LEFT" >- reCreateNoteTableTriggers(db: SQLiteDatabase)</TD></TR>
-<TR><TD ALIGN="LEFT" >- upgradeToV2(db: SQLiteDatabase)</TD></TR>
-<TR><TD ALIGN="LEFT" >- upgradeToV3(db: SQLiteDatabase)</TD></TR>
-<TR><TD ALIGN="LEFT" >- upgradeToV4(db: SQLiteDatabase)</TD></TR>
-</TABLE>>
-	style=filled
-	margin=0
-	shape=plaintext
-	fillcolor="#FFFFFF"
-];
-
-NotesProvider896280021[
-	label=<<TABLE BORDER="1" CELLBORDER="0" CELLPADDING="4" CELLSPACING="0">
-<TR><TD ALIGN="LEFT" >(C)NotesProvider</TD></TR>
-<HR/>
-<TR><TD ALIGN="LEFT" >-   mHelper: NotesDatabaseHelper [0..1]</TD></TR>
-<HR/>
-<TR><TD ALIGN="LEFT" >+ delete(uri: Uri, selection: String, selectionArgs: String[]): int</TD></TR>
-<TR><TD ALIGN="LEFT" >+ getType(uri: Uri): String</TD></TR>
-<TR><TD ALIGN="LEFT" >- increaseNoteVersion(id: long, selection: String, selectionArgs: String[])</TD></TR>
-<TR><TD ALIGN="LEFT" >+ insert(uri: Uri, values: ContentValues): Uri</TD></TR>
-<TR><TD ALIGN="LEFT" >+ onCreate(): boolean</TD></TR>
-<TR><TD ALIGN="LEFT" >- parseSelection(selection: String): String</TD></TR>
-<TR><TD ALIGN="LEFT" >+ query(uri: Uri, projection: String[], selection: String, selectionArgs: String[], sortOrder: String): Cursor</TD></TR>
-<TR><TD ALIGN="LEFT" >+ update(uri: Uri, values: ContentValues, selection: String, selectionArgs: String[]): int</TD></TR>
-</TABLE>>
-	style=filled
-	margin=0
-	shape=plaintext
-	fillcolor="#FFFFFF"
-];
-} 
-} 
-
-'edges    
-NotesProvider896280021 -> NotesDatabaseHelper896280021[label="mHelper
-[0..1]"];
-    
-}
-@enduml

小米标签及案例/源程序代码-小米便签-Notes-master/Notes-master/src/net/micode/notes/data/NotesProvider.java

@@ -16,6 +16,7 @@
 
 package net.micode.notes.data;
 
+
 import android.app.SearchManager;
 import android.content.ContentProvider;
 import android.content.ContentUris;
@@ -32,15 +33,9 @@ import net.micode.notes.R;
 import net.micode.notes.data.Notes.DataColumns;
 import net.micode.notes.data.Notes.NoteColumns;
 import net.micode.notes.data.NotesDatabaseHelper.TABLE;
-//为存储和获取数据提供接口。可以在不同的应用程序之间共享数据
-//ContentProvider提供的方法
-//query：查询
-//insert：插入
-//update：更新
-//delete：删除
-//getType：得到数据类型
+
+
 public class NotesProvider extends ContentProvider {
-    // UriMatcher用于匹配Uri
     private static final UriMatcher mMatcher;
 
     private NotesDatabaseHelper mHelper;
@@ -56,9 +51,7 @@ public class NotesProvider extends ContentProvider {
     private static final int URI_SEARCH_SUGGEST  = 6;
 
     static {
-        // 创建UriMatcher时，调用UriMatcher(UriMatcher.NO_MATCH)表示不匹配任何路径的返回码
         mMatcher = new UriMatcher(UriMatcher.NO_MATCH);
-        // 把需要匹配Uri路径全部给注册上
         mMatcher.addURI(Notes.AUTHORITY, "note", URI_NOTE);
         mMatcher.addURI(Notes.AUTHORITY, "note/#", URI_NOTE_ITEM);
         mMatcher.addURI(Notes.AUTHORITY, "data", URI_DATA);
@@ -72,7 +65,6 @@ public class NotesProvider extends ContentProvider {
      * x'0A' represents the '\n' character in sqlite. For title and content in the search result,
      * we will trim '\n' and white space in order to show more information.
      */
-    // 声明 NOTES_SEARCH_PROJECTION
     private static final String NOTES_SEARCH_PROJECTION = NoteColumns.ID + ","
         + NoteColumns.ID + " AS " + SearchManager.SUGGEST_COLUMN_INTENT_EXTRA_DATA + ","
         + "TRIM(REPLACE(" + NoteColumns.SNIPPET + ", x'0A','')) AS " + SearchManager.SUGGEST_COLUMN_TEXT_1 + ","
@@ -80,7 +72,7 @@ public class NotesProvider extends ContentProvider {
         + R.drawable.search_result + " AS " + SearchManager.SUGGEST_COLUMN_ICON_1 + ","
         + "'" + Intent.ACTION_VIEW + "' AS " + SearchManager.SUGGEST_COLUMN_INTENT_ACTION + ","
         + "'" + Notes.TextNote.CONTENT_TYPE + "' AS " + SearchManager.SUGGEST_COLUMN_INTENT_DATA;
-    // 声明NOTES_SNIPPET_SEARCH_QUERY
+
     private static String NOTES_SNIPPET_SEARCH_QUERY = "SELECT " + NOTES_SEARCH_PROJECTION
         + " FROM " + TABLE.NOTE
         + " WHERE " + NoteColumns.SNIPPET + " LIKE ?"
@@ -88,24 +80,18 @@ public class NotesProvider extends ContentProvider {
         + " AND " + NoteColumns.TYPE + "=" + Notes.TYPE_NOTE;
 
     @Override
-    // Context只有在onCreate()中才被初始化
-    // 对mHelper进行实例化
     public boolean onCreate() {
         mHelper = NotesDatabaseHelper.getInstance(getContext());
         return true;
     }
 
     @Override
-    // 查询uri在数据库中对应的位置
     public Cursor query(Uri uri, String[] projection, String selection, String[] selectionArgs,
             String sortOrder) {
         Cursor c = null;
-        // 获取可读数据库
         SQLiteDatabase db = mHelper.getReadableDatabase();
         String id = null;
-        // 匹配查找uri
         switch (mMatcher.match(uri)) {
-            // 对于不同的匹配值，在数据库中查找相应的条目
             case URI_NOTE:
                 c = db.query(TABLE.NOTE, projection, selection, selectionArgs, null, null,
                         sortOrder);
@@ -127,7 +113,6 @@ public class NotesProvider extends ContentProvider {
             case URI_SEARCH:
             case URI_SEARCH_SUGGEST:
                 if (sortOrder != null || projection != null) {
-                    // 不合法的参数异常
                     throw new IllegalArgumentException(
                             "do not specify sortOrder, selection, selectionArgs, or projection" + "with this query");
                 }
@@ -135,8 +120,6 @@ public class NotesProvider extends ContentProvider {
                 String searchString = null;
                 if (mMatcher.match(uri) == URI_SEARCH_SUGGEST) {
                     if (uri.getPathSegments().size() > 1) {
-                        // getPathSegments()方法得到一个String的List，
-                        // 在uri.getPathSegments().get(1)为第2个元素
                         searchString = uri.getPathSegments().get(1);
                     }
                 } else {
@@ -156,7 +139,6 @@ public class NotesProvider extends ContentProvider {
                 }
                 break;
             default:
-                // 抛出异常
                 throw new IllegalArgumentException("Unknown URI " + uri);
         }
         if (c != null) {
@@ -166,17 +148,13 @@ public class NotesProvider extends ContentProvider {
     }
 
     @Override
-    // 插入一个uri
     public Uri insert(Uri uri, ContentValues values) {
-        // 获得可写的数据库
         SQLiteDatabase db = mHelper.getWritableDatabase();
         long dataId = 0, noteId = 0, insertedId = 0;
         switch (mMatcher.match(uri)) {
-            // 新增一个条目
             case URI_NOTE:
                 insertedId = noteId = db.insert(TABLE.NOTE, null, values);
                 break;
-            // 如果存在，查找NOTE_ID
             case URI_DATA:
                 if (values.containsKey(DataColumns.NOTE_ID)) {
                     noteId = values.getAsLong(DataColumns.NOTE_ID);
@@ -189,7 +167,6 @@ public class NotesProvider extends ContentProvider {
                 throw new IllegalArgumentException("Unknown URI " + uri);
         }
         // Notify the note uri
-        // notifyChange获得一个ContextResolver对象并且更新里面的内容
         if (noteId > 0) {
             getContext().getContentResolver().notifyChange(
                     ContentUris.withAppendedId(Notes.CONTENT_NOTE_URI, noteId), null);
@@ -201,17 +178,13 @@ public class NotesProvider extends ContentProvider {
                     ContentUris.withAppendedId(Notes.CONTENT_DATA_URI, dataId), null);
         }
 
-        // 返回插入的uri的路径
         return ContentUris.withAppendedId(uri, insertedId);
     }
 
     @Override
-    // 删除一个uri
     public int delete(Uri uri, String selection, String[] selectionArgs) {
-        //Uri代表要操作的数据，Android上可用的每种资源 -包括 图像、视频片段、音频资源等都可以用Uri来表示。
         int count = 0;
         String id = null;
-        // 获得可写的数据库
         SQLiteDatabase db = mHelper.getWritableDatabase();
         boolean deleteData = false;
         switch (mMatcher.match(uri)) {
@@ -255,7 +228,6 @@ public class NotesProvider extends ContentProvider {
     }
 
     @Override
-    // 更新一个uri
     public int update(Uri uri, ContentValues values, String selection, String[] selectionArgs) {
         int count = 0;
         String id = null;
@@ -295,12 +267,10 @@ public class NotesProvider extends ContentProvider {
         return count;
     }
 
-    // 将字符串解析成规定格式
     private String parseSelection(String selection) {
         return (!TextUtils.isEmpty(selection) ? " AND (" + selection + ')' : "");
     }
 
-    //增加一个noteVersion
     private void increaseNoteVersion(long id, String selection, String[] selectionArgs) {
         StringBuilder sql = new StringBuilder(120);
         sql.append("UPDATE ");
@@ -323,7 +293,6 @@ public class NotesProvider extends ContentProvider {
             sql.append(selectString);
         }
 
-        // execSQL()方法可以执行insert、delete、update和CREATE TABLE之类有更改行为的SQL语句
         mHelper.getWritableDatabase().execSQL(sql.toString());
     }
 

小米标签及案例/源程序代码-小米便签-Notes-master/Notes-master/src/net/micode/notes/data/NotesProvider_0_onCreate_calls.puml

@@ -1,123 +0,0 @@
-@startuml
-
-/' diagram meta data start
-config=CallConfiguration;
-{
-  "rootMethod": "net.micode.notes.data.NotesProvider#onCreate()",
-  "projectClassification": {
-    "searchMode": "OpenProject", // OpenProject, AllProjects
-    "includedProjects": "",
-    "pathEndKeywords": "*.impl",
-    "isClientPath": "",
-    "isClientName": "",
-    "isTestPath": "",
-    "isTestName": "",
-    "isMappingPath": "",
-    "isMappingName": "",
-    "isDataAccessPath": "",
-    "isDataAccessName": "",
-    "isDataStructurePath": "",
-    "isDataStructureName": "",
-    "isInterfaceStructuresPath": "",
-    "isInterfaceStructuresName": "",
-    "isEntryPointPath": "",
-    "isEntryPointName": "",
-    "treatFinalFieldsAsMandatory": false
-  },
-  "graphRestriction": {
-    "classPackageExcludeFilter": "",
-    "classPackageIncludeFilter": "",
-    "classNameExcludeFilter": "",
-    "classNameIncludeFilter": "",
-    "methodNameExcludeFilter": "",
-    "methodNameIncludeFilter": "",
-    "removeByInheritance": "", // inheritance/annotation based filtering is done in a second step
-    "removeByAnnotation": "",
-    "removeByClassPackage": "", // cleanup the graph after inheritance/annotation based filtering is done
-    "removeByClassName": "",
-    "cutMappings": false,
-    "cutEnum": true,
-    "cutTests": true,
-    "cutClient": true,
-    "cutDataAccess": true,
-    "cutInterfaceStructures": true,
-    "cutDataStructures": true,
-    "cutGetterAndSetter": true,
-    "cutConstructors": true
-  },
-  "graphTraversal": {
-    "forwardDepth": 3,
-    "backwardDepth": 3,
-    "classPackageExcludeFilter": "",
-    "classPackageIncludeFilter": "",
-    "classNameExcludeFilter": "",
-    "classNameIncludeFilter": "",
-    "methodNameExcludeFilter": "",
-    "methodNameIncludeFilter": "",
-    "hideMappings": false,
-    "hideDataStructures": false,
-    "hidePrivateMethods": true,
-    "hideInterfaceCalls": true, // indirection: implementation -> interface (is hidden) -> implementation
-    "onlyShowApplicationEntryPoints": false, // root node is included
-    "useMethodCallsForStructureDiagram": "ForwardOnly" // ForwardOnly, BothDirections, No
-  },
-  "details": {
-    "aggregation": "GroupByClass", // ByClass, GroupByClass, None
-    "showMethodParametersTypes": false,
-    "showMethodParametersNames": false,
-    "showMethodReturnType": false,
-    "showPackageLevels": 2,
-    "showCallOrder": false,
-    "edgeMode": "MethodsOnly", // TypesOnly, MethodsOnly, TypesAndMethods, MethodsAndDirectTypeUsage
-    "showDetailedClassStructure": false
-  },
-  "rootClass": "net.micode.notes.data.NotesProvider",
-  "extensionCallbackMethod": "" // qualified.class.name#methodName - signature: public static String method(String)
-}
-diagram meta data end '/
-
-
-
-digraph g {
-    rankdir="LR"
-    splines=polyline
-    
-
-'nodes 
-subgraph cluster_1074360951 { 
-   	label=micode
-	labeljust=l
-	fillcolor="#ececec"
-	style=filled
-   
-   subgraph cluster_502284772 { 
-   	label=notes
-	labeljust=l
-	fillcolor="#d8d8d8"
-	style=filled
-   
-   subgraph cluster_298648879 { 
-   	label=NotesProvider
-	labeljust=l
-	fillcolor=white
-	style=filled
-   
-   NotesProvider896280021XXXonCreate0[
-	label="+ onCreate()"
-	style=filled
-	fillcolor=white
-	tooltip="NotesProvider
-
-null"
-	penwidth=4
-	fontcolor=darkgreen
-];
-} 
-} 
-} 
-
-'edges    
-
-    
-}
-@enduml

小米标签及案例/源程序代码-小米便签-Notes-master/Notes-master/src/net/micode/notes/data/NotesProvider_1_query_calls.puml

@@ -1,123 +0,0 @@
-@startuml
-
-/' diagram meta data start
-config=CallConfiguration;
-{
-  "rootMethod": "net.micode.notes.data.NotesProvider#query(Uri,String[],String,String[],String)",
-  "projectClassification": {
-    "searchMode": "OpenProject", // OpenProject, AllProjects
-    "includedProjects": "",
-    "pathEndKeywords": "*.impl",
-    "isClientPath": "",
-    "isClientName": "",
-    "isTestPath": "",
-    "isTestName": "",
-    "isMappingPath": "",
-    "isMappingName": "",
-    "isDataAccessPath": "",
-    "isDataAccessName": "",
-    "isDataStructurePath": "",
-    "isDataStructureName": "",
-    "isInterfaceStructuresPath": "",
-    "isInterfaceStructuresName": "",
-    "isEntryPointPath": "",
-    "isEntryPointName": "",
-    "treatFinalFieldsAsMandatory": false
-  },
-  "graphRestriction": {
-    "classPackageExcludeFilter": "",
-    "classPackageIncludeFilter": "",
-    "classNameExcludeFilter": "",
-    "classNameIncludeFilter": "",
-    "methodNameExcludeFilter": "",
-    "methodNameIncludeFilter": "",
-    "removeByInheritance": "", // inheritance/annotation based filtering is done in a second step
-    "removeByAnnotation": "",
-    "removeByClassPackage": "", // cleanup the graph after inheritance/annotation based filtering is done
-    "removeByClassName": "",
-    "cutMappings": false,
-    "cutEnum": true,
-    "cutTests": true,
-    "cutClient": true,
-    "cutDataAccess": true,
-    "cutInterfaceStructures": true,
-    "cutDataStructures": true,
-    "cutGetterAndSetter": true,
-    "cutConstructors": true
-  },
-  "graphTraversal": {
-    "forwardDepth": 3,
-    "backwardDepth": 3,
-    "classPackageExcludeFilter": "",
-    "classPackageIncludeFilter": "",
-    "classNameExcludeFilter": "",
-    "classNameIncludeFilter": "",
-    "methodNameExcludeFilter": "",
-    "methodNameIncludeFilter": "",
-    "hideMappings": false,
-    "hideDataStructures": false,
-    "hidePrivateMethods": true,
-    "hideInterfaceCalls": true, // indirection: implementation -> interface (is hidden) -> implementation
-    "onlyShowApplicationEntryPoints": false, // root node is included
-    "useMethodCallsForStructureDiagram": "ForwardOnly" // ForwardOnly, BothDirections, No
-  },
-  "details": {
-    "aggregation": "GroupByClass", // ByClass, GroupByClass, None
-    "showMethodParametersTypes": false,
-    "showMethodParametersNames": false,
-    "showMethodReturnType": false,
-    "showPackageLevels": 2,
-    "showCallOrder": false,
-    "edgeMode": "MethodsOnly", // TypesOnly, MethodsOnly, TypesAndMethods, MethodsAndDirectTypeUsage
-    "showDetailedClassStructure": false
-  },
-  "rootClass": "net.micode.notes.data.NotesProvider",
-  "extensionCallbackMethod": "" // qualified.class.name#methodName - signature: public static String method(String)
-}
-diagram meta data end '/
-
-
-
-digraph g {
-    rankdir="LR"
-    splines=polyline
-    
-
-'nodes 
-subgraph cluster_1074360951 { 
-   	label=micode
-	labeljust=l
-	fillcolor="#ececec"
-	style=filled
-   
-   subgraph cluster_502284772 { 
-   	label=notes
-	labeljust=l
-	fillcolor="#d8d8d8"
-	style=filled
-   
-   subgraph cluster_298648879 { 
-   	label=NotesProvider
-	labeljust=l
-	fillcolor=white
-	style=filled
-   
-   NotesProvider896280021XXXquery112198364[
-	label="+ query()"
-	style=filled
-	fillcolor=white
-	tooltip="NotesProvider
-
-null"
-	penwidth=4
-	fontcolor=darkgreen
-];
-} 
-} 
-} 
-
-'edges    
-
-    
-}
-@enduml

小米标签及案例/源程序代码-小米便签-Notes-master/Notes-master/src/net/micode/notes/data/NotesProvider_2_insert_calls.puml

@@ -1,123 +0,0 @@
-@startuml
-
-/' diagram meta data start
-config=CallConfiguration;
-{
-  "rootMethod": "net.micode.notes.data.NotesProvider#insert(Uri,ContentValues)",
-  "projectClassification": {
-    "searchMode": "OpenProject", // OpenProject, AllProjects
-    "includedProjects": "",
-    "pathEndKeywords": "*.impl",
-    "isClientPath": "",
-    "isClientName": "",
-    "isTestPath": "",
-    "isTestName": "",
-    "isMappingPath": "",
-    "isMappingName": "",
-    "isDataAccessPath": "",
-    "isDataAccessName": "",
-    "isDataStructurePath": "",
-    "isDataStructureName": "",
-    "isInterfaceStructuresPath": "",
-    "isInterfaceStructuresName": "",
-    "isEntryPointPath": "",
-    "isEntryPointName": "",
-    "treatFinalFieldsAsMandatory": false
-  },
-  "graphRestriction": {
-    "classPackageExcludeFilter": "",
-    "classPackageIncludeFilter": "",
-    "classNameExcludeFilter": "",
-    "classNameIncludeFilter": "",
-    "methodNameExcludeFilter": "",
-    "methodNameIncludeFilter": "",
-    "removeByInheritance": "", // inheritance/annotation based filtering is done in a second step
-    "removeByAnnotation": "",
-    "removeByClassPackage": "", // cleanup the graph after inheritance/annotation based filtering is done
-    "removeByClassName": "",
-    "cutMappings": false,
-    "cutEnum": true,
-    "cutTests": true,
-    "cutClient": true,
-    "cutDataAccess": true,
-    "cutInterfaceStructures": true,
-    "cutDataStructures": true,
-    "cutGetterAndSetter": true,
-    "cutConstructors": true
-  },
-  "graphTraversal": {
-    "forwardDepth": 3,
-    "backwardDepth": 3,
-    "classPackageExcludeFilter": "",
-    "classPackageIncludeFilter": "",
-    "classNameExcludeFilter": "",
-    "classNameIncludeFilter": "",
-    "methodNameExcludeFilter": "",
-    "methodNameIncludeFilter": "",
-    "hideMappings": false,
-    "hideDataStructures": false,
-    "hidePrivateMethods": true,
-    "hideInterfaceCalls": true, // indirection: implementation -> interface (is hidden) -> implementation
-    "onlyShowApplicationEntryPoints": false, // root node is included
-    "useMethodCallsForStructureDiagram": "ForwardOnly" // ForwardOnly, BothDirections, No
-  },
-  "details": {
-    "aggregation": "GroupByClass", // ByClass, GroupByClass, None
-    "showMethodParametersTypes": false,
-    "showMethodParametersNames": false,
-    "showMethodReturnType": false,
-    "showPackageLevels": 2,
-    "showCallOrder": false,
-    "edgeMode": "MethodsOnly", // TypesOnly, MethodsOnly, TypesAndMethods, MethodsAndDirectTypeUsage
-    "showDetailedClassStructure": false
-  },
-  "rootClass": "net.micode.notes.data.NotesProvider",
-  "extensionCallbackMethod": "" // qualified.class.name#methodName - signature: public static String method(String)
-}
-diagram meta data end '/
-
-
-
-digraph g {
-    rankdir="LR"
-    splines=polyline
-    
-
-'nodes 
-subgraph cluster_1074360951 { 
-   	label=micode
-	labeljust=l
-	fillcolor="#ececec"
-	style=filled
-   
-   subgraph cluster_502284772 { 
-   	label=notes
-	labeljust=l
-	fillcolor="#d8d8d8"
-	style=filled
-   
-   subgraph cluster_298648879 { 
-   	label=NotesProvider
-	labeljust=l
-	fillcolor=white
-	style=filled
-   
-   NotesProvider896280021XXXinsert2104207589[
-	label="+ insert()"
-	style=filled
-	fillcolor=white
-	tooltip="NotesProvider
-
-null"
-	penwidth=4
-	fontcolor=darkgreen
-];
-} 
-} 
-} 
-
-'edges    
-
-    
-}
-@enduml

小米标签及案例/源程序代码-小米便签-Notes-master/Notes-master/src/net/micode/notes/data/NotesProvider_3_delete_calls.puml

@@ -1,123 +0,0 @@
-@startuml
-
-/' diagram meta data start
-config=CallConfiguration;
-{
-  "rootMethod": "net.micode.notes.data.NotesProvider#delete(Uri,String,String[])",
-  "projectClassification": {
-    "searchMode": "OpenProject", // OpenProject, AllProjects
-    "includedProjects": "",
-    "pathEndKeywords": "*.impl",
-    "isClientPath": "",
-    "isClientName": "",
-    "isTestPath": "",
-    "isTestName": "",
-    "isMappingPath": "",
-    "isMappingName": "",
-    "isDataAccessPath": "",
-    "isDataAccessName": "",
-    "isDataStructurePath": "",
-    "isDataStructureName": "",
-    "isInterfaceStructuresPath": "",
-    "isInterfaceStructuresName": "",
-    "isEntryPointPath": "",
-    "isEntryPointName": "",
-    "treatFinalFieldsAsMandatory": false
-  },
-  "graphRestriction": {
-    "classPackageExcludeFilter": "",
-    "classPackageIncludeFilter": "",
-    "classNameExcludeFilter": "",
-    "classNameIncludeFilter": "",
-    "methodNameExcludeFilter": "",
-    "methodNameIncludeFilter": "",
-    "removeByInheritance": "", // inheritance/annotation based filtering is done in a second step
-    "removeByAnnotation": "",
-    "removeByClassPackage": "", // cleanup the graph after inheritance/annotation based filtering is done
-    "removeByClassName": "",
-    "cutMappings": false,
-    "cutEnum": true,
-    "cutTests": true,
-    "cutClient": true,
-    "cutDataAccess": true,
-    "cutInterfaceStructures": true,
-    "cutDataStructures": true,
-    "cutGetterAndSetter": true,
-    "cutConstructors": true
-  },
-  "graphTraversal": {
-    "forwardDepth": 3,
-    "backwardDepth": 3,
-    "classPackageExcludeFilter": "",
-    "classPackageIncludeFilter": "",
-    "classNameExcludeFilter": "",
-    "classNameIncludeFilter": "",
-    "methodNameExcludeFilter": "",
-    "methodNameIncludeFilter": "",
-    "hideMappings": false,
-    "hideDataStructures": false,
-    "hidePrivateMethods": true,
-    "hideInterfaceCalls": true, // indirection: implementation -> interface (is hidden) -> implementation
-    "onlyShowApplicationEntryPoints": false, // root node is included
-    "useMethodCallsForStructureDiagram": "ForwardOnly" // ForwardOnly, BothDirections, No
-  },
-  "details": {
-    "aggregation": "GroupByClass", // ByClass, GroupByClass, None
-    "showMethodParametersTypes": false,
-    "showMethodParametersNames": false,
-    "showMethodReturnType": false,
-    "showPackageLevels": 2,
-    "showCallOrder": false,
-    "edgeMode": "MethodsOnly", // TypesOnly, MethodsOnly, TypesAndMethods, MethodsAndDirectTypeUsage
-    "showDetailedClassStructure": false
-  },
-  "rootClass": "net.micode.notes.data.NotesProvider",
-  "extensionCallbackMethod": "" // qualified.class.name#methodName - signature: public static String method(String)
-}
-diagram meta data end '/
-
-
-
-digraph g {
-    rankdir="LR"
-    splines=polyline
-    
-
-'nodes 
-subgraph cluster_1074360951 { 
-   	label=micode
-	labeljust=l
-	fillcolor="#ececec"
-	style=filled
-   
-   subgraph cluster_502284772 { 
-   	label=notes
-	labeljust=l
-	fillcolor="#d8d8d8"
-	style=filled
-   
-   subgraph cluster_298648879 { 
-   	label=NotesProvider
-	labeljust=l
-	fillcolor=white
-	style=filled
-   
-   NotesProvider896280021XXXdelete90008712[
-	label="+ delete()"
-	style=filled
-	fillcolor=white
-	tooltip="NotesProvider
-
-null"
-	penwidth=4
-	fontcolor=darkgreen
-];
-} 
-} 
-} 
-
-'edges    
-
-    
-}
-@enduml

小米标签及案例/源程序代码-小米便签-Notes-master/Notes-master/src/net/micode/notes/data/NotesProvider_4_update_calls.puml

@@ -1,123 +0,0 @@
-@startuml
-
-/' diagram meta data start
-config=CallConfiguration;
-{
-  "rootMethod": "net.micode.notes.data.NotesProvider#update(Uri,ContentValues,String,String[])",
-  "projectClassification": {
-    "searchMode": "OpenProject", // OpenProject, AllProjects
-    "includedProjects": "",
-    "pathEndKeywords": "*.impl",
-    "isClientPath": "",
-    "isClientName": "",
-    "isTestPath": "",
-    "isTestName": "",
-    "isMappingPath": "",
-    "isMappingName": "",
-    "isDataAccessPath": "",
-    "isDataAccessName": "",
-    "isDataStructurePath": "",
-    "isDataStructureName": "",
-    "isInterfaceStructuresPath": "",
-    "isInterfaceStructuresName": "",
-    "isEntryPointPath": "",
-    "isEntryPointName": "",
-    "treatFinalFieldsAsMandatory": false
-  },
-  "graphRestriction": {
-    "classPackageExcludeFilter": "",
-    "classPackageIncludeFilter": "",
-    "classNameExcludeFilter": "",
-    "classNameIncludeFilter": "",
-    "methodNameExcludeFilter": "",
-    "methodNameIncludeFilter": "",
-    "removeByInheritance": "", // inheritance/annotation based filtering is done in a second step
-    "removeByAnnotation": "",
-    "removeByClassPackage": "", // cleanup the graph after inheritance/annotation based filtering is done
-    "removeByClassName": "",
-    "cutMappings": false,
-    "cutEnum": true,
-    "cutTests": true,
-    "cutClient": true,
-    "cutDataAccess": true,
-    "cutInterfaceStructures": true,
-    "cutDataStructures": true,
-    "cutGetterAndSetter": true,
-    "cutConstructors": true
-  },
-  "graphTraversal": {
-    "forwardDepth": 3,
-    "backwardDepth": 3,
-    "classPackageExcludeFilter": "",
-    "classPackageIncludeFilter": "",
-    "classNameExcludeFilter": "",
-    "classNameIncludeFilter": "",
-    "methodNameExcludeFilter": "",
-    "methodNameIncludeFilter": "",
-    "hideMappings": false,
-    "hideDataStructures": false,
-    "hidePrivateMethods": true,
-    "hideInterfaceCalls": true, // indirection: implementation -> interface (is hidden) -> implementation
-    "onlyShowApplicationEntryPoints": false, // root node is included
-    "useMethodCallsForStructureDiagram": "ForwardOnly" // ForwardOnly, BothDirections, No
-  },
-  "details": {
-    "aggregation": "GroupByClass", // ByClass, GroupByClass, None
-    "showMethodParametersTypes": false,
-    "showMethodParametersNames": false,
-    "showMethodReturnType": false,
-    "showPackageLevels": 2,
-    "showCallOrder": false,
-    "edgeMode": "MethodsOnly", // TypesOnly, MethodsOnly, TypesAndMethods, MethodsAndDirectTypeUsage
-    "showDetailedClassStructure": false
-  },
-  "rootClass": "net.micode.notes.data.NotesProvider",
-  "extensionCallbackMethod": "" // qualified.class.name#methodName - signature: public static String method(String)
-}
-diagram meta data end '/
-
-
-
-digraph g {
-    rankdir="LR"
-    splines=polyline
-    
-
-'nodes 
-subgraph cluster_1074360951 { 
-   	label=micode
-	labeljust=l
-	fillcolor="#ececec"
-	style=filled
-   
-   subgraph cluster_502284772 { 
-   	label=notes
-	labeljust=l
-	fillcolor="#d8d8d8"
-	style=filled
-   
-   subgraph cluster_298648879 { 
-   	label=NotesProvider
-	labeljust=l
-	fillcolor=white
-	style=filled
-   
-   NotesProvider896280021XXXupdate1755998087[
-	label="+ update()"
-	style=filled
-	fillcolor=white
-	tooltip="NotesProvider
-
-null"
-	penwidth=4
-	fontcolor=darkgreen
-];
-} 
-} 
-} 
-
-'edges    
-
-    
-}
-@enduml

小米标签及案例/源程序代码-小米便签-Notes-master/Notes-master/src/net/micode/notes/data/NotesProvider_5_getType_calls.puml

@@ -1,123 +0,0 @@
-@startuml
-
-/' diagram meta data start
-config=CallConfiguration;
-{
-  "rootMethod": "net.micode.notes.data.NotesProvider#getType(Uri)",
-  "projectClassification": {
-    "searchMode": "OpenProject", // OpenProject, AllProjects
-    "includedProjects": "",
-    "pathEndKeywords": "*.impl",
-    "isClientPath": "",
-    "isClientName": "",
-    "isTestPath": "",
-    "isTestName": "",
-    "isMappingPath": "",
-    "isMappingName": "",
-    "isDataAccessPath": "",
-    "isDataAccessName": "",
-    "isDataStructurePath": "",
-    "isDataStructureName": "",
-    "isInterfaceStructuresPath": "",
-    "isInterfaceStructuresName": "",
-    "isEntryPointPath": "",
-    "isEntryPointName": "",
-    "treatFinalFieldsAsMandatory": false
-  },
-  "graphRestriction": {
-    "classPackageExcludeFilter": "",
-    "classPackageIncludeFilter": "",
-    "classNameExcludeFilter": "",
-    "classNameIncludeFilter": "",
-    "methodNameExcludeFilter": "",
-    "methodNameIncludeFilter": "",
-    "removeByInheritance": "", // inheritance/annotation based filtering is done in a second step
-    "removeByAnnotation": "",
-    "removeByClassPackage": "", // cleanup the graph after inheritance/annotation based filtering is done
-    "removeByClassName": "",
-    "cutMappings": false,
-    "cutEnum": true,
-    "cutTests": true,
-    "cutClient": true,
-    "cutDataAccess": true,
-    "cutInterfaceStructures": true,
-    "cutDataStructures": true,
-    "cutGetterAndSetter": true,
-    "cutConstructors": true
-  },
-  "graphTraversal": {
-    "forwardDepth": 3,
-    "backwardDepth": 3,
-    "classPackageExcludeFilter": "",
-    "classPackageIncludeFilter": "",
-    "classNameExcludeFilter": "",
-    "classNameIncludeFilter": "",
-    "methodNameExcludeFilter": "",
-    "methodNameIncludeFilter": "",
-    "hideMappings": false,
-    "hideDataStructures": false,
-    "hidePrivateMethods": true,
-    "hideInterfaceCalls": true, // indirection: implementation -> interface (is hidden) -> implementation
-    "onlyShowApplicationEntryPoints": false, // root node is included
-    "useMethodCallsForStructureDiagram": "ForwardOnly" // ForwardOnly, BothDirections, No
-  },
-  "details": {
-    "aggregation": "GroupByClass", // ByClass, GroupByClass, None
-    "showMethodParametersTypes": false,
-    "showMethodParametersNames": false,
-    "showMethodReturnType": false,
-    "showPackageLevels": 2,
-    "showCallOrder": false,
-    "edgeMode": "MethodsOnly", // TypesOnly, MethodsOnly, TypesAndMethods, MethodsAndDirectTypeUsage
-    "showDetailedClassStructure": false
-  },
-  "rootClass": "net.micode.notes.data.NotesProvider",
-  "extensionCallbackMethod": "" // qualified.class.name#methodName - signature: public static String method(String)
-}
-diagram meta data end '/
-
-
-
-digraph g {
-    rankdir="LR"
-    splines=polyline
-    
-
-'nodes 
-subgraph cluster_1074360951 { 
-   	label=micode
-	labeljust=l
-	fillcolor="#ececec"
-	style=filled
-   
-   subgraph cluster_502284772 { 
-   	label=notes
-	labeljust=l
-	fillcolor="#d8d8d8"
-	style=filled
-   
-   subgraph cluster_298648879 { 
-   	label=NotesProvider
-	labeljust=l
-	fillcolor=white
-	style=filled
-   
-   NotesProvider896280021XXXgetType85324[
-	label="+ getType()"
-	style=filled
-	fillcolor=white
-	tooltip="NotesProvider
-
-null"
-	penwidth=4
-	fontcolor=darkgreen
-];
-} 
-} 
-} 
-
-'edges    
-
-    
-}
-@enduml

小米标签及案例/源程序代码-小米便签-Notes-master/Notes-master/src/net/micode/notes/data/NotesProvider_delete_flow.puml

@@ -1,83 +0,0 @@
-@startuml
-
-/' diagram meta data start
-config=FlowConfiguration;
-{
-  "rootMethod": "net.micode.notes.data.NotesProvider#delete(Uri,String,String[])",
-  "projectClassification": {
-    "searchMode": "OpenProject", // OpenProject, AllProjects
-    "includedProjects": "",
-    "pathEndKeywords": "*.impl",
-    "isClientPath": "",
-    "isClientName": "",
-    "isTestPath": "",
-    "isTestName": "",
-    "isMappingPath": "",
-    "isMappingName": "",
-    "isDataAccessPath": "",
-    "isDataAccessName": "",
-    "isDataStructurePath": "",
-    "isDataStructureName": "",
-    "isInterfaceStructuresPath": "",
-    "isInterfaceStructuresName": "",
-    "isEntryPointPath": "",
-    "isEntryPointName": "",
-    "treatFinalFieldsAsMandatory": false
-  },
-  "graphRestriction": {
-    "classPackageExcludeFilter": "",
-    "classPackageIncludeFilter": "",
-    "classNameExcludeFilter": "",
-    "classNameIncludeFilter": "",
-    "methodNameExcludeFilter": "",
-    "methodNameIncludeFilter": "",
-    "removeByInheritance": "", // inheritance/annotation based filtering is done in a second step
-    "removeByAnnotation": "",
-    "removeByClassPackage": "", // cleanup the graph after inheritance/annotation based filtering is done
-    "removeByClassName": "",
-    "cutMappings": false,
-    "cutEnum": false,
-    "cutTests": true,
-    "cutClient": true,
-    "cutDataAccess": false,
-    "cutInterfaceStructures": false,
-    "cutDataStructures": false,
-    "cutGetterAndSetter": false,
-    "cutConstructors": false
-  },
-  "graphTraversal": {
-    "forwardDepth": 999,
-    "backwardDepth": 0,
-    "classPackageExcludeFilter": "",
-    "classPackageIncludeFilter": "",
-    "classNameExcludeFilter": "",
-    "classNameIncludeFilter": "",
-    "methodNameExcludeFilter": "",
-    "methodNameIncludeFilter": "",
-    "hideMappings": false,
-    "hideDataStructures": false,
-    "hidePrivateMethods": false,
-    "hideInterfaceCalls": false, // indirection: implementation -> interface (is hidden) -> implementation
-    "onlyShowApplicationEntryPoints": false, // root node is included
-    "useMethodCallsForStructureDiagram": "ForwardOnly" // ForwardOnly, BothDirections, No
-  },
-  "rootClass": "net.micode.notes.data.NotesProvider",
-  "extensionCallbackMethod": "" // qualified.class.name#methodName - signature: public static String method(String)
-}
-diagram meta data end '/
-
-
-
-digraph g {
-    rankdir="TB"
-    splines=polyline
-    
-
-'nodes 
-
-
-'edges    
-
-    
-}
-@enduml

小米标签及案例/源程序代码-小米便签-Notes-master/Notes-master/src/net/micode/notes/data/NotesProvider_getType_flow.puml

@@ -1,83 +0,0 @@
-@startuml
-
-/' diagram meta data start
-config=FlowConfiguration;
-{
-  "rootMethod": "net.micode.notes.data.NotesProvider#getType(Uri)",
-  "projectClassification": {
-    "searchMode": "OpenProject", // OpenProject, AllProjects
-    "includedProjects": "",
-    "pathEndKeywords": "*.impl",
-    "isClientPath": "",
-    "isClientName": "",
-    "isTestPath": "",
-    "isTestName": "",
-    "isMappingPath": "",
-    "isMappingName": "",
-    "isDataAccessPath": "",
-    "isDataAccessName": "",
-    "isDataStructurePath": "",
-    "isDataStructureName": "",
-    "isInterfaceStructuresPath": "",
-    "isInterfaceStructuresName": "",
-    "isEntryPointPath": "",
-    "isEntryPointName": "",
-    "treatFinalFieldsAsMandatory": false
-  },
-  "graphRestriction": {
-    "classPackageExcludeFilter": "",
-    "classPackageIncludeFilter": "",
-    "classNameExcludeFilter": "",
-    "classNameIncludeFilter": "",
-    "methodNameExcludeFilter": "",
-    "methodNameIncludeFilter": "",
-    "removeByInheritance": "", // inheritance/annotation based filtering is done in a second step
-    "removeByAnnotation": "",
-    "removeByClassPackage": "", // cleanup the graph after inheritance/annotation based filtering is done
-    "removeByClassName": "",
-    "cutMappings": false,
-    "cutEnum": false,
-    "cutTests": true,
-    "cutClient": true,
-    "cutDataAccess": false,
-    "cutInterfaceStructures": false,
-    "cutDataStructures": false,
-    "cutGetterAndSetter": false,
-    "cutConstructors": false
-  },
-  "graphTraversal": {
-    "forwardDepth": 999,
-    "backwardDepth": 0,
-    "classPackageExcludeFilter": "",
-    "classPackageIncludeFilter": "",
-    "classNameExcludeFilter": "",
-    "classNameIncludeFilter": "",
-    "methodNameExcludeFilter": "",
-    "methodNameIncludeFilter": "",
-    "hideMappings": false,
-    "hideDataStructures": false,
-    "hidePrivateMethods": false,
-    "hideInterfaceCalls": false, // indirection: implementation -> interface (is hidden) -> implementation
-    "onlyShowApplicationEntryPoints": false, // root node is included
-    "useMethodCallsForStructureDiagram": "ForwardOnly" // ForwardOnly, BothDirections, No
-  },
-  "rootClass": "net.micode.notes.data.NotesProvider",
-  "extensionCallbackMethod": "" // qualified.class.name#methodName - signature: public static String method(String)
-}
-diagram meta data end '/
-
-
-
-digraph g {
-    rankdir="TB"
-    splines=polyline
-    
-
-'nodes 
-
-
-'edges    
-
-    
-}
-@enduml

小米标签及案例/源程序代码-小米便签-Notes-master/Notes-master/src/net/micode/notes/data/NotesProvider_insert_flow.puml

@@ -1,83 +0,0 @@
-@startuml
-
-/' diagram meta data start
-config=FlowConfiguration;
-{
-  "rootMethod": "net.micode.notes.data.NotesProvider#insert(Uri,ContentValues)",
-  "projectClassification": {
-    "searchMode": "OpenProject", // OpenProject, AllProjects
-    "includedProjects": "",
-    "pathEndKeywords": "*.impl",
-    "isClientPath": "",
-    "isClientName": "",
-    "isTestPath": "",
-    "isTestName": "",
-    "isMappingPath": "",
-    "isMappingName": "",
-    "isDataAccessPath": "",
-    "isDataAccessName": "",
-    "isDataStructurePath": "",
-    "isDataStructureName": "",
-    "isInterfaceStructuresPath": "",
-    "isInterfaceStructuresName": "",
-    "isEntryPointPath": "",
-    "isEntryPointName": "",
-    "treatFinalFieldsAsMandatory": false
-  },
-  "graphRestriction": {
-    "classPackageExcludeFilter": "",
-    "classPackageIncludeFilter": "",
-    "classNameExcludeFilter": "",
-    "classNameIncludeFilter": "",
-    "methodNameExcludeFilter": "",
-    "methodNameIncludeFilter": "",
-    "removeByInheritance": "", // inheritance/annotation based filtering is done in a second step
-    "removeByAnnotation": "",
-    "removeByClassPackage": "", // cleanup the graph after inheritance/annotation based filtering is done
-    "removeByClassName": "",
-    "cutMappings": false,
-    "cutEnum": false,
-    "cutTests": true,
-    "cutClient": true,
-    "cutDataAccess": false,
-    "cutInterfaceStructures": false,
-    "cutDataStructures": false,
-    "cutGetterAndSetter": false,
-    "cutConstructors": false
-  },
-  "graphTraversal": {
-    "forwardDepth": 999,
-    "backwardDepth": 0,
-    "classPackageExcludeFilter": "",
-    "classPackageIncludeFilter": "",
-    "classNameExcludeFilter": "",
-    "classNameIncludeFilter": "",
-    "methodNameExcludeFilter": "",
-    "methodNameIncludeFilter": "",
-    "hideMappings": false,
-    "hideDataStructures": false,
-    "hidePrivateMethods": false,
-    "hideInterfaceCalls": false, // indirection: implementation -> interface (is hidden) -> implementation
-    "onlyShowApplicationEntryPoints": false, // root node is included
-    "useMethodCallsForStructureDiagram": "ForwardOnly" // ForwardOnly, BothDirections, No
-  },
-  "rootClass": "net.micode.notes.data.NotesProvider",
-  "extensionCallbackMethod": "" // qualified.class.name#methodName - signature: public static String method(String)
-}
-diagram meta data end '/
-
-
-
-digraph g {
-    rankdir="TB"
-    splines=polyline
-    
-
-'nodes 
-
-
-'edges    
-
-    
-}
-@enduml

小米标签及案例/源程序代码-小米便签-Notes-master/Notes-master/src/net/micode/notes/data/NotesProvider_onCreate_flow.puml

@@ -1,83 +0,0 @@
-@startuml
-
-/' diagram meta data start
-config=FlowConfiguration;
-{
-  "rootMethod": "net.micode.notes.data.NotesProvider#onCreate()",
-  "projectClassification": {
-    "searchMode": "OpenProject", // OpenProject, AllProjects
-    "includedProjects": "",
-    "pathEndKeywords": "*.impl",
-    "isClientPath": "",
-    "isClientName": "",
-    "isTestPath": "",
-    "isTestName": "",
-    "isMappingPath": "",
-    "isMappingName": "",
-    "isDataAccessPath": "",
-    "isDataAccessName": "",
-    "isDataStructurePath": "",
-    "isDataStructureName": "",
-    "isInterfaceStructuresPath": "",
-    "isInterfaceStructuresName": "",
-    "isEntryPointPath": "",
-    "isEntryPointName": "",
-    "treatFinalFieldsAsMandatory": false
-  },
-  "graphRestriction": {
-    "classPackageExcludeFilter": "",
-    "classPackageIncludeFilter": "",
-    "classNameExcludeFilter": "",
-    "classNameIncludeFilter": "",
-    "methodNameExcludeFilter": "",
-    "methodNameIncludeFilter": "",
-    "removeByInheritance": "", // inheritance/annotation based filtering is done in a second step
-    "removeByAnnotation": "",
-    "removeByClassPackage": "", // cleanup the graph after inheritance/annotation based filtering is done
-    "removeByClassName": "",
-    "cutMappings": false,
-    "cutEnum": false,
-    "cutTests": true,
-    "cutClient": true,
-    "cutDataAccess": false,
-    "cutInterfaceStructures": false,
-    "cutDataStructures": false,
-    "cutGetterAndSetter": false,
-    "cutConstructors": false
-  },
-  "graphTraversal": {
-    "forwardDepth": 999,
-    "backwardDepth": 0,
-    "classPackageExcludeFilter": "",
-    "classPackageIncludeFilter": "",
-    "classNameExcludeFilter": "",
-    "classNameIncludeFilter": "",
-    "methodNameExcludeFilter": "",
-    "methodNameIncludeFilter": "",
-    "hideMappings": false,
-    "hideDataStructures": false,
-    "hidePrivateMethods": false,
-    "hideInterfaceCalls": false, // indirection: implementation -> interface (is hidden) -> implementation
-    "onlyShowApplicationEntryPoints": false, // root node is included
-    "useMethodCallsForStructureDiagram": "ForwardOnly" // ForwardOnly, BothDirections, No
-  },
-  "rootClass": "net.micode.notes.data.NotesProvider",
-  "extensionCallbackMethod": "" // qualified.class.name#methodName - signature: public static String method(String)
-}
-diagram meta data end '/
-
-
-
-digraph g {
-    rankdir="TB"
-    splines=polyline
-    
-
-'nodes 
-
-
-'edges    
-
-    
-}
-@enduml

小米标签及案例/源程序代码-小米便签-Notes-master/Notes-master/src/net/micode/notes/data/NotesProvider_query_flow.puml

@@ -1,83 +0,0 @@
-@startuml
-
-/' diagram meta data start
-config=FlowConfiguration;
-{
-  "rootMethod": "net.micode.notes.data.NotesProvider#query(Uri,String[],String,String[],String)",
-  "projectClassification": {
-    "searchMode": "OpenProject", // OpenProject, AllProjects
-    "includedProjects": "",
-    "pathEndKeywords": "*.impl",
-    "isClientPath": "",
-    "isClientName": "",
-    "isTestPath": "",
-    "isTestName": "",
-    "isMappingPath": "",
-    "isMappingName": "",
-    "isDataAccessPath": "",
-    "isDataAccessName": "",
-    "isDataStructurePath": "",
-    "isDataStructureName": "",
-    "isInterfaceStructuresPath": "",
-    "isInterfaceStructuresName": "",
-    "isEntryPointPath": "",
-    "isEntryPointName": "",
-    "treatFinalFieldsAsMandatory": false
-  },
-  "graphRestriction": {
-    "classPackageExcludeFilter": "",
-    "classPackageIncludeFilter": "",
-    "classNameExcludeFilter": "",
-    "classNameIncludeFilter": "",
-    "methodNameExcludeFilter": "",
-    "methodNameIncludeFilter": "",
-    "removeByInheritance": "", // inheritance/annotation based filtering is done in a second step
-    "removeByAnnotation": "",
-    "removeByClassPackage": "", // cleanup the graph after inheritance/annotation based filtering is done
-    "removeByClassName": "",
-    "cutMappings": false,
-    "cutEnum": false,
-    "cutTests": true,
-    "cutClient": true,
-    "cutDataAccess": false,
-    "cutInterfaceStructures": false,
-    "cutDataStructures": false,
-    "cutGetterAndSetter": false,
-    "cutConstructors": false
-  },
-  "graphTraversal": {
-    "forwardDepth": 999,
-    "backwardDepth": 0,
-    "classPackageExcludeFilter": "",
-    "classPackageIncludeFilter": "",
-    "classNameExcludeFilter": "",
-    "classNameIncludeFilter": "",
-    "methodNameExcludeFilter": "",
-    "methodNameIncludeFilter": "",
-    "hideMappings": false,
-    "hideDataStructures": false,
-    "hidePrivateMethods": false,
-    "hideInterfaceCalls": false, // indirection: implementation -> interface (is hidden) -> implementation
-    "onlyShowApplicationEntryPoints": false, // root node is included
-    "useMethodCallsForStructureDiagram": "ForwardOnly" // ForwardOnly, BothDirections, No
-  },
-  "rootClass": "net.micode.notes.data.NotesProvider",
-  "extensionCallbackMethod": "" // qualified.class.name#methodName - signature: public static String method(String)
-}
-diagram meta data end '/
-
-
-
-digraph g {
-    rankdir="TB"
-    splines=polyline
-    
-
-'nodes 
-
-
-'edges    
-
-    
-}
-@enduml

小米标签及案例/源程序代码-小米便签-Notes-master/Notes-master/src/net/micode/notes/data/NotesProvider_structure.puml

@@ -1,148 +0,0 @@
-@startuml
-
-/' diagram meta data start
-config=StructureConfiguration;
-{
-  "projectClassification": {
-    "searchMode": "OpenProject", // OpenProject, AllProjects
-    "includedProjects": "",
-    "pathEndKeywords": "*.impl",
-    "isClientPath": "",
-    "isClientName": "",
-    "isTestPath": "",
-    "isTestName": "",
-    "isMappingPath": "",
-    "isMappingName": "",
-    "isDataAccessPath": "",
-    "isDataAccessName": "",
-    "isDataStructurePath": "",
-    "isDataStructureName": "",
-    "isInterfaceStructuresPath": "",
-    "isInterfaceStructuresName": "",
-    "isEntryPointPath": "",
-    "isEntryPointName": "",
-    "treatFinalFieldsAsMandatory": false
-  },
-  "graphRestriction": {
-    "classPackageExcludeFilter": "",
-    "classPackageIncludeFilter": "",
-    "classNameExcludeFilter": "",
-    "classNameIncludeFilter": "",
-    "methodNameExcludeFilter": "",
-    "methodNameIncludeFilter": "",
-    "removeByInheritance": "", // inheritance/annotation based filtering is done in a second step
-    "removeByAnnotation": "",
-    "removeByClassPackage": "", // cleanup the graph after inheritance/annotation based filtering is done
-    "removeByClassName": "",
-    "cutMappings": false,
-    "cutEnum": true,
-    "cutTests": true,
-    "cutClient": true,
-    "cutDataAccess": false,
-    "cutInterfaceStructures": false,
-    "cutDataStructures": false,
-    "cutGetterAndSetter": true,
-    "cutConstructors": true
-  },
-  "graphTraversal": {
-    "forwardDepth": 6,
-    "backwardDepth": 6,
-    "classPackageExcludeFilter": "",
-    "classPackageIncludeFilter": "",
-    "classNameExcludeFilter": "",
-    "classNameIncludeFilter": "",
-    "methodNameExcludeFilter": "",
-    "methodNameIncludeFilter": "",
-    "hideMappings": false,
-    "hideDataStructures": false,
-    "hidePrivateMethods": true,
-    "hideInterfaceCalls": true, // indirection: implementation -> interface (is hidden) -> implementation
-    "onlyShowApplicationEntryPoints": false, // root node is included
-    "useMethodCallsForStructureDiagram": "ForwardOnly" // ForwardOnly, BothDirections, No
-  },
-  "details": {
-    "aggregation": "GroupByClass", // ByClass, GroupByClass, None
-    "showClassGenericTypes": true,
-    "showMethods": true,
-    "showMethodParameterNames": true,
-    "showMethodParameterTypes": true,
-    "showMethodReturnType": true,
-    "showPackageLevels": 2,
-    "showDetailedClassStructure": true
-  },
-  "rootClass": "net.micode.notes.data.NotesProvider",
-  "extensionCallbackMethod": "" // qualified.class.name#methodName - signature: public static String method(String)
-}
-diagram meta data end '/
-
-
-
-digraph g {
-    rankdir="TB"
-    splines=polyline
-    
-
-'nodes 
-subgraph cluster_1074360951 { 
-   	label=micode
-	labeljust=l
-	fillcolor="#ececec"
-	style=filled
-   
-   subgraph cluster_502284772 { 
-   	label=notes
-	labeljust=l
-	fillcolor="#d8d8d8"
-	style=filled
-   
-   NotesDatabaseHelper896280021[
-	label=<<TABLE BORDER="1" CELLBORDER="0" CELLPADDING="4" CELLSPACING="0">
-<TR><TD ALIGN="LEFT" >(C)NotesDatabaseHelper</TD></TR>
-<HR/>
-<TR><TD ALIGN="LEFT" >+ createDataTable(db: SQLiteDatabase)</TD></TR>
-<TR><TD ALIGN="LEFT" >+ createNoteTable(db: SQLiteDatabase)</TD></TR>
-<TR><TD ALIGN="LEFT" >- createSystemFolder(db: SQLiteDatabase)</TD></TR>
-<TR><TD ALIGN="LEFT" ># getInstance(context: Context): NotesDatabaseHelper</TD></TR>
-<TR><TD ALIGN="LEFT" >+ onCreate(db: SQLiteDatabase)</TD></TR>
-<TR><TD ALIGN="LEFT" >+ onUpgrade(db: SQLiteDatabase, oldVersion: int, newVersion: int)</TD></TR>
-<TR><TD ALIGN="LEFT" >- reCreateDataTableTriggers(db: SQLiteDatabase)</TD></TR>
-<TR><TD ALIGN="LEFT" >- reCreateNoteTableTriggers(db: SQLiteDatabase)</TD></TR>
-<TR><TD ALIGN="LEFT" >- upgradeToV2(db: SQLiteDatabase)</TD></TR>
-<TR><TD ALIGN="LEFT" >- upgradeToV3(db: SQLiteDatabase)</TD></TR>
-<TR><TD ALIGN="LEFT" >- upgradeToV4(db: SQLiteDatabase)</TD></TR>
-</TABLE>>
-	style=filled
-	margin=0
-	shape=plaintext
-	fillcolor="#FFFFFF"
-];
-
-NotesProvider896280021[
-	label=<<TABLE BORDER="1" CELLBORDER="0" CELLPADDING="4" CELLSPACING="0">
-<TR><TD ALIGN="LEFT" >(C)NotesProvider</TD></TR>
-<HR/>
-<TR><TD ALIGN="LEFT" >-   mHelper: NotesDatabaseHelper [0..1]</TD></TR>
-<HR/>
-<TR><TD ALIGN="LEFT" >+ delete(uri: Uri, selection: String, selectionArgs: String[]): int</TD></TR>
-<TR><TD ALIGN="LEFT" >+ getType(uri: Uri): String</TD></TR>
-<TR><TD ALIGN="LEFT" >- increaseNoteVersion(id: long, selection: String, selectionArgs: String[])</TD></TR>
-<TR><TD ALIGN="LEFT" >+ insert(uri: Uri, values: ContentValues): Uri</TD></TR>
-<TR><TD ALIGN="LEFT" >+ onCreate(): boolean</TD></TR>
-<TR><TD ALIGN="LEFT" >- parseSelection(selection: String): String</TD></TR>
-<TR><TD ALIGN="LEFT" >+ query(uri: Uri, projection: String[], selection: String, selectionArgs: String[], sortOrder: String): Cursor</TD></TR>
-<TR><TD ALIGN="LEFT" >+ update(uri: Uri, values: ContentValues, selection: String, selectionArgs: String[]): int</TD></TR>
-</TABLE>>
-	style=filled
-	margin=0
-	shape=plaintext
-	fillcolor="#FFFFFF"
-];
-} 
-} 
-
-'edges    
-NotesProvider896280021 -> NotesDatabaseHelper896280021[label="mHelper
-[0..1]"];
-    
-}
-@enduml

小米标签及案例/源程序代码-小米便签-Notes-master/Notes-master/src/net/micode/notes/data/NotesProvider_update_flow.puml

@@ -1,83 +0,0 @@
-@startuml
-
-/' diagram meta data start
-config=FlowConfiguration;
-{
-  "rootMethod": "net.micode.notes.data.NotesProvider#update(Uri,ContentValues,String,String[])",
-  "projectClassification": {
-    "searchMode": "OpenProject", // OpenProject, AllProjects
-    "includedProjects": "",
-    "pathEndKeywords": "*.impl",
-    "isClientPath": "",
-    "isClientName": "",
-    "isTestPath": "",
-    "isTestName": "",
-    "isMappingPath": "",
-    "isMappingName": "",
-    "isDataAccessPath": "",
-    "isDataAccessName": "",
-    "isDataStructurePath": "",
-    "isDataStructureName": "",
-    "isInterfaceStructuresPath": "",
-    "isInterfaceStructuresName": "",
-    "isEntryPointPath": "",
-    "isEntryPointName": "",
-    "treatFinalFieldsAsMandatory": false
-  },
-  "graphRestriction": {
-    "classPackageExcludeFilter": "",
-    "classPackageIncludeFilter": "",
-    "classNameExcludeFilter": "",
-    "classNameIncludeFilter": "",
-    "methodNameExcludeFilter": "",
-    "methodNameIncludeFilter": "",
-    "removeByInheritance": "", // inheritance/annotation based filtering is done in a second step
-    "removeByAnnotation": "",
-    "removeByClassPackage": "", // cleanup the graph after inheritance/annotation based filtering is done
-    "removeByClassName": "",
-    "cutMappings": false,
-    "cutEnum": false,
-    "cutTests": true,
-    "cutClient": true,
-    "cutDataAccess": false,
-    "cutInterfaceStructures": false,
-    "cutDataStructures": false,
-    "cutGetterAndSetter": false,
-    "cutConstructors": false
-  },
-  "graphTraversal": {
-    "forwardDepth": 999,
-    "backwardDepth": 0,
-    "classPackageExcludeFilter": "",
-    "classPackageIncludeFilter": "",
-    "classNameExcludeFilter": "",
-    "classNameIncludeFilter": "",
-    "methodNameExcludeFilter": "",
-    "methodNameIncludeFilter": "",
-    "hideMappings": false,
-    "hideDataStructures": false,
-    "hidePrivateMethods": false,
-    "hideInterfaceCalls": false, // indirection: implementation -> interface (is hidden) -> implementation
-    "onlyShowApplicationEntryPoints": false, // root node is included
-    "useMethodCallsForStructureDiagram": "ForwardOnly" // ForwardOnly, BothDirections, No
-  },
-  "rootClass": "net.micode.notes.data.NotesProvider",
-  "extensionCallbackMethod": "" // qualified.class.name#methodName - signature: public static String method(String)
-}
-diagram meta data end '/
-
-
-
-digraph g {
-    rankdir="TB"
-    splines=polyline
-    
-
-'nodes 
-
-
-'edges    
-
-    
-}
-@enduml

小米标签及案例/源程序代码-小米便签-Notes-master/Notes-master/src/net/micode/notes/data/Notes_structure.puml

@@ -1,114 +0,0 @@
-@startuml
-
-/' diagram meta data start
-config=StructureConfiguration;
-{
-  "projectClassification": {
-    "searchMode": "OpenProject", // OpenProject, AllProjects
-    "includedProjects": "",
-    "pathEndKeywords": "*.impl",
-    "isClientPath": "",
-    "isClientName": "",
-    "isTestPath": "",
-    "isTestName": "",
-    "isMappingPath": "",
-    "isMappingName": "",
-    "isDataAccessPath": "",
-    "isDataAccessName": "",
-    "isDataStructurePath": "",
-    "isDataStructureName": "",
-    "isInterfaceStructuresPath": "",
-    "isInterfaceStructuresName": "",
-    "isEntryPointPath": "",
-    "isEntryPointName": "",
-    "treatFinalFieldsAsMandatory": false
-  },
-  "graphRestriction": {
-    "classPackageExcludeFilter": "",
-    "classPackageIncludeFilter": "",
-    "classNameExcludeFilter": "",
-    "classNameIncludeFilter": "",
-    "methodNameExcludeFilter": "",
-    "methodNameIncludeFilter": "",
-    "removeByInheritance": "", // inheritance/annotation based filtering is done in a second step
-    "removeByAnnotation": "",
-    "removeByClassPackage": "", // cleanup the graph after inheritance/annotation based filtering is done
-    "removeByClassName": "",
-    "cutMappings": false,
-    "cutEnum": true,
-    "cutTests": true,
-    "cutClient": true,
-    "cutDataAccess": false,
-    "cutInterfaceStructures": false,
-    "cutDataStructures": false,
-    "cutGetterAndSetter": true,
-    "cutConstructors": true
-  },
-  "graphTraversal": {
-    "forwardDepth": 6,
-    "backwardDepth": 6,
-    "classPackageExcludeFilter": "",
-    "classPackageIncludeFilter": "",
-    "classNameExcludeFilter": "",
-    "classNameIncludeFilter": "",
-    "methodNameExcludeFilter": "",
-    "methodNameIncludeFilter": "",
-    "hideMappings": false,
-    "hideDataStructures": false,
-    "hidePrivateMethods": true,
-    "hideInterfaceCalls": true, // indirection: implementation -> interface (is hidden) -> implementation
-    "onlyShowApplicationEntryPoints": false, // root node is included
-    "useMethodCallsForStructureDiagram": "ForwardOnly" // ForwardOnly, BothDirections, No
-  },
-  "details": {
-    "aggregation": "GroupByClass", // ByClass, GroupByClass, None
-    "showClassGenericTypes": true,
-    "showMethods": true,
-    "showMethodParameterNames": true,
-    "showMethodParameterTypes": true,
-    "showMethodReturnType": true,
-    "showPackageLevels": 2,
-    "showDetailedClassStructure": true
-  },
-  "rootClass": "net.micode.notes.data.Notes",
-  "extensionCallbackMethod": "" // qualified.class.name#methodName - signature: public static String method(String)
-}
-diagram meta data end '/
-
-
-
-digraph g {
-    rankdir="TB"
-    splines=polyline
-    
-
-'nodes 
-subgraph cluster_1074360951 { 
-   	label=micode
-	labeljust=l
-	fillcolor="#ececec"
-	style=filled
-   
-   subgraph cluster_502284772 { 
-   	label=notes
-	labeljust=l
-	fillcolor="#d8d8d8"
-	style=filled
-   
-   Notes896280021[
-	label=<<TABLE BORDER="1" CELLBORDER="0" CELLPADDING="4" CELLSPACING="0">
-<TR><TD ALIGN="LEFT" >(C)Notes</TD></TR>
-</TABLE>>
-	style=filled
-	margin=0
-	shape=plaintext
-	fillcolor="#FFFFFF"
-];
-} 
-} 
-
-'edges    
-
-    
-}
-@enduml

小米标签及案例/源程序代码-小米便签-Notes-master/Notes-master/src/net/micode/notes/gtask/data/MetaData.java

@@ -16,22 +16,19 @@
 
 package net.micode.notes.gtask.data;
 
-//导入所需的类
-import android.database.Cursor;        //处理数据库查询的Cursor类
-import android.util.Log;                      //日志记录类Log
+import android.database.Cursor;
+import android.util.Log;
 
 import net.micode.notes.tool.GTaskStringUtils;
 
 import org.json.JSONException;
 import org.json.JSONObject;
 
-//声明MetaData类，这个类extends了Task类，即继承了Task类的所有属性和方法
+
 public class MetaData extends Task {
     private final static String TAG = MetaData.class.getSimpleName();
-    //定义了一个私有静态常量字符串 TAG，用于标识日志记录的来源。TAG 的值是 MetaData 类的简单名称
 
     private String mRelatedGid = null;
-    //声明了一个私有字符串变量 mRelatedGid，用于存储关联的 GID（Google 任务 ID）
 
     public void setMeta(String gid, JSONObject metaInfo) {
         try {

小米标签及案例/源程序代码-小米便签-Notes-master/Notes-master/src/net/micode/notes/gtask/data/MetaData_0_setMeta_calls.puml

@@ -1,140 +0,0 @@
-@startuml
-
-/' diagram meta data start
-config=CallConfiguration;
-{
-  "rootMethod": "net.micode.notes.gtask.data.MetaData#setMeta(String,JSONObject)",
-  "projectClassification": {
-    "searchMode": "OpenProject", // OpenProject, AllProjects
-    "includedProjects": "",
-    "pathEndKeywords": "*.impl",
-    "isClientPath": "",
-    "isClientName": "",
-    "isTestPath": "",
-    "isTestName": "",
-    "isMappingPath": "",
-    "isMappingName": "",
-    "isDataAccessPath": "",
-    "isDataAccessName": "",
-    "isDataStructurePath": "",
-    "isDataStructureName": "",
-    "isInterfaceStructuresPath": "",
-    "isInterfaceStructuresName": "",
-    "isEntryPointPath": "",
-    "isEntryPointName": "",
-    "treatFinalFieldsAsMandatory": false
-  },
-  "graphRestriction": {
-    "classPackageExcludeFilter": "",
-    "classPackageIncludeFilter": "",
-    "classNameExcludeFilter": "",
-    "classNameIncludeFilter": "",
-    "methodNameExcludeFilter": "",
-    "methodNameIncludeFilter": "",
-    "removeByInheritance": "", // inheritance/annotation based filtering is done in a second step
-    "removeByAnnotation": "",
-    "removeByClassPackage": "", // cleanup the graph after inheritance/annotation based filtering is done
-    "removeByClassName": "",
-    "cutMappings": false,
-    "cutEnum": true,
-    "cutTests": true,
-    "cutClient": true,
-    "cutDataAccess": true,
-    "cutInterfaceStructures": true,
-    "cutDataStructures": true,
-    "cutGetterAndSetter": true,
-    "cutConstructors": true
-  },
-  "graphTraversal": {
-    "forwardDepth": 3,
-    "backwardDepth": 3,
-    "classPackageExcludeFilter": "",
-    "classPackageIncludeFilter": "",
-    "classNameExcludeFilter": "",
-    "classNameIncludeFilter": "",
-    "methodNameExcludeFilter": "",
-    "methodNameIncludeFilter": "",
-    "hideMappings": false,
-    "hideDataStructures": false,
-    "hidePrivateMethods": true,
-    "hideInterfaceCalls": true, // indirection: implementation -> interface (is hidden) -> implementation
-    "onlyShowApplicationEntryPoints": false, // root node is included
-    "useMethodCallsForStructureDiagram": "ForwardOnly" // ForwardOnly, BothDirections, No
-  },
-  "details": {
-    "aggregation": "GroupByClass", // ByClass, GroupByClass, None
-    "showMethodParametersTypes": false,
-    "showMethodParametersNames": false,
-    "showMethodReturnType": false,
-    "showPackageLevels": 2,
-    "showCallOrder": false,
-    "edgeMode": "MethodsOnly", // TypesOnly, MethodsOnly, TypesAndMethods, MethodsAndDirectTypeUsage
-    "showDetailedClassStructure": false
-  },
-  "rootClass": "net.micode.notes.gtask.data.MetaData",
-  "extensionCallbackMethod": "" // qualified.class.name#methodName - signature: public static String method(String)
-}
-diagram meta data end '/
-
-
-
-digraph g {
-    rankdir="LR"
-    splines=polyline
-    
-
-'nodes 
-subgraph cluster_1074360951 { 
-   	label=micode
-	labeljust=l
-	fillcolor="#ececec"
-	style=filled
-   
-   subgraph cluster_502284772 { 
-   	label=notes
-	labeljust=l
-	fillcolor="#d8d8d8"
-	style=filled
-   
-   subgraph cluster_1368530406 { 
-   	label=GTaskManager
-	labeljust=l
-	fillcolor=white
-	style=filled
-   
-   GTaskManager641041527XXXsync656730312[
-	label="+ sync()"
-	style=filled
-	fillcolor=white
-	tooltip="GTaskManager
-
-null"
-	fontcolor=darkgreen
-];
-} 
-
-subgraph cluster_633221264 { 
-   	label=MetaData
-	labeljust=l
-	fillcolor=white
-	style=filled
-   
-   MetaData617846867XXXsetMeta238127764[
-	label="+ setMeta()"
-	style=filled
-	fillcolor=white
-	tooltip="MetaData
-
-null"
-	penwidth=4
-	fontcolor=darkgreen
-];
-} 
-} 
-} 
-
-'edges    
-GTaskManager641041527XXXsync656730312 -> MetaData617846867XXXsetMeta238127764;
-    
-}
-@enduml

小米标签及案例/源程序代码-小米便签-Notes-master/Notes-master/src/net/micode/notes/gtask/data/MetaData_1_getRelatedGid_calls.puml

@@ -1,140 +0,0 @@
-@startuml
-
-/' diagram meta data start
-config=CallConfiguration;
-{
-  "rootMethod": "net.micode.notes.gtask.data.MetaData#getRelatedGid()",
-  "projectClassification": {
-    "searchMode": "OpenProject", // OpenProject, AllProjects
-    "includedProjects": "",
-    "pathEndKeywords": "*.impl",
-    "isClientPath": "",
-    "isClientName": "",
-    "isTestPath": "",
-    "isTestName": "",
-    "isMappingPath": "",
-    "isMappingName": "",
-    "isDataAccessPath": "",
-    "isDataAccessName": "",
-    "isDataStructurePath": "",
-    "isDataStructureName": "",
-    "isInterfaceStructuresPath": "",
-    "isInterfaceStructuresName": "",
-    "isEntryPointPath": "",
-    "isEntryPointName": "",
-    "treatFinalFieldsAsMandatory": false
-  },
-  "graphRestriction": {
-    "classPackageExcludeFilter": "",
-    "classPackageIncludeFilter": "",
-    "classNameExcludeFilter": "",
-    "classNameIncludeFilter": "",
-    "methodNameExcludeFilter": "",
-    "methodNameIncludeFilter": "",
-    "removeByInheritance": "", // inheritance/annotation based filtering is done in a second step
-    "removeByAnnotation": "",
-    "removeByClassPackage": "", // cleanup the graph after inheritance/annotation based filtering is done
-    "removeByClassName": "",
-    "cutMappings": false,
-    "cutEnum": true,
-    "cutTests": true,
-    "cutClient": true,
-    "cutDataAccess": true,
-    "cutInterfaceStructures": true,
-    "cutDataStructures": true,
-    "cutGetterAndSetter": true,
-    "cutConstructors": true
-  },
-  "graphTraversal": {
-    "forwardDepth": 3,
-    "backwardDepth": 3,
-    "classPackageExcludeFilter": "",
-    "classPackageIncludeFilter": "",
-    "classNameExcludeFilter": "",
-    "classNameIncludeFilter": "",
-    "methodNameExcludeFilter": "",
-    "methodNameIncludeFilter": "",
-    "hideMappings": false,
-    "hideDataStructures": false,
-    "hidePrivateMethods": true,
-    "hideInterfaceCalls": true, // indirection: implementation -> interface (is hidden) -> implementation
-    "onlyShowApplicationEntryPoints": false, // root node is included
-    "useMethodCallsForStructureDiagram": "ForwardOnly" // ForwardOnly, BothDirections, No
-  },
-  "details": {
-    "aggregation": "GroupByClass", // ByClass, GroupByClass, None
-    "showMethodParametersTypes": false,
-    "showMethodParametersNames": false,
-    "showMethodReturnType": false,
-    "showPackageLevels": 2,
-    "showCallOrder": false,
-    "edgeMode": "MethodsOnly", // TypesOnly, MethodsOnly, TypesAndMethods, MethodsAndDirectTypeUsage
-    "showDetailedClassStructure": false
-  },
-  "rootClass": "net.micode.notes.gtask.data.MetaData",
-  "extensionCallbackMethod": "" // qualified.class.name#methodName - signature: public static String method(String)
-}
-diagram meta data end '/
-
-
-
-digraph g {
-    rankdir="LR"
-    splines=polyline
-    
-
-'nodes 
-subgraph cluster_1074360951 { 
-   	label=micode
-	labeljust=l
-	fillcolor="#ececec"
-	style=filled
-   
-   subgraph cluster_502284772 { 
-   	label=notes
-	labeljust=l
-	fillcolor="#d8d8d8"
-	style=filled
-   
-   subgraph cluster_1368530406 { 
-   	label=GTaskManager
-	labeljust=l
-	fillcolor=white
-	style=filled
-   
-   GTaskManager641041527XXXsync656730312[
-	label="+ sync()"
-	style=filled
-	fillcolor=white
-	tooltip="GTaskManager
-
-null"
-	fontcolor=darkgreen
-];
-} 
-
-subgraph cluster_633221264 { 
-   	label=MetaData
-	labeljust=l
-	fillcolor=white
-	style=filled
-   
-   MetaData617846867XXXgetRelatedGid0[
-	label="+ getRelatedGid()"
-	style=filled
-	fillcolor=white
-	tooltip="MetaData
-
-null"
-	penwidth=4
-	fontcolor=darkgreen
-];
-} 
-} 
-} 
-
-'edges    
-GTaskManager641041527XXXsync656730312 -> MetaData617846867XXXgetRelatedGid0;
-    
-}
-@enduml

小米标签及案例/源程序代码-小米便签-Notes-master/Notes-master/src/net/micode/notes/gtask/data/MetaData_2_isWorthSaving_calls.puml

@@ -1,140 +0,0 @@
-@startuml
-
-/' diagram meta data start
-config=CallConfiguration;
-{
-  "rootMethod": "net.micode.notes.gtask.data.MetaData#isWorthSaving()",
-  "projectClassification": {
-    "searchMode": "OpenProject", // OpenProject, AllProjects
-    "includedProjects": "",
-    "pathEndKeywords": "*.impl",
-    "isClientPath": "",
-    "isClientName": "",
-    "isTestPath": "",
-    "isTestName": "",
-    "isMappingPath": "",
-    "isMappingName": "",
-    "isDataAccessPath": "",
-    "isDataAccessName": "",
-    "isDataStructurePath": "",
-    "isDataStructureName": "",
-    "isInterfaceStructuresPath": "",
-    "isInterfaceStructuresName": "",
-    "isEntryPointPath": "",
-    "isEntryPointName": "",
-    "treatFinalFieldsAsMandatory": false
-  },
-  "graphRestriction": {
-    "classPackageExcludeFilter": "",
-    "classPackageIncludeFilter": "",
-    "classNameExcludeFilter": "",
-    "classNameIncludeFilter": "",
-    "methodNameExcludeFilter": "",
-    "methodNameIncludeFilter": "",
-    "removeByInheritance": "", // inheritance/annotation based filtering is done in a second step
-    "removeByAnnotation": "",
-    "removeByClassPackage": "", // cleanup the graph after inheritance/annotation based filtering is done
-    "removeByClassName": "",
-    "cutMappings": false,
-    "cutEnum": true,
-    "cutTests": true,
-    "cutClient": true,
-    "cutDataAccess": true,
-    "cutInterfaceStructures": true,
-    "cutDataStructures": true,
-    "cutGetterAndSetter": true,
-    "cutConstructors": true
-  },
-  "graphTraversal": {
-    "forwardDepth": 3,
-    "backwardDepth": 3,
-    "classPackageExcludeFilter": "",
-    "classPackageIncludeFilter": "",
-    "classNameExcludeFilter": "",
-    "classNameIncludeFilter": "",
-    "methodNameExcludeFilter": "",
-    "methodNameIncludeFilter": "",
-    "hideMappings": false,
-    "hideDataStructures": false,
-    "hidePrivateMethods": true,
-    "hideInterfaceCalls": true, // indirection: implementation -> interface (is hidden) -> implementation
-    "onlyShowApplicationEntryPoints": false, // root node is included
-    "useMethodCallsForStructureDiagram": "ForwardOnly" // ForwardOnly, BothDirections, No
-  },
-  "details": {
-    "aggregation": "GroupByClass", // ByClass, GroupByClass, None
-    "showMethodParametersTypes": false,
-    "showMethodParametersNames": false,
-    "showMethodReturnType": false,
-    "showPackageLevels": 2,
-    "showCallOrder": false,
-    "edgeMode": "MethodsOnly", // TypesOnly, MethodsOnly, TypesAndMethods, MethodsAndDirectTypeUsage
-    "showDetailedClassStructure": false
-  },
-  "rootClass": "net.micode.notes.gtask.data.MetaData",
-  "extensionCallbackMethod": "" // qualified.class.name#methodName - signature: public static String method(String)
-}
-diagram meta data end '/
-
-
-
-digraph g {
-    rankdir="LR"
-    splines=polyline
-    
-
-'nodes 
-subgraph cluster_1074360951 { 
-   	label=micode
-	labeljust=l
-	fillcolor="#ececec"
-	style=filled
-   
-   subgraph cluster_502284772 { 
-   	label=notes
-	labeljust=l
-	fillcolor="#d8d8d8"
-	style=filled
-   
-   subgraph cluster_1368530406 { 
-   	label=GTaskManager
-	labeljust=l
-	fillcolor=white
-	style=filled
-   
-   GTaskManager641041527XXXsync656730312[
-	label="+ sync()"
-	style=filled
-	fillcolor=white
-	tooltip="GTaskManager
-
-null"
-	fontcolor=darkgreen
-];
-} 
-
-subgraph cluster_633221264 { 
-   	label=MetaData
-	labeljust=l
-	fillcolor=white
-	style=filled
-   
-   MetaData617846867XXXisWorthSaving0[
-	label="+ isWorthSaving()"
-	style=filled
-	fillcolor=white
-	tooltip="MetaData
-
-null"
-	penwidth=4
-	fontcolor=darkgreen
-];
-} 
-} 
-} 
-
-'edges    
-GTaskManager641041527XXXsync656730312 -> MetaData617846867XXXisWorthSaving0;
-    
-}
-@enduml

小米标签及案例/源程序代码-小米便签-Notes-master/Notes-master/src/net/micode/notes/gtask/data/MetaData_3_setContentByRemoteJSON_calls.puml

@@ -1,140 +0,0 @@
-@startuml
-
-/' diagram meta data start
-config=CallConfiguration;
-{
-  "rootMethod": "net.micode.notes.gtask.data.MetaData#setContentByRemoteJSON(JSONObject)",
-  "projectClassification": {
-    "searchMode": "OpenProject", // OpenProject, AllProjects
-    "includedProjects": "",
-    "pathEndKeywords": "*.impl",
-    "isClientPath": "",
-    "isClientName": "",
-    "isTestPath": "",
-    "isTestName": "",
-    "isMappingPath": "",
-    "isMappingName": "",
-    "isDataAccessPath": "",
-    "isDataAccessName": "",
-    "isDataStructurePath": "",
-    "isDataStructureName": "",
-    "isInterfaceStructuresPath": "",
-    "isInterfaceStructuresName": "",
-    "isEntryPointPath": "",
-    "isEntryPointName": "",
-    "treatFinalFieldsAsMandatory": false
-  },
-  "graphRestriction": {
-    "classPackageExcludeFilter": "",
-    "classPackageIncludeFilter": "",
-    "classNameExcludeFilter": "",
-    "classNameIncludeFilter": "",
-    "methodNameExcludeFilter": "",
-    "methodNameIncludeFilter": "",
-    "removeByInheritance": "", // inheritance/annotation based filtering is done in a second step
-    "removeByAnnotation": "",
-    "removeByClassPackage": "", // cleanup the graph after inheritance/annotation based filtering is done
-    "removeByClassName": "",
-    "cutMappings": false,
-    "cutEnum": true,
-    "cutTests": true,
-    "cutClient": true,
-    "cutDataAccess": true,
-    "cutInterfaceStructures": true,
-    "cutDataStructures": true,
-    "cutGetterAndSetter": true,
-    "cutConstructors": true
-  },
-  "graphTraversal": {
-    "forwardDepth": 3,
-    "backwardDepth": 3,
-    "classPackageExcludeFilter": "",
-    "classPackageIncludeFilter": "",
-    "classNameExcludeFilter": "",
-    "classNameIncludeFilter": "",
-    "methodNameExcludeFilter": "",
-    "methodNameIncludeFilter": "",
-    "hideMappings": false,
-    "hideDataStructures": false,
-    "hidePrivateMethods": true,
-    "hideInterfaceCalls": true, // indirection: implementation -> interface (is hidden) -> implementation
-    "onlyShowApplicationEntryPoints": false, // root node is included
-    "useMethodCallsForStructureDiagram": "ForwardOnly" // ForwardOnly, BothDirections, No
-  },
-  "details": {
-    "aggregation": "GroupByClass", // ByClass, GroupByClass, None
-    "showMethodParametersTypes": false,
-    "showMethodParametersNames": false,
-    "showMethodReturnType": false,
-    "showPackageLevels": 2,
-    "showCallOrder": false,
-    "edgeMode": "MethodsOnly", // TypesOnly, MethodsOnly, TypesAndMethods, MethodsAndDirectTypeUsage
-    "showDetailedClassStructure": false
-  },
-  "rootClass": "net.micode.notes.gtask.data.MetaData",
-  "extensionCallbackMethod": "" // qualified.class.name#methodName - signature: public static String method(String)
-}
-diagram meta data end '/
-
-
-
-digraph g {
-    rankdir="LR"
-    splines=polyline
-    
-
-'nodes 
-subgraph cluster_1074360951 { 
-   	label=micode
-	labeljust=l
-	fillcolor="#ececec"
-	style=filled
-   
-   subgraph cluster_502284772 { 
-   	label=notes
-	labeljust=l
-	fillcolor="#d8d8d8"
-	style=filled
-   
-   subgraph cluster_1368530406 { 
-   	label=GTaskManager
-	labeljust=l
-	fillcolor=white
-	style=filled
-   
-   GTaskManager641041527XXXsync656730312[
-	label="+ sync()"
-	style=filled
-	fillcolor=white
-	tooltip="GTaskManager
-
-null"
-	fontcolor=darkgreen
-];
-} 
-
-subgraph cluster_633221264 { 
-   	label=MetaData
-	labeljust=l
-	fillcolor=white
-	style=filled
-   
-   MetaData617846867XXXsetContentByRemoteJSON1752376903[
-	label="+ setContentByRemoteJSON()"
-	style=filled
-	fillcolor=white
-	tooltip="MetaData
-
-null"
-	penwidth=4
-	fontcolor=darkgreen
-];
-} 
-} 
-} 
-
-'edges    
-GTaskManager641041527XXXsync656730312 -> MetaData617846867XXXsetContentByRemoteJSON1752376903;
-    
-}
-@enduml

小米标签及案例/源程序代码-小米便签-Notes-master/Notes-master/src/net/micode/notes/gtask/data/MetaData_4_setContentByLocalJSON_calls.puml

@@ -1,123 +0,0 @@
-@startuml
-
-/' diagram meta data start
-config=CallConfiguration;
-{
-  "rootMethod": "net.micode.notes.gtask.data.MetaData#setContentByLocalJSON(JSONObject)",
-  "projectClassification": {
-    "searchMode": "OpenProject", // OpenProject, AllProjects
-    "includedProjects": "",
-    "pathEndKeywords": "*.impl",
-    "isClientPath": "",
-    "isClientName": "",
-    "isTestPath": "",
-    "isTestName": "",
-    "isMappingPath": "",
-    "isMappingName": "",
-    "isDataAccessPath": "",
-    "isDataAccessName": "",
-    "isDataStructurePath": "",
-    "isDataStructureName": "",
-    "isInterfaceStructuresPath": "",
-    "isInterfaceStructuresName": "",
-    "isEntryPointPath": "",
-    "isEntryPointName": "",
-    "treatFinalFieldsAsMandatory": false
-  },
-  "graphRestriction": {
-    "classPackageExcludeFilter": "",
-    "classPackageIncludeFilter": "",
-    "classNameExcludeFilter": "",
-    "classNameIncludeFilter": "",
-    "methodNameExcludeFilter": "",
-    "methodNameIncludeFilter": "",
-    "removeByInheritance": "", // inheritance/annotation based filtering is done in a second step
-    "removeByAnnotation": "",
-    "removeByClassPackage": "", // cleanup the graph after inheritance/annotation based filtering is done
-    "removeByClassName": "",
-    "cutMappings": false,
-    "cutEnum": true,
-    "cutTests": true,
-    "cutClient": true,
-    "cutDataAccess": true,
-    "cutInterfaceStructures": true,
-    "cutDataStructures": true,
-    "cutGetterAndSetter": true,
-    "cutConstructors": true
-  },
-  "graphTraversal": {
-    "forwardDepth": 3,
-    "backwardDepth": 3,
-    "classPackageExcludeFilter": "",
-    "classPackageIncludeFilter": "",
-    "classNameExcludeFilter": "",
-    "classNameIncludeFilter": "",
-    "methodNameExcludeFilter": "",
-    "methodNameIncludeFilter": "",
-    "hideMappings": false,
-    "hideDataStructures": false,
-    "hidePrivateMethods": true,
-    "hideInterfaceCalls": true, // indirection: implementation -> interface (is hidden) -> implementation
-    "onlyShowApplicationEntryPoints": false, // root node is included
-    "useMethodCallsForStructureDiagram": "ForwardOnly" // ForwardOnly, BothDirections, No
-  },
-  "details": {
-    "aggregation": "GroupByClass", // ByClass, GroupByClass, None
-    "showMethodParametersTypes": false,
-    "showMethodParametersNames": false,
-    "showMethodReturnType": false,
-    "showPackageLevels": 2,
-    "showCallOrder": false,
-    "edgeMode": "MethodsOnly", // TypesOnly, MethodsOnly, TypesAndMethods, MethodsAndDirectTypeUsage
-    "showDetailedClassStructure": false
-  },
-  "rootClass": "net.micode.notes.gtask.data.MetaData",
-  "extensionCallbackMethod": "" // qualified.class.name#methodName - signature: public static String method(String)
-}
-diagram meta data end '/
-
-
-
-digraph g {
-    rankdir="LR"
-    splines=polyline
-    
-
-'nodes 
-subgraph cluster_1074360951 { 
-   	label=micode
-	labeljust=l
-	fillcolor="#ececec"
-	style=filled
-   
-   subgraph cluster_502284772 { 
-   	label=notes
-	labeljust=l
-	fillcolor="#d8d8d8"
-	style=filled
-   
-   subgraph cluster_633221264 { 
-   	label=MetaData
-	labeljust=l
-	fillcolor=white
-	style=filled
-   
-   MetaData617846867XXXsetContentByLocalJSON1752376903[
-	label="+ setContentByLocalJSON()"
-	style=filled
-	fillcolor=white
-	tooltip="MetaData
-
-null"
-	penwidth=4
-	fontcolor=darkgreen
-];
-} 
-} 
-} 
-
-'edges    
-
-    
-}
-@enduml

小米标签及案例/源程序代码-小米便签-Notes-master/Notes-master/src/net/micode/notes/gtask/data/MetaData_5_getLocalJSONFromContent_calls.puml

@@ -1,123 +0,0 @@
-@startuml
-
-/' diagram meta data start
-config=CallConfiguration;
-{
-  "rootMethod": "net.micode.notes.gtask.data.MetaData#getLocalJSONFromContent()",
-  "projectClassification": {
-    "searchMode": "OpenProject", // OpenProject, AllProjects
-    "includedProjects": "",
-    "pathEndKeywords": "*.impl",
-    "isClientPath": "",
-    "isClientName": "",
-    "isTestPath": "",
-    "isTestName": "",
-    "isMappingPath": "",
-    "isMappingName": "",
-    "isDataAccessPath": "",
-    "isDataAccessName": "",
-    "isDataStructurePath": "",
-    "isDataStructureName": "",
-    "isInterfaceStructuresPath": "",
-    "isInterfaceStructuresName": "",
-    "isEntryPointPath": "",
-    "isEntryPointName": "",
-    "treatFinalFieldsAsMandatory": false
-  },
-  "graphRestriction": {
-    "classPackageExcludeFilter": "",
-    "classPackageIncludeFilter": "",
-    "classNameExcludeFilter": "",
-    "classNameIncludeFilter": "",
-    "methodNameExcludeFilter": "",
-    "methodNameIncludeFilter": "",
-    "removeByInheritance": "", // inheritance/annotation based filtering is done in a second step
-    "removeByAnnotation": "",
-    "removeByClassPackage": "", // cleanup the graph after inheritance/annotation based filtering is done
-    "removeByClassName": "",
-    "cutMappings": false,
-    "cutEnum": true,
-    "cutTests": true,
-    "cutClient": true,
-    "cutDataAccess": true,
-    "cutInterfaceStructures": true,
-    "cutDataStructures": true,
-    "cutGetterAndSetter": true,
-    "cutConstructors": true
-  },
-  "graphTraversal": {
-    "forwardDepth": 3,
-    "backwardDepth": 3,
-    "classPackageExcludeFilter": "",
-    "classPackageIncludeFilter": "",
-    "classNameExcludeFilter": "",
-    "classNameIncludeFilter": "",
-    "methodNameExcludeFilter": "",
-    "methodNameIncludeFilter": "",
-    "hideMappings": false,
-    "hideDataStructures": false,
-    "hidePrivateMethods": true,
-    "hideInterfaceCalls": true, // indirection: implementation -> interface (is hidden) -> implementation
-    "onlyShowApplicationEntryPoints": false, // root node is included
-    "useMethodCallsForStructureDiagram": "ForwardOnly" // ForwardOnly, BothDirections, No
-  },
-  "details": {
-    "aggregation": "GroupByClass", // ByClass, GroupByClass, None
-    "showMethodParametersTypes": false,
-    "showMethodParametersNames": false,
-    "showMethodReturnType": false,
-    "showPackageLevels": 2,
-    "showCallOrder": false,
-    "edgeMode": "MethodsOnly", // TypesOnly, MethodsOnly, TypesAndMethods, MethodsAndDirectTypeUsage
-    "showDetailedClassStructure": false
-  },
-  "rootClass": "net.micode.notes.gtask.data.MetaData",
-  "extensionCallbackMethod": "" // qualified.class.name#methodName - signature: public static String method(String)
-}
-diagram meta data end '/
-
-
-
-digraph g {
-    rankdir="LR"
-    splines=polyline
-    
-
-'nodes 
-subgraph cluster_1074360951 { 
-   	label=micode
-	labeljust=l
-	fillcolor="#ececec"
-	style=filled
-   
-   subgraph cluster_502284772 { 
-   	label=notes
-	labeljust=l
-	fillcolor="#d8d8d8"
-	style=filled
-   
-   subgraph cluster_633221264 { 
-   	label=MetaData
-	labeljust=l
-	fillcolor=white
-	style=filled
-   
-   MetaData617846867XXXgetLocalJSONFromContent0[
-	label="+ getLocalJSONFromContent()"
-	style=filled
-	fillcolor=white
-	tooltip="MetaData
-
-null"
-	penwidth=4
-	fontcolor=darkgreen
-];
-} 
-} 
-} 
-
-'edges    
-
-    
-}
-@enduml

小米标签及案例/源程序代码-小米便签-Notes-master/Notes-master/src/net/micode/notes/gtask/data/MetaData_6_getSyncAction_calls.puml

@@ -1,176 +0,0 @@
-@startuml
-
-/' diagram meta data start
-config=CallConfiguration;
-{
-  "rootMethod": "net.micode.notes.gtask.data.MetaData#getSyncAction(Cursor)",
-  "projectClassification": {
-    "searchMode": "OpenProject", // OpenProject, AllProjects
-    "includedProjects": "",
-    "pathEndKeywords": "*.impl",
-    "isClientPath": "",
-    "isClientName": "",
-    "isTestPath": "",
-    "isTestName": "",
-    "isMappingPath": "",
-    "isMappingName": "",
-    "isDataAccessPath": "",
-    "isDataAccessName": "",
-    "isDataStructurePath": "",
-    "isDataStructureName": "",
-    "isInterfaceStructuresPath": "",
-    "isInterfaceStructuresName": "",
-    "isEntryPointPath": "",
-    "isEntryPointName": "",
-    "treatFinalFieldsAsMandatory": false
-  },
-  "graphRestriction": {
-    "classPackageExcludeFilter": "",
-    "classPackageIncludeFilter": "",
-    "classNameExcludeFilter": "",
-    "classNameIncludeFilter": "",
-    "methodNameExcludeFilter": "",
-    "methodNameIncludeFilter": "",
-    "removeByInheritance": "", // inheritance/annotation based filtering is done in a second step
-    "removeByAnnotation": "",
-    "removeByClassPackage": "", // cleanup the graph after inheritance/annotation based filtering is done
-    "removeByClassName": "",
-    "cutMappings": false,
-    "cutEnum": true,
-    "cutTests": true,
-    "cutClient": true,
-    "cutDataAccess": true,
-    "cutInterfaceStructures": true,
-    "cutDataStructures": true,
-    "cutGetterAndSetter": true,
-    "cutConstructors": true
-  },
-  "graphTraversal": {
-    "forwardDepth": 3,
-    "backwardDepth": 3,
-    "classPackageExcludeFilter": "",
-    "classPackageIncludeFilter": "",
-    "classNameExcludeFilter": "",
-    "classNameIncludeFilter": "",
-    "methodNameExcludeFilter": "",
-    "methodNameIncludeFilter": "",
-    "hideMappings": false,
-    "hideDataStructures": false,
-    "hidePrivateMethods": true,
-    "hideInterfaceCalls": true, // indirection: implementation -> interface (is hidden) -> implementation
-    "onlyShowApplicationEntryPoints": false, // root node is included
-    "useMethodCallsForStructureDiagram": "ForwardOnly" // ForwardOnly, BothDirections, No
-  },
-  "details": {
-    "aggregation": "GroupByClass", // ByClass, GroupByClass, None
-    "showMethodParametersTypes": false,
-    "showMethodParametersNames": false,
-    "showMethodReturnType": false,
-    "showPackageLevels": 2,
-    "showCallOrder": false,
-    "edgeMode": "MethodsOnly", // TypesOnly, MethodsOnly, TypesAndMethods, MethodsAndDirectTypeUsage
-    "showDetailedClassStructure": false
-  },
-  "rootClass": "net.micode.notes.gtask.data.MetaData",
-  "extensionCallbackMethod": "" // qualified.class.name#methodName - signature: public static String method(String)
-}
-diagram meta data end '/
-
-
-
-digraph g {
-    rankdir="LR"
-    splines=polyline
-    
-
-'nodes 
-subgraph cluster_1074360951 { 
-   	label=micode
-	labeljust=l
-	fillcolor="#ececec"
-	style=filled
-   
-   subgraph cluster_502284772 { 
-   	label=notes
-	labeljust=l
-	fillcolor="#d8d8d8"
-	style=filled
-   
-   subgraph cluster_1368530406 { 
-   	label=GTaskManager
-	labeljust=l
-	fillcolor=white
-	style=filled
-   
-   GTaskManager641041527XXXsync656730312[
-	label="+ sync()"
-	style=filled
-	fillcolor=white
-	tooltip="GTaskManager
-
-null"
-	fontcolor=darkgreen
-];
-} 
-
-subgraph cluster_633221264 { 
-   	label=MetaData
-	labeljust=l
-	fillcolor=white
-	style=filled
-   
-   MetaData617846867XXXgetSyncAction2029715318[
-	label="+ getSyncAction()"
-	style=filled
-	fillcolor=white
-	tooltip="MetaData
-
-null"
-	penwidth=4
-	fontcolor=darkgreen
-];
-} 
-
-subgraph cluster_761247683 { 
-   	label=Node
-	labeljust=l
-	fillcolor=white
-	style=filled
-   
-   Node617846867XXXgetSyncAction2029715318[
-	label="+ getSyncAction()"
-	style=filled
-	fillcolor=white
-	tooltip="Node
-
-null"
-	fontcolor=darkgreen
-];
-} 
-
-subgraph cluster_761413446 { 
-   	label=Task
-	labeljust=l
-	fillcolor=white
-	style=filled
-   
-   Task617846867XXXgetSyncAction2029715318[
-	label="+ getSyncAction()"
-	style=filled
-	fillcolor=white
-	tooltip="Task
-
-null"
-	fontcolor=darkgreen
-];
-} 
-} 
-} 
-
-'edges    
-GTaskManager641041527XXXsync656730312 -> Node617846867XXXgetSyncAction2029715318;
-Node617846867XXXgetSyncAction2029715318 -> Task617846867XXXgetSyncAction2029715318;
-Task617846867XXXgetSyncAction2029715318 -> MetaData617846867XXXgetSyncAction2029715318;
-    
-}
-@enduml

小米标签及案例/源程序代码-小米便签-Notes-master/Notes-master/src/net/micode/notes/gtask/data/MetaData_getLocalJSONFromContent_flow.puml

@@ -1,83 +0,0 @@
-@startuml
-
-/' diagram meta data start
-config=FlowConfiguration;
-{
-  "rootMethod": "net.micode.notes.gtask.data.MetaData#getLocalJSONFromContent()",
-  "projectClassification": {
-    "searchMode": "OpenProject", // OpenProject, AllProjects
-    "includedProjects": "",
-    "pathEndKeywords": "*.impl",
-    "isClientPath": "",
-    "isClientName": "",
-    "isTestPath": "",
-    "isTestName": "",
-    "isMappingPath": "",
-    "isMappingName": "",
-    "isDataAccessPath": "",
-    "isDataAccessName": "",
-    "isDataStructurePath": "",
-    "isDataStructureName": "",
-    "isInterfaceStructuresPath": "",
-    "isInterfaceStructuresName": "",
-    "isEntryPointPath": "",
-    "isEntryPointName": "",
-    "treatFinalFieldsAsMandatory": false
-  },
-  "graphRestriction": {
-    "classPackageExcludeFilter": "",
-    "classPackageIncludeFilter": "",
-    "classNameExcludeFilter": "",
-    "classNameIncludeFilter": "",
-    "methodNameExcludeFilter": "",
-    "methodNameIncludeFilter": "",
-    "removeByInheritance": "", // inheritance/annotation based filtering is done in a second step
-    "removeByAnnotation": "",
-    "removeByClassPackage": "", // cleanup the graph after inheritance/annotation based filtering is done
-    "removeByClassName": "",
-    "cutMappings": false,
-    "cutEnum": false,
-    "cutTests": true,
-    "cutClient": true,
-    "cutDataAccess": false,
-    "cutInterfaceStructures": false,
-    "cutDataStructures": false,
-    "cutGetterAndSetter": false,
-    "cutConstructors": false
-  },
-  "graphTraversal": {
-    "forwardDepth": 999,
-    "backwardDepth": 0,
-    "classPackageExcludeFilter": "",
-    "classPackageIncludeFilter": "",
-    "classNameExcludeFilter": "",
-    "classNameIncludeFilter": "",
-    "methodNameExcludeFilter": "",
-    "methodNameIncludeFilter": "",
-    "hideMappings": false,
-    "hideDataStructures": false,
-    "hidePrivateMethods": false,
-    "hideInterfaceCalls": false, // indirection: implementation -> interface (is hidden) -> implementation
-    "onlyShowApplicationEntryPoints": false, // root node is included
-    "useMethodCallsForStructureDiagram": "ForwardOnly" // ForwardOnly, BothDirections, No
-  },
-  "rootClass": "net.micode.notes.gtask.data.MetaData",
-  "extensionCallbackMethod": "" // qualified.class.name#methodName - signature: public static String method(String)
-}
-diagram meta data end '/
-
-
-
-digraph g {
-    rankdir="TB"
-    splines=polyline
-    
-
-'nodes 
-
-
-'edges    
-
-    
-}
-@enduml

小米标签及案例/源程序代码-小米便签-Notes-master/Notes-master/src/net/micode/notes/gtask/data/MetaData_getSyncAction_flow.puml

@@ -1,83 +0,0 @@
-@startuml
-
-/' diagram meta data start
-config=FlowConfiguration;
-{
-  "rootMethod": "net.micode.notes.gtask.data.MetaData#getSyncAction(Cursor)",
-  "projectClassification": {
-    "searchMode": "OpenProject", // OpenProject, AllProjects
-    "includedProjects": "",
-    "pathEndKeywords": "*.impl",
-    "isClientPath": "",
-    "isClientName": "",
-    "isTestPath": "",
-    "isTestName": "",
-    "isMappingPath": "",
-    "isMappingName": "",
-    "isDataAccessPath": "",
-    "isDataAccessName": "",
-    "isDataStructurePath": "",
-    "isDataStructureName": "",
-    "isInterfaceStructuresPath": "",
-    "isInterfaceStructuresName": "",
-    "isEntryPointPath": "",
-    "isEntryPointName": "",
-    "treatFinalFieldsAsMandatory": false
-  },
-  "graphRestriction": {
-    "classPackageExcludeFilter": "",
-    "classPackageIncludeFilter": "",
-    "classNameExcludeFilter": "",
-    "classNameIncludeFilter": "",
-    "methodNameExcludeFilter": "",
-    "methodNameIncludeFilter": "",
-    "removeByInheritance": "", // inheritance/annotation based filtering is done in a second step
-    "removeByAnnotation": "",
-    "removeByClassPackage": "", // cleanup the graph after inheritance/annotation based filtering is done
-    "removeByClassName": "",
-    "cutMappings": false,
-    "cutEnum": false,
-    "cutTests": true,
-    "cutClient": true,
-    "cutDataAccess": false,
-    "cutInterfaceStructures": false,
-    "cutDataStructures": false,
-    "cutGetterAndSetter": false,
-    "cutConstructors": false
-  },
-  "graphTraversal": {
-    "forwardDepth": 999,
-    "backwardDepth": 0,
-    "classPackageExcludeFilter": "",
-    "classPackageIncludeFilter": "",
-    "classNameExcludeFilter": "",
-    "classNameIncludeFilter": "",
-    "methodNameExcludeFilter": "",
-    "methodNameIncludeFilter": "",
-    "hideMappings": false,
-    "hideDataStructures": false,
-    "hidePrivateMethods": false,
-    "hideInterfaceCalls": false, // indirection: implementation -> interface (is hidden) -> implementation
-    "onlyShowApplicationEntryPoints": false, // root node is included
-    "useMethodCallsForStructureDiagram": "ForwardOnly" // ForwardOnly, BothDirections, No
-  },
-  "rootClass": "net.micode.notes.gtask.data.MetaData",
-  "extensionCallbackMethod": "" // qualified.class.name#methodName - signature: public static String method(String)
-}
-diagram meta data end '/
-
-
-
-digraph g {
-    rankdir="TB"
-    splines=polyline
-    
-
-'nodes 
-
-
-'edges    
-
-    
-}
-@enduml

小米标签及案例/源程序代码-小米便签-Notes-master/Notes-master/src/net/micode/notes/gtask/data/MetaData_isWorthSaving_flow.puml

@@ -1,83 +0,0 @@
-@startuml
-
-/' diagram meta data start
-config=FlowConfiguration;
-{
-  "rootMethod": "net.micode.notes.gtask.data.MetaData#isWorthSaving()",
-  "projectClassification": {
-    "searchMode": "OpenProject", // OpenProject, AllProjects
-    "includedProjects": "",
-    "pathEndKeywords": "*.impl",
-    "isClientPath": "",
-    "isClientName": "",
-    "isTestPath": "",
-    "isTestName": "",
-    "isMappingPath": "",
-    "isMappingName": "",
-    "isDataAccessPath": "",
-    "isDataAccessName": "",
-    "isDataStructurePath": "",
-    "isDataStructureName": "",
-    "isInterfaceStructuresPath": "",
-    "isInterfaceStructuresName": "",
-    "isEntryPointPath": "",
-    "isEntryPointName": "",
-    "treatFinalFieldsAsMandatory": false
-  },
-  "graphRestriction": {
-    "classPackageExcludeFilter": "",
-    "classPackageIncludeFilter": "",
-    "classNameExcludeFilter": "",
-    "classNameIncludeFilter": "",
-    "methodNameExcludeFilter": "",
-    "methodNameIncludeFilter": "",
-    "removeByInheritance": "", // inheritance/annotation based filtering is done in a second step
-    "removeByAnnotation": "",
-    "removeByClassPackage": "", // cleanup the graph after inheritance/annotation based filtering is done
-    "removeByClassName": "",
-    "cutMappings": false,
-    "cutEnum": false,
-    "cutTests": true,
-    "cutClient": true,
-    "cutDataAccess": false,
-    "cutInterfaceStructures": false,
-    "cutDataStructures": false,
-    "cutGetterAndSetter": false,
-    "cutConstructors": false
-  },
-  "graphTraversal": {
-    "forwardDepth": 999,
-    "backwardDepth": 0,
-    "classPackageExcludeFilter": "",
-    "classPackageIncludeFilter": "",
-    "classNameExcludeFilter": "",
-    "classNameIncludeFilter": "",
-    "methodNameExcludeFilter": "",
-    "methodNameIncludeFilter": "",
-    "hideMappings": false,
-    "hideDataStructures": false,
-    "hidePrivateMethods": false,
-    "hideInterfaceCalls": false, // indirection: implementation -> interface (is hidden) -> implementation
-    "onlyShowApplicationEntryPoints": false, // root node is included
-    "useMethodCallsForStructureDiagram": "ForwardOnly" // ForwardOnly, BothDirections, No
-  },
-  "rootClass": "net.micode.notes.gtask.data.MetaData",
-  "extensionCallbackMethod": "" // qualified.class.name#methodName - signature: public static String method(String)
-}
-diagram meta data end '/
-
-
-
-digraph g {
-    rankdir="TB"
-    splines=polyline
-    
-
-'nodes 
-
-
-'edges    
-
-    
-}
-@enduml

小米标签及案例/源程序代码-小米便签-Notes-master/Notes-master/src/net/micode/notes/gtask/data/MetaData_setContentByLocalJSON_flow.puml

@@ -1,83 +0,0 @@
-@startuml
-
-/' diagram meta data start
-config=FlowConfiguration;
-{
-  "rootMethod": "net.micode.notes.gtask.data.MetaData#setContentByLocalJSON(JSONObject)",
-  "projectClassification": {
-    "searchMode": "OpenProject", // OpenProject, AllProjects
-    "includedProjects": "",
-    "pathEndKeywords": "*.impl",
-    "isClientPath": "",
-    "isClientName": "",
-    "isTestPath": "",
-    "isTestName": "",
-    "isMappingPath": "",
-    "isMappingName": "",
-    "isDataAccessPath": "",
-    "isDataAccessName": "",
-    "isDataStructurePath": "",
-    "isDataStructureName": "",
-    "isInterfaceStructuresPath": "",
-    "isInterfaceStructuresName": "",
-    "isEntryPointPath": "",
-    "isEntryPointName": "",
-    "treatFinalFieldsAsMandatory": false
-  },
-  "graphRestriction": {
-    "classPackageExcludeFilter": "",
-    "classPackageIncludeFilter": "",
-    "classNameExcludeFilter": "",
-    "classNameIncludeFilter": "",
-    "methodNameExcludeFilter": "",
-    "methodNameIncludeFilter": "",
-    "removeByInheritance": "", // inheritance/annotation based filtering is done in a second step
-    "removeByAnnotation": "",
-    "removeByClassPackage": "", // cleanup the graph after inheritance/annotation based filtering is done
-    "removeByClassName": "",
-    "cutMappings": false,
-    "cutEnum": false,
-    "cutTests": true,
-    "cutClient": true,
-    "cutDataAccess": false,
-    "cutInterfaceStructures": false,
-    "cutDataStructures": false,
-    "cutGetterAndSetter": false,
-    "cutConstructors": false
-  },
-  "graphTraversal": {
-    "forwardDepth": 999,
-    "backwardDepth": 0,
-    "classPackageExcludeFilter": "",
-    "classPackageIncludeFilter": "",
-    "classNameExcludeFilter": "",
-    "classNameIncludeFilter": "",
-    "methodNameExcludeFilter": "",
-    "methodNameIncludeFilter": "",
-    "hideMappings": false,
-    "hideDataStructures": false,
-    "hidePrivateMethods": false,
-    "hideInterfaceCalls": false, // indirection: implementation -> interface (is hidden) -> implementation
-    "onlyShowApplicationEntryPoints": false, // root node is included
-    "useMethodCallsForStructureDiagram": "ForwardOnly" // ForwardOnly, BothDirections, No
-  },
-  "rootClass": "net.micode.notes.gtask.data.MetaData",
-  "extensionCallbackMethod": "" // qualified.class.name#methodName - signature: public static String method(String)
-}
-diagram meta data end '/
-
-
-
-digraph g {
-    rankdir="TB"
-    splines=polyline
-    
-
-'nodes 
-
-
-'edges    
-
-    
-}
-@enduml

小米标签及案例/源程序代码-小米便签-Notes-master/Notes-master/src/net/micode/notes/gtask/data/MetaData_setContentByRemoteJSON_flow.puml

@@ -1,83 +0,0 @@
-@startuml
-
-/' diagram meta data start
-config=FlowConfiguration;
-{
-  "rootMethod": "net.micode.notes.gtask.data.MetaData#setContentByRemoteJSON(JSONObject)",
-  "projectClassification": {
-    "searchMode": "OpenProject", // OpenProject, AllProjects
-    "includedProjects": "",
-    "pathEndKeywords": "*.impl",
-    "isClientPath": "",
-    "isClientName": "",
-    "isTestPath": "",
-    "isTestName": "",
-    "isMappingPath": "",
-    "isMappingName": "",
-    "isDataAccessPath": "",
-    "isDataAccessName": "",
-    "isDataStructurePath": "",
-    "isDataStructureName": "",
-    "isInterfaceStructuresPath": "",
-    "isInterfaceStructuresName": "",
-    "isEntryPointPath": "",
-    "isEntryPointName": "",
-    "treatFinalFieldsAsMandatory": false
-  },
-  "graphRestriction": {
-    "classPackageExcludeFilter": "",
-    "classPackageIncludeFilter": "",
-    "classNameExcludeFilter": "",
-    "classNameIncludeFilter": "",
-    "methodNameExcludeFilter": "",
-    "methodNameIncludeFilter": "",
-    "removeByInheritance": "", // inheritance/annotation based filtering is done in a second step
-    "removeByAnnotation": "",
-    "removeByClassPackage": "", // cleanup the graph after inheritance/annotation based filtering is done
-    "removeByClassName": "",
-    "cutMappings": false,
-    "cutEnum": false,
-    "cutTests": true,
-    "cutClient": true,
-    "cutDataAccess": false,
-    "cutInterfaceStructures": false,
-    "cutDataStructures": false,
-    "cutGetterAndSetter": false,
-    "cutConstructors": false
-  },
-  "graphTraversal": {
-    "forwardDepth": 999,
-    "backwardDepth": 0,
-    "classPackageExcludeFilter": "",
-    "classPackageIncludeFilter": "",
-    "classNameExcludeFilter": "",
-    "classNameIncludeFilter": "",
-    "methodNameExcludeFilter": "",
-    "methodNameIncludeFilter": "",
-    "hideMappings": false,
-    "hideDataStructures": false,
-    "hidePrivateMethods": false,
-    "hideInterfaceCalls": false, // indirection: implementation -> interface (is hidden) -> implementation
-    "onlyShowApplicationEntryPoints": false, // root node is included
-    "useMethodCallsForStructureDiagram": "ForwardOnly" // ForwardOnly, BothDirections, No
-  },
-  "rootClass": "net.micode.notes.gtask.data.MetaData",
-  "extensionCallbackMethod": "" // qualified.class.name#methodName - signature: public static String method(String)
-}
-diagram meta data end '/
-
-
-
-digraph g {
-    rankdir="TB"
-    splines=polyline
-    
-
-'nodes 
-
-
-'edges    
-
-    
-}
-@enduml

小米标签及案例/源程序代码-小米便签-Notes-master/Notes-master/src/net/micode/notes/gtask/data/MetaData_structure.puml

@@ -1,256 +0,0 @@
-@startuml
-
-/' diagram meta data start
-config=StructureConfiguration;
-{
-  "projectClassification": {
-    "searchMode": "OpenProject", // OpenProject, AllProjects
-    "includedProjects": "",
-    "pathEndKeywords": "*.impl",
-    "isClientPath": "",
-    "isClientName": "",
-    "isTestPath": "",
-    "isTestName": "",
-    "isMappingPath": "",
-    "isMappingName": "",
-    "isDataAccessPath": "",
-    "isDataAccessName": "",
-    "isDataStructurePath": "",
-    "isDataStructureName": "",
-    "isInterfaceStructuresPath": "",
-    "isInterfaceStructuresName": "",
-    "isEntryPointPath": "",
-    "isEntryPointName": "",
-    "treatFinalFieldsAsMandatory": false
-  },
-  "graphRestriction": {
-    "classPackageExcludeFilter": "",
-    "classPackageIncludeFilter": "",
-    "classNameExcludeFilter": "",
-    "classNameIncludeFilter": "",
-    "methodNameExcludeFilter": "",
-    "methodNameIncludeFilter": "",
-    "removeByInheritance": "", // inheritance/annotation based filtering is done in a second step
-    "removeByAnnotation": "",
-    "removeByClassPackage": "", // cleanup the graph after inheritance/annotation based filtering is done
-    "removeByClassName": "",
-    "cutMappings": false,
-    "cutEnum": true,
-    "cutTests": true,
-    "cutClient": true,
-    "cutDataAccess": false,
-    "cutInterfaceStructures": false,
-    "cutDataStructures": false,
-    "cutGetterAndSetter": true,
-    "cutConstructors": true
-  },
-  "graphTraversal": {
-    "forwardDepth": 6,
-    "backwardDepth": 6,
-    "classPackageExcludeFilter": "",
-    "classPackageIncludeFilter": "",
-    "classNameExcludeFilter": "",
-    "classNameIncludeFilter": "",
-    "methodNameExcludeFilter": "",
-    "methodNameIncludeFilter": "",
-    "hideMappings": false,
-    "hideDataStructures": false,
-    "hidePrivateMethods": true,
-    "hideInterfaceCalls": true, // indirection: implementation -> interface (is hidden) -> implementation
-    "onlyShowApplicationEntryPoints": false, // root node is included
-    "useMethodCallsForStructureDiagram": "ForwardOnly" // ForwardOnly, BothDirections, No
-  },
-  "details": {
-    "aggregation": "GroupByClass", // ByClass, GroupByClass, None
-    "showClassGenericTypes": true,
-    "showMethods": true,
-    "showMethodParameterNames": true,
-    "showMethodParameterTypes": true,
-    "showMethodReturnType": true,
-    "showPackageLevels": 2,
-    "showDetailedClassStructure": true
-  },
-  "rootClass": "net.micode.notes.gtask.data.MetaData",
-  "extensionCallbackMethod": "" // qualified.class.name#methodName - signature: public static String method(String)
-}
-diagram meta data end '/
-
-
-
-digraph g {
-    rankdir="TB"
-    splines=polyline
-    
-
-'nodes 
-subgraph cluster_1074360951 { 
-   	label=micode
-	labeljust=l
-	fillcolor="#ececec"
-	style=filled
-   
-   subgraph cluster_502284772 { 
-   	label=notes
-	labeljust=l
-	fillcolor="#d8d8d8"
-	style=filled
-   
-   GTaskASyncTask641041527[
-	label=<<TABLE BORDER="1" CELLBORDER="0" CELLPADDING="4" CELLSPACING="0">
-<TR><TD ALIGN="LEFT" >(C)GTaskASyncTask</TD></TR>
-<HR/>
-<TR><TD ALIGN="LEFT" >-   mContext: Context [0..1]</TD></TR>
-<TR><TD ALIGN="LEFT" >-   mNotifiManager: NotificationManager [0..1]</TD></TR>
-<TR><TD ALIGN="LEFT" >-   mOnCompleteListener: OnCompleteListener [0..1]</TD></TR>
-<TR><TD ALIGN="LEFT" >-   mTaskManager: GTaskManager [0..1]</TD></TR>
-<HR/>
-<TR><TD ALIGN="LEFT" >+ cancelSync()</TD></TR>
-<TR><TD ALIGN="LEFT" ># doInBackground(unused: Void...): Integer</TD></TR>
-<TR><TD ALIGN="LEFT" ># onPostExecute(result: Integer)</TD></TR>
-<TR><TD ALIGN="LEFT" ># onProgressUpdate(progress: String...)</TD></TR>
-<TR><TD ALIGN="LEFT" >+ publishProgess(message: String)</TD></TR>
-<TR><TD ALIGN="LEFT" >- showNotification(tickerId: int, content: String)</TD></TR>
-</TABLE>>
-	style=filled
-	margin=0
-	shape=plaintext
-	fillcolor="#FFFFFF"
-];
-
-GTaskManager641041527[
-	label=<<TABLE BORDER="1" CELLBORDER="0" CELLPADDING="4" CELLSPACING="0">
-<TR><TD ALIGN="LEFT" >(C)GTaskManager</TD></TR>
-<HR/>
-<TR><TD ALIGN="LEFT" >-   mActivity: Activity [0..1]</TD></TR>
-<TR><TD ALIGN="LEFT" >-   mCancelled: boolean [1]</TD></TR>
-<TR><TD ALIGN="LEFT" >-   mContentResolver: ContentResolver [0..1]</TD></TR>
-<TR><TD ALIGN="LEFT" >-   mContext: Context [0..1]</TD></TR>
-<TR><TD ALIGN="LEFT" >-   mGTaskHashMap: HashMap&lt;String, Node&gt; [0..*]</TD></TR>
-<TR><TD ALIGN="LEFT" >-   mGTaskListHashMap: HashMap&lt;String, TaskList&gt; [0..*]</TD></TR>
-<TR><TD ALIGN="LEFT" >-   mGidToNid: HashMap&lt;String, Long&gt; [0..*]</TD></TR>
-<TR><TD ALIGN="LEFT" >-   mLocalDeleteIdMap: HashSet&lt;Long&gt; [0..*]</TD></TR>
-<TR><TD ALIGN="LEFT" >-   mMetaHashMap: HashMap&lt;String, MetaData&gt; [0..*]</TD></TR>
-<TR><TD ALIGN="LEFT" >-   mMetaList: TaskList [0..1]</TD></TR>
-<TR><TD ALIGN="LEFT" >-   mNidToGid: HashMap&lt;Long, String&gt; [0..*]</TD></TR>
-<TR><TD ALIGN="LEFT" >-   mSyncing: boolean [1]</TD></TR>
-<HR/>
-<TR><TD ALIGN="LEFT" >- addLocalNode(node: Node)</TD></TR>
-<TR><TD ALIGN="LEFT" >- addRemoteNode(node: Node, c: Cursor)</TD></TR>
-<TR><TD ALIGN="LEFT" >+ cancelSync()</TD></TR>
-<TR><TD ALIGN="LEFT" >- doContentSync(syncType: int, node: Node, c: Cursor)</TD></TR>
-<TR><TD ALIGN="LEFT" >- initGTaskList()</TD></TR>
-<TR><TD ALIGN="LEFT" >- refreshLocalSyncId()</TD></TR>
-<TR><TD ALIGN="LEFT" >+ sync(context: Context, asyncTask: GTaskASyncTask): int</TD></TR>
-<TR><TD ALIGN="LEFT" >- syncContent()</TD></TR>
-<TR><TD ALIGN="LEFT" >- syncFolder()</TD></TR>
-<TR><TD ALIGN="LEFT" >- updateLocalNode(node: Node, c: Cursor)</TD></TR>
-<TR><TD ALIGN="LEFT" >- updateRemoteMeta(gid: String, sqlNote: SqlNote)</TD></TR>
-<TR><TD ALIGN="LEFT" >- updateRemoteNode(node: Node, c: Cursor)</TD></TR>
-</TABLE>>
-	style=filled
-	margin=0
-	shape=plaintext
-	fillcolor="#FFFFFF"
-];
-
-MetaData617846867[
-	label=<<TABLE BORDER="1" CELLBORDER="0" CELLPADDING="4" CELLSPACING="0">
-<TR><TD ALIGN="LEFT" >(C)MetaData</TD></TR>
-<HR/>
-<TR><TD ALIGN="LEFT" >-   mRelatedGid: String [0..1]</TD></TR>
-<HR/>
-<TR><TD ALIGN="LEFT" >+ getSyncAction(c: Cursor): int</TD></TR>
-</TABLE>>
-	style=filled
-	margin=0
-	shape=plaintext
-	fillcolor="#FFFFFF"
-];
-
-Node617846867[
-	label=<<TABLE BORDER="1" CELLBORDER="0" CELLPADDING="4" CELLSPACING="0">
-<TR><TD ALIGN="LEFT" >(C)Node</TD></TR>
-<HR/>
-<TR><TD ALIGN="LEFT" >-   mDeleted: boolean [1]</TD></TR>
-<TR><TD ALIGN="LEFT" >-   mGid: String [0..1]</TD></TR>
-<TR><TD ALIGN="LEFT" >-   mLastModified: long [1]</TD></TR>
-<TR><TD ALIGN="LEFT" >-   mName: String [0..1]</TD></TR>
-<HR/>
-<TR><TD ALIGN="LEFT" >+ getCreateAction(actionId: int): JSONObject</TD></TR>
-<TR><TD ALIGN="LEFT" >+ getSyncAction(c: Cursor): int</TD></TR>
-<TR><TD ALIGN="LEFT" >+ getUpdateAction(actionId: int): JSONObject</TD></TR>
-</TABLE>>
-	style=filled
-	margin=0
-	shape=plaintext
-	fillcolor="#FFFFFF"
-];
-
-Task617846867[
-	label=<<TABLE BORDER="1" CELLBORDER="0" CELLPADDING="4" CELLSPACING="0">
-<TR><TD ALIGN="LEFT" >(C)Task</TD></TR>
-<HR/>
-<TR><TD ALIGN="LEFT" >-   mCompleted: boolean [1]</TD></TR>
-<TR><TD ALIGN="LEFT" >-   mMetaInfo: JSONObject [0..1]</TD></TR>
-<TR><TD ALIGN="LEFT" >-   mNotes: String [0..1]</TD></TR>
-<TR><TD ALIGN="LEFT" >-   mParent: TaskList [0..1]</TD></TR>
-<TR><TD ALIGN="LEFT" >-   mPriorSibling: Task [0..1]</TD></TR>
-<HR/>
-<TR><TD ALIGN="LEFT" >+ getCreateAction(actionId: int): JSONObject</TD></TR>
-<TR><TD ALIGN="LEFT" >+ getSyncAction(c: Cursor): int</TD></TR>
-<TR><TD ALIGN="LEFT" >+ getUpdateAction(actionId: int): JSONObject</TD></TR>
-</TABLE>>
-	style=filled
-	margin=0
-	shape=plaintext
-	fillcolor="#FFFFFF"
-];
-
-TaskList617846867[
-	label=<<TABLE BORDER="1" CELLBORDER="0" CELLPADDING="4" CELLSPACING="0">
-<TR><TD ALIGN="LEFT" >(C)TaskList</TD></TR>
-<HR/>
-<TR><TD ALIGN="LEFT" >-   mChildren: ArrayList&lt;Task&gt; [0..*]</TD></TR>
-<TR><TD ALIGN="LEFT" >-   mIndex: int [1]</TD></TR>
-<HR/>
-<TR><TD ALIGN="LEFT" >+ addChildTask(task: Task): boolean</TD></TR>
-<TR><TD ALIGN="LEFT" >+ addChildTask(task: Task, index: int): boolean</TD></TR>
-<TR><TD ALIGN="LEFT" >+ findChildTaskByGid(gid: String): Task</TD></TR>
-<TR><TD ALIGN="LEFT" >+ getChilTaskByGid(gid: String): Task</TD></TR>
-<TR><TD ALIGN="LEFT" >+ getChildTaskByIndex(index: int): Task</TD></TR>
-<TR><TD ALIGN="LEFT" >+ getChildTaskIndex(task: Task): int</TD></TR>
-<TR><TD ALIGN="LEFT" >+ getCreateAction(actionId: int): JSONObject</TD></TR>
-<TR><TD ALIGN="LEFT" >+ getSyncAction(c: Cursor): int</TD></TR>
-<TR><TD ALIGN="LEFT" >+ getUpdateAction(actionId: int): JSONObject</TD></TR>
-<TR><TD ALIGN="LEFT" >+ moveChildTask(task: Task, index: int): boolean</TD></TR>
-<TR><TD ALIGN="LEFT" >+ removeChildTask(task: Task): boolean</TD></TR>
-</TABLE>>
-	style=filled
-	margin=0
-	shape=plaintext
-	fillcolor="#FFFFFF"
-];
-} 
-} 
-
-'edges    
-GTaskASyncTask641041527 -> GTaskManager641041527[label="mTaskManager
-[0..1]"];
-GTaskManager641041527 -> MetaData617846867[label="mMetaHashMap
-[0..*]"];
-GTaskManager641041527 -> Node617846867[label="mGTaskHashMap
-[0..*]"];
-GTaskManager641041527 -> TaskList617846867[label="mGTaskListHashMap
-[0..*]"];
-GTaskManager641041527 -> TaskList617846867[label="mMetaList
-[0..1]"];
-Node617846867 -> Task617846867[arrowhead=none, arrowtail=empty, dir=both];
-Node617846867 -> TaskList617846867[arrowhead=none, arrowtail=empty, dir=both];
-Task617846867 -> MetaData617846867[arrowhead=none, arrowtail=empty, dir=both];
-Task617846867 -> TaskList617846867[label="mParent
-[0..1]"];
-TaskList617846867 -> Task617846867[label="mChildren
-[0..*]"];
-    
-}
-@enduml

小米标签及案例/源程序代码-小米便签-Notes-master/Notes-master/src/net/micode/notes/gtask/data/Node.java

@@ -47,7 +47,7 @@ public abstract class Node {
 
     private boolean mDeleted;
 
-    protected Node() {
+    public Node() {
         mGid = null;
         mName = "";
         mLastModified = 0;

小米标签及案例/源程序代码-小米便签-Notes-master/Notes-master/src/net/micode/notes/gtask/data/Node_0_Node_calls.puml

@@ -1,123 +0,0 @@
-@startuml
-
-/' diagram meta data start
-config=CallConfiguration;
-{
-  "rootMethod": "net.micode.notes.gtask.data.Node#Node()",
-  "projectClassification": {
-    "searchMode": "OpenProject", // OpenProject, AllProjects
-    "includedProjects": "",
-    "pathEndKeywords": "*.impl",
-    "isClientPath": "",
-    "isClientName": "",
-    "isTestPath": "",
-    "isTestName": "",
-    "isMappingPath": "",
-    "isMappingName": "",
-    "isDataAccessPath": "",
-    "isDataAccessName": "",
-    "isDataStructurePath": "",
-    "isDataStructureName": "",
-    "isInterfaceStructuresPath": "",
-    "isInterfaceStructuresName": "",
-    "isEntryPointPath": "",
-    "isEntryPointName": "",
-    "treatFinalFieldsAsMandatory": false
-  },
-  "graphRestriction": {
-    "classPackageExcludeFilter": "",
-    "classPackageIncludeFilter": "",
-    "classNameExcludeFilter": "",
-    "classNameIncludeFilter": "",
-    "methodNameExcludeFilter": "",
-    "methodNameIncludeFilter": "",
-    "removeByInheritance": "", // inheritance/annotation based filtering is done in a second step
-    "removeByAnnotation": "",
-    "removeByClassPackage": "", // cleanup the graph after inheritance/annotation based filtering is done
-    "removeByClassName": "",
-    "cutMappings": false,
-    "cutEnum": true,
-    "cutTests": true,
-    "cutClient": true,
-    "cutDataAccess": true,
-    "cutInterfaceStructures": true,
-    "cutDataStructures": true,
-    "cutGetterAndSetter": true,
-    "cutConstructors": true
-  },
-  "graphTraversal": {
-    "forwardDepth": 3,
-    "backwardDepth": 3,
-    "classPackageExcludeFilter": "",
-    "classPackageIncludeFilter": "",
-    "classNameExcludeFilter": "",
-    "classNameIncludeFilter": "",
-    "methodNameExcludeFilter": "",
-    "methodNameIncludeFilter": "",
-    "hideMappings": false,
-    "hideDataStructures": false,
-    "hidePrivateMethods": true,
-    "hideInterfaceCalls": true, // indirection: implementation -> interface (is hidden) -> implementation
-    "onlyShowApplicationEntryPoints": false, // root node is included
-    "useMethodCallsForStructureDiagram": "ForwardOnly" // ForwardOnly, BothDirections, No
-  },
-  "details": {
-    "aggregation": "GroupByClass", // ByClass, GroupByClass, None
-    "showMethodParametersTypes": false,
-    "showMethodParametersNames": false,
-    "showMethodReturnType": false,
-    "showPackageLevels": 2,
-    "showCallOrder": false,
-    "edgeMode": "MethodsOnly", // TypesOnly, MethodsOnly, TypesAndMethods, MethodsAndDirectTypeUsage
-    "showDetailedClassStructure": false
-  },
-  "rootClass": "net.micode.notes.gtask.data.Node",
-  "extensionCallbackMethod": "" // qualified.class.name#methodName - signature: public static String method(String)
-}
-diagram meta data end '/
-
-
-
-digraph g {
-    rankdir="LR"
-    splines=polyline
-    
-
-'nodes 
-subgraph cluster_1074360951 { 
-   	label=micode
-	labeljust=l
-	fillcolor="#ececec"
-	style=filled
-   
-   subgraph cluster_502284772 { 
-   	label=notes
-	labeljust=l
-	fillcolor="#d8d8d8"
-	style=filled
-   
-   subgraph cluster_761247683 { 
-   	label=Node
-	labeljust=l
-	fillcolor=white
-	style=filled
-   
-   Node617846867XXXNode0[
-	label="+ Node()"
-	style=filled
-	fillcolor=white
-	tooltip="Node
-
-null"
-	penwidth=4
-	fontcolor=darkgreen
-];
-} 
-} 
-} 
-
-'edges    
-
-    
-}
-@enduml

小米标签及案例/源程序代码-小米便签-Notes-master/Notes-master/src/net/micode/notes/gtask/data/Node_10_setDeleted_calls.puml

@@ -1,158 +0,0 @@
-@startuml
-
-/' diagram meta data start
-config=CallConfiguration;
-{
-  "rootMethod": "net.micode.notes.gtask.data.Node#setDeleted(boolean)",
-  "projectClassification": {
-    "searchMode": "OpenProject", // OpenProject, AllProjects
-    "includedProjects": "",
-    "pathEndKeywords": "*.impl",
-    "isClientPath": "",
-    "isClientName": "",
-    "isTestPath": "",
-    "isTestName": "",
-    "isMappingPath": "",
-    "isMappingName": "",
-    "isDataAccessPath": "",
-    "isDataAccessName": "",
-    "isDataStructurePath": "",
-    "isDataStructureName": "",
-    "isInterfaceStructuresPath": "",
-    "isInterfaceStructuresName": "",
-    "isEntryPointPath": "",
-    "isEntryPointName": "",
-    "treatFinalFieldsAsMandatory": false
-  },
-  "graphRestriction": {
-    "classPackageExcludeFilter": "",
-    "classPackageIncludeFilter": "",
-    "classNameExcludeFilter": "",
-    "classNameIncludeFilter": "",
-    "methodNameExcludeFilter": "",
-    "methodNameIncludeFilter": "",
-    "removeByInheritance": "", // inheritance/annotation based filtering is done in a second step
-    "removeByAnnotation": "",
-    "removeByClassPackage": "", // cleanup the graph after inheritance/annotation based filtering is done
-    "removeByClassName": "",
-    "cutMappings": false,
-    "cutEnum": true,
-    "cutTests": true,
-    "cutClient": true,
-    "cutDataAccess": true,
-    "cutInterfaceStructures": true,
-    "cutDataStructures": true,
-    "cutGetterAndSetter": true,
-    "cutConstructors": true
-  },
-  "graphTraversal": {
-    "forwardDepth": 3,
-    "backwardDepth": 3,
-    "classPackageExcludeFilter": "",
-    "classPackageIncludeFilter": "",
-    "classNameExcludeFilter": "",
-    "classNameIncludeFilter": "",
-    "methodNameExcludeFilter": "",
-    "methodNameIncludeFilter": "",
-    "hideMappings": false,
-    "hideDataStructures": false,
-    "hidePrivateMethods": true,
-    "hideInterfaceCalls": true, // indirection: implementation -> interface (is hidden) -> implementation
-    "onlyShowApplicationEntryPoints": false, // root node is included
-    "useMethodCallsForStructureDiagram": "ForwardOnly" // ForwardOnly, BothDirections, No
-  },
-  "details": {
-    "aggregation": "GroupByClass", // ByClass, GroupByClass, None
-    "showMethodParametersTypes": false,
-    "showMethodParametersNames": false,
-    "showMethodReturnType": false,
-    "showPackageLevels": 2,
-    "showCallOrder": false,
-    "edgeMode": "MethodsOnly", // TypesOnly, MethodsOnly, TypesAndMethods, MethodsAndDirectTypeUsage
-    "showDetailedClassStructure": false
-  },
-  "rootClass": "net.micode.notes.gtask.data.Node",
-  "extensionCallbackMethod": "" // qualified.class.name#methodName - signature: public static String method(String)
-}
-diagram meta data end '/
-
-
-
-digraph g {
-    rankdir="LR"
-    splines=polyline
-    
-
-'nodes 
-subgraph cluster_1074360951 { 
-   	label=micode
-	labeljust=l
-	fillcolor="#ececec"
-	style=filled
-   
-   subgraph cluster_502284772 { 
-   	label=notes
-	labeljust=l
-	fillcolor="#d8d8d8"
-	style=filled
-   
-   subgraph cluster_1368530406 { 
-   	label=GTaskManager
-	labeljust=l
-	fillcolor=white
-	style=filled
-   
-   GTaskManager641041527XXXsync656730312[
-	label="+ sync()"
-	style=filled
-	fillcolor=white
-	tooltip="GTaskManager
-
-null"
-	fontcolor=darkgreen
-];
-} 
-
-subgraph cluster_1430436466 { 
-   	label=GTaskClient
-	labeljust=l
-	fillcolor=white
-	style=filled
-   
-   GTaskClient641041527XXXdeleteNode2433570[
-	label="+ deleteNode()"
-	style=filled
-	fillcolor=white
-	tooltip="GTaskClient
-
-null"
-	fontcolor=darkgreen
-];
-} 
-
-subgraph cluster_761247683 { 
-   	label=Node
-	labeljust=l
-	fillcolor=white
-	style=filled
-   
-   Node617846867XXXsetDeleted64711720[
-	label="+ setDeleted()"
-	style=filled
-	fillcolor=white
-	tooltip="Node
-
-null"
-	penwidth=4
-	fontcolor=darkgreen
-];
-} 
-} 
-} 
-
-'edges    
-GTaskClient641041527XXXdeleteNode2433570 -> Node617846867XXXsetDeleted64711720;
-GTaskManager641041527XXXsync656730312 -> GTaskClient641041527XXXdeleteNode2433570;
-    
-}
-@enduml

小米标签及案例/源程序代码-小米便签-Notes-master/Notes-master/src/net/micode/notes/gtask/data/Node_11_getGid_calls.puml

@@ -1,317 +0,0 @@
-@startuml
-
-/' diagram meta data start
-config=CallConfiguration;
-{
-  "rootMethod": "net.micode.notes.gtask.data.Node#getGid()",
-  "projectClassification": {
-    "searchMode": "OpenProject", // OpenProject, AllProjects
-    "includedProjects": "",
-    "pathEndKeywords": "*.impl",
-    "isClientPath": "",
-    "isClientName": "",
-    "isTestPath": "",
-    "isTestName": "",
-    "isMappingPath": "",
-    "isMappingName": "",
-    "isDataAccessPath": "",
-    "isDataAccessName": "",
-    "isDataStructurePath": "",
-    "isDataStructureName": "",
-    "isInterfaceStructuresPath": "",
-    "isInterfaceStructuresName": "",
-    "isEntryPointPath": "",
-    "isEntryPointName": "",
-    "treatFinalFieldsAsMandatory": false
-  },
-  "graphRestriction": {
-    "classPackageExcludeFilter": "",
-    "classPackageIncludeFilter": "",
-    "classNameExcludeFilter": "",
-    "classNameIncludeFilter": "",
-    "methodNameExcludeFilter": "",
-    "methodNameIncludeFilter": "",
-    "removeByInheritance": "", // inheritance/annotation based filtering is done in a second step
-    "removeByAnnotation": "",
-    "removeByClassPackage": "", // cleanup the graph after inheritance/annotation based filtering is done
-    "removeByClassName": "",
-    "cutMappings": false,
-    "cutEnum": true,
-    "cutTests": true,
-    "cutClient": true,
-    "cutDataAccess": true,
-    "cutInterfaceStructures": true,
-    "cutDataStructures": true,
-    "cutGetterAndSetter": true,
-    "cutConstructors": true
-  },
-  "graphTraversal": {
-    "forwardDepth": 3,
-    "backwardDepth": 3,
-    "classPackageExcludeFilter": "",
-    "classPackageIncludeFilter": "",
-    "classNameExcludeFilter": "",
-    "classNameIncludeFilter": "",
-    "methodNameExcludeFilter": "",
-    "methodNameIncludeFilter": "",
-    "hideMappings": false,
-    "hideDataStructures": false,
-    "hidePrivateMethods": true,
-    "hideInterfaceCalls": true, // indirection: implementation -> interface (is hidden) -> implementation
-    "onlyShowApplicationEntryPoints": false, // root node is included
-    "useMethodCallsForStructureDiagram": "ForwardOnly" // ForwardOnly, BothDirections, No
-  },
-  "details": {
-    "aggregation": "GroupByClass", // ByClass, GroupByClass, None
-    "showMethodParametersTypes": false,
-    "showMethodParametersNames": false,
-    "showMethodReturnType": false,
-    "showPackageLevels": 2,
-    "showCallOrder": false,
-    "edgeMode": "MethodsOnly", // TypesOnly, MethodsOnly, TypesAndMethods, MethodsAndDirectTypeUsage
-    "showDetailedClassStructure": false
-  },
-  "rootClass": "net.micode.notes.gtask.data.Node",
-  "extensionCallbackMethod": "" // qualified.class.name#methodName - signature: public static String method(String)
-}
-diagram meta data end '/
-
-
-
-digraph g {
-    rankdir="LR"
-    splines=polyline
-    
-
-'nodes 
-subgraph cluster_1074360951 { 
-   	label=micode
-	labeljust=l
-	fillcolor="#ececec"
-	style=filled
-   
-   subgraph cluster_502284772 { 
-   	label=notes
-	labeljust=l
-	fillcolor="#d8d8d8"
-	style=filled
-   
-   subgraph cluster_1368530406 { 
-   	label=GTaskManager
-	labeljust=l
-	fillcolor=white
-	style=filled
-   
-   GTaskManager641041527XXXsync656730312[
-	label="+ sync()"
-	style=filled
-	fillcolor=white
-	tooltip="GTaskManager
-
-null"
-	fontcolor=darkgreen
-];
-} 
-
-subgraph cluster_1430436466 { 
-   	label=GTaskClient
-	labeljust=l
-	fillcolor=white
-	style=filled
-   
-   GTaskClient641041527XXXaddUpdateNode2433570[
-	label="+ addUpdateNode()"
-	style=filled
-	fillcolor=white
-	tooltip="GTaskClient
-
-null"
-	fontcolor=darkgreen
-];
-
-GTaskClient641041527XXXcreateTask2599333[
-	label="+ createTask()"
-	style=filled
-	fillcolor=white
-	tooltip="GTaskClient
-
-null"
-	fontcolor=darkgreen
-];
-
-GTaskClient641041527XXXdeleteNode2433570[
-	label="+ deleteNode()"
-	style=filled
-	fillcolor=white
-	tooltip="GTaskClient
-
-null"
-	fontcolor=darkgreen
-];
-
-GTaskClient641041527XXXmoveTask913927955[
-	label="+ moveTask()"
-	style=filled
-	fillcolor=white
-	tooltip="GTaskClient
-
-null"
-	fontcolor=darkgreen
-];
-} 
-
-subgraph cluster_673796356 { 
-   	label=TaskList
-	labeljust=l
-	fillcolor=white
-	style=filled
-   
-   TaskList617846867XXXfindChildTaskByGid1808118735[
-	label="+ findChildTaskByGid()"
-	style=filled
-	fillcolor=white
-	tooltip="TaskList
-
-null"
-	fontcolor=darkgreen
-];
-
-TaskList617846867XXXgetChilTaskByGid1808118735[
-	label="+ getChilTaskByGid()"
-	style=filled
-	fillcolor=white
-	tooltip="TaskList
-
-null"
-	fontcolor=darkgreen
-];
-
-TaskList617846867XXXgetSyncAction2029715318[
-	label="+ getSyncAction()"
-	style=filled
-	fillcolor=white
-	tooltip="TaskList
-
-null"
-	fontcolor=darkgreen
-];
-
-TaskList617846867XXXgetUpdateAction104431[
-	label="+ getUpdateAction()"
-	style=filled
-	fillcolor=white
-	tooltip="TaskList
-
-null"
-	fontcolor=darkgreen
-];
-} 
-
-subgraph cluster_761247683 { 
-   	label=Node
-	labeljust=l
-	fillcolor=white
-	style=filled
-   
-   Node617846867XXXgetCreateAction104431[
-	label="+ getCreateAction()"
-	style=filled
-	fillcolor=white
-	tooltip="Node
-
-null"
-	fontcolor=darkgreen
-];
-
-Node617846867XXXgetGid0[
-	label="+ getGid()"
-	style=filled
-	fillcolor=white
-	tooltip="Node
-
-null"
-	penwidth=4
-	fontcolor=darkgreen
-];
-
-Node617846867XXXgetSyncAction2029715318[
-	label="+ getSyncAction()"
-	style=filled
-	fillcolor=white
-	tooltip="Node
-
-null"
-	fontcolor=darkgreen
-];
-
-Node617846867XXXgetUpdateAction104431[
-	label="+ getUpdateAction()"
-	style=filled
-	fillcolor=white
-	tooltip="Node
-
-null"
-	fontcolor=darkgreen
-];
-} 
-
-subgraph cluster_761413446 { 
-   	label=Task
-	labeljust=l
-	fillcolor=white
-	style=filled
-   
-   Task617846867XXXgetCreateAction104431[
-	label="+ getCreateAction()"
-	style=filled
-	fillcolor=white
-	tooltip="Task
-
-null"
-	fontcolor=darkgreen
-];
-
-Task617846867XXXgetSyncAction2029715318[
-	label="+ getSyncAction()"
-	style=filled
-	fillcolor=white
-	tooltip="Task
-
-null"
-	fontcolor=darkgreen
-];
-
-Task617846867XXXgetUpdateAction104431[
-	label="+ getUpdateAction()"
-	style=filled
-	fillcolor=white
-	tooltip="Task
-
-null"
-	fontcolor=darkgreen
-];
-} 
-} 
-} 
-
-'edges    
-GTaskClient641041527XXXaddUpdateNode2433570 -> Node617846867XXXgetUpdateAction104431;
-GTaskClient641041527XXXcreateTask2599333 -> Task617846867XXXgetCreateAction104431;
-GTaskClient641041527XXXdeleteNode2433570 -> Node617846867XXXgetUpdateAction104431;
-GTaskClient641041527XXXmoveTask913927955 -> Node617846867XXXgetGid0;
-GTaskManager641041527XXXsync656730312 -> Node617846867XXXgetGid0;
-Node617846867XXXgetCreateAction104431 -> Task617846867XXXgetCreateAction104431;
-Node617846867XXXgetSyncAction2029715318 -> Task617846867XXXgetSyncAction2029715318;
-Node617846867XXXgetSyncAction2029715318 -> TaskList617846867XXXgetSyncAction2029715318;
-Node617846867XXXgetUpdateAction104431 -> Task617846867XXXgetUpdateAction104431;
-Node617846867XXXgetUpdateAction104431 -> TaskList617846867XXXgetUpdateAction104431;
-Task617846867XXXgetCreateAction104431 -> Node617846867XXXgetGid0;
-Task617846867XXXgetSyncAction2029715318 -> Node617846867XXXgetGid0;
-Task617846867XXXgetUpdateAction104431 -> Node617846867XXXgetGid0;
-TaskList617846867XXXfindChildTaskByGid1808118735 -> Node617846867XXXgetGid0;
-TaskList617846867XXXgetChilTaskByGid1808118735 -> Node617846867XXXgetGid0;
-TaskList617846867XXXgetSyncAction2029715318 -> Node617846867XXXgetGid0;
-TaskList617846867XXXgetUpdateAction104431 -> Node617846867XXXgetGid0;
-    
-}
-@enduml

小米标签及案例/源程序代码-小米便签-Notes-master/Notes-master/src/net/micode/notes/gtask/data/Node_12_getName_calls.puml

@@ -1,274 +0,0 @@
-@startuml
-
-/' diagram meta data start
-config=CallConfiguration;
-{
-  "rootMethod": "net.micode.notes.gtask.data.Node#getName()",
-  "projectClassification": {
-    "searchMode": "OpenProject", // OpenProject, AllProjects
-    "includedProjects": "",
-    "pathEndKeywords": "*.impl",
-    "isClientPath": "",
-    "isClientName": "",
-    "isTestPath": "",
-    "isTestName": "",
-    "isMappingPath": "",
-    "isMappingName": "",
-    "isDataAccessPath": "",
-    "isDataAccessName": "",
-    "isDataStructurePath": "",
-    "isDataStructureName": "",
-    "isInterfaceStructuresPath": "",
-    "isInterfaceStructuresName": "",
-    "isEntryPointPath": "",
-    "isEntryPointName": "",
-    "treatFinalFieldsAsMandatory": false
-  },
-  "graphRestriction": {
-    "classPackageExcludeFilter": "",
-    "classPackageIncludeFilter": "",
-    "classNameExcludeFilter": "",
-    "classNameIncludeFilter": "",
-    "methodNameExcludeFilter": "",
-    "methodNameIncludeFilter": "",
-    "removeByInheritance": "", // inheritance/annotation based filtering is done in a second step
-    "removeByAnnotation": "",
-    "removeByClassPackage": "", // cleanup the graph after inheritance/annotation based filtering is done
-    "removeByClassName": "",
-    "cutMappings": false,
-    "cutEnum": true,
-    "cutTests": true,
-    "cutClient": true,
-    "cutDataAccess": true,
-    "cutInterfaceStructures": true,
-    "cutDataStructures": true,
-    "cutGetterAndSetter": true,
-    "cutConstructors": true
-  },
-  "graphTraversal": {
-    "forwardDepth": 3,
-    "backwardDepth": 3,
-    "classPackageExcludeFilter": "",
-    "classPackageIncludeFilter": "",
-    "classNameExcludeFilter": "",
-    "classNameIncludeFilter": "",
-    "methodNameExcludeFilter": "",
-    "methodNameIncludeFilter": "",
-    "hideMappings": false,
-    "hideDataStructures": false,
-    "hidePrivateMethods": true,
-    "hideInterfaceCalls": true, // indirection: implementation -> interface (is hidden) -> implementation
-    "onlyShowApplicationEntryPoints": false, // root node is included
-    "useMethodCallsForStructureDiagram": "ForwardOnly" // ForwardOnly, BothDirections, No
-  },
-  "details": {
-    "aggregation": "GroupByClass", // ByClass, GroupByClass, None
-    "showMethodParametersTypes": false,
-    "showMethodParametersNames": false,
-    "showMethodReturnType": false,
-    "showPackageLevels": 2,
-    "showCallOrder": false,
-    "edgeMode": "MethodsOnly", // TypesOnly, MethodsOnly, TypesAndMethods, MethodsAndDirectTypeUsage
-    "showDetailedClassStructure": false
-  },
-  "rootClass": "net.micode.notes.gtask.data.Node",
-  "extensionCallbackMethod": "" // qualified.class.name#methodName - signature: public static String method(String)
-}
-diagram meta data end '/
-
-
-
-digraph g {
-    rankdir="LR"
-    splines=polyline
-    
-
-'nodes 
-subgraph cluster_1074360951 { 
-   	label=micode
-	labeljust=l
-	fillcolor="#ececec"
-	style=filled
-   
-   subgraph cluster_502284772 { 
-   	label=notes
-	labeljust=l
-	fillcolor="#d8d8d8"
-	style=filled
-   
-   subgraph cluster_1368530406 { 
-   	label=GTaskManager
-	labeljust=l
-	fillcolor=white
-	style=filled
-   
-   GTaskManager641041527XXXsync656730312[
-	label="+ sync()"
-	style=filled
-	fillcolor=white
-	tooltip="GTaskManager
-
-null"
-	fontcolor=darkgreen
-];
-} 
-
-subgraph cluster_1430436466 { 
-   	label=GTaskClient
-	labeljust=l
-	fillcolor=white
-	style=filled
-   
-   GTaskClient641041527XXXaddUpdateNode2433570[
-	label="+ addUpdateNode()"
-	style=filled
-	fillcolor=white
-	tooltip="GTaskClient
-
-null"
-	fontcolor=darkgreen
-];
-
-GTaskClient641041527XXXcreateTask2599333[
-	label="+ createTask()"
-	style=filled
-	fillcolor=white
-	tooltip="GTaskClient
-
-null"
-	fontcolor=darkgreen
-];
-
-GTaskClient641041527XXXcreateTaskList345738269[
-	label="+ createTaskList()"
-	style=filled
-	fillcolor=white
-	tooltip="GTaskClient
-
-null"
-	fontcolor=darkgreen
-];
-
-GTaskClient641041527XXXdeleteNode2433570[
-	label="+ deleteNode()"
-	style=filled
-	fillcolor=white
-	tooltip="GTaskClient
-
-null"
-	fontcolor=darkgreen
-];
-} 
-
-subgraph cluster_673796356 { 
-   	label=TaskList
-	labeljust=l
-	fillcolor=white
-	style=filled
-   
-   TaskList617846867XXXgetCreateAction104431[
-	label="+ getCreateAction()"
-	style=filled
-	fillcolor=white
-	tooltip="TaskList
-
-null"
-	fontcolor=darkgreen
-];
-
-TaskList617846867XXXgetUpdateAction104431[
-	label="+ getUpdateAction()"
-	style=filled
-	fillcolor=white
-	tooltip="TaskList
-
-null"
-	fontcolor=darkgreen
-];
-} 
-
-subgraph cluster_761247683 { 
-   	label=Node
-	labeljust=l
-	fillcolor=white
-	style=filled
-   
-   Node617846867XXXgetCreateAction104431[
-	label="+ getCreateAction()"
-	style=filled
-	fillcolor=white
-	tooltip="Node
-
-null"
-	fontcolor=darkgreen
-];
-
-Node617846867XXXgetName0[
-	label="+ getName()"
-	style=filled
-	fillcolor=white
-	tooltip="Node
-
-null"
-	penwidth=4
-	fontcolor=darkgreen
-];
-
-Node617846867XXXgetUpdateAction104431[
-	label="+ getUpdateAction()"
-	style=filled
-	fillcolor=white
-	tooltip="Node
-
-null"
-	fontcolor=darkgreen
-];
-} 
-
-subgraph cluster_761413446 { 
-   	label=Task
-	labeljust=l
-	fillcolor=white
-	style=filled
-   
-   Task617846867XXXgetCreateAction104431[
-	label="+ getCreateAction()"
-	style=filled
-	fillcolor=white
-	tooltip="Task
-
-null"
-	fontcolor=darkgreen
-];
-
-Task617846867XXXgetUpdateAction104431[
-	label="+ getUpdateAction()"
-	style=filled
-	fillcolor=white
-	tooltip="Task
-
-null"
-	fontcolor=darkgreen
-];
-} 
-} 
-} 
-
-'edges    
-GTaskClient641041527XXXaddUpdateNode2433570 -> Node617846867XXXgetUpdateAction104431;
-GTaskClient641041527XXXcreateTask2599333 -> Task617846867XXXgetCreateAction104431;
-GTaskClient641041527XXXcreateTaskList345738269 -> TaskList617846867XXXgetCreateAction104431;
-GTaskClient641041527XXXdeleteNode2433570 -> Node617846867XXXgetUpdateAction104431;
-GTaskManager641041527XXXsync656730312 -> GTaskClient641041527XXXcreateTaskList345738269;
-GTaskManager641041527XXXsync656730312 -> Node617846867XXXgetName0;
-Node617846867XXXgetCreateAction104431 -> Task617846867XXXgetCreateAction104431;
-Node617846867XXXgetCreateAction104431 -> TaskList617846867XXXgetCreateAction104431;
-Node617846867XXXgetUpdateAction104431 -> Task617846867XXXgetUpdateAction104431;
-Node617846867XXXgetUpdateAction104431 -> TaskList617846867XXXgetUpdateAction104431;
-Task617846867XXXgetCreateAction104431 -> Node617846867XXXgetName0;
-Task617846867XXXgetUpdateAction104431 -> Node617846867XXXgetName0;
-TaskList617846867XXXgetCreateAction104431 -> Node617846867XXXgetName0;
-TaskList617846867XXXgetUpdateAction104431 -> Node617846867XXXgetName0;
-    
-}
-@enduml

小米标签及案例/源程序代码-小米便签-Notes-master/Notes-master/src/net/micode/notes/gtask/data/Node_13_getLastModified_calls.puml

@@ -1,188 +0,0 @@
-@startuml
-
-/' diagram meta data start
-config=CallConfiguration;
-{
-  "rootMethod": "net.micode.notes.gtask.data.Node#getLastModified()",
-  "projectClassification": {
-    "searchMode": "OpenProject", // OpenProject, AllProjects
-    "includedProjects": "",
-    "pathEndKeywords": "*.impl",
-    "isClientPath": "",
-    "isClientName": "",
-    "isTestPath": "",
-    "isTestName": "",
-    "isMappingPath": "",
-    "isMappingName": "",
-    "isDataAccessPath": "",
-    "isDataAccessName": "",
-    "isDataStructurePath": "",
-    "isDataStructureName": "",
-    "isInterfaceStructuresPath": "",
-    "isInterfaceStructuresName": "",
-    "isEntryPointPath": "",
-    "isEntryPointName": "",
-    "treatFinalFieldsAsMandatory": false
-  },
-  "graphRestriction": {
-    "classPackageExcludeFilter": "",
-    "classPackageIncludeFilter": "",
-    "classNameExcludeFilter": "",
-    "classNameIncludeFilter": "",
-    "methodNameExcludeFilter": "",
-    "methodNameIncludeFilter": "",
-    "removeByInheritance": "", // inheritance/annotation based filtering is done in a second step
-    "removeByAnnotation": "",
-    "removeByClassPackage": "", // cleanup the graph after inheritance/annotation based filtering is done
-    "removeByClassName": "",
-    "cutMappings": false,
-    "cutEnum": true,
-    "cutTests": true,
-    "cutClient": true,
-    "cutDataAccess": true,
-    "cutInterfaceStructures": true,
-    "cutDataStructures": true,
-    "cutGetterAndSetter": true,
-    "cutConstructors": true
-  },
-  "graphTraversal": {
-    "forwardDepth": 3,
-    "backwardDepth": 3,
-    "classPackageExcludeFilter": "",
-    "classPackageIncludeFilter": "",
-    "classNameExcludeFilter": "",
-    "classNameIncludeFilter": "",
-    "methodNameExcludeFilter": "",
-    "methodNameIncludeFilter": "",
-    "hideMappings": false,
-    "hideDataStructures": false,
-    "hidePrivateMethods": true,
-    "hideInterfaceCalls": true, // indirection: implementation -> interface (is hidden) -> implementation
-    "onlyShowApplicationEntryPoints": false, // root node is included
-    "useMethodCallsForStructureDiagram": "ForwardOnly" // ForwardOnly, BothDirections, No
-  },
-  "details": {
-    "aggregation": "GroupByClass", // ByClass, GroupByClass, None
-    "showMethodParametersTypes": false,
-    "showMethodParametersNames": false,
-    "showMethodReturnType": false,
-    "showPackageLevels": 2,
-    "showCallOrder": false,
-    "edgeMode": "MethodsOnly", // TypesOnly, MethodsOnly, TypesAndMethods, MethodsAndDirectTypeUsage
-    "showDetailedClassStructure": false
-  },
-  "rootClass": "net.micode.notes.gtask.data.Node",
-  "extensionCallbackMethod": "" // qualified.class.name#methodName - signature: public static String method(String)
-}
-diagram meta data end '/
-
-
-
-digraph g {
-    rankdir="LR"
-    splines=polyline
-    
-
-'nodes 
-subgraph cluster_1074360951 { 
-   	label=micode
-	labeljust=l
-	fillcolor="#ececec"
-	style=filled
-   
-   subgraph cluster_502284772 { 
-   	label=notes
-	labeljust=l
-	fillcolor="#d8d8d8"
-	style=filled
-   
-   subgraph cluster_1368530406 { 
-   	label=GTaskManager
-	labeljust=l
-	fillcolor=white
-	style=filled
-   
-   GTaskManager641041527XXXsync656730312[
-	label="+ sync()"
-	style=filled
-	fillcolor=white
-	tooltip="GTaskManager
-
-null"
-	fontcolor=darkgreen
-];
-} 
-
-subgraph cluster_673796356 { 
-   	label=TaskList
-	labeljust=l
-	fillcolor=white
-	style=filled
-   
-   TaskList617846867XXXgetSyncAction2029715318[
-	label="+ getSyncAction()"
-	style=filled
-	fillcolor=white
-	tooltip="TaskList
-
-null"
-	fontcolor=darkgreen
-];
-} 
-
-subgraph cluster_761247683 { 
-   	label=Node
-	labeljust=l
-	fillcolor=white
-	style=filled
-   
-   Node617846867XXXgetLastModified0[
-	label="+ getLastModified()"
-	style=filled
-	fillcolor=white
-	tooltip="Node
-
-null"
-	penwidth=4
-	fontcolor=darkgreen
-];
-
-Node617846867XXXgetSyncAction2029715318[
-	label="+ getSyncAction()"
-	style=filled
-	fillcolor=white
-	tooltip="Node
-
-null"
-	fontcolor=darkgreen
-];
-} 
-
-subgraph cluster_761413446 { 
-   	label=Task
-	labeljust=l
-	fillcolor=white
-	style=filled
-   
-   Task617846867XXXgetSyncAction2029715318[
-	label="+ getSyncAction()"
-	style=filled
-	fillcolor=white
-	tooltip="Task
-
-null"
-	fontcolor=darkgreen
-];
-} 
-} 
-} 
-
-'edges    
-GTaskManager641041527XXXsync656730312 -> Node617846867XXXgetSyncAction2029715318;
-Node617846867XXXgetSyncAction2029715318 -> Task617846867XXXgetSyncAction2029715318;
-Node617846867XXXgetSyncAction2029715318 -> TaskList617846867XXXgetSyncAction2029715318;
-Task617846867XXXgetSyncAction2029715318 -> Node617846867XXXgetLastModified0;
-TaskList617846867XXXgetSyncAction2029715318 -> Node617846867XXXgetLastModified0;
-    
-}
-@enduml

小米标签及案例/源程序代码-小米便签-Notes-master/Notes-master/src/net/micode/notes/gtask/data/Node_14_getDeleted_calls.puml

@@ -1,199 +0,0 @@
-@startuml
-
-/' diagram meta data start
-config=CallConfiguration;
-{
-  "rootMethod": "net.micode.notes.gtask.data.Node#getDeleted()",
-  "projectClassification": {
-    "searchMode": "OpenProject", // OpenProject, AllProjects
-    "includedProjects": "",
-    "pathEndKeywords": "*.impl",
-    "isClientPath": "",
-    "isClientName": "",
-    "isTestPath": "",
-    "isTestName": "",
-    "isMappingPath": "",
-    "isMappingName": "",
-    "isDataAccessPath": "",
-    "isDataAccessName": "",
-    "isDataStructurePath": "",
-    "isDataStructureName": "",
-    "isInterfaceStructuresPath": "",
-    "isInterfaceStructuresName": "",
-    "isEntryPointPath": "",
-    "isEntryPointName": "",
-    "treatFinalFieldsAsMandatory": false
-  },
-  "graphRestriction": {
-    "classPackageExcludeFilter": "",
-    "classPackageIncludeFilter": "",
-    "classNameExcludeFilter": "",
-    "classNameIncludeFilter": "",
-    "methodNameExcludeFilter": "",
-    "methodNameIncludeFilter": "",
-    "removeByInheritance": "", // inheritance/annotation based filtering is done in a second step
-    "removeByAnnotation": "",
-    "removeByClassPackage": "", // cleanup the graph after inheritance/annotation based filtering is done
-    "removeByClassName": "",
-    "cutMappings": false,
-    "cutEnum": true,
-    "cutTests": true,
-    "cutClient": true,
-    "cutDataAccess": true,
-    "cutInterfaceStructures": true,
-    "cutDataStructures": true,
-    "cutGetterAndSetter": true,
-    "cutConstructors": true
-  },
-  "graphTraversal": {
-    "forwardDepth": 3,
-    "backwardDepth": 3,
-    "classPackageExcludeFilter": "",
-    "classPackageIncludeFilter": "",
-    "classNameExcludeFilter": "",
-    "classNameIncludeFilter": "",
-    "methodNameExcludeFilter": "",
-    "methodNameIncludeFilter": "",
-    "hideMappings": false,
-    "hideDataStructures": false,
-    "hidePrivateMethods": true,
-    "hideInterfaceCalls": true, // indirection: implementation -> interface (is hidden) -> implementation
-    "onlyShowApplicationEntryPoints": false, // root node is included
-    "useMethodCallsForStructureDiagram": "ForwardOnly" // ForwardOnly, BothDirections, No
-  },
-  "details": {
-    "aggregation": "GroupByClass", // ByClass, GroupByClass, None
-    "showMethodParametersTypes": false,
-    "showMethodParametersNames": false,
-    "showMethodReturnType": false,
-    "showPackageLevels": 2,
-    "showCallOrder": false,
-    "edgeMode": "MethodsOnly", // TypesOnly, MethodsOnly, TypesAndMethods, MethodsAndDirectTypeUsage
-    "showDetailedClassStructure": false
-  },
-  "rootClass": "net.micode.notes.gtask.data.Node",
-  "extensionCallbackMethod": "" // qualified.class.name#methodName - signature: public static String method(String)
-}
-diagram meta data end '/
-
-
-
-digraph g {
-    rankdir="LR"
-    splines=polyline
-    
-
-'nodes 
-subgraph cluster_1074360951 { 
-   	label=micode
-	labeljust=l
-	fillcolor="#ececec"
-	style=filled
-   
-   subgraph cluster_502284772 { 
-   	label=notes
-	labeljust=l
-	fillcolor="#d8d8d8"
-	style=filled
-   
-   subgraph cluster_1430436466 { 
-   	label=GTaskClient
-	labeljust=l
-	fillcolor=white
-	style=filled
-   
-   GTaskClient641041527XXXaddUpdateNode2433570[
-	label="+ addUpdateNode()"
-	style=filled
-	fillcolor=white
-	tooltip="GTaskClient
-
-null"
-	fontcolor=darkgreen
-];
-
-GTaskClient641041527XXXdeleteNode2433570[
-	label="+ deleteNode()"
-	style=filled
-	fillcolor=white
-	tooltip="GTaskClient
-
-null"
-	fontcolor=darkgreen
-];
-} 
-
-subgraph cluster_673796356 { 
-   	label=TaskList
-	labeljust=l
-	fillcolor=white
-	style=filled
-   
-   TaskList617846867XXXgetUpdateAction104431[
-	label="+ getUpdateAction()"
-	style=filled
-	fillcolor=white
-	tooltip="TaskList
-
-null"
-	fontcolor=darkgreen
-];
-} 
-
-subgraph cluster_761247683 { 
-   	label=Node
-	labeljust=l
-	fillcolor=white
-	style=filled
-   
-   Node617846867XXXgetDeleted0[
-	label="+ getDeleted()"
-	style=filled
-	fillcolor=white
-	tooltip="Node
-
-null"
-	penwidth=4
-	fontcolor=darkgreen
-];
-
-Node617846867XXXgetUpdateAction104431[
-	label="+ getUpdateAction()"
-	style=filled
-	fillcolor=white
-	tooltip="Node
-
-null"
-	fontcolor=darkgreen
-];
-} 
-
-subgraph cluster_761413446 { 
-   	label=Task
-	labeljust=l
-	fillcolor=white
-	style=filled
-   
-   Task617846867XXXgetUpdateAction104431[
-	label="+ getUpdateAction()"
-	style=filled
-	fillcolor=white
-	tooltip="Task
-
-null"
-	fontcolor=darkgreen
-];
-} 
-} 
-} 
-
-'edges    
-GTaskClient641041527XXXaddUpdateNode2433570 -> Node617846867XXXgetUpdateAction104431;
-GTaskClient641041527XXXdeleteNode2433570 -> Node617846867XXXgetUpdateAction104431;
-Node617846867XXXgetUpdateAction104431 -> Task617846867XXXgetUpdateAction104431;
-Node617846867XXXgetUpdateAction104431 -> TaskList617846867XXXgetUpdateAction104431;
-Task617846867XXXgetUpdateAction104431 -> Node617846867XXXgetDeleted0;
-TaskList617846867XXXgetUpdateAction104431 -> Node617846867XXXgetDeleted0;
-    
-}
-@enduml

小米标签及案例/源程序代码-小米便签-Notes-master/Notes-master/src/net/micode/notes/gtask/data/Node_1_getCreateAction_calls.puml

@@ -1,169 +0,0 @@
-@startuml
-
-/' diagram meta data start
-config=CallConfiguration;
-{
-  "rootMethod": "net.micode.notes.gtask.data.Node#getCreateAction(int)",
-  "projectClassification": {
-    "searchMode": "OpenProject", // OpenProject, AllProjects
-    "includedProjects": "",
-    "pathEndKeywords": "*.impl",
-    "isClientPath": "",
-    "isClientName": "",
-    "isTestPath": "",
-    "isTestName": "",
-    "isMappingPath": "",
-    "isMappingName": "",
-    "isDataAccessPath": "",
-    "isDataAccessName": "",
-    "isDataStructurePath": "",
-    "isDataStructureName": "",
-    "isInterfaceStructuresPath": "",
-    "isInterfaceStructuresName": "",
-    "isEntryPointPath": "",
-    "isEntryPointName": "",
-    "treatFinalFieldsAsMandatory": false
-  },
-  "graphRestriction": {
-    "classPackageExcludeFilter": "",
-    "classPackageIncludeFilter": "",
-    "classNameExcludeFilter": "",
-    "classNameIncludeFilter": "",
-    "methodNameExcludeFilter": "",
-    "methodNameIncludeFilter": "",
-    "removeByInheritance": "", // inheritance/annotation based filtering is done in a second step
-    "removeByAnnotation": "",
-    "removeByClassPackage": "", // cleanup the graph after inheritance/annotation based filtering is done
-    "removeByClassName": "",
-    "cutMappings": false,
-    "cutEnum": true,
-    "cutTests": true,
-    "cutClient": true,
-    "cutDataAccess": true,
-    "cutInterfaceStructures": true,
-    "cutDataStructures": true,
-    "cutGetterAndSetter": true,
-    "cutConstructors": true
-  },
-  "graphTraversal": {
-    "forwardDepth": 3,
-    "backwardDepth": 3,
-    "classPackageExcludeFilter": "",
-    "classPackageIncludeFilter": "",
-    "classNameExcludeFilter": "",
-    "classNameIncludeFilter": "",
-    "methodNameExcludeFilter": "",
-    "methodNameIncludeFilter": "",
-    "hideMappings": false,
-    "hideDataStructures": false,
-    "hidePrivateMethods": true,
-    "hideInterfaceCalls": true, // indirection: implementation -> interface (is hidden) -> implementation
-    "onlyShowApplicationEntryPoints": false, // root node is included
-    "useMethodCallsForStructureDiagram": "ForwardOnly" // ForwardOnly, BothDirections, No
-  },
-  "details": {
-    "aggregation": "GroupByClass", // ByClass, GroupByClass, None
-    "showMethodParametersTypes": false,
-    "showMethodParametersNames": false,
-    "showMethodReturnType": false,
-    "showPackageLevels": 2,
-    "showCallOrder": false,
-    "edgeMode": "MethodsOnly", // TypesOnly, MethodsOnly, TypesAndMethods, MethodsAndDirectTypeUsage
-    "showDetailedClassStructure": false
-  },
-  "rootClass": "net.micode.notes.gtask.data.Node",
-  "extensionCallbackMethod": "" // qualified.class.name#methodName - signature: public static String method(String)
-}
-diagram meta data end '/
-
-
-
-digraph g {
-    rankdir="LR"
-    splines=polyline
-    
-
-'nodes 
-subgraph cluster_1074360951 { 
-   	label=micode
-	labeljust=l
-	fillcolor="#ececec"
-	style=filled
-   
-   subgraph cluster_502284772 { 
-   	label=notes
-	labeljust=l
-	fillcolor="#d8d8d8"
-	style=filled
-   
-   subgraph cluster_673796356 { 
-   	label=TaskList
-	labeljust=l
-	fillcolor=white
-	style=filled
-   
-   TaskList617846867XXXgetChildTaskIndex2599333[
-	label="+ getChildTaskIndex()"
-	style=filled
-	fillcolor=white
-	tooltip="TaskList
-
-null"
-	fontcolor=darkgreen
-];
-
-TaskList617846867XXXgetCreateAction104431[
-	label="+ getCreateAction()"
-	style=filled
-	fillcolor=white
-	tooltip="TaskList
-
-null"
-	fontcolor=darkgreen
-];
-} 
-
-subgraph cluster_761247683 { 
-   	label=Node
-	labeljust=l
-	fillcolor=white
-	style=filled
-   
-   Node617846867XXXgetCreateAction104431[
-	label="+ getCreateAction()"
-	style=filled
-	fillcolor=white
-	tooltip="Node
-
-null"
-	penwidth=4
-	fontcolor=darkgreen
-];
-} 
-
-subgraph cluster_761413446 { 
-   	label=Task
-	labeljust=l
-	fillcolor=white
-	style=filled
-   
-   Task617846867XXXgetCreateAction104431[
-	label="+ getCreateAction()"
-	style=filled
-	fillcolor=white
-	tooltip="Task
-
-null"
-	fontcolor=darkgreen
-];
-} 
-} 
-} 
-
-'edges    
-Node617846867XXXgetCreateAction104431 -> Task617846867XXXgetCreateAction104431;
-Node617846867XXXgetCreateAction104431 -> TaskList617846867XXXgetCreateAction104431;
-Task617846867XXXgetCreateAction104431 -> TaskList617846867XXXgetChildTaskIndex2599333;
-    
-}
-@enduml

小米标签及案例/源程序代码-小米便签-Notes-master/Notes-master/src/net/micode/notes/gtask/data/Node_2_getUpdateAction_calls.puml

@@ -1,205 +0,0 @@
-@startuml
-
-/' diagram meta data start
-config=CallConfiguration;
-{
-  "rootMethod": "net.micode.notes.gtask.data.Node#getUpdateAction(int)",
-  "projectClassification": {
-    "searchMode": "OpenProject", // OpenProject, AllProjects
-    "includedProjects": "",
-    "pathEndKeywords": "*.impl",
-    "isClientPath": "",
-    "isClientName": "",
-    "isTestPath": "",
-    "isTestName": "",
-    "isMappingPath": "",
-    "isMappingName": "",
-    "isDataAccessPath": "",
-    "isDataAccessName": "",
-    "isDataStructurePath": "",
-    "isDataStructureName": "",
-    "isInterfaceStructuresPath": "",
-    "isInterfaceStructuresName": "",
-    "isEntryPointPath": "",
-    "isEntryPointName": "",
-    "treatFinalFieldsAsMandatory": false
-  },
-  "graphRestriction": {
-    "classPackageExcludeFilter": "",
-    "classPackageIncludeFilter": "",
-    "classNameExcludeFilter": "",
-    "classNameIncludeFilter": "",
-    "methodNameExcludeFilter": "",
-    "methodNameIncludeFilter": "",
-    "removeByInheritance": "", // inheritance/annotation based filtering is done in a second step
-    "removeByAnnotation": "",
-    "removeByClassPackage": "", // cleanup the graph after inheritance/annotation based filtering is done
-    "removeByClassName": "",
-    "cutMappings": false,
-    "cutEnum": true,
-    "cutTests": true,
-    "cutClient": true,
-    "cutDataAccess": true,
-    "cutInterfaceStructures": true,
-    "cutDataStructures": true,
-    "cutGetterAndSetter": true,
-    "cutConstructors": true
-  },
-  "graphTraversal": {
-    "forwardDepth": 3,
-    "backwardDepth": 3,
-    "classPackageExcludeFilter": "",
-    "classPackageIncludeFilter": "",
-    "classNameExcludeFilter": "",
-    "classNameIncludeFilter": "",
-    "methodNameExcludeFilter": "",
-    "methodNameIncludeFilter": "",
-    "hideMappings": false,
-    "hideDataStructures": false,
-    "hidePrivateMethods": true,
-    "hideInterfaceCalls": true, // indirection: implementation -> interface (is hidden) -> implementation
-    "onlyShowApplicationEntryPoints": false, // root node is included
-    "useMethodCallsForStructureDiagram": "ForwardOnly" // ForwardOnly, BothDirections, No
-  },
-  "details": {
-    "aggregation": "GroupByClass", // ByClass, GroupByClass, None
-    "showMethodParametersTypes": false,
-    "showMethodParametersNames": false,
-    "showMethodReturnType": false,
-    "showPackageLevels": 2,
-    "showCallOrder": false,
-    "edgeMode": "MethodsOnly", // TypesOnly, MethodsOnly, TypesAndMethods, MethodsAndDirectTypeUsage
-    "showDetailedClassStructure": false
-  },
-  "rootClass": "net.micode.notes.gtask.data.Node",
-  "extensionCallbackMethod": "" // qualified.class.name#methodName - signature: public static String method(String)
-}
-diagram meta data end '/
-
-
-
-digraph g {
-    rankdir="LR"
-    splines=polyline
-    
-
-'nodes 
-subgraph cluster_1074360951 { 
-   	label=micode
-	labeljust=l
-	fillcolor="#ececec"
-	style=filled
-   
-   subgraph cluster_502284772 { 
-   	label=notes
-	labeljust=l
-	fillcolor="#d8d8d8"
-	style=filled
-   
-   subgraph cluster_1368530406 { 
-   	label=GTaskManager
-	labeljust=l
-	fillcolor=white
-	style=filled
-   
-   GTaskManager641041527XXXsync656730312[
-	label="+ sync()"
-	style=filled
-	fillcolor=white
-	tooltip="GTaskManager
-
-null"
-	fontcolor=darkgreen
-];
-} 
-
-subgraph cluster_1430436466 { 
-   	label=GTaskClient
-	labeljust=l
-	fillcolor=white
-	style=filled
-   
-   GTaskClient641041527XXXaddUpdateNode2433570[
-	label="+ addUpdateNode()"
-	style=filled
-	fillcolor=white
-	tooltip="GTaskClient
-
-null"
-	fontcolor=darkgreen
-];
-
-GTaskClient641041527XXXdeleteNode2433570[
-	label="+ deleteNode()"
-	style=filled
-	fillcolor=white
-	tooltip="GTaskClient
-
-null"
-	fontcolor=darkgreen
-];
-} 
-
-subgraph cluster_673796356 { 
-   	label=TaskList
-	labeljust=l
-	fillcolor=white
-	style=filled
-   
-   TaskList617846867XXXgetUpdateAction104431[
-	label="+ getUpdateAction()"
-	style=filled
-	fillcolor=white
-	tooltip="TaskList
-
-null"
-	fontcolor=darkgreen
-];
-} 
-
-subgraph cluster_761247683 { 
-   	label=Node
-	labeljust=l
-	fillcolor=white
-	style=filled
-   
-   Node617846867XXXgetUpdateAction104431[
-	label="+ getUpdateAction()"
-	style=filled
-	fillcolor=white
-	tooltip="Node
-
-null"
-	penwidth=4
-	fontcolor=darkgreen
-];
-} 
-
-subgraph cluster_761413446 { 
-   	label=Task
-	labeljust=l
-	fillcolor=white
-	style=filled
-   
-   Task617846867XXXgetUpdateAction104431[
-	label="+ getUpdateAction()"
-	style=filled
-	fillcolor=white
-	tooltip="Task
-
-null"
-	fontcolor=darkgreen
-];
-} 
-} 
-} 
-
-'edges    
-GTaskClient641041527XXXaddUpdateNode2433570 -> Node617846867XXXgetUpdateAction104431;
-GTaskClient641041527XXXdeleteNode2433570 -> Node617846867XXXgetUpdateAction104431;
-GTaskManager641041527XXXsync656730312 -> GTaskClient641041527XXXaddUpdateNode2433570;
-Node617846867XXXgetUpdateAction104431 -> Task617846867XXXgetUpdateAction104431;
-Node617846867XXXgetUpdateAction104431 -> TaskList617846867XXXgetUpdateAction104431;
-    
-}
-@enduml

小米标签及案例/源程序代码-小米便签-Notes-master/Notes-master/src/net/micode/notes/gtask/data/Node_3_setContentByRemoteJSON_calls.puml

@@ -1,123 +0,0 @@
-@startuml
-
-/' diagram meta data start
-config=CallConfiguration;
-{
-  "rootMethod": "net.micode.notes.gtask.data.Node#setContentByRemoteJSON(JSONObject)",
-  "projectClassification": {
-    "searchMode": "OpenProject", // OpenProject, AllProjects
-    "includedProjects": "",
-    "pathEndKeywords": "*.impl",
-    "isClientPath": "",
-    "isClientName": "",
-    "isTestPath": "",
-    "isTestName": "",
-    "isMappingPath": "",
-    "isMappingName": "",
-    "isDataAccessPath": "",
-    "isDataAccessName": "",
-    "isDataStructurePath": "",
-    "isDataStructureName": "",
-    "isInterfaceStructuresPath": "",
-    "isInterfaceStructuresName": "",
-    "isEntryPointPath": "",
-    "isEntryPointName": "",
-    "treatFinalFieldsAsMandatory": false
-  },
-  "graphRestriction": {
-    "classPackageExcludeFilter": "",
-    "classPackageIncludeFilter": "",
-    "classNameExcludeFilter": "",
-    "classNameIncludeFilter": "",
-    "methodNameExcludeFilter": "",
-    "methodNameIncludeFilter": "",
-    "removeByInheritance": "", // inheritance/annotation based filtering is done in a second step
-    "removeByAnnotation": "",
-    "removeByClassPackage": "", // cleanup the graph after inheritance/annotation based filtering is done
-    "removeByClassName": "",
-    "cutMappings": false,
-    "cutEnum": true,
-    "cutTests": true,
-    "cutClient": true,
-    "cutDataAccess": true,
-    "cutInterfaceStructures": true,
-    "cutDataStructures": true,
-    "cutGetterAndSetter": true,
-    "cutConstructors": true
-  },
-  "graphTraversal": {
-    "forwardDepth": 3,
-    "backwardDepth": 3,
-    "classPackageExcludeFilter": "",
-    "classPackageIncludeFilter": "",
-    "classNameExcludeFilter": "",
-    "classNameIncludeFilter": "",
-    "methodNameExcludeFilter": "",
-    "methodNameIncludeFilter": "",
-    "hideMappings": false,
-    "hideDataStructures": false,
-    "hidePrivateMethods": true,
-    "hideInterfaceCalls": true, // indirection: implementation -> interface (is hidden) -> implementation
-    "onlyShowApplicationEntryPoints": false, // root node is included
-    "useMethodCallsForStructureDiagram": "ForwardOnly" // ForwardOnly, BothDirections, No
-  },
-  "details": {
-    "aggregation": "GroupByClass", // ByClass, GroupByClass, None
-    "showMethodParametersTypes": false,
-    "showMethodParametersNames": false,
-    "showMethodReturnType": false,
-    "showPackageLevels": 2,
-    "showCallOrder": false,
-    "edgeMode": "MethodsOnly", // TypesOnly, MethodsOnly, TypesAndMethods, MethodsAndDirectTypeUsage
-    "showDetailedClassStructure": false
-  },
-  "rootClass": "net.micode.notes.gtask.data.Node",
-  "extensionCallbackMethod": "" // qualified.class.name#methodName - signature: public static String method(String)
-}
-diagram meta data end '/
-
-
-
-digraph g {
-    rankdir="LR"
-    splines=polyline
-    
-
-'nodes 
-subgraph cluster_1074360951 { 
-   	label=micode
-	labeljust=l
-	fillcolor="#ececec"
-	style=filled
-   
-   subgraph cluster_502284772 { 
-   	label=notes
-	labeljust=l
-	fillcolor="#d8d8d8"
-	style=filled
-   
-   subgraph cluster_761247683 { 
-   	label=Node
-	labeljust=l
-	fillcolor=white
-	style=filled
-   
-   Node617846867XXXsetContentByRemoteJSON1752376903[
-	label="+ setContentByRemoteJSON()"
-	style=filled
-	fillcolor=white
-	tooltip="Node
-
-null"
-	penwidth=4
-	fontcolor=darkgreen
-];
-} 
-} 
-} 
-
-'edges    
-
-    
-}
-@enduml

小米标签及案例/源程序代码-小米便签-Notes-master/Notes-master/src/net/micode/notes/gtask/data/Node_4_setContentByLocalJSON_calls.puml

@@ -1,140 +0,0 @@
-@startuml
-
-/' diagram meta data start
-config=CallConfiguration;
-{
-  "rootMethod": "net.micode.notes.gtask.data.Node#setContentByLocalJSON(JSONObject)",
-  "projectClassification": {
-    "searchMode": "OpenProject", // OpenProject, AllProjects
-    "includedProjects": "",
-    "pathEndKeywords": "*.impl",
-    "isClientPath": "",
-    "isClientName": "",
-    "isTestPath": "",
-    "isTestName": "",
-    "isMappingPath": "",
-    "isMappingName": "",
-    "isDataAccessPath": "",
-    "isDataAccessName": "",
-    "isDataStructurePath": "",
-    "isDataStructureName": "",
-    "isInterfaceStructuresPath": "",
-    "isInterfaceStructuresName": "",
-    "isEntryPointPath": "",
-    "isEntryPointName": "",
-    "treatFinalFieldsAsMandatory": false
-  },
-  "graphRestriction": {
-    "classPackageExcludeFilter": "",
-    "classPackageIncludeFilter": "",
-    "classNameExcludeFilter": "",
-    "classNameIncludeFilter": "",
-    "methodNameExcludeFilter": "",
-    "methodNameIncludeFilter": "",
-    "removeByInheritance": "", // inheritance/annotation based filtering is done in a second step
-    "removeByAnnotation": "",
-    "removeByClassPackage": "", // cleanup the graph after inheritance/annotation based filtering is done
-    "removeByClassName": "",
-    "cutMappings": false,
-    "cutEnum": true,
-    "cutTests": true,
-    "cutClient": true,
-    "cutDataAccess": true,
-    "cutInterfaceStructures": true,
-    "cutDataStructures": true,
-    "cutGetterAndSetter": true,
-    "cutConstructors": true
-  },
-  "graphTraversal": {
-    "forwardDepth": 3,
-    "backwardDepth": 3,
-    "classPackageExcludeFilter": "",
-    "classPackageIncludeFilter": "",
-    "classNameExcludeFilter": "",
-    "classNameIncludeFilter": "",
-    "methodNameExcludeFilter": "",
-    "methodNameIncludeFilter": "",
-    "hideMappings": false,
-    "hideDataStructures": false,
-    "hidePrivateMethods": true,
-    "hideInterfaceCalls": true, // indirection: implementation -> interface (is hidden) -> implementation
-    "onlyShowApplicationEntryPoints": false, // root node is included
-    "useMethodCallsForStructureDiagram": "ForwardOnly" // ForwardOnly, BothDirections, No
-  },
-  "details": {
-    "aggregation": "GroupByClass", // ByClass, GroupByClass, None
-    "showMethodParametersTypes": false,
-    "showMethodParametersNames": false,
-    "showMethodReturnType": false,
-    "showPackageLevels": 2,
-    "showCallOrder": false,
-    "edgeMode": "MethodsOnly", // TypesOnly, MethodsOnly, TypesAndMethods, MethodsAndDirectTypeUsage
-    "showDetailedClassStructure": false
-  },
-  "rootClass": "net.micode.notes.gtask.data.Node",
-  "extensionCallbackMethod": "" // qualified.class.name#methodName - signature: public static String method(String)
-}
-diagram meta data end '/
-
-
-
-digraph g {
-    rankdir="LR"
-    splines=polyline
-    
-
-'nodes 
-subgraph cluster_1074360951 { 
-   	label=micode
-	labeljust=l
-	fillcolor="#ececec"
-	style=filled
-   
-   subgraph cluster_502284772 { 
-   	label=notes
-	labeljust=l
-	fillcolor="#d8d8d8"
-	style=filled
-   
-   subgraph cluster_1368530406 { 
-   	label=GTaskManager
-	labeljust=l
-	fillcolor=white
-	style=filled
-   
-   GTaskManager641041527XXXsync656730312[
-	label="+ sync()"
-	style=filled
-	fillcolor=white
-	tooltip="GTaskManager
-
-null"
-	fontcolor=darkgreen
-];
-} 
-
-subgraph cluster_761247683 { 
-   	label=Node
-	labeljust=l
-	fillcolor=white
-	style=filled
-   
-   Node617846867XXXsetContentByLocalJSON1752376903[
-	label="+ setContentByLocalJSON()"
-	style=filled
-	fillcolor=white
-	tooltip="Node
-
-null"
-	penwidth=4
-	fontcolor=darkgreen
-];
-} 
-} 
-} 
-
-'edges    
-GTaskManager641041527XXXsync656730312 -> Node617846867XXXsetContentByLocalJSON1752376903;
-    
-}
-@enduml

小米标签及案例/源程序代码-小米便签-Notes-master/Notes-master/src/net/micode/notes/gtask/data/Node_5_getLocalJSONFromContent_calls.puml

@@ -1,140 +0,0 @@
-@startuml
-
-/' diagram meta data start
-config=CallConfiguration;
-{
-  "rootMethod": "net.micode.notes.gtask.data.Node#getLocalJSONFromContent()",
-  "projectClassification": {
-    "searchMode": "OpenProject", // OpenProject, AllProjects
-    "includedProjects": "",
-    "pathEndKeywords": "*.impl",
-    "isClientPath": "",
-    "isClientName": "",
-    "isTestPath": "",
-    "isTestName": "",
-    "isMappingPath": "",
-    "isMappingName": "",
-    "isDataAccessPath": "",
-    "isDataAccessName": "",
-    "isDataStructurePath": "",
-    "isDataStructureName": "",
-    "isInterfaceStructuresPath": "",
-    "isInterfaceStructuresName": "",
-    "isEntryPointPath": "",
-    "isEntryPointName": "",
-    "treatFinalFieldsAsMandatory": false
-  },
-  "graphRestriction": {
-    "classPackageExcludeFilter": "",
-    "classPackageIncludeFilter": "",
-    "classNameExcludeFilter": "",
-    "classNameIncludeFilter": "",
-    "methodNameExcludeFilter": "",
-    "methodNameIncludeFilter": "",
-    "removeByInheritance": "", // inheritance/annotation based filtering is done in a second step
-    "removeByAnnotation": "",
-    "removeByClassPackage": "", // cleanup the graph after inheritance/annotation based filtering is done
-    "removeByClassName": "",
-    "cutMappings": false,
-    "cutEnum": true,
-    "cutTests": true,
-    "cutClient": true,
-    "cutDataAccess": true,
-    "cutInterfaceStructures": true,
-    "cutDataStructures": true,
-    "cutGetterAndSetter": true,
-    "cutConstructors": true
-  },
-  "graphTraversal": {
-    "forwardDepth": 3,
-    "backwardDepth": 3,
-    "classPackageExcludeFilter": "",
-    "classPackageIncludeFilter": "",
-    "classNameExcludeFilter": "",
-    "classNameIncludeFilter": "",
-    "methodNameExcludeFilter": "",
-    "methodNameIncludeFilter": "",
-    "hideMappings": false,
-    "hideDataStructures": false,
-    "hidePrivateMethods": true,
-    "hideInterfaceCalls": true, // indirection: implementation -> interface (is hidden) -> implementation
-    "onlyShowApplicationEntryPoints": false, // root node is included
-    "useMethodCallsForStructureDiagram": "ForwardOnly" // ForwardOnly, BothDirections, No
-  },
-  "details": {
-    "aggregation": "GroupByClass", // ByClass, GroupByClass, None
-    "showMethodParametersTypes": false,
-    "showMethodParametersNames": false,
-    "showMethodReturnType": false,
-    "showPackageLevels": 2,
-    "showCallOrder": false,
-    "edgeMode": "MethodsOnly", // TypesOnly, MethodsOnly, TypesAndMethods, MethodsAndDirectTypeUsage
-    "showDetailedClassStructure": false
-  },
-  "rootClass": "net.micode.notes.gtask.data.Node",
-  "extensionCallbackMethod": "" // qualified.class.name#methodName - signature: public static String method(String)
-}
-diagram meta data end '/
-
-
-
-digraph g {
-    rankdir="LR"
-    splines=polyline
-    
-
-'nodes 
-subgraph cluster_1074360951 { 
-   	label=micode
-	labeljust=l
-	fillcolor="#ececec"
-	style=filled
-   
-   subgraph cluster_502284772 { 
-   	label=notes
-	labeljust=l
-	fillcolor="#d8d8d8"
-	style=filled
-   
-   subgraph cluster_1368530406 { 
-   	label=GTaskManager
-	labeljust=l
-	fillcolor=white
-	style=filled
-   
-   GTaskManager641041527XXXsync656730312[
-	label="+ sync()"
-	style=filled
-	fillcolor=white
-	tooltip="GTaskManager
-
-null"
-	fontcolor=darkgreen
-];
-} 
-
-subgraph cluster_761247683 { 
-   	label=Node
-	labeljust=l
-	fillcolor=white
-	style=filled
-   
-   Node617846867XXXgetLocalJSONFromContent0[
-	label="+ getLocalJSONFromContent()"
-	style=filled
-	fillcolor=white
-	tooltip="Node
-
-null"
-	penwidth=4
-	fontcolor=darkgreen
-];
-} 
-} 
-} 
-
-'edges    
-GTaskManager641041527XXXsync656730312 -> Node617846867XXXgetLocalJSONFromContent0;
-    
-}
-@enduml

小米标签及案例/源程序代码-小米便签-Notes-master/Notes-master/src/net/micode/notes/gtask/data/Node_6_getSyncAction_calls.puml

@@ -1,194 +0,0 @@
-@startuml
-
-/' diagram meta data start
-config=CallConfiguration;
-{
-  "rootMethod": "net.micode.notes.gtask.data.Node#getSyncAction(Cursor)",
-  "projectClassification": {
-    "searchMode": "OpenProject", // OpenProject, AllProjects
-    "includedProjects": "",
-    "pathEndKeywords": "*.impl",
-    "isClientPath": "",
-    "isClientName": "",
-    "isTestPath": "",
-    "isTestName": "",
-    "isMappingPath": "",
-    "isMappingName": "",
-    "isDataAccessPath": "",
-    "isDataAccessName": "",
-    "isDataStructurePath": "",
-    "isDataStructureName": "",
-    "isInterfaceStructuresPath": "",
-    "isInterfaceStructuresName": "",
-    "isEntryPointPath": "",
-    "isEntryPointName": "",
-    "treatFinalFieldsAsMandatory": false
-  },
-  "graphRestriction": {
-    "classPackageExcludeFilter": "",
-    "classPackageIncludeFilter": "",
-    "classNameExcludeFilter": "",
-    "classNameIncludeFilter": "",
-    "methodNameExcludeFilter": "",
-    "methodNameIncludeFilter": "",
-    "removeByInheritance": "", // inheritance/annotation based filtering is done in a second step
-    "removeByAnnotation": "",
-    "removeByClassPackage": "", // cleanup the graph after inheritance/annotation based filtering is done
-    "removeByClassName": "",
-    "cutMappings": false,
-    "cutEnum": true,
-    "cutTests": true,
-    "cutClient": true,
-    "cutDataAccess": true,
-    "cutInterfaceStructures": true,
-    "cutDataStructures": true,
-    "cutGetterAndSetter": true,
-    "cutConstructors": true
-  },
-  "graphTraversal": {
-    "forwardDepth": 3,
-    "backwardDepth": 3,
-    "classPackageExcludeFilter": "",
-    "classPackageIncludeFilter": "",
-    "classNameExcludeFilter": "",
-    "classNameIncludeFilter": "",
-    "methodNameExcludeFilter": "",
-    "methodNameIncludeFilter": "",
-    "hideMappings": false,
-    "hideDataStructures": false,
-    "hidePrivateMethods": true,
-    "hideInterfaceCalls": true, // indirection: implementation -> interface (is hidden) -> implementation
-    "onlyShowApplicationEntryPoints": false, // root node is included
-    "useMethodCallsForStructureDiagram": "ForwardOnly" // ForwardOnly, BothDirections, No
-  },
-  "details": {
-    "aggregation": "GroupByClass", // ByClass, GroupByClass, None
-    "showMethodParametersTypes": false,
-    "showMethodParametersNames": false,
-    "showMethodReturnType": false,
-    "showPackageLevels": 2,
-    "showCallOrder": false,
-    "edgeMode": "MethodsOnly", // TypesOnly, MethodsOnly, TypesAndMethods, MethodsAndDirectTypeUsage
-    "showDetailedClassStructure": false
-  },
-  "rootClass": "net.micode.notes.gtask.data.Node",
-  "extensionCallbackMethod": "" // qualified.class.name#methodName - signature: public static String method(String)
-}
-diagram meta data end '/
-
-
-
-digraph g {
-    rankdir="LR"
-    splines=polyline
-    
-
-'nodes 
-subgraph cluster_1074360951 { 
-   	label=micode
-	labeljust=l
-	fillcolor="#ececec"
-	style=filled
-   
-   subgraph cluster_502284772 { 
-   	label=notes
-	labeljust=l
-	fillcolor="#d8d8d8"
-	style=filled
-   
-   subgraph cluster_1368530406 { 
-   	label=GTaskManager
-	labeljust=l
-	fillcolor=white
-	style=filled
-   
-   GTaskManager641041527XXXsync656730312[
-	label="+ sync()"
-	style=filled
-	fillcolor=white
-	tooltip="GTaskManager
-
-null"
-	fontcolor=darkgreen
-];
-} 
-
-subgraph cluster_633221264 { 
-   	label=MetaData
-	labeljust=l
-	fillcolor=white
-	style=filled
-   
-   MetaData617846867XXXgetSyncAction2029715318[
-	label="+ getSyncAction()"
-	style=filled
-	fillcolor=white
-	tooltip="MetaData
-
-null"
-	fontcolor=darkgreen
-];
-} 
-
-subgraph cluster_673796356 { 
-   	label=TaskList
-	labeljust=l
-	fillcolor=white
-	style=filled
-   
-   TaskList617846867XXXgetSyncAction2029715318[
-	label="+ getSyncAction()"
-	style=filled
-	fillcolor=white
-	tooltip="TaskList
-
-null"
-	fontcolor=darkgreen
-];
-} 
-
-subgraph cluster_761247683 { 
-   	label=Node
-	labeljust=l
-	fillcolor=white
-	style=filled
-   
-   Node617846867XXXgetSyncAction2029715318[
-	label="+ getSyncAction()"
-	style=filled
-	fillcolor=white
-	tooltip="Node
-
-null"
-	penwidth=4
-	fontcolor=darkgreen
-];
-} 
-
-subgraph cluster_761413446 { 
-   	label=Task
-	labeljust=l
-	fillcolor=white
-	style=filled
-   
-   Task617846867XXXgetSyncAction2029715318[
-	label="+ getSyncAction()"
-	style=filled
-	fillcolor=white
-	tooltip="Task
-
-null"
-	fontcolor=darkgreen
-];
-} 
-} 
-} 
-
-'edges    
-GTaskManager641041527XXXsync656730312 -> Node617846867XXXgetSyncAction2029715318;
-Node617846867XXXgetSyncAction2029715318 -> Task617846867XXXgetSyncAction2029715318;
-Node617846867XXXgetSyncAction2029715318 -> TaskList617846867XXXgetSyncAction2029715318;
-Task617846867XXXgetSyncAction2029715318 -> MetaData617846867XXXgetSyncAction2029715318;
-    
-}
-@enduml

小米标签及案例/源程序代码-小米便签-Notes-master/Notes-master/src/net/micode/notes/gtask/data/Node_7_setGid_calls.puml

@@ -1,170 +0,0 @@
-@startuml
-
-/' diagram meta data start
-config=CallConfiguration;
-{
-  "rootMethod": "net.micode.notes.gtask.data.Node#setGid(String)",
-  "projectClassification": {
-    "searchMode": "OpenProject", // OpenProject, AllProjects
-    "includedProjects": "",
-    "pathEndKeywords": "*.impl",
-    "isClientPath": "",
-    "isClientName": "",
-    "isTestPath": "",
-    "isTestName": "",
-    "isMappingPath": "",
-    "isMappingName": "",
-    "isDataAccessPath": "",
-    "isDataAccessName": "",
-    "isDataStructurePath": "",
-    "isDataStructureName": "",
-    "isInterfaceStructuresPath": "",
-    "isInterfaceStructuresName": "",
-    "isEntryPointPath": "",
-    "isEntryPointName": "",
-    "treatFinalFieldsAsMandatory": false
-  },
-  "graphRestriction": {
-    "classPackageExcludeFilter": "",
-    "classPackageIncludeFilter": "",
-    "classNameExcludeFilter": "",
-    "classNameIncludeFilter": "",
-    "methodNameExcludeFilter": "",
-    "methodNameIncludeFilter": "",
-    "removeByInheritance": "", // inheritance/annotation based filtering is done in a second step
-    "removeByAnnotation": "",
-    "removeByClassPackage": "", // cleanup the graph after inheritance/annotation based filtering is done
-    "removeByClassName": "",
-    "cutMappings": false,
-    "cutEnum": true,
-    "cutTests": true,
-    "cutClient": true,
-    "cutDataAccess": true,
-    "cutInterfaceStructures": true,
-    "cutDataStructures": true,
-    "cutGetterAndSetter": true,
-    "cutConstructors": true
-  },
-  "graphTraversal": {
-    "forwardDepth": 3,
-    "backwardDepth": 3,
-    "classPackageExcludeFilter": "",
-    "classPackageIncludeFilter": "",
-    "classNameExcludeFilter": "",
-    "classNameIncludeFilter": "",
-    "methodNameExcludeFilter": "",
-    "methodNameIncludeFilter": "",
-    "hideMappings": false,
-    "hideDataStructures": false,
-    "hidePrivateMethods": true,
-    "hideInterfaceCalls": true, // indirection: implementation -> interface (is hidden) -> implementation
-    "onlyShowApplicationEntryPoints": false, // root node is included
-    "useMethodCallsForStructureDiagram": "ForwardOnly" // ForwardOnly, BothDirections, No
-  },
-  "details": {
-    "aggregation": "GroupByClass", // ByClass, GroupByClass, None
-    "showMethodParametersTypes": false,
-    "showMethodParametersNames": false,
-    "showMethodReturnType": false,
-    "showPackageLevels": 2,
-    "showCallOrder": false,
-    "edgeMode": "MethodsOnly", // TypesOnly, MethodsOnly, TypesAndMethods, MethodsAndDirectTypeUsage
-    "showDetailedClassStructure": false
-  },
-  "rootClass": "net.micode.notes.gtask.data.Node",
-  "extensionCallbackMethod": "" // qualified.class.name#methodName - signature: public static String method(String)
-}
-diagram meta data end '/
-
-
-
-digraph g {
-    rankdir="LR"
-    splines=polyline
-    
-
-'nodes 
-subgraph cluster_1074360951 { 
-   	label=micode
-	labeljust=l
-	fillcolor="#ececec"
-	style=filled
-   
-   subgraph cluster_502284772 { 
-   	label=notes
-	labeljust=l
-	fillcolor="#d8d8d8"
-	style=filled
-   
-   subgraph cluster_1368530406 { 
-   	label=GTaskManager
-	labeljust=l
-	fillcolor=white
-	style=filled
-   
-   GTaskManager641041527XXXsync656730312[
-	label="+ sync()"
-	style=filled
-	fillcolor=white
-	tooltip="GTaskManager
-
-null"
-	fontcolor=darkgreen
-];
-} 
-
-subgraph cluster_1430436466 { 
-   	label=GTaskClient
-	labeljust=l
-	fillcolor=white
-	style=filled
-   
-   GTaskClient641041527XXXcreateTask2599333[
-	label="+ createTask()"
-	style=filled
-	fillcolor=white
-	tooltip="GTaskClient
-
-null"
-	fontcolor=darkgreen
-];
-
-GTaskClient641041527XXXcreateTaskList345738269[
-	label="+ createTaskList()"
-	style=filled
-	fillcolor=white
-	tooltip="GTaskClient
-
-null"
-	fontcolor=darkgreen
-];
-} 
-
-subgraph cluster_761247683 { 
-   	label=Node
-	labeljust=l
-	fillcolor=white
-	style=filled
-   
-   Node617846867XXXsetGid1808118735[
-	label="+ setGid()"
-	style=filled
-	fillcolor=white
-	tooltip="Node
-
-null"
-	penwidth=4
-	fontcolor=darkgreen
-];
-} 
-} 
-} 
-
-'edges    
-GTaskClient641041527XXXcreateTask2599333 -> Node617846867XXXsetGid1808118735;
-GTaskClient641041527XXXcreateTaskList345738269 -> Node617846867XXXsetGid1808118735;
-GTaskManager641041527XXXsync656730312 -> GTaskClient641041527XXXcreateTask2599333;
-GTaskManager641041527XXXsync656730312 -> GTaskClient641041527XXXcreateTaskList345738269;
-    
-}
-@enduml

小米标签及案例/源程序代码-小米便签-Notes-master/Notes-master/src/net/micode/notes/gtask/data/Node_8_setName_calls.puml

@@ -1,140 +0,0 @@
-@startuml
-
-/' diagram meta data start
-config=CallConfiguration;
-{
-  "rootMethod": "net.micode.notes.gtask.data.Node#setName(String)",
-  "projectClassification": {
-    "searchMode": "OpenProject", // OpenProject, AllProjects
-    "includedProjects": "",
-    "pathEndKeywords": "*.impl",
-    "isClientPath": "",
-    "isClientName": "",
-    "isTestPath": "",
-    "isTestName": "",
-    "isMappingPath": "",
-    "isMappingName": "",
-    "isDataAccessPath": "",
-    "isDataAccessName": "",
-    "isDataStructurePath": "",
-    "isDataStructureName": "",
-    "isInterfaceStructuresPath": "",
-    "isInterfaceStructuresName": "",
-    "isEntryPointPath": "",
-    "isEntryPointName": "",
-    "treatFinalFieldsAsMandatory": false
-  },
-  "graphRestriction": {
-    "classPackageExcludeFilter": "",
-    "classPackageIncludeFilter": "",
-    "classNameExcludeFilter": "",
-    "classNameIncludeFilter": "",
-    "methodNameExcludeFilter": "",
-    "methodNameIncludeFilter": "",
-    "removeByInheritance": "", // inheritance/annotation based filtering is done in a second step
-    "removeByAnnotation": "",
-    "removeByClassPackage": "", // cleanup the graph after inheritance/annotation based filtering is done
-    "removeByClassName": "",
-    "cutMappings": false,
-    "cutEnum": true,
-    "cutTests": true,
-    "cutClient": true,
-    "cutDataAccess": true,
-    "cutInterfaceStructures": true,
-    "cutDataStructures": true,
-    "cutGetterAndSetter": true,
-    "cutConstructors": true
-  },
-  "graphTraversal": {
-    "forwardDepth": 3,
-    "backwardDepth": 3,
-    "classPackageExcludeFilter": "",
-    "classPackageIncludeFilter": "",
-    "classNameExcludeFilter": "",
-    "classNameIncludeFilter": "",
-    "methodNameExcludeFilter": "",
-    "methodNameIncludeFilter": "",
-    "hideMappings": false,
-    "hideDataStructures": false,
-    "hidePrivateMethods": true,
-    "hideInterfaceCalls": true, // indirection: implementation -> interface (is hidden) -> implementation
-    "onlyShowApplicationEntryPoints": false, // root node is included
-    "useMethodCallsForStructureDiagram": "ForwardOnly" // ForwardOnly, BothDirections, No
-  },
-  "details": {
-    "aggregation": "GroupByClass", // ByClass, GroupByClass, None
-    "showMethodParametersTypes": false,
-    "showMethodParametersNames": false,
-    "showMethodReturnType": false,
-    "showPackageLevels": 2,
-    "showCallOrder": false,
-    "edgeMode": "MethodsOnly", // TypesOnly, MethodsOnly, TypesAndMethods, MethodsAndDirectTypeUsage
-    "showDetailedClassStructure": false
-  },
-  "rootClass": "net.micode.notes.gtask.data.Node",
-  "extensionCallbackMethod": "" // qualified.class.name#methodName - signature: public static String method(String)
-}
-diagram meta data end '/
-
-
-
-digraph g {
-    rankdir="LR"
-    splines=polyline
-    
-
-'nodes 
-subgraph cluster_1074360951 { 
-   	label=micode
-	labeljust=l
-	fillcolor="#ececec"
-	style=filled
-   
-   subgraph cluster_502284772 { 
-   	label=notes
-	labeljust=l
-	fillcolor="#d8d8d8"
-	style=filled
-   
-   subgraph cluster_1368530406 { 
-   	label=GTaskManager
-	labeljust=l
-	fillcolor=white
-	style=filled
-   
-   GTaskManager641041527XXXsync656730312[
-	label="+ sync()"
-	style=filled
-	fillcolor=white
-	tooltip="GTaskManager
-
-null"
-	fontcolor=darkgreen
-];
-} 
-
-subgraph cluster_761247683 { 
-   	label=Node
-	labeljust=l
-	fillcolor=white
-	style=filled
-   
-   Node617846867XXXsetName1808118735[
-	label="+ setName()"
-	style=filled
-	fillcolor=white
-	tooltip="Node
-
-null"
-	penwidth=4
-	fontcolor=darkgreen
-];
-} 
-} 
-} 
-
-'edges    
-GTaskManager641041527XXXsync656730312 -> Node617846867XXXsetName1808118735;
-    
-}
-@enduml

小米标签及案例/源程序代码-小米便签-Notes-master/Notes-master/src/net/micode/notes/gtask/data/Node_9_setLastModified_calls.puml

@@ -1,123 +0,0 @@
-@startuml
-
-/' diagram meta data start
-config=CallConfiguration;
-{
-  "rootMethod": "net.micode.notes.gtask.data.Node#setLastModified(long)",
-  "projectClassification": {
-    "searchMode": "OpenProject", // OpenProject, AllProjects
-    "includedProjects": "",
-    "pathEndKeywords": "*.impl",
-    "isClientPath": "",
-    "isClientName": "",
-    "isTestPath": "",
-    "isTestName": "",
-    "isMappingPath": "",
-    "isMappingName": "",
-    "isDataAccessPath": "",
-    "isDataAccessName": "",
-    "isDataStructurePath": "",
-    "isDataStructureName": "",
-    "isInterfaceStructuresPath": "",
-    "isInterfaceStructuresName": "",
-    "isEntryPointPath": "",
-    "isEntryPointName": "",
-    "treatFinalFieldsAsMandatory": false
-  },
-  "graphRestriction": {
-    "classPackageExcludeFilter": "",
-    "classPackageIncludeFilter": "",
-    "classNameExcludeFilter": "",
-    "classNameIncludeFilter": "",
-    "methodNameExcludeFilter": "",
-    "methodNameIncludeFilter": "",
-    "removeByInheritance": "", // inheritance/annotation based filtering is done in a second step
-    "removeByAnnotation": "",
-    "removeByClassPackage": "", // cleanup the graph after inheritance/annotation based filtering is done
-    "removeByClassName": "",
-    "cutMappings": false,
-    "cutEnum": true,
-    "cutTests": true,
-    "cutClient": true,
-    "cutDataAccess": true,
-    "cutInterfaceStructures": true,
-    "cutDataStructures": true,
-    "cutGetterAndSetter": true,
-    "cutConstructors": true
-  },
-  "graphTraversal": {
-    "forwardDepth": 3,
-    "backwardDepth": 3,
-    "classPackageExcludeFilter": "",
-    "classPackageIncludeFilter": "",
-    "classNameExcludeFilter": "",
-    "classNameIncludeFilter": "",
-    "methodNameExcludeFilter": "",
-    "methodNameIncludeFilter": "",
-    "hideMappings": false,
-    "hideDataStructures": false,
-    "hidePrivateMethods": true,
-    "hideInterfaceCalls": true, // indirection: implementation -> interface (is hidden) -> implementation
-    "onlyShowApplicationEntryPoints": false, // root node is included
-    "useMethodCallsForStructureDiagram": "ForwardOnly" // ForwardOnly, BothDirections, No
-  },
-  "details": {
-    "aggregation": "GroupByClass", // ByClass, GroupByClass, None
-    "showMethodParametersTypes": false,
-    "showMethodParametersNames": false,
-    "showMethodReturnType": false,
-    "showPackageLevels": 2,
-    "showCallOrder": false,
-    "edgeMode": "MethodsOnly", // TypesOnly, MethodsOnly, TypesAndMethods, MethodsAndDirectTypeUsage
-    "showDetailedClassStructure": false
-  },
-  "rootClass": "net.micode.notes.gtask.data.Node",
-  "extensionCallbackMethod": "" // qualified.class.name#methodName - signature: public static String method(String)
-}
-diagram meta data end '/
-
-
-
-digraph g {
-    rankdir="LR"
-    splines=polyline
-    
-
-'nodes 
-subgraph cluster_1074360951 { 
-   	label=micode
-	labeljust=l
-	fillcolor="#ececec"
-	style=filled
-   
-   subgraph cluster_502284772 { 
-   	label=notes
-	labeljust=l
-	fillcolor="#d8d8d8"
-	style=filled
-   
-   subgraph cluster_761247683 { 
-   	label=Node
-	labeljust=l
-	fillcolor=white
-	style=filled
-   
-   Node617846867XXXsetLastModified3327612[
-	label="+ setLastModified()"
-	style=filled
-	fillcolor=white
-	tooltip="Node
-
-null"
-	penwidth=4
-	fontcolor=darkgreen
-];
-} 
-} 
-} 
-
-'edges    
-
-    
-}
-@enduml

小米标签及案例/源程序代码-小米便签-Notes-master/Notes-master/src/net/micode/notes/gtask/data/Node_structure.puml

@@ -1,256 +0,0 @@
-@startuml
-
-/' diagram meta data start
-config=StructureConfiguration;
-{
-  "projectClassification": {
-    "searchMode": "OpenProject", // OpenProject, AllProjects
-    "includedProjects": "",
-    "pathEndKeywords": "*.impl",
-    "isClientPath": "",
-    "isClientName": "",
-    "isTestPath": "",
-    "isTestName": "",
-    "isMappingPath": "",
-    "isMappingName": "",
-    "isDataAccessPath": "",
-    "isDataAccessName": "",
-    "isDataStructurePath": "",
-    "isDataStructureName": "",
-    "isInterfaceStructuresPath": "",
-    "isInterfaceStructuresName": "",
-    "isEntryPointPath": "",
-    "isEntryPointName": "",
-    "treatFinalFieldsAsMandatory": false
-  },
-  "graphRestriction": {
-    "classPackageExcludeFilter": "",
-    "classPackageIncludeFilter": "",
-    "classNameExcludeFilter": "",
-    "classNameIncludeFilter": "",
-    "methodNameExcludeFilter": "",
-    "methodNameIncludeFilter": "",
-    "removeByInheritance": "", // inheritance/annotation based filtering is done in a second step
-    "removeByAnnotation": "",
-    "removeByClassPackage": "", // cleanup the graph after inheritance/annotation based filtering is done
-    "removeByClassName": "",
-    "cutMappings": false,
-    "cutEnum": true,
-    "cutTests": true,
-    "cutClient": true,
-    "cutDataAccess": false,
-    "cutInterfaceStructures": false,
-    "cutDataStructures": false,
-    "cutGetterAndSetter": true,
-    "cutConstructors": true
-  },
-  "graphTraversal": {
-    "forwardDepth": 6,
-    "backwardDepth": 6,
-    "classPackageExcludeFilter": "",
-    "classPackageIncludeFilter": "",
-    "classNameExcludeFilter": "",
-    "classNameIncludeFilter": "",
-    "methodNameExcludeFilter": "",
-    "methodNameIncludeFilter": "",
-    "hideMappings": false,
-    "hideDataStructures": false,
-    "hidePrivateMethods": true,
-    "hideInterfaceCalls": true, // indirection: implementation -> interface (is hidden) -> implementation
-    "onlyShowApplicationEntryPoints": false, // root node is included
-    "useMethodCallsForStructureDiagram": "ForwardOnly" // ForwardOnly, BothDirections, No
-  },
-  "details": {
-    "aggregation": "GroupByClass", // ByClass, GroupByClass, None
-    "showClassGenericTypes": true,
-    "showMethods": true,
-    "showMethodParameterNames": true,
-    "showMethodParameterTypes": true,
-    "showMethodReturnType": true,
-    "showPackageLevels": 2,
-    "showDetailedClassStructure": true
-  },
-  "rootClass": "net.micode.notes.gtask.data.Node",
-  "extensionCallbackMethod": "" // qualified.class.name#methodName - signature: public static String method(String)
-}
-diagram meta data end '/
-
-
-
-digraph g {
-    rankdir="TB"
-    splines=polyline
-    
-
-'nodes 
-subgraph cluster_1074360951 { 
-   	label=micode
-	labeljust=l
-	fillcolor="#ececec"
-	style=filled
-   
-   subgraph cluster_502284772 { 
-   	label=notes
-	labeljust=l
-	fillcolor="#d8d8d8"
-	style=filled
-   
-   GTaskASyncTask641041527[
-	label=<<TABLE BORDER="1" CELLBORDER="0" CELLPADDING="4" CELLSPACING="0">
-<TR><TD ALIGN="LEFT" >(C)GTaskASyncTask</TD></TR>
-<HR/>
-<TR><TD ALIGN="LEFT" >-   mContext: Context [0..1]</TD></TR>
-<TR><TD ALIGN="LEFT" >-   mNotifiManager: NotificationManager [0..1]</TD></TR>
-<TR><TD ALIGN="LEFT" >-   mOnCompleteListener: OnCompleteListener [0..1]</TD></TR>
-<TR><TD ALIGN="LEFT" >-   mTaskManager: GTaskManager [0..1]</TD></TR>
-<HR/>
-<TR><TD ALIGN="LEFT" >+ cancelSync()</TD></TR>
-<TR><TD ALIGN="LEFT" ># doInBackground(unused: Void...): Integer</TD></TR>
-<TR><TD ALIGN="LEFT" ># onPostExecute(result: Integer)</TD></TR>
-<TR><TD ALIGN="LEFT" ># onProgressUpdate(progress: String...)</TD></TR>
-<TR><TD ALIGN="LEFT" >+ publishProgess(message: String)</TD></TR>
-<TR><TD ALIGN="LEFT" >- showNotification(tickerId: int, content: String)</TD></TR>
-</TABLE>>
-	style=filled
-	margin=0
-	shape=plaintext
-	fillcolor="#FFFFFF"
-];
-
-GTaskManager641041527[
-	label=<<TABLE BORDER="1" CELLBORDER="0" CELLPADDING="4" CELLSPACING="0">
-<TR><TD ALIGN="LEFT" >(C)GTaskManager</TD></TR>
-<HR/>
-<TR><TD ALIGN="LEFT" >-   mActivity: Activity [0..1]</TD></TR>
-<TR><TD ALIGN="LEFT" >-   mCancelled: boolean [1]</TD></TR>
-<TR><TD ALIGN="LEFT" >-   mContentResolver: ContentResolver [0..1]</TD></TR>
-<TR><TD ALIGN="LEFT" >-   mContext: Context [0..1]</TD></TR>
-<TR><TD ALIGN="LEFT" >-   mGTaskHashMap: HashMap&lt;String, Node&gt; [0..*]</TD></TR>
-<TR><TD ALIGN="LEFT" >-   mGTaskListHashMap: HashMap&lt;String, TaskList&gt; [0..*]</TD></TR>
-<TR><TD ALIGN="LEFT" >-   mGidToNid: HashMap&lt;String, Long&gt; [0..*]</TD></TR>
-<TR><TD ALIGN="LEFT" >-   mLocalDeleteIdMap: HashSet&lt;Long&gt; [0..*]</TD></TR>
-<TR><TD ALIGN="LEFT" >-   mMetaHashMap: HashMap&lt;String, MetaData&gt; [0..*]</TD></TR>
-<TR><TD ALIGN="LEFT" >-   mMetaList: TaskList [0..1]</TD></TR>
-<TR><TD ALIGN="LEFT" >-   mNidToGid: HashMap&lt;Long, String&gt; [0..*]</TD></TR>
-<TR><TD ALIGN="LEFT" >-   mSyncing: boolean [1]</TD></TR>
-<HR/>
-<TR><TD ALIGN="LEFT" >- addLocalNode(node: Node)</TD></TR>
-<TR><TD ALIGN="LEFT" >- addRemoteNode(node: Node, c: Cursor)</TD></TR>
-<TR><TD ALIGN="LEFT" >+ cancelSync()</TD></TR>
-<TR><TD ALIGN="LEFT" >- doContentSync(syncType: int, node: Node, c: Cursor)</TD></TR>
-<TR><TD ALIGN="LEFT" >- initGTaskList()</TD></TR>
-<TR><TD ALIGN="LEFT" >- refreshLocalSyncId()</TD></TR>
-<TR><TD ALIGN="LEFT" >+ sync(context: Context, asyncTask: GTaskASyncTask): int</TD></TR>
-<TR><TD ALIGN="LEFT" >- syncContent()</TD></TR>
-<TR><TD ALIGN="LEFT" >- syncFolder()</TD></TR>
-<TR><TD ALIGN="LEFT" >- updateLocalNode(node: Node, c: Cursor)</TD></TR>
-<TR><TD ALIGN="LEFT" >- updateRemoteMeta(gid: String, sqlNote: SqlNote)</TD></TR>
-<TR><TD ALIGN="LEFT" >- updateRemoteNode(node: Node, c: Cursor)</TD></TR>
-</TABLE>>
-	style=filled
-	margin=0
-	shape=plaintext
-	fillcolor="#FFFFFF"
-];
-
-MetaData617846867[
-	label=<<TABLE BORDER="1" CELLBORDER="0" CELLPADDING="4" CELLSPACING="0">
-<TR><TD ALIGN="LEFT" >(C)MetaData</TD></TR>
-<HR/>
-<TR><TD ALIGN="LEFT" >-   mRelatedGid: String [0..1]</TD></TR>
-<HR/>
-<TR><TD ALIGN="LEFT" >+ getSyncAction(c: Cursor): int</TD></TR>
-</TABLE>>
-	style=filled
-	margin=0
-	shape=plaintext
-	fillcolor="#FFFFFF"
-];
-
-Node617846867[
-	label=<<TABLE BORDER="1" CELLBORDER="0" CELLPADDING="4" CELLSPACING="0">
-<TR><TD ALIGN="LEFT" >(C)Node</TD></TR>
-<HR/>
-<TR><TD ALIGN="LEFT" >-   mDeleted: boolean [1]</TD></TR>
-<TR><TD ALIGN="LEFT" >-   mGid: String [0..1]</TD></TR>
-<TR><TD ALIGN="LEFT" >-   mLastModified: long [1]</TD></TR>
-<TR><TD ALIGN="LEFT" >-   mName: String [0..1]</TD></TR>
-<HR/>
-<TR><TD ALIGN="LEFT" >+ getCreateAction(actionId: int): JSONObject</TD></TR>
-<TR><TD ALIGN="LEFT" >+ getSyncAction(c: Cursor): int</TD></TR>
-<TR><TD ALIGN="LEFT" >+ getUpdateAction(actionId: int): JSONObject</TD></TR>
-</TABLE>>
-	style=filled
-	margin=0
-	shape=plaintext
-	fillcolor="#FFFFFF"
-];
-
-Task617846867[
-	label=<<TABLE BORDER="1" CELLBORDER="0" CELLPADDING="4" CELLSPACING="0">
-<TR><TD ALIGN="LEFT" >(C)Task</TD></TR>
-<HR/>
-<TR><TD ALIGN="LEFT" >-   mCompleted: boolean [1]</TD></TR>
-<TR><TD ALIGN="LEFT" >-   mMetaInfo: JSONObject [0..1]</TD></TR>
-<TR><TD ALIGN="LEFT" >-   mNotes: String [0..1]</TD></TR>
-<TR><TD ALIGN="LEFT" >-   mParent: TaskList [0..1]</TD></TR>
-<TR><TD ALIGN="LEFT" >-   mPriorSibling: Task [0..1]</TD></TR>
-<HR/>
-<TR><TD ALIGN="LEFT" >+ getCreateAction(actionId: int): JSONObject</TD></TR>
-<TR><TD ALIGN="LEFT" >+ getSyncAction(c: Cursor): int</TD></TR>
-<TR><TD ALIGN="LEFT" >+ getUpdateAction(actionId: int): JSONObject</TD></TR>
-</TABLE>>
-	style=filled
-	margin=0
-	shape=plaintext
-	fillcolor="#FFFFFF"
-];
-
-TaskList617846867[
-	label=<<TABLE BORDER="1" CELLBORDER="0" CELLPADDING="4" CELLSPACING="0">
-<TR><TD ALIGN="LEFT" >(C)TaskList</TD></TR>
-<HR/>
-<TR><TD ALIGN="LEFT" >-   mChildren: ArrayList&lt;Task&gt; [0..*]</TD></TR>
-<TR><TD ALIGN="LEFT" >-   mIndex: int [1]</TD></TR>
-<HR/>
-<TR><TD ALIGN="LEFT" >+ addChildTask(task: Task): boolean</TD></TR>
-<TR><TD ALIGN="LEFT" >+ addChildTask(task: Task, index: int): boolean</TD></TR>
-<TR><TD ALIGN="LEFT" >+ findChildTaskByGid(gid: String): Task</TD></TR>
-<TR><TD ALIGN="LEFT" >+ getChilTaskByGid(gid: String): Task</TD></TR>
-<TR><TD ALIGN="LEFT" >+ getChildTaskByIndex(index: int): Task</TD></TR>
-<TR><TD ALIGN="LEFT" >+ getChildTaskIndex(task: Task): int</TD></TR>
-<TR><TD ALIGN="LEFT" >+ getCreateAction(actionId: int): JSONObject</TD></TR>
-<TR><TD ALIGN="LEFT" >+ getSyncAction(c: Cursor): int</TD></TR>
-<TR><TD ALIGN="LEFT" >+ getUpdateAction(actionId: int): JSONObject</TD></TR>
-<TR><TD ALIGN="LEFT" >+ moveChildTask(task: Task, index: int): boolean</TD></TR>
-<TR><TD ALIGN="LEFT" >+ removeChildTask(task: Task): boolean</TD></TR>
-</TABLE>>
-	style=filled
-	margin=0
-	shape=plaintext
-	fillcolor="#FFFFFF"
-];
-} 
-} 
-
-'edges    
-GTaskASyncTask641041527 -> GTaskManager641041527[label="mTaskManager
-[0..1]"];
-GTaskManager641041527 -> MetaData617846867[label="mMetaHashMap
-[0..*]"];
-GTaskManager641041527 -> Node617846867[label="mGTaskHashMap
-[0..*]"];
-GTaskManager641041527 -> TaskList617846867[label="mGTaskListHashMap
-[0..*]"];
-GTaskManager641041527 -> TaskList617846867[label="mMetaList
-[0..1]"];
-Node617846867 -> Task617846867[arrowhead=none, arrowtail=empty, dir=both];
-Node617846867 -> TaskList617846867[arrowhead=none, arrowtail=empty, dir=both];
-Task617846867 -> MetaData617846867[arrowhead=none, arrowtail=empty, dir=both];
-Task617846867 -> TaskList617846867[label="mParent
-[0..1]"];
-TaskList617846867 -> Task617846867[label="mChildren
-[0..*]"];
-    
-}
-@enduml