pkw2ie96j
/
minote_wd
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Compare commits

base: pkw2ie96j:djx_branch
Branches Tags
pkw2ie96j:wxk_branch
pkw2ie96j:djx_branch
pkw2ie96j:master
pkw2ie96j:develop
pkw2ie96j:main
..
compare: pkw2ie96j:main
Branches Tags
pkw2ie96j:wxk_branch
pkw2ie96j:djx_branch
pkw2ie96j:master
pkw2ie96j:develop
pkw2ie96j:main

No commits in common. 'djx_branch' and 'main' have entirely different histories.
djx_branch ... main

5 changed files with 0 additions and 969 deletions
Show Stats

100
Contact.java
Unescape View File

@ -1,100 +0,0 @@
/*
* 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;
// 用于日志输出的标签，方便在Logcat中识别该类相关的日志信息，便于调试和查看运行情况。
private static final String TAG = "Contact";
// 定义一个用于查询联系人的筛选条件字符串，用于在联系人数据中查找与给定电话号码匹配的联系人记录。
// 该条件使用了数据库函数（PHONE_NUMBERS_EQUAL）来比较电话号码是否相等，同时限定了数据的MIME类型为电话号码类型（Phone.CONTENT_ITEM_TYPE），
// 并且要求对应的原始联系人ID在特定的查询结果集中（通过子查询查找符合最小匹配条件的原始联系人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），查询并返回对应的联系人姓名。
* 如果缓存（sContactCache）中已经存在该电话号码对应的联系人姓名，则直接从缓存中获取并返回；
* 如果缓存中不存在，则通过ContentResolver查询联系人数据库获取联系人姓名，同时将查询到的结果存入缓存，方便后续查询使用。
*
* @param context 安卓应用的上下文环境，用于获取ContentResolver等系统资源，以便进行数据库查询等操作。
* @param phoneNumber 要查询联系人姓名对应的电话号码字符串。
* @return 返回与给定电话号码对应的联系人姓名，如果未找到匹配的联系人则返回null。
*/
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工具类的toCallerIDMinMatch方法进行转换，
// 以适应不同格式的电话号码匹配需求，使查询条件更准确地匹配联系人数据库中的记录。
String selection = CALLER_ID_SELECTION.replace("+",
PhoneNumberUtils.toCallerIDMinMatch(phoneNumber));
// 通过上下文的ContentResolver发起查询操作，查询联系人数据的统一资源标识符（Data.CONTENT_URI），
// 指定只查询联系人的显示名称（Phone.DISPLAY_NAME）这一列数据，传入处理后的查询条件（selection）以及要查询的电话号码参数（phoneNumber），
// 排序规则设置为null，表示使用默认排序方式（这里暂未关注排序情况）。
Cursor cursor = context.getContentResolver().query(
Data.CONTENT_URI,
new String[]{Phone.DISPLAY_NAME},
selection,
new String[]{phoneNumber},
null);
// 如果查询结果游标（Cursor）不为空且游标可以移动到第一条记录（表示查询到了至少一条匹配的联系人记录），则进行以下操作。
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;
}
}
}

86
MetaData.java
Unescape View File

@ -1,86 +0,0 @@
package net.micode.notes.gtask.data;
import android.database.Cursor;
import android.util.Log;
import net.micode.notes.tool.GTaskStringUtils;
import org.json.JSONException;
import org.json.JSONObject;
// MetaData类继承自Task类，用于处理任务相关的元数据信息
public class MetaData extends Task {
// 定义一个私有静态常量TAG，用于在日志输出时标识当前类，其值为类的简单名称
private final static String TAG = MetaData.class.getSimpleName();
// 用于存储相关任务的标识符，初始值设为null
private String mRelatedGid = null;
// 设置元数据的方法，接收任务标识符gid和一个JSONObject类型的metaInfo对象
public void setMeta(String gid, JSONObject metaInfo) {
try {
// 尝试将任务标识符gid添加到metaInfo这个JSON对象中，键由GTaskStringUtils.META_HEAD_GTASK_ID指定
metaInfo.put(GTaskStringUtils.META_HEAD_GTASK_ID, gid);
} catch (JSONException e) {
// 如果添加过程中出现JSONException异常，通过Log.e记录错误日志，提示添加相关标识符失败
Log.e(TAG, "failed to put related gid");
}
// 将更新后的metaInfo对象转换为字符串，并通过调用继承自Task类的setNotes方法进行设置
setNotes(metaInfo.toString());
// 设置名称为GTaskStringUtils.META_NOTE_NAME所代表的值，该值应该是一个预定义的用于标识名称的字符串常量
setName(GTaskStringUtils.META_NOTE_NAME);
}
// 获取相关任务标识符的方法，返回mRelatedGid的值
public String getRelatedGid() {
return mRelatedGid;
}
// 重写isWorthSaving方法，判断当前MetaData对象是否值得保存
// 逻辑是只要通过getNotes方法（推测来自Task类用于获取备注信息相关内容）获取到的值不为null，就返回true
@Override
public boolean isWorthSaving() {
return getNotes()!= null;
}
// 重写用于根据远程获取的JSON对象来设置内容的方法
@Override
public void setContentByRemoteJSON(JSONObject js) {
// 首先调用父类（Task类）的setContentByRemoteJSON方法进行一些通用的或者继承体系中已有的设置操作
super.setContentByRemoteJSON(js);
if (getNotes()!= null) {
try {
// 对通过getNotes获取到的内容先进行trim操作去除首尾空白字符，然后解析为JSONObject
JSONObject metaInfo = new JSONObject(getNotes().trim());
// 从解析出的JSONObject中获取以GTaskStringUtils.META_HEAD_GTASK_ID为键对应的字符串值，并赋值给mRelatedGid
mRelatedGid = metaInfo.getString(GTaskStringUtils.META_HEAD_GTASK_ID);
} catch (JSONException e) {
// 如果在获取过程中出现JSONException异常，通过Log.w记录警告日志，并将mRelatedGid设为null
Log.w(TAG, "failed to get related gid");
mRelatedGid = null;
}
}
}
// 重写用于根据本地JSON对象设置内容的方法，此方法在当前类的设计中不应该被调用
// 直接抛出IllegalAccessError异常，并给出相应提示信息
@Override
public void setContentByLocalJSON(JSONObject js) {
// this function should not be called
throw new IllegalAccessError("MetaData:setContentByLocalJSON should not be called");
}
// 重写获取本地JSON对象的方法，此方法在当前类的设计中不应该被调用
// 直接抛出IllegalAccessError异常，并给出相应提示信息
@Override
public JSONObject getLocalJSONFromContent() {
throw new IllegalAccessError("MetaData:getLocalJSONFromContent should not be called");
}
// 重写获取同步操作相关的方法，此方法在当前类的设计中不应该被调用
// 直接抛出IllegalAccessError异常，并给出相应提示信息
@Override
public int getSyncAction(Cursor c) {
throw new IllegalAccessError("MetaData:getSyncAction should not be called");
}
}

313
Notes.java
Unescape View File

@ -1,313 +0,0 @@
/*
* 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.
*/
// 包声明，表明该类属于net.micode.notes.data包，用于存放笔记相关的数据结构和常量定义等内容
package net.micode.notes.data;
import android.net.Uri;
// Notes类，主要用于定义笔记应用中的各种常量、数据列接口以及特定类型笔记相关的内部类等，起到统一管理和规范数据相关定义的作用
public class Notes {
// 用于定义内容提供器（Content Provider）的授权（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），比如在启动某个与笔记相关的Activity或者Service时，可以通过这些键传递特定的参数，此处是与提醒日期相关的键
public static final String INTENT_EXTRA_ALERT_DATE = "net.micode.notes.alert_date";
// 与笔记背景颜色ID相关的Intent额外数据的键，用于传递或获取笔记背景颜色相关设置信息
public static final String INTENT_EXTRA_BACKGROUND_ID = "net.micode.notes.background_color_id";
// 与笔记对应的桌面小部件ID相关的Intent额外数据的键，可用于在不同组件间传递小部件相关的标识信息
public static final String INTENT_EXTRA_WIDGET_ID = "net.micode.notes.widget_id";
// 与笔记对应的桌面小部件类型相关的Intent额外数据的键，例如可能区分不同尺寸、样式的小部件类型
public static final String INTENT_EXTRA_WIDGET_TYPE = "net.micode.notes.widget_type";
// 与文件夹ID相关的Intent额外数据的键，用于传递文件夹相关的标识信息，方便进行文件夹相关操作的参数传递
public static final String INTENT_EXTRA_FOLDER_ID = "net.micode.notes.folder_id";
// 与通话日期相关的Intent额外数据的键，针对通话记录笔记等场景传递通话发生的日期信息
public static final String INTENT_EXTRA_CALL_DATE = "net.micode.notes.call_date";
// 定义无效的桌面小部件类型常量，用于表示不符合规范或者未初始化等情况下的小部件类型
public static final int TYPE_WIDGET_INVALIDE = -1;
// 定义一种桌面小部件类型常量，可能表示2倍尺寸等特定样式的小部件，具体含义需根据应用实际布局和设计确定
public static final int TYPE_WIDGET_2X = 0;
// 定义另一种桌面小部件类型常量，可能表示4倍尺寸等特定样式的小部件，同样具体样式和用途取决于应用本身的设定
public static final int TYPE_WIDGET_4X = 1;
// DataConstants内部类，用于定义数据相关的常量，比如不同类型笔记对应的MIME类型等，方便统一管理和识别不同类型的数据内容
public static class DataConstants {
// 表示普通文本笔记对应的MIME类型，其具体值来源于TextNote内部类中定义的CONTENT_ITEM_TYPE，用于标识文本笔记类型的数据
public static final String NOTE = TextNote.CONTENT_ITEM_TYPE;
// 表示通话记录笔记对应的MIME类型，其值来自CallNote内部类中定义的CONTENT_ITEM_TYPE，用于区分通话记录这种特殊类型的数据
public static final String CALL_NOTE = CallNote.CONTENT_ITEM_TYPE;
}
/**
* 用于查询所有笔记和文件夹的统一资源标识符（Uri）。
* 通过指定 "content://" 协议以及应用的授权字符串（AUTHORITY）和资源路径（"/note"）构建而成，
* 在使用Content Provider进行数据查询操作时，作为查询所有笔记和文件夹相关数据的入口地址。
*/
public static final Uri CONTENT_NOTE_URI = Uri.parse("content://" + AUTHORITY + "/note");
/**
* 用于查询数据（比如笔记的具体内容、附件等相关数据）的统一资源标识符（Uri）。
* 同样按照 "content://" 协议加上授权字符串和对应资源路径（"/data"）来构建，
* 作为查询笔记相关详细数据内容的访问地址，供Content Provider操作使用。
*/
public static final Uri CONTENT_DATA_URI = Uri.parse("content://" + AUTHORITY + "/data");
// NoteColumns接口，用于定义笔记表（note表）中各个数据列的名称常量，方便在数据库操作以及数据处理过程中统一引用，保证列名的准确性和一致性
public interface NoteColumns {
/**
* 表示一行数据（对应一条笔记记录）的唯一标识符（ID）。
* <P> 数据类型：INTEGER（在数据库中通常对应长整型，用于唯一标识每条记录） </P>
*/
public static final String ID = "_id";
/**
* 表示笔记或文件夹的父级ID，用于构建笔记的层级结构，例如文件夹下包含子笔记等情况，通过该字段建立关联。
* <P> 数据类型：INTEGER（长整型） </P>
*/
public static final String PARENT_ID = "parent_id";
/**
* 笔记或文件夹的创建日期，用于记录创建时间信息，方便按时间排序、筛选等操作。
* <P> 数据类型：INTEGER（长整型，通常存储时间戳等表示日期时间的数据） </P>
*/
public static final String CREATED_DATE = "created_date";
/**
* 最新修改日期，用于跟踪笔记或文件夹最后一次被修改的时间，可用于判断数据是否有更新等情况。
* <P> 数据类型：INTEGER（长整型） </P>
*/
public static final String MODIFIED_DATE = "modified_date";
/**
* 提醒日期，用于设置笔记的提醒时间相关功能，比如在特定时间提醒用户查看笔记内容等。
* <P> 数据类型：INTEGER（长整型） </P>
*/
public static final String ALERTED_DATE = "alert_date";
/**
* 对于文件夹而言，表示文件夹的名称；对于笔记来说，则是文本内容的摘要等简短描述信息，方便在列表展示等场景快速呈现主要内容。
* <P> 数据类型：TEXT（文本类型） </P>
*/
public static final String SNIPPET = "snippet";
/**
* 笔记对应的桌面小部件ID，用于关联笔记与相应的桌面小部件，便于在小部件上展示或操作相关笔记。
* <P> 数据类型：INTEGER（长整型） </P>
*/
public static final String WIDGET_ID = "widget_id";
/**
* 笔记对应的桌面小部件类型，用于区分不同样式、尺寸的小部件，如前面定义的2X、4X等类型。
* <P> 数据类型：INTEGER（长整型） </P>
*/
public static final String WIDGET_TYPE = "widget_type";
/**
* 笔记背景颜色的ID，用于设置和记录笔记在界面上显示的背景颜色相关信息，方便个性化展示。
* <P> 数据类型：INTEGER（长整型） </P>
*/
public static final String BG_COLOR_ID = "bg_color_id";
/**
* 对于文本笔记，该字段表示是否有附件（通常为0，表示没有附件）；对于多媒体笔记等，则表示至少有一个附件（通常为1），用于区分笔记是否包含额外的附属文件等情况。
* <P> 数据类型：INTEGER（整型） </P>
*/
public static final String HAS_ATTACHMENT = "has_attachment";
/**
* 文件夹中包含的笔记数量，用于统计每个文件夹下有多少条笔记，方便进行文件夹相关的管理操作，如显示文件夹包含的笔记数量等。
* <P> 数据类型：INTEGER（长整型） </P>
*/
public static final String NOTES_COUNT = "notes_count";
/**
* 表示文件类型，是笔记还是文件夹等，通过前面定义的TYPE_NOTE、TYPE_FOLDER、TYPE_SYSTEM等常量来区分不同性质的记录。
* <P> 数据类型：INTEGER（整型） </P>
*/
public static final String TYPE = "type";
/**
* 最后一次同步的ID，可能用于与服务器等外部数据源进行数据同步操作时的标识，记录上次同步的相关信息，便于判断数据是否需要再次同步等。
* <P> 数据类型：INTEGER（长整型） </P>
*/
public static final String SYNC_ID = "sync_id";
/**
* 用于标识本地是否有修改的标志，方便在数据同步等场景判断本地数据与外部数据源的数据差异情况，决定是否需要上传修改内容等操作。
* <P> 数据类型：INTEGER（整型） </P>
*/
public static final String LOCAL_MODIFIED = "local_modified";
/**
* 笔记在移动到临时文件夹之前的原始父级ID，用于记录笔记的来源信息，在一些还原、移动操作等场景可能会用到该原始信息进行相应处理。
* <P> 数据类型 : INTEGER（整型） </P>
*/
public static final String ORIGIN_PARENT_ID = "origin_parent_id";
/**
* 对应的gtask ID，可能用于与某些任务管理系统（如Google Tasks等）进行关联或交互时的标识，具体用途取决于应用与外部任务系统的集成情况。
* <P> 数据类型 : TEXT（文本类型） </P>
*/
public static final String GTASK_ID = "gtask_id";
/**
* 版本代码，可用于记录笔记相关的数据版本信息，比如在数据结构变化、功能更新等情况下通过版本号来判断兼容性和进行相应处理。
* <P> 数据类型 : INTEGER（长整型） </P>
*/
public static final String VERSION = "version";
}
// DataColumns接口，用于定义存放笔记相关数据（如附件、详细内容等）的数据表（data表）中各数据列的名称常量，与NoteColumns类似，保证在数据库操作中对列名的准确引用
public interface DataColumns {
/**
* 表示一行数据（对应一条数据记录，比如一条附件记录或者笔记详细内容记录等）的唯一标识符（ID）。
* <P> 数据类型：INTEGER（长整型） </P>
*/
public static final String ID = "_id";
/**
* 该行数据所代表的项目的MIME类型，用于标识数据的具体格式或类型，比如文本、图片、音频等不同类型的数据通过不同的MIME类型区分。
* <P> 数据类型：Text（文本类型） </P>
*/
public static final String MIME_TYPE = "mime_type";
/**
* 对应该数据所属笔记的引用ID，通过这个字段建立数据与笔记之间的关联，表明这条数据是属于哪条笔记的附件、详细内容等情况。
* <P> 数据类型：INTEGER（长整型） </P>
*/
public static final String NOTE_ID = "note_id";
/**
* 笔记或文件夹的创建日期，与NoteColumns中的CREATED_DATE类似，用于记录该数据相关的创建时间信息，可能用于排序、版本管理等操作。
* <P> 数据类型：INTEGER（长整型） </P>
*/
public static final String CREATED_DATE = "created_date";
/**
* 最新修改日期，同样类似于NoteColumns中的MODIFIED_DATE，用于跟踪该数据最后一次被修改的时间，便于判断数据的时效性和是否需要同步等情况。
* <P> 数据类型：INTEGER（长整型） </P>
*/
public static final String MODIFIED_DATE = "modified_date";
/**
* 数据的具体内容，比如文本笔记的正文内容、附件的二进制数据等，根据不同的MIME类型存储相应格式的数据内容。
* <P> 数据类型：TEXT（文本类型） </P>
*/
public static final String CONTENT = "content";
/**
* 通用数据列，其含义取决于具体的{@link #MIMETYPE}类型，主要用于存储整数类型的数据，不同的MIME类型下该字段可表示不同的具体业务含义。
* <P> 数据类型：INTEGER（整型） </P>
*/
public static final String DATA1 = "data1";
/**
* 通用数据列，含义同样取决于MIME类型，用于存储整数类型的数据，可在不同业务场景下根据需要赋予其具体含义。
* <P> 数据类型：INTEGER（整型） </P>
*/
public static final String DATA2 = "data2";
/**
* 通用数据列，含义由MIME类型决定，用于存储文本类型的数据，可根据具体的数据类型和业务逻辑存放相应的文本信息。
* <P> 数据类型：TEXT（文本类型） </P>
*/
public static final String DATA3 = "data3";
/**
* 通用数据列，也是基于MIME类型确定含义，用于存储文本类型的数据，在不同的笔记相关数据场景下可存放不同的文本内容。
* <P> 数据类型：TEXT（文本类型） </P>
*/
public static final String DATA4 = "data3";
/**
* 通用数据列，同样根据MIME类型来明确其具体含义，用于存储文本类型的数据，作为一种可灵活使用的文本数据存储字段。
* <P> 数据类型：TEXT（文本类型） </P>
*/
public static final String DATA5 = "data5";
}
// TextNote内部类，继承自DataColumns接口，主要用于定义文本笔记相关的特定数据列或常量，进一步细化文本笔记的数据结构和相关操作属性
public static final class TextNote implements DataColumns {
/**
* 用于指示文本是否处于复选框列表模式的标志，例如在笔记内容是待办事项列表等场景下使用，1表示处于复选框列表模式，0表示普通文本模式。
* <P> 数据类型：Integer（整型，取值为1或0来区分不同模式） </P>
*/
public static final String MODE = DATA1;
public static final int MODE_CHECK_LIST = 1;
// 文本笔记对应的内容类型的MIME字符串，用于标识一组文本笔记内容的类型，通常在Content Provider相关操作中用于匹配查询等情况。
public static final String CONTENT_TYPE = "vnd.android.cursor.dir/text_note";
// 单个文本笔记项对应的内容类型的MIME字符串，用于精确标识一条文本笔记内容的类型，方便更细致的Content Provider操作，如获取单条文本笔记数据等。
public static final String CONTENT_ITEM_TYPE = "vnd.android.cursor.item/text_note";
// 用于查询文本笔记相关数据的统一资源标识符（Uri），按照标准的Content Provider的Uri构建方式，通过授权字符串和特定资源路径（"/text_note"）组成，作为访问文本笔记数据的入口。
public static final Uri CONTENT_URI = Uri.parse("content://" + AUTHORITY + "/text_note");
}
// CallNote内部类，它实现了DataColumns接口，意味着它遵循该接口定义的数据列规范，
// 主要用于定义通话记录笔记相关的特定数据属性、MIME类型以及对应的内容访问Uri等，
// 方便在整个笔记应用的数据体系中对通话记录笔记这种特定类型进行专门的处理和操作。
public static final class CallNote implements DataColumns {
/**
* 定义表示通话记录笔记中通话日期的字段常量。
* 它复用了父接口（DataColumns）中定义的通用数据列DATA1来存储通话日期信息，
* <P> 数据类型：INTEGER（长整型），通常用于存储时间戳等方式表示的日期值，方便后续按时间进行排序、筛选等操作。 </P>
*/
public static final String CALL_DATE = DATA1;
/**
* 定义表示通话记录笔记中电话号码的字段常量。
* 使用了父接口（DataColumns）中通用的文本数据列DATA3来存储电话号码信息，
* <P> 数据类型：TEXT（文本类型），符合电话号码作为字符串进行存储和处理的常规需求。 </P>
*/
public static final String PHONE_NUMBER = DATA3;
// 定义通话记录笔记对应的内容类型的MIME字符串，用于标识一组通话记录笔记内容的类型。
// 在Content Provider相关操作中，当需要查询、匹配一组通话记录笔记时，可通过该MIME类型进行筛选判断，
// 表明这是一种代表多个通话记录笔记的目录类型（通常对应数据库中的多条记录集合）。
public static final String CONTENT_TYPE = "vnd.android.cursor.dir/call_note";
// 定义单个通话记录笔记项对应的内容类型的MIME字符串，用于精确标识一条通话记录笔记内容的类型。
// 相比于CONTENT_TYPE用于表示一组记录，它更侧重于精准定位到单条通话记录笔记，方便在Content Provider操作中进行获取单条数据等更细致的操作。
public static final String CONTENT_ITEM_TYPE = "vnd.android.cursor.item/call_note";
// 定义用于查询通话记录笔记相关数据的统一资源标识符（Uri）。
// 按照安卓中Content Provider标准的Uri构建方式，通过指定 "content://" 协议、应用的授权字符串（AUTHORITY，在外部类Notes中定义）以及特定资源路径（"/call_note"）组成，
// 这个Uri作为访问通话记录笔记数据的入口地址，在使用ContentResolver等进行数据查询、插入、更新、删除等操作时会用到，以定位到通话记录笔记相关的数据资源。
public static final Uri CONTENT_URI = Uri.parse("content://" + AUTHORITY + "/call_note");
}
}

470
NotesDatabaseHelper.java
Unescape View File

@ -1,470 +0,0 @@
/*
* 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.
*/
// 包声明，该类位于net.micode.notes.data包下，用于处理笔记相关的数据库操作
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";
}
// 用于日志输出的标签，方便在Logcat中识别该类相关的日志信息
private static final String TAG = "NotesDatabaseHelper";
// 采用单例模式，保存该类的唯一实例
private static NotesDatabaseHelper mInstance;
// 创建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" +
")";
// 创建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 ''" +
")";
// 创建基于note_id的索引的SQL语句，用于提高在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 + ");";
/**
* 当将笔记移动到文件夹时，增加文件夹的笔记数量的触发器SQL语句。
* 在更新note表的PARENT_ID列后触发，会根据新的父文件夹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";
/**
* 当从文件夹中移出笔记时，减少文件夹的笔记数量的触发器SQL语句。
* 在更新note表的PARENT_ID列后触发，会根据旧的父文件夹ID减少对应文件夹的笔记数量，
* 同时要确保笔记数量大于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语句。
* 在向note表插入新记录后触发，会根据新笔记的父文件夹ID增加对应文件夹的笔记数量
*/
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语句。
* 在从note表删除记录后触发，会根据被删除笔记的旧父文件夹ID减少对应文件夹的笔记数量，
* 并且要保证文件夹的笔记数量大于0才进行减少操作
*/
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";
/**
* 当插入类型为{@link DataConstants#NOTE}的数据时，更新笔记内容的触发器SQL语句。
* 在向DATA表插入新记录后触发，如果插入的数据类型是笔记类型，
* 则会将对应笔记的摘要（SNIPPET）更新为新插入数据的内容（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";
/**
* 当类型为{@link DataConstants#NOTE}的数据更新时，更新笔记内容的触发器SQL语句。
* 在更新DATA表的记录后触发，如果更新前的数据类型是笔记类型，
* 则会将对应笔记的摘要（SNIPPET）更新为更新后的数据内容（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";
/**
* 当类型为{@link DataConstants#NOTE}的数据被删除时，更新笔记内容的触发器SQL语句。
* 在从DATA表删除记录后触发，如果被删除的数据类型是笔记类型，
* 则会将对应笔记的摘要（SNIPPET）清空
*/
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";
/**
* 当笔记被删除时，删除该笔记相关数据的触发器SQL语句。
* 在从note表删除记录后触发，会删除DATA表中与被删除笔记相关联的数据（通过NOTE_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语句。
* 在从note表删除记录（可能是文件夹对应的记录）后触发，会删除note表中属于该文件夹的所有笔记
*/
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";
/**
* 当文件夹被移动到回收站文件夹时，移动该文件夹下所有笔记到回收站文件夹的触发器SQL语句。
* 在更新note表的PARENT_ID列（可能是文件夹移动操作）后触发，如果新的父文件夹ID是回收站文件夹ID，
* 则会将原属于该文件夹的所有笔记的父文件夹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";
// 构造函数，调用父类（SQLiteOpenHelper）的构造函数来初始化数据库相关信息，传入上下文、数据库名称、游标工厂（此处为null）以及数据库版本号
public NotesDatabaseHelper(Context context) {
super(context, DB_NAME, null, DB_VERSION);
}
// 在数据库中创建note表的方法，执行创建表的SQL语句，重新创建note表相关的触发器，并创建系统文件夹
public void createNoteTable(SQLiteDatabase db) {
db.execSQL(CREATE_NOTE_TABLE_SQL);
reCreateNoteTableTriggers(db);
createSystemFolder(db);
Log.d(TAG, "note table has been created");
}
// 重新创建note表相关触发器的方法，先删除已存在的同名触发器（如果有），再重新创建所有定义的note表相关触发器
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);
}
// 创建系统文件夹的方法，向note表中插入不同类型的系统文件夹记录，如通话记录文件夹、根文件夹、临时文件夹、回收站文件夹等
private void createSystemFolder(SQLiteDatabase db) {
ContentValues values = new ContentValues();
// 通话记录文件夹，设置相关字段值并插入到note表
/**
* call record foler for call notes
*/
values.put(NoteColumns.ID, Notes.ID_CALL_RECORD_FOLDER);
values.put(NoteColumns.TYPE, Notes.TYPE_SYSTEM);
db.insert(TABLE.NOTE, null, values);
// 根文件夹，清空ContentValues后重新设置字段值并插入到note表，根文件夹是默认文件夹
/**
* root folder which is default folder
*/
values.clear();
values.put(NoteColumns.ID, Notes.ID_ROOT_FOLDER);
values.put(NoteColumns.TYPE, Notes.TYPE_SYSTEM);
db.insert(TABLE.NOTE, null, values);
// 临时文件夹，用于临时移动笔记等操作，同样设置字段值后插入到note表
/**
* temporary folder which is used for moving note
*/
values.clear();
values.put(NoteColumns.ID, Notes.ID_TEMPARAY_FOLDER);
values.put(NoteColumns.TYPE, Notes.TYPE_SYSTEM);
db.insert(TABLE.NOTE, null, values);
/**
* 创建根文件夹并插入到数据库的note表中。
* 根文件夹作为默认文件夹，设置其对应的ID和类型字段值后插入。
* 先清空ContentValues对象（避免之前残留数据的影响），再设置相应字段值。
*/
/**
* root folder which is default folder
*/
values.clear();
values.put(NoteColumns.ID, Notes.ID_ROOT_FOLDER);
values.put(NoteColumns.TYPE, Notes.TYPE_SYSTEM);
db.insert(TABLE.NOTE, null, values);
/**
* 创建临时文件夹并插入到数据库的note表中。
* 临时文件夹用于笔记移动等操作，同样先清空ContentValues对象，然后设置其ID和类型字段值，最后插入到表中。
*/
/**
* temporary folder which is used for moving note
*/
values.clear();
values.put(NoteColumns.ID, Notes.ID_TEMPARAY_FOLDER);
values.put(NoteColumns.TYPE, Notes.TYPE_SYSTEM);
db.insert(TABLE.NOTE, null, values);
/**
* 创建回收站文件夹并插入到数据库的note表中。
* 先清空ContentValues对象，接着设置回收站文件夹的ID和类型字段值，随后将其插入到note表中，用于存放被删除或移到回收站的笔记等相关操作。
*/
/**
* create trash folder
*/
values.clear();
values.put(NoteColumns.ID, Notes.ID_TRASH_FOLER);
values.put(NoteColumns.TYPE, Notes.TYPE_SYSTEM);
db.insert(TABLE.NOTE, null, values);
}
/**
* 在数据库中创建data表的方法。
* 首先执行创建data表的SQL语句来定义表结构，然后重新创建与data表相关的触发器，
* 最后创建基于note_id的索引，以提高查询效率，并输出日志表示data表已创建成功。
*/
public void createDataTable(SQLiteDatabase db) {
db.execSQL(CREATE_DATA_TABLE_SQL);
reCreateDataTableTriggers(db);
db.execSQL(CREATE_DATA_NOTE_ID_INDEX_SQL);
Log.d(TAG, "data table has been created");
}
/**
* 重新创建data表相关触发器的私有方法。
* 先删除已存在的同名触发器（如果有的话），这是为了避免重复创建或旧触发器逻辑与新逻辑冲突等问题。
* 然后再执行创建相应触发器的SQL语句，用于处理如插入、更新、删除data表中数据时与note表关联字段的同步更新等操作。
*/
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);
}
/**
* 采用单例模式获取NotesDatabaseHelper实例的静态同步方法。
* 如果实例mInstance为空，则创建一个新的NotesDatabaseHelper对象并赋值给mInstance，
* 保证整个应用中只有一个该类的实例存在，便于统一管理数据库操作相关资源。
* 最后返回该实例，供其他地方调用数据库相关操作方法。
*/
static synchronized NotesDatabaseHelper getInstance(Context context) {
if (mInstance == null) {
mInstance = new NotesDatabaseHelper(context);
}
return mInstance;
}
/**
* 重写SQLiteOpenHelper的onCreate方法，当数据库首次创建时被调用。
* 该方法内会分别调用创建note表和data表的方法，完成数据库初始表结构的创建工作，
* 使得数据库具备存储笔记基本信息和相关数据的能力。
*/
@Override
public void onCreate(SQLiteDatabase db) {
createNoteTable(db);
createDataTable(db);
}
/**
* 重写SQLiteOpenHelper的onUpgrade方法，用于数据库升级操作。
* 根据旧版本号与新版本号的对比来执行相应的升级逻辑，比如添加新表、修改表结构、添加触发器等。
* 定义了两个布尔变量用于控制是否需要重新创建触发器以及是否跳过特定版本的升级逻辑。
*/
@Override
public void onUpgrade(SQLiteDatabase db, int oldVersion, int newVersion) {
boolean reCreateTriggers = false;
boolean skipV2 = false;
// 如果旧版本号是1，执行升级到版本2的操作，并标记跳过单独的从版本2到版本3的升级步骤（因为此次升级可能包含了后续版本升级的部分内容），然后将旧版本号加1。
if (oldVersion == 1) {
upgradeToV2(db);
skipV2 = true; // this upgrade including the upgrade from v2 to v3
oldVersion++;
}
// 如果旧版本号是2且没有跳过版本2升级的标记，执行升级到版本3的操作，并设置需要重新创建触发器的标记为true，之后将旧版本号加1。
if (oldVersion == 2 &&!skipV2) {
upgradeToV3(db);
reCreateTriggers = true;
oldVersion++;
}
// 如果旧版本号是3，执行升级到版本4的操作，然后将旧版本号加1。
if (oldVersion == 3) {
upgradeToV4(db);
oldVersion++;
}
// 如果需要重新创建触发器，分别调用重新创建note表和data表相关触发器的方法，确保触发器逻辑与升级后的数据库结构相匹配。
if (reCreateTriggers) {
reCreateNoteTableTriggers(db);
reCreateDataTableTriggers(db);
}
// 如果最终旧版本号与新版本号不相等，说明升级过程出现问题，抛出异常表示数据库升级失败。
if (oldVersion!= newVersion) {
throw new IllegalStateException("Upgrade notes database to version " + newVersion
+ "fails");
}
}
/**
* 执行从版本1升级到版本2的具体操作的私有方法。
* 先删除已存在的note表和data表（如果有的话），然后重新创建这两个表，以更新表结构等相关内容，
* 实现数据库从版本1到版本2的升级逻辑，比如可能涉及到表结构的调整、新增字段等情况。
*/
private void upgradeToV2(SQLiteDatabase db) {
db.execSQL("DROP TABLE IF EXISTS " + TABLE.NOTE);
db.execSQL("DROP TABLE IF EXISTS " + TABLE.DATA);
createNoteTable(db);
createDataTable(db);
}
/**
* 执行从版本2升级到版本3的具体操作的私有方法。
* 首先删除一些不再使用的触发器，避免其对后续逻辑产生干扰。
* 接着向note表中添加一个新的列（gtask_id）用于存储相关任务ID信息，扩充了note表的结构。
* 最后创建一个回收站系统文件夹，完善系统文件夹相关功能设置，实现版本2到版本3的升级逻辑。
*/
private void upgradeToV3(SQLiteDatabase db) {
// drop unused triggers
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");
// add a column for gtask id
db.execSQL("ALTER TABLE " + TABLE.NOTE + " ADD COLUMN " + NoteColumns.GTASK_ID
+ " TEXT NOT NULL DEFAULT ''");
// add a trash system folder
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);
}
/**
* 执行从版本3升级到版本4的具体操作的私有方法。
* 通过ALTER TABLE语句向note表中添加一个新的列（version），并设置默认值为0，
* 可能用于记录笔记相关的版本信息等，实现从版本3到版本4的数据库升级逻辑，完善表结构。
*/
private void upgradeToV4(SQLiteDatabase db) {
db.execSQL("ALTER TABLE " + TABLE.NOTE + " ADD COLUMN " + NoteColumns.VERSION
+ " INTEGER NOT NULL DEFAULT 0");
}
}

BIN
运行结果.png
View File

Binary file not shown.
Side by Side

Before

Width:  |  Height:  |  Size: 1.3 MiB

Write Preview
Loading…
Cancel
Save