泛读、标注、维护报告

git commit -m 添加代码标注“

README.md

@@ -1,2 +0,0 @@
-# ReadMiNotes
-

test.txt.txt

@@ -1 +0,0 @@
-软件工程

代码标注/AlarmAlertActivity.java

@@ -0,0 +1,166 @@
+/*
+ * 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.ui;
+
+import android.app.Activity;
+import android.app.AlertDialog;
+import android.content.Context;
+import android.content.DialogInterface;
+import android.content.DialogInterface.OnClickListener;
+import android.content.DialogInterface.OnDismissListener;
+import android.content.Intent;
+import android.media.AudioManager;
+import android.media.MediaPlayer;
+import android.media.RingtoneManager;
+import android.net.Uri;
+import android.os.Bundle;
+import android.os.PowerManager;
+import android.provider.Settings;
+import android.view.Window;
+import android.view.WindowManager;
+
+import net.micode.notes.R;
+import net.micode.notes.data.Notes;
+import net.micode.notes.tool.DataUtils;
+
+import java.io.IOException;
+
+
+public class AlarmAlertActivity extends Activity implements OnClickListener, OnDismissListener {
+    
+    private long mNoteId;           // 声明一个long类型的变量mNoteId
+    private String mSnippet;        // 声明一个String类型的变量mSnippet
+    private static final int SNIPPET_PREW_MAX_LEN = 60;     // 声明一个int类型的变量SNIPPET_PREW_MAX_LEN，值为60
+    MediaPlayer mPlayer;            // 声明一个MediaPlayer类型的变量mPlayer
+
+    
+    @Override                       // 重写onCreate方法，用于初始化Activity
+    protected void onCreate(Bundle savedInstanceState) {
+        super.onCreate(savedInstanceState);
+        requestWindowFeature(Window.FEATURE_NO_TITLE);  // 设置当前Activity的标题为空
+        final Window win = getWindow();     // 获取当前Activity的Window对象
+        win.addFlags(WindowManager.LayoutParams.FLAG_SHOW_WHEN_LOCKED);     // 设置当前Activity的Window对象的属性，使其在锁定状态时保持常亮
+
+        if (!isScreenOn()) {        // 判断当前屏幕是否处于锁定状态
+            win.addFlags(WindowManager.LayoutParams.FLAG_KEEP_SCREEN_ON // 如果当前屏幕处于锁定状态，则设置当前Activity的Window对象的属性，使其在锁定状态时保持常亮，并允许锁定屏幕
+                    | WindowManager.LayoutParams.FLAG_TURN_SCREEN_ON
+                    | WindowManager.LayoutParams.FLAG_ALLOW_LOCK_WHILE_SCREEN_ON
+                    | WindowManager.LayoutParams.FLAG_LAYOUT_INSET_DECOR);
+        }
+
+        Intent intent = getIntent();    // 获取当前Activity的Intent
+
+        try {
+            mNoteId = Long.valueOf(intent.getData().getPathSegments().get(1));  // 从Intent中获取mNoteId
+            mSnippet = DataUtils.getSnippetById(this.getContentResolver(), mNoteId);    // 从数据库中获取mSnippet
+            mSnippet = mSnippet.length() > SNIPPET_PREW_MAX_LEN ? mSnippet.substring(0, // 如果mSnippet的长度大于SNIPPET_PREW_MAX_LEN，则截取mSnippet的前SNIPPET_PREW_MAX_LEN个字符，并加上getResources().getString(R.string.notelist_string_info)
+                    SNIPPET_PREW_MAX_LEN) + getResources().getString(R.string.notelist_string_info)
+                    : mSnippet;
+        } catch (IllegalArgumentException e) {
+            e.printStackTrace();
+            return;
+        }
+
+        mPlayer = new MediaPlayer();    // 初始化mPlayer
+        
+        if (DataUtils.visibleInNoteDatabase(getContentResolver(), mNoteId, Notes.TYPE_NOTE)) {  // 判断mNoteId对应的Notes表中的TYPE_NOTE字段是否可见
+            showActionDialog();     // 如果可见，则显示ActionDialog
+            playAlarmSound();       // 播放闹钟音效
+        } else {
+            finish();               // 如果不可见，则结束当前Activity
+        }
+    }
+
+    
+    private boolean isScreenOn() {      // 判断当前屏幕是否处于锁定状态
+        PowerManager pm = (PowerManager) getSystemService(Context.POWER_SERVICE);   // 获取当前系统的PowerManager实例
+        return pm.isScreenOn();         // 判断当前屏幕是否处于锁定状态
+    }
+
+    
+    private void playAlarmSound() {     // 播放闹钟音效
+        Uri url = RingtoneManager.getActualDefaultRingtoneUri(this, RingtoneManager.TYPE_ALARM);    // 获取当前系统默认的闹钟铃声
+
+        int silentModeStreams = Settings.System.getInt(getContentResolver(),    // 获取当前系统设置的静音模式
+                Settings.System.MODE_RINGER_STREAMS_AFFECTED, 0);
+
+        if ((silentModeStreams & (1 << AudioManager.STREAM_ALARM)) != 0) {      // 判断当前系统设置的静音模式是否包含AudioManager.STREAM_ALARM
+            mPlayer.setAudioStreamType(silentModeStreams);                      // 如果包含，则设置mPlayer的音频流类型为silentModeStreams
+        } else {
+            mPlayer.setAudioStreamType(AudioManager.STREAM_ALARM);      // 如果不包含，则设置mPlayer的音频流类型为AudioManager.STREAM_ALARM
+        }
+        try {
+            mPlayer.setDataSource(this, url);   // 设置mPlayer的数据源
+            mPlayer.prepare();                  // 准备播放
+            mPlayer.setLooping(true);           // 设置mPlayer循环播放
+            mPlayer.start();                    // 开始播放
+        } catch (IllegalArgumentException e) {
+            // TODO Auto-generated catch block
+            e.printStackTrace();
+        } catch (SecurityException e) {
+            // TODO Auto-generated catch block
+            e.printStackTrace();
+        } catch (IllegalStateException e) {
+            // TODO Auto-generated catch block
+            e.printStackTrace();
+        } catch (IOException e) {
+            // TODO Auto-generated catch block
+            e.printStackTrace();
+        }
+    }
+
+    
+    private void showActionDialog() {           // 显示ActionDialog
+        AlertDialog.Builder dialog = new AlertDialog.Builder(this);     // 创建一个AlertDialog.Builder实例
+        dialog.setTitle(R.string.app_name);     // 设置AlertDialog的标题
+        dialog.setMessage(mSnippet);            // 设置AlertDialog的消息
+        dialog.setPositiveButton(R.string.notealert_ok, this);  // 设置AlertDialog的确定按钮
+        if (isScreenOn()) {                     // 判断当前屏幕是否处于锁定状态
+            dialog.setNegativeButton(R.string.notealert_enter, this);   // 如果当前屏幕处于锁定状态，则设置AlertDialog的取消按钮
+        }
+        dialog.show().setOnDismissListener(this);   // 显示AlertDialog
+    }
+
+    
+    public void onClick(DialogInterface dialog, int which) {        // 重写onClick方法，用于处理用户点击Dialog中的按钮
+        switch (which) {
+            case DialogInterface.BUTTON_NEGATIVE:
+                Intent intent = new Intent(this, NoteEditActivity.class);       // 创建一个Intent，用于启动NoteEditActivity
+                intent.setAction(Intent.ACTION_VIEW);   // 设置Intent的action
+                intent.putExtra(Intent.EXTRA_UID, mNoteId); // 设置Intent的参数
+                startActivity(intent);      // 启动NoteEditActivity
+                break;
+            default:
+                break;
+        }
+    }
+
+    
+    public void onDismiss(DialogInterface dialog) {     // 重写onDismiss方法，用于处理用户关闭Dialog
+        stopAlarmSound();   // 停止播放闹钟音效
+        finish();       // 结束当前Activity
+    }
+
+    
+    private void stopAlarmSound() {     // 停止播放闹钟音效
+        if (mPlayer != null) {          // 判断mPlayer是否为空
+            mPlayer.stop();             // 如果不为空，则停止播放
+            mPlayer.release();          // 释放mPlayer
+            mPlayer = null;             // 将mPlayer置为空
+        }
+    }
+}

代码标注/AlarmInitReceiver.java

@@ -0,0 +1,65 @@
+/*
+ * 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.ui;
+
+import android.app.AlarmManager;
+import android.app.PendingIntent;
+import android.content.BroadcastReceiver;
+import android.content.ContentUris;
+import android.content.Context;
+import android.content.Intent;
+import android.database.Cursor;
+
+import net.micode.notes.data.Notes;
+import net.micode.notes.data.Notes.NoteColumns;
+
+
+public class AlarmInitReceiver extends BroadcastReceiver {
+
+private static final String [] PROJECTION = new String [] {     // 声明一个私有静态变量PROJECTION，它是一个字符串数组，其中包含NoteColumns.ID和NoteColumns.ALERTED_DATE两个字符串
+        NoteColumns.ID,
+        NoteColumns.ALERTED_DATE
+    };
+
+    private static final int COLUMN_ID                = 0;
+    private static final int COLUMN_ALERTED_DATE      = 1;
+
+    @Override
+    public void onReceive(Context context, Intent intent) {
+        long currentDate = System.currentTimeMillis();      //获取当前时间
+        Cursor c = context.getContentResolver().query(Notes.CONTENT_NOTE_URI,       //查询数据库中alerted_date大于当前时间，type为note的记录
+                PROJECTION,
+                NoteColumns.ALERTED_DATE + ">? AND " + NoteColumns.TYPE + "=" + Notes.TYPE_NOTE,
+                new String[] { String.valueOf(currentDate) },
+                null);
+
+        if (c != null) {
+            if (c.moveToFirst()) {
+                do {
+                    long alertDate = c.getLong(COLUMN_ALERTED_DATE);    //获取alerted_date
+                    Intent sender = new Intent(context, AlarmReceiver.class);    //创建一个Intent，用于传递数据
+                    sender.setData(ContentUris.withAppendedId(Notes.CONTENT_NOTE_URI, c.getLong(COLUMN_ID)));    //将id传递给AlarmReceiver
+                    PendingIntent pendingIntent = PendingIntent.getBroadcast(context, 0, sender, 0);    //创建一个PendingIntent，用于传递Intent
+                    AlarmManager alermManager = (AlarmManager) context    //获取AlarmManager实例
+                            .getSystemService(Context.ALARM_SERVICE);
+                    alermManager.set(AlarmManager.RTC_WAKEUP, alertDate, pendingIntent);    //设置定时器，在alerted_date时间点，发送pendingIntent
+                } while (c.moveToNext());
+            }
+            c.close();
+        }
+    }
+}

代码标注/AlarmReceiver.java

@@ -0,0 +1,31 @@
+/*
+ * 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.ui;
+
+import android.content.BroadcastReceiver;
+import android.content.Context;
+import android.content.Intent;
+
+
+public class AlarmReceiver extends BroadcastReceiver {      // 创建一个AlarmReceiver类，继承自BroadcastReceiver
+    @Override
+    public void onReceive(Context context, Intent intent) {    // 重写onReceive方法，接收Intent类型的参数
+        intent.setClass(context, AlarmAlertActivity.class);    // 设置AlarmAlertActivity的Class
+        intent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK);    // 设置AlarmAlertActivity的Flag
+        context.startActivity(intent);      // 启动AlarmAlertActivity
+    }
+}

代码标注/DateTimePicker.java

@@ -0,0 +1,515 @@
+/*
+ * 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.ui;
+
+import java.text.DateFormatSymbols;
+import java.util.Calendar;
+
+import net.micode.notes.R;
+
+
+import android.content.Context;
+import android.text.format.DateFormat;
+import android.view.View;
+import android.widget.FrameLayout;
+import android.widget.NumberPicker;
+
+public class DateTimePicker extends FrameLayout {
+
+    private static final boolean DEFAULT_ENABLE_STATE = true;
+    //声明变量常量
+    private static final int HOURS_IN_HALF_DAY = 12;
+    private static final int HOURS_IN_ALL_DAY = 24;
+    private static final int DAYS_IN_ALL_WEEK = 7;
+    private static final int DATE_SPINNER_MIN_VAL = 0;
+    private static final int DATE_SPINNER_MAX_VAL = DAYS_IN_ALL_WEEK - 1;
+    private static final int HOUR_SPINNER_MIN_VAL_24_HOUR_VIEW = 0;
+    private static final int HOUR_SPINNER_MAX_VAL_24_HOUR_VIEW = 23;
+    private static final int HOUR_SPINNER_MIN_VAL_12_HOUR_VIEW = 1;
+    private static final int HOUR_SPINNER_MAX_VAL_12_HOUR_VIEW = 12;
+    private static final int MINUT_SPINNER_MIN_VAL = 0;
+    private static final int MINUT_SPINNER_MAX_VAL = 59;
+    private static final int AMPM_SPINNER_MIN_VAL = 0;
+    private static final int AMPM_SPINNER_MAX_VAL = 1;
+
+    private final NumberPicker mDateSpinner;
+    private final NumberPicker mHourSpinner;
+    private final NumberPicker mMinuteSpinner;
+    private final NumberPicker mAmPmSpinner;
+    private Calendar mDate;
+
+    private String[] mDateDisplayValues = new String[DAYS_IN_ALL_WEEK];
+
+    private boolean mIsAm;
+
+    private boolean mIs24HourView;
+
+    private boolean mIsEnabled = DEFAULT_ENABLE_STATE;
+
+    private boolean mInitialising;
+
+    private OnDateTimeChangedListener mOnDateTimeChangedListener;
+
+private NumberPicker.OnValueChangeListener mOnDateChangedListener = new NumberPicker.OnValueChangeListener() {    // 创建一个NumberPicker.OnValueChangeListener的匿名内部类，用于监听NumberPicker的值改变
+        @Override
+        public void onValueChange(NumberPicker picker, int oldVal, int newVal) {
+            mDate.add(Calendar.DAY_OF_YEAR, newVal - oldVal);    // 计算新旧值之间的差值，并将其加到mDate中
+            updateDateControl();    // 更新日期控件
+            onDateTimeChanged();    // 更新时间控件
+        }
+    };
+
+    private NumberPicker.OnValueChangeListener mOnHourChangedListener = new NumberPicker.OnValueChangeListener() {
+        @Override
+        public void onValueChange(NumberPicker picker, int oldVal, int newVal) {
+            boolean isDateChanged = false;
+            Calendar cal = Calendar.getInstance();
+            if (!mIs24HourView) {    // 判断是否是24小时制
+                if (!mIsAm && oldVal == HOURS_IN_HALF_DAY - 1 && newVal == HOURS_IN_HALF_DAY) {
+                if (mIsAm && oldVal == HOURS_IN_HALF_DAY - 1 && newVal == HOURS_IN_HALF_DAY) {    // 如果当前是上午，且当前小时是half day，则设置当前时间为下午
+                    cal.setTimeInMillis(mDate.getTimeInMillis());
+                    cal.add(Calendar.DAY_OF_YEAR, 1);
+                    isDateChanged = true;
+                } else if (mIsAm && oldVal == HOURS_IN_HALF_DAY && newVal == HOURS_IN_HALF_DAY - 1) {    // 如果当前是下午，且当前小时是half day，则设置当前时间为上午
+                    cal.setTimeInMillis(mDate.getTimeInMillis());
+                    cal.add(Calendar.DAY_OF_YEAR, -1);
+                    isDateChanged = true;
+                }
+                
+                if (oldVal == HOURS_IN_HALF_DAY - 1 && newVal == HOURS_IN_HALF_DAY ||    // 如果当前是上午，且当前小时是half day，则设置当前时间为下午
+                        oldVal == HOURS_IN_HALF_DAY && newVal == HOURS_IN_HALF_DAY - 1) {
+                    mIsAm = !mIsAm;
+                    updateAmPmControl();
+                }
+            } else {
+                if (oldVal == HOURS_IN_ALL_DAY - 1 && newVal == 0) {    // 如果当前是24小时制，且当前小时是all day，则设置当前时间为次日
+                    cal.setTimeInMillis(mDate.getTimeInMillis());
+                    cal.add(Calendar.DAY_OF_YEAR, 1);
+                    isDateChanged = true;
+                }
+                else if (oldVal == 0 && newVal == HOURS_IN_ALL_DAY - 1) {    // 如果当前是24小时制，且当前小时是all day，则设置当前时间为次日
+                    cal.setTimeInMillis(mDate.getTimeInMillis());
+                    cal.add(Calendar.DAY_OF_YEAR, -1);
+                    isDateChanged = true;
+                }
+            }
+            int newHour = mHourSpinner.getValue() % HOURS_IN_HALF_DAY + (mIsAm ? 0 : HOURS_IN_HALF_DAY);    // 获取当前小时
+            mDate.set(Calendar.HOUR_OF_DAY, newHour);    // 设置当前时间
+            onDateTimeChanged();
+            if (isDateChanged) {    // 如果日期改变，则更新当前日期
+                setCurrentYear(cal.get(Calendar.YEAR));
+                setCurrentMonth(cal.get(Calendar.MONTH));
+                setCurrentDay(cal.get(Calendar.DAY_OF_MONTH));
+            }
+        }
+    };
+
+    private NumberPicker.OnValueChangeListener mOnMinuteChangedListener = new NumberPicker.OnValueChangeListener() {
+        @Override
+        public void onValueChange(NumberPicker picker, int oldVal, int newVal) {
+            int minValue = mMinuteSpinner.getMinValue();    // 获取分钟数字选择器的最小值
+            int maxValue = mMinuteSpinner.getMaxValue();    // 获取分钟数字选择器的最大值
+            int offset = 0;
+        
+            if (oldVal == maxValue && newVal == minValue) {    // 如果旧的值是最大值，新的值是最小值，则偏移量加1
+                offset += 1;
+            } else if (oldVal == minValue && newVal == maxValue) {      // 如果旧的值是最小值，新的值是最大值，则偏移量减1
+                offset -= 1;
+            }
+        
+            if (offset != 0) {    // 如果偏移量不等于0，则添加偏移量
+                mDate.add(Calendar.HOUR_OF_DAY, offset);    // 添加偏移量
+                mHourSpinner.setValue(getCurrentHour());    // 设置小时数字选择器的值
+                updateDateControl();    // 更新日期控件
+                int newHour = getCurrentHourOfDay();    // 获取当前的小时
+                if (newHour >= HOURS_IN_HALF_DAY) {    // 如果当前的小时大于等于12，则设置AM为false
+                    mIsAm = false;
+                    updateAmPmControl();    // 更新AM/PM控件
+                } else {    // 否则，设置AM为true
+                    mIsAm = true;   
+                    updateAmPmControl();    // 更新AM/PM控件
+                }
+            }
+            mDate.set(Calendar.MINUTE, newVal);    // 设置分钟数字选择器的值
+            onDateTimeChanged();    // 更新日期控件
+        }
+    };
+
+    private NumberPicker.OnValueChangeListener mOnAmPmChangedListener = new NumberPicker.OnValueChangeListener() {
+        @Override
+        public void onValueChange(NumberPicker picker, int oldVal, int newVal) {
+            mIsAm = !mIsAm;    // 判断当前是上午还是下午
+            if (mIsAm) {    // 根据当前是上午还是下午，调整时间
+                mDate.add(Calendar.HOUR_OF_DAY, -HOURS_IN_HALF_DAY);
+            } else {
+                mDate.add(Calendar.HOUR_OF_DAY, HOURS_IN_HALF_DAY);
+            }
+        
+            updateAmPmControl();    // 更新AM/PM控制
+            onDateTimeChanged();    // 更新时间
+        }
+    };
+
+
+public interface OnDateTimeChangedListener {    // 添加中文注释后
+    
+        void onDateTimeChanged(DateTimePicker view, int year, int month,    // 当时间改变时调用
+                int dayOfMonth, int hourOfDay, int minute);
+    }
+
+
+ public DateTimePicker(Context context) {   // 构造函数，传入上下文和当前时间戳
+        this(context, System.currentTimeMillis());
+    }
+
+
+public DateTimePicker(Context context, long date) {    // 创建一个DateTimePicker对象，参数为context和date，dateFormat默认为24小时制
+        this(context, date, DateFormat.is24HourFormat(context));
+    }
+
+
+public DateTimePicker(Context context, long date, boolean is24HourView) {    // 创建DateTimePicker对象，传入上下文、日期和是否24小时视图
+        super(context);
+        mDate = Calendar.getInstance();
+        mInitialising = true;
+        mIsAm = getCurrentHourOfDay() >= HOURS_IN_HALF_DAY;
+        inflate(context, R.layout.datetime_picker, this);
+
+    
+ mDateSpinner = (NumberPicker) findViewById(R.id.date);    //获取日期选择器
+        mDateSpinner.setMinValue(DATE_SPINNER_MIN_VAL);    //设置最小值
+        mDateSpinner.setMaxValue(DATE_SPINNER_MAX_VAL);    //设置最大值
+        mDateSpinner.setOnValueChangedListener(mOnDateChangedListener);    //设置日期改变监听器
+
+        
+       mHourSpinner = (NumberPicker) findViewById(R.id.hour);
+        mHourSpinner.setOnValueChangedListener(mOnHourChangedListener);
+        mMinuteSpinner =  (NumberPicker) findViewById(R.id.minute);
+        mMinuteSpinner.setMinValue(MINUT_SPINNER_MIN_VAL);
+        mMinuteSpinner.setMaxValue(MINUT_SPINNER_MAX_VAL);
+        mMinuteSpinner.setOnLongPressUpdateInterval(100);
+        mMinuteSpinner.setOnValueChangedListener(mOnMinuteChangedListener);
+
+    
+        String[] stringsForAmPm = new DateFormatSymbols().getAmPmStrings();    // 设置AM/PM选择器
+        mAmPmSpinner = (NumberPicker) findViewById(R.id.amPm);
+        mAmPmSpinner.setMinValue(AMPM_SPINNER_MIN_VAL);
+        mAmPmSpinner.setMaxValue(AMPM_SPINNER_MAX_VAL);
+        mAmPmSpinner.setDisplayedValues(stringsForAmPm);
+        mAmPmSpinner.setOnValueChangedListener(mOnAmPmChangedListener);
+
+    
+        updateDateControl();    // 更新日期控制
+        updateHourControl();    // 更新小时控制
+        updateAmPmControl();    // 更新AM/PM控制
+
+        set24HourView(is24HourView);    // 设置24小时视图
+        setCurrentDate(date);    // 设置当前日期
+        setEnabled(isEnabled());    // 设置是否可用
+
+        mInitialising = false;
+    }
+
+    @Override
+    public void setEnabled(boolean enabled) {
+    
+        if (mIsEnabled == enabled) {    // 判断当前状态是否和传入的参数一致
+            return;
+        }
+    
+        super.setEnabled(enabled);    // 调用父类的setEnabled方法
+        mDateSpinner.setEnabled(enabled);    // 设置日期选择器是否可用
+        mMinuteSpinner.setEnabled(enabled);    // 设置分钟选择器是否可用
+        mHourSpinner.setEnabled(enabled);    // 设置小时选择器是否可用
+        mAmPmSpinner.setEnabled(enabled);    // 设置上午/下午选择器是否可用
+        mIsEnabled = enabled;    // 更新状态
+    }
+
+   @Override
+    public boolean isEnabled() {
+        return mIsEnabled;
+    }
+
+    /**
+     * Get the current date in millis
+     *
+     * @return the current date in millis
+     */
+
+public long getCurrentDateInTimeMillis() {    //获取当前日期的时间戳
+        return mDate.getTimeInMillis();
+    }
+    /**
+     * Set the current date
+     *
+     * @param date The current date in millis
+     */
+
+public void setCurrentDate(long date) {    //设置当前日期
+        Calendar cal = Calendar.getInstance();
+        cal.setTimeInMillis(date);
+        setCurrentDate(cal.get(Calendar.YEAR), cal.get(Calendar.MONTH), cal.get(Calendar.DAY_OF_MONTH),
+                cal.get(Calendar.HOUR_OF_DAY), cal.get(Calendar.MINUTE));
+    }
+
+    /**
+     * Set the current date
+     *
+     * @param year The current year
+     * @param month The current month
+     * @param dayOfMonth The current dayOfMonth
+     * @param hourOfDay The current hourOfDay
+     * @param minute The current minute
+     */
+
+public void setCurrentDate(int year, int month,
+            int dayOfMonth, int hourOfDay, int minute) {    //设置当前日期
+        setCurrentYear(year);        //设置当前年份
+        setCurrentMonth(month);        //设置当前月份
+        setCurrentDay(dayOfMonth);        //设置当前日期
+        setCurrentHour(hourOfDay);        //设置当前小时
+        setCurrentMinute(minute);        //设置当前分钟
+    }
+
+    /**
+     * Get current year
+     *
+     * @return The current year
+     */
+
+public int getCurrentYear() {    //获取当前年份
+        return mDate.get(Calendar.YEAR);
+    }
+
+    /**
+     * Set current year
+     *
+     * @param year The current year
+     */
+
+public void setCurrentYear(int year) {    //设置当前年份
+        if (!mInitialising && year == getCurrentYear()) {        //如果初始化完成且当前年份和传入年份相同，则直接返回
+            return;
+        }
+
+        mDate.set(Calendar.YEAR, year);        //设置当前年份
+        updateDateControl();        //更新日期控件
+        onDateTimeChanged();        //日期改变时调用
+    }
+
+    /**
+     * Get current month in the year
+     *
+     * @return The current month in the year
+     */
+
+public int getCurrentMonth() {    //获取当前月份
+        return mDate.get(Calendar.MONTH);
+    }
+
+    /**
+     * Set current month in the year
+     *
+     * @param month The month in the year
+     */
+
+public void setCurrentMonth(int month) {    //设置当前月份
+        if (!mInitialising && month == getCurrentMonth()) {
+            return;
+        }
+        mDate.set(Calendar.MONTH, month);
+        updateDateControl();
+        onDateTimeChanged();
+    }
+
+    /**
+     * Get current day of the month
+     *
+     * @return The day of the month
+     */
+
+public int getCurrentDay() {    //获取当前日期
+        return mDate.get(Calendar.DAY_OF_MONTH);
+    }
+
+    /**
+     * Set current day of the month
+     *
+     * @param dayOfMonth The day of the month
+     */
+
+public void setCurrentDay(int dayOfMonth) {    //设置当前日期
+        if (!mInitialising && dayOfMonth == getCurrentDay()) {
+            return;
+        }
+        mDate.set(Calendar.DAY_OF_MONTH, dayOfMonth);
+        updateDateControl();
+        onDateTimeChanged();
+    }
+
+    /**
+     * Get current hour in 24 hour mode, in the range (0~23)
+     * @return The current hour in 24 hour mode
+     */
+
+public int getCurrentHourOfDay() {    //获取当前小时
+        return mDate.get(Calendar.HOUR_OF_DAY);
+    }
+
+    private int getCurrentHour() {
+        if (mIs24HourView){        // 24小时模式
+            return getCurrentHourOfDay();
+        } else {    // 12小时模式
+            int hour = getCurrentHourOfDay();
+            if (hour > HOURS_IN_HALF_DAY) {    // 当前小时大于12小时，返回当前小时减去12小时
+                return hour - HOURS_IN_HALF_DAY;
+            } else {        // 当前小时小于等于12小时，返回当前小时
+                return hour == 0 ? HOURS_IN_HALF_DAY : hour;
+            }
+        }
+    }
+
+    /**
+     * Set current hour in 24 hour mode, in the range (0~23)
+     *
+     * @param hourOfDay
+     */
+
+public void setCurrentHour(int hourOfDay) {    //设置当前小时
+
+        if (!mInitialising && hourOfDay == getCurrentHourOfDay()) {        //如果初始化完成且当前小时和传入的参数相等，则直接返回
+            return;
+        }
+
+        mDate.set(Calendar.HOUR_OF_DAY, hourOfDay);        //设置当前小时
+        if (!mIs24HourView) {        //如果不是24小时制
+            if (hourOfDay >= HOURS_IN_HALF_DAY) {            //如果传入的参数大于等于12
+                mIsAm = false;        //设置AM为false
+                if (hourOfDay > HOURS_IN_HALF_DAY) {        //如果传入的参数大于12
+                    hourOfDay -= HOURS_IN_HALF_DAY;        //减去12
+                }
+            } else {
+                mIsAm = true;    //设置AM为true
+                if (hourOfDay == 0) {    //如果传入的参数等于0
+                    hourOfDay = HOURS_IN_HALF_DAY;    //设置为12
+                }
+            }
+            updateAmPmControl();    //更新AM/PM控制
+        }
+        mHourSpinner.setValue(hourOfDay);    //设置小时值
+        onDateTimeChanged();    //日期改变时调用
+    }
+
+    /**
+     * Get currentMinute
+     *
+     * @return The Current Minute
+     */
+
+public int getCurrentMinute() {    //获取当前分钟
+        return mDate.get(Calendar.MINUTE);
+    }
+
+    /**
+     * Set current minute
+     */
+
+public void setCurrentMinute(int minute) {    //设置当前分钟
+        if (!mInitialising && minute == getCurrentMinute()) {        //如果初始化未完成，且分钟数相同，则返回
+            return;
+        }
+        mMinuteSpinner.setValue(minute);        //设置分钟数
+        mDate.set(Calendar.MINUTE, minute);        //设置日期
+        onDateTimeChanged();        //更新时间
+    }
+
+    /**
+     * @return true if this is in 24 hour view else false.
+     */
+
+public boolean is24HourView () {    //获取是否是24小时视图
+        return mIs24HourView;
+    }
+
+    /**
+     * Set whether in 24 hour or AM/PM mode.
+     *
+     * @param is24HourView True for 24 hour mode. False for AM/PM mode.
+     */
+
+public void set24HourView(boolean is24HourView) {    //设置24小时视图
+        if (mIs24HourView == is24HourView) {
+            return;
+        }
+        mIs24HourView = is24HourView;
+
+        mAmPmSpinner.setVisibility(is24HourView ? View.GONE : View.VISIBLE);        //设置时间控制条的可见性
+        int hour = getCurrentHourOfDay();        //获取当前的小时
+        updateHourControl();        //更新小时控制条
+        setCurrentHour(hour);        //设置当前的小时
+        updateAmPmControl();        //更新上午/下午控制条
+    }
+
+    private void updateDateControl() {
+        Calendar cal = Calendar.getInstance();        // 获取当前时间
+        cal.setTimeInMillis(mDate.getTimeInMillis());
+        cal.add(Calendar.DAY_OF_YEAR, -DAYS_IN_ALL_WEEK / 2 - 1);        // 设置当前时间所在的星期
+        mDateSpinner.setDisplayedValues(null);        // 设置显示的值
+        for (int i = 0; i < DAYS_IN_ALL_WEEK; ++i) {        // 遍历所有的星期
+            cal.add(Calendar.DAY_OF_YEAR, 1);
+            mDateDisplayValues[i] = (String) DateFormat.format("MM.dd EEEE", cal);
+        }
+        mDateSpinner.setDisplayedValues(mDateDisplayValues);        // 设置显示的值
+        mDateSpinner.setValue(DAYS_IN_ALL_WEEK / 2);        // 设置当前时间所在的星期
+        mDateSpinner.invalidate();
+    }
+
+    private void updateAmPmControl() {
+        if (mIs24HourView) {        // 如果24小时视图是可见的，则隐藏AM/PM控制
+            mAmPmSpinner.setVisibility(View.GONE);
+        } else {
+            int index = mIsAm ? Calendar.AM : Calendar.PM;     // 否则，如果当前是AM，则设置索引为Calendar.AM，否则设置为Calendar.PM
+            mAmPmSpinner.setValue(index);
+            mAmPmSpinner.setVisibility(View.VISIBLE);
+        }
+    }
+    private void updateHourControl() {
+        if (mIs24HourView) {    // 根据mIs24HourView的值来更新mHourSpinner的值
+            mHourSpinner.setMinValue(HOUR_SPINNER_MIN_VAL_24_HOUR_VIEW);
+            mHourSpinner.setMaxValue(HOUR_SPINNER_MAX_VAL_24_HOUR_VIEW);
+        } else {
+            mHourSpinner.setMinValue(HOUR_SPINNER_MIN_VAL_12_HOUR_VIEW);
+            mHourSpinner.setMaxValue(HOUR_SPINNER_MAX_VAL_12_HOUR_VIEW);
+        }
+    }
+
+    /**
+     * Set the callback that indicates the 'Set' button has been pressed.
+     * @param callback the callback, if null will do nothing
+     */
+
+public void setOnDateTimeChangedListener(OnDateTimeChangedListener callback) {    //设置日期时间改变监听器
+        mOnDateTimeChangedListener = callback;
+    }
+
+    private void onDateTimeChanged() {
+        if (mOnDateTimeChangedListener != null) {        // 当日期时间改变时调用
+            mOnDateTimeChangedListener.onDateTimeChanged(this, getCurrentYear(),
+                    getCurrentMonth(), getCurrentDay(), getCurrentHourOfDay(), getCurrentMinute());
+        }
+    }
+}

代码标注/DateTimePickerDialog.java

@@ -0,0 +1,101 @@
+/*
+ * 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.ui;
+
+import java.util.Calendar;
+
+import net.micode.notes.R;
+import net.micode.notes.ui.DateTimePicker;
+import net.micode.notes.ui.DateTimePicker.OnDateTimeChangedListener;
+
+import android.app.AlertDialog;
+import android.content.Context;
+import android.content.DialogInterface;
+import android.content.DialogInterface.OnClickListener;
+import android.text.format.DateFormat;
+import android.text.format.DateUtils;
+
+
+public class DateTimePickerDialog extends AlertDialog implements OnClickListener {
+
+    // 创建一个Calendar实例
+    private Calendar mDate = Calendar.getInstance();
+    // 是否是24小时制
+    private boolean mIs24HourView;
+    // 设置时间监听器
+    private OnDateTimeSetListener mOnDateTimeSetListener;
+    // 创建一个DateTimePicker实例
+    private DateTimePicker mDateTimePicker;
+
+    // 定义一个接口，用于设置时间
+    public interface OnDateTimeSetListener {
+        void OnDateTimeSet(AlertDialog dialog, long date);
+    }
+
+    // 构造函数，传入上下文和时间
+    public DateTimePickerDialog(Context context, long date) {
+        super(context);
+        mDateTimePicker = new DateTimePicker(context);
+        setView(mDateTimePicker);
+        mDateTimePicker.setOnDateTimeChangedListener(new OnDateTimeChangedListener() {
+            public void onDateTimeChanged(DateTimePicker view, int year, int month,
+                    int dayOfMonth, int hourOfDay, int minute) {
+                mDate.set(Calendar.YEAR, year);
+                mDate.set(Calendar.MONTH, month);
+                mDate.set(Calendar.DAY_OF_MONTH, dayOfMonth);
+                mDate.set(Calendar.HOUR_OF_DAY, hourOfDay);
+                mDate.set(Calendar.MINUTE, minute);
+                updateTitle(mDate.getTimeInMillis());
+            }
+        });
+        mDate.setTimeInMillis(date);
+        mDate.set(Calendar.SECOND, 0);
+        mDateTimePicker.setCurrentDate(mDate.getTimeInMillis());
+        setButton(context.getString(R.string.datetime_dialog_ok), this);
+        setButton2(context.getString(R.string.datetime_dialog_cancel), (OnClickListener)null);
+        set24HourView(DateFormat.is24HourFormat(this.getContext()));
+        updateTitle(mDate.getTimeInMillis());
+    }
+
+    // 设置是否是24小时制
+    public void set24HourView(boolean is24HourView) {
+        mIs24HourView = is24HourView;
+    }
+
+    // 设置时间监听器
+    public void setOnDateTimeSetListener(OnDateTimeSetListener callBack) {
+        mOnDateTimeSetListener = callBack;
+    }
+
+    // 更新标题
+    private void updateTitle(long date) {
+        int flag =
+            DateUtils.FORMAT_SHOW_YEAR |
+            DateUtils.FORMAT_SHOW_DATE |
+            DateUtils.FORMAT_SHOW_TIME;
+        flag |= mIs24HourView ? DateUtils.FORMAT_24HOUR : DateUtils.FORMAT_24HOUR;
+        setTitle(DateUtils.formatDateTime(this.getContext(), date, flag));
+    }
+
+    // 点击事件
+    public void onClick(DialogInterface arg0, int arg1) {
+        if (mOnDateTimeSetListener != null) {
+            mOnDateTimeSetListener.OnDateTimeSet(this, mDate.getTimeInMillis());
+        }
+    }
+
+}

代码标注/DropdownMenu.java

@@ -0,0 +1,79 @@
+/*
+ * 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.ui;
+
+import android.content.Context;
+import android.view.Menu;
+import android.view.MenuItem;
+import android.view.View;
+import android.view.View.OnClickListener;
+import android.widget.Button;
+import android.widget.PopupMenu;
+import android.widget.PopupMenu.OnMenuItemClickListener;
+
+import net.micode.notes.R;
+
+public class DropdownMenu {
+    // 声明一个Button变量
+    private Button mButton;
+    // 声明一个PopupMenu变量
+    private PopupMenu mPopupMenu;
+    // 声明一个Menu变量
+    private Menu mMenu;
+
+    // 构造函数，传入上下文、Button和菜单ID
+    public DropdownMenu(Context context, Button button, int menuId) {
+        // 将传入的Button赋值给mButton
+        mButton = button;
+        // 为mButton设置背景资源
+        mButton.setBackgroundResource(R.drawable.dropdown_icon);
+        // 创建一个PopupMenu，传入上下文和mButton
+        mPopupMenu = new PopupMenu(context, mButton);
+        // 获取mPopupMenu的Menu
+        mMenu = mPopupMenu.getMenu();
+        // 为mMenu设置菜单ID
+        mPopupMenu.getMenuInflater().inflate(menuId, mMenu);
+        // 为mButton设置点击事件
+        mButton.setOnClickListener(new OnClickListener() {
+            public void onClick(View v) {
+                // 显示mPopupMenu
+                mPopupMenu.show();
+            }
+        });
+    }
+
+    // 设置点击事件
+    public void setOnDropdownMenuItemClickListener(OnMenuItemClickListener listener) {
+        // 如果mPopupMenu不为空
+        if (mPopupMenu != null) {
+            // 为mPopupMenu设置点击事件
+            mPopupMenu.setOnMenuItemClickListener(listener);
+        }
+    }
+
+    // 查找菜单项
+    public MenuItem findItem(int id) {
+        // 返回mMenu中id对应的菜单项
+        return mMenu.findItem(id);
+    }
+
+    // 设置标题
+    public void setTitle(CharSequence title) {
+        // 设置mButton的文本
+        mButton.setText(title);
+    }
+}

代码标注/FoldersListAdapter.java

@@ -0,0 +1,92 @@
+/*
+ * 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.ui;
+
+import android.content.Context;
+import android.database.Cursor;
+import android.view.View;
+import android.view.ViewGroup;
+import android.widget.CursorAdapter;
+import android.widget.LinearLayout;
+import android.widget.TextView;
+
+import net.micode.notes.R;
+import net.micode.notes.data.Notes;
+import net.micode.notes.data.Notes.NoteColumns;
+
+
+public class FoldersListAdapter extends CursorAdapter {
+    // 定义查询列
+    public static final String [] PROJECTION = {
+        NoteColumns.ID,
+        NoteColumns.SNIPPET
+    };
+
+    // 定义查询列的索引
+    public static final int ID_COLUMN   = 0;
+    public static final int NAME_COLUMN = 1;
+
+    public FoldersListAdapter(Context context, Cursor c) {
+        super(context, c);
+        // TODO Auto-generated constructor stub
+    }
+
+    @Override
+    public View newView(Context context, Cursor cursor, ViewGroup parent) {
+        // 创建一个新的View
+        return new FolderListItem(context);
+    }
+
+    @Override
+    public void bindView(View view, Context context, Cursor cursor) {
+        // 绑定View
+        if (view instanceof FolderListItem) {
+            // 获取文件夹名
+            String folderName = (cursor.getLong(ID_COLUMN) == Notes.ID_ROOT_FOLDER) ? context
+                    .getString(R.string.menu_move_parent_folder) : cursor.getString(NAME_COLUMN);
+            // 绑定文件夹名
+            ((FolderListItem) view).bind(folderName);
+        }
+    }
+
+    public String getFolderName(Context context, int position) {
+        // 获取指定位置的Cursor
+        Cursor cursor = (Cursor) getItem(position);
+        // 返回文件夹名
+        return (cursor.getLong(ID_COLUMN) == Notes.ID_ROOT_FOLDER) ? context
+                .getString(R.string.menu_move_parent_folder) : cursor.getString(NAME_COLUMN);
+    }
+
+    private class FolderListItem extends LinearLayout {
+        // 定义文本框
+        private TextView mName;
+
+        public FolderListItem(Context context) {
+            super(context);
+            // 加载布局
+            inflate(context, R.layout.folder_list_item, this);
+            // 获取文本框
+            mName = (TextView) findViewById(R.id.tv_folder_name);
+        }
+
+        public void bind(String name) {
+            // 绑定文本框
+            mName.setText(name);
+        }
+    }
+
+}

标注/Contact.java

@@ -0,0 +1,69 @@
+
+
+package net.micode.notes.data;
+
+import android.content.Context;
+import android.database.Cursor;
+import android.provider.ContactsContract.CommonDataKinds.Phone;
+import android.provider.ContactsContract.Data;
+import android.telephony.PhoneNumberUtils;
+import android.util.Log;
+
+import java.util.HashMap;
+// 定义一个Contact类
+public class Contact {
+    // 声明一个HashMap类型的静态变量sContactCache
+    private static HashMap<String, String> sContactCache;
+    // 声明一个String类型的静态变量TAG
+    private static final String TAG = "Contact";
+
+    // 声明一个String类型的静态变量CALLER_ID_SELECTION
+    private static final String CALLER_ID_SELECTION = "PHONE_NUMBERS_EQUAL(" + Phone.NUMBER
+    + ",?) AND " + Data.MIMETYPE + "='" + Phone.CONTENT_ITEM_TYPE + "'"
+    + " AND " + Data.RAW_CONTACT_ID + " IN "
+            + "(SELECT raw_contact_id "
+            + " FROM phone_lookup"
+            + " WHERE min_match = '+')";
+
+    // 定义一个静态方法getContact，参数为context和phoneNumber
+    public static String getContact(Context context, String phoneNumber) {
+        // 如果sContactCache为空，则初始化sContactCache
+        if(sContactCache == null) {
+            sContactCache = new HashMap<String, String>();
+        }
+
+        // 检查缓存中是否有该号码的联系人
+        if(sContactCache.containsKey(phoneNumber)) {
+            return sContactCache.get(phoneNumber);
+        }
+
+        // 查询数据库中是否有该号码的联系人
+        String selection = CALLER_ID_SELECTION.replace("+",
+                PhoneNumberUtils.toCallerIDMinMatch(phoneNumber));
+        // 根据电话号码查询联系人
+        Cursor cursor = context.getContentResolver().query(
+                Data.CONTENT_URI,
+                new String [] { Phone.DISPLAY_NAME },
+                selection,
+                new String[] { phoneNumber },
+                null);
+
+       if (cursor != null && cursor.moveToFirst()) {
+            try {
+                // 获取联系人名字
+                String name = cursor.getString(0);
+                // 将联系人名字存入缓存
+                sContactCache.put(phoneNumber, name);
+                return name;
+            } catch (IndexOutOfBoundsException e) {
+                Log.e(TAG, " Cursor get string error " + e.toString());
+                return null;
+            } finally {
+                cursor.close();
+            }
+        } else {
+            Log.d(TAG, "No contact matched with number:" + phoneNumber);
+            return null;
+        }
+    }
+}

标注/GTaskASyncTask.java

@@ -0,0 +1,102 @@
+package net.micode.notes.gtask.remote;
+ 
+/*异步操作类，实现GTask的异步操作过程
+ * 主要方法：
+ * private void showNotification(int tickerId, String content) 向用户提示当前同步的状态，是一个用于交互的方法
+ * protected Integer doInBackground(Void... unused) 此方法在后台线程执行，完成任务的主要工作，通常需要较长的时间
+ * protected void onProgressUpdate(String... progress)  可以使用进度条增加用户体验度。 此方法在主线程执行，用于显示任务执行的进度。
+ * protected void onPostExecute(Integer result)  相当于Handler 处理UI的方式，在这里面可以使用在doInBackground 得到的结果处理操作UI
+ */
+public class GTaskASyncTask extends AsyncTask<Void, String, Integer> {
+ 
+ 
+    private static int GTASK_SYNC_NOTIFICATION_ID = 5234235;
+ 
+    public interface OnCompleteListener {
+        void onComplete();
+    }
+ 
+    private Context mContext;
+ 
+    private NotificationManager mNotifiManager;
+ 
+    private GTaskManager mTaskManager;
+ 
+    private OnCompleteListener mOnCompleteListener;
+ 
+    public GTaskASyncTask(Context context, OnCompleteListener listener) {
+        mContext = context;
+        mOnCompleteListener = listener;
+        mNotifiManager = (NotificationManager) mContext
+                .getSystemService(Context.NOTIFICATION_SERVICE);
+        mTaskManager = GTaskManager.getInstance();
+    }
+ 
+    public void cancelSync() {
+        mTaskManager.cancelSync();
+    }
+ 
+    public void publishProgess(String message) { // 发布进度单位，系统将会调用onProgressUpdate()方法更新这些值
+        publishProgress(new String[] {
+            message
+        });
+    }
+ 
+    private void showNotification(int tickerId, String content) {
+        Notification notification = new Notification(R.drawable.notification, mContext
+                .getString(tickerId), System.currentTimeMillis());
+        notification.defaults = Notification.DEFAULT_LIGHTS; // 调用系统自带灯光
+        notification.flags = Notification.FLAG_AUTO_CANCEL;  // 点击清除按钮或点击通知后会自动消失
+        PendingIntent pendingIntent;  //一个描述了想要启动一个Activity、Broadcast或是Service的意图
+        if (tickerId != R.string.ticker_success) {
+            pendingIntent = PendingIntent.getActivity(mContext, 0, new Intent(mContext,
+                    NotesPreferenceActivity.class), 0);  //如果同步不成功，那么从系统取得一个用于启动一个NotesPreferenceActivity的PendingIntent对象
+ 
+        } else {
+            pendingIntent = PendingIntent.getActivity(mContext, 0, new Intent(mContext,
+                    NotesListActivity.class), 0); //如果同步成功，那么从系统取得一个用于启动一个NotesListActivity的PendingIntent对象
+        }
+        notification.setLatestEventInfo(mContext, mContext.getString(R.string.app_name), content,
+                pendingIntent);
+        mNotifiManager.notify(GTASK_SYNC_NOTIFICATION_ID, notification);//通过NotificationManager对象的notify（）方法来执行一个notification的消息
+    }
+ 
+    @Override
+    protected Integer doInBackground(Void... unused) {
+        publishProgess(mContext.getString(R.string.sync_progress_login, NotesPreferenceActivity
+                .getSyncAccountName(mContext)));  //利用getString,将把 NotesPreferenceActivity.getSyncAccountName(mContext))的字符串内容传进sync_progress_login中
+        return mTaskManager.sync(mContext, this);    //进行后台同步具体操作
+    }
+ 
+    @Override
+    protected void onProgressUpdate(String... progress) {
+        showNotification(R.string.ticker_syncing, progress[0]);
+        if (mContext instanceof GTaskSyncService) {  //instanceof 判断mContext是否是GTaskSyncService的实例
+            ((GTaskSyncService) mContext).sendBroadcast(progress[0]);
+        }
+    }
+ 
+    @Override
+    protected void onPostExecute(Integer result) {  //用于在执行完后台任务后更新UI,显示结果 
+        if (result == GTaskManager.STATE_SUCCESS) {
+            showNotification(R.string.ticker_success, mContext.getString(
+                    R.string.success_sync_account, mTaskManager.getSyncAccount()));
+            NotesPreferenceActivity.setLastSyncTime(mContext, System.currentTimeMillis());  //设置最新同步的时间
+        } else if (result == GTaskManager.STATE_NETWORK_ERROR) {
+            showNotification(R.string.ticker_fail, mContext.getString(R.string.error_sync_network));
+        } else if (result == GTaskManager.STATE_INTERNAL_ERROR) {
+            showNotification(R.string.ticker_fail, mContext.getString(R.string.error_sync_internal));
+        } else if (result == GTaskManager.STATE_SYNC_CANCELLED) {
+            showNotification(R.string.ticker_cancel, mContext
+                    .getString(R.string.error_sync_cancelled));
+        } //几种不同情况下的结果显示
+        if (mOnCompleteListener != null) {
+            new Thread(new Runnable() {  //这里好像是方法内的一个线程，但是并不太懂什么意思
+ 
+                public void run() {   //完成后的操作，使用onComplete()将所有值都重新初始化，相当于完成一次操作
+                    mOnCompleteListener.onComplete();    
+                }
+            }).start();
+        }
+    }
+}

标注/MetaData.java

@@ -0,0 +1,104 @@
+package net.micode.notes.gtask.data;
+ 
+public class MetaData extends Task {
+	/*
+	 * 功能描述：得到类的简写名称存入字符串TAG中
+	 * 实现过程：调用getSimpleName ()函数
+	 */
+    private final static String TAG = MetaData.class.getSimpleName();
+    private String mRelatedGid = null;
+    /*
+     * 功能描述：设置数据，即生成元数据库
+     * 实现过程：调用JSONObject库函数put ()，Task类中的setNotes ()和setName ()函数
+     * 参数注解：
+     */
+    public void setMeta(String gid, JSONObject metaInfo) 
+    {
+    	//对函数块进行注释
+        try {
+            metaInfo.put(GTaskStringUtils.META_HEAD_GTASK_ID, gid);
+            /*
+             * 将这对键值放入metaInfo这个jsonobject对象中
+             */
+        } catch (JSONException e) {
+            Log.e(TAG, "failed to put related gid");
+            /*
+             * 输出错误信息
+             */
+        }
+        setNotes(metaInfo.toString());
+        setName(GTaskStringUtils.META_NOTE_NAME);
+    }
+    /*
+     * 功能描述：获取相关联的Gid
+     */
+    public String getRelatedGid() {
+        return mRelatedGid;
+    }
+    /*
+     * 功能描述：判断当前数据是否为空，若为空则返回真即值得保存
+     * Made By CuiCan
+     */
+    @Override
+    public boolean isWorthSaving() {
+        return getNotes() != null;
+    }
+    /*
+     * 功能描述：使用远程json数据对象设置元数据内容
+     * 实现过程：调用父类Task中的setContentByRemoteJSON ()函数，并
+     * 参数注解： 
+     */
+    @Override
+    public void setContentByRemoteJSON(JSONObject js) {
+        super.setContentByRemoteJSON(js);
+        if (getNotes() != null) {
+            try {
+                JSONObject metaInfo = new JSONObject(getNotes().trim());
+                mRelatedGid = metaInfo.getString(GTaskStringUtils.META_HEAD_GTASK_ID);
+            } catch (JSONException e) {
+                Log.w(TAG, "failed to get related gid");
+                /*
+                 * 输出警告信息
+                 */
+                mRelatedGid = null;
+            }
+        }
+    }
+    /*
+     * 功能描述：使用本地json数据对象设置元数据内容，一般不会用到，若用到，则抛出异常
+     * Made By CuiCan
+     */
+    @Override
+    public void setContentByLocalJSON(JSONObject js) {
+        // this function should not be called
+        throw new IllegalAccessError("MetaData:setContentByLocalJSON should not be called");
+        /*
+         * 传递非法参数异常
+         */
+    }
+    /*
+     * 功能描述：从元数据内容中获取本地json对象，一般不会用到，若用到，则抛出异常
+     * Made By CuiCan
+     */
+    @Override
+    public JSONObject getLocalJSONFromContent() {
+        throw new IllegalAccessError("MetaData:getLocalJSONFromContent should not be called");
+        /*
+         * 传递非法参数异常
+         * Made By Cui Can
+         */
+    }
+    /*
+     * 功能描述：获取同步动作状态，一般不会用到，若用到，则抛出异常
+     * Made By CuiCan
+     */
+    @Override
+    public int getSyncAction(Cursor c) {
+        throw new IllegalAccessError("MetaData:getSyncAction should not be called");
+        /*
+         * 传递非法参数异常
+         * Made By Cui Can
+         */
+    }
+ 
+}

标注/Node.java

@@ -0,0 +1,90 @@
+package net.micode.notes.gtask.data;
+ 
+import android.database.Cursor;
+ 
+import org.json.JSONObject;
+ 
+/**
+ * 应该是同步操作的基础数据类型，定义了相关指示同步操作的常量
+ * 关键字：abstract
+ */
+public abstract class Node {
+	//定义了各种用于表征同步状态的常量
+    public static final int SYNC_ACTION_NONE = 0;// 本地和云端都无可更新内容（即本地和云端内容一致）
+    
+    public static final int SYNC_ACTION_ADD_REMOTE = 1;// 需要在远程云端增加内容
+ 
+    public static final int SYNC_ACTION_ADD_LOCAL = 2;// 需要在本地增加内容
+ 
+    public static final int SYNC_ACTION_DEL_REMOTE = 3;// 需要在远程云端删除内容
+ 
+    public static final int SYNC_ACTION_DEL_LOCAL = 4;// 需要在本地删除内容
+ 
+    public static final int SYNC_ACTION_UPDATE_REMOTE = 5;// 需要将本地内容更新到远程云端
+ 
+    public static final int SYNC_ACTION_UPDATE_LOCAL = 6;// 需要将远程云端内容更新到本地
+ 
+    public static final int SYNC_ACTION_UPDATE_CONFLICT = 7;// 同步出现冲突
+ 
+    public static final int SYNC_ACTION_ERROR = 8;// 同步出现错误
+ 
+    private String mGid;
+ 
+    private String mName;
+ 
+    private long mLastModified;//记录最后一次修改时间
+ 
+    private boolean mDeleted;//表征是否被删除
+ 
+    public Node() {
+        mGid = null;
+        mName = "";
+        mLastModified = 0;
+        mDeleted = false;
+    }
+ 
+    public abstract JSONObject getCreateAction(int actionId);
+ 
+    public abstract JSONObject getUpdateAction(int actionId);
+ 
+    public abstract void setContentByRemoteJSON(JSONObject js);
+ 
+    public abstract void setContentByLocalJSON(JSONObject js);
+ 
+    public abstract JSONObject getLocalJSONFromContent();
+ 
+    public abstract int getSyncAction(Cursor c);
+ 
+    public void setGid(String gid) {
+        this.mGid = gid;
+    }
+ 
+    public void setName(String name) {
+        this.mName = name;
+    }
+ 
+    public void setLastModified(long lastModified) {
+        this.mLastModified = lastModified;
+    }
+ 
+    public void setDeleted(boolean deleted) {
+        this.mDeleted = deleted;
+    }
+ 
+    public String getGid() {
+        return this.mGid;
+    }
+ 
+    public String getName() {
+        return this.mName;
+    }
+ 
+    public long getLastModified() {
+        return this.mLastModified;
+    }
+ 
+    public boolean getDeleted() {
+        return this.mDeleted;
+    }
+ 
+}

标注/Notes.java

@@ -0,0 +1,197 @@
+
+
+package net.micode.notes.data;
+
+import android.net.Uri;
+public class Notes {
+    // 定义数据库的权限
+    public static final String AUTHORITY = "micode_notes";
+    // 定义日志标签
+    public static final String TAG = "Notes";
+    // 定义笔记类型
+    public static final int TYPE_NOTE     = 0;
+    // 定义文件夹类型
+    public static final int TYPE_FOLDER   = 1;
+    // 定义系统类型
+    public static final int TYPE_SYSTEM   = 2;
+
+    
+    // 定义根文件夹id
+    public static final int ID_ROOT_FOLDER = 0;
+    // 定义临时文件夹id
+    public static final int ID_TEMPARAY_FOLDER = -1;
+    // 定义通话记录文件夹id
+    public static final int ID_CALL_RECORD_FOLDER = -2;
+    // 定义垃圾文件夹id
+    public static final int ID_TRASH_FOLER = -3;
+
+    // 定义意图的额外参数
+    public static final String INTENT_EXTRA_ALERT_DATE = "net.micode.notes.alert_date";
+    public static final String INTENT_EXTRA_BACKGROUND_ID = "net.micode.notes.background_color_id";
+    public static final String INTENT_EXTRA_WIDGET_ID = "net.micode.notes.widget_id";
+    public static final String INTENT_EXTRA_WIDGET_TYPE = "net.micode.notes.widget_type";
+    public static final String INTENT_EXTRA_FOLDER_ID = "net.micode.notes.folder_id";
+    public static final String INTENT_EXTRA_CALL_DATE = "net.micode.notes.call_date";
+
+    // 定义小部件类型
+    public static final int TYPE_WIDGET_INVALIDE      = -1;
+    public static final int TYPE_WIDGET_2X            = 0;
+    public static final int TYPE_WIDGET_4X            = 1;
+
+    // 定义数据常量
+    public static class DataConstants {
+        // 定义笔记类型
+        public static final String NOTE = TextNote.CONTENT_ITEM_TYPE;
+        // 定义通话记录类型
+        public static final String CALL_NOTE = CallNote.CONTENT_ITEM_TYPE;
+    }
+
+   
+    public static final Uri CONTENT_NOTE_URI = Uri.parse("content://" + AUTHORITY + "/note");
+
+    
+    public static final Uri CONTENT_DATA_URI = Uri.parse("content://" + AUTHORITY + "/data");
+
+    public interface NoteColumns {
+        
+        public static final String ID = "_id";
+
+        // 父ID
+       
+        public static final String PARENT_ID = "parent_id";
+
+        
+        public static final String CREATED_DATE = "created_date";
+
+        // 修改日期
+       
+        public static final String MODIFIED_DATE = "modified_date";
+
+
+        // 
+
+       
+        public static final String ALERTED_DATE = "alert_date";
+
+        // 摘要
+        
+       public static final String SNIPPET = "snippet";
+
+        // 
+        
+        public static final String WIDGET_ID = "widget_id";
+
+        
+        
+        public static final String WIDGET_TYPE = "widget_type";
+
+        
+        public static final String BG_COLOR_ID = "bg_color_id";
+
+       
+        public static final String HAS_ATTACHMENT = "has_attachment";
+
+        
+        public static final String NOTES_COUNT = "notes_count";
+
+       
+        public static final String TYPE = "type";
+
+        
+        public static final String SYNC_ID = "sync_id";
+
+       
+        public static final String LOCAL_MODIFIED = "local_modified";
+        
+        public static final String ORIGIN_PARENT_ID = "origin_parent_id";
+
+       
+        public static final String GTASK_ID = "gtask_id";
+
+        
+        public static final String VERSION = "version";
+    }
+
+    public interface DataColumns {
+       
+        // 定义_id字段
+        public static final String ID = "_id";
+
+       
+        // 定义mime_type字段
+        public static final String MIME_TYPE = "mime_type";
+
+       
+        // 定义note_id字段
+        public static final String NOTE_ID = "note_id";
+
+        
+        // 定义created_date字段
+        public static final String CREATED_DATE = "created_date";
+
+       
+        // 定义modified_date字段
+        public static final String MODIFIED_DATE = "modified_date";
+
+      
+        // 定义content字段
+        public static final String CONTENT = "content";
+
+
+      
+        // 定义data1字段
+        public static final String DATA1 = "data1";
+
+        
+        // 定义data2字段
+        public static final String DATA2 = "data2";
+
+        
+        // 定义data3字段
+        public static final String DATA3 = "data3";
+
+        
+        // 定义data4字段
+        public static final String DATA4 = "data4";
+
+        
+        // 定义data5字段
+        public static final String DATA5 = "data5";
+    }
+
+   public static final class TextNote implements DataColumns {
+        
+        // 数据类型
+        public static final String MODE = DATA1;
+
+        // 检查列表模式
+        public static final int MODE_CHECK_LIST = 1;
+
+        // 内容类型
+        public static final String CONTENT_TYPE = "vnd.android.cursor.dir/text_note";
+
+        // 内容项类型
+        public static final String CONTENT_ITEM_TYPE = "vnd.android.cursor.item/text_note";
+
+        // 内容URI
+        public static final Uri CONTENT_URI = Uri.parse("content://" + AUTHORITY + "/text_note");
+    }
+
+   public static final class CallNote implements DataColumns {
+       
+        // 电话日期
+        public static final String CALL_DATE = DATA1;
+
+        // 电话号码
+        public static final String PHONE_NUMBER = DATA3;
+
+        // 内容类型
+        public static final String CONTENT_TYPE = "vnd.android.cursor.dir/call_note";
+
+        // 内容项类型
+        public static final String CONTENT_ITEM_TYPE = "vnd.android.cursor.item/call_note";
+
+        // 内容URI
+        public static final Uri CONTENT_URI = Uri.parse("content://" + AUTHORITY + "/call_note");
+    }
+}

标注/NotesDatabaseHelper.java

@@ -0,0 +1,362 @@
+
+package net.micode.notes.data;
+
+import android.content.ContentValues;
+import android.content.Context;
+import android.database.sqlite.SQLiteDatabase;
+import android.database.sqlite.SQLiteOpenHelper;
+import android.util.Log;
+
+import net.micode.notes.data.Notes.DataColumns;
+import net.micode.notes.data.Notes.DataConstants;
+import net.micode.notes.data.Notes.NoteColumns;
+
+
+public class NotesDatabaseHelper extends SQLiteOpenHelper {
+    // 数据库名称
+    private static final String DB_NAME = "note.db";
+
+    // 数据库版本
+    private static final int DB_VERSION = 4;
+
+    // 表名
+    public interface TABLE {
+        public static final String NOTE = "note";
+
+        public static final String DATA = "data";
+    }
+
+    // 标签
+    private static final String TAG = "NotesDatabaseHelper";
+
+    // 实例
+    private static NotesDatabaseHelper mInstance;
+
+    // 创建表
+    private static final String CREATE_NOTE_TABLE_SQL =
+        "CREATE TABLE " + TABLE.NOTE + "(" +
+            NoteColumns.ID + " INTEGER PRIMARY KEY," +
+            NoteColumns.PARENT_ID + " INTEGER NOT NULL DEFAULT 0," +
+            NoteColumns.ALERTED_DATE + " INTEGER NOT NULL DEFAULT 0," +
+            NoteColumns.BG_COLOR_ID + " INTEGER NOT NULL DEFAULT 0," +
+            NoteColumns.CREATED_DATE + " INTEGER NOT NULL DEFAULT (strftime('%s','now') * 1000)," +
+            NoteColumns.HAS_ATTACHMENT + " INTEGER NOT NULL DEFAULT 0," +
+            NoteColumns.MODIFIED_DATE + " INTEGER NOT NULL DEFAULT (strftime('%s','now') * 1000)," +
+            NoteColumns.NOTES_COUNT + " INTEGER NOT NULL DEFAULT 0," +
+            NoteColumns.SNIPPET + " TEXT NOT NULL DEFAULT ''," +
+            NoteColumns.TYPE + " INTEGER NOT NULL DEFAULT 0," +
+            NoteColumns.WIDGET_ID + " INTEGER NOT NULL DEFAULT 0," +
+            NoteColumns.WIDGET_TYPE + " INTEGER NOT NULL DEFAULT -1," +
+            NoteColumns.SYNC_ID + " INTEGER NOT NULL DEFAULT 0," +
+            NoteColumns.LOCAL_MODIFIED + " INTEGER NOT NULL DEFAULT 0," +
+            NoteColumns.ORIGIN_PARENT_ID + " INTEGER NOT NULL DEFAULT 0," +
+            NoteColumns.GTASK_ID + " TEXT NOT NULL DEFAULT ''," +
+            NoteColumns.VERSION + " INTEGER NOT NULL DEFAULT 0" +
+        ")";
+   private static final String CREATE_DATA_TABLE_SQL =
+        "CREATE TABLE " + TABLE.DATA + "(" +
+            // 数据表的主键
+            DataColumns.ID + " INTEGER PRIMARY KEY," +
+            // 数据表的类型
+            DataColumns.MIME_TYPE + " TEXT NOT NULL," +
+            // 数据表的笔记ID
+            DataColumns.NOTE_ID + " INTEGER NOT NULL DEFAULT 0," +
+            // 数据表的创建时间
+            NoteColumns.CREATED_DATE + " INTEGER NOT NULL DEFAULT (strftime('%s','now') * 1000)," +
+            // 数据表的修改时间
+            NoteColumns.MODIFIED_DATE + " INTEGER NOT NULL DEFAULT (strftime('%s','now') * 1000)," +
+            // 数据表的内容
+            DataColumns.CONTENT + " TEXT NOT NULL DEFAULT ''," +
+            // 数据表的data1
+            DataColumns.DATA1 + " INTEGER," +
+            // 数据表的data2
+            DataColumns.DATA2 + " INTEGER," +
+            // 数据表的data3
+            DataColumns.DATA3 + " TEXT NOT NULL DEFAULT ''," +
+            // 数据表的data4
+            DataColumns.DATA4 + " TEXT NOT NULL DEFAULT ''," +
+            // 数据表的data5
+            DataColumns.DATA5 + " TEXT NOT NULL DEFAULT ''" +
+        ")";
+    // 创建一个名为note_id_index的索引，用于TABLE.DATA表的NOTE_ID列
+private static final String CREATE_DATA_NOTE_ID_INDEX_SQL =
+        "CREATE INDEX IF NOT EXISTS note_id_index ON " +
+        TABLE.DATA + "(" + DataColumns.NOTE_ID + ");";
+   
+   private static final String NOTE_INCREASE_FOLDER_COUNT_ON_UPDATE_TRIGGER =
+        "CREATE TRIGGER increase_folder_count_on_update "+
+        " AFTER UPDATE OF " + NoteColumns.PARENT_ID + " ON " + TABLE.NOTE +
+        " BEGIN " +
+        "  UPDATE " + TABLE.NOTE +
+        "   SET " + NoteColumns.NOTES_COUNT + "=" + NoteColumns.NOTES_COUNT + " + 1" +
+        "  WHERE " + NoteColumns.ID + "=new." + NoteColumns.PARENT_ID + ";" +
+        " END";
+   
+    private static final String NOTE_DECREASE_FOLDER_COUNT_ON_UPDATE_TRIGGER =
+        "CREATE TRIGGER decrease_folder_count_on_update " +
+        " AFTER UPDATE OF " + NoteColumns.PARENT_ID + " ON " + TABLE.NOTE +
+        " BEGIN " +
+        "  UPDATE " + TABLE.NOTE +
+        "   SET " + NoteColumns.NOTES_COUNT + "=" + NoteColumns.NOTES_COUNT + "-1" +
+        "  WHERE " + NoteColumns.ID + "=old." + NoteColumns.PARENT_ID +
+        "  AND " + NoteColumns.NOTES_COUNT + ">0" + ";" +
+        " END";
+
+   
+    private static final String NOTE_INCREASE_FOLDER_COUNT_ON_INSERT_TRIGGER =
+        "CREATE TRIGGER increase_folder_count_on_insert " +
+        " AFTER INSERT ON " + TABLE.NOTE +
+        " BEGIN " +
+        "  UPDATE " + TABLE.NOTE +
+        "   SET " + NoteColumns.NOTES_COUNT + "=" + NoteColumns.NOTES_COUNT + " + 1" +
+        "  WHERE " + NoteColumns.ID + "=new." + NoteColumns.PARENT_ID + ";" +
+        " END";
+
+    
+    private static final String NOTE_DECREASE_FOLDER_COUNT_ON_DELETE_TRIGGER =
+        "CREATE TRIGGER decrease_folder_count_on_delete " +
+        " AFTER DELETE ON " + TABLE.NOTE +
+        " BEGIN " +
+        "  UPDATE " + TABLE.NOTE +
+        "   SET " + NoteColumns.NOTES_COUNT + "=" + NoteColumns.NOTES_COUNT + "-1" +
+        "  WHERE " + NoteColumns.ID + "=old." + NoteColumns.PARENT_ID +
+        "  AND " + NoteColumns.NOTES_COUNT + ">0;" +
+        " END";
+
+    
+    private static final String DATA_UPDATE_NOTE_CONTENT_ON_INSERT_TRIGGER =
+        "CREATE TRIGGER update_note_content_on_insert " +
+        " AFTER INSERT ON " + TABLE.DATA +
+        " WHEN new." + DataColumns.MIME_TYPE + "='" + DataConstants.NOTE + "'" +
+        " BEGIN" +
+        "  UPDATE " + TABLE.NOTE +
+        "   SET " + NoteColumns.SNIPPET + "=new." + DataColumns.CONTENT +
+        "  WHERE " + NoteColumns.ID + "=new." + DataColumns.NOTE_ID + ";" +
+        " END";
+
+    
+    private static final String DATA_UPDATE_NOTE_CONTENT_ON_UPDATE_TRIGGER =
+        "CREATE TRIGGER update_note_content_on_update " +
+        " AFTER UPDATE ON " + TABLE.DATA +
+        " WHEN old." + DataColumns.MIME_TYPE + "='" + DataConstants.NOTE + "'" +
+        " BEGIN" +
+        "  UPDATE " + TABLE.NOTE +
+        "   SET " + NoteColumns.SNIPPET + "=new." + DataColumns.CONTENT +
+        "  WHERE " + NoteColumns.ID + "=new." + DataColumns.NOTE_ID + ";" +
+        " END";
+
+    
+    private static final String DATA_UPDATE_NOTE_CONTENT_ON_DELETE_TRIGGER =
+        "CREATE TRIGGER update_note_content_on_delete " +
+        " AFTER delete ON " + TABLE.DATA +
+        " WHEN old." + DataColumns.MIME_TYPE + "='" + DataConstants.NOTE + "'" +
+        " BEGIN" +
+        "  UPDATE " + TABLE.NOTE +
+        "   SET " + NoteColumns.SNIPPET + "=''" +
+        "  WHERE " + NoteColumns.ID + "=old." + DataColumns.NOTE_ID + ";" +
+        " END";
+
+    
+   private static final String NOTE_DELETE_DATA_ON_DELETE_TRIGGER =
+        "CREATE TRIGGER delete_data_on_delete " +
+        " AFTER DELETE ON " + TABLE.NOTE +
+        " BEGIN" +
+        "  DELETE FROM " + TABLE.DATA +
+        "   WHERE " + DataColumns.NOTE_ID + "=old." + NoteColumns.ID + ";" +
+        " END";
+
+    
+    private static final String FOLDER_DELETE_NOTES_ON_DELETE_TRIGGER =
+        "CREATE TRIGGER folder_delete_notes_on_delete " +
+        " AFTER DELETE ON " + TABLE.NOTE +
+        " BEGIN" +
+        "  DELETE FROM " + TABLE.NOTE +
+        "   WHERE " + NoteColumns.PARENT_ID + "=old." + NoteColumns.ID + ";" +
+        " END";
+
+    
+    private static final String FOLDER_MOVE_NOTES_ON_TRASH_TRIGGER =
+        "CREATE TRIGGER folder_move_notes_on_trash " +
+        " AFTER UPDATE ON " + TABLE.NOTE +
+        " WHEN new." + NoteColumns.PARENT_ID + "=" + Notes.ID_TRASH_FOLER +
+        " BEGIN" +
+        "  UPDATE " + TABLE.NOTE +
+        "   SET " + NoteColumns.PARENT_ID + "=" + Notes.ID_TRASH_FOLER +
+        "  WHERE " + NoteColumns.PARENT_ID + "=old." + NoteColumns.ID + ";" +
+        " END";
+    public NotesDatabaseHelper(Context context) {
+        super(context, DB_NAME, null, DB_VERSION);
+    }
+
+    public void createNoteTable(SQLiteDatabase db) {
+        db.execSQL(CREATE_NOTE_TABLE_SQL);
+        // 创建更新触发器，当父ID等于ID_TRASH_FOLER时，将父ID设置为ID_TRASH_FOLER
+        reCreateNoteTableTriggers(db);
+        // 创建系统文件夹
+        createSystemFolder(db);
+        Log.d(TAG, "note table has been created");
+    }
+
+   private void reCreateNoteTableTriggers(SQLiteDatabase db) {
+        // 删除所有旧的触发器
+        db.execSQL("DROP TRIGGER IF EXISTS increase_folder_count_on_update");
+        db.execSQL("DROP TRIGGER IF EXISTS decrease_folder_count_on_update");
+        db.execSQL("DROP TRIGGER IF EXISTS decrease_folder_count_on_delete");
+        db.execSQL("DROP TRIGGER IF EXISTS delete_data_on_delete");
+        db.execSQL("DROP TRIGGER IF EXISTS increase_folder_count_on_insert");
+        db.execSQL("DROP TRIGGER IF EXISTS folder_delete_notes_on_delete");
+        db.execSQL("DROP TRIGGER IF EXISTS folder_move_notes_on_trash");
+
+        // 创建新的触发器
+        db.execSQL(NOTE_INCREASE_FOLDER_COUNT_ON_UPDATE_TRIGGER);
+        db.execSQL(NOTE_DECREASE_FOLDER_COUNT_ON_UPDATE_TRIGGER);
+        db.execSQL(NOTE_DECREASE_FOLDER_COUNT_ON_DELETE_TRIGGER);
+        db.execSQL(NOTE_DELETE_DATA_ON_DELETE_TRIGGER);
+        db.execSQL(NOTE_INCREASE_FOLDER_COUNT_ON_INSERT_TRIGGER);
+        db.execSQL(FOLDER_DELETE_NOTES_ON_DELETE_TRIGGER);
+        db.execSQL(FOLDER_MOVE_NOTES_ON_TRASH_TRIGGER);
+    }
+
+   private void createSystemFolder(SQLiteDatabase db) {
+        ContentValues values = new ContentValues();
+
+        
+        // 创建一个系统文件夹，ID为Notes.ID_CALL_RECORD_FOLDER
+        values.put(NoteColumns.ID, Notes.ID_CALL_RECORD_FOLDER);
+        values.put(NoteColumns.TYPE, Notes.TYPE_SYSTEM);
+        db.insert(TABLE.NOTE, null, values);
+
+        
+        // 创建一个系统文件夹，ID为Notes.ID_ROOT_FOLDER
+        values.clear();
+        values.put(NoteColumns.ID, Notes.ID_ROOT_FOLDER);
+        values.put(NoteColumns.TYPE, Notes.TYPE_SYSTEM);
+        db.insert(TABLE.NOTE, null, values);
+
+        
+        // 创建一个系统文件夹，ID为Notes.ID_TEMPARAY_FOLDER
+        values.clear();
+        values.put(NoteColumns.ID, Notes.ID_TEMPARAY_FOLDER);
+        values.put(NoteColumns.TYPE, Notes.TYPE_SYSTEM);
+        db.insert(TABLE.NOTE, null, values);
+
+    
+         
+        // 创建一个系统文件夹，ID为Notes.ID_TRASH_FOLER
+        values.clear();
+        values.put(NoteColumns.ID, Notes.ID_TRASH_FOLER);
+        values.put(NoteColumns.TYPE, Notes.TYPE_SYSTEM);
+        db.insert(TABLE.NOTE, null, values);
+    }
+
+   public void createDataTable(SQLiteDatabase db) {
+        // 创建data表
+        db.execSQL(CREATE_DATA_TABLE_SQL);
+        // 重新创建触发器
+        reCreateDataTableTriggers(db);
+        // 创建data表的索引
+        db.execSQL(CREATE_DATA_NOTE_ID_INDEX_SQL);
+        Log.d(TAG, "data table has been created");
+    }
+
+    private void reCreateDataTableTriggers(SQLiteDatabase db) {
+        // 删除更新笔记内容的触发器
+        db.execSQL("DROP TRIGGER IF EXISTS update_note_content_on_insert");
+        db.execSQL("DROP TRIGGER IF EXISTS update_note_content_on_update");
+        db.execSQL("DROP TRIGGER IF EXISTS update_note_content_on_delete");
+
+        // 重新创建更新笔记内容的触发器
+        db.execSQL(DATA_UPDATE_NOTE_CONTENT_ON_INSERT_TRIGGER);
+        db.execSQL(DATA_UPDATE_NOTE_CONTENT_ON_UPDATE_TRIGGER);
+        db.execSQL(DATA_UPDATE_NOTE_CONTENT_ON_DELETE_TRIGGER);
+    }
+
+    static synchronized NotesDatabaseHelper getInstance(Context context) {
+        // 获取实例
+        if (mInstance == null) {
+            mInstance = new NotesDatabaseHelper(context);
+        }
+        return mInstance;
+    }
+
+    @Override
+    public void onCreate(SQLiteDatabase db) {
+        // 创建笔记表
+        createNoteTable(db);
+        // 创建data表
+        createDataTable(db);
+    }
+    @Override
+    // 添加中文注释后
+public void onUpgrade(SQLiteDatabase db, int oldVersion, int newVersion) {
+        boolean reCreateTriggers = false;
+        boolean skipV2 = false;
+
+        // 数据库版本为1时，升级到版本2
+        if (oldVersion == 1) {
+            upgradeToV2(db);
+            skipV2 = true; 
+            oldVersion++;
+        }
+
+        // 数据库版本为2时，升级到版本3
+        if (oldVersion == 2 && !skipV2) {
+            upgradeToV3(db);
+            reCreateTriggers = true;
+            oldVersion++;
+        }
+
+        // 数据库版本为3时，升级到版本4
+        if (oldVersion == 3) {
+            upgradeToV4(db);
+            oldVersion++;
+        }
+
+        // 如果数据库版本不是最新的，重新创建触发器
+        if (reCreateTriggers) {
+            reCreateNoteTableTriggers(db);
+            reCreateDataTableTriggers(db);
+        }
+
+        // 如果数据库版本不是最新的，抛出异常
+        if (oldVersion != newVersion) {
+            throw new IllegalStateException("Upgrade notes database to version " + newVersion
+                    + "fails");
+        }
+    }
+
+   private void upgradeToV2(SQLiteDatabase db) {
+        // 删除NOTE表
+        db.execSQL("DROP TABLE IF EXISTS " + TABLE.NOTE);
+        // 删除DATA表
+        db.execSQL("DROP TABLE IF EXISTS " + TABLE.DATA);
+        // 创建NOTE表
+        createNoteTable(db);
+        // 创建DATA表
+        createDataTable(db);
+    }
+
+    private void upgradeToV3(SQLiteDatabase db) {
+        
+        // 删除更新NOTE表的触发器
+        db.execSQL("DROP TRIGGER IF EXISTS update_note_modified_date_on_insert");
+        db.execSQL("DROP TRIGGER IF EXISTS update_note_modified_date_on_delete");
+        db.execSQL("DROP TRIGGER IF EXISTS update_note_modified_date_on_update");
+        
+        // 向NOTE表中添加GTASK_ID列
+        db.execSQL("ALTER TABLE " + TABLE.NOTE + " ADD COLUMN " + NoteColumns.GTASK_ID
+                + " TEXT NOT NULL DEFAULT ''");
+       
+        // 向NOTE表中插入一条数据
+        ContentValues values = new ContentValues();
+        values.put(NoteColumns.ID, Notes.ID_TRASH_FOLER);
+        values.put(NoteColumns.TYPE, Notes.TYPE_SYSTEM);
+        db.insert(TABLE.NOTE, null, values);
+    }
+
+    private void upgradeToV4(SQLiteDatabase db) {
+        // 向NOTE表中添加VERSION列
+        db.execSQL("ALTER TABLE " + TABLE.NOTE + " ADD COLUMN " + NoteColumns.VERSION
+                + " INTEGER NOT NULL DEFAULT 0");
+    }
+}

标注/SqlData.java

@@ -0,0 +1,577 @@
+/*
+ * Description：用于支持小米便签最底层的数据库相关操作，和sqldata的关系上是父集关系，即note是data的子父集。
+ * 和SqlData相比，SqlNote算是真正意义上的数据了。
+ */
+ 
+package net.micode.notes.gtask.data;
+/*
+ * 功能描述：
+ * 实现过程：
+ * 参数注解： 
+ * Made By CuiCan
+ */
+ 
+public class SqlNote {
+	/*
+	 * 功能描述：得到类的简写名称存入字符串TAG中
+	 * 实现过程：调用getSimpleName ()函数
+	 * Made By CuiCan
+	 */
+    private static final String TAG = SqlNote.class.getSimpleName();
+ 
+    private static final int INVALID_ID = -99999;
+    // 集合了interface NoteColumns中所有SF常量（17个）
+    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
+    };
+ 
+    //以下设置17个列的编号
+    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;
+ 
+    //一下定义了17个内部的变量，其中12个可以由content中获得，5个需要初始化为0或者new
+    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;
+ 
+    /*
+     * 功能描述：构造函数
+     * 参数注解： mIsCreate用于标示构造方式
+     * 参数注解： 
+     * Made By CuiCan
+     */
+    //构造函数只有context，对所有的变量进行初始化
+    public SqlNote(Context 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>();
+    }
+ 
+ 
+    /*
+     * 功能描述：构造函数
+     * 参数注解： mIsCreate用于标示构造方式
+     * 参数注解： 
+     * Made By CuiCan
+     */
+    //构造函数有context和一个数据库的cursor，多数变量通过cursor指向的一条记录直接进行初始化
+    public SqlNote(Context context, Cursor c) {
+        mContext = context;
+        mContentResolver = context.getContentResolver();
+        mIsCreate = false;
+        loadFromCursor(c);
+        mDataList = new ArrayList<SqlData>();
+        //
+        if (mType == Notes.TYPE_NOTE)
+            loadDataContent();
+        mDiffNoteValues = new ContentValues();
+    }
+ 
+ 
+    /*
+     * 功能描述：构造函数
+     * 参数注解： mIsCreate用于标示构造方式
+     * 参数注解： 
+     * Made By CuiCan
+     */
+    public SqlNote(Context context, long id) {
+        mContext = context;
+        mContentResolver = context.getContentResolver();
+        mIsCreate = false;
+        loadFromCursor(id);
+        mDataList = new ArrayList<SqlData>();
+        if (mType == Notes.TYPE_NOTE)
+            loadDataContent();
+        mDiffNoteValues = new ContentValues();
+ 
+    }
+ 
+    /*
+     * 功能描述：通过id从光标处加载数据
+     * Made By CuiCan
+     */
+    private void loadFromCursor(long id) {
+        Cursor c = null;
+        try {
+            c = mContentResolver.query(Notes.CONTENT_NOTE_URI, PROJECTION_NOTE, "(_id=?)",
+                    new String[] {
+                        String.valueOf(id)
+                    }, null);//通过id获得对应的ContentResolver中的cursor
+            if (c != null) {
+                c.moveToNext();
+                loadFromCursor(c);//然后加载数据进行初始化，这样函数
+                //SqlNote(Context context, long id)与SqlNote(Context context, long id)的实现方式基本相同
+            } else {
+                Log.w(TAG, "loadFromCursor: cursor = null");
+            }
+        } finally {
+            if (c != null)
+                c.close();
+        }
+    }
+ 
+    /*
+     * 功能描述：通过游标从光标处加载数据
+     * Made By CuiCan
+     */
+    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);
+    }
+ 
+    /*
+     * 功能描述：通过content机制获取共享数据并加载到数据库当前游标处
+     * 参数注解： 
+     * Made By CuiCan
+     */
+    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();
+        }
+    }
+ 
+    /*
+     * 功能描述：设置通过content机制用于共享的数据信息
+     * 参数注解： 
+     * Made By CuiCan
+     */
+    public boolean setContent(JSONObject js) {
+        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;
+    }
+ 
+    /*
+     * 功能描述：获取content机制提供的数据并加载到note中
+     * 参数注解： 
+     * Made By CuiCan
+     */
+    public JSONObject getContent() {
+        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时
+                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;
+    }
+ 
+    /*
+     * 功能描述：给当前id设置父id
+     * 参数注解： 
+     * Made By CuiCan
+     */
+    public void setParentId(long id) {
+        mParentId = id;
+        mDiffNoteValues.put(NoteColumns.PARENT_ID, id);
+    }
+ 
+    /*
+     * 功能描述：给当前id设置Gtaskid
+     * 参数注解： 
+     * Made By CuiCan
+     */
+    public void setGtaskId(String gid) {
+        mDiffNoteValues.put(NoteColumns.GTASK_ID, gid);
+    }
+ 
+    /*
+     * 功能描述：给当前id设置同步id
+     * 参数注解： 
+     * Made By CuiCan
+     */
+    public void setSyncId(long syncId) {
+        mDiffNoteValues.put(NoteColumns.SYNC_ID, syncId);
+    }
+ 
+    /*
+     * 功能描述：初始化本地修改，即撤销所有当前修改
+     * 参数注解： 
+     * Made By CuiCan
+     */
+    public void resetLocalModified() {
+        mDiffNoteValues.put(NoteColumns.LOCAL_MODIFIED, 0);
+    }
+ 
+    /*
+     * 功能描述：获得当前id
+     * 参数注解： 
+     * Made By CuiCan
+     */
+    public long getId() {
+        return mId;
+    }
+ 
+    /*
+     * 功能描述：获得当前id的父id
+     * 参数注解： 
+     * Made By CuiCan
+     */
+    public long getParentId() {
+        return mParentId;
+    }
+ 
+    /*
+     * 功能描述：获取小片段即用于显示的部分便签内容
+     * 参数注解： 
+     * Made By CuiCan
+     */
+    public String getSnippet() {
+        return mSnippet;
+    }
+ 
+    /*
+     * 功能描述：判断是否为便签类型
+     * 参数注解： 
+     * Made By CuiCan
+     */
+    public boolean isNoteType() {
+        return mType == Notes.TYPE_NOTE;
+    }
+ 
+    /*
+     * 功能描述：commit函数用于把当前造作所做的修改保存到数据库
+     * 参数注解： 
+     * Made By CuiCan
+     */
+    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中的实现
+                    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;
+    }
+}

标注/Task.java

@@ -0,0 +1,323 @@
+package net.micode.notes.gtask.data;
+ 
+public class Task extends Node {
+    private static final String TAG = Task.class.getSimpleName();
+ 
+    private boolean mCompleted;//是否完成
+ 
+    private String mNotes;
+ 
+    private JSONObject mMetaInfo;//将在实例中存储数据的类型
+ 
+    private Task mPriorSibling;//对应的优先兄弟Task的指针（待完善）
+ 
+    private TaskList mParent;//所在的任务列表的指针
+ 
+    public Task() {
+        super();
+        mCompleted = false;
+        mNotes = null;
+        mPriorSibling = null;//TaskList中当前Task前面的Task的指针
+        mParent = null;//当前Task所在的TaskList
+        mMetaInfo = null;
+    }
+ 
+    public JSONObject getCreateAction(int actionId) {
+        JSONObject js = new JSONObject();
+ 
+        try {
+            // action_type
+            js.put(GTaskStringUtils.GTASK_JSON_ACTION_TYPE,
+                    GTaskStringUtils.GTASK_JSON_ACTION_TYPE_CREATE);
+ 
+            // action_id
+            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
+            if (mParent!= null) {
+            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
+            if (mParent!= null) {
+            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) {
+        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) {
+        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) {    //<2F><>metadata<74><61><EFBFBD><EFBFBD>ʵʩ
+        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() {
+        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) {
+        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() {
+        return mMetaInfo != null || (getName() != null && getName().trim().length() > 0)
+                || (getNotes() != null && getNotes().trim().length() > 0);
+    }
+ 
+    public void setCompleted(boolean completed) {
+        this.mCompleted = completed;
+    }
+ 
+    public void setNotes(String notes) {
+        this.mNotes = notes;
+    }
+ 
+    public void setPriorSibling(Task priorSibling) {
+        this.mPriorSibling = priorSibling;
+    }
+ 
+    public void setParent(TaskList parent) {
+        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;
+    }
+ 
+}

标注/TaskList.java

@@ -0,0 +1,370 @@
+package net.micode.notes.gtask.data;
+ 
+public class TaskList extends Node {
+    private static final String TAG = TaskList.class.getSimpleName();//tag标记
+ 
+    private int mIndex;//当前TaskList的指针
+ 
+    private ArrayList<Task> mChildren;//类中主要的保存数据的单元，用来实现一个以Task为元素的ArrayList
+ 
+    public TaskList() {
+        super();
+        mChildren = new ArrayList<Task>();
+        mIndex = 1;
+    }
+ 
+    /* (non-Javadoc)
+     * @see net.micode.notes.gtask.data.Node#getCreateAction(int)
+     * 生成并返回一个包含了一定数据的JSONObject实体
+     */
+    public JSONObject getCreateAction(int actionId) {
+        JSONObject js = new JSONObject();
+ 
+        try {
+            // action_type
+            js.put(GTaskStringUtils.GTASK_JSON_ACTION_TYPE,
+                    GTaskStringUtils.GTASK_JSON_ACTION_TYPE_CREATE);
+ 
+            // action_id
+            js.put(GTaskStringUtils.GTASK_JSON_ACTION_ID, actionId);
+ 
+            // index
+            js.put(GTaskStringUtils.GTASK_JSON_INDEX, mIndex);
+ 
+            // entity_delta
+            JSONObject entity = new JSONObject();//entity实体
+            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;
+    }
+ 
+    /* (non-Javadoc)
+     * @see net.micode.notes.gtask.data.Node#getUpdateAction(int)
+     * 生成并返回一个包含了一定数据的JSONObject实体
+     */
+    public JSONObject getUpdateAction(int actionId) {
+        JSONObject js = new JSONObject();
+ 
+        try {
+            // action_type
+            js.put(GTaskStringUtils.GTASK_JSON_ACTION_TYPE,
+                    GTaskStringUtils.GTASK_JSON_ACTION_TYPE_UPDATE);
+ 
+            // action_id
+            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) {
+        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) {
+        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() {
+        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;
+    }
+ 
+    /**
+     * @return
+     * 功能：获得TaskList的大小，即mChildren的大小
+     */
+    public int getChildTaskCount() {
+        return mChildren.size();
+    }
+ 
+    /**
+     * @param task
+     * @return 返回值为是否成功添加任务。
+     * 功能：在当前任务表末尾添加新的任务。
+     */
+    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);
+                //注意：每一次ArrayList的变化都要紧跟相关Task中PriorSibling的更改
+                //，接下来几个函数都有相关操作
+            }
+        }
+        return ret;
+    }
+ 
+    /**
+     * @param task
+     * @param index
+     * @return
+     * 功能：在当前任务表的指定位置添加新的任务。
+     */
+    public boolean addChildTask(Task task, int index) {
+        if (index < 0 || index > mChildren.size()) {
+            Log.e(TAG, "add child task: invalid index");
+            return false;
+        }
+ 
+        int pos = mChildren.indexOf(task);
+        if (task != null && pos == -1) {
+            mChildren.add(index, task);
+ 
+            // update the task list
+            Task preTask = null;
+            Task afterTask = null;
+            if (index != 0)
+                preTask = mChildren.get(index - 1);
+            if (index != mChildren.size() - 1)
+                afterTask = mChildren.get(index + 1);
+ 
+            task.setPriorSibling(preTask);
+            if (afterTask != null)
+                afterTask.setPriorSibling(task);
+        }
+ 
+        return true;
+    }
+ 
+    /**
+     * @param task
+     * @return 返回删除是否成功
+     * 功能：删除TaskList中的一个Task
+     */
+    public boolean removeChildTask(Task task) {
+        boolean ret = false;
+        int index = mChildren.indexOf(task);
+        if (index != -1) {
+            ret = mChildren.remove(task);
+ 
+            if (ret) {
+                // reset prior sibling and parent
+                task.setPriorSibling(null);
+                task.setParent(null);
+ 
+                // update the task list
+                if (index != mChildren.size()) {
+                    mChildren.get(index).setPriorSibling(
+                            index == 0 ? null : mChildren.get(index - 1));
+                }
+            }
+        }
+        return ret;
+    }
+ 
+    /**
+     * @param task
+     * @param index
+     * @return
+     * 功能：将当前TaskList中含有的某个Task移到index位置
+     */
+    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));
+        //利用已实现好的功能完成当下功能；
+    }
+ 
+    /**
+     * @param gid
+     * @return返回寻找结果
+     * 功能：按gid寻找Task
+     */
+    public Task findChildTaskByGid(String gid) {
+        for (int i = 0; i < mChildren.size(); i++) {
+            Task t = mChildren.get(i);
+            if (t.getGid().equals(gid)) {
+                return t;
+            }
+        }
+        return null;
+    }
+ 
+    /**
+     * @param task
+     * @return
+     * 功能：返回指定Task的index
+     */
+    public int getChildTaskIndex(Task task) {
+        return mChildren.indexOf(task);
+    }
+ 
+    /**
+     * @param index
+     * @return
+     * 功能：返回指定index的Task
+     */
+    public Task getChildTaskByIndex(int index) {
+        if (index < 0 || index >= mChildren.size()) {
+            Log.e(TAG, "getTaskByIndex: invalid index");
+            return null;
+        }
+        return mChildren.get(index);
+    }
+ 
+    /**
+     * @param gid
+     * @return
+     * 功能：返回指定gid的Task
+     */
+    public Task getChilTaskByGid(String gid) {
+        for (Task task : mChildren) {//一种常见的ArrayList的遍历方法（四种，见精读笔记）
+            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;
+    }
+}