ADD file via upload

Contact.java

@@ -0,0 +1,95 @@
+/*
+ * 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.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 {
+    // 用于缓存电话号码与对应的联系人姓名，避免重复查询联系人数据库，提高性能
+    private static HashMap<String, String> sContactCache;
+    // 用于在日志输出时标识当前类，方便调试查看相关日志信息
+    private static final String TAG = "Contact";
+
+    // 构建的一个SQL查询条件字符串，用于从联系人数据库中筛选出与给定电话号码匹配的联系人记录
+    // 条件包括电话号码相等判断、数据类型匹配（确保是电话号码类型的数据）以及原始联系人ID相关的筛选条件等
+    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 = '+')";
+
+    // 该静态方法根据给定的上下文（Context）和电话号码（phoneNumber），尝试查找对应的联系人姓名
+    public static String getContact(Context context, String phoneNumber) {
+        // 如果缓存为空（首次使用或者缓存被清空等情况），则创建一个新的HashMap用于缓存联系人信息
+        if (sContactCache == null) {
+            sContactCache = new HashMap<String, String>();
+        }
+
+        // 首先检查缓存中是否已经存在该电话号码对应的联系人姓名，如果存在则直接返回缓存中的姓名，避免再次查询数据库
+        if (sContactCache.containsKey(phoneNumber)) {
+            return sContactCache.get(phoneNumber);
+        }
+
+        // 根据给定的电话号码，替换查询条件中的占位符，生成最终用于查询数据库的选择条件字符串
+        // 这里使用PhoneNumberUtils的方法将电话号码转换为合适的格式用于匹配查询（例如处理号码格式等情况）
+        String selection = CALLER_ID_SELECTION.replace("+",
+                PhoneNumberUtils.toCallerIDMinMatch(phoneNumber));
+
+        // 通过上下文的ContentResolver发起一个数据库查询操作
+        // 查询的是联系人数据的统一资源标识符（CONTENT_URI）
+        // 只查询联系人的显示名称（Phone.DISPLAY_NAME）这一列数据
+        // 使用前面生成的选择条件（selection），并传入要查询匹配的电话号码作为参数
+        Cursor cursor = context.getContentResolver().query(
+                Data.CONTENT_URI,
+                new String[]{Phone.DISPLAY_NAME},
+                selection,
+                new String[]{phoneNumber},
+                null);
+
+        // 如果游标不为空（表示查询到了数据）且游标可以移动到第一条记录（意味着有匹配的联系人记录）
+        if (cursor!= null && cursor.moveToFirst()) {
+            try {
+                // 从游标中获取第一列（索引为0）的数据，即联系人的显示名称
+                String name = cursor.getString(0);
+                // 将获取到的电话号码和对应的联系人姓名存入缓存中，方便下次查询使用
+                sContactCache.put(phoneNumber, name);
+                // 返回查找到的联系人姓名
+                return name;
+            } catch (IndexOutOfBoundsException e) {
+                // 如果在获取游标数据时出现越界异常（例如查询结果的列数不符合预期等情况），记录错误日志并返回null
+                Log.e(TAG, " Cursor get string error " + e.toString());
+                return null;
+            } finally {
+                // 无论是否成功获取到联系人姓名，都需要关闭游标，释放相关资源
+                cursor.close();
+            }
+        } else {
+            // 如果没有查询到匹配的联系人记录，记录一条调试日志，表明没有找到与给定电话号码匹配的联系人，然后返回null
+            Log.d(TAG, "No contact matched with number:" + phoneNumber);
+            return null;
+        }
+    }
+}

GTaskASyncTask.java

@@ -0,0 +1,170 @@
+/*
+ * Copyright (c) 2010-2011, The MiCode Open Source Community (www.micode.net)
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *        http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package net.micode.notes.gtask.remote;
+
+import android.app.Notification;
+import android.app.NotificationManager;
+import android.app.PendingIntent;
+import android.content.Context;
+import android.content.Intent;
+import android.os.AsyncTask;
+
+import net.micode.notes.R;
+import net.micode.notes.ui.NotesListActivity;
+import net.micode.notes.ui.NotesPreferenceActivity;
+
+// GTaskASyncTask类继承自AsyncTask，用于在后台执行与GTask相关的任务，并根据任务进度和结果进行相应的界面反馈（如显示通知等），同时支持任务取消等操作
+public class GTaskASyncTask extends AsyncTask<Void, String, Integer> {
+
+    // 定义一个静态的整数，作为GTask同步相关通知在系统中的唯一标识符，用于区分不同的通知
+    private static int GTASK_SYNC_NOTIFICATION_ID = 5234235;
+
+    // 定义一个接口，用于定义任务完成时需要执行的回调方法，外部类实现此接口来处理任务完成后的逻辑
+    public interface OnCompleteListener {
+        void onComplete();
+    }
+
+    // 用于保存应用的上下文环境，方便后续获取系统服务、资源等操作
+    private Context mContext;
+
+    // 用于管理和显示通知的系统服务对象，通过它可以创建、更新和取消通知
+    private NotificationManager mNotifiManager;
+
+    // GTask管理类的实例，负责具体的GTask相关业务逻辑，比如执行同步操作等
+    private GTaskManager mTaskManager;
+
+    // 实现了OnCompleteListener接口的对象引用，用于在任务完成后进行回调通知
+    private OnCompleteListener mOnCompleteListener;
+
+    // 构造函数，用于创建GTaskASyncTask实例，传入上下文和任务完成监听器对象
+    public GTaskASyncTask(Context context, OnCompleteListener listener) {
+        // 将传入的上下文赋值给成员变量，方便后续使用
+        mContext = context;
+        // 保存传入的任务完成监听器对象
+        mOnCompleteListener = listener;
+        // 获取系统的通知管理服务，以便后续可以发送通知
+        mNotifiManager = (NotificationManager) mContext
+                .getSystemService(Context.NOTIFICATION_SERVICE);
+        // 获取GTaskManager的单例实例，用于执行具体的GTask相关任务操作
+        mTaskManager = GTaskManager.getInstance();
+    }
+
+    // 用于取消正在进行的GTask同步任务，通过调用GTaskManager中的取消同步方法来实现
+    public void cancelSync() {
+        mTaskManager.cancelSync();
+    }
+
+    // 对外提供的方法，用于发布任务执行的进度信息，实际上是调用AsyncTask的publishProgress方法来通知主线程更新进度显示
+    public void publishProgess(String message) {
+        // 创建一个包含要发布消息的字符串数组，并调用publishProgress方法传递该数组
+        publishProgress(new String[] {
+                message
+        });
+    }
+
+    // 私有方法，用于创建并显示通知，根据传入的提示文本ID和具体内容来构建通知并发送到通知栏
+    private void showNotification(int tickerId, String content) {
+        PendingIntent pendingIntent;
+        // 根据传入的提示文本ID判断，如果不是表示成功的提示文本ID（通常对应不同的后续操作意图）
+        if (tickerId!= R.string.ticker_success) {
+            // 创建一个PendingIntent，用于当用户点击通知时，启动NotesPreferenceActivity，设置为不可变（遵循Android系统的一些安全和兼容性要求）
+            pendingIntent = PendingIntent.getActivity(mContext, 0, new Intent(mContext,
+                    NotesPreferenceActivity.class), PendingIntent.FLAG_IMMUTABLE);
+        } else {
+            // 如果是表示成功的提示文本ID，则创建一个PendingIntent，用于当用户点击通知时，启动NotesListActivity，同样设置为不可变
+            pendingIntent = PendingIntent.getActivity(mContext, 0, new Intent(mContext,
+                    NotesListActivity.class), PendingIntent.FLAG_IMMUTABLE);
+        }
+
+        // 使用Notification.Builder来构建通知对象，设置通知的一系列属性
+        Notification.Builder builder = new Notification.Builder(mContext)
+                // 设置通知点击后自动取消
+                .setAutoCancel(true)
+                // 设置通知的标题，从资源文件中获取应用名称作为标题
+                .setContentTitle(mContext.getString(R.string.app_name))
+                // 设置通知的内容文本，传入具体的内容字符串
+                .setContentText(content)
+                // 设置通知的点击意图，即用户点击通知后要执行的操作（由前面创建的PendingIntent决定）
+                .setContentIntent(pendingIntent)
+                // 设置通知触发的时间，使用当前系统时间
+                .setWhen(System.currentTimeMillis())
+                // 设置通知为持续进行状态（比如在同步过程中一直显示，直到任务完成等情况）
+                .setOngoing(true);
+
+        // 获取构建好的通知对象（在不同的Android版本中，获取方式可能有所不同，这里是一种常见的方式）
+        Notification notification = builder.getNotification();
+        // 通过通知管理器发送通知，使用之前定义的通知ID来标识该通知，确保唯一性
+        mNotifiManager.notify(GTASK_SYNC_NOTIFICATION_ID, notification);
+    }
+
+    // 在后台线程中执行的方法，用于执行实际的GTask同步任务相关逻辑，同时发布初始的进度信息
+    @Override
+    protected Integer doInBackground(Void... unused) {
+        // 发布同步登录进度信息，从资源文件中获取格式化后的字符串，其中包含同步账号名称（通过NotesPreferenceActivity获取）
+        publishProgess(mContext.getString(R.string.sync_progress_login, NotesPreferenceActivity
+                .getSyncAccountName(mContext)));
+        // 调用GTaskManager的sync方法执行同步操作，并返回同步结果（通常是表示不同状态的整数）
+        return mTaskManager.sync(mContext, this);
+    }
+
+    // 在主线程中执行的方法，用于处理任务执行过程中的进度更新情况，显示相应的通知，并在特定条件下发送广播通知相关组件
+    @Override
+    protected void onProgressUpdate(String... progress) {
+        // 根据进度信息显示相应的通知，使用表示正在同步的提示文本ID和传入的具体进度消息内容
+        showNotification(R.string.ticker_syncing, progress[0]);
+        // 如果当前上下文对象是GTaskSyncService类型（可能是在特定的服务环境中运行该任务）
+        if (mContext instanceof GTaskSyncService) {
+            // 则通过该服务发送广播，广播内容为进度消息，用于通知其他相关组件任务进度情况
+            ((GTaskSyncService) mContext).sendBroadcast(progress[0]);
+        }
+    }
+
+    // 在主线程中执行的方法，用于处理任务执行完成后的逻辑，根据不同的任务结果显示相应的通知，并在有任务完成监听器的情况下进行回调通知
+    @Override
+    protected void onPostExecute(Integer result) {
+        // 如果任务结果表示成功（通常对应GTaskManager中定义的表示成功的状态常量）
+        if (result == GTaskManager.STATE_SUCCESS) {
+            // 显示表示成功的通知，通知内容包含成功同步的账号信息（从资源文件中获取格式化后的字符串，包含账号信息，通过GTaskManager获取账号）
+            showNotification(R.string.ticker_success, mContext.getString(
+                    R.string.success_sync_account, mTaskManager.getSyncAccount()));
+            // 在NotesPreferenceActivity中记录最后同步时间，传入当前系统时间
+            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));
+        }
+
+        // 如果存在任务完成监听器对象（即外部传入了实现了OnCompleteListener接口的对象）
+        if (mOnCompleteListener!= null) {
+            // 创建一个新线程，用于执行任务完成的回调方法，避免阻塞主线程等情况
+            new Thread(new Runnable() {
+
+                public void run() {
+                    // 调用任务完成监听器的onComplete方法，通知外部任务已完成，由外部实现具体的后续逻辑
+                    mOnCompleteListener.onComplete();
+                }
+            }).start();
+        }
+    }
+}

GTaskSyncService.java

@@ -0,0 +1,172 @@
+/*
+ * Copyright (c) 2010-2011, The MiCode Open Source Community (www.micode.net)
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *        http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package net.micode.notes.gtask.remote;
+
+import android.app.Activity;
+import android.app.Service;
+import android.content.Context;
+import android.content.Intent;
+import android.os.Bundle;
+import android.os.IBinder;
+
+// GTaskSyncService类继承自Service，用于管理GTask相关的同步任务，提供了启动、取消同步任务的功能，并且能在不同状态下（如内存不足等）进行相应处理，同时可以对外广播同步相关的状态信息
+public class GTaskSyncService extends Service {
+
+    // 定义一个字符串常量，用于作为区分不同同步操作行为的Intent的Extra字段的键名
+    public final static String ACTION_STRING_NAME = "sync_action_type";
+
+    // 定义一个整数常量，表示启动同步任务的操作类型，作为通过Intent传递操作类型时的一个标识值
+    public final static int ACTION_START_SYNC = 0;
+
+    // 定义一个整数常量，表示取消同步任务的操作类型
+    public final static int ACTION_CANCEL_SYNC = 1;
+
+    // 定义一个整数常量，表示无效的操作类型，可能用于默认情况或者错误处理时的标识
+    public final static int ACTION_INVALID = 2;
+
+    // 定义一个字符串常量，作为用于广播GTask同步服务相关信息的Intent的动作（Action）名称，用于区分不同来源的广播
+    public final static String GTASK_SERVICE_BROADCAST_NAME = "net.micode.notes.gtask.remote.gtask_sync_service";
+
+    // 定义一个字符串常量，作为广播Intent中用于表示是否正在同步的Extra字段的键名，用于传递同步状态信息
+    public final static String GTASK_SERVICE_BROADCAST_IS_SYNCING = "isSyncing";
+
+    // 定义一个字符串常量，作为广播Intent中用于表示同步进度消息的Extra字段的键名，用于传递同步过程中的进度提示等信息
+    public final static String GTASK_SERVICE_BROADCAST_PROGRESS_MSG = "progressMsg";
+
+    // 静态变量，用于保存当前正在执行的GTaskASyncTask实例，初始化为null，表示没有正在进行的同步任务
+    private static GTaskASyncTask mSyncTask = null;
+
+    // 静态变量，用于保存同步任务的进度消息，初始化为空字符串
+    private static String mSyncProgress = "";
+
+    // 私有方法，用于启动同步任务，如果当前没有正在执行的同步任务，则创建一个新的GTaskASyncTask实例并执行它
+    private void startSync() {
+        // 判断当前是否没有正在执行的同步任务（即mSyncTask为null）
+        if (mSyncTask == null) {
+            // 创建一个新的GTaskASyncTask实例，传入当前服务的上下文（this表示当前Service实例）以及一个实现了OnCompleteListener接口的匿名内部类对象
+            mSyncTask = new GTaskASyncTask(this, new GTaskASyncTask.OnCompleteListener() {
+                // 实现OnCompleteListener接口的onComplete方法，当同步任务完成时会被调用
+                public void onComplete() {
+                    // 将正在执行的同步任务实例置为null，表示同步任务已结束
+                    mSyncTask = null;
+                    // 发送一个空消息的广播（可能用于通知其他组件同步已完成等情况，具体作用依赖接收广播的组件逻辑）
+                    sendBroadcast("");
+                    // 停止当前服务自身，因为同步任务已经完成，服务不再需要继续运行
+                    stopSelf();
+                }
+            });
+            // 发送一个空消息的广播（可能在任务启动阶段通知其他组件同步即将开始等情况）
+            sendBroadcast("");
+            // 执行同步任务，启动后台线程开始执行GTask相关的同步操作
+            mSyncTask.execute();
+        }
+    }
+
+    // 私有方法，用于取消正在执行的同步任务，如果当前有正在执行的同步任务，则调用其cancelSync方法进行取消操作
+    private void cancelSync() {
+        if (mSyncTask!= null) {
+            mSyncTask.cancelSync();
+        }
+    }
+
+    // 重写Service的onCreate方法，在服务创建时被调用，这里将正在执行的同步任务实例置为null，进行初始化操作
+    @Override
+    public void onCreate() {
+        mSyncTask = null;
+    }
+
+    // 重写Service的onStartCommand方法，当服务接收到通过startService方法启动的Intent时被调用，根据传入Intent中的操作类型执行相应的同步操作逻辑
+    @Override
+    public int onStartCommand(Intent intent, int flags, int startId) {
+        // 获取传入Intent中的额外数据（以Bundle形式存储）
+        Bundle bundle = intent.getExtras();
+        // 判断Bundle是否不为null且包含了用于区分操作类型的键（ACTION_STRING_NAME）
+        if (bundle!= null && bundle.containsKey(ACTION_STRING_NAME)) {
+            // 根据操作类型的值进行不同的处理，通过获取操作类型整数值（默认值为ACTION_INVALID，如果键不存在）
+            switch (bundle.getInt(ACTION_STRING_NAME, ACTION_INVALID)) {
+                // 如果操作类型是启动同步任务
+                case ACTION_START_SYNC:
+                    // 调用startSync方法启动同步任务
+                    startSync();
+                    break;
+                // 如果操作类型是取消同步任务
+                case ACTION_CANCEL_SYNC:
+                    // 调用cancelSync方法取消同步任务
+                    cancelSync();
+                    break;
+                default:
+                    break;
+            }
+            // 返回START_STICKY，表示服务在被系统强制关闭后（如内存不足等情况），会尝试重新创建并启动，保持服务的持续可用性（但不会重新传递之前的Intent）
+            return START_STICKY;
+        }
+        // 如果不符合上述条件，调用父类的onStartCommand方法进行默认处理
+        return super.onStartCommand(intent, flags, startId);
+    }
+
+    // 重写Service的onLowMemory方法，当系统内存不足时被调用，在这里如果有正在执行的同步任务，则取消该任务，释放内存资源
+    @Override
+    public void onLowMemory() {
+        if (mSyncTask!= null) {
+            mSyncTask.cancelSync();
+        }
+    }
+
+    // 重写Service的onBind方法，用于处理绑定服务的情况，这里返回null，表示该服务不支持绑定操作
+    public IBinder onBind(Intent intent) {
+        return null;
+    }
+
+    // 公共方法，用于发送包含同步相关状态信息（是否正在同步以及进度消息）的广播，更新同步进度消息并构建广播Intent发送出去
+    public void sendBroadcast(String msg) {
+        // 更新同步进度消息
+        mSyncProgress = msg;
+        // 创建一个新的Intent，设置其动作（Action）为之前定义的GTask同步服务广播的动作名称，用于标识该广播的来源和用途
+        Intent intent = new Intent(GTASK_SERVICE_BROADCAST_NAME);
+        // 向广播Intent中添加Extra数据，设置是否正在同步的状态，通过判断mSyncTask是否为null来确定（不为null表示正在同步）
+        intent.putExtra(GTASK_SERVICE_BROADCAST_IS_SYNCING, mSyncTask!= null);
+        // 向广播Intent中添加Extra数据，设置同步进度消息，使用传入的msg参数作为消息内容
+        intent.putExtra(GTASK_SERVICE_BROADCAST_PROGRESS_MSG, msg);
+        // 发送广播，将包含同步相关信息的Intent广播出去，以便其他组件可以接收并处理这些信息
+        sendBroadcast(intent);
+    }
+
+    // 静态公共方法，用于从Activity中启动同步任务，设置相关的Activity上下文到GTaskManager，并发送启动同步任务的Intent到GTaskSyncService
+    public static void startSync(Activity activity) {
+        GTaskManager.getInstance().setActivityContext(activity);
+        Intent intent = new Intent(activity, GTaskSyncService.class);
+        intent.putExtra(GTaskSyncService.ACTION_STRING_NAME, GTaskSyncService.ACTION_START_SYNC);
+        activity.startService(intent);
+    }
+
+    // 静态公共方法，用于从给定的上下文（通常是Activity或其他组件所在的上下文）中取消同步任务，发送取消同步任务的Intent到GTaskSyncService
+    public static void cancelSync(Context context) {
+        Intent intent = new Intent(context, GTaskSyncService.class);
+        intent.putExtra(GTaskSyncService.ACTION_STRING_NAME, GTaskSyncService.ACTION_CANCEL_SYNC);
+        context.startService(intent);
+    }
+
+    // 静态公共方法，用于判断当前是否有正在执行的同步任务，通过检查mSyncTask是否为null来确定，返回布尔值表示同步状态
+    public static boolean isSyncing() {
+        return mSyncTask!= null;
+    }
+
+    // 静态公共方法，用于获取当前的同步进度消息，返回保存同步进度消息的字符串变量的值
+    public static String getProgressString() {
+        return mSyncProgress;
+    }
+}

Notes.java

@@ -0,0 +1,292 @@
+/*
+ * 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.data;
+
+import android.net.Uri;
+
+// Notes类用于定义与笔记（Notes）相关的各种常量、接口以及内部类，为整个笔记应用的数据结构和操作提供统一的规范和标识
+public class Notes {
+    // 定义笔记应用的授权（Authority）字符串，用于在内容提供器（Content Provider）中标识该应用的数据来源
+    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是系统文件夹的标识符说明
+     * {@link Notes#ID_ROOT_FOLDER } 表示默认文件夹
+     * {@link Notes#ID_TEMPARAY_FOLDER } 用于存放无所属文件夹的笔记
+     * {@link Notes#ID_CALL_RECORD_FOLDER} 用于存储通话记录相关的笔记
+     */
+    public static final int ID_ROOT_FOLDER = 0;
+    public static final int ID_TEMPARAY_FOLDER = -1;
+    public static final int ID_CALL_RECORD_FOLDER = -2;
+    public static final int ID_TRASH_FOLER = -3;
+
+    // 定义一系列用于传递额外数据的Intent的键（Key）常量，方便在不同组件间传递与笔记相关的特定数据
+    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;
+
+    // DataConstants内部类，用于定义笔记相关的数据类型常量，目前主要涉及文本笔记（TextNote）和通话记录笔记（CallNote）的内容类型
+    public static class DataConstants {
+        public static final String NOTE = TextNote.CONTENT_ITEM_TYPE;
+        public static final String CALL_NOTE = CallNote.CONTENT_ITEM_TYPE;
+    }
+
+    /**
+     * 用于查询所有笔记和文件夹的统一资源标识符（Uri），通过指定的授权（AUTHORITY）和路径（"/note"）构建而成
+     * 外部组件可以使用这个Uri来访问该应用中所有笔记和文件夹相关的数据（通过内容提供器机制）
+     */
+    public static final Uri CONTENT_NOTE_URI = Uri.parse("content://" + AUTHORITY + "/note");
+
+    /**
+     * 用于查询数据的统一资源标识符（Uri），同样基于应用的授权（AUTHORITY）构建，路径为"/data"
+     * 可用于获取更具体的数据信息（比如不同类型笔记包含的数据内容等）
+     */
+    public static final Uri CONTENT_DATA_URI = Uri.parse("content://" + AUTHORITY + "/data");
+
+    // NoteColumns接口，定义了笔记表（用于存储笔记相关信息的数据库表）中各列的列名常量，方便在数据库操作等代码中统一引用
+    public interface NoteColumns {
+        /**
+         * 表示一行数据（一条笔记记录）的唯一ID，类型为长整型（INTEGER类型在数据库中对应的长整型表示）
+         * <P> Type: INTEGER (long) </P>
+         */
+        public static final String ID = "_id";
+
+        /**
+         * 笔记或文件夹的父级ID，用于表示层级关系，类型为长整型
+         * <P> Type: INTEGER (long) </P>
+         */
+        public static final String PARENT_ID = "parent_id";
+
+        /**
+         * 笔记或文件夹的创建日期，以时间戳等长整型数值表示，方便记录和查询创建时间先后顺序等操作
+         * <P> Type: INTEGER (long) </P>
+         */
+        public static final String CREATED_DATE = "created_date";
+
+        /**
+         * 笔记或文件夹的最近修改日期，同样以长整型表示，便于跟踪数据的更新情况
+         * <P> Type: INTEGER (long) </P>
+         */
+        public static final String MODIFIED_DATE = "modified_date";
+
+        /**
+         * 提醒日期，例如设置了提醒功能的笔记对应的提醒时间，类型为长整型
+         * <P> Type: INTEGER (long) </P>
+         */
+        public static final String ALERTED_DATE = "alert_date";
+
+        /**
+         * 对于文件夹来说是文件夹名称，对于笔记来说是文本内容的摘要等，类型为文本（TEXT）类型
+         * <P> Type: TEXT </P>
+         */
+        public static final String SNIPPET = "snippet";
+
+        /**
+         * 笔记对应的桌面小部件的ID，长整型，用于关联笔记与相应的小部件，便于小部件展示对应笔记相关信息等操作
+         * <P> Type: INTEGER (long) </P>
+         */
+        public static final String WIDGET_ID = "widget_id";
+
+        /**
+         * 笔记对应的桌面小部件的类型，长整型，用于区分不同规格或功能的小部件
+         * <P> Type: INTEGER (long) </P>
+         */
+        public static final String WIDGET_TYPE = "widget_type";
+
+        /**
+         * 笔记的背景颜色的ID，长整型，可用于设置笔记在界面上显示时的背景颜色相关属性
+         * <P> Type: INTEGER (long) </P>
+         */
+        public static final String BG_COLOR_ID = "bg_color_id";
+
+        /**
+         * 用于表示笔记是否有附件，对于文本笔记通常没有附件（值为0等表示），对于多媒体笔记则至少有一个附件（值为1等表示），类型为整型
+         * <P> Type: INTEGER </P>
+         */
+        public static final String HAS_ATTACHMENT = "has_attachment";
+
+        /**
+         * 文件夹中包含的笔记数量，长整型，方便统计和展示文件夹内的笔记情况
+         * <P> Type: INTEGER (long) </P>
+         */
+        public static final String NOTES_COUNT = "notes_count";
+
+        /**
+         * 表示文件类型，是文件夹还是笔记，整型，通过不同的值（如前面定义的TYPE_NOTE、TYPE_FOLDER等）来区分
+         * <P> Type: INTEGER </P>
+         */
+        public static final String TYPE = "type";
+
+        /**
+         * 最后一次同步的ID，长整型，可能用于与服务器等外部数据源同步数据时的标识和记录
+         * <P> Type: INTEGER (long) </P>
+         */
+        public static final String SYNC_ID = "sync_id";
+
+        /**
+         * 用于指示本地是否有修改的标志，整型，例如修改了笔记内容后可设置相应值来表示已修改状态
+         * <P> Type: INTEGER </P>
+         */
+        public static final String LOCAL_MODIFIED = "local_modified";
+
+        /**
+         * 在移动到临时文件夹之前的原始父级ID，整型，用于记录笔记在文件夹层级结构中的原始位置等情况
+         * <P> Type : INTEGER </P>
+         */
+        public static final String ORIGIN_PARENT_ID = "origin_parent_id";
+
+        /**
+         * 与gtask相关的ID，文本（TEXT）类型，可能用于与其他任务管理相关功能的关联或标识（具体取决于应用集成的任务管理体系）
+         * <P> Type : TEXT </P>
+         */
+        public static final String GTASK_ID = "gtask_id";
+
+        /**
+         * 版本代码，长整型，可用于记录笔记数据的版本情况，例如在数据更新迭代时进行版本控制等操作
+         * <P> Type : INTEGER (long) </P>
+         */
+        public static final String VERSION = "version";
+    }
+
+    // DataColumns接口，定义了存储笔记相关数据的数据表（可能是更详细的数据表，与NoteColumns对应的主表有所区分）中各列的列名常量
+    public interface DataColumns {
+        /**
+         * 表示一行数据的唯一ID，长整型，用于唯一标识每一条数据记录
+         * <P> Type: INTEGER (long) </P>
+         */
+        public static final String ID = "_id";
+
+        /**
+         * 该行数据所代表的项的MIME类型，文本（TEXT）类型，用于标识数据的具体格式、性质等，比如是文本、图片等不同类型的数据
+         * <P> Type: Text </P>
+         */
+        public static final String MIME_TYPE = "mime_type";
+
+        /**
+         * 该数据所属笔记的引用ID，长整型，建立数据与对应笔记之间的关联关系，方便查找和管理属于某条笔记的具体数据
+         * <P> Type: INTEGER (long) </P>
+         */
+        public static final String NOTE_ID = "note_id";
+
+        /**
+         * 数据的创建日期，长整型，记录数据创建的时间信息
+         * <P> Type: INTEGER (long) </P>
+         */
+        public static final String CREATED_DATE = "created_date";
+
+        /**
+         * 数据的最近修改日期，长整型，用于跟踪数据的更新情况
+         * <P> Type: INTEGER (long) </P>
+         */
+        public static final String MODIFIED_DATE = "modified_date";
+
+        /**
+         * 数据的具体内容，文本（TEXT）类型，实际存储的数据文本信息等就放在这一列（根据不同MIME类型可能有不同的格式和含义）
+         * <P> Type: TEXT </P>
+         */
+        public static final String CONTENT = "content";
+
+        /**
+         * 通用数据列，其含义根据 {@link #MIMETYPE} 具体确定，用于整数数据类型，整型
+         * <P> Type: INTEGER </P>
+         */
+        public static final String DATA1 = "data1";
+
+        /**
+         * 通用数据列，其含义根据 {@link #MIMETYPE} 具体确定，用于整数数据类型，整型
+         * <P> Type: INTEGER </P>
+         */
+        public static final String DATA2 = "data2";
+
+        /**
+         * 通用数据列，其含义根据 {@link #MIMETYPE} 具体确定，用于文本数据类型，文本（TEXT）类型
+         * <P> Type: TEXT </P>
+         */
+        public static final String DATA3 = "data3";
+
+        /**
+         * 通用数据列，其含义根据 {@link #MIMETYPE} 具体确定，用于文本数据类型，文本（TEXT）类型
+         * <P> Type: TEXT </P>
+         */
+        public static final String DATA4 = "data4";
+
+        /**
+         * 通用数据列，其含义根据 {@link #MIMETYPE} 具体确定，用于文本数据类型，文本（TEXT）类型
+         * <P> Type: TEXT </P>
+         */
+        public static final String DATA5 = "data5";
+    }
+
+    // TextNote内部类，继承自DataColumns接口，主要用于定义文本笔记相关的特定属性、常量以及内容资源标识符（Uri）等信息
+    public static final class TextNote implements DataColumns {
+        /**
+         * 用于指示文本是否处于复选框列表模式的标志，整型，1表示处于复选框列表模式，0表示正常文本模式
+         * <P> Type: Integer 1:check list mode 0: normal mode </P>
+         */
+        public static final String MODE = DATA1;
+
+        public static final int MODE_CHECK_LIST = 1;
+
+        // 表示文本笔记的内容类型，用于在内容提供器等场景标识该类型数据，格式符合Android的MIME类型规范
+        public static final String CONTENT_TYPE = "vnd.android.cursor.dir/text_note";
+
+        // 表示文本笔记的单个项目的内容类型，同样符合MIME类型规范，用于更具体的指向文本笔记中的单个条目
+        public static final String CONTENT_ITEM_TYPE = "vnd.android.cursor.item/text_note";
+
+        // 用于访问文本笔记相关数据的统一资源标识符（Uri），基于应用授权（AUTHORITY）和特定路径（"/text_note"）构建
+        public static final Uri CONTENT_URI = Uri.parse("content://" + AUTHORITY + "/text_note");
+    }
+
+    // CallNote内部类，同样继承自DataColumns接口，用于定义通话记录笔记相关的特定属性、常量以及内容资源标识符（Uri）等内容
+    public static final class CallNote implements DataColumns {
+        /**
+         * 通话记录的通话日期，长整型，用于记录通话发生的时间信息
+         * <P> Type: INTEGER (long) </P>
+         */
+        public static final String CALL_DATE = DATA1;
+
+        /**
+         * 通话记录对应的电话号码，文本（TEXT）类型，存储通话的对方号码等信息
+         * <P> Type: TEXT </P>
+         */
+        public static final String PHONE_NUMBER = DATA3;
+
+        // 表示通话记录笔记的内容类型，符合MIME类型规范，用于标识该类型数据在内容提供器中的类型
+        public static final String CONTENT_TYPE = "vnd.android.cursor.dir/call_note";
+
+        // 表示通话记录笔记单个项目的内容类型，符合MIME类型规范，用于更具体指向通话记录笔记中的单个条目
+        public static final String CONTENT_ITEM_TYPE = "vnd.android.cursor.item/call_note";
+
+        // 用于访问通话记录笔记相关数据的统一资源标识符（Uri），基于应用授权（AUTHORITY）和特定路径（"/call_note"）构建
+        public static final Uri CONTENT_URI = Uri.parse("content://" + AUTHORITY + "/call_note");
+    }
+}

NotesDatabaseHelper.java

@@ -0,0 +1,279 @@
+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;
+
+// NotesDatabaseHelper类继承自SQLiteOpenHelper，用于管理与笔记相关的数据库的创建、升级等操作
+// 它负责创建笔记表、数据表以及相关的触发器，处理数据库版本更新等功能
+public class NotesDatabaseHelper extends SQLiteOpenHelper {
+
+    // 定义数据库文件名
+    private static final String DB_NAME = "note.db";
+
+    // 定义数据库版本号，用于数据库升级时的版本判断等操作
+    private static final int DB_VERSION = 4;
+
+    // 定义内部接口TABLE，用于存放数据库中表的名称常量，方便在代码中统一引用表名，提高可读性和可维护性
+    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;
+
+    // 创建笔记表（TABLE.NOTE）的SQL语句，定义了表的各个列名、数据类型、默认值以及主键等信息
+    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" +
+                    ")";
+
+    // 创建数据表（TABLE.DATA）的SQL语句，同样定义了表的各列信息，用于存储与笔记相关的数据内容等
+    private static final String CREATE_DATA_TABLE_SQL =
+            "CREATE TABLE " + TABLE.DATA + "(" +
+                    DataColumns.ID + " INTEGER PRIMARY KEY," +
+                    DataColumns.MIME_TYPE + " TEXT NOT NULL," +
+                    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 ''," +
+                    DataColumns.DATA1 + " INTEGER," +
+                    DataColumns.DATA2 + " INTEGER," +
+                    DataColumns.DATA3 + " TEXT NOT NULL DEFAULT ''," +
+                    DataColumns.DATA4 + " TEXT NOT NULL DEFAULT ''," +
+                    DataColumns.DATA5 + " TEXT NOT NULL DEFAULT ''" +
+                    ")";
+
+    // 创建基于数据表（TABLE.DATA）中笔记ID（DataColumns.NOTE_ID）字段的索引的SQL语句，用于提高根据笔记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 + ");";
+
+    /**
+     * 以下是一系列用于数据库操作的触发器（Trigger）相关的SQL语句定义，触发器用于在特定数据库操作发生时自动执行一些额外的逻辑。
+     * 例如，在更新、插入、删除笔记或数据时，对相关的计数、关联数据等进行相应的调整。
+     */
+
+    /**
+     * 当笔记移动到某个文件夹（更新NoteColumns.PARENT_ID字段）后，增加该文件夹的笔记数量的触发器SQL语句。
+     * 它在TABLE.NOTE表的NoteColumns.PARENT_ID字段更新后触发，通过更新语句增加目标文件夹（新的父文件夹）的NoteColumns.NOTES_COUNT字段值。
+     */
+    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";
+
+    /**
+     * 当笔记从某个文件夹移出（更新NoteColumns.PARENT_ID字段）后，减少该文件夹的笔记数量的触发器SQL语句。
+     * 在TABLE.NOTE表的NoteColumns.PARENT_ID字段更新后触发，条件是原文件夹的NoteColumns.NOTES_COUNT大于0时，减少其数量。
+     */
+    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";
+
+    /**
+     * 当向某个文件夹插入新笔记后，增加该文件夹的笔记数量的触发器SQL语句。
+     * 在TABLE.NOTE表插入新记录后触发，通过更新语句增加新笔记所属文件夹（根据NoteColumns.PARENT_ID确定）的NoteColumns.NOTES_COUNT字段值。
+     */
+    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";
+
+    /**
+     * 当从某个文件夹删除笔记后，减少该文件夹的笔记数量的触发器SQL语句。
+     * 在TABLE.NOTE表删除记录后触发，条件是原文件夹的NoteColumns.NOTES_COUNT大于0时，减少其数量，基于原笔记所属文件夹ID进行操作。
+     */
+    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";
+
+    /**
+     * 当向数据表（TABLE.DATA）插入类型为{@link DataConstants#NOTE}的数据时，更新对应笔记的内容（NoteColumns.SNIPPET字段）的触发器SQL语句。
+     * 在TABLE.DATA表插入记录后触发，且插入的数据类型符合条件时，将对应笔记的内容设置为新插入数据的内容（DataColumns.CONTENT字段）。
+     */
+    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";
+
+    /**
+     * 当数据表（TABLE.DATA）中类型为{@link DataConstants#NOTE}的数据发生更新时，更新对应笔记的内容（NoteColumns.SNIPPET字段）的触发器SQL语句。
+     * 在TABLE.DATA表更新记录且符合数据类型条件时，将对应笔记的内容更新为新的数据内容（DataColumns.CONTENT字段）。
+     */
+    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";
+
+    /**
+     * 当数据表（TABLE.DATA）中类型为{@link DataConstants#NOTE}的数据被删除时，更新对应笔记的内容（NoteColumns.SNIPPET字段）为默认空值的触发器SQL语句。
+     * 在TABLE.DATA表删除记录且符合数据类型条件时，将对应笔记的内容设置为空字符串。
+     */
+    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";
+
+    /**
+     * 当笔记被删除后，删除与之关联的数据表（TABLE.DATA）中属于该笔记的数据的触发器SQL语句。
+     * 在TABLE.NOTE表删除记录后触发，通过删除语句从TABLE.DATA表中删除NoteColumns.ID与被删除笔记的ID匹配的数据记录。
+     */
+    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";
+
+    /**
+     * 当文件夹被删除后，删除该文件夹下所有笔记的触发器SQL语句。
+     * 在TABLE.NOTE表删除记录（即文件夹记录被删除）后触发，通过删除语句从TABLE.NOTE表中删除NoteColumns.PARENT_ID与被删除文件夹的ID匹配的笔记记录。
+     */
+    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";
+
+    /**
+     * 当文件夹被移动到回收站文件夹（更新NoteColumns.PARENT_ID字段）后，将该文件夹下所有笔记也移动到回收站文件夹的触发器SQL语句。
+     * 在TABLE.NOTE表更新记录且新的父文件夹ID为回收站文件夹ID（Notes.ID_TRASH_FOLER）时触发，将对应笔记的父文件夹ID都更新为回收站文件夹ID。
+     */
+    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";
+
+    // NotesDatabaseHelper构造函数，调用父类（SQLiteOpenHelper）的构造函数，传入上下文、数据库名、游标工厂（这里为null）和数据库版本号
+    public NotesDatabaseHelper(Context context) {
+        super(context, DB_NAME, null, DB_VERSION);
+    }
+
+    // 创建笔记表的方法，接收一个SQLiteDatabase实例，通过执行CREATE_NOTE_TABLE_SQL语句创建表，
+    // 然后重新创建笔记表相关的触发器，并创建系统文件夹，最后记录日志表示笔记表已创建成功
+    public void createNoteTable(SQLiteDatabase db) {
+        db.execSQL(CREATE_NOTE_TABLE_SQL);
+        reCreateNoteTableTriggers(db);
+        createSystemFolder(db);
+        Log.d(TAG, "note table has been created");
+    }
+
+    // 重新创建笔记表相关触发器的方法，先删除已存在的同名触发器（如果有），然后再执行创建各触发器的SQL语句，
+    // 这样可以确保触发器的定义是最新的，避免因数据库结构变化等原因导致的问题
+    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);
+    }
+
+    // 创建系统文件夹的方法，通过向笔记表（TABLE.NOTE）插入不同类型的系统文件夹记录来实现，
+    // 每个文件夹记录设置了相应的ID和类型（Notes.TYPE_SYSTEM），用于构建应用中的默认文件夹结构
+    private void createSystemFolder(SQLiteDatabase db) {
+        ContentValues values = new ContentValues();
+
+        /**
+         * 通话记录文件夹，用于存放通话相关的笔记（这里假设是相关功能用途）
+         */
+        values.put(NoteColumns.ID, Notes.ID_CALL_RECORD_FOLDER);
+        values.put(NoteColumns.TYPE, Notes.TYPE_SYSTEM);
+        db.insert(TABLE.NOTE, null, values);
+
+        /**
+         * 根文件夹，作为默认的顶级文件夹
+         */
+        values.clear();
+        values.put(NoteColumns.ID, Notes.ID_ROOT_FOLDER);
+        values.put(NoteColumns.TYPE, Notes.TYPE_SYSTEM);
+        db.insert(TABLE.NOTE, null, values);
+
+        /**
+         * 临时文件夹，可能用于在笔记移动等操作过程中的临时存放
+         */
+        values.clear();
+        values.put(NoteColumns.ID, Notes.ID_TEMPARAY_FOLDER);
+        values.put(NoteColumns.TYPE, Notes.TYPE_SYSTEM);

NotesProvider.java

@@ -0,0 +1,300 @@
+package net.micode.notes.data;
+
+import android.app.SearchManager;
+import android.content.ContentProvider;
+import android.content.ContentUris;
+import android.content.ContentValues;
+import android.content.Intent;
+import android.content.UriMatcher;
+import android.database.Cursor;
+import android.database.sqlite.SQLiteDatabase;
+import android.net.Uri;
+import android.text.TextUtils;
+import android.util.Log;
+
+import net.micode.notes.R;
+import net.micode.notes.data.Notes.DataColumns;
+import net.micode.notes.data.Notes.NoteColumns;
+import net.micode.notes.data.NotesDatabaseHelper.TABLE;
+
+// NotesProvider类继承自ContentProvider，是Android中用于在不同应用组件间共享数据的抽象基类
+// 本类主要负责处理与笔记相关的数据操作，如查询、插入、删除、更新等，并与底层数据库进行交互
+public class NotesProvider extends ContentProvider {
+
+    // UriMatcher用于根据传入的Uri来匹配相应的操作码，以确定要执行何种数据操作
+    // 这里定义为静态成员变量，方便在类的不同方法中使用相同的匹配规则来判断Uri类型
+    private static final UriMatcher mMatcher;
+
+    // NotesDatabaseHelper的实例，用于辅助进行数据库相关操作，例如获取数据库连接、执行SQL语句等
+    private NotesDatabaseHelper mHelper;
+
+    // 用于日志记录的标签，方便在查看日志时快速识别是该类中输出的日志信息
+    private static final String TAG = "NotesProvider";
+
+    // 以下定义了不同的整数常量，作为不同类型Uri的匹配码，用于区分不同的请求路径对应的操作
+    private static final int URI_NOTE = 1;
+    private static final int URI_NOTE_ITEM = 2;
+    private static final int URI_DATA = 3;
+    private static final int URI_DATA_ITEM = 4;
+    private static final int URI_SEARCH = 5;
+    private static final int URI_SEARCH_SUGGEST = 6;
+
+    // 静态初始化块，用于初始化UriMatcher，添加各种不同格式的Uri匹配规则
+    // 通过这些规则，后续可以根据传入的Uri快速判断其对应的操作类型
+    static {
+        mMatcher = new UriMatcher(UriMatcher.NO_MATCH);
+        // 添加匹配规则，当Uri的权限（Authority）为Notes.AUTHORITY，路径为"note"时，匹配码为URI_NOTE
+        // 通常用于对所有笔记进行批量操作的请求
+        mMatcher.addURI(Notes.AUTHORITY, "note", URI_NOTE);
+        // 当Uri的权限为Notes.AUTHORITY，路径为"note/数字"（#表示数字占位符）时，匹配码为URI_NOTE_ITEM
+        // 一般用于对单个笔记进行操作的请求，数字部分对应具体笔记的ID
+        mMatcher.addURI(Notes.AUTHORITY, "note/#", URI_NOTE_ITEM);
+        mMatcher.addURI(Notes.AUTHORITY, "data", URI_DATA);
+        mMatcher.addURI(Notes.AUTHORITY, "data/#", URI_DATA_ITEM);
+        mMatcher.addURI(Notes.AUTHORITY, "search", URI_SEARCH);
+        // 为搜索建议相关的Uri添加匹配规则，用于处理搜索建议的请求路径
+        mMatcher.addURI(Notes.AUTHORITY, SearchManager.SUGGEST_URI_PATH_QUERY, URI_SEARCH_SUGGEST);
+        mMatcher.addURI(Notes.AUTHORITY, SearchManager.SUGGEST_URI_PATH_QUERY + "/*", URI_SEARCH_SUGGEST);
+    }
+
+    // 定义用于搜索结果投影（Projection）的字符串，指定了从数据库查询搜索结果时要返回的列及格式
+    // 这里涉及到将笔记的一些字段进行处理后返回，例如去除换行符、设置图标、指定意图相关信息等
+    // 以便符合搜索结果展示和后续操作的要求
+    private static final String NOTES_SEARCH_PROJECTION = NoteColumns.ID + ","
+            + NoteColumns.ID + " AS " + SearchManager.SUGGEST_COLUMN_INTENT_EXTRA_DATA + ","
+            + "TRIM(REPLACE(" + NoteColumns.SNIPPET + ", x'0A','')) AS " + SearchManager.SUGGEST_COLUMN_TEXT_1 + ","
+            + "TRIM(REPLACE(" + NoteColumns.SNIPPET + ", x'0A','')) AS " + SearchManager.SUGGEST_COLUMN_TEXT_2 + ","
+            + R.drawable.search_result + " AS " + SearchManager.SUGGEST_COLUMN_ICON_1 + ","
+            + "'" + Intent.ACTION_VIEW + "' AS " + SearchManager.SUGGEST_COLUMN_INTENT_ACTION + ","
+            + "'" + Notes.TextNote.CONTENT_TYPE + "' AS " + SearchManager.SUGGEST_COLUMN_INTENT_DATA;
+
+    // 定义用于查询笔记片段搜索的SQL语句模板，基于上面的投影字符串构建
+    // 根据笔记片段（SNIPPET）字段进行模糊匹配查询，同时添加了一些筛选条件，如排除回收站文件夹、只查询笔记类型等
+    private static String NOTES_SNIPPET_SEARCH_QUERY = "SELECT " + NOTES_SEARCH_PROJECTION
+            + " FROM " + TABLE.NOTE
+            + " WHERE " + NoteColumns.SNIPPET + " LIKE?"
+            + " AND " + NoteColumns.PARENT_ID + "<>" + Notes.ID_TRASH_FOLER
+            + " AND " + NoteColumns.TYPE + "=" + Notes.TYPE_NOTE;
+
+    // 重写ContentProvider的onCreate方法，在内容提供器创建时调用
+    // 主要用于初始化NotesDatabaseHelper实例，获取数据库操作的辅助对象，若初始化成功则返回true表示创建成功
+    @Override
+    public boolean onCreate() {
+        mHelper = NotesDatabaseHelper.getInstance(getContext());
+        return true;
+    }
+
+    // 重写ContentProvider的query方法，用于处理数据查询请求
+    // 根据传入的Uri、投影、选择条件等参数，从数据库中查询相应的数据并返回结果集（Cursor）
+    @Override
+    public Cursor query(Uri uri, String[] projection, String selection, String[] selectionArgs,
+                        String sortOrder) {
+        Cursor c = null;
+        // 获取可读数据库实例，用于执行查询操作，确保不会对数据库进行写操作
+        SQLiteDatabase db = mHelper.getReadableDatabase();
+        String id = null;
+        // 使用UriMatcher匹配传入的Uri，根据匹配结果执行不同的查询逻辑
+        switch (mMatcher.match(uri)) {
+            case URI_NOTE:
+                // 如果是URI_NOTE类型的Uri，直接对笔记表（TABLE.NOTE）进行查询，使用传入的投影、选择条件等参数
+                c = db.query(TABLE.NOTE, projection, selection, selectionArgs, null, null,
+                        sortOrder);
+                break;
+            case URI_NOTE_ITEM:
+                // 如果是URI_NOTE_ITEM类型的Uri，先获取路径中的笔记ID（即uri.getPathSegments().get(1)）
+                // 然后在查询笔记表时添加基于笔记ID的筛选条件，确保查询的是指定ID的单个笔记
+                id = uri.getPathSegments().get(1);
+                c = db.query(TABLE.NOTE, projection, NoteColumns.ID + "=" + id
+                        + parseSelection(selection), selectionArgs, null, null, sortOrder);
+                break;
+            case URI_DATA:
+                // 针对URI_DATA类型的Uri，对数据表（TABLE.DATA）进行查询，同样使用传入的相关参数
+                c = db.query(TABLE.DATA, projection, selection, selectionArgs, null, null,
+                        sortOrder);
+                break;
+            case URI_DATA_ITEM:
+                // 对于URI_DATA_ITEM类型的Uri，获取路径中的数据ID，然后在查询数据表时添加基于该数据ID的筛选条件
+                id = uri.getPathSegments().get(1);
+                c = db.query(TABLE.DATA, projection, DataColumns.ID + "=" + id
+                        + parseSelection(selection), selectionArgs, null, null, sortOrder);
+                break;
+            case URI_SEARCH:
+            case URI_SEARCH_SUGGEST:
+                // 如果是搜索或搜索建议相关的Uri类型
+                if (sortOrder!= null || projection!= null) {
+                    // 若传入了排序顺序或投影参数，则抛出异常，因为对于这种类型的查询不应该指定这些参数
+                    throw new IllegalArgumentException(
+                            "do not specify sortOrder, selection, selectionArgs, or projection" + "with this query");
+                }
+
+                String searchString = null;
+                // 根据具体是搜索还是搜索建议的Uri类型，获取不同方式传入的搜索字符串
+                if (mMatcher.match(uri) == URI_SEARCH_SUGGEST) {
+                    if (uri.getPathSegments().size() > 1) {
+                        searchString = uri.getPathSegments().get(1);
+                    }
+                } else {
+                    searchString = uri.getQueryParameter("pattern");
+                }
+
+                if (TextUtils.isEmpty(searchString)) {
+                    // 如果搜索字符串为空，则直接返回null，因为没有内容可查询
+                    return null;
+                }
+
+                try {
+                    // 对搜索字符串进行格式化，添加模糊匹配的通配符（%），用于构建模糊查询条件
+                    searchString = String.format("%%%s%%", searchString);
+                    // 使用格式化后的搜索字符串，执行原始的SQL查询语句（NOTES_SNIPPET_SEARCH_QUERY）来获取搜索结果
+                    c = db.rawQuery(NOTES_SNIPPET_SEARCH_QUERY,
+                            new String[] { searchString });
+                } catch (IllegalStateException ex) {
+                    // 如果在查询过程中出现异常，记录错误日志
+                    Log.e(TAG, "got exception: " + ex.toString());
+                }
+                break;
+            default:
+                // 如果传入的Uri无法匹配任何已知的类型，则抛出异常，表示未知的Uri请求
+                throw new IllegalArgumentException("Unknown URI " + uri);
+        }
+        if (c!= null) {
+            // 如果查询到了有效的结果集（Cursor），设置通知Uri，以便在数据变化时通知相关观察者
+            c.setNotificationUri(getContext().getContentResolver(), uri);
+        }
+        return c;
+    }
+
+    // 重写ContentProvider的insert方法，用于处理数据插入请求
+    // 根据传入的Uri和要插入的数据（ContentValues），将数据插入到相应的数据库表中，并返回插入后数据的Uri
+    @Override
+    public Uri insert(Uri uri, ContentValues values) {
+        SQLiteDatabase db = mHelper.getWritableDatabase();
+        long dataId = 0, noteId = 0, insertedId = 0;
+        // 使用UriMatcher匹配传入的Uri，根据匹配结果执行不同的插入逻辑
+        switch (mMatcher.match(uri)) {
+            case URI_NOTE:
+                // 如果是URI_NOTE类型的Uri，直接向笔记表（TABLE.NOTE）插入数据，获取插入后笔记的ID
+                insertedId = noteId = db.insert(TABLE.NOTE, null, values);
+                break;
+            case URI_DATA:
+                // 对于URI_DATA类型的Uri，先检查要插入的数据中是否包含笔记ID（DataColumns.NOTE_ID）
+                if (values.containsKey(DataColumns.NOTE_ID)) {
+                    noteId = values.getAsLong(DataColumns.NOTE_ID);
+                } else {
+                    // 如果没有笔记ID，则记录警告日志，表示数据格式错误
+                    Log.d(TAG, "Wrong data format without note id:" + values.toString());
+                }
+                // 向数据表（TABLE.DATA）插入数据，获取插入后数据的ID
+                insertedId = dataId = db.insert(TABLE.DATA, null, values);
+                break;
+            default:
+                // 如果传入的Uri无法匹配任何已知的类型，则抛出异常，表示未知的Uri请求
+                throw new IllegalArgumentException("Unknown URI " + uri);
+        }
+        // 如果插入的笔记ID大于0，即成功插入了笔记数据，通知与笔记相关的Uri发生了变化
+        // 以便相关观察者（如使用ContentObserver监听的组件）可以做出响应
+        if (noteId > 0) {
+            getContext().getContentResolver().notifyChange(
+                    ContentUris.withAppendedId(Notes.CONTENT_NOTE_URI, noteId), null);
+        }
+
+        // 如果插入的数据ID大于0，即成功插入了数据，通知与数据相关的Uri发生了变化
+        if (dataId > 0) {
+            getContext().getContentResolver().notifyChange(
+                    ContentUris.withAppendedId(Notes.CONTENT_DATA_URI, dataId), null);
+        }
+
+        // 返回插入数据后对应的Uri，通过在原始Uri基础上添加插入数据的ID构建
+        return ContentUris.withAppendedId(uri, insertedId);
+    }
+
+    // 重写ContentProvider的delete方法，用于处理数据删除请求
+    // 根据传入的Uri、选择条件等参数，从相应的数据库表中删除匹配的数据，并返回删除的行数
+    @Override
+    public int delete(Uri uri, String selection, String[] selectionArgs) {
+        int count = 0;
+        String id = null;
+        SQLiteDatabase db = mHelper.getWritableDatabase();
+        boolean deleteData = false;
+        // 使用UriMatcher匹配传入的Uri，根据匹配结果执行不同的删除逻辑
+        switch (mMatcher.match(uri)) {
+            case URI_NOTE:
+                // 如果是URI_NOTE类型的Uri，在原选择条件基础上添加笔记ID大于0的条件（确保删除合法的笔记记录）
+                // 然后从笔记表（TABLE.NOTE）中删除匹配的数据，获取删除的行数
+                selection = "(" + selection + ") AND " + NoteColumns.ID + ">0 ";
+                count = db.delete(TABLE.NOTE, selection, selectionArgs);
+                break;
+            case URI_NOTE_ITEM:
+                // 如果是URI_NOTE_ITEM类型的Uri，获取路径中的笔记ID
+                id = uri.getPathSegments().get(1);
+                /**
+                 * ID小于等于0的是系统文件夹，不允许删除（移动到回收站），这里进行判断跳过此类操作
+                 */
+                long noteId = Long.valueOf(id);
+                if (noteId <= 0) {
+                    break;
+                }
+                // 根据笔记ID从笔记表中删除相应的记录，获取删除的行数
+                count = db.delete(TABLE.NOTE,
+                        NoteColumns.ID + "=" + id + parseSelection(selection), selectionArgs);
+                break;
+            case URI_DATA:
+                // 针对URI_DATA类型的Uri，从数据表（TABLE.DATA）中删除匹配的数据，获取删除的行数，并标记正在删除数据
+                count = db.delete(TABLE.DATA, selection, selectionArgs);
+                deleteData = true;
+                break;
+            case URI_DATA_ITEM:
+                // 对于URI_DATA_ITEM类型的Uri，获取路径中的数据ID，然后从数据表中删除相应的数据记录，获取删除的行数，并标记正在删除数据
+                id = uri.getPathSegments().get(1);
+                count = db.delete(TABLE.DATA,
+                        DataColumns.ID + "=" + id + parseSelection(selection), selectionArgs);
+                deleteData = true;
+                break;
+            default:
+                // 如果传入的Uri无法匹配任何已知的类型，则抛出异常，表示未知的Uri请求
+                throw new IllegalArgumentException("Unknown URI " + uri);
+        }
+        if (count > 0) {
+            // 如果成功删除了数据（删除行数大于0）
+            if (deleteData) {
+                // 如果正在删除数据，通知与笔记相关的Uri发生了变化，因为数据的变化可能影响到笔记相关的展示等情况
+                getContext().getContentResolver().notifyChange(Notes.CONTENT_NOTE_URI, null);
+            }
+            // 通知与当前操作的Uri发生了变化，以便相关观察者做出响应
+            getContext().getContentResolver().notifyChange(uri, null);
+        }
+        return count;
+    }
+
+    // 重写ContentProvider的update方法，用于处理数据更新请求
+    // 根据传入的Uri、要更新的数据（ContentValues）、选择条件等参数，更新相应数据库表中的数据，并返回更新的行数
+    @Override
+    public int update(Uri uri, ContentValues values, String selection, String[] selectionArgs) {
+        int count = 0;
+        String id = null;
+        SQLiteDatabase db = mHelper.getWritableDatabase();
+        boolean updateData = false;
+        // 使用UriMatcher匹配传入的Uri，根据匹配结果执行不同的更新逻辑
+        switch (mMatcher.match(uri)) {
+            case URI_NOTE:
+                // 如果是URI_NOTE类型的Uri，先调用increaseNoteVersion方法来更新笔记的版本号（可能用于版本控制等逻辑）
+                increaseNoteVersion(-1, selection, selectionArgs);
+                // 然后根据传入的参数更新笔记表（TABLE.NOTE）中的数据，获取更新的行数
+                count = db.update(TABLE.NOTE, values, selection, selectionArgs);
+                break;
+            case URI_NOTE_ITEM:
+                // 如果是URI_NOTE_ITEM类型的Uri，获取路径中的笔记ID
+                id = uri.getPathSegments().get(1);
+                // 调用increaseNoteVersion方法根据笔记ID来更新笔记的版本号
+                increaseNoteVersion(Long.valueOf(id), selection, selectionArgs);
+                // 根据笔记ID和其他传入参数更新笔记表中的相应记录，获取更新的行数
+                count = db.update(TABLE.NOTE, values, NoteColumns.ID + "=" + id
+                        + parseSelection(selection), selectionArgs);
+                break;
+            case URI_DATA:
+                // 针对URI_DATA类型的Uri，直接根据传入参数更新数据表（TABLE.DATA）中的数据，获取更新的行数，并标记正在更新数据
+                count = db.update(TABLE.DATA, values, selection, selectionArgs);
+                updateData = true;
+                break;
+            case URI_DATA_ITEM:
+                // 对于

ResourceParser.java

@@ -0,0 +1,222 @@
+/*
+ * 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.tool;
+
+import android.content.Context;
+import android.preference.PreferenceManager;
+
+import net.micode.notes.R;
+import net.micode.notes.ui.NotesPreferenceActivity;
+
+// ResourceParser类主要用于解析和提供应用中各种与资源相关的信息，例如背景颜色、字体大小以及不同界面元素对应的资源ID等，方便在应用的不同地方统一获取和使用这些资源相关设置
+public class ResourceParser {
+
+    // 定义表示黄色的常量，用于标识某种颜色选项，可能在背景颜色等设置中使用，值为0，可作为索引或标识值
+    public static final int YELLOW = 0;
+    // 定义表示蓝色的常量，类似黄色的作用，用于区分不同颜色选项，值为1
+    public static final int BLUE = 1;
+    // 定义表示白色的常量，值为2
+    public static final int WHITE = 2;
+    // 定义表示绿色的常量，值为3
+    public static final int GREEN = 3;
+    // 定义表示红色的常量，值为4
+    public static final int RED = 4;
+
+    // 定义默认的背景颜色的常量，初始设置为黄色（对应前面定义的YELLOW常量值），表示在没有特定设置时的默认背景颜色选项
+    public static final int BG_DEFAULT_COLOR = YELLOW;
+
+    // 定义表示小字体的常量，用于字体大小相关的标识，值为0
+    public static final int TEXT_SMALL = 0;
+    // 定义表示中字体的常量，值为1
+    public static final int TEXT_MEDIUM = 1;
+    // 定义表示大字体的常量，值为2
+    public static final int TEXT_LARGE = 2;
+    // 定义表示超大字体的常量，值为3
+    public static final int TEXT_SUPER = 3;
+
+    // 定义默认的字体大小的常量，初始设置为中字体（对应前面定义的TEXT_MEDIUM常量值），表示在没有特定设置时的默认字体大小选项
+    public static final int BG_DEFAULT_FONT_SIZE = TEXT_MEDIUM;
+
+    // 内部静态类NoteBgResources，用于管理笔记编辑界面相关的背景资源，例如背景图片资源ID等
+    public static class NoteBgResources {
+        // 定义一个静态的整数数组，存储笔记编辑界面背景图片资源ID，对应不同的颜色选项（按顺序依次对应前面定义的颜色常量顺序）
+        private final static int[] BG_EDIT_RESOURCES = new int[] {
+                R.drawable.edit_yellow,
+                R.drawable.edit_blue,
+                R.drawable.edit_white,
+                R.drawable.edit_green,
+                R.drawable.edit_red
+        };
+
+        // 定义一个静态的整数数组，存储笔记编辑界面标题背景图片资源ID，同样对应不同的颜色选项
+        private final static int[] BG_EDIT_TITLE_RESOURCES = new int[] {
+                R.drawable.edit_title_yellow,
+                R.drawable.edit_title_blue,
+                R.drawable.edit_title_white,
+                R.drawable.edit_title_green,
+                R.drawable.edit_title_red
+        };
+
+        // 静态方法，根据传入的索引id获取笔记编辑界面的背景图片资源ID，返回对应的BG_EDIT_RESOURCES数组中的元素（即资源ID）
+        public static int getNoteBgResource(int id) {
+            return BG_EDIT_RESOURCES[id];
+        }
+
+        // 静态方法，根据传入的索引id获取笔记编辑界面标题的背景图片资源ID，返回对应的BG_EDIT_TITLE_RESOURCES数组中的元素（即资源ID）
+        public static int getNoteTitleBgResource(int id) {
+            return BG_EDIT_TITLE_RESOURCES[id];
+        }
+    }
+
+    // 静态方法，用于获取默认的背景颜色对应的ID值，根据应用的偏好设置（Preference）来决定返回值
+    public static int getDefaultBgId(Context context) {
+        // 获取应用默认的共享偏好设置对象，通过它可以读取用户之前设置的各种偏好选项
+        if (PreferenceManager.getDefaultSharedPreferences(context).getBoolean(
+                NotesPreferenceActivity.PREFERENCE_SET_BG_COLOR_KEY, false)) {
+            // 如果用户设置了特定的背景颜色选项（通过对应的偏好设置键值判断，这里假设为PREFERENCE_SET_BG_COLOR_KEY，值为true表示已设置）
+            // 则随机生成一个索引值（范围是NoteBgResources类中背景资源数组的长度范围内），作为返回的背景颜色ID
+            return (int) (Math.random() * NoteBgResources.BG_EDIT_RESOURCES.length);
+        } else {
+            // 如果用户没有设置特定的背景颜色选项，则返回默认的背景颜色ID（前面定义的BG_DEFAULT_COLOR）
+            return BG_DEFAULT_COLOR;
+        }
+    }
+
+    // 内部静态类NoteItemBgResources，用于管理笔记列表项相关的背景资源，如不同位置（首个、中间、最后等）的背景图片资源ID
+    public static class NoteItemBgResources {
+        // 定义一个静态的整数数组，存储笔记列表项首个位置的背景图片资源ID，对应不同的颜色选项
+        private final static int[] BG_FIRST_RESOURCES = new int[] {
+                R.drawable.list_yellow_up,
+                R.drawable.list_blue_up,
+                R.drawable.list_white_up,
+                R.drawable.list_green_up,
+                R.drawable.list_red_up
+        };
+
+        // 定义一个静态的整数数组，存储笔记列表项中间位置的背景图片资源ID，对应不同的颜色选项
+        private final static int[] BG_NORMAL_RESOURCES = new int[] {
+                R.drawable.list_yellow_middle,
+                R.drawable.list_blue_middle,
+                R.drawable.list_white_middle,
+                R.drawable.list_green_middle,
+                R.drawable.list_red_middle
+        };
+
+        // 定义一个静态的整数数组，存储笔记列表项最后位置的背景图片资源ID，对应不同的颜色选项
+        private final static int[] BG_LAST_RESOURCES = new int[] {
+                R.drawable.list_yellow_down,
+                R.drawable.list_blue_down,
+                R.drawable.list_white_down,
+                R.drawable.list_green_down,
+                R.drawable.list_red_down,
+        };
+
+        // 定义一个静态的整数数组，存储笔记列表项单个显示时（可能没有前后相邻项的情况）的背景图片资源ID，对应不同的颜色选项
+        private final static int[] BG_SINGLE_RESOURCES = new int[] {
+                R.drawable.list_yellow_single,
+                R.drawable.list_blue_single,
+                R.drawable.list_white_single,
+                R.drawable.list_green_single,
+                R.drawable.list_red_single
+        };
+
+        // 静态方法，根据传入的索引id获取笔记列表项首个位置的背景图片资源ID，返回对应的BG_FIRST_RESOURCES数组中的元素（即资源ID）
+        public static int getNoteBgFirstRes(int id) {
+            return BG_FIRST_RESOURCES[id];
+        }
+
+        // 静态方法，根据传入的索引id获取笔记列表项最后位置的背景图片资源ID，返回对应的BG_LAST_RESOURCES数组中的元素（即资源ID）
+        public static int getNoteBgLastRes(int id) {
+            return BG_LAST_RESOURCES[id];
+        }
+
+        // 静态方法，根据传入的索引id获取笔记列表项单个显示时的背景图片资源ID，返回对应的BG_SINGLE_RESOURCES数组中的元素（即资源ID）
+        public static int getNoteBgSingleRes(int id) {
+            return BG_SINGLE_RESOURCES[id];
+        }
+
+        // 静态方法，根据传入的索引id获取笔记列表项中间位置的背景图片资源ID，返回对应的BG_NORMAL_RESOURCES数组中的元素（即资源ID）
+        public static int getNoteBgNormalRes(int id) {
+            return BG_NORMAL_RESOURCES[id];
+        }
+
+        // 静态方法，获取文件夹的背景图片资源ID，返回固定的文件夹背景图片资源ID（这里假设为R.drawable.list_folder）
+        public static int getFolderBgRes() {
+            return R.drawable.list_folder;
+        }
+    }
+
+    // 内部静态类WidgetBgResources，用于管理应用小部件（Widget）相关的背景资源，如不同尺寸小部件对应的背景图片资源ID
+    public static class WidgetBgResources {
+        // 定义一个静态的整数数组，存储2x尺寸小部件的背景图片资源ID，对应不同的颜色选项
+        private final static int[] BG_2X_RESOURCES = new int[] {
+                R.drawable.widget_2x_yellow,
+                R.drawable.widget_2x_blue,
+                R.drawable.widget_2x_white,
+                R.drawable.widget_2x_green,
+                R.drawable.widget_2x_red,
+        };
+
+        // 静态方法，根据传入的索引id获取2x尺寸小部件的背景图片资源ID，返回对应的BG_2X_RESOURCES数组中的元素（即资源ID）
+        public static int getWidget2xBgResource(int id) {
+            return BG_2X_RESOURCES[id];
+        }
+
+        // 定义一个静态的整数数组，存储4x尺寸小部件的背景图片资源ID，对应不同的颜色选项
+        private final static int[] BG_4X_RESOURCES = new int[] {
+                R.drawable.widget_4x_yellow,
+                R.drawable.widget_4x_blue,
+                R.drawable.widget_4x_white,
+                R.drawable.widget_4x_green,
+                R.drawable.widget_4x_red
+        };
+
+        // 静态方法，根据传入的索引id获取4x尺寸小部件的背景图片资源ID，返回对应的BG_4X_RESOURCES数组中的元素（即资源ID）
+        public static int getWidget4xBgResource(int id) {
+            return BG_4X_RESOURCES[id];
+        }
+    }
+
+    // 内部静态类TextAppearanceResources，用于管理文本外观相关的资源，如不同字体大小对应的样式资源ID等
+    public static class TextAppearanceResources {
+        // 定义一个静态的整数数组，存储不同字体大小对应的文本外观样式资源ID（按顺序对应前面定义的字体大小常量顺序）
+        private final static int[] TEXTAPPEARANCE_RESOURCES = new int[] {
+                R.style.TextAppearanceNormal,
+                R.style.TextAppearanceMedium,
+                R.style.TextAppearanceLarge,
+                R.style.TextAppearanceSuper
+        };
+
+        // 静态方法，根据传入的索引id获取文本外观样式资源ID，同时进行了边界检查，如果传入的id超出资源数组长度范围，则返回默认的字体大小对应的资源ID（避免出现资源获取异常情况）
+        public static int getTexAppearanceResource(int id) {
+            /**
+             * HACKME: Fix bug of store the resource id in shared preference.
+             * The id may larger than the length of resources, in this case,
+             * return the {@link ResourceParser#BG_DEFAULT_FONT_SIZE}
+             */
+            if (id >= TEXTAPPEARANCE_RESOURCES.length) {
+                return BG_DEFAULT_FONT_SIZE;
+            }
+            return TEXTAPPEARANCE_RESOURCES[id];
+        }
+
+        // 静态方法，获取文本外观样式资源数组的长度，用于判断资源数量或者进行循环等操作时参考
+        public static int getResourcesSize() {
+            return TEXTAPPEARANCE_RESOURCES.length;
+        }
+    }
+}

SqlData.java

@@ -0,0 +1,236 @@
+/*
+ * Copyright (c) 2010-2011, The MiCode Open Source Community (www.micode.net)
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *        http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package net.micode.notes.gtask.data;
+
+import android.content.ContentResolver;
+import android.content.ContentUris;
+import android.content.ContentValues;
+import android.content.Context;
+import android.database.Cursor;
+import android.net.Uri;
+import android.util.Log;
+
+import net.micode.notes.data.Notes;
+import net.micode.notes.data.Notes.DataColumns;
+import net.micode.notes.data.Notes.DataConstants;
+import net.micode.notes.data.Notes.NoteColumns;
+import net.micode.notes.data.NotesDatabaseHelper.TABLE;
+import net.micode.notes.gtask.exception.ActionFailureException;
+
+import org.json.JSONException;
+import org.json.JSONObject;
+
+// SqlData类主要用于处理与数据库中相关数据的交互操作，能够从数据库游标加载数据、设置和获取JSON格式的数据内容，以及将数据的变更提交到数据库等
+public class SqlData {
+    // 用于日志记录的标签，方便在Log输出中识别该类相关的日志信息，使用类的简单名称作为标签
+    private static final String TAG = SqlData.class.getSimpleName();
+
+    // 定义一个表示无效ID的值，通常用于初始化或者标识某个尚未正确赋值的ID情况
+    private static final int INVALID_ID = -99999;
+
+    // 定义查询数据时的投影（即要获取的列）数组，指定了从数据库获取数据时包含的列名
+    public static final String[] PROJECTION_DATA = new String[] {
+            DataColumns.ID, DataColumns.MIME_TYPE, DataColumns.CONTENT, DataColumns.DATA1,
+            DataColumns.DATA3
+    };
+
+    // 定义在投影数组中数据ID列对应的索引位置，方便后续从游标中获取对应列的值
+    public static final int DATA_ID_COLUMN = 0;
+
+    // 定义在投影数组中数据MIME_TYPE列对应的索引位置
+    public static final int DATA_MIME_TYPE_COLUMN = 1;
+
+    // 定义在投影数组中数据CONTENT列对应的索引位置
+    public static final int DATA_CONTENT_COLUMN = 2;
+
+    // 定义在投影数组中数据DATA1列对应的索引位置
+    public static final int DATA_CONTENT_DATA_1_COLUMN = 3;
+
+    // 定义在投影数组中数据DATA3列对应的索引位置
+    public static final int DATA_CONTENT_DATA_3_COLUMN = 4;
+
+    // 用于与内容提供器进行交互，用于执行如插入、更新等数据操作
+    private ContentResolver mContentResolver;
+
+    // 标记当前对象所代表的数据是否是新创建的，初始化为true，表示新创建状态
+    private boolean mIsCreate;
+
+    // 存储数据的ID，初始化为无效ID值
+    private long mDataId;
+
+    // 存储数据的MIME类型，初始化为默认的NOTE类型（可能来自DataConstants类）
+    private String mDataMimeType;
+
+    // 存储数据的具体内容，初始化为空字符串
+    private String mDataContent;
+
+    // 存储数据内容中相关的一个长整型数据（具体含义可能根据业务而定），初始化为0
+    private long mDataContentData1;
+
+    // 存储数据内容中相关的一个字符串数据（具体含义可能根据业务而定），初始化为空字符串
+    private String mDataContentData3;
+
+    // 用于存储数据发生变更的内容值，方便后续批量提交变更到数据库
+    private ContentValues mDiffDataValues;
+
+    // 构造函数，用于创建一个新的SqlData实例，通常用于创建新的数据对象情况，传入上下文用于获取内容解析器
+    public SqlData(Context context) {
+        // 获取上下文对应的内容解析器，用于后续与内容提供器交互操作
+        mContentResolver = context.getContentResolver();
+        // 标记为新创建状态
+        mIsCreate = true;
+        // 设置初始的无效数据ID
+        mDataId = INVALID_ID;
+        // 设置默认的MIME类型
+        mDataMimeType = DataConstants.NOTE;
+        // 设置初始的空内容字符串
+        mDataContent = "";
+        // 设置初始的相关数据值为0
+        mDataContentData1 = 0;
+        // 设置初始的相关数据字符串为空
+        mDataContentData3 = "";
+        // 初始化用于存储变更数据值的ContentValues对象
+        mDiffDataValues = new ContentValues();
+    }
+
+    // 另一个构造函数，用于根据已有的数据库游标创建SqlData实例，通常用于从数据库读取现有数据并封装到该对象中，传入上下文和游标
+    public SqlData(Context context, Cursor c) {
+        // 获取上下文对应的内容解析器
+        mContentResolver = context.getContentResolver();
+        // 标记为非新创建状态，因为是从现有数据构建
+        mIsCreate = false;
+        // 从游标中加载数据到该对象的各个属性中
+        loadFromCursor(c);
+        // 初始化用于存储变更数据值的ContentValues对象
+        mDiffDataValues = new ContentValues();
+    }
+
+    // 从给定的游标中读取数据并设置到当前对象的对应属性中，根据之前定义的列索引位置获取相应的值
+    private void loadFromCursor(Cursor c) {
+        mDataId = c.getLong(DATA_ID_COLUMN);
+        mDataMimeType = c.getString(DATA_MIME_TYPE_COLUMN);
+        mDataContent = c.getString(DATA_CONTENT_COLUMN);
+        mDataContentData1 = c.getLong(DATA_CONTENT_DATA_1_COLUMN);
+        mDataContentData3 = c.getString(DATA_CONTENT_DATA_3_COLUMN);
+    }
+
+    // 根据传入的JSON对象设置当前对象的数据内容，比较并更新有变化的数据项到mDiffDataValues中，用于后续提交变更
+    public void setContent(JSONObject js) throws JSONException {
+        long dataId = js.has(DataColumns.ID)? js.getLong(DataColumns.ID) : INVALID_ID;
+        if (mIsCreate || mDataId!= dataId) {
+            mDiffDataValues.put(DataColumns.ID, dataId);
+        }
+        mDataId = dataId;
+
+        String dataMimeType = js.has(DataColumns.MIME_TYPE)? js.getString(DataColumns.MIME_TYPE)
+                : DataConstants.NOTE;
+        if (mIsCreate ||!mDataMimeType.equals(dataMimeType)) {
+            mDiffDataValues.put(DataColumns.MIME_TYPE, dataMimeType);
+        }
+        mDataMimeType = dataMimeType;
+
+        String dataContent = js.has(DataColumns.CONTENT)? js.getString(DataColumns.CONTENT) : "";
+        if (mIsCreate ||!mDataContent.equals(dataContent)) {
+            mDiffDataValues.put(DataColumns.CONTENT, dataContent);
+        }
+        mDataContent = dataContent;
+
+        long dataContentData1 = js.has(DataColumns.DATA1)? js.getLong(DataColumns.DATA1) : 0;
+        if (mIsCreate || mDataContentData1!= dataContentData1) {
+            mDiffDataValues.put(DataColumns.DATA1, dataContentData1);
+        }
+        mDataContentData1 = dataContentData1;
+
+        String dataContentData3 = js.has(DataColumns.DATA3)? js.getString(DataColumns.DATA3) : "";
+        if (mIsCreate ||!mDataContentData3.equals(dataContentData3)) {
+            mDiffDataValues.put(DataColumns.DATA3, dataContentData3);
+        }
+        mDataContentData3 = dataContentData3;
+    }
+
+    // 将当前对象的数据内容转换为JSON对象返回，如果是新创建状态（尚未在数据库中存在）则记录错误日志并返回null
+    public JSONObject getContent() throws JSONException {
+        if (mIsCreate) {
+            Log.e(TAG, "it seems that we haven't created this in database yet");
+            return null;
+        }
+        JSONObject js = new JSONObject();
+        js.put(DataColumns.ID, mDataId);
+        js.put(DataColumns.MIME_TYPE, mDataMimeType);
+        js.put(DataColumns.CONTENT, mDataContent);
+        js.put(DataColumns.DATA1, mDataContentData1);
+        js.put(DataColumns.DATA3, mDataContentData3);
+        return js;
+    }
+
+    // 将数据的变更提交到数据库中，根据是新创建还是已有数据执行不同的操作（插入或更新），同时处理版本验证等逻辑
+    public void commit(long noteId, boolean validateVersion, long version) {
+
+        if (mIsCreate) {
+            // 如果是新创建数据且当前设置的ID为无效ID，同时变更数据值中包含了ID字段，则移除该ID字段（可能是由数据库自动生成等情况）
+            if (mDataId == INVALID_ID && mDiffDataValues.containsKey(DataColumns.ID)) {
+                mDiffDataValues.remove(DataColumns.ID);
+            }
+
+            // 设置关联的笔记ID到变更数据值中，以便插入时建立关联
+            mDiffDataValues.put(DataColumns.NOTE_ID, noteId);
+            // 通过内容解析器向指定的数据库URI插入数据，获取插入后数据对应的URI
+            Uri uri = mContentResolver.insert(Notes.CONTENT_DATA_URI, mDiffDataValues);
+            try {
+                // 尝试从插入后的URI中获取插入数据的ID，设置到当前对象的mDataId属性中
+                mDataId = Long.valueOf(uri.getPathSegments().get(1));
+            } catch (NumberFormatException e) {
+                // 如果获取ID过程出现格式转换异常，记录错误日志并抛出操作失败异常，表示创建笔记失败
+                Log.e(TAG, "Get note id error :" + e.toString());
+                throw new ActionFailureException("create note failed");
+            }
+        } else {
+            // 如果是已有数据且有变更数据值（即有数据需要更新）
+            if (mDiffDataValues.size() > 0) {
+                int result = 0;
+                // 如果不需要验证版本
+                if (!validateVersion) {
+                    // 直接执行更新操作，更新对应数据ID的数据，不做版本相关验证
+                    result = mContentResolver.update(ContentUris.withAppendedId(
+                            Notes.CONTENT_DATA_URI, mDataId), mDiffDataValues, null, null);
+                } else {
+                    // 如果需要验证版本，则执行带版本验证条件的更新操作，根据指定的笔记ID和版本号进行更新
+                    result = mContentResolver.update(ContentUris.withAppendedId(
+                                    Notes.CONTENT_DATA_URI, mDataId), mDiffDataValues,
+                            "? in (SELECT " + NoteColumns.ID + " FROM " + TABLE.NOTE
+                                    + " WHERE " + NoteColumns.VERSION + "=?)", new String[] {
+                                    String.valueOf(noteId), String.valueOf(version)
+                            });
+                }
+                if (result == 0) {
+                    // 如果更新操作没有实际更新任何数据，记录警告日志，可能是用户在同步时已经更新了笔记等情况
+                    Log.w(TAG, "there is no update. maybe user updates note when syncing");
+                }
+            }
+        }
+
+        // 清除变更数据值，准备下一次的数据变更操作
+        mDiffDataValues.clear();
+        // 将创建标记设置为false，表示当前数据已不是新创建状态
+        mIsCreate = false;
+    }
+
+    // 获取当前数据对象的ID值
+    public long getId() {
+        return mDataId;
+    }
+}