p82feo7wg
/
MiNoteRead
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Compare commits

base: p82feo7wg:master
Branches Tags
p82feo7wg:luogang_branch
p82feo7wg:master
p82feo7wg:wangjiaqi_branch
p82feo7wg:develop
..
compare: p82feo7wg:develop
Branches Tags
p82feo7wg:luogang_branch
p82feo7wg:master
p82feo7wg:wangjiaqi_branch
p82feo7wg:develop

No commits in common. 'master' and 'develop' have entirely different histories.
master ... develop

67 changed files with 862 additions and 4193 deletions
Show Stats

BIN
doc/小米便签泛读报告.docx
View File

Binary file not shown.

BIN
doc/小米便签质量分析报告.docx
View File

Binary file not shown.

0
doc/阅读记录.docx
Unescape View File

3
src/Notes-master/res/.idea/.gitignore vendored
Unescape View File

@ -0,0 +1,3 @@
# Default ignored files
/shelf/
/workspace.xml

6
src/Notes-master/res/.idea/AndroidProjectSystem.xml
Unescape View File

@ -0,0 +1,6 @@
<?xml version="1.0" encoding="UTF-8"?>
<project version="4">
<component name="AndroidProjectSystem">
<option name="providerId" value="com.android.tools.idea.GradleProjectSystem" />
</component>
</project>

12
src/Notes-master/res/.idea/gradle.xml
Unescape View File

@ -0,0 +1,12 @@
<?xml version="1.0" encoding="UTF-8"?>
<project version="4">
<component name="GradleSettings">
<option name="linkedExternalProjectsSettings">
<GradleProjectSettings>
<option name="testRunner" value="CHOOSE_PER_TEST" />
<option name="externalProjectPath" value="$PROJECT_DIR$" />
<option name="gradleJvm" value="#JAVA_HOME" />
</GradleProjectSettings>
</option>
</component>
</project>

7
src/Notes-master/res/.idea/misc.xml
Unescape View File

@ -0,0 +1,7 @@
<?xml version="1.0" encoding="UTF-8"?>
<project version="4">
<component name="ExternalStorageConfigurationManager" enabled="true" />
<component name="ProjectRootManager">
<output url="file://$PROJECT_DIR$/out" />
</component>
</project>

17
src/Notes-master/res/.idea/runConfigurations.xml
Unescape View File

@ -0,0 +1,17 @@
<?xml version="1.0" encoding="UTF-8"?>
<project version="4">
<component name="RunConfigurationProducerService">
<option name="ignoredProducers">
<set>
<option value="com.intellij.execution.junit.AbstractAllInDirectoryConfigurationProducer" />
<option value="com.intellij.execution.junit.AllInPackageConfigurationProducer" />
<option value="com.intellij.execution.junit.PatternConfigurationProducer" />
<option value="com.intellij.execution.junit.TestInClassConfigurationProducer" />
<option value="com.intellij.execution.junit.UniqueIdConfigurationProducer" />
<option value="com.intellij.execution.junit.testDiscovery.JUnitTestDiscoveryConfigurationProducer" />
<option value="org.jetbrains.kotlin.idea.junit.KotlinJUnitRunConfigurationProducer" />
<option value="org.jetbrains.kotlin.idea.junit.KotlinPatternConfigurationProducer" />
</set>
</option>
</component>
</project>

170
src/Notes-master/res/drawable/ic_launcher_background.xml
Unescape View File

@ -1,170 +0,0 @@
<?xml version="1.0" encoding="utf-8"?>
<vector xmlns:android="http://schemas.android.com/apk/res/android"
android:width="108dp"
android:height="108dp"
android:viewportWidth="108"
android:viewportHeight="108">
<path
android:fillColor="#3DDC84"
android:pathData="M0,0h108v108h-108z" />
<path
android:fillColor="#00000000"
android:pathData="M9,0L9,108"
android:strokeWidth="0.8"
android:strokeColor="#33FFFFFF" />
<path
android:fillColor="#00000000"
android:pathData="M19,0L19,108"
android:strokeWidth="0.8"
android:strokeColor="#33FFFFFF" />
<path
android:fillColor="#00000000"
android:pathData="M29,0L29,108"
android:strokeWidth="0.8"
android:strokeColor="#33FFFFFF" />
<path
android:fillColor="#00000000"
android:pathData="M39,0L39,108"
android:strokeWidth="0.8"
android:strokeColor="#33FFFFFF" />
<path
android:fillColor="#00000000"
android:pathData="M49,0L49,108"
android:strokeWidth="0.8"
android:strokeColor="#33FFFFFF" />
<path
android:fillColor="#00000000"
android:pathData="M59,0L59,108"
android:strokeWidth="0.8"
android:strokeColor="#33FFFFFF" />
<path
android:fillColor="#00000000"
android:pathData="M69,0L69,108"
android:strokeWidth="0.8"
android:strokeColor="#33FFFFFF" />
<path
android:fillColor="#00000000"
android:pathData="M79,0L79,108"
android:strokeWidth="0.8"
android:strokeColor="#33FFFFFF" />
<path
android:fillColor="#00000000"
android:pathData="M89,0L89,108"
android:strokeWidth="0.8"
android:strokeColor="#33FFFFFF" />
<path
android:fillColor="#00000000"
android:pathData="M99,0L99,108"
android:strokeWidth="0.8"
android:strokeColor="#33FFFFFF" />
<path
android:fillColor="#00000000"
android:pathData="M0,9L108,9"
android:strokeWidth="0.8"
android:strokeColor="#33FFFFFF" />
<path
android:fillColor="#00000000"
android:pathData="M0,19L108,19"
android:strokeWidth="0.8"
android:strokeColor="#33FFFFFF" />
<path
android:fillColor="#00000000"
android:pathData="M0,29L108,29"
android:strokeWidth="0.8"
android:strokeColor="#33FFFFFF" />
<path
android:fillColor="#00000000"
android:pathData="M0,39L108,39"
android:strokeWidth="0.8"
android:strokeColor="#33FFFFFF" />
<path
android:fillColor="#00000000"
android:pathData="M0,49L108,49"
android:strokeWidth="0.8"
android:strokeColor="#33FFFFFF" />
<path
android:fillColor="#00000000"
android:pathData="M0,59L108,59"
android:strokeWidth="0.8"
android:strokeColor="#33FFFFFF" />
<path
android:fillColor="#00000000"
android:pathData="M0,69L108,69"
android:strokeWidth="0.8"
android:strokeColor="#33FFFFFF" />
<path
android:fillColor="#00000000"
android:pathData="M0,79L108,79"
android:strokeWidth="0.8"
android:strokeColor="#33FFFFFF" />
<path
android:fillColor="#00000000"
android:pathData="M0,89L108,89"
android:strokeWidth="0.8"
android:strokeColor="#33FFFFFF" />
<path
android:fillColor="#00000000"
android:pathData="M0,99L108,99"
android:strokeWidth="0.8"
android:strokeColor="#33FFFFFF" />
<path
android:fillColor="#00000000"
android:pathData="M19,29L89,29"
android:strokeWidth="0.8"
android:strokeColor="#33FFFFFF" />
<path
android:fillColor="#00000000"
android:pathData="M19,39L89,39"
android:strokeWidth="0.8"
android:strokeColor="#33FFFFFF" />
<path
android:fillColor="#00000000"
android:pathData="M19,49L89,49"
android:strokeWidth="0.8"
android:strokeColor="#33FFFFFF" />
<path
android:fillColor="#00000000"
android:pathData="M19,59L89,59"
android:strokeWidth="0.8"
android:strokeColor="#33FFFFFF" />
<path
android:fillColor="#00000000"
android:pathData="M19,69L89,69"
android:strokeWidth="0.8"
android:strokeColor="#33FFFFFF" />
<path
android:fillColor="#00000000"
android:pathData="M19,79L89,79"
android:strokeWidth="0.8"
android:strokeColor="#33FFFFFF" />
<path
android:fillColor="#00000000"
android:pathData="M29,19L29,89"
android:strokeWidth="0.8"
android:strokeColor="#33FFFFFF" />
<path
android:fillColor="#00000000"
android:pathData="M39,19L39,89"
android:strokeWidth="0.8"
android:strokeColor="#33FFFFFF" />
<path
android:fillColor="#00000000"
android:pathData="M49,19L49,89"
android:strokeWidth="0.8"
android:strokeColor="#33FFFFFF" />
<path
android:fillColor="#00000000"
android:pathData="M59,19L59,89"
android:strokeWidth="0.8"
android:strokeColor="#33FFFFFF" />
<path
android:fillColor="#00000000"
android:pathData="M69,19L69,89"
android:strokeWidth="0.8"
android:strokeColor="#33FFFFFF" />
<path
android:fillColor="#00000000"
android:pathData="M79,19L79,89"
android:strokeWidth="0.8"
android:strokeColor="#33FFFFFF" />
</vector>

30
src/Notes-master/res/drawable/ic_launcher_foreground.xml
Unescape View File

@ -1,30 +0,0 @@
<vector xmlns:android="http://schemas.android.com/apk/res/android"
xmlns:aapt="http://schemas.android.com/aapt"
android:width="108dp"
android:height="108dp"
android:viewportWidth="108"
android:viewportHeight="108">
<path android:pathData="M31,63.928c0,0 6.4,-11 12.1,-13.1c7.2,-2.6 26,-1.4 26,-1.4l38.1,38.1L107,108.928l-32,-1L31,63.928z">
<aapt:attr name="android:fillColor">
<gradient
android:endX="85.84757"
android:endY="92.4963"
android:startX="42.9492"
android:startY="49.59793"
android:type="linear">
<item
android:color="#44000000"
android:offset="0.0" />
<item
android:color="#00000000"
android:offset="1.0" />
</gradient>
</aapt:attr>
</path>
<path
android:fillColor="#FFFFFF"
android:fillType="nonZero"
android:pathData="M65.3,45.828l3.8,-6.6c0.2,-0.4 0.1,-0.9 -0.3,-1.1c-0.4,-0.2 -0.9,-0.1 -1.1,0.3l-3.9,6.7c-6.3,-2.8 -13.4,-2.8 -19.7,0l-3.9,-6.7c-0.2,-0.4 -0.7,-0.5 -1.1,-0.3C38.8,38.328 38.7,38.828 38.9,39.228l3.8,6.6C36.2,49.428 31.7,56.028 31,63.928h46C76.3,56.028 71.8,49.428 65.3,45.828zM43.4,57.328c-0.8,0 -1.5,-0.5 -1.8,-1.2c-0.3,-0.7 -0.1,-1.5 0.4,-2.1c0.5,-0.5 1.4,-0.7 2.1,-0.4c0.7,0.3 1.2,1 1.2,1.8C45.3,56.528 44.5,57.328 43.4,57.328L43.4,57.328zM64.6,57.328c-0.8,0 -1.5,-0.5 -1.8,-1.2s-0.1,-1.5 0.4,-2.1c0.5,-0.5 1.4,-0.7 2.1,-0.4c0.7,0.3 1.2,1 1.2,1.8C66.5,56.528 65.6,57.328 64.6,57.328L64.6,57.328z"
android:strokeWidth="1"
android:strokeColor="#00000000" />
</vector>

19
src/Notes-master/res/layout/activity_main.xml
Unescape View File

@ -1,19 +0,0 @@
<?xml version="1.0" encoding="utf-8"?>
<androidx.constraintlayout.widget.ConstraintLayout xmlns:android="http://schemas.android.com/apk/res/android"
xmlns:app="http://schemas.android.com/apk/res-auto"
xmlns:tools="http://schemas.android.com/tools"
android:id="@+id/main"
android:layout_width="match_parent"
android:layout_height="match_parent"
tools:context=".MainActivity">
<TextView
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:text="Hello World!"
app:layout_constraintBottom_toBottomOf="parent"
app:layout_constraintEnd_toEndOf="parent"
app:layout_constraintStart_toStartOf="parent"
app:layout_constraintTop_toTopOf="parent" />
</androidx.constraintlayout.widget.ConstraintLayout>

6
src/Notes-master/res/mipmap-anydpi/ic_launcher.xml
Unescape View File

@ -1,6 +0,0 @@
<?xml version="1.0" encoding="utf-8"?>
<adaptive-icon xmlns:android="http://schemas.android.com/apk/res/android">
<background android:drawable="@drawable/ic_launcher_background" />
<foreground android:drawable="@drawable/ic_launcher_foreground" />
<monochrome android:drawable="@drawable/ic_launcher_foreground" />
</adaptive-icon>

6
src/Notes-master/res/mipmap-anydpi/ic_launcher_round.xml
Unescape View File

@ -1,6 +0,0 @@
<?xml version="1.0" encoding="utf-8"?>
<adaptive-icon xmlns:android="http://schemas.android.com/apk/res/android">
<background android:drawable="@drawable/ic_launcher_background" />
<foreground android:drawable="@drawable/ic_launcher_foreground" />
<monochrome android:drawable="@drawable/ic_launcher_foreground" />
</adaptive-icon>

BIN
src/Notes-master/res/mipmap-hdpi/ic_launcher.webp
View File

Binary file not shown.
Side by Side

Before

Width:  |  Height:  |  Size: 1.4 KiB

BIN
src/Notes-master/res/mipmap-hdpi/ic_launcher_round.webp
View File

Binary file not shown.
Side by Side

Before

Width:  |  Height:  |  Size: 2.8 KiB

BIN
src/Notes-master/res/mipmap-mdpi/ic_launcher.webp
View File

Binary file not shown.
Side by Side

Before

Width:  |  Height:  |  Size: 982 B

BIN
src/Notes-master/res/mipmap-mdpi/ic_launcher_round.webp
View File

Binary file not shown.
Side by Side

Before

Width:  |  Height:  |  Size: 1.7 KiB

BIN
src/Notes-master/res/mipmap-xhdpi/ic_launcher.webp
View File

Binary file not shown.
Side by Side

Before

Width:  |  Height:  |  Size: 1.9 KiB

BIN
src/Notes-master/res/mipmap-xhdpi/ic_launcher_round.webp
View File

Binary file not shown.
Side by Side

Before

Width:  |  Height:  |  Size: 3.8 KiB

BIN
src/Notes-master/res/mipmap-xxhdpi/ic_launcher.webp
View File

Binary file not shown.
Side by Side

Before

Width:  |  Height:  |  Size: 2.8 KiB

BIN
src/Notes-master/res/mipmap-xxhdpi/ic_launcher_round.webp
View File

Binary file not shown.
Side by Side

Before

Width:  |  Height:  |  Size: 5.8 KiB

BIN
src/Notes-master/res/mipmap-xxxhdpi/ic_launcher.webp
View File

Binary file not shown.
Side by Side

Before

Width:  |  Height:  |  Size: 3.8 KiB

BIN
src/Notes-master/res/mipmap-xxxhdpi/ic_launcher_round.webp
View File

Binary file not shown.
Side by Side

Before

Width:  |  Height:  |  Size: 7.6 KiB

7
src/Notes-master/res/values-night/themes.xml
Unescape View File

@ -1,7 +0,0 @@
<resources xmlns:tools="http://schemas.android.com/tools">
<!-- Base application theme. -->
<style name="Base.Theme.Notesmaster" parent="Theme.Material3.DayNight.NoActionBar">
<!-- Customize your dark theme here. -->
<!-- <item name="colorPrimary">@color/my_dark_primary</item> -->
</style>
</resources>

3
src/Notes-master/res/values/styles.xml
Unescape View File

@ -63,6 +63,7 @@
</style>
<style name="NoteActionBarStyle" parent="@android:style/Widget.Holo.Light.ActionBar.Solid">
<item name="android:visibility">visible</item>
<item name="android:displayOptions" />
<item name="android:visibility">gone</item>
</style>
</resources>

9
src/Notes-master/res/values/themes.xml
Unescape View File

@ -1,9 +0,0 @@
<resources xmlns:tools="http://schemas.android.com/tools">
<!-- Base application theme. -->
<style name="Base.Theme.Notesmaster" parent="Theme.Material3.DayNight.NoActionBar">
<!-- Customize your light theme here. -->
<!-- <item name="colorPrimary">@color/my_light_primary</item> -->
</style>
<style name="Theme.Notesmaster" parent="Base.Theme.Notesmaster" />
</resources>

13
src/Notes-master/res/xml/backup_rules.xml
Unescape View File

@ -1,13 +0,0 @@
<?xml version="1.0" encoding="utf-8"?><!--
Sample backup rules file; uncomment and customize as necessary.
See https://developer.android.com/guide/topics/data/autobackup
for details.
Note: This file is ignored for devices older than API 31
See https://developer.android.com/about/versions/12/backup-restore
-->
<full-backup-content>
<!--
<include domain="sharedpref" path="."/>
<exclude domain="sharedpref" path="device.xml"/>
-->
</full-backup-content>

19
src/Notes-master/res/xml/data_extraction_rules.xml
Unescape View File

@ -1,19 +0,0 @@
<?xml version="1.0" encoding="utf-8"?><!--
Sample data extraction rules file; uncomment and customize as necessary.
See https://developer.android.com/about/versions/12/backup-restore#xml-changes
for details.
-->
<data-extraction-rules>
<cloud-backup>
<!-- TODO: Use <include> and <exclude> to control what is backed up.
<include .../>
<exclude .../>
-->
</cloud-backup>
<!--
<device-transfer>
<include .../>
<exclude .../>
</device-transfer>
-->
</data-extraction-rules>

61
src/Notes-master/src/net/micode/notes/data/Contact.java
Unescape View File

@ -25,92 +25,47 @@ import android.util.Log;
import java.util.HashMap;
/**
* 联系人查询工具类
* 核心功能：在小米便签中用于智能识别电话号码并显示联系人名称
* 实现方法：通过电话号码查询系统联系人的姓名，并通过哈希表缓存查询结果，避免重复查询，提升性能
*/
public class Contact {
// 功能：缓存查询结果，，暂时存储电话号码与联系人的映射关系，避免重复查询,节省开销
private static HashMap<String, String> sContactCache;
// 日志标签
private static final String TAG = "Contact";
// 查询联系人的选择条件
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 = '+')";
/**
* SQL语句逻辑解读
* AND 连接一个条件与下一个条件
* 第一个条件：PHONE_NUMBERS_EQUAL(Phone.NUMBER,?)
* PHONE_NUMBERS_EQUAL 函数：Android系统提供的特殊函数，用于查找和Phone.NUMBER相同的电话号码
* 第二个条件：Data.MIMETYPE = 'Phone.CONTENT_ITEM_TYPE'
* 确保数据类型必须是电话号码类型
* 第三个条件：Data.RAW_CONTACT_ID IN A
* 联系人的ID必须存在于这个表格A中
* 表格A：(SELECT raw_contact_id FROM phone_lookup WHERE min_match = '+')
* phone_lookup：Android系统中的一个与联系人数据有关的特殊表
* min_match：最小匹配位数
* 预先计算一个电话号码的最小匹配形式的表格
*/
/**
* 根据电话号码获取联系人姓名。
*
* @param context 上下文对象，用于访问 ContentResolver
* @param phoneNumber 电话号码（原始字符串，不做预处理）
* @return 联系人姓名；未找到或异常时返回 null
*/
public static String getContact(Context context, String phoneNumber) {
// 如果缓存哈希表为空，则创建新的哈希表
if(sContactCache == null) {
sContactCache = new HashMap<String, String>();
}
// 检查缓存中是否已有该电话号码对应的联系人
// 检查缓存中是否已存在该电话号码的查询结果
if(sContactCache.containsKey(phoneNumber)) {
return sContactCache.get(phoneNumber);
}
// 构建查询条件，替换min_match参数
// PhoneNumberUtils.toCallerIDMinMatch(phoneNumber)用于计算电话号码的最小匹配位数
// 将占位符"+"替换为最小匹配数,以构建完整的查询语句
String selection = CALLER_ID_SELECTION.replace("+",
PhoneNumberUtils.toCallerIDMinMatch(phoneNumber));
/**
* 查询联系人数据库
* context.getContentResolver().query：查询当前应用程序的数据
*/
Cursor cursor = context.getContentResolver().query(
Data.CONTENT_URI, // 查询URI
new String [] { Phone.DISPLAY_NAME }, // 联系人的名称作为返回值
selection, // 查询条件
new String[] { phoneNumber }, // 电话号码作为查询参数
null); // 无排序方式
// 如果找到联系人，返回名称并缓存
// 查询系统联系人数据库
Data.CONTENT_URI,
new String [] { Phone.DISPLAY_NAME },
selection,
new String[] { phoneNumber },
null);
if (cursor != null && cursor.moveToFirst()) {
try {
// 获取第一行第一列的联系人姓名
String name = cursor.getString(0);
// 将联系人和电话号码存入缓存中，以便下次查找
sContactCache.put(phoneNumber, name);
return name;
} catch (IndexOutOfBoundsException e) {
// 发生数组越界异常，将异常记录到日志Log中
Log.e(TAG, " Cursor get string error " + e.toString());
return null;
} finally {
// 关闭Cursor，防止内存泄露
cursor.close();
}
} else {
// 没有找到匹配的联系人，将信息写入日志中
Log.d(TAG, "No contact matched with number:" + phoneNumber);
return null;
}

251
src/Notes-master/src/net/micode/notes/data/Notes.java
Unescape View File

@ -17,43 +17,24 @@
package net.micode.notes.data;
import android.net.Uri;
/**
* 笔记应用的数据结构定义
* 包含所有笔记相关的常量、接口和内部类定义
* 纯定义类，不包含函数实现
*/
public class Notes {
// ContentProvider的授权标识
public static final String AUTHORITY = "micode_notes";
// 日志标签
public static final String TAG = "Notes";
// 0类型：普通笔记
public static final int TYPE_NOTE = 0;
// 1类型：文件夹
public static final int TYPE_FOLDER = 1;
// 2类型：系统文件夹
public static final int TYPE_SYSTEM = 2;
// 系统文件夹的 ID 定义。
// #ID_ROOT_FOLDER 默认根文件夹
// #ID_TEMPARAY_FOLDER 临时文件夹，移动笔记时的中转
// #ID_CALL_RECORD_FOLDER 通话记录专用文件夹
// #ID_TRASH_FOLER 回收站
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 Extra 键常量，用于在 Android 组件间通过 Intent 传递数据，包括：
* 1. 提醒日期
* 2. 背景颜色ID
* 3. 小部件ID
* 4. 小部件类型
* 5. 文件夹ID
* 6. 通话日期
* Following IDs are system folders' identifiers
* {@link Notes#ID_ROOT_FOLDER } is default folder
* {@link Notes#ID_TEMPARAY_FOLDER } is for notes belonging no folder
* {@link Notes#ID_CALL_RECORD_FOLDER} is to store call records
*/
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;
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";
@ -61,176 +42,238 @@ public class Notes {
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";
// 无效的小部件类型 -1
public static final int TYPE_WIDGET_INVALIDE = -1;
// 2x2小部件类型 0
public static final int TYPE_WIDGET_2X = 0;
// 4x4小部件类型 1
public static final int TYPE_WIDGET_4X = 1;
/**
* 数据类型常量定义
*/
public static class DataConstants {
// 普通笔记的MIME类型
public static final String NOTE = TextNote.CONTENT_ITEM_TYPE;
// 通话记录笔记的MIME类型
public static final String CALL_NOTE = CallNote.CONTENT_ITEM_TYPE;
}
// URI 是 ContentProvider 的标准访问入口，用于统一访问应用的数据。
// 查询所有笔记和文件夹的URI
public static final Uri CONTENT_NOTE_URI = Uri.parse("content://" + AUTHORITY + "/note");
// 查询数据表的URI
public static final Uri CONTENT_DATA_URI = Uri.parse("content://" + AUTHORITY + "/data");
/**
* NoteColumns 接口 - 便签表(notes表)列定义
* 定义了便签和文件夹数据库表的所有列名和类型
* Uri to query all notes and folders
*/
public static final Uri CONTENT_NOTE_URI = Uri.parse("content://" + AUTHORITY + "/note");
/**
* 笔记表的列名定义接口
* Uri to query data
*/
public interface NoteColumns {
public static final Uri CONTENT_DATA_URI = Uri.parse("content://" + AUTHORITY + "/data");
// 行的唯一ID
public interface NoteColumns {
/**
* The unique ID for a row
* <P> Type: INTEGER (long) </P>
*/
public static final String ID = "_id";
// 笔记或文件夹的父ID
/**
* The parent's id for note or folder
* <P> Type: INTEGER (long) </P>
*/
public static final String PARENT_ID = "parent_id";
// 笔记或文件夹的创建日期
/**
* Created data for note or folder
* <P> Type: INTEGER (long) </P>
*/
public static final String CREATED_DATE = "created_date";
// 最后修改日期
/**
* Latest modified date
* <P> Type: INTEGER (long) </P>
*/
public static final String MODIFIED_DATE = "modified_date";
// 提醒日期
/**
* Alert date
* <P> Type: INTEGER (long) </P>
*/
public static final String ALERTED_DATE = "alert_date";
// 文件夹名称或笔记的文本内容摘要
/**
* Folder's name or text content of note
* <P> Type: TEXT </P>
*/
public static final String SNIPPET = "snippet";
// 笔记的小部件ID
/**
* Note's widget id
* <P> Type: INTEGER (long) </P>
*/
public static final String WIDGET_ID = "widget_id";
// 笔记的小部件类型
/**
* Note's widget type
* <P> Type: INTEGER (long) </P>
*/
public static final String WIDGET_TYPE = "widget_type";
// 笔记的背景颜色ID
/**
* Note's background color's id
* <P> Type: INTEGER (long) </P>
*/
public static final String BG_COLOR_ID = "bg_color_id";
// 是否有附件；对于文本笔记没有附件，多媒体笔记至少有一个附件
/**
* For text note, it doesn't has attachment, for multi-media
* note, it has at least one attachment
* <P> Type: INTEGER </P>
*/
public static final String HAS_ATTACHMENT = "has_attachment";
// 文件夹中的笔记数量
/**
* Folder's count of notes
* <P> Type: INTEGER (long) </P>
*/
public static final String NOTES_COUNT = "notes_count";
// 文件类型：文件夹或笔记
/**
* The file type: folder or note
* <P> Type: INTEGER </P>
*/
public static final String TYPE = "type";
// 最后一次同步的ID
/**
* The last sync id
* <P> Type: INTEGER (long) </P>
*/
public static final String SYNC_ID = "sync_id";
// 标记是否在本地被修改
/**
* Sign to indicate local modified or not
* <P> Type: INTEGER </P>
*/
public static final String LOCAL_MODIFIED = "local_modified";
// 移动到临时文件夹之前的原始父ID
/**
* Original parent id before moving into temporary folder
* <P> Type : INTEGER </P>
*/
public static final String ORIGIN_PARENT_ID = "origin_parent_id";
// Google Task的ID
/**
* The gtask id
* <P> Type : TEXT </P>
*/
public static final String GTASK_ID = "gtask_id";
// 版本号
/**
* The version code
* <P> Type : INTEGER (long) </P>
*/
public static final String VERSION = "version";
}
/**
* DataColumns 接口 - 便签数据表(data表)列定义
* 定义了便签详细内容的数据表列名和类型
* 使用MIME_TYPE字段区分不同类型的便签数据（文本便签、通话记录等）
*/
public interface DataColumns {
// 行的唯一ID
/**
* The unique ID for a row
* <P> Type: INTEGER (long) </P>
*/
public static final String ID = "_id";
// 该行数据项的MIME类型
/**
* The MIME type of the item represented by this row.
* <P> Type: Text </P>
*/
public static final String MIME_TYPE = "mime_type";
// 该数据所属笔记的引用ID
/**
* The reference id to note that this data belongs to
* <P> Type: INTEGER (long) </P>
*/
public static final String NOTE_ID = "note_id";
// 笔记或文件夹的创建日期
/**
* Created data for note or folder
* <P> Type: INTEGER (long) </P>
*/
public static final String CREATED_DATE = "created_date";
// 最后修改日期
/**
* Latest modified date
* <P> Type: INTEGER (long) </P>
*/
public static final String MODIFIED_DATE = "modified_date";
// 数据内容
/**
* Data's content
* <P> Type: TEXT </P>
*/
public static final String CONTENT = "content";
// 通用数据列1
/**
* Generic data column, the meaning is {@link #MIMETYPE} specific, used for
* integer data type
* <P> Type: INTEGER </P>
*/
public static final String DATA1 = "data1";
// 通用数据列2
/**
* Generic data column, the meaning is {@link #MIMETYPE} specific, used for
* integer data type
* <P> Type: INTEGER </P>
*/
public static final String DATA2 = "data2";
// 通用数据列3
/**
* Generic data column, the meaning is {@link #MIMETYPE} specific, used for
* TEXT data type
* <P> Type: TEXT </P>
*/
public static final String DATA3 = "data3";
// 通用数据列4
/**
* Generic data column, the meaning is {@link #MIMETYPE} specific, used for
* TEXT data type
* <P> Type: TEXT </P>
*/
public static final String DATA4 = "data4";
// 通用数据列5
/**
* Generic data column, the meaning is {@link #MIMETYPE} specific, used for
* TEXT data type
* <P> Type: TEXT </P>
*/
public static final String DATA5 = "data5";
}
/**
* TextNote 类 - 文本便签数据定义
* 定义了文本便签特有的数据列和URI
*/
public static final class TextNote implements DataColumns {
// 模式标识：文本是否为清单模式
/**
* Mode to indicate the text in check list mode or not
* <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;
// 普通模式常量
public static final int MODE_NORMAL = 0;
// 文本笔记的目录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
public static final Uri CONTENT_URI = Uri.parse("content://" + AUTHORITY + "/text_note");
}
/**
* CallNote 类 - 通话记录便签数据定义
* 定义了通话记录便签特有的数据列和URI
*/
public static final class CallNote implements DataColumns {
// 通话日期
/**
* Call date for this record
* <P> Type: INTEGER (long) </P>
*/
public static final String CALL_DATE = DATA1;
// 电话号码
/**
* Phone number for this record
* <P> Type: TEXT </P>
*/
public static final String PHONE_NUMBER = DATA3;
// 联系人姓名
public static final String CONTACT_NAME = DATA4;
// 通话记录笔记的目录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
public static final Uri CONTENT_URI = Uri.parse("content://" + AUTHORITY + "/call_note");
}
}

170
src/Notes-master/src/net/micode/notes/data/NotesDatabaseHelper.java
Unescape View File

@ -26,31 +26,21 @@ import net.micode.notes.data.Notes.DataColumns;
import net.micode.notes.data.Notes.DataConstants;
import net.micode.notes.data.Notes.NoteColumns;
/**
* 笔记数据库帮助
* 负责数据库的创建、升级和维护
*/
public class NotesDatabaseHelper extends SQLiteOpenHelper {
private static final String DB_NAME = "note.db"; // 数据库名称
private static final int DB_VERSION = 4; // 数据库版本
;
/**
* 数据库表名定义接口
*/
private static final String DB_NAME = "note.db";
private static final int DB_VERSION = 4;
public interface TABLE {
/** 笔记表名 */
public static final String NOTE = "note";
/** 数据表名 */
public static final String DATA = "data";
}
private static final String TAG = "NotesDatabaseHelper";
private static final String TAG = "NotesDatabaseHelper"; // 日志标签
private static NotesDatabaseHelper mInstance; // 单例实例
/** 数据库帮助类的单例实例 */
private static NotesDatabaseHelper mInstance;
private static final String CREATE_NOTE_TABLE_SQL =
"CREATE TABLE " + TABLE.NOTE + "(" +
@ -73,7 +63,6 @@ public class NotesDatabaseHelper extends SQLiteOpenHelper {
NoteColumns.VERSION + " INTEGER NOT NULL DEFAULT 0" +
")";
// 创建笔记数据表的SQL语句
private static final String CREATE_DATA_TABLE_SQL =
"CREATE TABLE " + TABLE.DATA + "(" +
DataColumns.ID + " INTEGER PRIMARY KEY," +
@ -89,18 +78,24 @@ public class NotesDatabaseHelper extends SQLiteOpenHelper {
DataColumns.DATA5 + " TEXT NOT NULL DEFAULT ''" +
")";
// 创建笔记数据表中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 + ");";
/**
* 当笔记移动到文件夹时增加文件夹的笔记计数
* Increase folder's note count when move note to the folder
*/
private static final String NOTE_INCREASE_FOLDER_COUNT_ON_UPDATE_TRIGGER ="CREATE TRIGGER increase_folder_count_on_update "+" AFTER UPDATE OF " + NoteColumns.PARENT_ID + " ON " + TABLE.NOTE +" BEGIN " +" UPDATE " + TABLE.NOTE +" SET " + NoteColumns.NOTES_COUNT + "=" + NoteColumns.NOTES_COUNT + " + 1" +" WHERE " + NoteColumns.ID + "=new." + NoteColumns.PARENT_ID + ";" +" END";
private static final String NOTE_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";
/**
* 当笔记从文件夹移走时减少文件夹的笔记计数
* Decrease folder's note count when move note from folder
*/
private static final String NOTE_DECREASE_FOLDER_COUNT_ON_UPDATE_TRIGGER =
"CREATE TRIGGER decrease_folder_count_on_update " +
@ -113,7 +108,7 @@ public class NotesDatabaseHelper extends SQLiteOpenHelper {
" END";
/**
* 当向文件夹中插入新笔记时增加文件夹的笔记计数
* Increase folder's note count when insert new note to the folder
*/
private static final String NOTE_INCREASE_FOLDER_COUNT_ON_INSERT_TRIGGER =
"CREATE TRIGGER increase_folder_count_on_insert " +
@ -125,7 +120,7 @@ public class NotesDatabaseHelper extends SQLiteOpenHelper {
" END";
/**
* 当从文件夹中删除笔记时减少文件夹的笔记计数
* Decrease folder's note count when delete note from the folder
*/
private static final String NOTE_DECREASE_FOLDER_COUNT_ON_DELETE_TRIGGER =
"CREATE TRIGGER decrease_folder_count_on_delete " +
@ -137,7 +132,9 @@ public class NotesDatabaseHelper extends SQLiteOpenHelper {
" AND " + NoteColumns.NOTES_COUNT + ">0;" +
" END";
/**插入 TEXT_NOTE 类型的数据行时，用数据内容刷新 note.snippet */
/**
* Update note's content when insert data with type {@link DataConstants#NOTE}
*/
private static final String DATA_UPDATE_NOTE_CONTENT_ON_INSERT_TRIGGER =
"CREATE TRIGGER update_note_content_on_insert " +
" AFTER INSERT ON " + TABLE.DATA +
@ -148,7 +145,9 @@ public class NotesDatabaseHelper extends SQLiteOpenHelper {
" WHERE " + NoteColumns.ID + "=new." + DataColumns.NOTE_ID + ";" +
" END";
/**更新 TEXT_NOTE 数据行时，同步更新 note.snippet */
/**
* Update note's content when data with {@link DataConstants#NOTE} type has changed
*/
private static final String DATA_UPDATE_NOTE_CONTENT_ON_UPDATE_TRIGGER =
"CREATE TRIGGER update_note_content_on_update " +
" AFTER UPDATE ON " + TABLE.DATA +
@ -159,7 +158,9 @@ public class NotesDatabaseHelper extends SQLiteOpenHelper {
" WHERE " + NoteColumns.ID + "=new." + DataColumns.NOTE_ID + ";" +
" END";
/** 删除 TEXT_NOTE 数据行时，清空 note.snippet */
/**
* Update note's content when data with {@link DataConstants#NOTE} type has deleted
*/
private static final String DATA_UPDATE_NOTE_CONTENT_ON_DELETE_TRIGGER =
"CREATE TRIGGER update_note_content_on_delete " +
" AFTER delete ON " + TABLE.DATA +
@ -171,7 +172,7 @@ public class NotesDatabaseHelper extends SQLiteOpenHelper {
" END";
/**
* 删除已删除笔记的数据
* Delete datas belong to note which has been deleted
*/
private static final String NOTE_DELETE_DATA_ON_DELETE_TRIGGER =
"CREATE TRIGGER delete_data_on_delete " +
@ -182,7 +183,7 @@ public class NotesDatabaseHelper extends SQLiteOpenHelper {
" END";
/**
* 删除已删除文件夹下的所有笔记
* Delete notes belong to folder which has been deleted
*/
private static final String FOLDER_DELETE_NOTES_ON_DELETE_TRIGGER =
"CREATE TRIGGER folder_delete_notes_on_delete " +
@ -193,7 +194,7 @@ public class NotesDatabaseHelper extends SQLiteOpenHelper {
" END";
/**
* 当文件夹被移到回收站时，将其所有笔记也移到回收站
* Move notes belong to folder which has been moved to trash folder
*/
private static final String FOLDER_MOVE_NOTES_ON_TRASH_TRIGGER =
"CREATE TRIGGER folder_move_notes_on_trash " +
@ -205,31 +206,18 @@ public class NotesDatabaseHelper extends SQLiteOpenHelper {
" WHERE " + NoteColumns.PARENT_ID + "=old." + NoteColumns.ID + ";" +
" END";
/**
* 构造方法
* @param context 上下文对象
*/
public NotesDatabaseHelper(Context context) {
super(context, DB_NAME, null, DB_VERSION);
}
/**
* 创建笔记表
* @param db 数据库对象
*/
public void createNoteTable(SQLiteDatabase db) {
db.execSQL(CREATE_NOTE_TABLE_SQL); // 创建笔记表结构
reCreateNoteTableTriggers(db); // 重建笔记表触发器
createSystemFolder(db); // 创建系统文件夹
db.execSQL(CREATE_NOTE_TABLE_SQL);
reCreateNoteTableTriggers(db);
createSystemFolder(db);
Log.d(TAG, "note table has been created");
}
/**
* 重建笔记表的触发器
* @param db 数据库对象
*/
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");
@ -238,7 +226,6 @@ public class NotesDatabaseHelper extends SQLiteOpenHelper {
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);
@ -248,71 +235,58 @@ public class NotesDatabaseHelper extends SQLiteOpenHelper {
db.execSQL(FOLDER_MOVE_NOTES_ON_TRASH_TRIGGER);
}
/**
* 创建系统文件夹
* @param db 数据库对象
*/
private void createSystemFolder(SQLiteDatabase db) {
ContentValues values = new ContentValues();
/**
* 通话记录文件夹，用于存储通话记录笔记
* 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);
// 创建根文件夹（默认文件夹）
/**
* 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);
// 创建临时文件夹（用于移动笔记）
/**
* 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);
// 创建回收站文件夹
/**
* 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);
}
/**
* 创建笔记数据表
* @param db 数据库对象
*/
public void createDataTable(SQLiteDatabase db) {
db.execSQL(CREATE_DATA_TABLE_SQL); // 创建笔记数据表结构
reCreateDataTableTriggers(db); // 重建笔记数据表触发器
db.execSQL(CREATE_DATA_NOTE_ID_INDEX_SQL); // 创建note_id列索引
db.execSQL(CREATE_DATA_TABLE_SQL);
reCreateDataTableTriggers(db);
db.execSQL(CREATE_DATA_NOTE_ID_INDEX_SQL);
Log.d(TAG, "data table has been created");
}
/**
* 重建笔记数据表的触发器
* @param db 数据库对象
*/
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的单例实例
* @param context 上下文对象
* @return NotesDatabaseHelper的单例实例
*/
static synchronized NotesDatabaseHelper getInstance(Context context) {
if (mInstance == null) {
mInstance = new NotesDatabaseHelper(context);
@ -320,97 +294,67 @@ public class NotesDatabaseHelper extends SQLiteOpenHelper {
return mInstance;
}
/** 创建数据库：依次创建 note 表与 data 表 */
@Override
public void onCreate(SQLiteDatabase db) {
createNoteTable(db); // 创建笔记表
createDataTable(db); // 创建笔记数据表
createNoteTable(db);
createDataTable(db);
}
/**
* 当数据库版本需要更新时调用
* @param db 数据库对象
* @param oldVersion 旧版本号
* @param newVersion 新版本号
*/
@Override
public void onUpgrade(SQLiteDatabase db, int oldVersion, int newVersion) {
boolean reCreateTriggers = false;
boolean skipV2 = false;
boolean reCreateTriggers = false; // 是否需要重建触发器
boolean skipV2 = false; // 是否跳过版本2的升级
// 从版本1升级
if (oldVersion == 1) {
upgradeToV2(db);
skipV2 = true; // this upgrade including the upgrade from v2 to v3
oldVersion++;
}
// 从版本2升级（跳过已在版本1升级中处理的情况）
if (oldVersion == 2 && !skipV2) {
upgradeToV3(db);
reCreateTriggers = true;
oldVersion++;
}
// 从版本3升级
if (oldVersion == 3) {
upgradeToV4(db);
oldVersion++;
}
// 如果需要，重建触发器
if (reCreateTriggers) {
reCreateNoteTableTriggers(db);
reCreateDataTableTriggers(db);
}
// 检查升级是否成功
if (oldVersion != newVersion) {
throw new IllegalStateException("Upgrade notes database to version " + newVersion);
throw new IllegalStateException("Upgrade notes database to version " + newVersion
+ "fails");
}
}
/**
* 将数据库升级到版本2
* @param db 数据库对象
*/
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);
}
/**
* 将数据库升级到版本3
* @param db 数据库对象
*/
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");
// 添加gtask_id列用于同步
// 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);
}
/**
* 将数据库升级到版本4
* @param db 数据库对象
*/
private void upgradeToV4(SQLiteDatabase db) {
db.execSQL("ALTER TABLE " + TABLE.NOTE + " ADD COLUMN " + NoteColumns.VERSION
+ " INTEGER NOT NULL DEFAULT 0");

130
src/Notes-master/src/net/micode/notes/data/NotesProvider.java
Unescape View File

@ -35,58 +35,35 @@ import net.micode.notes.data.Notes.NoteColumns;
import net.micode.notes.data.NotesDatabaseHelper.TABLE;
/**
* 笔记内容提供者
* 负责处理笔记和数据的CRUD操作，提供ContentProvider接口
* 支持搜索和搜索建议功能
*/
public class NotesProvider extends ContentProvider {
private static final UriMatcher mMatcher;
private static final UriMatcher mMatcher; // URI匹配器，用于解析不同类型的URI请求
// 数据库帮助类实例，负责获取读写数据库
private NotesDatabaseHelper mHelper;
private static final String TAG = "NotesProvider"; // 日志标签
private static final String TAG = "NotesProvider";
// URI匹配码：笔记列表
private static final int URI_NOTE = 1;
// URI匹配码：单个笔记
private static final int URI_NOTE_ITEM = 2;
// URI匹配码：数据列表
private static final int URI_DATA = 3;
// URI匹配码：单个数据项
private static final int URI_DATA_ITEM = 4;
// URI匹配码：搜索
private static final int URI_SEARCH = 5;
// URI匹配码：搜索建议
private static final int URI_SEARCH_SUGGEST = 6;
/**
* 静态初始化块 - 配置URI匹配规则
*/
static {
mMatcher = new UriMatcher(UriMatcher.NO_MATCH);
// 笔记集合URI
mMatcher.addURI(Notes.AUTHORITY, "note", URI_NOTE);
// 单个笔记URI（带ID）
mMatcher.addURI(Notes.AUTHORITY, "note/#", URI_NOTE_ITEM);
// 笔记数据集合URI
mMatcher.addURI(Notes.AUTHORITY, "data", URI_DATA);
// 单个笔记数据URI（带ID）
mMatcher.addURI(Notes.AUTHORITY, "data/#", URI_DATA_ITEM);
// 搜索URI
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);
}
/**
* 笔记搜索投影字段。
* x'0A' 代表 SQLite 中的换行符；搜索时去掉换行与空格，便于列表展示更多内容。
* x'0A' represents the '\n' character in sqlite. For title and content in the search result,
* we will trim '\n' and white space in order to show more information.
*/
private static final String NOTES_SEARCH_PROJECTION = NoteColumns.ID + ","
+ NoteColumns.ID + " AS " + SearchManager.SUGGEST_COLUMN_INTENT_EXTRA_DATA + ","
@ -96,35 +73,18 @@ public class NotesProvider extends ContentProvider {
+ "'" + Intent.ACTION_VIEW + "' AS " + SearchManager.SUGGEST_COLUMN_INTENT_ACTION + ","
+ "'" + Notes.TextNote.CONTENT_TYPE + "' AS " + SearchManager.SUGGEST_COLUMN_INTENT_DATA;
/**
* 笔记片段搜索查询语句
* 只搜索非回收站中的普通笔记，根据内容片段进行模糊匹配
*/
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;
/**
* 内容提供者创建时调用
* 初始化数据库帮助类实例
*/
@Override
public boolean onCreate() {
mHelper = NotesDatabaseHelper.getInstance(getContext());
return true;
}
/**
* 查询方法 - 处理对笔记和数据的查询请求
* @param uri 请求的URI
* @param projection 查询的列
* @param selection 查询条件
* @param selectionArgs 查询条件参数
* @param sortOrder 排序方式
* @return 查询结果游标
*/
@Override
public Cursor query(Uri uri, String[] projection, String selection, String[] selectionArgs,
String sortOrder) {
@ -132,27 +92,26 @@ public class NotesProvider extends ContentProvider {
SQLiteDatabase db = mHelper.getReadableDatabase();
String id = null;
switch (mMatcher.match(uri)) {
case URI_NOTE: // 查询笔记集合
case URI_NOTE:
c = db.query(TABLE.NOTE, projection, selection, selectionArgs, null, null,
sortOrder);
break;
case URI_NOTE_ITEM: // 查询单个笔记
case URI_NOTE_ITEM:
id = uri.getPathSegments().get(1);
c = db.query(TABLE.NOTE, projection, NoteColumns.ID + "=" + id
+ parseSelection(selection), selectionArgs, null, null, sortOrder);
break;
case URI_DATA: // 查询笔记数据集合
case URI_DATA:
c = db.query(TABLE.DATA, projection, selection, selectionArgs, null, null,
sortOrder);
break;
case URI_DATA_ITEM: // 查询单个笔记数据
case URI_DATA_ITEM:
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: // 搜索建议请求
case URI_SEARCH:
case URI_SEARCH_SUGGEST:
if (sortOrder != null || projection != null) {
throw new IllegalArgumentException(
"do not specify sortOrder, selection, selectionArgs, or projection" + "with this query");
@ -183,27 +142,20 @@ public class NotesProvider extends ContentProvider {
throw new IllegalArgumentException("Unknown URI " + uri);
}
if (c != null) {
// 通知游标所关联的 URI，用于后续数据变更时自动刷新
c.setNotificationUri(getContext().getContentResolver(), uri);
}
return c;
}
/**
* 插入方法 - 处理对笔记和数据的插入请求
* @param uri 请求的URI
* @param values 要插入的数据
* @return 插入后的资源URI
*/
@Override
public Uri insert(Uri uri, ContentValues values) {
SQLiteDatabase db = mHelper.getWritableDatabase();
long dataId = 0, noteId = 0, insertedId = 0;
switch (mMatcher.match(uri)) {
case URI_NOTE: // 插入笔记
case URI_NOTE:
insertedId = noteId = db.insert(TABLE.NOTE, null, values);
break;
case URI_DATA: // 插入笔记数据
case URI_DATA:
if (values.containsKey(DataColumns.NOTE_ID)) {
noteId = values.getAsLong(DataColumns.NOTE_ID);
} else {
@ -214,13 +166,13 @@ public class NotesProvider extends ContentProvider {
default:
throw new IllegalArgumentException("Unknown URI " + uri);
}
// 通知笔记 URI 变化（noteId>0 时）
// Notify the note uri
if (noteId > 0) {
getContext().getContentResolver().notifyChange(
ContentUris.withAppendedId(Notes.CONTENT_NOTE_URI, noteId), null);
}
// 通知数据 URI 变化（dataId>0 时）
// Notify the data uri
if (dataId > 0) {
getContext().getContentResolver().notifyChange(
ContentUris.withAppendedId(Notes.CONTENT_DATA_URI, dataId), null);
@ -229,13 +181,6 @@ public class NotesProvider extends ContentProvider {
return ContentUris.withAppendedId(uri, insertedId);
}
/**
* 删除方法 - 处理对笔记和数据的删除请求
* @param uri 请求的URI
* @param selection 删除条件
* @param selectionArgs 删除条件参数
* @return 删除的行数
*/
@Override
public int delete(Uri uri, String selection, String[] selectionArgs) {
int count = 0;
@ -252,7 +197,6 @@ public class NotesProvider extends ContentProvider {
/**
* ID that smaller than 0 is system folder which is not allowed to
* trash
* ID小于0的是系统文件夹，不允许删除
*/
long noteId = Long.valueOf(id);
if (noteId <= 0) {
@ -276,7 +220,6 @@ public class NotesProvider extends ContentProvider {
}
if (count > 0) {
if (deleteData) {
// 数据行删除会影响笔记摘要，通知笔记 URI
getContext().getContentResolver().notifyChange(Notes.CONTENT_NOTE_URI, null);
}
getContext().getContentResolver().notifyChange(uri, null);
@ -284,37 +227,28 @@ public class NotesProvider extends ContentProvider {
return count;
}
/**
* 更新数据库中的数据
* @param uri 要更新的内容URI
* @param values 要更新的列值
* @param selection 更新条件
* @param selectionArgs 更新条件参数
* @return 更新的行数
*/
@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; // 是否更新了数据内容
boolean updateData = false;
switch (mMatcher.match(uri)) {
case URI_NOTE: // 更新所有笔记
increaseNoteVersion(-1, selection, selectionArgs); // 增加笔记版本号
case URI_NOTE:
increaseNoteVersion(-1, selection, selectionArgs);
count = db.update(TABLE.NOTE, values, selection, selectionArgs);
break;
case URI_NOTE_ITEM: // 更新单个笔记
case URI_NOTE_ITEM:
id = uri.getPathSegments().get(1);
increaseNoteVersion(Long.valueOf(id), selection, selectionArgs); // 增加笔记版本号
increaseNoteVersion(Long.valueOf(id), selection, selectionArgs);
count = db.update(TABLE.NOTE, values, NoteColumns.ID + "=" + id
+ parseSelection(selection), selectionArgs);
break;
case URI_DATA: // 更新所有笔记数据
case URI_DATA:
count = db.update(TABLE.DATA, values, selection, selectionArgs);
updateData = true;
break;
case URI_DATA_ITEM: // 更新单个笔记数据
case URI_DATA_ITEM:
id = uri.getPathSegments().get(1);
count = db.update(TABLE.DATA, values, DataColumns.ID + "=" + id
+ parseSelection(selection), selectionArgs);
@ -326,32 +260,17 @@ public class NotesProvider extends ContentProvider {
if (count > 0) {
if (updateData) {
// 数据行更新影响笔记摘要，通知笔记 URI
getContext().getContentResolver().notifyChange(Notes.CONTENT_NOTE_URI, null);
}
// 通知URI的观察者数据已更改
getContext().getContentResolver().notifyChange(uri, null);
}
return count;
}
/**
* 拼接 WHERE 子句，如果传入 selection 非空则加上 AND (...)。
*
* @param selection 选择条件
* @return 格式化后的选择条件
*/
private String parseSelection(String selection) {
return (!TextUtils.isEmpty(selection) ? " AND (" + selection + ")" : "");
return (!TextUtils.isEmpty(selection) ? " AND (" + selection + ')' : "");
}
/**
* 增加笔记版本号，用于标记被修改过。
* 用于记录笔记的修改版本，支持并发更新场景
* @param id 笔记ID；小于0表示不按ID过滤，仅使用 selection
* @param selection 选择条件
* @param selectionArgs 选择参数
*/
private void increaseNoteVersion(long id, String selection, String[] selectionArgs) {
StringBuilder sql = new StringBuilder(120);
sql.append("UPDATE ");
@ -377,11 +296,6 @@ public class NotesProvider extends ContentProvider {
mHelper.getWritableDatabase().execSQL(sql.toString());
}
/**
* 获取内容URI对应的MIME类型
* @param uri 内容URI
* @return MIME类型 - 目前未完全实现，返回null
*/
@Override
public String getType(Uri uri) {
// TODO Auto-generated method stub

39
src/Notes-master/src/net/micode/notes/gtask/data/MetaData.java
Unescape View File

@ -25,22 +25,11 @@ import org.json.JSONException;
import org.json.JSONObject;
/**
* 元数据 - 继承自Task
* 用于处理Google任务的元数据信息
*/
public class MetaData extends Task {
// 日志标签
private final static String TAG = MetaData.class.getSimpleName();
// 相关的Google任务ID
private String mRelatedGid = null;
/**
* 设置元数据
* @param gid Google任务ID
* @param metaInfo 元信息JSON对象
*/
public void setMeta(String gid, JSONObject metaInfo) {
try {
metaInfo.put(GTaskStringUtils.META_HEAD_GTASK_ID, gid);
@ -51,27 +40,15 @@ public class MetaData extends Task {
setName(GTaskStringUtils.META_NOTE_NAME);
}
/**
* 获取相关的Google任务ID
* @return 相关的Google任务ID
*/
public String getRelatedGid() {
return mRelatedGid;
}
/**
* 判断是否值得保存
* @return 如果有元信息则返回true，否则返回false
*/
@Override
public boolean isWorthSaving() {
return getNotes() != null;
}
/**
* 通过远程JSON设置内容
* @param js 远程JSON对象
*/
@Override
public void setContentByRemoteJSON(JSONObject js) {
super.setContentByRemoteJSON(js);
@ -86,33 +63,17 @@ public class MetaData extends Task {
}
}
/**
* 通过本地JSON设置内容
* 该方法不应该被调用
* @param js 本地JSON对象
*/
@Override
public void setContentByLocalJSON(JSONObject js) {
// this function should not be called
throw new IllegalAccessError("MetaData:setContentByLocalJSON should not be called");
}
/**
* 从内容获取本地JSON
* 该方法不应该被调用
* @return 本地JSON对象
*/
@Override
public JSONObject getLocalJSONFromContent() {
throw new IllegalAccessError("MetaData:getLocalJSONFromContent should not be called");
}
/**
* 获取同步操作
* 该方法不应该被调用
* @param c 游标
* @return 同步操作类型
*/
@Override
public int getSyncAction(Cursor c) {
throw new IllegalAccessError("MetaData:getSyncAction should not be called");

110
src/Notes-master/src/net/micode/notes/gtask/data/Node.java
Unescape View File

@ -20,32 +20,33 @@ import android.database.Cursor;
import org.json.JSONObject;
/**
* 同步节点抽象 - 定义了同步操作的基本结构和接口
* 所有需要进行同步的对象都应该继承这个类
*/
public abstract class Node {
// 同步操作类型常量
public static final int SYNC_ACTION_NONE = 0; // 无操作
public static final int SYNC_ACTION_ADD_REMOTE = 1; // 远程添加
public static final int SYNC_ACTION_ADD_LOCAL = 2; // 本地添加
public static final int SYNC_ACTION_DEL_REMOTE = 3; // 远程删除
public static final int SYNC_ACTION_DEL_LOCAL = 4; // 本地删除
public static final int SYNC_ACTION_UPDATE_REMOTE = 5; // 远程更新
public static final int SYNC_ACTION_UPDATE_LOCAL = 6; // 本地更新
public static final int SYNC_ACTION_UPDATE_CONFLICT = 7; // 更新冲突
public static final int SYNC_ACTION_ERROR = 8; // 同步错误
// 成员变量
private String mGid; // Google任务ID
private String mName; // 节点名称
private long mLastModified; // 最后修改时间戳
private boolean mDeleted; // 是否已删除
/**
* 构造函数
* 初始化节点的基本属性
*/
public static final int SYNC_ACTION_NONE = 0;
public static final int SYNC_ACTION_ADD_REMOTE = 1;
public static final int SYNC_ACTION_ADD_LOCAL = 2;
public static final int SYNC_ACTION_DEL_REMOTE = 3;
public static final int SYNC_ACTION_DEL_LOCAL = 4;
public static final int SYNC_ACTION_UPDATE_REMOTE = 5;
public static final int SYNC_ACTION_UPDATE_LOCAL = 6;
public static final int SYNC_ACTION_UPDATE_CONFLICT = 7;
public static final int SYNC_ACTION_ERROR = 8;
private String mGid;
private String mName;
private long mLastModified;
private boolean mDeleted;
public Node() {
mGid = null;
mName = "";
@ -53,105 +54,46 @@ public abstract class Node {
mDeleted = false;
}
/**
* 获取创建操作的JSON对象
* @param actionId 操作ID
* @return 创建操作的JSON对象
*/
public abstract JSONObject getCreateAction(int actionId);
/**
* 获取更新操作的JSON对象
* @param actionId 操作ID
* @return 更新操作的JSON对象
*/
public abstract JSONObject getUpdateAction(int actionId);
/**
* 通过远程JSON设置内容
* @param js 远程JSON对象
*/
public abstract void setContentByRemoteJSON(JSONObject js);
/**
* 通过本地JSON设置内容
* @param js 本地JSON对象
*/
public abstract void setContentByLocalJSON(JSONObject js);
/**
* 从内容获取本地JSON
* @return 本地JSON对象
*/
public abstract JSONObject getLocalJSONFromContent();
/**
* 获取同步操作类型
* @param c 游标
* @return 同步操作类型
*/
public abstract int getSyncAction(Cursor c);
/**
* 设置Google任务ID
* @param gid Google任务ID
*/
public void setGid(String gid) {
this.mGid = gid;
}
/**
* 设置节点名称
* @param name 节点名称
*/
public void setName(String name) {
this.mName = name;
}
/**
* 设置最后修改时间
* @param lastModified 最后修改时间戳
*/
public void setLastModified(long lastModified) {
this.mLastModified = lastModified;
}
/**
* 设置删除状态
* @param deleted 是否已删除
*/
public void setDeleted(boolean deleted) {
this.mDeleted = deleted;
}
/**
* 获取Google任务ID
* @return Google任务ID
*/
public String getGid() {
return this.mGid;
}
/**
* 获取节点名称
* @return 节点名称
*/
public String getName() {
return this.mName;
}
/**
* 获取最后修改时间
* @return 最后修改时间戳
*/
public long getLastModified() {
return this.mLastModified;
}
/**
* 获取删除状态
* @return 是否已删除
*/
public boolean getDeleted() {
return this.mDeleted;
}

84
src/Notes-master/src/net/micode/notes/gtask/data/SqlData.java
Unescape View File

@ -35,44 +35,42 @@ import org.json.JSONException;
import org.json.JSONObject;
/**
* SQL数据处理 - 负责处理笔记数据的CRUD操作
* 与ContentResolver交互，实现数据的加载、保存和更新
*/
public class SqlData {
// 日志标签
private static final String TAG = SqlData.class.getSimpleName();
// 无效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
};
// 投影列索引常量
public static final int DATA_ID_COLUMN = 0; // 数据ID列
public static final int DATA_MIME_TYPE_COLUMN = 1; // MIME类型列
public static final int DATA_CONTENT_COLUMN = 2; // 内容列
public static final int DATA_CONTENT_DATA_1_COLUMN = 3; // DATA1列
public static final int DATA_CONTENT_DATA_3_COLUMN = 4; // DATA3列
// 成员变量
private ContentResolver mContentResolver; // 内容解析器
private boolean mIsCreate; // 是否为创建模式
private long mDataId; // 数据ID
private String mDataMimeType; // 数据MIME类型
private String mDataContent; // 数据内容
private long mDataContentData1; // DATA1字段值
private String mDataContentData3; // DATA3字段值
private ContentValues mDiffDataValues; // 差异数据值，用于更新操作
/**
* 构造函数 - 创建新的数据对象
* @param context 上下文对象
*/
public static final int DATA_ID_COLUMN = 0;
public static final int DATA_MIME_TYPE_COLUMN = 1;
public static final int DATA_CONTENT_COLUMN = 2;
public static final int DATA_CONTENT_DATA_1_COLUMN = 3;
public static final int DATA_CONTENT_DATA_3_COLUMN = 4;
private ContentResolver mContentResolver;
private boolean mIsCreate;
private long mDataId;
private String mDataMimeType;
private String mDataContent;
private long mDataContentData1;
private String mDataContentData3;
private ContentValues mDiffDataValues;
public SqlData(Context context) {
mContentResolver = context.getContentResolver();
mIsCreate = true;
@ -84,11 +82,6 @@ public class SqlData {
mDiffDataValues = new ContentValues();
}
/**
* 构造函数 - 从数据库游标创建数据对象
* @param context 上下文对象
* @param c 数据库游标
*/
public SqlData(Context context, Cursor c) {
mContentResolver = context.getContentResolver();
mIsCreate = false;
@ -96,10 +89,6 @@ public class SqlData {
mDiffDataValues = new ContentValues();
}
/**
* 从游标加载数据
* @param c 数据库游标
*/
private void loadFromCursor(Cursor c) {
mDataId = c.getLong(DATA_ID_COLUMN);
mDataMimeType = c.getString(DATA_MIME_TYPE_COLUMN);
@ -108,11 +97,6 @@ public class SqlData {
mDataContentData3 = c.getString(DATA_CONTENT_DATA_3_COLUMN);
}
/**
* 通过JSON对象设置数据内容
* @param js JSON对象，包含数据内容
* @throws JSONException JSON解析异常
*/
public void setContent(JSONObject js) throws JSONException {
long dataId = js.has(DataColumns.ID) ? js.getLong(DataColumns.ID) : INVALID_ID;
if (mIsCreate || mDataId != dataId) {
@ -146,11 +130,6 @@ public class SqlData {
mDataContentData3 = dataContentData3;
}
/**
* 获取数据内容的JSON对象
* @return 包含数据内容的JSON对象
* @throws JSONException JSON解析异常
*/
public JSONObject getContent() throws JSONException {
if (mIsCreate) {
Log.e(TAG, "it seems that we haven't created this in database yet");
@ -165,13 +144,6 @@ public class SqlData {
return js;
}
/**
* 提交数据到数据库
* @param noteId 笔记ID
* @param validateVersion 是否验证版本
* @param version 版本号
* @throws ActionFailureException 操作失败异常
*/
public void commit(long noteId, boolean validateVersion, long version) {
if (mIsCreate) {
@ -211,10 +183,6 @@ public class SqlData {
mIsCreate = false;
}
/**
* 获取数据ID
* @return 数据ID
*/
public long getId() {
return mDataId;
}

216
src/Notes-master/src/net/micode/notes/gtask/data/SqlNote.java
Unescape View File

@ -38,21 +38,11 @@ import org.json.JSONObject;
import java.util.ArrayList;
/**
* SqlNote - 用于管理笔记和相关数据的同步操作
* 该类负责将笔记数据与 Google Tasks 进行同步，处理数据的创建、更新和删除操作
*/
public class SqlNote {
private static final String TAG = SqlNote.class.getSimpleName();
/**
* 无效ID常量 - 用于标记未创建或无效的笔记ID
*/
private static final int INVALID_ID = -99999;
/**
* 笔记查询投影数组 - 定义从数据库查询笔记时返回的列
*/
public static final String[] PROJECTION_NOTE = new String[] {
NoteColumns.ID, NoteColumns.ALERTED_DATE, NoteColumns.BG_COLOR_ID,
NoteColumns.CREATED_DATE, NoteColumns.HAS_ATTACHMENT, NoteColumns.MODIFIED_DATE,
@ -62,185 +52,76 @@ public class SqlNote {
NoteColumns.VERSION
};
/**
* 笔记ID列索引 - PROJECTION_NOTE数组中ID列的位置
*/
public static final int ID_COLUMN = 0;
/**
* 提醒日期列索引 - PROJECTION_NOTE数组中提醒日期列的位置
*/
public static final int ALERTED_DATE_COLUMN = 1;
/**
* 背景颜色ID列索引 - PROJECTION_NOTE数组中背景颜色ID列的位置
*/
public static final int BG_COLOR_ID_COLUMN = 2;
/**
* 创建日期列索引 - PROJECTION_NOTE数组中创建日期列的位置
*/
public static final int CREATED_DATE_COLUMN = 3;
/**
* 是否有附件列索引 - PROJECTION_NOTE数组中是否有附件列的位置
*/
public static final int HAS_ATTACHMENT_COLUMN = 4;
/**
* 修改日期列索引 - PROJECTION_NOTE数组中修改日期列的位置
*/
public static final int MODIFIED_DATE_COLUMN = 5;
/**
* 笔记数量列索引 - PROJECTION_NOTE数组中笔记数量列的位置
*/
public static final int NOTES_COUNT_COLUMN = 6;
/**
* 父文件夹ID列索引 - PROJECTION_NOTE数组中父文件夹ID列的位置
*/
public static final int PARENT_ID_COLUMN = 7;
/**
* 笔记摘要列索引 - PROJECTION_NOTE数组中笔记摘要列的位置
*/
public static final int SNIPPET_COLUMN = 8;
/**
* 笔记类型列索引 - PROJECTION_NOTE数组中笔记类型列的位置
*/
public static final int TYPE_COLUMN = 9;
/**
* 小部件ID列索引 - PROJECTION_NOTE数组中小部件ID列的位置
*/
public static final int WIDGET_ID_COLUMN = 10;
/**
* 小部件类型列索引 - PROJECTION_NOTE数组中小部件类型列的位置
*/
public static final int WIDGET_TYPE_COLUMN = 11;
/**
* 同步ID列索引 - PROJECTION_NOTE数组中同步ID列的位置
*/
public static final int SYNC_ID_COLUMN = 12;
/**
* 本地修改状态列索引 - PROJECTION_NOTE数组中本地修改状态列的位置
*/
public static final int LOCAL_MODIFIED_COLUMN = 13;
/**
* 原始父文件夹ID列索引 - PROJECTION_NOTE数组中原始父文件夹ID列的位置
*/
public static final int ORIGIN_PARENT_ID_COLUMN = 14;
/**
* Google Tasks ID列索引 - PROJECTION_NOTE数组中Google Tasks ID列的位置
*/
public static final int GTASK_ID_COLUMN = 15;
/**
* 版本号列索引 - PROJECTION_NOTE数组中版本号列的位置
*/
public static final int VERSION_COLUMN = 16;
/**
* 上下文对象 - 用于访问应用资源和内容解析器
*/
private Context mContext;
/**
* 内容解析器 - 用于访问ContentProvider进行数据操作
*/
private ContentResolver mContentResolver;
/**
* 创建标志 - 标记笔记是否为新创建（未保存到数据库）
*/
private boolean mIsCreate;
/**
* 笔记ID - 唯一标识一个笔记
*/
private long mId;
/**
* 提醒日期 - 笔记的提醒时间戳
*/
private long mAlertDate;
/**
* 背景颜色ID - 笔记的背景颜色资源ID
*/
private int mBgColorId;
/**
* 创建日期 - 笔记创建的时间戳
*/
private long mCreatedDate;
/**
* 是否有附件 - 标记笔记是否包含附件（0表示无，1表示有）
*/
private int mHasAttachment;
/**
* 修改日期 - 笔记最后修改的时间戳
*/
private long mModifiedDate;
/**
* 父文件夹ID - 笔记所属文件夹的ID
*/
private long mParentId;
/**
* 笔记摘要 - 笔记内容的简短描述
*/
private String mSnippet;
/**
* 笔记类型 - 区分笔记、文件夹、系统文件夹等类型
*/
private int mType;
/**
* 小部件ID - 关联的应用小部件ID
*/
private int mWidgetId;
/**
* 小部件类型 - 关联的应用小部件类型
*/
private int mWidgetType;
/**
* 原始父文件夹ID - 笔记原始所属文件夹的ID（用于移动操作）
*/
private long mOriginParent;
/**
* 版本号 - 用于处理并发编辑和同步冲突
*/
private long mVersion;
/**
* 差异内容值 - 存储笔记属性的变更，用于数据库更新
*/
private ContentValues mDiffNoteValues;
/**
* 数据列表 - 存储与笔记关联的详细内容数据
*/
private ArrayList<SqlData> mDataList;
/**
* 构造函数 - 创建一个新的笔记对象
* @param context 上下文对象
*/
public SqlNote(Context context) {
mContext = context;
mContentResolver = context.getContentResolver();
@ -262,11 +143,6 @@ public class SqlNote {
mDataList = new ArrayList<SqlData>();
}
/**
* 构造函数 - 从数据库游标创建笔记对象
* @param context 上下文对象
* @param c 包含笔记数据的数据库游标
*/
public SqlNote(Context context, Cursor c) {
mContext = context;
mContentResolver = context.getContentResolver();
@ -278,11 +154,6 @@ public class SqlNote {
mDiffNoteValues = new ContentValues();
}
/**
* 构造函数 - 根据笔记ID创建笔记对象
* @param context 上下文对象
* @param id 笔记ID
*/
public SqlNote(Context context, long id) {
mContext = context;
mContentResolver = context.getContentResolver();
@ -292,12 +163,9 @@ public class SqlNote {
if (mType == Notes.TYPE_NOTE)
loadDataContent();
mDiffNoteValues = new ContentValues();
}
/**
* 根据ID从数据库加载笔记数据
* @param id 笔记ID
*/
private void loadFromCursor(long id) {
Cursor c = null;
try {
@ -317,10 +185,6 @@ public class SqlNote {
}
}
/**
* 从数据库游标加载笔记数据
* @param c 包含笔记数据的游标
*/
private void loadFromCursor(Cursor c) {
mId = c.getLong(ID_COLUMN);
mAlertDate = c.getLong(ALERTED_DATE_COLUMN);
@ -336,10 +200,6 @@ public class SqlNote {
mVersion = c.getLong(VERSION_COLUMN);
}
/**
* 加载笔记关联的数据内容
* 从数据库查询与当前笔记关联的所有数据项
*/
private void loadDataContent() {
Cursor c = null;
mDataList.clear();
@ -366,19 +226,13 @@ public class SqlNote {
}
}
/**
* 从JSON对象设置笔记内容
* @param js 包含笔记数据的JSON对象
* @return 设置成功返回true，失败返回false
*/
public boolean setContent(JSONObject js) {
try {
JSONObject note = js.getJSONObject(GTaskStringUtils.META_HEAD_NOTE);
if (note.getInt(NoteColumns.TYPE) == Notes.TYPE_SYSTEM) {
// 系统文件夹不允许修改
Log.w(TAG, "cannot set system folder");
} else if (note.getInt(NoteColumns.TYPE) == Notes.TYPE_FOLDER) {
// 对于文件夹，只能更新摘要和类型
// for folder we can only update the snnipet and type
String snippet = note.has(NoteColumns.SNIPPET) ? note
.getString(NoteColumns.SNIPPET) : "";
if (mIsCreate || !mSnippet.equals(snippet)) {
@ -393,7 +247,6 @@ public class SqlNote {
}
mType = type;
} else if (note.getInt(NoteColumns.TYPE) == Notes.TYPE_NOTE) {
// 对于普通笔记，更新所有属性并处理关联数据
JSONArray dataArray = js.getJSONArray(GTaskStringUtils.META_HEAD_DATA);
long id = note.has(NoteColumns.ID) ? note.getLong(NoteColumns.ID) : INVALID_ID;
if (mIsCreate || mId != id) {
@ -478,11 +331,9 @@ public class SqlNote {
}
mOriginParent = originParent;
// 处理关联的数据项
for (int i = 0; i < dataArray.length(); i++) {
JSONObject data = dataArray.getJSONObject(i);
SqlData sqlData = null;
// 查找是否已存在相同ID的数据项
if (data.has(DataColumns.ID)) {
long dataId = data.getLong(DataColumns.ID);
for (SqlData temp : mDataList) {
@ -492,13 +343,11 @@ public class SqlNote {
}
}
// 如果不存在，则创建新的数据项
if (sqlData == null) {
sqlData = new SqlData(mContext);
mDataList.add(sqlData);
}
// 设置数据项内容
sqlData.setContent(data);
}
}
@ -510,23 +359,17 @@ public class SqlNote {
return true;
}
/**
* 将笔记内容转换为JSON对象
* @return 包含笔记数据的JSON对象，未创建的笔记返回null
*/
public JSONObject getContent() {
try {
JSONObject js = new JSONObject();
if (mIsCreate) {
// 未保存到数据库的笔记无法获取完整内容
Log.e(TAG, "it seems that we haven't created this in database yet");
return null;
}
JSONObject note = new JSONObject();
if (mType == Notes.TYPE_NOTE) {
// 普通笔记包含所有属性和关联数据
note.put(NoteColumns.ID, mId);
note.put(NoteColumns.ALERTED_DATE, mAlertDate);
note.put(NoteColumns.BG_COLOR_ID, mBgColorId);
@ -541,7 +384,6 @@ public class SqlNote {
note.put(NoteColumns.ORIGIN_PARENT_ID, mOriginParent);
js.put(GTaskStringUtils.META_HEAD_NOTE, note);
// 添加关联的数据项
JSONArray dataArray = new JSONArray();
for (SqlData sqlData : mDataList) {
JSONObject data = sqlData.getContent();
@ -551,7 +393,6 @@ public class SqlNote {
}
js.put(GTaskStringUtils.META_HEAD_DATA, dataArray);
} else if (mType == Notes.TYPE_FOLDER || mType == Notes.TYPE_SYSTEM) {
// 文件夹和系统文件夹只包含基本属性
note.put(NoteColumns.ID, mId);
note.put(NoteColumns.TYPE, mType);
note.put(NoteColumns.SNIPPET, mSnippet);
@ -566,87 +407,47 @@ public class SqlNote {
return null;
}
/**
* 设置笔记的父文件夹ID
* @param id 父文件夹ID
*/
public void setParentId(long id) {
mParentId = id;
mDiffNoteValues.put(NoteColumns.PARENT_ID, id);
}
/**
* 设置Google Tasks ID
* @param gid Google Tasks ID
*/
public void setGtaskId(String gid) {
mDiffNoteValues.put(NoteColumns.GTASK_ID, gid);
}
/**
* 设置同步ID
* @param syncId 同步ID
*/
public void setSyncId(long syncId) {
mDiffNoteValues.put(NoteColumns.SYNC_ID, syncId);
}
/**
* 重置本地修改状态
* 将本地修改标记设置为0，表示没有本地修改
*/
public void resetLocalModified() {
mDiffNoteValues.put(NoteColumns.LOCAL_MODIFIED, 0);
}
/**
* 获取笔记ID
* @return 笔记ID
*/
public long getId() {
return mId;
}
/**
* 获取父文件夹ID
* @return 父文件夹ID
*/
public long getParentId() {
return mParentId;
}
/**
* 获取笔记摘要
* @return 笔记摘要
*/
public String getSnippet() {
return mSnippet;
}
/**
* 判断是否为笔记类型
* @return 是笔记类型返回true，否则返回false
*/
public boolean isNoteType() {
return mType == Notes.TYPE_NOTE;
}
/**
* 将笔记提交到数据库
* @param validateVersion 是否验证版本号（用于处理并发编辑）
*/
public void commit(boolean validateVersion) {
if (mIsCreate) {
// 创建新笔记
// 如果ID无效且包含ID字段，则移除该字段（由数据库自动生成）
if (mId == INVALID_ID && mDiffNoteValues.containsKey(NoteColumns.ID)) {
mDiffNoteValues.remove(NoteColumns.ID);
}
// 插入新笔记到数据库
Uri uri = mContentResolver.insert(Notes.CONTENT_NOTE_URI, mDiffNoteValues);
try {
// 从返回的URI中提取新生成的笔记ID
mId = Long.valueOf(uri.getPathSegments().get(1));
} catch (NumberFormatException e) {
Log.e(TAG, "Get note id error :" + e.toString());
@ -656,32 +457,25 @@ public class SqlNote {
throw new IllegalStateException("Create thread id failed");
}
// 如果是普通笔记，提交关联的数据项
if (mType == Notes.TYPE_NOTE) {
for (SqlData sqlData : mDataList) {
sqlData.commit(mId, false, -1);
}
}
} else {
// 更新现有笔记
// 验证笔记ID的有效性（根文件夹和通话记录文件夹是特殊情况）
if (mId <= 0 && mId != Notes.ID_ROOT_FOLDER && mId != Notes.ID_CALL_RECORD_FOLDER) {
Log.e(TAG, "No such note");
throw new IllegalStateException("Try to update note with invalid id");
}
// 如果有需要更新的字段
if (mDiffNoteValues.size() > 0) {
mVersion ++; // 版本号递增
mVersion ++;
int result = 0;
if (!validateVersion) {
// 不验证版本号，直接更新
result = mContentResolver.update(Notes.CONTENT_NOTE_URI, mDiffNoteValues, "("
+ NoteColumns.ID + "=?)", new String[] {
String.valueOf(mId)
});
} else {
// 验证版本号，确保不会覆盖并发编辑
result = mContentResolver.update(Notes.CONTENT_NOTE_URI, mDiffNoteValues, "("
+ NoteColumns.ID + "=?) AND (" + NoteColumns.VERSION + "<=?)",
new String[] {
@ -693,7 +487,6 @@ public class SqlNote {
}
}
// 如果是普通笔记，提交关联的数据项
if (mType == Notes.TYPE_NOTE) {
for (SqlData sqlData : mDataList) {
sqlData.commit(mId, validateVersion, mVersion);
@ -701,12 +494,11 @@ public class SqlNote {
}
}
// 刷新本地信息，确保与数据库保持一致
// refresh local info
loadFromCursor(mId);
if (mType == Notes.TYPE_NOTE)
loadDataContent();
// 清除差异内容值并标记为已创建
mDiffNoteValues.clear();
mIsCreate = false;
}

184
src/Notes-master/src/net/micode/notes/gtask/data/Task.java
Unescape View File

@ -32,91 +32,64 @@ import org.json.JSONException;
import org.json.JSONObject;
/**
* Task - 表示Google Tasks中的一个任务
* 继承自Node类，扩展了任务特定的功能
*/
public class Task extends Node {
private static final String TAG = Task.class.getSimpleName();
/**
* 完成状态 - 标记任务是否已完成
*/
private boolean mCompleted;
/**
* 任务备注 - 任务的详细描述或备注信息
*/
private String mNotes;
/**
* 元信息 - 包含任务的额外信息的JSON对象
*/
private JSONObject mMetaInfo;
/**
* 前一个兄弟任务 - 任务在父列表中的前一个任务
*/
private Task mPriorSibling;
/**
* 父任务列表 - 任务所属的任务列表
*/
private TaskList mParent;
/**
* 构造函数 - 初始化一个新的任务对象
*/
public Task() {
super();
mCompleted = false; // 默认未完成
mNotes = null; // 默认无备注
mPriorSibling = null; // 默认无前一个兄弟任务
mParent = null; // 默认无父任务列表
mMetaInfo = null; // 默认无元信息
mCompleted = false;
mNotes = null;
mPriorSibling = null;
mParent = null;
mMetaInfo = null;
}
/**
* 获取创建任务的操作JSON对象
* @param actionId 操作ID
* @return 包含创建任务操作信息的JSON对象
*/
public JSONObject getCreateAction(int actionId) {
JSONObject js = new JSONObject();
try {
// 设置操作类型为创建
// action_type
js.put(GTaskStringUtils.GTASK_JSON_ACTION_TYPE,
GTaskStringUtils.GTASK_JSON_ACTION_TYPE_CREATE);
// 设置操作ID
// action_id
js.put(GTaskStringUtils.GTASK_JSON_ACTION_ID, actionId);
// 设置任务在父列表中的索引位置
// index
js.put(GTaskStringUtils.GTASK_JSON_INDEX, mParent.getChildTaskIndex(this));
// 设置任务实体信息
// entity_delta
JSONObject entity = new JSONObject();
entity.put(GTaskStringUtils.GTASK_JSON_NAME, getName()); // 任务名称
entity.put(GTaskStringUtils.GTASK_JSON_CREATOR_ID, "null"); // 创建者ID
entity.put(GTaskStringUtils.GTASK_JSON_NAME, getName());
entity.put(GTaskStringUtils.GTASK_JSON_CREATOR_ID, "null");
entity.put(GTaskStringUtils.GTASK_JSON_ENTITY_TYPE,
GTaskStringUtils.GTASK_JSON_TYPE_TASK); // 实体类型为任务
GTaskStringUtils.GTASK_JSON_TYPE_TASK);
if (getNotes() != null) {
entity.put(GTaskStringUtils.GTASK_JSON_NOTES, getNotes()); // 任务备注（如果有）
entity.put(GTaskStringUtils.GTASK_JSON_NOTES, getNotes());
}
js.put(GTaskStringUtils.GTASK_JSON_ENTITY_DELTA, entity);
// 设置父任务列表ID
// parent_id
js.put(GTaskStringUtils.GTASK_JSON_PARENT_ID, mParent.getGid());
// 设置目标父类型为组
// dest_parent_type
js.put(GTaskStringUtils.GTASK_JSON_DEST_PARENT_TYPE,
GTaskStringUtils.GTASK_JSON_TYPE_GROUP);
// 设置列表ID
// list_id
js.put(GTaskStringUtils.GTASK_JSON_LIST_ID, mParent.getGid());
// 设置前一个兄弟任务ID（如果有）
// prior_sibling_id
if (mPriorSibling != null) {
js.put(GTaskStringUtils.GTASK_JSON_PRIOR_SIBLING_ID, mPriorSibling.getGid());
}
@ -130,32 +103,27 @@ public class Task extends Node {
return js;
}
/**
* 获取更新任务的操作JSON对象
* @param actionId 操作ID
* @return 包含更新任务操作信息的JSON对象
*/
public JSONObject getUpdateAction(int actionId) {
JSONObject js = new JSONObject();
try {
// 设置操作类型为更新
// action_type
js.put(GTaskStringUtils.GTASK_JSON_ACTION_TYPE,
GTaskStringUtils.GTASK_JSON_ACTION_TYPE_UPDATE);
// 设置操作ID
// action_id
js.put(GTaskStringUtils.GTASK_JSON_ACTION_ID, actionId);
// 设置任务ID
// id
js.put(GTaskStringUtils.GTASK_JSON_ID, getGid());
// 设置要更新的实体信息
// entity_delta
JSONObject entity = new JSONObject();
entity.put(GTaskStringUtils.GTASK_JSON_NAME, getName()); // 更新任务名称
entity.put(GTaskStringUtils.GTASK_JSON_NAME, getName());
if (getNotes() != null) {
entity.put(GTaskStringUtils.GTASK_JSON_NOTES, getNotes()); // 更新任务备注（如果有）
entity.put(GTaskStringUtils.GTASK_JSON_NOTES, getNotes());
}
entity.put(GTaskStringUtils.GTASK_JSON_DELETED, getDeleted()); // 更新删除状态
entity.put(GTaskStringUtils.GTASK_JSON_DELETED, getDeleted());
js.put(GTaskStringUtils.GTASK_JSON_ENTITY_DELTA, entity);
} catch (JSONException e) {
@ -167,39 +135,35 @@ public class Task extends Node {
return js;
}
/**
* 从远程JSON对象设置任务内容
* @param js 包含远程任务数据的JSON对象
*/
public void setContentByRemoteJSON(JSONObject js) {
if (js != null) {
try {
// 设置任务ID
// id
if (js.has(GTaskStringUtils.GTASK_JSON_ID)) {
setGid(js.getString(GTaskStringUtils.GTASK_JSON_ID));
}
// 设置最后修改时间
// last_modified
if (js.has(GTaskStringUtils.GTASK_JSON_LAST_MODIFIED)) {
setLastModified(js.getLong(GTaskStringUtils.GTASK_JSON_LAST_MODIFIED));
}
// 设置任务名称
// name
if (js.has(GTaskStringUtils.GTASK_JSON_NAME)) {
setName(js.getString(GTaskStringUtils.GTASK_JSON_NAME));
}
// 设置任务备注
// notes
if (js.has(GTaskStringUtils.GTASK_JSON_NOTES)) {
setNotes(js.getString(GTaskStringUtils.GTASK_JSON_NOTES));
}
// 设置删除状态
// deleted
if (js.has(GTaskStringUtils.GTASK_JSON_DELETED)) {
setDeleted(js.getBoolean(GTaskStringUtils.GTASK_JSON_DELETED));
}
// 设置完成状态
// completed
if (js.has(GTaskStringUtils.GTASK_JSON_COMPLETED)) {
setCompleted(js.getBoolean(GTaskStringUtils.GTASK_JSON_COMPLETED));
}
@ -211,28 +175,21 @@ public class Task extends Node {
}
}
/**
* 从本地JSON对象设置任务内容
* @param js 包含本地笔记数据的JSON对象
*/
public void setContentByLocalJSON(JSONObject js) {
if (js == null || !js.has(GTaskStringUtils.META_HEAD_NOTE)
|| !js.has(GTaskStringUtils.META_HEAD_DATA)) {
Log.w(TAG, "setContentByLocalJSON: nothing is avaiable");
return;
}
try {
JSONObject note = js.getJSONObject(GTaskStringUtils.META_HEAD_NOTE);
JSONArray dataArray = js.getJSONArray(GTaskStringUtils.META_HEAD_DATA);
// 确保是普通笔记类型
if (note.getInt(NoteColumns.TYPE) != Notes.TYPE_NOTE) {
Log.e(TAG, "invalid type");
return;
}
// 查找并设置笔记内容作为任务名称
for (int i = 0; i < dataArray.length(); i++) {
JSONObject data = dataArray.getJSONObject(i);
if (TextUtils.equals(data.getString(DataColumns.MIME_TYPE), DataConstants.NOTE)) {
@ -247,37 +204,31 @@ public class Task extends Node {
}
}
/**
* 从任务内容生成本地JSON对象
* @return 包含本地笔记数据的JSON对象
*/
public JSONObject getLocalJSONFromContent() {
String name = getName();
try {
if (mMetaInfo == null) {
// 从网络创建的新任务
// new task created from web
if (name == null) {
Log.w(TAG, "the note seems to be an empty one");
return null;
}
// 创建新的JSON对象结构
JSONObject js = new JSONObject();
JSONObject note = new JSONObject();
JSONArray dataArray = new JSONArray();
JSONObject data = new JSONObject();
data.put(DataColumns.CONTENT, name); // 设置笔记内容为任务名称
data.put(DataColumns.CONTENT, name);
dataArray.put(data);
js.put(GTaskStringUtils.META_HEAD_DATA, dataArray); // 添加数据数组
note.put(NoteColumns.TYPE, Notes.TYPE_NOTE); // 设置笔记类型为普通笔记
js.put(GTaskStringUtils.META_HEAD_NOTE, note); // 添加笔记对象
js.put(GTaskStringUtils.META_HEAD_DATA, dataArray);
note.put(NoteColumns.TYPE, Notes.TYPE_NOTE);
js.put(GTaskStringUtils.META_HEAD_NOTE, note);
return js;
} else {
// 已同步的任务
// synced task
JSONObject note = mMetaInfo.getJSONObject(GTaskStringUtils.META_HEAD_NOTE);
JSONArray dataArray = mMetaInfo.getJSONArray(GTaskStringUtils.META_HEAD_DATA);
// 更新笔记内容为当前任务名称
for (int i = 0; i < dataArray.length(); i++) {
JSONObject data = dataArray.getJSONObject(i);
if (TextUtils.equals(data.getString(DataColumns.MIME_TYPE), DataConstants.NOTE)) {
@ -286,7 +237,7 @@ public class Task extends Node {
}
}
note.put(NoteColumns.TYPE, Notes.TYPE_NOTE); // 确保笔记类型为普通笔记
note.put(NoteColumns.TYPE, Notes.TYPE_NOTE);
return mMetaInfo;
}
} catch (JSONException e) {
@ -296,14 +247,9 @@ public class Task extends Node {
}
}
/**
* 设置任务的元信息
* @param metaData 包含元信息的MetaData对象
*/
public void setMetaInfo(MetaData metaData) {
if (metaData != null && metaData.getNotes() != null) {
try {
// 从元数据中解析JSON对象
mMetaInfo = new JSONObject(metaData.getNotes());
} catch (JSONException e) {
Log.w(TAG, e.toString());
@ -312,11 +258,6 @@ public class Task extends Node {
}
}
/**
* 确定任务的同步操作类型
* @param c 包含本地笔记数据的游标
* @return 同步操作类型：SYNC_ACTION_NONE、SYNC_ACTION_UPDATE_LOCAL、SYNC_ACTION_UPDATE_REMOTE或SYNC_ACTION_ERROR
*/
public int getSyncAction(Cursor c) {
try {
JSONObject noteInfo = null;
@ -325,43 +266,40 @@ public class Task extends Node {
}
if (noteInfo == null) {
// 元信息已删除，更新远程
Log.w(TAG, "it seems that note meta has been deleted");
return SYNC_ACTION_UPDATE_REMOTE;
}
if (!noteInfo.has(NoteColumns.ID)) {
// 远程笔记ID已删除，更新本地
Log.w(TAG, "remote note id seems to be deleted");
return SYNC_ACTION_UPDATE_LOCAL;
}
// 验证笔记ID
// validate the note id now
if (c.getLong(SqlNote.ID_COLUMN) != noteInfo.getLong(NoteColumns.ID)) {
Log.w(TAG, "note id doesn't match");
return SYNC_ACTION_UPDATE_LOCAL;
}
if (c.getInt(SqlNote.LOCAL_MODIFIED_COLUMN) == 0) {
// 本地没有更新
// there is no local update
if (c.getLong(SqlNote.SYNC_ID_COLUMN) == getLastModified()) {
// 双方都没有更新
// no update both side
return SYNC_ACTION_NONE;
} else {
// 将远程更新应用到本地
// apply remote to local
return SYNC_ACTION_UPDATE_LOCAL;
}
} else {
// 本地有更新，验证Google Tasks ID
// validate gtask id
if (!c.getString(SqlNote.GTASK_ID_COLUMN).equals(getGid())) {
Log.e(TAG, "gtask id doesn't match");
return SYNC_ACTION_ERROR;
}
if (c.getLong(SqlNote.SYNC_ID_COLUMN) == getLastModified()) {
// 只有本地更新
// local modification only
return SYNC_ACTION_UPDATE_REMOTE;
} else {
// 本地和远程都有更新，存在冲突
return SYNC_ACTION_UPDATE_CONFLICT;
}
}
@ -373,75 +311,39 @@ public class Task extends Node {
return SYNC_ACTION_ERROR;
}
/**
* 判断任务是否值得保存
* @return 任务有元信息、非空名称或非空备注时返回true，否则返回false
*/
public boolean isWorthSaving() {
return mMetaInfo != null || (getName() != null && getName().trim().length() > 0)
|| (getNotes() != null && getNotes().trim().length() > 0);
}
/**
* 设置任务的完成状态
* @param completed 完成状态
*/
public void setCompleted(boolean completed) {
this.mCompleted = completed;
}
/**
* 设置任务的备注
* @param notes 任务备注
*/
public void setNotes(String notes) {
this.mNotes = notes;
}
/**
* 设置任务的前一个兄弟任务
* @param priorSibling 前一个兄弟任务
*/
public void setPriorSibling(Task priorSibling) {
this.mPriorSibling = priorSibling;
}
/**
* 设置任务的父任务列表
* @param parent 父任务列表
*/
public void setParent(TaskList parent) {
this.mParent = parent;
}
/**
* 获取任务的完成状态
* @return 完成状态
*/
public boolean getCompleted() {
return this.mCompleted;
}
/**
* 获取任务的备注
* @return 任务备注
*/
public String getNotes() {
return this.mNotes;
}
/**
* 获取任务的前一个兄弟任务
* @return 前一个兄弟任务
*/
public Task getPriorSibling() {
return this.mPriorSibling;
}
/**
* 获取任务的父任务列表
* @return 父任务列表
*/
public TaskList getParent() {
return this.mParent;
}

168
src/Notes-master/src/net/micode/notes/gtask/data/TaskList.java
Unescape View File

@ -30,57 +30,39 @@ import org.json.JSONObject;
import java.util.ArrayList;
/**
* TaskList - 表示Google Tasks中的一个任务列表
* 继承自Node类，包含任务列表的基本信息和子任务
*/
public class TaskList extends Node {
private static final String TAG = TaskList.class.getSimpleName();
/**
* 索引 - 任务列表在父容器中的位置
*/
private int mIndex;
/**
* 子任务列表 - 存储任务列表中的所有任务
*/
private ArrayList<Task> mChildren;
/**
* 构造函数 - 初始化一个新的任务列表对象
*/
public TaskList() {
super();
mChildren = new ArrayList<Task>(); // 初始化子任务列表
mIndex = 1; // 默认索引为1
mChildren = new ArrayList<Task>();
mIndex = 1;
}
/**
* 获取创建任务列表的操作JSON对象
* @param actionId 操作ID
* @return 包含创建任务列表操作信息的JSON对象
*/
public JSONObject getCreateAction(int actionId) {
JSONObject js = new JSONObject();
try {
// 设置操作类型为创建
// action_type
js.put(GTaskStringUtils.GTASK_JSON_ACTION_TYPE,
GTaskStringUtils.GTASK_JSON_ACTION_TYPE_CREATE);
// 设置操作ID
// action_id
js.put(GTaskStringUtils.GTASK_JSON_ACTION_ID, actionId);
// 设置任务列表索引
// index
js.put(GTaskStringUtils.GTASK_JSON_INDEX, mIndex);
// 设置任务列表实体信息
// entity_delta
JSONObject entity = new JSONObject();
entity.put(GTaskStringUtils.GTASK_JSON_NAME, getName()); // 任务列表名称
entity.put(GTaskStringUtils.GTASK_JSON_CREATOR_ID, "null"); // 创建者ID
entity.put(GTaskStringUtils.GTASK_JSON_NAME, getName());
entity.put(GTaskStringUtils.GTASK_JSON_CREATOR_ID, "null");
entity.put(GTaskStringUtils.GTASK_JSON_ENTITY_TYPE,
GTaskStringUtils.GTASK_JSON_TYPE_GROUP); // 实体类型为组
GTaskStringUtils.GTASK_JSON_TYPE_GROUP);
js.put(GTaskStringUtils.GTASK_JSON_ENTITY_DELTA, entity);
} catch (JSONException e) {
@ -92,29 +74,24 @@ public class TaskList extends Node {
return js;
}
/**
* 获取更新任务列表的操作JSON对象
* @param actionId 操作ID
* @return 包含更新任务列表操作信息的JSON对象
*/
public JSONObject getUpdateAction(int actionId) {
JSONObject js = new JSONObject();
try {
// 设置操作类型为更新
// action_type
js.put(GTaskStringUtils.GTASK_JSON_ACTION_TYPE,
GTaskStringUtils.GTASK_JSON_ACTION_TYPE_UPDATE);
// 设置操作ID
// action_id
js.put(GTaskStringUtils.GTASK_JSON_ACTION_ID, actionId);
// 设置任务列表ID
// id
js.put(GTaskStringUtils.GTASK_JSON_ID, getGid());
// 设置要更新的实体信息
// entity_delta
JSONObject entity = new JSONObject();
entity.put(GTaskStringUtils.GTASK_JSON_NAME, getName()); // 更新任务列表名称
entity.put(GTaskStringUtils.GTASK_JSON_DELETED, getDeleted()); // 更新删除状态
entity.put(GTaskStringUtils.GTASK_JSON_NAME, getName());
entity.put(GTaskStringUtils.GTASK_JSON_DELETED, getDeleted());
js.put(GTaskStringUtils.GTASK_JSON_ENTITY_DELTA, entity);
} catch (JSONException e) {
@ -126,24 +103,20 @@ public class TaskList extends Node {
return js;
}
/**
* 从远程JSON对象设置任务列表内容
* @param js 包含远程任务列表数据的JSON对象
*/
public void setContentByRemoteJSON(JSONObject js) {
if (js != null) {
try {
// 设置任务列表ID
// id
if (js.has(GTaskStringUtils.GTASK_JSON_ID)) {
setGid(js.getString(GTaskStringUtils.GTASK_JSON_ID));
}
// 设置最后修改时间
// last_modified
if (js.has(GTaskStringUtils.GTASK_JSON_LAST_MODIFIED)) {
setLastModified(js.getLong(GTaskStringUtils.GTASK_JSON_LAST_MODIFIED));
}
// 设置任务列表名称
// name
if (js.has(GTaskStringUtils.GTASK_JSON_NAME)) {
setName(js.getString(GTaskStringUtils.GTASK_JSON_NAME));
}
@ -156,26 +129,18 @@ public class TaskList extends Node {
}
}
/**
* 从本地JSON对象设置任务列表内容
* @param js 包含本地文件夹数据的JSON对象
*/
public void setContentByLocalJSON(JSONObject js) {
if (js == null || !js.has(GTaskStringUtils.META_HEAD_NOTE)) {
Log.w(TAG, "setContentByLocalJSON: nothing is avaiable");
return;
}
try {
JSONObject folder = js.getJSONObject(GTaskStringUtils.META_HEAD_NOTE);
// 根据本地文件夹类型设置任务列表名称
if (folder.getInt(NoteColumns.TYPE) == Notes.TYPE_FOLDER) {
// 普通文件夹，添加前缀
String name = folder.getString(NoteColumns.SNIPPET);
setName(GTaskStringUtils.MIUI_FOLDER_PREFFIX + name);
} else if (folder.getInt(NoteColumns.TYPE) == Notes.TYPE_SYSTEM) {
// 系统文件夹，根据ID设置不同名称
if (folder.getLong(NoteColumns.ID) == Notes.ID_ROOT_FOLDER)
setName(GTaskStringUtils.MIUI_FOLDER_PREFFIX + GTaskStringUtils.FOLDER_DEFAULT);
else if (folder.getLong(NoteColumns.ID) == Notes.ID_CALL_RECORD_FOLDER)
@ -192,30 +157,21 @@ public class TaskList extends Node {
}
}
/**
* 从任务列表内容生成本地JSON对象
* @return 包含本地文件夹数据的JSON对象
*/
public JSONObject getLocalJSONFromContent() {
try {
JSONObject js = new JSONObject();
JSONObject folder = new JSONObject();
// 移除任务列表名称的前缀
String folderName = getName();
if (getName().startsWith(GTaskStringUtils.MIUI_FOLDER_PREFFIX))
folderName = folderName.substring(GTaskStringUtils.MIUI_FOLDER_PREFFIX.length(),
folderName.length());
// 设置文件夹名称
folder.put(NoteColumns.SNIPPET, folderName);
// 根据名称设置文件夹类型
if (folderName.equals(GTaskStringUtils.FOLDER_DEFAULT)
|| folderName.equals(GTaskStringUtils.FOLDER_CALL_NOTE))
folder.put(NoteColumns.TYPE, Notes.TYPE_SYSTEM); // 系统文件夹
folder.put(NoteColumns.TYPE, Notes.TYPE_SYSTEM);
else
folder.put(NoteColumns.TYPE, Notes.TYPE_FOLDER); // 普通文件夹
folder.put(NoteColumns.TYPE, Notes.TYPE_FOLDER);
js.put(GTaskStringUtils.META_HEAD_NOTE, folder);
@ -227,33 +183,28 @@ public class TaskList extends Node {
}
}
/**
* 确定任务列表的同步操作类型
* @param c 包含本地文件夹数据的游标
* @return 同步操作类型：SYNC_ACTION_NONE、SYNC_ACTION_UPDATE_LOCAL、SYNC_ACTION_UPDATE_REMOTE或SYNC_ACTION_ERROR
*/
public int getSyncAction(Cursor c) {
try {
if (c.getInt(SqlNote.LOCAL_MODIFIED_COLUMN) == 0) {
// 本地没有更新
// there is no local update
if (c.getLong(SqlNote.SYNC_ID_COLUMN) == getLastModified()) {
// 双方都没有更新
// no update both side
return SYNC_ACTION_NONE;
} else {
// 将远程更新应用到本地
// apply remote to local
return SYNC_ACTION_UPDATE_LOCAL;
}
} else {
// 本地有更新，验证Google Tasks ID
// validate gtask id
if (!c.getString(SqlNote.GTASK_ID_COLUMN).equals(getGid())) {
Log.e(TAG, "gtask id doesn't match");
return SYNC_ACTION_ERROR;
}
if (c.getLong(SqlNote.SYNC_ID_COLUMN) == getLastModified()) {
// 只有本地更新
// local modification only
return SYNC_ACTION_UPDATE_REMOTE;
} else {
// 对于文件夹冲突，直接应用本地修改
// for folder conflicts, just apply local modification
return SYNC_ACTION_UPDATE_REMOTE;
}
}
@ -265,25 +216,16 @@ public class TaskList extends Node {
return SYNC_ACTION_ERROR;
}
/**
* 获取子任务数量
* @return 子任务数量
*/
public int getChildTaskCount() {
return mChildren.size();
}
/**
* 添加子任务到列表末尾
* @param task 要添加的任务
* @return 添加成功返回true，失败返回false
*/
public boolean addChildTask(Task task) {
boolean ret = false;
if (task != null && !mChildren.contains(task)) {
ret = mChildren.add(task);
if (ret) {
// 设置前一个兄弟任务和父任务
// need to set prior sibling and parent
task.setPriorSibling(mChildren.isEmpty() ? null : mChildren
.get(mChildren.size() - 1));
task.setParent(this);
@ -292,12 +234,6 @@ public class TaskList extends Node {
return ret;
}
/**
* 在指定位置添加子任务
* @param task 要添加的任务
* @param index 添加位置的索引
* @return 添加成功返回true，失败返回false
*/
public boolean addChildTask(Task task, int index) {
if (index < 0 || index > mChildren.size()) {
Log.e(TAG, "add child task: invalid index");
@ -308,7 +244,7 @@ public class TaskList extends Node {
if (task != null && pos == -1) {
mChildren.add(index, task);
// 更新任务列表的兄弟关系
// update the task list
Task preTask = null;
Task afterTask = null;
if (index != 0)
@ -324,11 +260,6 @@ public class TaskList extends Node {
return true;
}
/**
* 移除子任务
* @param task 要移除的任务
* @return 移除成功返回true，失败返回false
*/
public boolean removeChildTask(Task task) {
boolean ret = false;
int index = mChildren.indexOf(task);
@ -336,11 +267,11 @@ public class TaskList extends Node {
ret = mChildren.remove(task);
if (ret) {
// 重置前一个兄弟任务和父任务
// reset prior sibling and parent
task.setPriorSibling(null);
task.setParent(null);
// 更新任务列表的兄弟关系
// update the task list
if (index != mChildren.size()) {
mChildren.get(index).setPriorSibling(
index == 0 ? null : mChildren.get(index - 1));
@ -350,13 +281,8 @@ public class TaskList extends Node {
return ret;
}
/**
* 移动子任务到新位置
* @param task 要移动的任务
* @param index 新位置的索引
* @return 移动成功返回true，失败返回false
*/
public boolean moveChildTask(Task task, int index) {
if (index < 0 || index >= mChildren.size()) {
Log.e(TAG, "move child task: invalid index");
return false;
@ -373,11 +299,6 @@ public class TaskList extends Node {
return (removeChildTask(task) && addChildTask(task, index));
}
/**
* 根据Google Tasks ID查找子任务
* @param gid Google Tasks ID
* @return 找到的任务，未找到返回null
*/
public Task findChildTaskByGid(String gid) {
for (int i = 0; i < mChildren.size(); i++) {
Task t = mChildren.get(i);
@ -388,20 +309,10 @@ public class TaskList extends Node {
return null;
}
/**
* 获取子任务在列表中的索引位置
* @param task 子任务
* @return 子任务的索引位置
*/
public int getChildTaskIndex(Task task) {
return mChildren.indexOf(task);
}
/**
* 根据索引位置获取子任务
* @param index 索引位置
* @return 找到的任务，索引无效返回null
*/
public Task getChildTaskByIndex(int index) {
if (index < 0 || index >= mChildren.size()) {
Log.e(TAG, "getTaskByIndex: invalid index");
@ -410,11 +321,6 @@ public class TaskList extends Node {
return mChildren.get(index);
}
/**
* 根据Google Tasks ID获取子任务
* @param gid Google Tasks ID
* @return 找到的任务，未找到返回null
*/
public Task getChilTaskByGid(String gid) {
for (Task task : mChildren) {
if (task.getGid().equals(gid))
@ -423,26 +329,14 @@ public class TaskList extends Node {
return null;
}
/**
* 获取所有子任务的列表
* @return 子任务列表
*/
public ArrayList<Task> getChildTaskList() {
return this.mChildren;
}
/**
* 设置任务列表的索引
* @param index 索引值
*/
public void setIndex(int index) {
this.mIndex = index;
}
/**
* 获取任务列表的索引
* @return 索引值
*/
public int getIndex() {
return this.mIndex;
}

16
src/Notes-master/src/net/micode/notes/gtask/exception/ActionFailureException.java
Unescape View File

@ -16,33 +16,17 @@
package net.micode.notes.gtask.exception;
/**
* 操作失败异常，用于表示Google Tasks同步操作失败的情况
*/
public class ActionFailureException extends RuntimeException {
/** 序列化版本UID */
private static final long serialVersionUID = 4425249765923293627L;
/**
* 默认构造方法
*/
public ActionFailureException() {
super();
}
/**
* 带错误消息的构造方法
* @param paramString 错误消息
*/
public ActionFailureException(String paramString) {
super(paramString);
}
/**
* 带错误消息和原因的构造方法
* @param paramString 错误消息
* @param paramThrowable 异常原因
*/
public ActionFailureException(String paramString, Throwable paramThrowable) {
super(paramString, paramThrowable);
}

16
src/Notes-master/src/net/micode/notes/gtask/exception/NetworkFailureException.java
Unescape View File

@ -16,33 +16,17 @@
package net.micode.notes.gtask.exception;
/**
* 网络失败异常，用于表示Google Tasks同步过程中网络连接失败的情况
*/
public class NetworkFailureException extends Exception {
/** 序列化版本UID */
private static final long serialVersionUID = 2107610287180234136L;
/**
* 默认构造方法
*/
public NetworkFailureException() {
super();
}
/**
* 带错误消息的构造方法
* @param paramString 错误消息
*/
public NetworkFailureException(String paramString) {
super(paramString);
}
/**
* 带错误消息和原因的构造方法
* @param paramString 错误消息
* @param paramThrowable 异常原因
*/
public NetworkFailureException(String paramString, Throwable paramThrowable) {
super(paramString, paramThrowable);
}

84
src/Notes-master/src/net/micode/notes/gtask/remote/GTaskASyncTask.java
Unescape View File

@ -29,51 +29,22 @@ import net.micode.notes.ui.NotesListActivity;
import net.micode.notes.ui.NotesPreferenceActivity;
/**
* GTaskASyncTask- 用于在后台执行Google Tasks同步操作的异步任务
*/
public class GTaskASyncTask extends AsyncTask<Void, String, Integer> {
/**
* 同步通知ID常量 - 用于标识Google Tasks同步通知
*/
private static int GTASK_SYNC_NOTIFICATION_ID = 5234235;
/**
* OnCompleteListener接口 - 同步完成时的回调接口
*/
public interface OnCompleteListener {
/**
* 同步完成时调用
*/
void onComplete();
}
/**
* 上下文对象 - 用于访问系统服务和资源
*/
private Context mContext;
/**
* 通知管理器 - 用于显示同步通知
*/
private NotificationManager mNotifiManager;
/**
* 任务管理器 - 用于执行实际的同步操作
*/
private GTaskManager mTaskManager;
/**
* 完成监听器 - 同步完成时的回调对象
*/
private OnCompleteListener mOnCompleteListener;
/**
* 构造函数 - 初始化Google Tasks异步任务
* @param context 上下文对象
* @param listener 同步完成时的回调监听器
*/
public GTaskASyncTask(Context context, OnCompleteListener listener) {
mContext = context;
mOnCompleteListener = listener;
@ -82,70 +53,35 @@ public class GTaskASyncTask extends AsyncTask<Void, String, Integer> {
mTaskManager = GTaskManager.getInstance();
}
/**
* 取消同步操作
*/
public void cancelSync() {
mTaskManager.cancelSync();
}
/**
* 发布同步进度
* @param message 进度消息
*/
public void publishProgess(String message) {
publishProgress(new String[] {
message
});
}
//private void showNotification(int tickerId, String content) {
// Notification notification = new Notification(R.drawable.notification, mContext
// .getString(tickerId), System.currentTimeMillis());
// notification.defaults = Notification.DEFAULT_LIGHTS;
// notification.flags = Notification.FLAG_AUTO_CANCEL;
// PendingIntent pendingIntent;
// if (tickerId != R.string.ticker_success) {
// pendingIntent = PendingIntent.getActivity(mContext, 0, new Intent(mContext,
// NotesPreferenceActivity.class), 0);
//
// } else {
// pendingIntent = PendingIntent.getActivity(mContext, 0, new Intent(mContext,
// NotesListActivity.class), 0);
// }
// notification.setLatestEventInfo(mContext, mContext.getString(R.string.app_name), content,
// pendingIntent);
// mNotifiManager.notify(GTASK_SYNC_NOTIFICATION_ID, notification);
//}
/**
* 显示同步通知
* @param tickerId 通知标题的字符串资源ID
* @param content 通知内容
*/
private void showNotification(int tickerId, String content) {
Notification notification = new Notification(R.drawable.notification, mContext
.getString(tickerId), System.currentTimeMillis());
notification.defaults = Notification.DEFAULT_LIGHTS;
notification.flags = Notification.FLAG_AUTO_CANCEL;
PendingIntent pendingIntent;
if (tickerId != R.string.ticker_success) {
// 同步失败时，点击通知跳转到设置页面
pendingIntent = PendingIntent.getActivity(mContext, 0, new Intent(mContext,
NotesPreferenceActivity.class), PendingIntent.FLAG_IMMUTABLE);
NotesPreferenceActivity.class), 0);
} else {
// 同步成功时，点击通知跳转到笔记列表页面
pendingIntent = PendingIntent.getActivity(mContext, 0, new Intent(mContext,
NotesListActivity.class), PendingIntent.FLAG_IMMUTABLE);
NotesListActivity.class), 0);
}
// 创建通知构建器
Notification.Builder builder = new Notification.Builder(mContext)
.setAutoCancel(true) // 点击后自动取消通知
.setContentTitle(mContext.getString(R.string.app_name)) // 设置通知标题
.setContentText(content) // 设置通知内容
.setContentIntent(pendingIntent) // 设置点击通知时的跳转意图
.setWhen(System.currentTimeMillis()) // 设置通知时间
.setOngoing(true); // 设置为持续通知
Notification notification=builder.getNotification();
mNotifiManager.notify(GTASK_SYNC_NOTIFICATION_ID, notification); // 显示通知
notification.setLatestEventInfo(mContext, mContext.getString(R.string.app_name), content,
pendingIntent);
mNotifiManager.notify(GTASK_SYNC_NOTIFICATION_ID, notification);
}
@Override
protected Integer doInBackground(Void... unused) {
publishProgess(mContext.getString(R.string.sync_progress_login, NotesPreferenceActivity

158
src/Notes-master/src/net/micode/notes/gtask/remote/GTaskClient.java
Unescape View File

@ -61,44 +61,35 @@ import java.util.zip.Inflater;
import java.util.zip.InflaterInputStream;
/**
* Google Tasks客户端
* 实现与Google Tasks API的通信，处理任务和任务列表的CRUD操作
* 使用单例模式确保全局只有一个实例
*/
public class GTaskClient {
private static final String TAG = GTaskClient.class.getSimpleName(); // 日志标签
private static final String TAG = GTaskClient.class.getSimpleName();
private static final String GTASK_URL = "https://mail.google.com/tasks/"; // Google Tasks基础URL
private static final String GTASK_URL = "https://mail.google.com/tasks/";
private static final String GTASK_GET_URL = "https://mail.google.com/tasks/ig"; // Google Tasks GET请求URL
private static final String GTASK_GET_URL = "https://mail.google.com/tasks/ig";
private static final String GTASK_POST_URL = "https://mail.google.com/tasks/r/ig"; // Google Tasks POST请求URL
private static final String GTASK_POST_URL = "https://mail.google.com/tasks/r/ig";
private static GTaskClient mInstance = null; // 单例实例
private static GTaskClient mInstance = null;
private DefaultHttpClient mHttpClient; // HTTP客户端实例
private DefaultHttpClient mHttpClient;
private String mGetUrl; // 当前使用的GET请求URL
private String mGetUrl;
private String mPostUrl; // 当前使用的POST请求URL
private String mPostUrl;
private long mClientVersion; // 客户端版本号
private long mClientVersion;
private boolean mLoggedin; // 登录状态标识
private boolean mLoggedin;
private long mLastLoginTime; // 最后登录时间
private long mLastLoginTime;
private int mActionId; // 操作ID计数器
private int mActionId;
private Account mAccount; // Google账户
private Account mAccount;
private JSONArray mUpdateArray; // 更新操作数组，用于批量提交更新
private JSONArray mUpdateArray;
/**
* 私有构造函数 - 初始化客户端实例
* 单例模式确保外部无法直接创建实例
*/
private GTaskClient() {
mHttpClient = null;
mGetUrl = GTASK_GET_URL;
@ -111,11 +102,6 @@ public class GTaskClient {
mUpdateArray = null;
}
/**
* 获取GTaskClient的单例实例
* 使用同步方法确保线程安全
* @return GTaskClient单例实例
*/
public static synchronized GTaskClient getInstance() {
if (mInstance == null) {
mInstance = new GTaskClient();
@ -123,13 +109,6 @@ public class GTaskClient {
return mInstance;
}
/**
* 登录Google Tasks服务
* 如果已经登录且会话未过期，则直接返回true
* 否则重新登录Google账户并建立与Google Tasks的连接
* @param activity 调用该方法的Activity实例，用于获取账户信息
* @return 是否登录成功
*/
public boolean login(Activity activity) {
// we suppose that the cookie would expire after 5 minutes
// then we need to re-login
@ -185,12 +164,6 @@ public class GTaskClient {
return true;
}
/**
* 登录Google账户并获取认证令牌
* @param activity 调用该方法的Activity实例，用于获取账户信息
* @param invalidateToken 是否使当前令牌无效并重新获取
* @return 认证令牌，如果获取失败则返回null
*/
private String loginGoogleAccount(Activity activity, boolean invalidateToken) {
String authToken;
AccountManager accountManager = AccountManager.get(activity);
@ -234,13 +207,6 @@ public class GTaskClient {
return authToken;
}
/**
* 尝试使用认证令牌登录Google Tasks服务
* 如果第一次登录失败，会尝试重新获取令牌并再次登录
* @param activity 调用该方法的Activity实例，用于重新获取令牌
* @param authToken 认证令牌
* @return 是否登录成功
*/
private boolean tryToLoginGtask(Activity activity, String authToken) {
if (!loginGtask(authToken)) {
// maybe the auth token is out of date, now let's invalidate the
@ -259,12 +225,6 @@ public class GTaskClient {
return true;
}
/**
* 使用认证令牌登录Google Tasks服务
* 配置HTTP客户端，设置超时时间，发送登录请求并处理响应
* @param authToken 认证令牌
* @return 是否登录成功
*/
private boolean loginGtask(String authToken) {
int timeoutConnection = 10000;
int timeoutSocket = 15000;
@ -320,20 +280,10 @@ public class GTaskClient {
return true;
}
/**
* 获取唯一的操作ID
* 每次调用都会递增操作ID计数器
* @return 新的操作ID
*/
private int getActionId() {
return mActionId++;
}
/**
* 创建HTTP POST请求对象
* 设置请求URL和必要的请求头
* @return 配置好的HttpPost对象
*/
private HttpPost createHttpPost() {
HttpPost httpPost = new HttpPost(mPostUrl);
httpPost.setHeader("Content-Type", "application/x-www-form-urlencoded;charset=utf-8");
@ -341,13 +291,6 @@ public class GTaskClient {
return httpPost;
}
/**
* 获取HTTP响应内容
* 支持gzip和deflate压缩格式，自动解压并返回字符串内容
* @param entity HTTP响应实体
* @return 响应内容字符串
* @throws IOException 如果读取响应内容失败
*/
private String getResponseContent(HttpEntity entity) throws IOException {
String contentEncoding = null;
if (entity.getContentEncoding() != null) {
@ -380,14 +323,6 @@ public class GTaskClient {
}
}
/**
* 发送POST请求到Google Tasks API
* 封装JSON数据并发送请求，处理响应并返回JSON对象
* @param js 要发送的JSON对象
* @return 响应的JSON对象
* @throws NetworkFailureException 如果网络请求失败
* @throws ActionFailureException 如果请求处理失败
*/
private JSONObject postRequest(JSONObject js) throws NetworkFailureException {
if (!mLoggedin) {
Log.e(TAG, "please login first");
@ -425,13 +360,6 @@ public class GTaskClient {
}
}
/**
* 创建新的Google Tasks任务
* 提交更新并发送创建任务的请求，处理响应并更新任务的GID
* @param task 要创建的任务对象
* @throws NetworkFailureException 如果网络请求失败
* @throws ActionFailureException 如果创建任务失败
*/
public void createTask(Task task) throws NetworkFailureException {
commitUpdate();
try {
@ -458,13 +386,6 @@ public class GTaskClient {
}
}
/**
* 创建新的Google Tasks任务列表
* 提交更新并发送创建任务列表的请求，处理响应并更新任务列表的GID
* @param tasklist 要创建的任务列表对象
* @throws NetworkFailureException 如果网络请求失败
* @throws ActionFailureException 如果创建任务列表失败
*/
public void createTaskList(TaskList tasklist) throws NetworkFailureException {
commitUpdate();
try {
@ -491,12 +412,6 @@ public class GTaskClient {
}
}
/**
* 提交更新到Google Tasks服务器
* 将mUpdateArray中的所有更新操作批量发送到服务器
* @throws NetworkFailureException 如果网络请求失败
* @throws ActionFailureException 如果更新处理失败
*/
public void commitUpdate() throws NetworkFailureException {
if (mUpdateArray != null) {
try {
@ -518,12 +433,6 @@ public class GTaskClient {
}
}
/**
* 将节点添加到更新数组中
* 当更新数组超过10个元素时，会自动提交更新
* @param node 要添加的节点对象
* @throws NetworkFailureException 如果提交更新时网络请求失败
*/
public void addUpdateNode(Node node) throws NetworkFailureException {
if (node != null) {
// too many update items may result in an error
@ -538,15 +447,6 @@ public class GTaskClient {
}
}
/**
* 移动任务位置
* 可以在同一个任务列表内移动任务，也可以将任务从一个任务列表移动到另一个任务列表
* @param task 要移动的任务对象
* @param preParent 移动前的父任务列表
* @param curParent 移动后的父任务列表
* @throws NetworkFailureException 如果网络请求失败
* @throws ActionFailureException 如果移动任务失败
*/
public void moveTask(Task task, TaskList preParent, TaskList curParent)
throws NetworkFailureException {
commitUpdate();
@ -586,13 +486,6 @@ public class GTaskClient {
}
}
/**
* 删除节点
* 将节点标记为已删除并发送删除请求到Google Tasks服务器
* @param node 要删除的节点对象
* @throws NetworkFailureException 如果网络请求失败
* @throws ActionFailureException 如果删除节点失败
*/
public void deleteNode(Node node) throws NetworkFailureException {
commitUpdate();
try {
@ -616,13 +509,6 @@ public class GTaskClient {
}
}
/**
* 获取所有任务列表
* 从Google Tasks服务器获取所有任务列表信息
* @return 任务列表的JSON数组
* @throws NetworkFailureException 如果网络请求失败
* @throws ActionFailureException 如果获取任务列表失败
*/
public JSONArray getTaskLists() throws NetworkFailureException {
if (!mLoggedin) {
Log.e(TAG, "please login first");
@ -661,14 +547,6 @@ public class GTaskClient {
}
}
/**
* 获取指定任务列表中的所有任务
* 从Google Tasks服务器获取指定任务列表的所有任务信息
* @param listGid 任务列表的GID
* @return 任务的JSON数组
* @throws NetworkFailureException 如果网络请求失败
* @throws ActionFailureException 如果获取任务失败
*/
public JSONArray getTaskList(String listGid) throws NetworkFailureException {
commitUpdate();
try {
@ -697,18 +575,10 @@ public class GTaskClient {
}
}
/**
* 获取当前同步的Google账户
* @return 当前同步的Account对象
*/
public Account getSyncAccount() {
return mAccount;
}
/**
* 重置更新数组
* 清空mUpdateArray中的所有更新操作
*/
public void resetUpdateArray() {
mUpdateArray = null;
}

191
src/Notes-master/src/net/micode/notes/gtask/remote/GTaskManager.java
Unescape View File

@ -48,45 +48,45 @@ import java.util.Iterator;
import java.util.Map;
/**
* Google Tasks同步管理器
* 负责处理本地笔记与Google Tasks之间的同步逻辑
* 实现单例模式，管理同步状态和同步操作
*/
public class GTaskManager {
private static final String TAG = GTaskManager.class.getSimpleName(); // 日志标签
// 同步状态常量定义
public static final int STATE_SUCCESS = 0; // 同步成功
public static final int STATE_NETWORK_ERROR = 1; // 网络错误
public static final int STATE_INTERNAL_ERROR = 2; // 内部错误
public static final int STATE_SYNC_IN_PROGRESS = 3; // 同步进行中
public static final int STATE_SYNC_CANCELLED = 4; // 同步已取消
private static GTaskManager mInstance = null; // 单例实例
private Activity mActivity; // 用于获取认证令牌的Activity实例
private Context mContext; // 应用上下文
private ContentResolver mContentResolver; // 内容解析器，用于访问本地数据库
private boolean mSyncing; // 同步状态标志
private boolean mCancelled; // 同步取消标志
// Google Tasks数据结构映射
private HashMap<String, TaskList> mGTaskListHashMap; // Google任务列表映射
private HashMap<String, Node> mGTaskHashMap; // Google任务节点映射
private HashMap<String, MetaData> mMetaHashMap; // 元数据映射
private TaskList mMetaList; // 元数据任务列表
// 同步辅助数据结构
private HashSet<Long> mLocalDeleteIdMap; // 本地删除的笔记ID集合
private HashMap<String, Long> mGidToNid; // Google任务ID到本地笔记ID的映射
private HashMap<Long, String> mNidToGid; // 本地笔记ID到Google任务ID的映射
/**
* 私有构造函数 - 初始化同步管理器实例
* 初始化所有同步相关的数据结构和状态标志
*/
private static final String TAG = GTaskManager.class.getSimpleName();
public static final int STATE_SUCCESS = 0;
public static final int STATE_NETWORK_ERROR = 1;
public static final int STATE_INTERNAL_ERROR = 2;
public static final int STATE_SYNC_IN_PROGRESS = 3;
public static final int STATE_SYNC_CANCELLED = 4;
private static GTaskManager mInstance = null;
private Activity mActivity;
private Context mContext;
private ContentResolver mContentResolver;
private boolean mSyncing;
private boolean mCancelled;
private HashMap<String, TaskList> mGTaskListHashMap;
private HashMap<String, Node> mGTaskHashMap;
private HashMap<String, MetaData> mMetaHashMap;
private TaskList mMetaList;
private HashSet<Long> mLocalDeleteIdMap;
private HashMap<String, Long> mGidToNid;
private HashMap<Long, String> mNidToGid;
private GTaskManager() {
mSyncing = false;
mCancelled = false;
@ -99,11 +99,6 @@ public class GTaskManager {
mNidToGid = new HashMap<Long, String>();
}
/**
* 获取GTaskManager的单例实例
* 使用同步方法确保线程安全
* @return GTaskManager单例实例
*/
public static synchronized GTaskManager getInstance() {
if (mInstance == null) {
mInstance = new GTaskManager();
@ -111,28 +106,11 @@ public class GTaskManager {
return mInstance;
}
/**
* 设置Activity上下文
* 用于后续获取Google认证令牌
* @param activity 用于获取认证令牌的Activity实例
*/
public synchronized void setActivityContext(Activity activity) {
// used for getting authtoken
mActivity = activity;
}
/**
* 执行笔记与Google Tasks之间的同步操作
* 这是GTaskManager的核心方法，协调整个同步流程
* @param context 应用上下文
* @param asyncTask 异步任务实例，用于发布同步进度
* @return 同步状态码：
* STATE_SUCCESS - 同步成功
* STATE_NETWORK_ERROR - 网络错误
* STATE_INTERNAL_ERROR - 内部错误
* STATE_SYNC_IN_PROGRESS - 同步进行中
* STATE_SYNC_CANCELLED - 同步已取消
*/
public int sync(Context context, GTaskASyncTask asyncTask) {
if (mSyncing) {
Log.d(TAG, "Sync is in progress");
@ -190,13 +168,6 @@ public class GTaskManager {
return mCancelled ? STATE_SYNC_CANCELLED : STATE_SUCCESS;
}
/**
* 初始化Google Tasks列表
* 从Google服务器获取所有任务列表和任务数据，并构建本地映射
* 处理元数据任务列表，确保其存在
* @throws NetworkFailureException 如果网络请求失败
* @throws ActionFailureException 如果处理JSON数据失败
*/
private void initGTaskList() throws NetworkFailureException {
if (mCancelled)
return;
@ -276,18 +247,6 @@ public class GTaskManager {
}
}
/**
* 同步内容
* 处理本地和Google Tasks之间的内容同步
* 包括：
* 1. 处理本地已删除的笔记
* 2. 同步文件夹
* 3. 处理本地已存在的笔记
* 4. 处理Google端新增的内容
* 5. 清理本地删除的笔记
* 6. 刷新本地同步ID
* @throws NetworkFailureException 如果网络请求失败
*/
private void syncContent() throws NetworkFailureException {
int syncType;
Cursor c = null;
@ -392,16 +351,6 @@ public class GTaskManager {
}
/**
* 同步文件夹
* 处理本地和Google Tasks之间的文件夹同步
* 包括：
* 1. 同步根文件夹
* 2. 同步通话记录文件夹
* 3. 同步本地已存在的普通文件夹
* 4. 同步Google端新增的文件夹
* @throws NetworkFailureException 如果网络请求失败
*/
private void syncFolder() throws NetworkFailureException {
Cursor c = null;
String gid;
@ -527,21 +476,6 @@ public class GTaskManager {
GTaskClient.getInstance().commitUpdate();
}
/**
* 执行内容同步操作
* 根据同步类型执行不同的同步动作
* @param syncType 同步类型：
* Node.SYNC_ACTION_ADD_LOCAL - 本地添加
* Node.SYNC_ACTION_ADD_REMOTE - 远程添加
* Node.SYNC_ACTION_DEL_LOCAL - 本地删除
* Node.SYNC_ACTION_DEL_REMOTE - 远程删除
* Node.SYNC_ACTION_UPDATE_LOCAL - 本地更新
* Node.SYNC_ACTION_UPDATE_REMOTE - 远程更新
* Node.SYNC_ACTION_UPDATE_CONFLICT - 更新冲突
* @param node 要同步的节点
* @param c 本地数据库游标
* @throws NetworkFailureException 如果网络请求失败
*/
private void doContentSync(int syncType, Node node, Cursor c) throws NetworkFailureException {
if (mCancelled) {
return;
@ -588,12 +522,6 @@ public class GTaskManager {
}
}
/**
* 添加本地节点
* 将Google Tasks中的节点添加到本地数据库
* @param node 要添加的Google Tasks节点
* @throws NetworkFailureException 如果网络请求失败
*/
private void addLocalNode(Node node) throws NetworkFailureException {
if (mCancelled) {
return;
@ -668,13 +596,6 @@ public class GTaskManager {
updateRemoteMeta(node.getGid(), sqlNote);
}
/**
* 更新本地节点
* 使用Google Tasks中的节点信息更新本地数据库中的笔记
* @param node Google Tasks中的节点信息
* @param c 本地数据库游标
* @throws NetworkFailureException 如果网络请求失败
*/
private void updateLocalNode(Node node, Cursor c) throws NetworkFailureException {
if (mCancelled) {
return;
@ -698,13 +619,6 @@ public class GTaskManager {
updateRemoteMeta(node.getGid(), sqlNote);
}
/**
* 添加远程节点
* 将本地数据库中的笔记添加到Google Tasks
* @param node Google Tasks节点（可能为null）
* @param c 本地数据库游标
* @throws NetworkFailureException 如果网络请求失败
*/
private void addRemoteNode(Node node, Cursor c) throws NetworkFailureException {
if (mCancelled) {
return;
@ -778,14 +692,6 @@ public class GTaskManager {
mNidToGid.put(sqlNote.getId(), n.getGid());
}
/**
* 更新远程节点
* 将本地数据库中笔记的更新同步到Google Tasks
* 如果需要，还会处理任务的移动（更改父文件夹）
* @param node Google Tasks节点
* @param c 本地数据库游标
* @throws NetworkFailureException 如果网络请求失败
*/
private void updateRemoteNode(Node node, Cursor c) throws NetworkFailureException {
if (mCancelled) {
return;
@ -824,13 +730,6 @@ public class GTaskManager {
sqlNote.commit(true);
}
/**
* 更新远程元数据
* 将本地笔记的元数据信息更新到Google Tasks的元数据列表中
* @param gid Google Tasks节点ID
* @param sqlNote 本地笔记对象
* @throws NetworkFailureException 如果网络请求失败
*/
private void updateRemoteMeta(String gid, SqlNote sqlNote) throws NetworkFailureException {
if (sqlNote != null && sqlNote.isNoteType()) {
MetaData metaData = mMetaHashMap.get(gid);
@ -847,12 +746,6 @@ public class GTaskManager {
}
}
/**
* 刷新本地同步ID
* 同步完成后，更新本地笔记的同步ID为Google Tasks的最后修改时间
* 确保下次同步时能正确检测到更改
* @throws NetworkFailureException 如果网络请求失败
*/
private void refreshLocalSyncId() throws NetworkFailureException {
if (mCancelled) {
return;
@ -897,18 +790,10 @@ public class GTaskManager {
}
}
/**
* 获取当前同步账户
* @return 当前用于Google Tasks同步的账户名称
*/
public String getSyncAccount() {
return GTaskClient.getInstance().getSyncAccount().name;
}
/**
* 取消当前同步操作
* 设置取消标志，使正在进行的同步操作能够优雅地终止
*/
public void cancelSync() {
mCancelled = true;
}

82
src/Notes-master/src/net/micode/notes/gtask/remote/GTaskSyncService.java
Unescape View File

@ -23,33 +23,25 @@ import android.content.Intent;
import android.os.Bundle;
import android.os.IBinder;
/**
* Google Tasks同步服务
* 管理Google Tasks与本地笔记之间的同步操作的Service组件
* 提供开始同步、取消同步的功能，并通过广播通知同步状态和进度
*/
public class GTaskSyncService extends Service {
// 动作类型常量定义
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; // 无效动作
// 广播相关常量定义
public final static String GTASK_SERVICE_BROADCAST_NAME = "net.micode.notes.gtask.remote.gtask_sync_service"; // 广播的Intent动作名称
public final static String GTASK_SERVICE_BROADCAST_IS_SYNCING = "isSyncing"; // 广播中同步状态的键
public final static String GTASK_SERVICE_BROADCAST_PROGRESS_MSG = "progressMsg"; // 广播中同步进度消息的键
// 同步任务相关变量
private static GTaskASyncTask mSyncTask = null; // 当前执行的同步任务实例
private static String mSyncProgress = ""; // 当前同步进度消息
/**
* 启动同步操作
* 创建并执行Google Tasks同步异步任务
* 如果已经有同步任务在执行，则不重复启动
*/
public final static String ACTION_STRING_NAME = "sync_action_type";
public final static int ACTION_START_SYNC = 0;
public final static int ACTION_CANCEL_SYNC = 1;
public final static int ACTION_INVALID = 2;
public final static String GTASK_SERVICE_BROADCAST_NAME = "net.micode.notes.gtask.remote.gtask_sync_service";
public final static String GTASK_SERVICE_BROADCAST_IS_SYNCING = "isSyncing";
public final static String GTASK_SERVICE_BROADCAST_PROGRESS_MSG = "progressMsg";
private static GTaskASyncTask mSyncTask = null;
private static String mSyncProgress = "";
private void startSync() {
if (mSyncTask == null) {
mSyncTask = new GTaskASyncTask(this, new GTaskASyncTask.OnCompleteListener() {
@ -64,10 +56,6 @@ public class GTaskSyncService extends Service {
}
}
/**
* 取消同步操作
* 如果有同步任务正在执行，则取消该任务
*/
private void cancelSync() {
if (mSyncTask != null) {
mSyncTask.cancelSync();
@ -76,13 +64,11 @@ public class GTaskSyncService extends Service {
@Override
public void onCreate() {
// 服务创建时初始化同步任务为null
mSyncTask = null;
}
@Override
public int onStartCommand(Intent intent, int flags, int startId) {
// 处理传入的Intent，根据动作类型执行相应的同步操作
Bundle bundle = intent.getExtras();
if (bundle != null && bundle.containsKey(ACTION_STRING_NAME)) {
switch (bundle.getInt(ACTION_STRING_NAME, ACTION_INVALID)) {
@ -95,7 +81,6 @@ public class GTaskSyncService extends Service {
default:
break;
}
// 返回START_STICKY表示如果服务被系统杀死，会在资源允许时重新创建
return START_STICKY;
}
return super.onStartCommand(intent, flags, startId);
@ -103,28 +88,15 @@ public class GTaskSyncService extends Service {
@Override
public void onLowMemory() {
// 系统内存不足时，如果有同步任务正在执行，则取消它以释放资源
if (mSyncTask != null) {
mSyncTask.cancelSync();
}
}
/**
* Service的绑定方法
* 该服务不支持绑定，因此返回null
* @param intent 绑定意图
* @return null
*/
@Override
public IBinder onBind(Intent intent) {
return null;
}
/**
* 发送同步状态广播
* 通知应用其他组件同步的当前状态和进度
* @param msg 同步进度消息
*/
public void sendBroadcast(String msg) {
mSyncProgress = msg;
Intent intent = new Intent(GTASK_SERVICE_BROADCAST_NAME);
@ -133,11 +105,6 @@ public class GTaskSyncService extends Service {
sendBroadcast(intent);
}
/**
* 静态方法：启动Google Tasks同步服务
* 这是启动同步的公共入口方法，设置Activity上下文并发送启动同步的Intent
* @param activity 用于获取Google认证的Activity实例
*/
public static void startSync(Activity activity) {
GTaskManager.getInstance().setActivityContext(activity);
Intent intent = new Intent(activity, GTaskSyncService.class);
@ -145,29 +112,16 @@ public class GTaskSyncService extends Service {
activity.startService(intent);
}
/**
* 静态方法：取消Google Tasks同步服务
* 这是取消同步的公共入口方法，发送取消同步的Intent
* @param context 应用上下文
*/
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);
}
/**
* 静态方法：检查是否正在同步
* @return true表示正在同步，false表示未在同步
*/
public static boolean isSyncing() {
return mSyncTask != null;
}
/**
* 静态方法：获取当前同步进度消息
* @return 当前同步进度消息字符串
*/
public static String getProgressString() {
return mSyncProgress;
}

116
src/Notes-master/src/net/micode/notes/model/Note.java
Unescape View File

@ -34,26 +34,15 @@ import net.micode.notes.data.Notes.TextNote;
import java.util.ArrayList;
/**
* 笔记模型
* 用于处理笔记的创建、更新和同步操作
* 采用分层设计，将笔记的元数据和具体内容分开管理
*/
public class Note {
/** 笔记差异值，用于记录笔记表的修改字段（增量更新） */
private ContentValues mNoteDiffValues;
/** 笔记数据对象，负责文本与通话相关的数据行 */
private NoteData mNoteData;
private static final String TAG = "Note";
/**
* 创建新笔记并返回ID。
*
* @param context 上下文对象
* @param folderId 目标父文件夹ID
* @return 新创建的笔记ID（>0）；失败抛出异常或返回0
* Create a new note id for adding a new note to databases
*/
public static synchronized long getNewNoteId(Context context, long folderId) {
// 在数据库中创建新笔记：设置创建/修改时间、类型、父文件夹等初始值
// Create a new note in the database
ContentValues values = new ContentValues();
long createdTime = System.currentTimeMillis();
values.put(NoteColumns.CREATED_DATE, createdTime);
@ -76,82 +65,41 @@ public class Note {
return noteId;
}
/**
* 构造方法 - 初始化笔记对象
*/
public Note() {
mNoteDiffValues = new ContentValues();
mNoteData = new NoteData();
}
/**
* 设置笔记表字段的值，并标记本地修改。
* @param key 字段名
* @param value 字段值
*/
public void setNoteValue(String key, String value) {
mNoteDiffValues.put(key, value);
mNoteDiffValues.put(NoteColumns.LOCAL_MODIFIED, 1);
mNoteDiffValues.put(NoteColumns.MODIFIED_DATE, System.currentTimeMillis());
}
/**
* 设置文本数据字段（data 表）。
* @param key 字段名
* @param value 字段值
*/
public void setTextData(String key, String value) {
mNoteData.setTextData(key, value);
}
/**
* 设置文本笔记的数据ID
* @param id 文本笔记数据ID
*/
public void setTextDataId(long id) {
mNoteData.setTextDataId(id);
}
/**
* 获取文本笔记的数据ID
* @return 文本笔记数据ID
*/
public long getTextDataId() {
return mNoteData.mTextDataId;
}
/**
* 设置通话笔记的数据ID
* @param id 通话笔记数据ID
*/
public void setCallDataId(long id) {
mNoteData.setCallDataId(id);
}
/**
* 设置通话数据字段（data 表）。
* @param key 字段名
* @param value 字段值
*/
public void setCallData(String key, String value) {
mNoteData.setCallData(key, value);
}
/**
* 检查笔记是否在本地被修改
* @return 如果笔记在本地被修改，返回true，否则返回false
*/
public boolean isLocalModified() {
return mNoteDiffValues.size() > 0 || mNoteData.isLocalModified();
}
/**
* 将笔记的增量更新同步到数据库。
*
* @param context 上下文对象
* @param noteId 笔记ID
* @return 同步成功返回 true，失败返回 false
*/
public boolean syncNote(Context context, long noteId) {
if (noteId <= 0) {
throw new IllegalArgumentException("Wrong note id:" + noteId);
@ -161,12 +109,16 @@ public class Note {
return true;
}
// 理论上任何变更都应更新 LOCAL_MODIFIED 与 MODIFIED_DATE；即便 note 表更新失败，也继续尝试写 data
/**
* In theory, once data changed, the note should be updated on {@link NoteColumns#LOCAL_MODIFIED} and
* {@link NoteColumns#MODIFIED_DATE}. For data safety, though update note fails, we also update the
* note data info
*/
if (context.getContentResolver().update(
ContentUris.withAppendedId(Notes.CONTENT_NOTE_URI, noteId), mNoteDiffValues, null,
null) == 0) {
Log.e(TAG, "Update note error, should not happen");
// 不返回，继续执行
// Do not return, fall through
}
mNoteDiffValues.clear();
@ -178,22 +130,17 @@ public class Note {
return true;
}
/**
* 笔记数据内部类
* 用于管理笔记的具体内容数据，支持文本笔记和通话笔记
*/
private class NoteData {
private long mTextDataId; // 文本笔记数据ID
private ContentValues mTextDataValues; // 文本笔记数据值
private long mCallDataId; // 通话笔记数据ID
private ContentValues mCallDataValues; // 通话笔记数据值
private static final String TAG = "NoteData"; // 日志标签
private long mTextDataId;
private ContentValues mTextDataValues;
private long mCallDataId;
private ContentValues mCallDataValues;
private static final String TAG = "NoteData";
/** 构造函数：初始化两个数据集与对应 ID */
public NoteData() {
mTextDataValues = new ContentValues();
mCallDataValues = new ContentValues();
@ -201,19 +148,10 @@ public class Note {
mCallDataId = 0;
}
/**
* 检查笔记数据是否在本地被修改
* @return 如果笔记数据在本地被修改，返回true，否则返回false
*/
boolean isLocalModified() {
return mTextDataValues.size() > 0 || mCallDataValues.size() > 0;
}
/**
* 设置文本笔记的数据ID
* @param id 文本笔记数据ID
* @throws IllegalArgumentException 如果ID小于等于0
*/
void setTextDataId(long id) {
if(id <= 0) {
throw new IllegalArgumentException("Text data id should larger than 0");
@ -221,11 +159,6 @@ public class Note {
mTextDataId = id;
}
/**
* 设置通话笔记的数据ID
* @param id 通话笔记数据ID
* @throws IllegalArgumentException 如果ID小于等于0
*/
void setCallDataId(long id) {
if (id <= 0) {
throw new IllegalArgumentException("Call data id should larger than 0");
@ -233,37 +166,22 @@ public class Note {
mCallDataId = id;
}
/**
* 设置通话数据字段，并同步标记 note 为本地修改。
* @param key 字段名
* @param value 字段值
*/
void setCallData(String key, String value) {
mCallDataValues.put(key, value);
mNoteDiffValues.put(NoteColumns.LOCAL_MODIFIED, 1);
mNoteDiffValues.put(NoteColumns.MODIFIED_DATE, System.currentTimeMillis());
}
/**
* 设置文本数据字段，并同步标记 note 为本地修改。
* @param key 字段名
* @param value 字段值
*/
void setTextData(String key, String value) {
mTextDataValues.put(key, value);
mNoteDiffValues.put(NoteColumns.LOCAL_MODIFIED, 1);
mNoteDiffValues.put(NoteColumns.MODIFIED_DATE, System.currentTimeMillis());
}
/**
* 将笔记数据推入内容解析器
* 将本地修改的笔记数据同步到数据库中
* @param context 上下文对象
* @param noteId 笔记ID
* @return 同步后的URI，同步失败返回null
*/
Uri pushIntoContentResolver(Context context, long noteId) {
// 安全检查
/**
* Check for safety
*/
if (noteId <= 0) {
throw new IllegalArgumentException("Wrong note id:" + noteId);
}
@ -272,7 +190,6 @@ public class Note {
ContentProviderOperation.Builder builder = null;
if(mTextDataValues.size() > 0) {
// 写入或更新文本数据（MIME: text_note）
mTextDataValues.put(DataColumns.NOTE_ID, noteId);
if (mTextDataId == 0) {
mTextDataValues.put(DataColumns.MIME_TYPE, TextNote.CONTENT_ITEM_TYPE);
@ -295,7 +212,6 @@ public class Note {
}
if(mCallDataValues.size() > 0) {
// 写入或更新通话数据（MIME: call_note）
mCallDataValues.put(DataColumns.NOTE_ID, noteId);
if (mCallDataId == 0) {
mCallDataValues.put(DataColumns.MIME_TYPE, CallNote.CONTENT_ITEM_TYPE);

269
src/Notes-master/src/net/micode/notes/model/WorkingNote.java
Unescape View File

@ -31,79 +31,77 @@ import net.micode.notes.data.Notes.NoteColumns;
import net.micode.notes.data.Notes.TextNote;
import net.micode.notes.tool.ResourceParser.NoteBgResources;
/**
* 工作笔记类。
* <p>职责：代表当前正在编辑/展示的笔记，封装从数据库加载、修改、保存、以及小部件联动等操作。</p>
* <p>使用场景：编辑页、列表点击进入编辑、或小部件创建笔记时，都通过该类聚合业务逻辑。</p>
*/
/**
* 工作笔记
* 用于在用户界面层管理笔记的编辑状态和操作
* 封装了笔记的数据模型和用户交互相关的逻辑
*/
public class WorkingNote {
private Note mNote; // 实际的笔记数据模型
private long mNoteId; // 笔记ID
private String mContent; // 笔记内容
private int mMode; // 笔记模式（普通模式/清单模式）
private long mAlertDate; // 提醒日期时间
private long mModifiedDate; // 最后修改时间
private int mBgColorId; // 背景颜色ID
private int mWidgetId; // 小部件ID
private int mWidgetType; // 小部件类型
private long mFolderId; // 所属文件夹ID
private Context mContext; // 上下文对象
private static final String TAG = "WorkingNote"; // 日志标签
private boolean mIsDeleted; // 是否已删除
private NoteSettingChangedListener mNoteSettingStatusListener; // 笔记设置变化监听器
// Note for the working note
private Note mNote;
// Note Id
private long mNoteId;
// Note content
private String mContent;
// Note mode
private int mMode;
private long mAlertDate;
private long mModifiedDate;
private int mBgColorId;
private int mWidgetId;
private int mWidgetType;
private long mFolderId;
private Context mContext;
private static final String TAG = "WorkingNote";
private boolean mIsDeleted;
private NoteSettingChangedListener mNoteSettingStatusListener;
public static final String[] DATA_PROJECTION = new String[] {
DataColumns.ID, // 数据ID
DataColumns.CONTENT, // 笔记内容
DataColumns.MIME_TYPE, // 数据类型
DataColumns.DATA1, // 附加数据1
DataColumns.DATA2, // 附加数据2
DataColumns.DATA3, // 附加数据3
DataColumns.DATA4, // 附加数据4
DataColumns.ID,
DataColumns.CONTENT,
DataColumns.MIME_TYPE,
DataColumns.DATA1,
DataColumns.DATA2,
DataColumns.DATA3,
DataColumns.DATA4,
};
/**
* 笔记元数据查询投影列
* 用于查询笔记的基本信息
*/
public static final String[] NOTE_PROJECTION = new String[] {
NoteColumns.PARENT_ID, // 所属文件夹ID
NoteColumns.ALERTED_DATE, // 提醒日期
NoteColumns.BG_COLOR_ID, // 背景颜色ID
NoteColumns.WIDGET_ID, // 小部件ID
NoteColumns.WIDGET_TYPE, // 小部件类型
NoteColumns.MODIFIED_DATE // 修改日期
NoteColumns.PARENT_ID,
NoteColumns.ALERTED_DATE,
NoteColumns.BG_COLOR_ID,
NoteColumns.WIDGET_ID,
NoteColumns.WIDGET_TYPE,
NoteColumns.MODIFIED_DATE
};
// 数据查询结果列索引
private static final int DATA_ID_COLUMN = 0; // 数据ID列索引
private static final int DATA_CONTENT_COLUMN = 1; // 内容列索引
private static final int DATA_MIME_TYPE_COLUMN = 2; // MIME类型列索引
private static final int DATA_MODE_COLUMN = 3; // 模式列索引
private static final int DATA_ID_COLUMN = 0;
private static final int DATA_CONTENT_COLUMN = 1;
private static final int DATA_MIME_TYPE_COLUMN = 2;
private static final int DATA_MODE_COLUMN = 3;
private static final int NOTE_PARENT_ID_COLUMN = 0;
private static final int NOTE_ALERTED_DATE_COLUMN = 1;
private static final int NOTE_BG_COLOR_ID_COLUMN = 2;
// 笔记查询结果列索引
private static final int NOTE_PARENT_ID_COLUMN = 0; // 父文件夹ID列索引
private static final int NOTE_ALERTED_DATE_COLUMN = 1; // 提醒日期列索引
private static final int NOTE_BG_COLOR_ID_COLUMN = 2; // 背景颜色ID列索引
private static final int NOTE_WIDGET_ID_COLUMN = 3; // 小部件ID列索引
private static final int NOTE_WIDGET_TYPE_COLUMN = 4; // 小部件类型列索引
private static final int NOTE_MODIFIED_DATE_COLUMN = 5; // 修改日期列索引
private static final int NOTE_WIDGET_ID_COLUMN = 3;
private static final int NOTE_WIDGET_TYPE_COLUMN = 4;
private static final int NOTE_MODIFIED_DATE_COLUMN = 5;
/**
* 新建笔记的构造函数。
*
* @param context 上下文对象
* @param folderId 文件夹ID
*/
// New note construct
private WorkingNote(Context context, long folderId) {
mContext = context;
mAlertDate = 0;
@ -116,12 +114,7 @@ public class WorkingNote {
mWidgetType = Notes.TYPE_WIDGET_INVALIDE;
}
/**
* 构造方法 - 加载现有笔记
* @param context 上下文对象
* @param noteId 笔记ID
* @param folderId 所属文件夹ID
*/
// Existing note construct
private WorkingNote(Context context, long noteId, long folderId) {
mContext = context;
mNoteId = noteId;
@ -131,10 +124,6 @@ public class WorkingNote {
loadNote();
}
/**
* 加载笔记元数据（note 表），包括父文件夹、背景色、小部件、提醒、修改时间等。
* 加载完成后再拉取 data 表详细内容。
*/
private void loadNote() {
Cursor cursor = mContext.getContentResolver().query(
ContentUris.withAppendedId(Notes.CONTENT_NOTE_URI, mNoteId), NOTE_PROJECTION, null,
@ -157,10 +146,6 @@ public class WorkingNote {
loadNoteData();
}
/**
* 加载笔记的数据内容（data 表）。
* <p>遍历该笔记的所有数据行：找到文本行（NOTE）记录内容与模式；找到通话行（CALL_NOTE）记录其数据ID。</p>
*/
private void loadNoteData() {
Cursor cursor = mContext.getContentResolver().query(Notes.CONTENT_DATA_URI, DATA_PROJECTION,
DataColumns.NOTE_ID + "=?", new String[] {
@ -189,16 +174,6 @@ public class WorkingNote {
}
}
/**
* 创建空白笔记实例（尚未写入数据库）。
*
* @param context 上下文对象
* @param folderId 目标文件夹ID
* @param widgetId 关联小部件ID
* @param widgetType 小部件类型
* @param defaultBgColorId 默认背景色
* @return 工作笔记对象
*/
public static WorkingNote createEmptyNote(Context context, long folderId, int widgetId,
int widgetType, int defaultBgColorId) {
WorkingNote note = new WorkingNote(context, folderId);
@ -208,21 +183,10 @@ public class WorkingNote {
return note;
}
/**
* 从数据库加载指定ID的笔记
* @param context 上下文对象
* @param id 笔记ID
* @return 加载的工作笔记对象
*/
public static WorkingNote load(Context context, long id) {
return new WorkingNote(context, id, 0);
}
/**
* 保存笔记：必要时创建新记录，然后同步增量到 note/data，并刷新小部件。
*
* @return 保存成功返回true，否则返回false
*/
public synchronized boolean saveNote() {
if (isWorthSaving()) {
if (!existInDatabase()) {
@ -234,7 +198,9 @@ public class WorkingNote {
mNote.syncNote(mContext, mNoteId);
// 如果该笔记存在小部件，更新小部件内容
/**
* Update widget content if there exist any widget of this note
*/
if (mWidgetId != AppWidgetManager.INVALID_APPWIDGET_ID
&& mWidgetType != Notes.TYPE_WIDGET_INVALIDE
&& mNoteSettingStatusListener != null) {
@ -246,19 +212,10 @@ public class WorkingNote {
}
}
/**
* 判断笔记是否已有持久化记录（noteId>0）。
* @return 存在返回true
*/
public boolean existInDatabase() {
return mNoteId > 0;
}
/**
* 检查笔记是否值得保存
* 当笔记已删除、空内容且不存在于数据库中、或存在于数据库但未被修改时，不值得保存
* @return 如果笔记值得保存返回true，否则返回false
*/
private boolean isWorthSaving() {
if (mIsDeleted || (!existInDatabase() && TextUtils.isEmpty(mContent))
|| (existInDatabase() && !mNote.isLocalModified())) {
@ -268,19 +225,10 @@ public class WorkingNote {
}
}
/**
* 注册笔记设置变化监听器（用于通知 UI 或小部件刷新）。
* @param l 监听器对象
*/
public void setOnSettingStatusChangedListener(NoteSettingChangedListener l) {
mNoteSettingStatusListener = l;
}
/**
* 设置提醒时间，并通知监听器。
* @param date 提醒日期时间戳
* @param set 是否设置提醒
*/
public void setAlertDate(long date, boolean set) {
if (date != mAlertDate) {
mAlertDate = date;
@ -291,10 +239,6 @@ public class WorkingNote {
}
}
/**
* 标记笔记为已删除，若关联小部件则触发刷新。
* @param mark 是否标记为删除
*/
public void markDeleted(boolean mark) {
mIsDeleted = mark;
if (mWidgetId != AppWidgetManager.INVALID_APPWIDGET_ID
@ -303,10 +247,6 @@ public class WorkingNote {
}
}
/**
* 设置背景颜色，并通知监听器、记录本地修改。
* @param id 背景颜色ID
*/
public void setBgColorId(int id) {
if (id != mBgColorId) {
mBgColorId = id;
@ -317,10 +257,6 @@ public class WorkingNote {
}
}
/**
* 设置清单模式。
* @param mode 模式（0 普通，1 清单）
*/
public void setCheckListMode(int mode) {
if (mMode != mode) {
if (mNoteSettingStatusListener != null) {
@ -331,10 +267,6 @@ public class WorkingNote {
}
}
/**
* 设置笔记小部件类型
* @param type 小部件类型
*/
public void setWidgetType(int type) {
if (type != mWidgetType) {
mWidgetType = type;
@ -342,10 +274,6 @@ public class WorkingNote {
}
}
/**
* 设置笔记小部件ID
* @param id 小部件ID
*/
public void setWidgetId(int id) {
if (id != mWidgetId) {
mWidgetId = id;
@ -353,10 +281,6 @@ public class WorkingNote {
}
}
/**
* 设置笔记工作内容
* @param text 笔记内容
*/
public void setWorkingText(String text) {
if (!TextUtils.equals(mContent, text)) {
mContent = text;
@ -364,139 +288,80 @@ public class WorkingNote {
}
}
/**
* 将笔记转换为通话记录笔记
* @param phoneNumber 电话号码
* @param callDate 通话日期时间
*/
public void convertToCallNote(String phoneNumber, long callDate) {
mNote.setCallData(CallNote.CALL_DATE, String.valueOf(callDate));
mNote.setCallData(CallNote.PHONE_NUMBER, phoneNumber);
mNote.setNoteValue(NoteColumns.PARENT_ID, String.valueOf(Notes.ID_CALL_RECORD_FOLDER));
}
/**
* 检查笔记是否设置了提醒
* @return 如果设置了提醒返回true，否则返回false
*/
public boolean hasClockAlert() {
return (mAlertDate > 0 ? true : false);
}
/**
* 获取笔记内容
* @return 笔记内容
*/
public String getContent() {
return mContent;
}
/**
* 获取笔记提醒日期
* @return 提醒日期时间
*/
public long getAlertDate() {
return mAlertDate;
}
/**
* 获取笔记最后修改时间
* @return 最后修改时间
*/
public long getModifiedDate() {
return mModifiedDate;
}
/**
* 获取笔记背景颜色资源ID
* @return 背景颜色资源ID
*/
public int getBgColorResId() {
return NoteBgResources.getNoteBgResource(mBgColorId);
}
/**
* 获取笔记背景颜色ID
* @return 背景颜色ID
*/
public int getBgColorId() {
return mBgColorId;
}
/**
* 获取笔记标题背景资源ID
* @return 标题背景资源ID
*/
public int getTitleBgResId() {
return NoteBgResources.getNoteTitleBgResource(mBgColorId);
}
/**
* 获取笔记模式（普通模式/清单模式）
* @return 笔记模式
*/
public int getCheckListMode() {
return mMode;
}
/**
* 获取笔记ID
* @return 笔记ID
*/
public long getNoteId() {
return mNoteId;
}
/**
* 获取笔记所属文件夹ID
* @return 文件夹ID
*/
public long getFolderId() {
return mFolderId;
}
/**
* 获取笔记小部件ID
* @return 小部件ID
*/
public int getWidgetId() {
return mWidgetId;
}
/**
* 获取笔记小部件类型
* @return 小部件类型
*/
public int getWidgetType() {
return mWidgetType;
}
/**
* 笔记设置变化监听器
* 用于监听笔记设置变化事件
*/
public interface NoteSettingChangedListener {
/**
* 当笔记背景颜色改变时调用
* Called when the background color of current note has just changed
*/
void onBackgroundColorChanged();
/**
* 当用户设置或取消提醒时调用
* @param date 提醒日期时间
* @param set 是否设置提醒
* Called when user set clock
*/
void onClockAlertChanged(long date, boolean set);
/**
* 当笔记小部件内容需要更新时调用
* Call when user create note from widget
*/
void onWidgetChanged();
/**
* 当切换笔记模式（普通模式/清单模式）时调用
* @param oldMode 切换前的模式
* @param newMode 切换后的模式
* Call when switch between check list mode and normal mode
* @param oldMode is previous mode before change
* @param newMode is new mode
*/
void onCheckListModeChanged(int oldMode, int newMode);
}

200
src/Notes-master/src/net/micode/notes/tool/BackupUtils.java
Unescape View File

@ -36,20 +36,11 @@ import java.io.IOException;
import java.io.PrintStream;
/**
* 备份工具 - 用于将笔记数据导出为文本文件
* 采用单例模式设计，确保全局只有一个备份工具实例
*/
public class BackupUtils {
private static final String TAG = "BackupUtils"; // 日志标签
/** 单例实例 */
private static BackupUtils sInstance; // 单例实例
private static final String TAG = "BackupUtils";
// Singleton stuff
private static BackupUtils sInstance;
/**
* 获取BackupUtils单例实例
* @param context 上下文对象
* @return BackupUtils单例实例
*/
public static synchronized BackupUtils getInstance(Context context) {
if (sInstance == null) {
sInstance = new BackupUtils(context);
@ -57,109 +48,83 @@ public class BackupUtils {
return sInstance;
}
/** 备份或恢复状态常量 */
/** SD卡未挂载 */
public static final int STATE_SD_CARD_UNMOUONTED = 0; // SD卡未挂载
/** 备份文件不存在 */
public static final int STATE_BACKUP_FILE_NOT_EXIST = 1; // 备份文件不存在
/** 数据格式损坏，可能被其他程序修改 */
public static final int STATE_DATA_DESTROIED = 2; // 数据格式错误
/** 运行时异常导致恢复或备份失败 */
public static final int STATE_SYSTEM_ERROR = 3; // 系统错误
/** 备份或恢复成功 */
public static final int STATE_SUCCESS = 4; // 操作成功
/** 文本导出对象 */
private TextExport mTextExport;
/**
* 私有构造方法 - 初始化文本导出工具
* @param context 上下文对象
* Following states are signs to represents backup or restore
* status
*/
// Currently, the sdcard is not mounted
public static final int STATE_SD_CARD_UNMOUONTED = 0;
// The backup file not exist
public static final int STATE_BACKUP_FILE_NOT_EXIST = 1;
// The data is not well formated, may be changed by other programs
public static final int STATE_DATA_DESTROIED = 2;
// Some run-time exception which causes restore or backup fails
public static final int STATE_SYSTEM_ERROR = 3;
// Backup or restore success
public static final int STATE_SUCCESS = 4;
private TextExport mTextExport;
private BackupUtils(Context context) {
mTextExport = new TextExport(context);
}
/**
* 检查外部存储是否已挂载。
* @return 可用返回true
*/
private static boolean externalStorageAvailable() {
return Environment.MEDIA_MOUNTED.equals(Environment.getExternalStorageState());
}
/**
* 将笔记导出为文本文件
* @return 导出状态码
*/
public int exportToText() {
return mTextExport.exportToText();
}
/**
* 获取导出的文本文件名
* @return 导出的文本文件名
*/
public String getExportedTextFileName() {
return mTextExport.mFileName;
}
/**
* 获取导出的文本文件目录
* @return 导出的文本文件目录
*/
public String getExportedTextFileDir() {
return mTextExport.mFileDirectory;
}
/**
* 文本导出内部类：遍历 note/data 表，将结果写入 SD 卡上的 txt 文件。
*/
private static class TextExport {
// 笔记查询投影列
private static final String[] NOTE_PROJECTION = {
NoteColumns.ID, // 笔记ID
NoteColumns.MODIFIED_DATE, // 修改日期
NoteColumns.SNIPPET, // 笔记摘要
NoteColumns.TYPE // 笔记类型
NoteColumns.ID,
NoteColumns.MODIFIED_DATE,
NoteColumns.SNIPPET,
NoteColumns.TYPE
};
// 笔记查询结果列索引
private static final int NOTE_COLUMN_ID = 0; // ID列索引
private static final int NOTE_COLUMN_MODIFIED_DATE = 1; // 修改日期列索引
private static final int NOTE_COLUMN_SNIPPET = 2; // 摘要列索引
private static final int NOTE_COLUMN_ID = 0;
private static final int NOTE_COLUMN_MODIFIED_DATE = 1;
private static final int NOTE_COLUMN_SNIPPET = 2;
// 笔记数据查询投影列
private static final String[] DATA_PROJECTION = {
DataColumns.CONTENT, // 内容
DataColumns.MIME_TYPE, // MIME类型
DataColumns.DATA1, // 数据1
DataColumns.DATA2, // 数据2
DataColumns.DATA3, // 数据3
DataColumns.DATA4, // 数据4
DataColumns.CONTENT,
DataColumns.MIME_TYPE,
DataColumns.DATA1,
DataColumns.DATA2,
DataColumns.DATA3,
DataColumns.DATA4,
};
// 笔记数据查询结果列索引
private static final int DATA_COLUMN_CONTENT = 0; // 内容列索引
private static final int DATA_COLUMN_MIME_TYPE = 1; // MIME类型列索引
private static final int DATA_COLUMN_CALL_DATE = 2; // 通话日期列索引
private static final int DATA_COLUMN_PHONE_NUMBER = 4; // 电话号码列索引
private static final int DATA_COLUMN_CONTENT = 0;
private static final int DATA_COLUMN_MIME_TYPE = 1;
private static final int DATA_COLUMN_CALL_DATE = 2;
private static final int DATA_COLUMN_PHONE_NUMBER = 4;
// 文本格式模板
private final String [] TEXT_FORMAT;
private static final int FORMAT_FOLDER_NAME = 0; // 文件夹名称格式
private static final int FORMAT_NOTE_DATE = 1; // 笔记日期格式
private static final int FORMAT_NOTE_CONTENT = 2; // 笔记内容格式
private static final int FORMAT_FOLDER_NAME = 0;
private static final int FORMAT_NOTE_DATE = 1;
private static final int FORMAT_NOTE_CONTENT = 2;
// 成员变量
private Context mContext; // 上下文对象
private String mFileName; // 导出文件名
private String mFileDirectory; // 导出文件目录
private Context mContext;
private String mFileName;
private String mFileDirectory;
/**
* 构造方法 - 初始化文本导出工具
* @param context 上下文对象
*/
public TextExport(Context context) {
TEXT_FORMAT = context.getResources().getStringArray(R.array.format_for_exported_note);
mContext = context;
@ -167,22 +132,15 @@ public class BackupUtils {
mFileDirectory = "";
}
/**
* 获取指定ID的文本格式模板
* @param id 格式模板ID
* @return 文本格式模板
*/
private String getFormat(int id) {
return TEXT_FORMAT[id];
}
/**
* 将指定ID的文件夹及其包含的笔记导出为文本格式
* @param folderId 文件夹ID
* @param ps 输出流对象
* Export the folder identified by folder id to text
*/
private void exportFolderToText(String folderId, PrintStream ps) {
// 查询该文件夹下的所有笔记
// Query notes belong to this folder
Cursor notesCursor = mContext.getContentResolver().query(Notes.CONTENT_NOTE_URI,
NOTE_PROJECTION, NoteColumns.PARENT_ID + "=?", new String[] {
folderId
@ -191,11 +149,11 @@ public class BackupUtils {
if (notesCursor != null) {
if (notesCursor.moveToFirst()) {
do {
// 打印笔记的最后修改日期
// Print note's last modified date
ps.println(String.format(getFormat(FORMAT_NOTE_DATE), DateFormat.format(
mContext.getString(R.string.format_datetime_mdhm),
notesCursor.getLong(NOTE_COLUMN_MODIFIED_DATE))));
// 查询该笔记的详细数据
// Query data belong to this note
String noteId = notesCursor.getString(NOTE_COLUMN_ID);
exportNoteToText(noteId, ps);
} while (notesCursor.moveToNext());
@ -205,12 +163,9 @@ public class BackupUtils {
}
/**
* 将指定ID的笔记导出到输出流中
* @param noteId 笔记ID
* @param ps 输出流对象
* Export note identified by id to a print stream
*/
private void exportNoteToText(String noteId, PrintStream ps) {
// 查询该笔记的详细数据
Cursor dataCursor = mContext.getContentResolver().query(Notes.CONTENT_DATA_URI,
DATA_PROJECTION, DataColumns.NOTE_ID + "=?", new String[] {
noteId
@ -220,29 +175,26 @@ public class BackupUtils {
if (dataCursor.moveToFirst()) {
do {
String mimeType = dataCursor.getString(DATA_COLUMN_MIME_TYPE);
// 处理通话记录类型笔记
if (DataConstants.CALL_NOTE.equals(mimeType)) {
// Print phone number
String phoneNumber = dataCursor.getString(DATA_COLUMN_PHONE_NUMBER);
long callDate = dataCursor.getLong(DATA_COLUMN_CALL_DATE);
String location = dataCursor.getString(DATA_COLUMN_CONTENT);
// 打印电话号码
if (!TextUtils.isEmpty(phoneNumber)) {
ps.println(String.format(getFormat(FORMAT_NOTE_CONTENT),
phoneNumber));
}
// 打印通话日期
// Print call date
ps.println(String.format(getFormat(FORMAT_NOTE_CONTENT), DateFormat
.format(mContext.getString(R.string.format_datetime_mdhm),
callDate)));
// 打印通话附件位置
// Print call attachment location
if (!TextUtils.isEmpty(location)) {
ps.println(String.format(getFormat(FORMAT_NOTE_CONTENT),
location));
}
}
// 处理普通类型笔记
else if (DataConstants.NOTE.equals(mimeType)) {
} else if (DataConstants.NOTE.equals(mimeType)) {
String content = dataCursor.getString(DATA_COLUMN_CONTENT);
if (!TextUtils.isEmpty(content)) {
ps.println(String.format(getFormat(FORMAT_NOTE_CONTENT),
@ -253,10 +205,10 @@ public class BackupUtils {
}
dataCursor.close();
}
// 在笔记之间打印分隔符
// print a line separator between note
try {
ps.write(new byte[] {
Character.LINE_SEPARATOR, Character.LINE_SEPARATOR
Character.LINE_SEPARATOR, Character.LETTER_NUMBER
});
} catch (IOException e) {
Log.e(TAG, e.toString());
@ -264,24 +216,20 @@ public class BackupUtils {
}
/**
* 将所有笔记导出为用户可读的文本格式
* @return 导出状态码
* Note will be exported as text which is user readable
*/
public int exportToText() {
// 检查外部存储是否可用
if (!externalStorageAvailable()) {
Log.d(TAG, "Media was not mounted");
return STATE_SD_CARD_UNMOUONTED;
}
// 获取输出流
PrintStream ps = getExportToTextPrintStream();
if (ps == null) {
Log.e(TAG, "get print stream error");
return STATE_SYSTEM_ERROR;
}
// 首先导出文件夹及其包含的笔记
// First export folder and its notes
Cursor folderCursor = mContext.getContentResolver().query(
Notes.CONTENT_NOTE_URI,
NOTE_PROJECTION,
@ -292,9 +240,8 @@ public class BackupUtils {
if (folderCursor != null) {
if (folderCursor.moveToFirst()) {
do {
// 打印文件夹名称
// Print folder's name
String folderName = "";
// 特殊处理通话记录文件夹
if(folderCursor.getLong(NOTE_COLUMN_ID) == Notes.ID_CALL_RECORD_FOLDER) {
folderName = mContext.getString(R.string.call_record_folder_name);
} else {
@ -303,8 +250,6 @@ public class BackupUtils {
if (!TextUtils.isEmpty(folderName)) {
ps.println(String.format(getFormat(FORMAT_FOLDER_NAME), folderName));
}
// 导出该文件夹下的所有笔记
String folderId = folderCursor.getString(NOTE_COLUMN_ID);
exportFolderToText(folderId, ps);
} while (folderCursor.moveToNext());
@ -312,7 +257,7 @@ public class BackupUtils {
folderCursor.close();
}
// 导出根目录下的笔记
// Export notes in root's folder
Cursor noteCursor = mContext.getContentResolver().query(
Notes.CONTENT_NOTE_URI,
NOTE_PROJECTION,
@ -322,42 +267,33 @@ public class BackupUtils {
if (noteCursor != null) {
if (noteCursor.moveToFirst()) {
do {
// 打印笔记修改日期
ps.println(String.format(getFormat(FORMAT_NOTE_DATE), DateFormat.format(
mContext.getString(R.string.format_datetime_mdhm),
noteCursor.getLong(NOTE_COLUMN_MODIFIED_DATE))));
// 导出笔记内容
// Query data belong to this note
String noteId = noteCursor.getString(NOTE_COLUMN_ID);
exportNoteToText(noteId, ps);
} while (noteCursor.moveToNext());
}
noteCursor.close();
}
// 关闭输出流
ps.close();
return STATE_SUCCESS;
}
/**
* 获取指向导出文本文件的输出流
* @return 输出流对象，失败则返回null
* Get a print stream pointed to the file {@generateExportedTextFile}
*/
private PrintStream getExportToTextPrintStream() {
// 生成导出文件
File file = generateFileMountedOnSDcard(mContext, R.string.file_path,
R.string.file_name_txt_format);
if (file == null) {
Log.e(TAG, "create file to exported failed");
return null;
}
// 保存文件名和目录信息
mFileName = file.getName();
mFileDirectory = mContext.getString(R.string.file_path);
// 创建输出流
PrintStream ps = null;
try {
FileOutputStream fos = new FileOutputStream(file);
@ -374,27 +310,19 @@ public class BackupUtils {
}
/**
* 在SD卡上生成用于存储导出数据的文本文件
* @param context 上下文对象
* @param filePathResId 文件路径资源ID
* @param fileNameFormatResId 文件名格式资源ID
* @return 创建的文件对象，失败则返回null
* Generate the text file to store imported data
*/
private static File generateFileMountedOnSDcard(Context context, int filePathResId, int fileNameFormatResId) {
StringBuilder sb = new StringBuilder();
// 构建文件路径：SD卡根目录 + 自定义路径
sb.append(Environment.getExternalStorageDirectory());
sb.append(context.getString(filePathResId));
File filedir = new File(sb.toString());
// 构建完整文件名：路径 + 格式化文件名（包含当前日期）
sb.append(context.getString(
fileNameFormatResId,
DateFormat.format(context.getString(R.string.format_date_ymd),
System.currentTimeMillis())));
File file = new File(sb.toString());
// 创建目录和文件
try {
if (!filedir.exists()) {
filedir.mkdir();

98
src/Notes-master/src/net/micode/notes/tool/DataUtils.java
Unescape View File

@ -34,28 +34,9 @@ import net.micode.notes.ui.NotesListAdapter.AppWidgetAttribute;
import java.util.ArrayList;
import java.util.HashSet;
/**
* 数据工具类。
* <p>职责：封装常用的数据库批量操作（删除、移动、查询校验等），统一错误处理与日志。</p>
* <p>使用场景：列表/编辑/同步等需要对 note 表或 data 表做批量操作时复用。</p>
*/
/**
* 数据工具 - 提供笔记数据的各种操作工具方法
* 包含批量删除、移动笔记、文件夹管理、小部件处理等功能
*/
public class DataUtils {
/**
* 日志标签
*/
public static final String TAG = "DataUtils";
/**
* 批量删除笔记。
*
* @param resolver ContentResolver对象
* @param ids 要删除的笔记ID集合
* @return 删除成功返回true，否则返回false
*/
public static boolean batchDeleteNotes(ContentResolver resolver, HashSet<Long> ids) {
if (ids == null) {
Log.d(TAG, "the ids is null");
@ -91,13 +72,6 @@ public class DataUtils {
return false;
}
/**
* 将单个笔记从源文件夹移动到目标文件夹
* @param resolver 内容解析器
* @param id 笔记ID
* @param srcFolderId 源文件夹ID
* @param desFolderId 目标文件夹ID
*/
public static void moveNoteToFoler(ContentResolver resolver, long id, long srcFolderId, long desFolderId) {
ContentValues values = new ContentValues();
values.put(NoteColumns.PARENT_ID, desFolderId);
@ -106,13 +80,6 @@ public class DataUtils {
resolver.update(ContentUris.withAppendedId(Notes.CONTENT_NOTE_URI, id), values, null, null);
}
/**
* 批量将笔记移动到指定文件夹
* @param resolver 内容解析器
* @param ids 要移动的笔记ID集合
* @param folderId 目标文件夹ID
* @return 是否移动成功
*/
public static boolean batchMoveToFolder(ContentResolver resolver, HashSet<Long> ids,
long folderId) {
if (ids == null) {
@ -145,9 +112,7 @@ public class DataUtils {
}
/**
* 获取用户创建的文件夹数量（不包括系统文件夹）
* @param resolver 内容解析器
* @return 用户文件夹数量
* Get the all folder count except system folders {@link Notes#TYPE_SYSTEM}}
*/
public static int getUserFolderCount(ContentResolver resolver) {
Cursor cursor =resolver.query(Notes.CONTENT_NOTE_URI,
@ -171,13 +136,6 @@ public class DataUtils {
return count;
}
/**
* 检查指定ID和类型的笔记是否在数据库中可见（不在垃圾桶中）
* @param resolver 内容解析器
* @param noteId 笔记ID
* @param type 笔记类型
* @return 是否可见
*/
public static boolean visibleInNoteDatabase(ContentResolver resolver, long noteId, int type) {
Cursor cursor = resolver.query(ContentUris.withAppendedId(Notes.CONTENT_NOTE_URI, noteId),
null,
@ -195,12 +153,6 @@ public class DataUtils {
return exist;
}
/**
* 检查指定ID的笔记是否存在于数据库中
* @param resolver 内容解析器
* @param noteId 笔记ID
* @return 是否存在
*/
public static boolean existInNoteDatabase(ContentResolver resolver, long noteId) {
Cursor cursor = resolver.query(ContentUris.withAppendedId(Notes.CONTENT_NOTE_URI, noteId),
null, null, null, null);
@ -215,12 +167,6 @@ public class DataUtils {
return exist;
}
/**
* 检查指定ID的笔记数据是否存在于数据库中
* @param resolver 内容解析器
* @param dataId 数据ID
* @return 是否存在
*/
public static boolean existInDataDatabase(ContentResolver resolver, long dataId) {
Cursor cursor = resolver.query(ContentUris.withAppendedId(Notes.CONTENT_DATA_URI, dataId),
null, null, null, null);
@ -235,12 +181,6 @@ public class DataUtils {
return exist;
}
/**
* 检查指定名称的可见文件夹是否存在（不在垃圾桶中）
* @param resolver 内容解析器
* @param name 文件夹名称
* @return 是否存在
*/
public static boolean checkVisibleFolderName(ContentResolver resolver, String name) {
Cursor cursor = resolver.query(Notes.CONTENT_NOTE_URI, null,
NoteColumns.TYPE + "=" + Notes.TYPE_FOLDER +
@ -257,12 +197,6 @@ public class DataUtils {
return exist;
}
/**
* 获取与指定文件夹关联的所有应用小部件
* @param resolver 内容解析器
* @param folderId 文件夹ID
* @return 应用小部件属性集合
*/
public static HashSet<AppWidgetAttribute> getFolderNoteWidget(ContentResolver resolver, long folderId) {
Cursor c = resolver.query(Notes.CONTENT_NOTE_URI,
new String[] { NoteColumns.WIDGET_ID, NoteColumns.WIDGET_TYPE },
@ -290,13 +224,6 @@ public class DataUtils {
return set;
}
/**
* 通过笔记ID获取电话号码
* 用于通话记录笔记的电话号码获取
* @param resolver 内容解析器
* @param noteId 笔记ID
* @return 电话号码
*/
public static String getCallNumberByNoteId(ContentResolver resolver, long noteId) {
Cursor cursor = resolver.query(Notes.CONTENT_DATA_URI,
new String [] { CallNote.PHONE_NUMBER },
@ -316,14 +243,6 @@ public class DataUtils {
return "";
}
/**
* 通过电话号码和通话日期获取笔记ID
* 用于通话记录笔记的查询
* @param resolver 内容解析器
* @param phoneNumber 电话号码
* @param callDate 通话日期时间戳
* @return 笔记ID
*/
public static long getNoteIdByPhoneNumberAndCallDate(ContentResolver resolver, String phoneNumber, long callDate) {
Cursor cursor = resolver.query(Notes.CONTENT_DATA_URI,
new String [] { CallNote.NOTE_ID },
@ -345,13 +264,6 @@ public class DataUtils {
return 0;
}
/**
* 通过笔记ID获取笔记摘要
* @param resolver 内容解析器
* @param noteId 笔记ID
* @return 笔记摘要
* @throws IllegalArgumentException 如果笔记不存在
*/
public static String getSnippetById(ContentResolver resolver, long noteId) {
Cursor cursor = resolver.query(Notes.CONTENT_NOTE_URI,
new String [] { NoteColumns.SNIPPET },
@ -370,12 +282,6 @@ public class DataUtils {
throw new IllegalArgumentException("Note is not found with id: " + noteId);
}
/**
* 格式化笔记摘要
* 去除首尾空格并只保留第一行内容
* @param snippet 原始笔记摘要
* @return 格式化后的笔记摘要
*/
public static String getFormattedSnippet(String snippet) {
if (snippet != null) {
snippet = snippet.trim();

187
src/Notes-master/src/net/micode/notes/tool/GTaskStringUtils.java
Unescape View File

@ -16,285 +16,98 @@
package net.micode.notes.tool;
/**
* Google Tasks字符串工具 - 定义Google Tasks同步相关的所有字符串常量
* 包含JSON字段名、操作类型、文件夹名称等用于Google Tasks API交互和本地数据处理的常量
*/
public class GTaskStringUtils {
/**
* JSON字段：操作ID
*/
public final static String GTASK_JSON_ACTION_ID = "action_id";
/**
* JSON字段：操作列表
*/
public final static String GTASK_JSON_ACTION_LIST = "action_list";
/**
* JSON字段：操作类型
*/
public final static String GTASK_JSON_ACTION_TYPE = "action_type";
/**
* JSON字段：操作类型 - 创建
*/
public final static String GTASK_JSON_ACTION_TYPE_CREATE = "create";
/**
* JSON字段：操作类型 - 获取所有
*/
public final static String GTASK_JSON_ACTION_TYPE_GETALL = "get_all";
/**
* JSON字段：操作类型 - 移动
*/
public final static String GTASK_JSON_ACTION_TYPE_MOVE = "move";
/**
* JSON字段：操作类型 - 更新
*/
public final static String GTASK_JSON_ACTION_TYPE_UPDATE = "update";
/**
* JSON字段：创建者ID
*/
public final static String GTASK_JSON_CREATOR_ID = "creator_id";
/**
* JSON字段：子实体
*/
public final static String GTASK_JSON_CHILD_ENTITY = "child_entity";
/**
* JSON字段：客户端版本
*/
public final static String GTASK_JSON_CLIENT_VERSION = "client_version";
/**
* JSON字段：已完成
*/
public final static String GTASK_JSON_COMPLETED = "completed";
/**
* JSON字段：当前列表ID
*/
public final static String GTASK_JSON_CURRENT_LIST_ID = "current_list_id";
/**
* JSON字段：默认列表ID
*/
public final static String GTASK_JSON_DEFAULT_LIST_ID = "default_list_id";
/**
* JSON字段：已删除
*/
public final static String GTASK_JSON_DELETED = "deleted";
/**
* JSON字段：目标列表
*/
public final static String GTASK_JSON_DEST_LIST = "dest_list";
/**
* JSON字段：目标父节点
*/
public final static String GTASK_JSON_DEST_PARENT = "dest_parent";
/**
* JSON字段：目标父节点类型
*/
public final static String GTASK_JSON_DEST_PARENT_TYPE = "dest_parent_type";
/**
* JSON字段：实体增量
*/
public final static String GTASK_JSON_ENTITY_DELTA = "entity_delta";
/**
* JSON字段：实体类型
*/
public final static String GTASK_JSON_ENTITY_TYPE = "entity_type";
/**
* JSON字段：获取已删除
*/
public final static String GTASK_JSON_GET_DELETED = "get_deleted";
/**
* JSON字段：ID
*/
public final static String GTASK_JSON_ID = "id";
/**
* JSON字段：索引
*/
public final static String GTASK_JSON_INDEX = "index";
/**
* JSON字段：最后修改时间
*/
public final static String GTASK_JSON_LAST_MODIFIED = "last_modified";
/**
* JSON字段：最新同步点
*/
public final static String GTASK_JSON_LATEST_SYNC_POINT = "latest_sync_point";
/**
* JSON字段：列表ID
*/
public final static String GTASK_JSON_LIST_ID = "list_id";
/**
* JSON字段：列表集合
*/
public final static String GTASK_JSON_LISTS = "lists";
/**
* JSON字段：名称
*/
public final static String GTASK_JSON_NAME = "name";
/**
* JSON字段：新ID
*/
public final static String GTASK_JSON_NEW_ID = "new_id";
/**
* JSON字段：备注
*/
public final static String GTASK_JSON_NOTES = "notes";
/**
* JSON字段：父节点ID
*/
public final static String GTASK_JSON_PARENT_ID = "parent_id";
/**
* JSON字段：前一个兄弟节点ID
*/
public final static String GTASK_JSON_PRIOR_SIBLING_ID = "prior_sibling_id";
/**
* JSON字段：结果
*/
public final static String GTASK_JSON_RESULTS = "results";
/**
* JSON字段：源列表
*/
public final static String GTASK_JSON_SOURCE_LIST = "source_list";
/**
* JSON字段：任务集合
*/
public final static String GTASK_JSON_TASKS = "tasks";
/**
* JSON字段：类型
*/
public final static String GTASK_JSON_TYPE = "type";
/**
* JSON字段：类型 - 组
*/
public final static String GTASK_JSON_TYPE_GROUP = "GROUP";
/**
* JSON字段：类型 - 任务
*/
public final static String GTASK_JSON_TYPE_TASK = "TASK";
/**
* JSON字段：用户
*/
public final static String GTASK_JSON_USER = "user";
/**
* MIUI文件夹前缀
*/
public final static String MIUI_FOLDER_PREFFIX = "[MIUI_Notes]";
/**
* 默认文件夹名称
*/
public final static String FOLDER_DEFAULT = "Default";
/**
* 通话记录文件夹名称
*/
public final static String FOLDER_CALL_NOTE = "Call_Note";
/**
* 元数据文件夹名称
*/
public final static String FOLDER_META = "METADATA";
/**
* 元数据头：Google Tasks ID
*/
public final static String META_HEAD_GTASK_ID = "meta_gid";
/**
* 元数据头：笔记
*/
public final static String META_HEAD_NOTE = "meta_note";
/**
* 元数据头：数据
*/
public final static String META_HEAD_DATA = "meta_data";
/**
* 元数据笔记名称
*/
public final static String META_NOTE_NAME = "[META INFO] DON'T UPDATE AND DELETE";
}

168
src/Notes-master/src/net/micode/notes/tool/ResourceParser.java
Unescape View File

@ -22,76 +22,24 @@ import android.preference.PreferenceManager;
import net.micode.notes.R;
import net.micode.notes.ui.NotesPreferenceActivity;
/**
* 资源解析工具 - 管理笔记应用的UI资源
* 包括背景资源、字体大小、小部件资源等
*/
public class ResourceParser {
/**
* 笔记背景颜色常量 - 黄色
*/
public static final int YELLOW = 0;
/**
* 笔记背景颜色常量 - 蓝色
*/
public static final int BLUE = 1;
/**
* 笔记背景颜色常量 - 白色
*/
public static final int WHITE = 2;
/**
* 笔记背景颜色常量 - 绿色
*/
public static final int GREEN = 3;
/**
* 笔记背景颜色常量 - 红色
*/
public static final int RED = 4;
/**
* 默认笔记背景颜色
*/
public static final int BG_DEFAULT_COLOR = YELLOW;
/**
* 字体大小常量 - 小
*/
public static final int TEXT_SMALL = 0;
/**
* 字体大小常量 - 中
*/
public static final int TEXT_MEDIUM = 1;
/**
* 字体大小常量 - 大
*/
public static final int TEXT_LARGE = 2;
/**
* 字体大小常量 - 超大
*/
public static final int TEXT_SUPER = 3;
/**
* 默认字体大小
*/
public static final int BG_DEFAULT_FONT_SIZE = TEXT_MEDIUM;
/**
* 笔记编辑背景资源类
* 管理笔记编辑界面的背景资源
*/
public static class NoteBgResources {
/**
* 笔记编辑主背景资源数组
* 索引对应背景颜色常量
*/
private final static int [] BG_EDIT_RESOURCES = new int [] {
R.drawable.edit_yellow,
R.drawable.edit_blue,
@ -100,10 +48,6 @@ public class ResourceParser {
R.drawable.edit_red
};
/**
* 笔记编辑标题栏背景资源数组
* 索引对应背景颜色常量
*/
private final static int [] BG_EDIT_TITLE_RESOURCES = new int [] {
R.drawable.edit_title_yellow,
R.drawable.edit_title_blue,
@ -112,31 +56,15 @@ public class ResourceParser {
R.drawable.edit_title_red
};
/**
* 获取笔记编辑主背景资源
* @param id 背景颜色ID
* @return 背景资源ID
*/
public static int getNoteBgResource(int id) {
return BG_EDIT_RESOURCES[id];
}
/**
* 获取笔记编辑标题栏背景资源
* @param id 背景颜色ID
* @return 标题栏背景资源ID
*/
public static int getNoteTitleBgResource(int id) {
return BG_EDIT_TITLE_RESOURCES[id];
}
}
/**
* 获取默认背景颜色ID
* 根据用户偏好设置决定是使用随机颜色还是默认颜色
* @param context 上下文
* @return 背景颜色ID
*/
public static int getDefaultBgId(Context context) {
if (PreferenceManager.getDefaultSharedPreferences(context).getBoolean(
NotesPreferenceActivity.PREFERENCE_SET_BG_COLOR_KEY, false)) {
@ -146,15 +74,7 @@ public class ResourceParser {
}
}
/**
* 笔记列表项背景资源类
* 管理笔记列表中不同位置项的背景资源
*/
public static class NoteItemBgResources {
/**
* 列表首项背景资源数组
* 索引对应背景颜色常量
*/
private final static int [] BG_FIRST_RESOURCES = new int [] {
R.drawable.list_yellow_up,
R.drawable.list_blue_up,
@ -163,10 +83,6 @@ public class ResourceParser {
R.drawable.list_red_up
};
/**
* 列表中间项背景资源数组
* 索引对应背景颜色常量
*/
private final static int [] BG_NORMAL_RESOURCES = new int [] {
R.drawable.list_yellow_middle,
R.drawable.list_blue_middle,
@ -175,10 +91,6 @@ public class ResourceParser {
R.drawable.list_red_middle
};
/**
* 列表末项背景资源数组
* 索引对应背景颜色常量
*/
private final static int [] BG_LAST_RESOURCES = new int [] {
R.drawable.list_yellow_down,
R.drawable.list_blue_down,
@ -187,10 +99,6 @@ public class ResourceParser {
R.drawable.list_red_down,
};
/**
* 列表单项背景资源数组
* 索引对应背景颜色常量
*/
private final static int [] BG_SINGLE_RESOURCES = new int [] {
R.drawable.list_yellow_single,
R.drawable.list_blue_single,
@ -199,60 +107,28 @@ public class ResourceParser {
R.drawable.list_red_single
};
/**
* 获取列表首项背景资源
* @param id 背景颜色ID
* @return 首项背景资源ID
*/
public static int getNoteBgFirstRes(int id) {
return BG_FIRST_RESOURCES[id];
}
/**
* 获取列表末项背景资源
* @param id 背景颜色ID
* @return 末项背景资源ID
*/
public static int getNoteBgLastRes(int id) {
return BG_LAST_RESOURCES[id];
}
/**
* 获取列表单项背景资源
* @param id 背景颜色ID
* @return 单项背景资源ID
*/
public static int getNoteBgSingleRes(int id) {
return BG_SINGLE_RESOURCES[id];
}
/**
* 获取列表中间项背景资源
* @param id 背景颜色ID
* @return 中间项背景资源ID
*/
public static int getNoteBgNormalRes(int id) {
return BG_NORMAL_RESOURCES[id];
}
/**
* 获取文件夹项背景资源
* @return 文件夹背景资源ID
*/
public static int getFolderBgRes() {
return R.drawable.list_folder;
}
}
/**
* 小部件背景资源类
* 管理不同尺寸小部件的背景资源
*/
public static class WidgetBgResources {
/**
* 2x尺寸小部件背景资源数组
* 索引对应背景颜色常量
*/
private final static int [] BG_2X_RESOURCES = new int [] {
R.drawable.widget_2x_yellow,
R.drawable.widget_2x_blue,
@ -261,19 +137,10 @@ public class ResourceParser {
R.drawable.widget_2x_red,
};
/**
* 获取2x尺寸小部件背景资源
* @param id 背景颜色ID
* @return 2x小部件背景资源ID
*/
public static int getWidget2xBgResource(int id) {
return BG_2X_RESOURCES[id];
}
/**
* 4x尺寸小部件背景资源数组
* 索引对应背景颜色常量
*/
private final static int [] BG_4X_RESOURCES = new int [] {
R.drawable.widget_4x_yellow,
R.drawable.widget_4x_blue,
@ -282,48 +149,31 @@ public class ResourceParser {
R.drawable.widget_4x_red
};
/**
* 获取4x尺寸小部件背景资源
* @param id 背景颜色ID
* @return 4x小部件背景资源ID
*/
public static int getWidget4xBgResource(int id) {
return BG_4X_RESOURCES[id];
}
}
/**
* 文本外观资源类
* 管理不同字体大小的文本样式资源
*/
public static class TextAppearanceResources {
/**
* 文本外观资源数组
* 索引对应字体大小常量
*/
private final static int [] TEXTAPPEARANCE_RESOURCES = new int [] {
R.style.TextAppearanceNormal, // TEXT_SMALL
R.style.TextAppearanceMedium, // TEXT_MEDIUM
R.style.TextAppearanceLarge, // TEXT_LARGE
R.style.TextAppearanceSuper // TEXT_SUPER
R.style.TextAppearanceNormal,
R.style.TextAppearanceMedium,
R.style.TextAppearanceLarge,
R.style.TextAppearanceSuper
};
/**
* 获取文本外观资源
* @param id 字体大小ID
* @return 文本外观资源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];
}
/**
* 获取文本外观资源数量
* @return 文本外观资源数量
*/
public static int getResourcesSize() {
return TEXTAPPEARANCE_RESOURCES.length;
}

87
src/Notes-master/src/net/micode/notes/ui/AlarmAlertActivity.java
Unescape View File

@ -39,51 +39,22 @@ import net.micode.notes.tool.DataUtils;
import java.io.IOException;
/**
* 闹钟提醒活动
* 当笔记提醒时间到达时显示提醒界面
*/
/**
* 闹钟提醒活动
* 用于显示笔记提醒对话框并播放闹钟声音
*/
public class AlarmAlertActivity extends Activity implements OnClickListener, OnDismissListener {
/**
* 笔记ID
*/
private long mNoteId;
/**
* 笔记摘要内容
*/
private String mSnippet;
/**
* 摘要预览最大长度
*/
private static final int SNIPPET_PREW_MAX_LEN = 60;
/**
* 媒体播放器，用于播放闹钟声音
*/
MediaPlayer mPlayer;
/**
* 创建活动时调用的方法
* 设置窗口特性、处理意图数据、初始化播放器并显示提醒对话框
* @param savedInstanceState 保存的实例状态
*/
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
requestWindowFeature(Window.FEATURE_NO_TITLE);
final Window win = getWindow();
// 允许在锁屏时显示
win.addFlags(WindowManager.LayoutParams.FLAG_SHOW_WHEN_LOCKED);
if (!isScreenOn()) {
// 如果屏幕关闭，添加标志唤醒屏幕并保持点亮
win.addFlags(WindowManager.LayoutParams.FLAG_KEEP_SCREEN_ON
| WindowManager.LayoutParams.FLAG_TURN_SCREEN_ON
| WindowManager.LayoutParams.FLAG_ALLOW_LOCK_WHILE_SCREEN_ON
@ -93,11 +64,8 @@ public class AlarmAlertActivity extends Activity implements OnClickListener, OnD
Intent intent = getIntent();
try {
// 从Intent中获取笔记ID
mNoteId = Long.valueOf(intent.getData().getPathSegments().get(1));
// 获取笔记摘要
mSnippet = DataUtils.getSnippetById(this.getContentResolver(), mNoteId);
// 限制摘要长度
mSnippet = mSnippet.length() > SNIPPET_PREW_MAX_LEN ? mSnippet.substring(0,
SNIPPET_PREW_MAX_LEN) + getResources().getString(R.string.notelist_string_info)
: mSnippet;
@ -106,9 +74,7 @@ public class AlarmAlertActivity extends Activity implements OnClickListener, OnD
return;
}
// 初始化媒体播放器
mPlayer = new MediaPlayer();
// 检查笔记是否可见，如果可见则显示对话框并播放声音
if (DataUtils.visibleInNoteDatabase(getContentResolver(), mNoteId, Notes.TYPE_NOTE)) {
showActionDialog();
playAlarmSound();
@ -117,28 +83,17 @@ public class AlarmAlertActivity extends Activity implements OnClickListener, OnD
}
}
/**
* 检查屏幕是否开启
* @return 屏幕是否开启
*/
private boolean isScreenOn() {
PowerManager pm = (PowerManager) getSystemService(Context.POWER_SERVICE);
return pm.isScreenOn();
}
/**
* 播放闹钟声音
* 获取系统默认闹钟铃声并设置循环播放
*/
private void playAlarmSound() {
// 获取系统默认闹钟铃声URI
Uri url = RingtoneManager.getActualDefaultRingtoneUri(this, RingtoneManager.TYPE_ALARM);
// 获取静音模式下受影响的音频流
int silentModeStreams = Settings.System.getInt(getContentResolver(),
Settings.System.MODE_RINGER_STREAMS_AFFECTED, 0);
// 设置音频流类型
if ((silentModeStreams & (1 << AudioManager.STREAM_ALARM)) != 0) {
mPlayer.setAudioStreamType(silentModeStreams);
} else {
@ -147,75 +102,57 @@ public class AlarmAlertActivity extends Activity implements OnClickListener, OnD
try {
mPlayer.setDataSource(this, url);
mPlayer.prepare();
mPlayer.setLooping(true); // 设置循环播放
mPlayer.setLooping(true);
mPlayer.start();
} catch (IllegalArgumentException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (SecurityException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (IllegalStateException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
/**
* 显示提醒对话框
* 对话框显示笔记摘要，并根据屏幕状态提供不同的按钮选项
*/
private void showActionDialog() {
AlertDialog.Builder dialog = new AlertDialog.Builder(this);
dialog.setTitle(R.string.app_name);
dialog.setMessage(mSnippet); // 显示笔记摘要
dialog.setPositiveButton(R.string.notealert_ok, this); // 确定按钮
dialog.setMessage(mSnippet);
dialog.setPositiveButton(R.string.notealert_ok, this);
if (isScreenOn()) {
// 如果屏幕已开启，显示"进入"按钮
dialog.setNegativeButton(R.string.notealert_enter, this);
}
// 显示对话框并设置消失监听器
dialog.show().setOnDismissListener(this);
}
/**
* 处理对话框按钮点击事件
* @param dialog 对话框实例
* @param which 被点击的按钮ID
*/
public void onClick(DialogInterface dialog, int which) {
switch (which) {
case DialogInterface.BUTTON_NEGATIVE:
// 点击"进入"按钮，打开笔记编辑界面查看完整笔记
Intent intent = new Intent(this, NoteEditActivity.class);
intent.setAction(Intent.ACTION_VIEW);
intent.putExtra(Intent.EXTRA_UID, mNoteId);
startActivity(intent);
break;
default:
// 点击"确定"按钮，不执行额外操作
break;
}
}
/**
* 处理对话框消失事件
* 停止闹钟声音并结束活动
* @param dialog 对话框实例
*/
public void onDismiss(DialogInterface dialog) {
stopAlarmSound(); // 停止闹钟声音
finish(); // 结束活动
stopAlarmSound();
finish();
}
/**
* 停止闹钟声音
* 释放媒体播放器资源
*/
private void stopAlarmSound() {
if (mPlayer != null) {
mPlayer.stop();
mPlayer.release(); // 释放资源
mPlayer = null; // 清空引用
mPlayer.release();
mPlayer = null;
}
}
}

41
src/Notes-master/src/net/micode/notes/ui/AlarmInitReceiver.java
Unescape View File

@ -27,42 +27,20 @@ import android.database.Cursor;
import net.micode.notes.data.Notes;
import net.micode.notes.data.Notes.NoteColumns;
/**
* 闹钟初始化接收器
* 在系统启动时重新设置所有笔记的提醒
*/
/**
* 闹钟初始化广播接收器
* 用于系统启动或其他触发事件时重新设置所有笔记的闹钟提醒
*/
public class AlarmInitReceiver extends BroadcastReceiver {
/**
* 数据库查询投影
* 只查询需要的列：笔记ID和提醒日期
*/
private static final String [] PROJECTION = new String [] {
NoteColumns.ID, // 笔记ID
NoteColumns.ALERTED_DATE // 提醒日期
NoteColumns.ID,
NoteColumns.ALERTED_DATE
};
/**
* 查询结果列索引常量
*/
private static final int COLUMN_ID = 0; // 笔记ID列索引
private static final int COLUMN_ALERTED_DATE = 1; // 提醒日期列索引
private static final int COLUMN_ID = 0;
private static final int COLUMN_ALERTED_DATE = 1;
/**
* 接收广播时调用的方法
* 重新设置所有未来时间的笔记提醒闹钟
* @param context 上下文
* @param intent 接收到的意图
*/
@Override
public void onReceive(Context context, Intent intent) {
long currentDate = System.currentTimeMillis();
// 查询数据库中所有设置了未来提醒日期的笔记
Cursor c = context.getContentResolver().query(Notes.CONTENT_NOTE_URI,
PROJECTION,
NoteColumns.ALERTED_DATE + ">? AND " + NoteColumns.TYPE + "=" + Notes.TYPE_NOTE,
@ -72,23 +50,16 @@ public class AlarmInitReceiver extends BroadcastReceiver {
if (c != null) {
if (c.moveToFirst()) {
do {
// 获取提醒日期和笔记ID
long alertDate = c.getLong(COLUMN_ALERTED_DATE);
// 创建闹钟接收器的意图
Intent sender = new Intent(context, AlarmReceiver.class);
sender.setData(ContentUris.withAppendedId(Notes.CONTENT_NOTE_URI, c.getLong(COLUMN_ID)));
// 创建PendingIntent用于触发闹钟
PendingIntent pendingIntent = PendingIntent.getBroadcast(context, 0, sender, 0);
// 获取闹钟管理器并设置闹钟
AlarmManager alermManager = (AlarmManager) context
.getSystemService(Context.ALARM_SERVICE);
alermManager.set(AlarmManager.RTC_WAKEUP, alertDate, pendingIntent);
} while (c.moveToNext());
}
c.close(); // 关闭游标
c.close();
}
}
}

13
src/Notes-master/src/net/micode/notes/ui/AlarmReceiver.java
Unescape View File

@ -20,24 +20,11 @@ import android.content.BroadcastReceiver;
import android.content.Context;
import android.content.Intent;
/**
* 闹钟接收器
* 用于接收闹钟触发事件并启动提醒活动
*/
public class AlarmReceiver extends BroadcastReceiver {
/**
* 接收闹钟触发广播时调用的方法
* 启动闹钟提醒活动显示笔记提醒
* @param context 上下文
* @param intent 接收到的意图，包含笔记ID
*/
@Override
public void onReceive(Context context, Intent intent) {
// 将意图的目标类设置为闹钟提醒活动
intent.setClass(context, AlarmAlertActivity.class);
// 添加新任务标志，允许从非活动上下文启动活动
intent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
// 启动闹钟提醒活动
context.startActivity(intent);
}
}

147
src/Notes-master/src/net/micode/notes/ui/DateTimePicker.java
Unescape View File

@ -28,135 +28,85 @@ import android.view.View;
import android.widget.FrameLayout;
import android.widget.NumberPicker;
/**
* 日期时间选择器组件
* 用于在笔记应用中设置提醒时间，支持24小时制和12小时制切换
* 提供日期、小时、分钟和AM/PM的选择功能
*/
public class DateTimePicker extends FrameLayout {
/** 默认启用状态 */
private static final boolean DEFAULT_ENABLE_STATE = true;
/** 半天的小时数 */
private static final int HOURS_IN_HALF_DAY = 12;
/** 全天的小时数 */
private static final int HOURS_IN_ALL_DAY = 24;
/** 一周的天数 */
private static final int DAYS_IN_ALL_WEEK = 7;
/** 日期选择器的最小值 */
private static final int DATE_SPINNER_MIN_VAL = 0;
/** 日期选择器的最大值 */
private static final int DATE_SPINNER_MAX_VAL = DAYS_IN_ALL_WEEK - 1;
/** 24小时制小时选择器的最小值 */
private static final int HOUR_SPINNER_MIN_VAL_24_HOUR_VIEW = 0;
/** 24小时制小时选择器的最大值 */
private static final int HOUR_SPINNER_MAX_VAL_24_HOUR_VIEW = 23;
/** 12小时制小时选择器的最小值 */
private static final int HOUR_SPINNER_MIN_VAL_12_HOUR_VIEW = 1;
/** 12小时制小时选择器的最大值 */
private static final int HOUR_SPINNER_MAX_VAL_12_HOUR_VIEW = 12;
/** 分钟选择器的最小值 */
private static final int MINUT_SPINNER_MIN_VAL = 0;
/** 分钟选择器的最大值 */
private static final int MINUT_SPINNER_MAX_VAL = 59;
/** AM/PM选择器的最小值 */
private static final int AMPM_SPINNER_MIN_VAL = 0;
/** AM/PM选择器的最大值 */
private static final int AMPM_SPINNER_MAX_VAL = 1;
/** 日期选择器 */
private final NumberPicker mDateSpinner;
/** 小时选择器 */
private final NumberPicker mHourSpinner;
/** 分钟选择器 */
private final NumberPicker mMinuteSpinner;
/** AM/PM选择器 */
private final NumberPicker mAmPmSpinner;
/** 当前选择的日期 */
private Calendar mDate;
/** 日期显示值数组 */
private String[] mDateDisplayValues = new String[DAYS_IN_ALL_WEEK];
/** 是否为上午 */
private boolean mIsAm;
/** 是否为24小时制 */
private boolean mIs24HourView;
/** 是否启用 */
private boolean mIsEnabled = DEFAULT_ENABLE_STATE;
/** 是否正在初始化 */
private boolean mInitialising;
/** 日期时间变化监听器 */
private OnDateTimeChangedListener mOnDateTimeChangedListener;
/** 日期变化监听器 */
private NumberPicker.OnValueChangeListener mOnDateChangedListener = new NumberPicker.OnValueChangeListener() {
@Override
public void onValueChange(NumberPicker picker, int oldVal, int newVal) {
// 根据日期选择器的变化调整当前日期
mDate.add(Calendar.DAY_OF_YEAR, newVal - oldVal);
// 更新日期选择器显示
updateDateControl();
// 通知日期时间变化
onDateTimeChanged();
}
};
/** 小时变化监听器 */
private NumberPicker.OnValueChangeListener mOnHourChangedListener = new NumberPicker.OnValueChangeListener() {
@Override
public void onValueChange(NumberPicker picker, int oldVal, int newVal) {
boolean isDateChanged = false;
Calendar cal = Calendar.getInstance();
if (!mIs24HourView) {
// 处理12小时制下的日期变更逻辑
if (!mIsAm && oldVal == HOURS_IN_HALF_DAY - 1 && newVal == HOURS_IN_HALF_DAY) {
// 从下午11点变为12点，日期加1天
cal.setTimeInMillis(mDate.getTimeInMillis());
cal.add(Calendar.DAY_OF_YEAR, 1);
isDateChanged = true;
} else if (mIsAm && oldVal == HOURS_IN_HALF_DAY && newVal == HOURS_IN_HALF_DAY - 1) {
// 从上午12点变为11点，日期减1天
cal.setTimeInMillis(mDate.getTimeInMillis());
cal.add(Calendar.DAY_OF_YEAR, -1);
isDateChanged = true;
}
// 处理12小时制下的AM/PM切换
if (oldVal == HOURS_IN_HALF_DAY - 1 && newVal == HOURS_IN_HALF_DAY ||
oldVal == HOURS_IN_HALF_DAY && newVal == HOURS_IN_HALF_DAY - 1) {
mIsAm = !mIsAm;
updateAmPmControl();
}
} else {
// 处理24小时制下的日期变更逻辑
if (oldVal == HOURS_IN_ALL_DAY - 1 && newVal == 0) {
// 从23点变为0点，日期加1天
cal.setTimeInMillis(mDate.getTimeInMillis());
cal.add(Calendar.DAY_OF_YEAR, 1);
isDateChanged = true;
} else if (oldVal == 0 && newVal == HOURS_IN_ALL_DAY - 1) {
// 从0点变为23点，日期减1天
cal.setTimeInMillis(mDate.getTimeInMillis());
cal.add(Calendar.DAY_OF_YEAR, -1);
isDateChanged = true;
}
}
// 更新当前小时
int newHour = mHourSpinner.getValue() % HOURS_IN_HALF_DAY + (mIsAm ? 0 : HOURS_IN_HALF_DAY);
mDate.set(Calendar.HOUR_OF_DAY, newHour);
// 通知日期时间变化
onDateTimeChanged();
// 如果日期发生变化，更新年、月、日
if (isDateChanged) {
setCurrentYear(cal.get(Calendar.YEAR));
setCurrentMonth(cal.get(Calendar.MONTH));
@ -165,31 +115,21 @@ public class DateTimePicker extends FrameLayout {
}
};
/** 分钟变化监听器 */
private NumberPicker.OnValueChangeListener mOnMinuteChangedListener = new NumberPicker.OnValueChangeListener() {
@Override
public void onValueChange(NumberPicker picker, int oldVal, int newVal) {
int minValue = mMinuteSpinner.getMinValue();
int maxValue = mMinuteSpinner.getMaxValue();
int offset = 0;
// 处理分钟溢出/下溢的情况
if (oldVal == maxValue && newVal == minValue) {
// 分钟从59变为0，小时加1
offset += 1;
} else if (oldVal == minValue && newVal == maxValue) {
// 分钟从0变为59，小时减1
offset -= 1;
}
if (offset != 0) {
// 更新小时
mDate.add(Calendar.HOUR_OF_DAY, offset);
mHourSpinner.setValue(getCurrentHour());
// 更新日期显示
updateDateControl();
// 更新AM/PM状态
int newHour = getCurrentHourOfDay();
if (newHour >= HOURS_IN_HALF_DAY) {
mIsAm = false;
@ -199,78 +139,38 @@ public class DateTimePicker extends FrameLayout {
updateAmPmControl();
}
}
// 设置当前分钟
mDate.set(Calendar.MINUTE, newVal);
// 通知日期时间变化
onDateTimeChanged();
}
};
/** AM/PM变化监听器 */
private NumberPicker.OnValueChangeListener mOnAmPmChangedListener = new NumberPicker.OnValueChangeListener() {
@Override
public void onValueChange(NumberPicker picker, int oldVal, int newVal) {
// 切换AM/PM状态
mIsAm = !mIsAm;
// 根据AM/PM状态调整小时
if (mIsAm) {
// 从PM切换到AM，小时减12
mDate.add(Calendar.HOUR_OF_DAY, -HOURS_IN_HALF_DAY);
} else {
// 从AM切换到PM，小时加12
mDate.add(Calendar.HOUR_OF_DAY, HOURS_IN_HALF_DAY);
}
// 更新AM/PM选择器显示
updateAmPmControl();
// 通知日期时间变化
onDateTimeChanged();
}
};
/**
* 日期时间变化监听器接口
* 用于监听日期时间选择器的变化事件
*/
public interface OnDateTimeChangedListener {
/**
* 当日期时间发生变化时调用
* @param view 日期时间选择器实例
* @param year 年
* @param month 月
* @param dayOfMonth 日
* @param hourOfDay 时（24小时制）
* @param minute 分
*/
void onDateTimeChanged(DateTimePicker view, int year, int month,
int dayOfMonth, int hourOfDay, int minute);
}
/**
* 创建一个日期时间选择器实例，使用当前时间和系统默认的时间格式
* @param context 上下文
*/
public DateTimePicker(Context context) {
this(context, System.currentTimeMillis());
}
/**
* 创建一个日期时间选择器实例，使用指定时间和系统默认的时间格式
* @param context 上下文
* @param date 指定的时间（毫秒）
*/
public DateTimePicker(Context context, long date) {
this(context, date, DateFormat.is24HourFormat(context));
}
/**
* 创建一个日期时间选择器实例，使用指定时间和时间格式
* @param context 上下文
* @param date 指定的时间（毫秒）
* @param is24HourView 是否使用24小时制
*/
public DateTimePicker(Context context, long date, boolean is24HourView) {
super(context);
mDate = Calendar.getInstance();
@ -278,24 +178,19 @@ public class DateTimePicker extends FrameLayout {
mIsAm = getCurrentHourOfDay() >= HOURS_IN_HALF_DAY;
inflate(context, R.layout.datetime_picker, this);
// 初始化日期选择器
mDateSpinner = (NumberPicker) findViewById(R.id.date);
mDateSpinner.setMinValue(DATE_SPINNER_MIN_VAL);
mDateSpinner.setMaxValue(DATE_SPINNER_MAX_VAL);
mDateSpinner.setOnValueChangedListener(mOnDateChangedListener);
// 初始化小时选择器
mHourSpinner = (NumberPicker) findViewById(R.id.hour);
mHourSpinner.setOnValueChangedListener(mOnHourChangedListener);
// 初始化分钟选择器
mMinuteSpinner = (NumberPicker) findViewById(R.id.minute);
mMinuteSpinner.setMinValue(MINUT_SPINNER_MIN_VAL);
mMinuteSpinner.setMaxValue(MINUT_SPINNER_MAX_VAL);
mMinuteSpinner.setOnLongPressUpdateInterval(100); // 设置长按更新间隔
mMinuteSpinner.setOnLongPressUpdateInterval(100);
mMinuteSpinner.setOnValueChangedListener(mOnMinuteChangedListener);
// 初始化AM/PM选择器
String[] stringsForAmPm = new DateFormatSymbols().getAmPmStrings();
mAmPmSpinner = (NumberPicker) findViewById(R.id.amPm);
mAmPmSpinner.setMinValue(AMPM_SPINNER_MIN_VAL);
@ -303,21 +198,19 @@ public class DateTimePicker extends FrameLayout {
mAmPmSpinner.setDisplayedValues(stringsForAmPm);
mAmPmSpinner.setOnValueChangedListener(mOnAmPmChangedListener);
// 更新控件到初始状态
// update controls to initial state
updateDateControl();
updateHourControl();
updateAmPmControl();
// 设置时间格式（24小时制/12小时制）
set24HourView(is24HourView);
// 设置初始时间
// set to current time
setCurrentDate(date);
// 设置启用状态
setEnabled(isEnabled());
// 初始化完成
// set the content descriptions
mInitialising = false;
}
@ -455,22 +348,14 @@ public class DateTimePicker extends FrameLayout {
return mDate.get(Calendar.HOUR_OF_DAY);
}
/**
* 获取当前小时（根据时间格式返回适当的表示）
* @return 当前小时（24小时制返回0-23，12小时制返回1-12）
*/
private int getCurrentHour() {
if (mIs24HourView){
// 24小时制直接返回小时
return getCurrentHourOfDay();
} else {
// 12小时制需要转换
int hour = getCurrentHourOfDay();
if (hour > HOURS_IN_HALF_DAY) {
// 下午时间，减去12
return hour - HOURS_IN_HALF_DAY;
} else {
// 上午时间，0点转换为12点
return hour == 0 ? HOURS_IN_HALF_DAY : hour;
}
}
@ -549,54 +434,35 @@ public class DateTimePicker extends FrameLayout {
updateAmPmControl();
}
/**
* 更新日期选择器的显示值
* 生成一周内的日期显示字符串
*/
private void updateDateControl() {
Calendar cal = Calendar.getInstance();
cal.setTimeInMillis(mDate.getTimeInMillis());
// 计算起始日期（当前日期减去3天）
cal.add(Calendar.DAY_OF_YEAR, -DAYS_IN_ALL_WEEK / 2 - 1);
mDateSpinner.setDisplayedValues(null);
// 生成一周的日期显示值
for (int i = 0; i < DAYS_IN_ALL_WEEK; ++i) {
cal.add(Calendar.DAY_OF_YEAR, 1);
// 格式化日期为"MM.dd EEEE"（月.日 星期几）
mDateDisplayValues[i] = (String) DateFormat.format("MM.dd EEEE", cal);
}
mDateSpinner.setDisplayedValues(mDateDisplayValues);
mDateSpinner.setValue(DAYS_IN_ALL_WEEK / 2); // 默认选择当前日期
mDateSpinner.setValue(DAYS_IN_ALL_WEEK / 2);
mDateSpinner.invalidate();
}
/**
* 更新AM/PM选择器的显示
*/
private void updateAmPmControl() {
if (mIs24HourView) {
// 24小时制隐藏AM/PM选择器
mAmPmSpinner.setVisibility(View.GONE);
} else {
// 12小时制设置AM/PM值并显示
int index = mIsAm ? Calendar.AM : Calendar.PM;
mAmPmSpinner.setValue(index);
mAmPmSpinner.setVisibility(View.VISIBLE);
}
}
/**
* 更新小时选择器的范围
*/
private void updateHourControl() {
if (mIs24HourView) {
// 24小时制范围：0-23
mHourSpinner.setMinValue(HOUR_SPINNER_MIN_VAL_24_HOUR_VIEW);
mHourSpinner.setMaxValue(HOUR_SPINNER_MAX_VAL_24_HOUR_VIEW);
} else {
// 12小时制范围：1-12
mHourSpinner.setMinValue(HOUR_SPINNER_MIN_VAL_12_HOUR_VIEW);
mHourSpinner.setMaxValue(HOUR_SPINNER_MAX_VAL_12_HOUR_VIEW);
}
@ -610,9 +476,6 @@ public class DateTimePicker extends FrameLayout {
mOnDateTimeChangedListener = callback;
}
/**
* 通知日期时间变化
*/
private void onDateTimeChanged() {
if (mOnDateTimeChangedListener != null) {
mOnDateTimeChangedListener.onDateTimeChanged(this, getCurrentYear(),

55
src/Notes-master/src/net/micode/notes/ui/DateTimePickerDialog.java
Unescape View File

@ -29,114 +29,59 @@ import android.content.DialogInterface.OnClickListener;
import android.text.format.DateFormat;
import android.text.format.DateUtils;
/**
* 日期时间选择对话框
* 封装DateTimePicker组件，提供一个对话框界面让用户选择日期时间
*/
public class DateTimePickerDialog extends AlertDialog implements OnClickListener {
/** 当前选择的日期 */
private Calendar mDate = Calendar.getInstance();
/** 是否为24小时制 */
private boolean mIs24HourView;
/** 日期时间设置监听器 */
private OnDateTimeSetListener mOnDateTimeSetListener;
/** 日期时间选择器组件 */
private DateTimePicker mDateTimePicker;
/**
* 日期时间设置监听器接口
* 用于监听用户选择日期时间后的确认事件
*/
public interface OnDateTimeSetListener {
/**
* 当用户确认选择日期时间时调用
* @param dialog 日期时间选择对话框实例
* @param date 选择的日期时间（毫秒）
*/
void OnDateTimeSet(AlertDialog dialog, long date);
}
/**
* 创建一个日期时间选择对话框实例
* @param context 上下文
* @param date 初始日期时间（毫秒）
*/
public DateTimePickerDialog(Context context, long date) {
super(context);
// 初始化日期时间选择器
mDateTimePicker = new DateTimePicker(context);
setView(mDateTimePicker);
// 设置日期时间变化监听器
mDateTimePicker.setOnDateTimeChangedListener(new OnDateTimeChangedListener() {
public void onDateTimeChanged(DateTimePicker view, int year, int month,
int dayOfMonth, int hourOfDay, int minute) {
// 更新当前日期时间
mDate.set(Calendar.YEAR, year);
mDate.set(Calendar.MONTH, month);
mDate.set(Calendar.DAY_OF_MONTH, dayOfMonth);
mDate.set(Calendar.HOUR_OF_DAY, hourOfDay);
mDate.set(Calendar.MINUTE, minute);
// 更新对话框标题
updateTitle(mDate.getTimeInMillis());
}
});
// 设置初始日期时间（清除秒数）
mDate.setTimeInMillis(date);
mDate.set(Calendar.SECOND, 0);
mDateTimePicker.setCurrentDate(mDate.getTimeInMillis());
// 设置对话框按钮
setButton(context.getString(R.string.datetime_dialog_ok), this);
setButton2(context.getString(R.string.datetime_dialog_cancel), (OnClickListener)null);
// 设置时间格式（24小时制/12小时制）
set24HourView(DateFormat.is24HourFormat(this.getContext()));
// 更新对话框标题
updateTitle(mDate.getTimeInMillis());
}
/**
* 设置是否使用24小时制
* @param is24HourView true表示使用24小时制，false表示使用12小时制
*/
public void set24HourView(boolean is24HourView) {
mIs24HourView = is24HourView;
}
/**
* 设置日期时间设置监听器
* @param callBack 监听器实例
*/
public void setOnDateTimeSetListener(OnDateTimeSetListener callBack) {
mOnDateTimeSetListener = callBack;
}
/**
* 更新对话框标题，显示当前选择的日期时间
* @param date 日期时间（毫秒）
*/
private void updateTitle(long date) {
int flag =
DateUtils.FORMAT_SHOW_YEAR |
DateUtils.FORMAT_SHOW_DATE |
DateUtils.FORMAT_SHOW_TIME;
// 根据时间格式设置标志
flag |= mIs24HourView ? DateUtils.FORMAT_24HOUR : DateUtils.FORMAT_24HOUR;
// 格式化并设置标题
setTitle(DateUtils.formatDateTime(this.getContext(), date, flag));
}
/**
* 点击对话框按钮时调用
* @param arg0 对话框实例
* @param arg1 按钮索引
*/
public void onClick(DialogInterface arg0, int arg1) {
// 当点击确认按钮时，通知监听器日期时间已设置
if (mOnDateTimeSetListener != null) {
mOnDateTimeSetListener.OnDateTimeSet(this, mDate.getTimeInMillis());
}

30
src/Notes-master/src/net/micode/notes/ui/DropdownMenu.java
Unescape View File

@ -27,34 +27,17 @@ import android.widget.PopupMenu.OnMenuItemClickListener;
import net.micode.notes.R;
/**
* 下拉菜单组件
* 封装Android的PopupMenu功能，提供一个带有按钮和下拉菜单的组件
*/
public class DropdownMenu {
/** 下拉菜单的按钮 */
private Button mButton;
/** 弹出菜单实例 */
private PopupMenu mPopupMenu;
/** 菜单实例 */
private Menu mMenu;
/**
* 创建一个下拉菜单实例
* @param context 上下文
* @param button 下拉菜单的按钮
* @param menuId 菜单资源ID
*/
public DropdownMenu(Context context, Button button, int menuId) {
mButton = button;
// 设置按钮背景为下拉图标
mButton.setBackgroundResource(R.drawable.dropdown_icon);
// 创建弹出菜单实例
mPopupMenu = new PopupMenu(context, mButton);
mMenu = mPopupMenu.getMenu();
// 填充菜单内容
mPopupMenu.getMenuInflater().inflate(menuId, mMenu);
// 设置按钮点击事件，显示弹出菜单
mButton.setOnClickListener(new OnClickListener() {
public void onClick(View v) {
mPopupMenu.show();
@ -62,29 +45,16 @@ public class DropdownMenu {
});
}
/**
* 设置菜单点击事件监听器
* @param listener 菜单项点击事件监听器
*/
public void setOnDropdownMenuItemClickListener(OnMenuItemClickListener listener) {
if (mPopupMenu != null) {
mPopupMenu.setOnMenuItemClickListener(listener);
}
}
/**
* 根据ID查找菜单项
* @param id 菜单项ID
* @return 菜单项实例，如果未找到返回null
*/
public MenuItem findItem(int id) {
return mMenu.findItem(id);
}
/**
* 设置下拉菜单按钮的标题
* @param title 标题文本
*/
public void setTitle(CharSequence title) {
mButton.setText(title);
}

56
src/Notes-master/src/net/micode/notes/ui/FoldersListAdapter.java
Unescape View File

@ -28,98 +28,50 @@ import net.micode.notes.R;
import net.micode.notes.data.Notes;
import net.micode.notes.data.Notes.NoteColumns;
/**
* 文件夹列表适配器
* 用于在对话框中显示文件夹列表
*/
/**
* 文件夹列表适配器
* 用于在列表中显示笔记文件夹的CursorAdapter
*/
public class FoldersListAdapter extends CursorAdapter {
/** 查询投影数组 */
public static final String [] PROJECTION = {
NoteColumns.ID, // 文件夹ID
NoteColumns.SNIPPET // 文件夹名称
NoteColumns.ID,
NoteColumns.SNIPPET
};
/** 文件夹ID列索引 */
public static final int ID_COLUMN = 0;
/** 文件夹名称列索引 */
public static final int NAME_COLUMN = 1;
/**
* 创建一个文件夹列表适配器实例
* @param context 上下文
* @param c 包含文件夹数据的Cursor
*/
public FoldersListAdapter(Context context, Cursor c) {
super(context, c);
// TODO Auto-generated constructor stub
}
/**
* 创建一个新的文件夹列表项视图
* @param context 上下文
* @param cursor 包含文件夹数据的Cursor
* @param parent 父视图组
* @return 新创建的文件夹列表项视图
*/
@Override
public View newView(Context context, Cursor cursor, ViewGroup parent) {
return new FolderListItem(context);
}
/**
* 将文件夹数据绑定到列表项视图
* @param view 列表项视图
* @param context 上下文
* @param cursor 包含文件夹数据的Cursor
*/
@Override
public void bindView(View view, Context context, Cursor cursor) {
if (view instanceof FolderListItem) {
// 如果是根文件夹，显示"移动到父文件夹"文本，否则显示文件夹名称
String folderName = (cursor.getLong(ID_COLUMN) == Notes.ID_ROOT_FOLDER) ? context
.getString(R.string.menu_move_parent_folder) : cursor.getString(NAME_COLUMN);
((FolderListItem) view).bind(folderName);
}
}
/**
* 获取指定位置的文件夹名称
* @param context 上下文
* @param position 位置索引
* @return 文件夹名称
*/
public String getFolderName(Context context, int position) {
Cursor cursor = (Cursor) getItem(position);
// 如果是根文件夹，返回"移动到父文件夹"文本，否则返回文件夹名称
return (cursor.getLong(ID_COLUMN) == Notes.ID_ROOT_FOLDER) ? context
.getString(R.string.menu_move_parent_folder) : cursor.getString(NAME_COLUMN);
}
/**
* 文件夹列表项视图
*/
private class FolderListItem extends LinearLayout {
/** 文件夹名称文本视图 */
private TextView mName;
/**
* 创建一个文件夹列表项视图
* @param context 上下文
*/
public FolderListItem(Context context) {
super(context);
// 填充布局
inflate(context, R.layout.folder_list_item, this);
mName = (TextView) findViewById(R.id.tv_folder_name);
}
/**
* 绑定文件夹名称到视图
* @param name 文件夹名称
*/
public void bind(String name) {
mName.setText(name);
}

351
src/Notes-master/src/net/micode/notes/ui/NoteEditActivity.java
Unescape View File

@ -72,28 +72,18 @@ import java.util.regex.Matcher;
import java.util.regex.Pattern;
/**
* 笔记编辑活动
* 负责处理笔记的创建、编辑和预览功能
* 实现了笔记设置变化监听器和文本视图变化监听器接口
*/
public class NoteEditActivity extends Activity implements OnClickListener,
NoteSettingChangedListener, OnTextViewChangeListener {
/**
* 头部视图持有者类
* 用于缓存头部视图的控件引用，提高性能
*/
private class HeadViewHolder {
public TextView tvModified; // 最后修改时间文本视图
public ImageView ivAlertIcon; // 提醒图标
public TextView tvAlertDate; // 提醒日期文本视图
public ImageView ibSetBgColor; // 设置背景颜色按钮
public TextView tvModified;
public ImageView ivAlertIcon;
public TextView tvAlertDate;
public ImageView ibSetBgColor;
}
/**
* 背景选择器按钮映射
* 用于将背景选择按钮ID映射到对应的背景颜色常量
*/
private static final Map<Integer, Integer> sBgSelectorBtnsMap = new HashMap<Integer, Integer>();
static {
sBgSelectorBtnsMap.put(R.id.iv_bg_yellow, ResourceParser.YELLOW);
@ -103,10 +93,6 @@ public class NoteEditActivity extends Activity implements OnClickListener,
sBgSelectorBtnsMap.put(R.id.iv_bg_white, ResourceParser.WHITE);
}
/**
* 背景选择器选中状态映射
* 用于将背景颜色常量映射到对应的选中状态图标ID
*/
private static final Map<Integer, Integer> sBgSelectorSelectionMap = new HashMap<Integer, Integer>();
static {
sBgSelectorSelectionMap.put(ResourceParser.YELLOW, R.id.iv_bg_yellow_select);
@ -116,10 +102,6 @@ public class NoteEditActivity extends Activity implements OnClickListener,
sBgSelectorSelectionMap.put(ResourceParser.WHITE, R.id.iv_bg_white_select);
}
/**
* 字体大小按钮映射
* 用于将字体大小选择按钮ID映射到对应的字体大小常量
*/
private static final Map<Integer, Integer> sFontSizeBtnsMap = new HashMap<Integer, Integer>();
static {
sFontSizeBtnsMap.put(R.id.ll_font_large, ResourceParser.TEXT_LARGE);
@ -128,10 +110,6 @@ public class NoteEditActivity extends Activity implements OnClickListener,
sFontSizeBtnsMap.put(R.id.ll_font_super, ResourceParser.TEXT_SUPER);
}
/**
* 字体选择器选中状态映射
* 用于将字体大小常量映射到对应的选中状态图标ID
*/
private static final Map<Integer, Integer> sFontSelectorSelectionMap = new HashMap<Integer, Integer>();
static {
sFontSelectorSelectionMap.put(ResourceParser.TEXT_LARGE, R.id.iv_large_select);
@ -140,47 +118,52 @@ public class NoteEditActivity extends Activity implements OnClickListener,
sFontSelectorSelectionMap.put(ResourceParser.TEXT_SUPER, R.id.iv_super_select);
}
private static final String TAG = "NoteEditActivity"; // 日志标签
private static final String TAG = "NoteEditActivity";
private HeadViewHolder mNoteHeaderHolder; // 头部视图持有者
private View mHeadViewPanel; // 头部视图面板
private View mNoteBgColorSelector; // 背景颜色选择器
private View mFontSizeSelector; // 字体大小选择器
private EditText mNoteEditor; // 笔记编辑器
private View mNoteEditorPanel; // 笔记编辑器面板
private WorkingNote mWorkingNote; // 工作笔记对象
private SharedPreferences mSharedPrefs; // 共享偏好设置
private int mFontSizeId; // 字体大小ID
private HeadViewHolder mNoteHeaderHolder;
private static final String PREFERENCE_FONT_SIZE = "pref_font_size"; // 字体大小偏好设置键
private static final int SHORTCUT_ICON_TITLE_MAX_LEN = 10; // 快捷图标标题最大长度
private View mHeadViewPanel;
public static final String TAG_CHECKED = String.valueOf('\u221A'); // 已勾选标记
public static final String TAG_UNCHECKED = String.valueOf('\u25A1'); // 未勾选标记
private View mNoteBgColorSelector;
private LinearLayout mEditTextList; // 编辑文本列表（用于清单模式）
private String mUserQuery; // 用户查询字符串
private Pattern mPattern; // 正则表达式模式（用于高亮查询结果）
private View mFontSizeSelector;
private EditText mNoteEditor;
private View mNoteEditorPanel;
private WorkingNote mWorkingNote;
private SharedPreferences mSharedPrefs;
private int mFontSizeId;
private static final String PREFERENCE_FONT_SIZE = "pref_font_size";
private static final int SHORTCUT_ICON_TITLE_MAX_LEN = 10;
public static final String TAG_CHECKED = String.valueOf('\u221A');
public static final String TAG_UNCHECKED = String.valueOf('\u25A1');
private LinearLayout mEditTextList;
private String mUserQuery;
private Pattern mPattern;
/**
* 创建活动时调用
* @param savedInstanceState 保存的实例状态
*/
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
this.setContentView(R.layout.note_edit); // 设置布局
this.setContentView(R.layout.note_edit);
// 如果没有保存的状态且无法初始化活动状态，则结束活动
if (savedInstanceState == null && !initActivityState(getIntent())) {
finish();
return;
}
initResources(); // 初始化资源
initResources();
}
/**
* 当前活动在内存不足时可能被杀死。一旦被杀死，当用户再次加载此活动时，我们应该恢复以前的状态
* Current activity may be killed when the memory is low. Once it is killed, for another time
* user load this activity, we should restore the former state
*/
@Override
protected void onRestoreInstanceState(Bundle savedInstanceState) {
@ -196,12 +179,6 @@ public class NoteEditActivity extends Activity implements OnClickListener,
}
}
/**
* 初始化活动状态
* 根据传入的意图设置工作笔记的状态
* @param intent 传入的意图
* @return 是否初始化成功
*/
private boolean initActivityState(Intent intent) {
/**
* If the user specified the {@link Intent#ACTION_VIEW} but not provided with id,
@ -285,44 +262,27 @@ public class NoteEditActivity extends Activity implements OnClickListener,
return true;
}
/**
* 活动恢复时调用
*/
@Override
protected void onResume() {
super.onResume();
initNoteScreen(); // 初始化笔记屏幕
initNoteScreen();
}
/**
* 初始化笔记屏幕
* 设置笔记编辑器的文本外观、内容和选择模式
*/
private void initNoteScreen() {
// 设置笔记编辑器的文本外观
mNoteEditor.setTextAppearance(this, TextAppearanceResources
.getTexAppearanceResource(mFontSizeId));
// 根据笔记模式设置显示方式
if (mWorkingNote.getCheckListMode() == TextNote.MODE_CHECK_LIST) {
switchToListMode(mWorkingNote.getContent()); // 切换到清单模式
switchToListMode(mWorkingNote.getContent());
} else {
// 设置笔记内容并高亮查询结果
mNoteEditor.setText(getHighlightQueryResult(mWorkingNote.getContent(), mUserQuery));
// 将光标定位到文本末尾
mNoteEditor.setSelection(mNoteEditor.getText().length());
}
// 隐藏所有背景选择的选中状态
for (Integer id : sBgSelectorSelectionMap.keySet()) {
findViewById(sBgSelectorSelectionMap.get(id)).setVisibility(View.GONE);
}
// 设置头部视图和编辑器面板的背景
mHeadViewPanel.setBackgroundResource(mWorkingNote.getTitleBgResId());
mNoteEditorPanel.setBackgroundResource(mWorkingNote.getBgColorResId());
// 设置最后修改时间
mNoteHeaderHolder.tvModified.setText(DateUtils.formatDateTime(this,
mWorkingNote.getModifiedDate(), DateUtils.FORMAT_SHOW_DATE
| DateUtils.FORMAT_NUMERIC_DATE | DateUtils.FORMAT_SHOW_TIME
@ -332,13 +292,9 @@ public class NoteEditActivity extends Activity implements OnClickListener,
* TODO: Add the menu for setting alert. Currently disable it because the DateTimePicker
* is not ready
*/
showAlertHeader(); // 显示提醒头部
showAlertHeader();
}
/**
* 显示提醒头部
* 根据笔记的提醒设置显示或隐藏提醒信息
*/
private void showAlertHeader() {
if (mWorkingNote.hasClockAlert()) {
long time = System.currentTimeMillis();
@ -362,10 +318,6 @@ public class NoteEditActivity extends Activity implements OnClickListener,
initActivityState(intent);
}
/**
* 保存活动状态
* @param outState 保存状态的Bundle
*/
@Override
protected void onSaveInstanceState(Bundle outState) {
super.onSaveInstanceState(outState);
@ -381,12 +333,6 @@ public class NoteEditActivity extends Activity implements OnClickListener,
Log.d(TAG, "Save working note id: " + mWorkingNote.getNoteId() + " onSaveInstanceState");
}
/**
* 分发触摸事件
* 处理背景颜色选择器和字体大小选择器的点击外部关闭逻辑
* @param ev 触摸事件
* @return 是否消费了事件
*/
@Override
public boolean dispatchTouchEvent(MotionEvent ev) {
if (mNoteBgColorSelector.getVisibility() == View.VISIBLE
@ -403,12 +349,6 @@ public class NoteEditActivity extends Activity implements OnClickListener,
return super.dispatchTouchEvent(ev);
}
/**
* 检查触摸事件是否在视图范围内
* @param view 视图对象
* @param ev 触摸事件
* @return 是否在范围内
*/
private boolean inRangeOfView(View view, MotionEvent ev) {
int []location = new int[2];
view.getLocationOnScreen(location);
@ -423,10 +363,6 @@ public class NoteEditActivity extends Activity implements OnClickListener,
return true;
}
/**
* 初始化资源
* 初始化所有UI控件和资源引用
*/
private void initResources() {
mHeadViewPanel = findViewById(R.id.note_title);
mNoteHeaderHolder = new HeadViewHolder();
@ -438,25 +374,18 @@ public class NoteEditActivity extends Activity implements OnClickListener,
mNoteEditor = (EditText) findViewById(R.id.note_edit_view);
mNoteEditorPanel = findViewById(R.id.sv_note_edit);
mNoteBgColorSelector = findViewById(R.id.note_bg_color_selector);
// 为所有背景选择按钮设置点击监听器
for (int id : sBgSelectorBtnsMap.keySet()) {
ImageView iv = (ImageView) findViewById(id);
iv.setOnClickListener(this);
}
mFontSizeSelector = findViewById(R.id.font_size_selector);
// 为所有字体大小选择按钮设置点击监听器
for (int id : sFontSizeBtnsMap.keySet()) {
View view = findViewById(id);
view.setOnClickListener(this);
};
// 初始化共享偏好设置和字体大小
mSharedPrefs = PreferenceManager.getDefaultSharedPreferences(this);
mFontSizeId = mSharedPrefs.getInt(PREFERENCE_FONT_SIZE, ResourceParser.BG_DEFAULT_FONT_SIZE);
/**
* HACKME: Fix bug of store the resource id in shared preference.
* The id may larger than the length of resources, in this case,
@ -465,14 +394,9 @@ public class NoteEditActivity extends Activity implements OnClickListener,
if(mFontSizeId >= TextAppearanceResources.getResourcesSize()) {
mFontSizeId = ResourceParser.BG_DEFAULT_FONT_SIZE;
}
mEditTextList = (LinearLayout) findViewById(R.id.note_edit_list);
}
/**
* 活动暂停时调用
* 保存笔记并清除设置状态
*/
@Override
protected void onPause() {
super.onPause();
@ -482,14 +406,8 @@ public class NoteEditActivity extends Activity implements OnClickListener,
clearSettingState();
}
/**
* 更新小部件
* 更新与当前笔记关联的小部件内容
*/
private void updateWidget() {
Intent intent = new Intent(AppWidgetManager.ACTION_APPWIDGET_UPDATE);
// 根据小部件类型设置对应的小部件提供器
if (mWorkingNote.getWidgetType() == Notes.TYPE_WIDGET_2X) {
intent.setClass(this, NoteWidgetProvider_2x.class);
} else if (mWorkingNote.getWidgetType() == Notes.TYPE_WIDGET_4X) {
@ -503,36 +421,26 @@ public class NoteEditActivity extends Activity implements OnClickListener,
mWorkingNote.getWidgetId()
});
sendBroadcast(intent); // 发送广播更新小部件
sendBroadcast(intent);
setResult(RESULT_OK, intent);
}
/**
* 点击事件处理
* 处理各种UI控件的点击事件
* @param v 被点击的视图
*/
public void onClick(View v) {
int id = v.getId();
if (id == R.id.btn_set_bg_color) {
// 显示背景颜色选择器
mNoteBgColorSelector.setVisibility(View.VISIBLE);
findViewById(sBgSelectorSelectionMap.get(mWorkingNote.getBgColorId())).setVisibility(
View.VISIBLE);
- View.VISIBLE);
} else if (sBgSelectorBtnsMap.containsKey(id)) {
// 处理背景颜色选择
findViewById(sBgSelectorSelectionMap.get(mWorkingNote.getBgColorId())).setVisibility(
View.GONE);
mWorkingNote.setBgColorId(sBgSelectorBtnsMap.get(id));
mNoteBgColorSelector.setVisibility(View.GONE);
} else if (sFontSizeBtnsMap.containsKey(id)) {
// 处理字体大小选择
findViewById(sFontSelectorSelectionMap.get(mFontSizeId)).setVisibility(View.GONE);
mFontSizeId = sFontSizeBtnsMap.get(id);
mSharedPrefs.edit().putInt(PREFERENCE_FONT_SIZE, mFontSizeId).commit();
findViewById(sFontSelectorSelectionMap.get(mFontSizeId)).setVisibility(View.VISIBLE);
// 根据当前模式更新字体大小
if (mWorkingNote.getCheckListMode() == TextNote.MODE_CHECK_LIST) {
getWorkingText();
switchToListMode(mWorkingNote.getContent());
@ -544,9 +452,6 @@ public class NoteEditActivity extends Activity implements OnClickListener,
}
}
/**
* 按下返回键时调用
*/
@Override
public void onBackPressed() {
if(clearSettingState()) {
@ -557,11 +462,6 @@ public class NoteEditActivity extends Activity implements OnClickListener,
super.onBackPressed();
}
/**
* 清除设置状态
* 隐藏所有设置面板
* @return 是否有设置面板被隐藏
*/
private boolean clearSettingState() {
if (mNoteBgColorSelector.getVisibility() == View.VISIBLE) {
mNoteBgColorSelector.setVisibility(View.GONE);
@ -573,10 +473,6 @@ public class NoteEditActivity extends Activity implements OnClickListener,
return false;
}
/**
* 背景颜色改变时调用
* 实现NoteSettingChangedListener接口
*/
public void onBackgroundColorChanged() {
findViewById(sBgSelectorSelectionMap.get(mWorkingNote.getBgColorId())).setVisibility(
View.VISIBLE);
@ -584,11 +480,6 @@ public class NoteEditActivity extends Activity implements OnClickListener,
mHeadViewPanel.setBackgroundResource(mWorkingNote.getTitleBgResId());
}
/**
* 准备菜单时调用
* @param menu 菜单对象
* @return 是否准备成功
*/
@Override
public boolean onPrepareOptionsMenu(Menu menu) {
if (isFinishing()) {
@ -614,20 +505,13 @@ public class NoteEditActivity extends Activity implements OnClickListener,
return true;
}
/**
* 菜单项选择处理
* 处理各种菜单按钮的点击事件
* @param item 选择的菜单项
* @return 是否处理了该事件
*/
@Override
public boolean onOptionsItemSelected(MenuItem item) {
switch (item.getItemId()) {
case R.id.menu_new_note:
createNewNote(); // 创建新笔记
createNewNote();
break;
case R.id.menu_delete:
// 显示删除确认对话框
AlertDialog.Builder builder = new AlertDialog.Builder(this);
builder.setTitle(getString(R.string.alert_title_delete));
builder.setIcon(android.R.drawable.ic_dialog_alert);
@ -635,7 +519,7 @@ public class NoteEditActivity extends Activity implements OnClickListener,
builder.setPositiveButton(android.R.string.ok,
new DialogInterface.OnClickListener() {
public void onClick(DialogInterface dialog, int which) {
deleteCurrentNote(); // 删除当前笔记
deleteCurrentNote();
finish();
}
});
@ -643,27 +527,25 @@ public class NoteEditActivity extends Activity implements OnClickListener,
builder.show();
break;
case R.id.menu_font_size:
// 显示字体大小选择器
mFontSizeSelector.setVisibility(View.VISIBLE);
findViewById(sFontSelectorSelectionMap.get(mFontSizeId)).setVisibility(View.VISIBLE);
break;
case R.id.menu_list_mode:
// 切换笔记模式（普通模式/清单模式）
mWorkingNote.setCheckListMode(mWorkingNote.getCheckListMode() == 0 ?
TextNote.MODE_CHECK_LIST : 0);
break;
case R.id.menu_share:
getWorkingText(); // 获取当前工作文本
sendTo(this, mWorkingNote.getContent()); // 分享笔记内容
getWorkingText();
sendTo(this, mWorkingNote.getContent());
break;
case R.id.menu_send_to_desktop:
sendToDesktop(); // 发送到桌面
sendToDesktop();
break;
case R.id.menu_alert:
setReminder(); // 设置提醒
setReminder();
break;
case R.id.menu_delete_remind:
mWorkingNote.setAlertDate(0, false); // 删除提醒
mWorkingNote.setAlertDate(0, false);
break;
default:
break;
@ -671,10 +553,6 @@ public class NoteEditActivity extends Activity implements OnClickListener,
return true;
}
/**
* 设置提醒
* 显示日期时间选择器，设置笔记的提醒时间
*/
private void setReminder() {
DateTimePickerDialog d = new DateTimePickerDialog(this, System.currentTimeMillis());
d.setOnDateTimeSetListener(new OnDateTimeSetListener() {
@ -686,10 +564,8 @@ public class NoteEditActivity extends Activity implements OnClickListener,
}
/**
* 分享笔记
* 分享笔记内容到支持{@link Intent#ACTION_SEND}动作和{@text/plain}类型的应用
* @param context 上下文对象
* @param info 要分享的内容
* Share note to apps that support {@link Intent#ACTION_SEND} action
* and {@text/plain} type
*/
private void sendTo(Context context, String info) {
Intent intent = new Intent(Intent.ACTION_SEND);
@ -698,15 +574,11 @@ public class NoteEditActivity extends Activity implements OnClickListener,
context.startActivity(intent);
}
/**
* 创建新笔记
* 保存当前笔记并创建一个新的笔记
*/
private void createNewNote() {
// 首先保存当前编辑的笔记
// Firstly, save current editing notes
saveNote();
// 为了安全起见，启动一个新的NoteEditActivity
// For safety, start a new NoteEditActivity
finish();
Intent intent = new Intent(this, NoteEditActivity.class);
intent.setAction(Intent.ACTION_INSERT_OR_EDIT);
@ -714,10 +586,6 @@ public class NoteEditActivity extends Activity implements OnClickListener,
startActivity(intent);
}
/**
* 删除当前笔记
* 根据同步模式决定是直接删除还是移动到回收站
*/
private void deleteCurrentNote() {
if (mWorkingNote.existInDatabase()) {
HashSet<Long> ids = new HashSet<Long>();
@ -728,12 +596,10 @@ public class NoteEditActivity extends Activity implements OnClickListener,
Log.d(TAG, "Wrong note id, should not happen");
}
if (!isSyncMode()) {
// 非同步模式下直接删除
if (!DataUtils.batchDeleteNotes(getContentResolver(), ids)) {
Log.e(TAG, "Delete Note error");
}
} else {
// 同步模式下移动到回收站
if (!DataUtils.batchMoveToFolder(getContentResolver(), ids, Notes.ID_TRASH_FOLER)) {
Log.e(TAG, "Move notes to trash folder error, should not happens");
}
@ -742,20 +608,10 @@ public class NoteEditActivity extends Activity implements OnClickListener,
mWorkingNote.markDeleted(true);
}
/**
* 检查是否为同步模式
* @return 是否为同步模式
*/
private boolean isSyncMode() {
return NotesPreferenceActivity.getSyncAccountName(this).trim().length() > 0;
}
/**
* 提醒时间改变时调用
* 实现NoteSettingChangedListener接口
* @param date 提醒时间
* @param set 是否设置提醒
*/
public void onClockAlertChanged(long date, boolean set) {
/**
* User could set clock to an unsaved note, so before setting the
@ -786,20 +642,10 @@ public class NoteEditActivity extends Activity implements OnClickListener,
}
}
/**
* 小部件改变时调用
* 实现NoteSettingChangedListener接口
*/
public void onWidgetChanged() {
updateWidget();
}
/**
* 编辑文本删除时调用
* 实现OnTextViewChangeListener接口
* @param index 删除的索引
* @param text 删除的文本
*/
public void onEditTextDelete(int index, String text) {
int childCount = mEditTextList.getChildCount();
if (childCount == 1) {
@ -826,12 +672,6 @@ public class NoteEditActivity extends Activity implements OnClickListener,
edit.setSelection(length);
}
/**
* 编辑文本回车时调用
* 实现OnTextViewChangeListener接口
* @param index 当前索引
* @param text 文本内容
*/
public void onEditTextEnter(int index, String text) {
/**
* Should not happen, check for debug
@ -851,43 +691,30 @@ public class NoteEditActivity extends Activity implements OnClickListener,
}
}
/**
* 切换到清单模式
* 将普通文本模式转换为清单模式
* @param text 要转换的文本内容
*/
private void switchToListMode(String text) {
mEditTextList.removeAllViews(); // 清空编辑文本列表
String[] items = text.split("\n"); // 按行分割文本
mEditTextList.removeAllViews();
String[] items = text.split("\n");
int index = 0;
for (String item : items) {
if(!TextUtils.isEmpty(item)) {
mEditTextList.addView(getListItem(item, index)); // 添加列表项
mEditTextList.addView(getListItem(item, index));
index++;
}
}
mEditTextList.addView(getListItem("", index)); // 添加最后一个空列表项
mEditTextList.getChildAt(index).findViewById(R.id.et_edit_text).requestFocus(); // 设置焦点
mEditTextList.addView(getListItem("", index));
mEditTextList.getChildAt(index).findViewById(R.id.et_edit_text).requestFocus();
mNoteEditor.setVisibility(View.GONE); // 隐藏普通编辑器
mEditTextList.setVisibility(View.VISIBLE); // 显示清单编辑器
mNoteEditor.setVisibility(View.GONE);
mEditTextList.setVisibility(View.VISIBLE);
}
/**
* 获取高亮查询结果
* 对文本中的查询关键词进行高亮处理
* @param fullText 完整文本
* @param userQuery 用户查询字符串
* @return 带有高亮效果的文本
*/
private Spannable getHighlightQueryResult(String fullText, String userQuery) {
SpannableString spannable = new SpannableString(fullText == null ? "" : fullText);
if (!TextUtils.isEmpty(userQuery)) {
mPattern = Pattern.compile(userQuery); // 编译正则表达式
Matcher m = mPattern.matcher(fullText); // 创建匹配器
mPattern = Pattern.compile(userQuery);
Matcher m = mPattern.matcher(fullText);
int start = 0;
while (m.find(start)) {
// 设置高亮背景色
spannable.setSpan(
new BackgroundColorSpan(this.getResources().getColor(
R.color.user_query_highlight)), m.start(), m.end(),
@ -898,19 +725,10 @@ public class NoteEditActivity extends Activity implements OnClickListener,
return spannable;
}
/**
* 获取列表项视图
* 创建并初始化清单模式下的单个列表项视图
* @param item 列表项文本
* @param index 列表项索引
* @return 列表项视图
*/
private View getListItem(String item, int index) {
View view = LayoutInflater.from(this).inflate(R.layout.note_edit_list_item, null);
final NoteEditText edit = (NoteEditText) view.findViewById(R.id.et_edit_text);
edit.setTextAppearance(this, TextAppearanceResources.getTexAppearanceResource(mFontSizeId));
// 设置复选框的选中状态变化监听器
CheckBox cb = ((CheckBox) view.findViewById(R.id.cb_edit_item));
cb.setOnCheckedChangeListener(new OnCheckedChangeListener() {
public void onCheckedChanged(CompoundButton buttonView, boolean isChecked) {
@ -922,7 +740,6 @@ public class NoteEditActivity extends Activity implements OnClickListener,
}
});
// 处理已勾选和未勾选的标记
if (item.startsWith(TAG_CHECKED)) {
cb.setChecked(true);
edit.setPaintFlags(edit.getPaintFlags() | Paint.STRIKE_THRU_TEXT_FLAG);
@ -939,12 +756,6 @@ public class NoteEditActivity extends Activity implements OnClickListener,
return view;
}
/**
* 文本内容改变时调用
* 实现OnTextViewChangeListener接口
* @param index 当前索引
* @param hasText 是否有文本内容
*/
public void onTextChange(int index, boolean hasText) {
if (index >= mEditTextList.getChildCount()) {
Log.e(TAG, "Wrong index, should not happen");
@ -957,12 +768,6 @@ public class NoteEditActivity extends Activity implements OnClickListener,
}
}
/**
* 清单模式改变时调用
* 实现NoteSettingChangedListener接口
* @param oldMode 旧模式
* @param newMode 新模式
*/
public void onCheckListModeChanged(int oldMode, int newMode) {
if (newMode == TextNote.MODE_CHECK_LIST) {
switchToListMode(mNoteEditor.getText().toString());
@ -977,11 +782,6 @@ public class NoteEditActivity extends Activity implements OnClickListener,
}
}
/**
* 获取当前工作文本
* 根据笔记模式获取当前编辑的文本内容
* @return 是否有已勾选的项目
*/
private boolean getWorkingText() {
boolean hasChecked = false;
if (mWorkingNote.getCheckListMode() == TextNote.MODE_CHECK_LIST) {
@ -1005,13 +805,9 @@ public class NoteEditActivity extends Activity implements OnClickListener,
return hasChecked;
}
/**
* 保存笔记
* @return 是否保存成功
*/
private boolean saveNote() {
getWorkingText(); // 获取当前工作文本
boolean saved = mWorkingNote.saveNote(); // 保存笔记到数据库
getWorkingText();
boolean saved = mWorkingNote.saveNote();
if (saved) {
/**
* There are two modes from List view to edit view, open one note,
@ -1025,10 +821,6 @@ public class NoteEditActivity extends Activity implements OnClickListener,
return saved;
}
/**
* 发送到桌面
* 在桌面上创建当前笔记的快捷方式
*/
private void sendToDesktop() {
/**
* Before send message to home, we should make sure that current
@ -1064,12 +856,6 @@ public class NoteEditActivity extends Activity implements OnClickListener,
}
}
/**
* 创建快捷图标标题
* 处理快捷图标标题，移除标记并限制长度
* @param content 笔记内容
* @return 快捷图标标题
*/
private String makeShortcutIconTitle(String content) {
content = content.replace(TAG_CHECKED, "");
content = content.replace(TAG_UNCHECKED, "");
@ -1077,19 +863,10 @@ public class NoteEditActivity extends Activity implements OnClickListener,
SHORTCUT_ICON_TITLE_MAX_LEN) : content;
}
/**
* 显示短时间提示
* @param resId 提示文本资源ID
*/
private void showToast(int resId) {
showToast(resId, Toast.LENGTH_SHORT);
}
/**
* 显示提示
* @param resId 提示文本资源ID
* @param duration 提示持续时间
*/
private void showToast(int resId, int duration) {
Toast.makeText(this, resId, duration).show();
}

83
src/Notes-master/src/net/micode/notes/ui/NoteEditText.java
Unescape View File

@ -37,31 +37,20 @@ import net.micode.notes.R;
import java.util.HashMap;
import java.util.Map;
/**
* 笔记编辑文本组件
* 自定义的EditText组件，用于笔记编辑，支持链接检测和特殊的键盘事件处理
*/
public class NoteEditText extends EditText {
/** 日志标签 */
private static final String TAG = "NoteEditText";
/** 当前文本框的索引 */
private int mIndex;
/** 删除前的选择起始位置 */
private int mSelectionStartBeforeDelete;
/** 电话链接协议 */
private static final String SCHEME_TEL = "tel:" ;
/** HTTP链接协议 */
private static final String SCHEME_HTTP = "http:" ;
/** 电子邮件链接协议 */
private static final String SCHEME_EMAIL = "mailto:" ;
/** 链接协议与对应的操作资源ID映射 */
private static final Map<String, Integer> sSchemaActionResMap = new HashMap<String, Integer>();
static {
sSchemaActionResMap.put(SCHEME_TEL, R.string.note_link_tel); // 电话链接操作文本
sSchemaActionResMap.put(SCHEME_HTTP, R.string.note_link_web); // 网页链接操作文本
sSchemaActionResMap.put(SCHEME_EMAIL, R.string.note_link_email); // 电子邮件链接操作文本
sSchemaActionResMap.put(SCHEME_TEL, R.string.note_link_tel);
sSchemaActionResMap.put(SCHEME_HTTP, R.string.note_link_web);
sSchemaActionResMap.put(SCHEME_EMAIL, R.string.note_link_email);
}
/**
@ -88,60 +77,33 @@ public class NoteEditText extends EditText {
private OnTextViewChangeListener mOnTextViewChangeListener;
/**
* 创建一个笔记编辑文本组件实例
* @param context 上下文
*/
public NoteEditText(Context context) {
super(context, null);
mIndex = 0;
}
/**
* 设置当前文本框的索引
* @param index 索引值
*/
public void setIndex(int index) {
mIndex = index;
}
/**
* 设置文本视图变化监听器
* @param listener 监听器实例
*/
public void setOnTextViewChangeListener(OnTextViewChangeListener listener) {
mOnTextViewChangeListener = listener;
}
/**
* 创建一个笔记编辑文本组件实例
* @param context 上下文
* @param attrs 属性集
*/
public NoteEditText(Context context, AttributeSet attrs) {
super(context, attrs, android.R.attr.editTextStyle);
}
/**
* 创建一个笔记编辑文本组件实例
* @param context 上下文
* @param attrs 属性集
* @param defStyle 默认样式
*/
public NoteEditText(Context context, AttributeSet attrs, int defStyle) {
super(context, attrs, defStyle);
// TODO Auto-generated constructor stub
}
/**
* 处理触摸事件
* @param event 触摸事件
* @return 是否消费了事件
*/
@Override
public boolean onTouchEvent(MotionEvent event) {
switch (event.getAction()) {
case MotionEvent.ACTION_DOWN:
// 计算触摸位置在文本中的偏移量
int x = (int) event.getX();
int y = (int) event.getY();
x -= getTotalPaddingLeft();
@ -152,7 +114,6 @@ public class NoteEditText extends EditText {
Layout layout = getLayout();
int line = layout.getLineForVertical(y);
int off = layout.getOffsetForHorizontal(line, x);
// 设置选择位置
Selection.setSelection(getText(), off);
break;
}
@ -160,23 +121,15 @@ public class NoteEditText extends EditText {
return super.onTouchEvent(event);
}
/**
* 处理按键按下事件
* @param keyCode 按键码
* @param event 按键事件
* @return 是否消费了事件
*/
@Override
public boolean onKeyDown(int keyCode, KeyEvent event) {
switch (keyCode) {
case KeyEvent.KEYCODE_ENTER:
// 如果设置了监听器，不拦截回车键
if (mOnTextViewChangeListener != null) {
return false;
}
break;
case KeyEvent.KEYCODE_DEL:
// 记录删除前的选择起始位置
mSelectionStartBeforeDelete = getSelectionStart();
break;
default:
@ -185,18 +138,11 @@ public class NoteEditText extends EditText {
return super.onKeyDown(keyCode, event);
}
/**
* 处理按键抬起事件
* @param keyCode 按键码
* @param event 按键事件
* @return 是否消费了事件
*/
@Override
public boolean onKeyUp(int keyCode, KeyEvent event) {
switch(keyCode) {
case KeyEvent.KEYCODE_DEL:
if (mOnTextViewChangeListener != null) {
// 如果在文本框开头按下删除键且不是第一个文本框，触发删除事件
if (0 == mSelectionStartBeforeDelete && mIndex != 0) {
mOnTextViewChangeListener.onEditTextDelete(mIndex, getText().toString());
return true;
@ -207,7 +153,6 @@ public class NoteEditText extends EditText {
break;
case KeyEvent.KEYCODE_ENTER:
if (mOnTextViewChangeListener != null) {
// 处理回车键，将光标后的文本移到新的文本框
int selectionStart = getSelectionStart();
String text = getText().subSequence(selectionStart, length()).toString();
setText(getText().subSequence(0, selectionStart));
@ -222,16 +167,9 @@ public class NoteEditText extends EditText {
return super.onKeyUp(keyCode, event);
}
/**
* 处理焦点变化事件
* @param focused 是否获得焦点
* @param direction 焦点变化方向
* @param previouslyFocusedRect 之前焦点所在的矩形
*/
@Override
protected void onFocusChanged(boolean focused, int direction, Rect previouslyFocusedRect) {
if (mOnTextViewChangeListener != null) {
// 当失去焦点且文本为空时，通知监听器文本已清空
if (!focused && TextUtils.isEmpty(getText())) {
mOnTextViewChangeListener.onTextChange(mIndex, false);
} else {
@ -241,10 +179,6 @@ public class NoteEditText extends EditText {
super.onFocusChanged(focused, direction, previouslyFocusedRect);
}
/**
* 创建上下文菜单
* @param menu 上下文菜单
*/
@Override
protected void onCreateContextMenu(ContextMenu menu) {
if (getText() instanceof Spanned) {
@ -254,10 +188,8 @@ public class NoteEditText extends EditText {
int min = Math.min(selStart, selEnd);
int max = Math.max(selStart, selEnd);
// 获取选中文本中的URL链接
final URLSpan[] urls = ((Spanned) getText()).getSpans(min, max, URLSpan.class);
if (urls.length == 1) {
// 根据链接协议获取对应的操作文本
int defaultResId = 0;
for(String schema: sSchemaActionResMap.keySet()) {
if(urls[0].getURL().indexOf(schema) >= 0) {
@ -267,14 +199,13 @@ public class NoteEditText extends EditText {
}
if (defaultResId == 0) {
defaultResId = R.string.note_link_other; // 默认操作文本
defaultResId = R.string.note_link_other;
}
// 添加菜单项并设置点击事件
menu.add(0, 0, 0, defaultResId).setOnMenuItemClickListener(
new OnMenuItemClickListener() {
public boolean onMenuItemClick(MenuItem item) {
// 处理链接点击事件
// goto a new intent
urls[0].onClick(NoteEditText.this);
return true;
}

169
src/Notes-master/src/net/micode/notes/ui/NoteItemData.java
Unescape View File

@ -25,101 +25,57 @@ import net.micode.notes.data.Notes;
import net.micode.notes.data.Notes.NoteColumns;
import net.micode.notes.tool.DataUtils;
/**
* 笔记项数据类
* 封装笔记列表项的数据信息
*/
/**
* 笔记列表项数据
* 用于存储和管理笔记列表中每个项的数据
*/
public class NoteItemData {
/** 数据库查询投影数组 */
static final String [] PROJECTION = new String [] {
NoteColumns.ID, // 笔记ID
NoteColumns.ALERTED_DATE, // 提醒日期
NoteColumns.BG_COLOR_ID, // 背景颜色ID
NoteColumns.CREATED_DATE, // 创建日期
NoteColumns.HAS_ATTACHMENT, // 是否有附件
NoteColumns.MODIFIED_DATE, // 修改日期
NoteColumns.NOTES_COUNT, // 笔记数量
NoteColumns.PARENT_ID, // 父文件夹ID
NoteColumns.SNIPPET, // 笔记摘要
NoteColumns.TYPE, // 笔记类型
NoteColumns.WIDGET_ID, // 小部件ID
NoteColumns.WIDGET_TYPE, // 小部件类型
NoteColumns.ID,
NoteColumns.ALERTED_DATE,
NoteColumns.BG_COLOR_ID,
NoteColumns.CREATED_DATE,
NoteColumns.HAS_ATTACHMENT,
NoteColumns.MODIFIED_DATE,
NoteColumns.NOTES_COUNT,
NoteColumns.PARENT_ID,
NoteColumns.SNIPPET,
NoteColumns.TYPE,
NoteColumns.WIDGET_ID,
NoteColumns.WIDGET_TYPE,
};
/** 笔记ID列索引 */
private static final int ID_COLUMN = 0;
/** 提醒日期列索引 */
private static final int ALERTED_DATE_COLUMN = 1;
/** 背景颜色ID列索引 */
private static final int BG_COLOR_ID_COLUMN = 2;
/** 创建日期列索引 */
private static final int CREATED_DATE_COLUMN = 3;
/** 是否有附件列索引 */
private static final int HAS_ATTACHMENT_COLUMN = 4;
/** 修改日期列索引 */
private static final int MODIFIED_DATE_COLUMN = 5;
/** 笔记数量列索引 */
private static final int NOTES_COUNT_COLUMN = 6;
/** 父文件夹ID列索引 */
private static final int PARENT_ID_COLUMN = 7;
/** 笔记摘要列索引 */
private static final int SNIPPET_COLUMN = 8;
/** 笔记类型列索引 */
private static final int TYPE_COLUMN = 9;
/** 小部件ID列索引 */
private static final int WIDGET_ID_COLUMN = 10;
/** 小部件类型列索引 */
private static final int WIDGET_TYPE_COLUMN = 11;
/** 笔记ID */
private long mId;
/** 提醒日期 */
private long mAlertDate;
/** 背景颜色ID */
private int mBgColorId;
/** 创建日期 */
private long mCreatedDate;
/** 是否有附件 */
private boolean mHasAttachment;
/** 修改日期 */
private long mModifiedDate;
/** 笔记数量 */
private int mNotesCount;
/** 父文件夹ID */
private long mParentId;
/** 笔记摘要 */
private String mSnippet;
/** 笔记类型 */
private int mType;
/** 小部件ID */
private int mWidgetId;
/** 小部件类型 */
private int mWidgetType;
/** 联系人姓名（用于通话记录） */
private String mName;
/** 电话号码（用于通话记录） */
private String mPhoneNumber;
/** 是否为最后一项 */
private boolean mIsLastItem;
/** 是否为第一项 */
private boolean mIsFirstItem;
/** 是否只有一项 */
private boolean mIsOnlyOneItem;
/** 是否是文件夹后的唯一笔记 */
private boolean mIsOneNoteFollowingFolder;
/** 是否是文件夹后的多个笔记 */
private boolean mIsMultiNotesFollowingFolder;
/**
* 创建一个笔记列表项数据实例
* @param context 上下文
* @param cursor 包含笔记数据的Cursor
*/
public NoteItemData(Context context, Cursor cursor) {
mId = cursor.getLong(ID_COLUMN);
mAlertDate = cursor.getLong(ALERTED_DATE_COLUMN);
@ -130,7 +86,6 @@ public class NoteItemData {
mNotesCount = cursor.getInt(NOTES_COUNT_COLUMN);
mParentId = cursor.getLong(PARENT_ID_COLUMN);
mSnippet = cursor.getString(SNIPPET_COLUMN);
// 移除复选框标签
mSnippet = mSnippet.replace(NoteEditActivity.TAG_CHECKED, "").replace(
NoteEditActivity.TAG_UNCHECKED, "");
mType = cursor.getInt(TYPE_COLUMN);
@ -138,7 +93,6 @@ public class NoteItemData {
mWidgetType = cursor.getInt(WIDGET_TYPE_COLUMN);
mPhoneNumber = "";
// 如果是通话记录文件夹中的笔记，获取电话号码和联系人姓名
if (mParentId == Notes.ID_CALL_RECORD_FOLDER) {
mPhoneNumber = DataUtils.getCallNumberByNoteId(context.getContentResolver(), mId);
if (!TextUtils.isEmpty(mPhoneNumber)) {
@ -152,14 +106,9 @@ public class NoteItemData {
if (mName == null) {
mName = "";
}
// 检查笔记在列表中的位置
checkPostion(cursor);
}
/**
* 检查笔记在列表中的位置
* @param cursor 包含笔记数据的Cursor
*/
private void checkPostion(Cursor cursor) {
mIsLastItem = cursor.isLast() ? true : false;
mIsFirstItem = cursor.isFirst() ? true : false;
@ -167,20 +116,17 @@ public class NoteItemData {
mIsMultiNotesFollowingFolder = false;
mIsOneNoteFollowingFolder = false;
// 如果是笔记类型且不是第一项，检查前一项是否为文件夹
if (mType == Notes.TYPE_NOTE && !mIsFirstItem) {
int position = cursor.getPosition();
if (cursor.moveToPrevious()) {
if (cursor.getInt(TYPE_COLUMN) == Notes.TYPE_FOLDER
|| cursor.getInt(TYPE_COLUMN) == Notes.TYPE_SYSTEM) {
// 检查是否有多个笔记跟随在文件夹后面
if (cursor.getCount() > (position + 1)) {
mIsMultiNotesFollowingFolder = true;
} else {
mIsOneNoteFollowingFolder = true;
}
}
// 恢复Cursor位置
if (!cursor.moveToNext()) {
throw new IllegalStateException("cursor move to previous but can't move back");
}
@ -188,179 +134,90 @@ public class NoteItemData {
}
}
/**
* 是否是文件夹后的唯一笔记
* @return true表示是文件夹后的唯一笔记，false表示不是
*/
public boolean isOneFollowingFolder() {
return mIsOneNoteFollowingFolder;
}
/**
* 是否是文件夹后的多个笔记
* @return true表示是文件夹后的多个笔记，false表示不是
*/
public boolean isMultiFollowingFolder() {
return mIsMultiNotesFollowingFolder;
}
/**
* 是否为最后一项
* @return true表示是最后一项，false表示不是
*/
public boolean isLast() {
return mIsLastItem;
}
/**
* 获取联系人姓名（用于通话记录）
* @return 联系人姓名
*/
public String getCallName() {
return mName;
}
/**
* 是否为第一项
* @return true表示是第一项，false表示不是
*/
public boolean isFirst() {
return mIsFirstItem;
}
/**
* 是否只有一项
* @return true表示只有一项，false表示不是
*/
public boolean isSingle() {
return mIsOnlyOneItem;
}
/**
* 获取笔记ID
* @return 笔记ID
*/
public long getId() {
return mId;
}
/**
* 获取提醒日期
* @return 提醒日期
*/
public long getAlertDate() {
return mAlertDate;
}
/**
* 获取创建日期
* @return 创建日期
*/
public long getCreatedDate() {
return mCreatedDate;
}
/**
* 是否有附件
* @return true表示有附件，false表示没有
*/
public boolean hasAttachment() {
return mHasAttachment;
}
/**
* 获取修改日期
* @return 修改日期
*/
public long getModifiedDate() {
return mModifiedDate;
}
/**
* 获取背景颜色ID
* @return 背景颜色ID
*/
public int getBgColorId() {
return mBgColorId;
}
/**
* 获取父文件夹ID
* @return 父文件夹ID
*/
public long getParentId() {
return mParentId;
}
/**
* 获取笔记数量
* @return 笔记数量
*/
public int getNotesCount() {
return mNotesCount;
}
/**
* 获取文件夹ID
* @return 文件夹ID
*/
public long getFolderId () {
return mParentId;
}
/**
* 获取笔记类型
* @return 笔记类型
*/
public int getType() {
return mType;
}
/**
* 获取小部件类型
* @return 小部件类型
*/
public int getWidgetType() {
return mWidgetType;
}
/**
* 获取小部件ID
* @return 小部件ID
*/
public int getWidgetId() {
return mWidgetId;
}
/**
* 获取笔记摘要
* @return 笔记摘要
*/
public String getSnippet() {
return mSnippet;
}
/**
* 是否有提醒
* @return true表示有提醒，false表示没有
*/
public boolean hasAlert() {
return (mAlertDate > 0);
}
/**
* 是否为通话记录
* @return true表示是通话记录，false表示不是
*/
public boolean isCallRecord() {
return (mParentId == Notes.ID_CALL_RECORD_FOLDER && !TextUtils.isEmpty(mPhoneNumber));
}
/**
* 从Cursor中获取笔记类型
* @param cursor 包含笔记数据的Cursor
* @return 笔记类型
*/
public static int getNoteType(Cursor cursor) {
return cursor.getInt(TYPE_COLUMN);
}

242
src/Notes-master/src/net/micode/notes/ui/NotesListActivity.java
Unescape View File

@ -78,90 +78,85 @@ import java.io.InputStream;
import java.io.InputStreamReader;
import java.util.HashSet;
/**
* 笔记列表活动 - 负责显示和管理笔记列表
* 提供笔记的创建、编辑、删除、移动等功能
* 支持文件夹管理和多选操作模式
*/
public class NotesListActivity extends Activity implements OnClickListener, OnItemLongClickListener {
// 异步查询处理的标记常量
private static final int FOLDER_NOTE_LIST_QUERY_TOKEN = 0; // 查询笔记列表的标记
private static final int FOLDER_LIST_QUERY_TOKEN = 1; // 查询文件夹列表的标记
private static final int FOLDER_NOTE_LIST_QUERY_TOKEN = 0;
private static final int FOLDER_LIST_QUERY_TOKEN = 1;
private static final int MENU_FOLDER_DELETE = 0;
// 文件夹上下文菜单的菜单项ID
private static final int MENU_FOLDER_DELETE = 0; // 删除文件夹
private static final int MENU_FOLDER_VIEW = 1; // 查看文件夹
private static final int MENU_FOLDER_CHANGE_NAME = 2; // 修改文件夹名称
private static final int MENU_FOLDER_VIEW = 1;
private static final int MENU_FOLDER_CHANGE_NAME = 2;
// 用于存储应用介绍是否已添加的偏好设置键
private static final String PREFERENCE_ADD_INTRODUCTION = "net.micode.notes.introduction";
/**
* 列表所处的编辑状态：
* NOTE_LIST 根目录；SUB_FOLDER 子文件夹；CALL_RECORD_FOLDER 通话记录专用文件夹。
*/
private enum ListEditState {
NOTE_LIST, // 笔记列表状态
SUB_FOLDER, // 子文件夹状态
CALL_RECORD_FOLDER // 通话记录文件夹状态
NOTE_LIST, SUB_FOLDER, CALL_RECORD_FOLDER
};
// 成员变量
private ListEditState mState; // 当前列表编辑状态
private BackgroundQueryHandler mBackgroundQueryHandler; // 异步查询处理器
private NotesListAdapter mNotesListAdapter; // 笔记列表适配器
private ListView mNotesListView; // 笔记列表视图
private Button mAddNewNote; // 新建笔记按钮
private boolean mDispatch; // 是否分发触摸事件给列表视图
private int mOriginY; // 原始触摸Y坐标
private int mDispatchY; // 分发触摸Y坐标
private TextView mTitleBar; // 标题栏
private long mCurrentFolderId; // 当前文件夹ID
private ContentResolver mContentResolver; // 内容解析器
private ModeCallback mModeCallBack; // 多选模式回调
private static final String TAG = "NotesListActivity"; // 日志标签
public static final int NOTES_LISTVIEW_SCROLL_RATE = 30;// 笔记列表滚动速率
private NoteItemData mFocusNoteDataItem; // 当前焦点的笔记数据项
// 查询条件常量
private static final String NORMAL_SELECTION = NoteColumns.PARENT_ID + "=?"; // 普通文件夹查询条件
private ListEditState mState;
private BackgroundQueryHandler mBackgroundQueryHandler;
private NotesListAdapter mNotesListAdapter;
private ListView mNotesListView;
private Button mAddNewNote;
private boolean mDispatch;
private int mOriginY;
private int mDispatchY;
private TextView mTitleBar;
private long mCurrentFolderId;
private ContentResolver mContentResolver;
private ModeCallback mModeCallBack;
private static final String TAG = "NotesListActivity";
public static final int NOTES_LISTVIEW_SCROLL_RATE = 30;
private NoteItemData mFocusNoteDataItem;
private static final String NORMAL_SELECTION = NoteColumns.PARENT_ID + "=?";
private static final String ROOT_FOLDER_SELECTION = "(" + NoteColumns.TYPE + "<>"
+ Notes.TYPE_SYSTEM + " AND " + NoteColumns.PARENT_ID + "=?)" + " OR ("
+ NoteColumns.ID + "=" + Notes.ID_CALL_RECORD_FOLDER + " AND "
+ NoteColumns.NOTES_COUNT + ">0)"; // 根文件夹查询条件（显示非系统文件夹和非空通话记录文件夹）
+ NoteColumns.NOTES_COUNT + ">0)";
// 请求码常量
private final static int REQUEST_CODE_OPEN_NODE = 102; // 打开笔记的请求码
private final static int REQUEST_CODE_NEW_NODE = 103; // 新建笔记的请求码
private final static int REQUEST_CODE_OPEN_NODE = 102;
private final static int REQUEST_CODE_NEW_NODE = 103;
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.note_list); // 设置布局
initResources(); // 初始化资源
setContentView(R.layout.note_list);
initResources();
// 首次进入时插入“介绍”笔记
setAppInfoFromRawRes(); // 设置应用信息（首次使用时添加介绍笔记）
/**
* Insert an introduction when user firstly use this application
*/
setAppInfoFromRawRes();
}
@Override
protected void onActivityResult(int requestCode, int resultCode, Intent data) {
// 处理从NoteEditActivity返回的结果
if (resultCode == RESULT_OK
&& (requestCode == REQUEST_CODE_OPEN_NODE || requestCode == REQUEST_CODE_NEW_NODE)) {
// 如果是打开或新建笔记的请求返回成功，刷新列表
mNotesListAdapter.changeCursor(null);
} else {
super.onActivityResult(requestCode, resultCode, data);
}
}
/**
* 从原始资源文件中设置应用介绍信息
* 当用户首次使用应用时，添加介绍笔记
*/
private void setAppInfoFromRawRes() {
SharedPreferences sp = PreferenceManager.getDefaultSharedPreferences(this);
if (!sp.getBoolean(PREFERENCE_ADD_INTRODUCTION, false)) {
@ -208,20 +203,12 @@ public class NotesListActivity extends Activity implements OnClickListener, OnIt
}
}
/**
* 当活动开始时调用
* 启动异步查询笔记列表
*/
@Override
protected void onStart() {
super.onStart();
startAsyncNotesListQuery();
}
/**
* 初始化资源
* 设置内容解析器、异步查询处理器、列表适配器等
*/
private void initResources() {
mContentResolver = this.getContentResolver();
mBackgroundQueryHandler = new BackgroundQueryHandler(this.getContentResolver());
@ -244,19 +231,11 @@ public class NotesListActivity extends Activity implements OnClickListener, OnIt
mModeCallBack = new ModeCallback();
}
/**
* 多选模式回调类 - 处理笔记的多选操作
* 实现了多选模式下的菜单创建、选择状态变化等功能
*/
private class ModeCallback implements ListView.MultiChoiceModeListener, OnMenuItemClickListener {
private DropdownMenu mDropDownMenu;
private ActionMode mActionMode;
private MenuItem mMoveMenu;
/**
* 创建操作模式时调用
* 设置多选模式下的菜单和视图
*/
public boolean onCreateActionMode(ActionMode mode, Menu menu) {
getMenuInflater().inflate(R.menu.note_list_options, menu);
menu.findItem(R.id.delete).setOnMenuItemClickListener(this);
@ -290,10 +269,6 @@ public class NotesListActivity extends Activity implements OnClickListener, OnIt
return true;
}
/**
* 更新菜单状态
* 根据选择的笔记数量更新下拉菜单标题和全选状态
*/
private void updateMenu() {
int selectedCount = mNotesListAdapter.getSelectedCount();
// Update dropdown menu
@ -321,37 +296,22 @@ public class NotesListActivity extends Activity implements OnClickListener, OnIt
return false;
}
/**
* 销毁操作模式时调用
* 恢复普通模式下的视图状态
*/
public void onDestroyActionMode(ActionMode mode) {
mNotesListAdapter.setChoiceMode(false);
mNotesListView.setLongClickable(true);
mAddNewNote.setVisibility(View.VISIBLE);
}
/**
* 结束操作模式
*/
public void finishActionMode() {
mActionMode.finish();
}
/**
* 当列表项的选择状态改变时调用
* 更新适配器中的选择状态并刷新菜单
*/
public void onItemCheckedStateChanged(ActionMode mode, int position, long id,
boolean checked) {
mNotesListAdapter.setCheckedItem(position, checked);
updateMenu();
}
/**
* 处理菜单项点击事件
* 支持删除和移动操作
*/
public boolean onMenuItemClick(MenuItem item) {
if (mNotesListAdapter.getSelectedCount() == 0) {
Toast.makeText(NotesListActivity.this, getString(R.string.menu_select_none),
@ -361,7 +321,6 @@ public class NotesListActivity extends Activity implements OnClickListener, OnIt
switch (item.getItemId()) {
case R.id.delete:
// 显示删除确认对话框
AlertDialog.Builder builder = new AlertDialog.Builder(NotesListActivity.this);
builder.setTitle(getString(R.string.alert_title_delete));
builder.setIcon(android.R.drawable.ic_dialog_alert);
@ -371,14 +330,13 @@ public class NotesListActivity extends Activity implements OnClickListener, OnIt
new DialogInterface.OnClickListener() {
public void onClick(DialogInterface dialog,
int which) {
batchDelete(); // 执行批量删除
batchDelete();
}
});
builder.setNegativeButton(android.R.string.cancel, null);
builder.show();
break;
case R.id.move:
// 查询目标文件夹列表
startQueryDestinationFolders();
break;
default:
@ -388,10 +346,6 @@ public class NotesListActivity extends Activity implements OnClickListener, OnIt
}
}
/**
* 新建笔记按钮的触摸监听器
* 处理特殊的触摸事件分发逻辑
*/
private class NewNoteOnTouchListener implements OnTouchListener {
public boolean onTouch(View v, MotionEvent event) {
@ -402,13 +356,22 @@ public class NotesListActivity extends Activity implements OnClickListener, OnIt
int newNoteViewHeight = mAddNewNote.getHeight();
int start = screenHeight - newNoteViewHeight;
int eventY = start + (int) event.getY();
// 子文件夹状态需减去标题栏高度
/**
* Minus TitleBar's height
*/
if (mState == ListEditState.SUB_FOLDER) {
eventY -= mTitleBar.getHeight();
start -= mTitleBar.getHeight();
}
// HACKME: 点击“新建”按钮透明区时，将事件派发给下方列表。
// 透明区近似线性公式 y = -0.12x + 94（px），背景改动需同步更新该公式。
/**
* HACKME:When click the transparent part of "New Note" button, dispatch
* the event to the list view behind this button. The transparent part of
* "New Note" button could be expressed by formula y=-0.12x+94（Unit:pixel）
* and the line top of the button. The coordinate based on left of the "New
* Note" button. The 94 represents maximum height of the transparent part.
* Notice that, if the background of the button changes, the formula should
* also change. This is very bad, just for the UI designer's strong requirement.
*/
if (event.getY() < (event.getX() * (-0.12) + 94)) {
View view = mNotesListView.getChildAt(mNotesListView.getChildCount() - 1
- mNotesListView.getFooterViewsCount());
@ -445,10 +408,6 @@ public class NotesListActivity extends Activity implements OnClickListener, OnIt
};
/**
* 开始异步查询笔记列表
* 根据当前文件夹ID选择不同的查询条件
*/
private void startAsyncNotesListQuery() {
String selection = (mCurrentFolderId == Notes.ID_ROOT_FOLDER) ? ROOT_FOLDER_SELECTION
: NORMAL_SELECTION;
@ -458,27 +417,18 @@ public class NotesListActivity extends Activity implements OnClickListener, OnIt
}, NoteColumns.TYPE + " DESC," + NoteColumns.MODIFIED_DATE + " DESC");
}
/**
* 后台查询处理器 - 处理异步数据库查询
*/
private final class BackgroundQueryHandler extends AsyncQueryHandler {
public BackgroundQueryHandler(ContentResolver contentResolver) {
super(contentResolver);
}
/**
* 查询完成时调用
* 根据不同的查询标记处理查询结果
*/
@Override
protected void onQueryComplete(int token, Object cookie, Cursor cursor) {
switch (token) {
case FOLDER_NOTE_LIST_QUERY_TOKEN:
// 查询笔记列表完成，更新适配器
mNotesListAdapter.changeCursor(cursor);
break;
case FOLDER_LIST_QUERY_TOKEN:
// 查询文件夹列表完成，显示文件夹菜单
if (cursor != null && cursor.getCount() > 0) {
showFolderListMenu(cursor);
} else {
@ -491,10 +441,6 @@ public class NotesListActivity extends Activity implements OnClickListener, OnIt
}
}
/**
* 显示文件夹列表菜单
* 用于选择移动笔记的目标文件夹
*/
private void showFolderListMenu(Cursor cursor) {
AlertDialog.Builder builder = new AlertDialog.Builder(NotesListActivity.this);
builder.setTitle(R.string.menu_title_select_folder);
@ -516,10 +462,6 @@ public class NotesListActivity extends Activity implements OnClickListener, OnIt
builder.show();
}
/**
* 创建新笔记
* 跳转到笔记编辑界面
*/
private void createNewNote() {
Intent intent = new Intent(this, NoteEditActivity.class);
intent.setAction(Intent.ACTION_INSERT_OR_EDIT);
@ -527,10 +469,6 @@ public class NotesListActivity extends Activity implements OnClickListener, OnIt
this.startActivityForResult(intent, REQUEST_CODE_NEW_NODE);
}
/**
* 批量删除笔记
* 在同步模式下将笔记移动到回收站，非同步模式下直接删除
*/
private void batchDelete() {
new AsyncTask<Void, Void, HashSet<AppWidgetAttribute>>() {
protected HashSet<AppWidgetAttribute> doInBackground(Void... unused) {
@ -568,10 +506,6 @@ public class NotesListActivity extends Activity implements OnClickListener, OnIt
}.execute();
}
/**
* 删除文件夹
* 在同步模式下将文件夹移动到回收站，非同步模式下直接删除
*/
private void deleteFolder(long folderId) {
if (folderId == Notes.ID_ROOT_FOLDER) {
Log.e(TAG, "Wrong folder id, should not happen " + folderId);
@ -599,10 +533,6 @@ public class NotesListActivity extends Activity implements OnClickListener, OnIt
}
}
/**
* 打开笔记
* 跳转到笔记编辑界面查看/编辑笔记
*/
private void openNode(NoteItemData data) {
Intent intent = new Intent(this, NoteEditActivity.class);
intent.setAction(Intent.ACTION_VIEW);
@ -610,10 +540,6 @@ public class NotesListActivity extends Activity implements OnClickListener, OnIt
this.startActivityForResult(intent, REQUEST_CODE_OPEN_NODE);
}
/**
* 打开文件夹
* 更新当前文件夹ID并重新查询笔记列表
*/
private void openFolder(NoteItemData data) {
mCurrentFolderId = data.getId();
startAsyncNotesListQuery();
@ -631,10 +557,6 @@ public class NotesListActivity extends Activity implements OnClickListener, OnIt
mTitleBar.setVisibility(View.VISIBLE);
}
/**
* 处理点击事件
* 当前只处理新建笔记按钮的点击
*/
public void onClick(View v) {
switch (v.getId()) {
case R.id.btn_new_note:
@ -645,9 +567,6 @@ public class NotesListActivity extends Activity implements OnClickListener, OnIt
}
}
/**
* 显示软键盘
*/
private void showSoftInput() {
InputMethodManager inputMethodManager = (InputMethodManager) getSystemService(Context.INPUT_METHOD_SERVICE);
if (inputMethodManager != null) {
@ -655,18 +574,11 @@ public class NotesListActivity extends Activity implements OnClickListener, OnIt
}
}
/**
* 隐藏软键盘
*/
private void hideSoftInput(View view) {
InputMethodManager inputMethodManager = (InputMethodManager) getSystemService(Context.INPUT_METHOD_SERVICE);
inputMethodManager.hideSoftInputFromWindow(view.getWindowToken(), 0);
}
/**
* 显示创建或修改文件夹的对话框
* @param create 是否为创建文件夹模式
*/
private void showCreateOrModifyFolderDialog(final boolean create) {
final AlertDialog.Builder builder = new AlertDialog.Builder(this);
View view = LayoutInflater.from(this).inflate(R.layout.dialog_edit_text, null);
@ -752,10 +664,6 @@ public class NotesListActivity extends Activity implements OnClickListener, OnIt
});
}
/**
* 处理返回键按下事件
* 根据当前状态返回到上一级菜单或退出应用
*/
@Override
public void onBackPressed() {
switch (mState) {
@ -780,10 +688,6 @@ public class NotesListActivity extends Activity implements OnClickListener, OnIt
}
}
/**
* 更新小部件
* 根据小部件类型发送相应的广播更新
*/
private void updateWidget(int appWidgetId, int appWidgetType) {
Intent intent = new Intent(AppWidgetManager.ACTION_APPWIDGET_UPDATE);
if (appWidgetType == Notes.TYPE_WIDGET_2X) {
@ -803,10 +707,6 @@ public class NotesListActivity extends Activity implements OnClickListener, OnIt
setResult(RESULT_OK, intent);
}
/**
* 文件夹上下文菜单监听器
* 创建文件夹的上下文菜单
*/
private final OnCreateContextMenuListener mFolderOnCreateContextMenuListener = new OnCreateContextMenuListener() {
public void onCreateContextMenu(ContextMenu menu, View v, ContextMenuInfo menuInfo) {
if (mFocusNoteDataItem != null) {
@ -818,10 +718,6 @@ public class NotesListActivity extends Activity implements OnClickListener, OnIt
}
};
/**
* 上下文菜单关闭时调用
* 清除列表视图的上下文菜单监听器
*/
@Override
public void onContextMenuClosed(Menu menu) {
if (mNotesListView != null) {
@ -830,10 +726,6 @@ public class NotesListActivity extends Activity implements OnClickListener, OnIt
super.onContextMenuClosed(menu);
}
/**
* 处理上下文菜单项的选择
* 支持查看、删除、重命名文件夹操作
*/
@Override
public boolean onContextItemSelected(MenuItem item) {
if (mFocusNoteDataItem == null) {
@ -868,10 +760,6 @@ public class NotesListActivity extends Activity implements OnClickListener, OnIt
return true;
}
/**
* 准备选项菜单
* 根据当前状态加载不同的菜单布局
*/
@Override
public boolean onPrepareOptionsMenu(Menu menu) {
menu.clear();
@ -890,10 +778,6 @@ public class NotesListActivity extends Activity implements OnClickListener, OnIt
return true;
}
/**
* 处理选项菜单项的选择
* 支持新建文件夹、导出文本、同步等操作
*/
@Override
public boolean onOptionsItemSelected(MenuItem item) {
switch (item.getItemId()) {

88
src/Notes-master/src/net/micode/notes/ui/NotesListAdapter.java
Unescape View File

@ -30,41 +30,19 @@ import java.util.HashMap;
import java.util.HashSet;
import java.util.Iterator;
/**
* 笔记列表适配器。
* <p>职责：为列表提供笔记/文件夹数据视图绑定，管理多选状态（批量删除/移动），并暴露选中项信息。</p>
*/
/**
* 笔记列表适配器
* 继承自CursorAdapter，用于在列表视图中显示笔记数据
* 支持多选模式和笔记项的选择状态管理
*/
public class NotesListAdapter extends CursorAdapter {
private static final String TAG = "NotesListAdapter";
/** 上下文对象 */
private Context mContext;
/** 选中的索引映射（position -> 是否选中） */
private HashMap<Integer, Boolean> mSelectedIndex;
/** 笔记数量 */
private int mNotesCount;
/** 是否处于选择模式 */
private boolean mChoiceMode;
/**
* 应用小部件属性类
* 用于存储应用小部件的ID和类型信息
*/
public static class AppWidgetAttribute {
/** 小部件ID */
public int widgetId;
/** 小部件类型 */
public int widgetType;
};
/**
* 构造方法
* @param context 应用上下文
*/
public NotesListAdapter(Context context) {
super(context, null);
mSelectedIndex = new HashMap<Integer, Boolean>();
@ -72,25 +50,11 @@ public class NotesListAdapter extends CursorAdapter {
mNotesCount = 0;
}
/**
* 创建新的视图
* @param context 应用上下文
* @param cursor 数据库游标
* @param parent 父视图组
* @return 新创建的NotesListItem视图
*/
@Override
public View newView(Context context, Cursor cursor, ViewGroup parent) {
return new NotesListItem(context);
}
/**
* 绑定数据到视图
* 将数据库游标中的数据绑定到NotesListItem视图上
* @param view 要绑定的视图
* @param context 应用上下文
* @param cursor 数据库游标
*/
@Override
public void bindView(View view, Context context, Cursor cursor) {
if (view instanceof NotesListItem) {
@ -100,42 +64,24 @@ public class NotesListAdapter extends CursorAdapter {
}
}
/**
* 设置指定位置的笔记项的选中状态
* @param position 笔记项的位置
* @param checked 选中状态，true为选中，false为未选中
*/
public void setCheckedItem(final int position, final boolean checked) {
mSelectedIndex.put(position, checked);
notifyDataSetChanged();
}
/**
* 检查是否处于选择模式
* @return true表示处于选择模式，false表示非选择模式
*/
public boolean isInChoiceMode() {
return mChoiceMode;
}
/**
* 设置选择模式
* @param mode true为选择模式，false为非选择模式
*/
public void setChoiceMode(boolean mode) {
mSelectedIndex.clear(); // 清除所有选中项
mSelectedIndex.clear();
mChoiceMode = mode;
}
/**
* 选择或取消选择所有笔记项
* @param checked true为全选，false为取消全选
*/
public void selectAll(boolean checked) {
Cursor cursor = getCursor();
for (int i = 0; i < getCount(); i++) {
if (cursor.moveToPosition(i)) {
// 只处理类型为笔记的项
if (NoteItemData.getNoteType(cursor) == Notes.TYPE_NOTE) {
setCheckedItem(i, checked);
}
@ -143,10 +89,6 @@ public class NotesListAdapter extends CursorAdapter {
}
}
/**
* 获取所有选中项的ID
* @return 包含所有选中项ID的HashSet
*/
public HashSet<Long> getSelectedItemIds() {
HashSet<Long> itemSet = new HashSet<Long>();
for (Integer position : mSelectedIndex.keySet()) {
@ -163,10 +105,6 @@ public class NotesListAdapter extends CursorAdapter {
return itemSet;
}
/**
* 获取所有选中项的小部件属性
* @return 包含所有选中项小部件属性的HashSet
*/
public HashSet<AppWidgetAttribute> getSelectedWidget() {
HashSet<AppWidgetAttribute> itemSet = new HashSet<AppWidgetAttribute>();
for (Integer position : mSelectedIndex.keySet()) {
@ -190,10 +128,6 @@ public class NotesListAdapter extends CursorAdapter {
return itemSet;
}
/**
* 获取选中项的数量
* @return 选中项的数量
*/
public int getSelectedCount() {
Collection<Boolean> values = mSelectedIndex.values();
if (null == values) {
@ -209,20 +143,11 @@ public class NotesListAdapter extends CursorAdapter {
return count;
}
/**
* 检查是否所有笔记项都被选中
* @return true表示所有笔记项都被选中，false表示不是
*/
public boolean isAllSelected() {
int checkedCount = getSelectedCount();
return (checkedCount != 0 && checkedCount == mNotesCount);
}
/**
* 检查指定位置的笔记项是否被选中
* @param position 笔记项的位置
* @return true表示被选中，false表示未被选中
*/
public boolean isSelectedItem(final int position) {
if (null == mSelectedIndex.get(position)) {
return false;
@ -233,25 +158,20 @@ public class NotesListAdapter extends CursorAdapter {
@Override
protected void onContentChanged() {
super.onContentChanged();
calcNotesCount(); // 重新计算笔记总数
calcNotesCount();
}
@Override
public void changeCursor(Cursor cursor) {
super.changeCursor(cursor);
calcNotesCount(); // 重新计算笔记总数
calcNotesCount();
}
/**
* 计算笔记总数
* 遍历所有游标项，统计类型为笔记的项的数量
*/
private void calcNotesCount() {
mNotesCount = 0;
for (int i = 0; i < getCount(); i++) {
Cursor c = (Cursor) getItem(i);
if (c != null) {
// 只统计类型为笔记的项
if (NoteItemData.getNoteType(c) == Notes.TYPE_NOTE) {
mNotesCount++;
}

55
src/Notes-master/src/net/micode/notes/ui/NotesListItem.java
Unescape View File

@ -29,37 +29,18 @@ import net.micode.notes.data.Notes;
import net.micode.notes.tool.DataUtils;
import net.micode.notes.tool.ResourceParser.NoteItemBgResources;
/**
* 笔记列表项视图
* 用于在列表中显示单个笔记项
*/
/**
* 笔记列表项视图
* 用于在笔记列表中显示单个笔记项的自定义视图
*/
public class NotesListItem extends LinearLayout {
/** 提醒图标 */
private ImageView mAlert;
/** 笔记标题文本视图 */
private TextView mTitle;
/** 时间文本视图 */
private TextView mTime;
/** 联系人姓名文本视图（用于通话记录） */
private TextView mCallName;
/** 笔记项数据 */
private NoteItemData mItemData;
/** 复选框（用于选择模式） */
private CheckBox mCheckBox;
/**
* 创建一个笔记列表项视图实例
* @param context 上下文
*/
public NotesListItem(Context context) {
super(context);
// 填充布局
inflate(context, R.layout.note_item, this);
// 获取视图组件
mAlert = (ImageView) findViewById(R.id.iv_alert_icon);
mTitle = (TextView) findViewById(R.id.tv_title);
mTime = (TextView) findViewById(R.id.tv_time);
@ -67,15 +48,7 @@ public class NotesListItem extends LinearLayout {
mCheckBox = (CheckBox) findViewById(android.R.id.checkbox);
}
/**
* 将笔记数据绑定到视图
* @param context 上下文
* @param data 笔记项数据
* @param choiceMode 是否为选择模式
* @param checked 是否被选中
*/
public void bind(Context context, NoteItemData data, boolean choiceMode, boolean checked) {
// 处理选择模式下的复选框显示
if (choiceMode && data.getType() == Notes.TYPE_NOTE) {
mCheckBox.setVisibility(View.VISIBLE);
mCheckBox.setChecked(checked);
@ -84,8 +57,6 @@ public class NotesListItem extends LinearLayout {
}
mItemData = data;
// 处理通话记录文件夹
if (data.getId() == Notes.ID_CALL_RECORD_FOLDER) {
mCallName.setVisibility(View.GONE);
mAlert.setVisibility(View.VISIBLE);
@ -93,9 +64,7 @@ public class NotesListItem extends LinearLayout {
mTitle.setText(context.getString(R.string.call_record_folder_name)
+ context.getString(R.string.format_folder_files_count, data.getNotesCount()));
mAlert.setImageResource(R.drawable.call_record);
}
// 处理通话记录笔记
else if (data.getParentId() == Notes.ID_CALL_RECORD_FOLDER) {
} else if (data.getParentId() == Notes.ID_CALL_RECORD_FOLDER) {
mCallName.setVisibility(View.VISIBLE);
mCallName.setText(data.getCallName());
mTitle.setTextAppearance(context,R.style.TextAppearanceSecondaryItem);
@ -106,20 +75,16 @@ public class NotesListItem extends LinearLayout {
} else {
mAlert.setVisibility(View.GONE);
}
}
// 处理普通文件夹或笔记
else {
} else {
mCallName.setVisibility(View.GONE);
mTitle.setTextAppearance(context, R.style.TextAppearancePrimaryItem);
if (data.getType() == Notes.TYPE_FOLDER) {
// 文件夹显示格式：名称 + 数量
mTitle.setText(data.getSnippet()
+ context.getString(R.string.format_folder_files_count,
data.getNotesCount()));
mAlert.setVisibility(View.GONE);
} else {
// 笔记显示格式：摘要
mTitle.setText(DataUtils.getFormattedSnippet(data.getSnippet()));
if (data.hasAlert()) {
mAlert.setImageResource(R.drawable.clock);
@ -129,23 +94,14 @@ public class NotesListItem extends LinearLayout {
}
}
}
// 设置修改时间
mTime.setText(DateUtils.getRelativeTimeSpanString(data.getModifiedDate()));
// 设置背景
setBackground(data);
}
/**
* 设置笔记项的背景
* @param data 笔记项数据
*/
private void setBackground(NoteItemData data) {
int id = data.getBgColorId();
if (data.getType() == Notes.TYPE_NOTE) {
// 根据笔记在列表中的位置选择不同的背景
if (data.isSingle() || data.isOneFollowingFolder()) {
setBackgroundResource(NoteItemBgResources.getNoteBgSingleRes(id));
} else if (data.isLast()) {
@ -156,15 +112,10 @@ public class NotesListItem extends LinearLayout {
setBackgroundResource(NoteItemBgResources.getNoteBgNormalRes(id));
}
} else {
// 文件夹使用固定背景
setBackgroundResource(NoteItemBgResources.getFolderBgRes());
}
}
/**
* 获取笔记项数据
* @return 笔记项数据
*/
public NoteItemData getItemData() {
return mItemData;
}

152
src/Notes-master/src/net/micode/notes/ui/NotesPreferenceActivity.java
Unescape View File

@ -47,84 +47,56 @@ import net.micode.notes.data.Notes;
import net.micode.notes.data.Notes.NoteColumns;
import net.micode.notes.gtask.remote.GTaskSyncService;
/**
* 笔记设置页面。
* <p>职责：承载账户绑定/切换、GTask 同步开关、上次同步时间展示、背景随机开关等设置。</p>
* <p>关键点：绑定账户时需清理本地 gtask 关联字段；同步过程中禁止修改账户；页面通过广播实时刷新同步状态。</p>
*/
/**
* 设置活动，用于管理同步账户、最后同步时间和背景颜色偏好
*/
public class NotesPreferenceActivity extends PreferenceActivity {
/** 偏好设置文件名 */
public static final String PREFERENCE_NAME = "notes_preferences";
/** 同步账户名存储键 */
public static final String PREFERENCE_SYNC_ACCOUNT_NAME = "pref_key_account_name";
/** 最后同步时间存储键 */
public static final String PREFERENCE_LAST_SYNC_TIME = "pref_last_sync_time";
/** 设置背景颜色的偏好键 */
public static final String PREFERENCE_SET_BG_COLOR_KEY = "pref_key_bg_random_appear";
/** 同步账户的偏好键 */
private static final String PREFERENCE_SYNC_ACCOUNT_KEY = "pref_sync_account_key";
/** 账户权限过滤键 */
private static final String AUTHORITIES_FILTER_KEY = "authorities";
/** 账户偏好分类 */
private PreferenceCategory mAccountCategory;
/** 同步状态广播接收器 */
private GTaskReceiver mReceiver;
/** 原始账户列表 */
private Account[] mOriAccounts;
/** 是否添加了新账户 */
private boolean mHasAddedAccount;
/**
* 创建活动时调用，初始化布局、偏好设置和广播接收器
* @param icicle 保存的实例状态
*/
@Override
protected void onCreate(Bundle icicle) {
super.onCreate(icicle);
/* 使用应用图标作为导航 */
/* using the app icon for navigation */
getActionBar().setDisplayHomeAsUpEnabled(true);
// 从资源文件加载偏好设置
addPreferencesFromResource(R.xml.preferences);
// 获取账户偏好分类
mAccountCategory = (PreferenceCategory) findPreference(PREFERENCE_SYNC_ACCOUNT_KEY);
// 创建并注册同步状态广播接收器
mReceiver = new GTaskReceiver();
IntentFilter filter = new IntentFilter();
filter.addAction(GTaskSyncService.GTASK_SERVICE_BROADCAST_NAME);
registerReceiver(mReceiver, filter);
mOriAccounts = null;
// 加载设置头部布局
View header = LayoutInflater.from(this).inflate(R.layout.settings_header, null);
getListView().addHeaderView(header, null, true);
}
/**
* 活动恢复时调用，检查是否添加了新账户并刷新UI
*/
@Override
protected void onResume() {
super.onResume();
// 若用户刚新增了 Google 账号，自动选中新账号为同步账号
// need to set sync account automatically if user has added a new
// account
if (mHasAddedAccount) {
Account[] accounts = getGoogleAccounts();
if (mOriAccounts != null && accounts.length > mOriAccounts.length) {
// 查找新增的账户
for (Account accountNew : accounts) {
boolean found = false;
for (Account accountOld : mOriAccounts) {
@ -134,7 +106,6 @@ public class NotesPreferenceActivity extends PreferenceActivity {
}
}
if (!found) {
// 设置新增账户为同步账户
setSyncAccount(accountNew.name);
break;
}
@ -142,48 +113,36 @@ public class NotesPreferenceActivity extends PreferenceActivity {
}
}
// 刷新UI界面
refreshUI();
}
/**
* 活动销毁时调用，取消注册广播接收器
*/
@Override
protected void onDestroy() {
// 取消注册同步状态广播接收器
if (mReceiver != null) {
unregisterReceiver(mReceiver);
}
super.onDestroy();
}
/**
* 加载账户偏好设置，创建账户选择偏好项
*/
private void loadAccountPreference() {
// 清空账户偏好分类中的所有项
mAccountCategory.removeAll();
// 创建账户选择偏好项
Preference accountPref = new Preference(this);
final String defaultAccount = getSyncAccountName(this);
accountPref.setTitle(getString(R.string.preferences_account_title));
accountPref.setSummary(getString(R.string.preferences_account_summary));
// 设置偏好项点击监听器
accountPref.setOnPreferenceClickListener(new OnPreferenceClickListener() {
public boolean onPreferenceClick(Preference preference) {
// 只有当不同步时才能更改账户
if (!GTaskSyncService.isSyncing()) {
if (TextUtils.isEmpty(defaultAccount)) {
// 首次设置账户，显示账户选择对话框
// the first time to set account
showSelectAccountAlertDialog();
} else {
// 已绑定过账号，提示更换风险
// if the account has already been set, we need to promp
// user about the risk
showChangeAccountConfirmAlertDialog();
}
} else {
// 同步中不能更改账户，显示提示信息
Toast.makeText(NotesPreferenceActivity.this,
R.string.preferences_toast_cannot_change_account, Toast.LENGTH_SHORT)
.show();
@ -192,113 +151,85 @@ public class NotesPreferenceActivity extends PreferenceActivity {
}
});
// 将账户偏好项添加到分类中
mAccountCategory.addPreference(accountPref);
}
/**
* 加载同步按钮和最后同步时间显示
*/
private void loadSyncButton() {
// 获取同步按钮和最后同步时间文本视图
Button syncButton = (Button) findViewById(R.id.preference_sync_button);
TextView lastSyncTimeView = (TextView) findViewById(R.id.prefenerece_sync_status_textview);
// 根据同步状态配置按钮文案与行为
// set button state
if (GTaskSyncService.isSyncing()) {
// 同步中，按钮显示取消同步
syncButton.setText(getString(R.string.preferences_button_sync_cancel));
syncButton.setOnClickListener(new View.OnClickListener() {
public void onClick(View v) {
// 取消同步
GTaskSyncService.cancelSync(NotesPreferenceActivity.this);
}
});
} else {
// 未同步，按钮显示立即同步
syncButton.setText(getString(R.string.preferences_button_sync_immediately));
syncButton.setOnClickListener(new View.OnClickListener() {
public void onClick(View v) {
// 开始同步
GTaskSyncService.startSync(NotesPreferenceActivity.this);
}
});
}
// 只有设置了同步账户，按钮才可用
syncButton.setEnabled(!TextUtils.isEmpty(getSyncAccountName(this)));
// 展示最近同步时间或实时进度
// set last sync time
if (GTaskSyncService.isSyncing()) {
// 同步中，显示同步进度
lastSyncTimeView.setText(GTaskSyncService.getProgressString());
lastSyncTimeView.setVisibility(View.VISIBLE);
} else {
// 未同步，显示最后同步时间
long lastSyncTime = getLastSyncTime(this);
if (lastSyncTime != 0) {
// 格式化并显示最后同步时间
lastSyncTimeView.setText(getString(R.string.preferences_last_sync_time,
DateFormat.format(getString(R.string.preferences_last_sync_time_format),
lastSyncTime)));
lastSyncTimeView.setVisibility(View.VISIBLE);
} else {
// 从未同步过，隐藏时间显示
lastSyncTimeView.setVisibility(View.GONE);
}
}
}
/**
* 刷新UI界面，重新加载账户偏好和同步按钮
*/
private void refreshUI() {
loadAccountPreference();
loadSyncButton();
}
/**
* 显示选择账户的对话框，允许用户选择已有账户或添加新账户
*/
private void showSelectAccountAlertDialog() {
AlertDialog.Builder dialogBuilder = new AlertDialog.Builder(this);
// 加载自定义标题视图
View titleView = LayoutInflater.from(this).inflate(R.layout.account_dialog_title, null);
TextView titleTextView = (TextView) titleView.findViewById(R.id.account_dialog_title);
titleTextView.setText(getString(R.string.preferences_dialog_select_account_title));
TextView subtitleTextView = (TextView) titleView.findViewById(R.id.account_dialog_subtitle);
subtitleTextView.setText(getString(R.string.preferences_dialog_select_account_tips));
// 设置对话框标题和空的确定按钮
dialogBuilder.setCustomTitle(titleView);
dialogBuilder.setPositiveButton(null, null);
// 获取所有Google账户
Account[] accounts = getGoogleAccounts();
String defAccount = getSyncAccountName(this);
// 保存原始账户列表和添加账户标志
mOriAccounts = accounts;
mHasAddedAccount = false;
if (accounts.length > 0) {
// 创建账户列表项
CharSequence[] items = new CharSequence[accounts.length];
final CharSequence[] itemMapping = items;
int checkedItem = -1;
int index = 0;
for (Account account : accounts) {
// 标记当前默认账户
if (TextUtils.equals(account.name, defAccount)) {
checkedItem = index;
}
items[index++] = account.name;
}
// 设置单选列表项和选择监听器
dialogBuilder.setSingleChoiceItems(items, checkedItem,
new DialogInterface.OnClickListener() {
public void onClick(DialogInterface dialog, int which) {
// 设置选择的账户为同步账户
setSyncAccount(itemMapping[which].toString());
dialog.dismiss();
refreshUI();
@ -306,17 +237,13 @@ public class NotesPreferenceActivity extends PreferenceActivity {
});
}
// 加载添加账户视图
View addAccountView = LayoutInflater.from(this).inflate(R.layout.add_account_text, null);
dialogBuilder.setView(addAccountView);
// 显示对话框并设置添加账户点击监听器
final AlertDialog dialog = dialogBuilder.show();
addAccountView.setOnClickListener(new View.OnClickListener() {
public void onClick(View v) {
// 标记已添加账户
mHasAddedAccount = true;
// 打开添加账户设置界面
Intent intent = new Intent("android.settings.ADD_ACCOUNT_SETTINGS");
intent.putExtra(AUTHORITIES_FILTER_KEY, new String[] {
"gmail-ls"
@ -327,13 +254,9 @@ public class NotesPreferenceActivity extends PreferenceActivity {
});
}
/**
* 显示更改账户的确认对话框，提醒用户更改账户的风险
*/
private void showChangeAccountConfirmAlertDialog() {
AlertDialog.Builder dialogBuilder = new AlertDialog.Builder(this);
// 加载自定义标题视图
View titleView = LayoutInflater.from(this).inflate(R.layout.account_dialog_title, null);
TextView titleTextView = (TextView) titleView.findViewById(R.id.account_dialog_title);
titleTextView.setText(getString(R.string.preferences_dialog_change_account_title,
@ -342,46 +265,31 @@ public class NotesPreferenceActivity extends PreferenceActivity {
subtitleTextView.setText(getString(R.string.preferences_dialog_change_account_warn_msg));
dialogBuilder.setCustomTitle(titleView);
// 创建菜单项数组
CharSequence[] menuItemArray = new CharSequence[] {
getString(R.string.preferences_menu_change_account),
getString(R.string.preferences_menu_remove_account),
getString(R.string.preferences_menu_cancel)
};
// 设置菜单项点击监听器
dialogBuilder.setItems(menuItemArray, new DialogInterface.OnClickListener() {
public void onClick(DialogInterface dialog, int which) {
if (which == 0) {
// 更改账户，显示账户选择对话框
showSelectAccountAlertDialog();
} else if (which == 1) {
// 移除账户
removeSyncAccount();
refreshUI();
}
}
});
// 显示对话框
dialogBuilder.show();
}
/**
* 获取设备上所有的Google账户
* @return Google账户数组
*/
private Account[] getGoogleAccounts() {
AccountManager accountManager = AccountManager.get(this);
return accountManager.getAccountsByType("com.google");
}
/**
* 设置同步账户，并清理相关的本地同步信息
* @param account 要设置的账户名
*/
private void setSyncAccount(String account) {
// 只有当账户名不同时才更新
if (!getSyncAccountName(this).equals(account)) {
// 更新账户偏好设置
SharedPreferences settings = getSharedPreferences(PREFERENCE_NAME, Context.MODE_PRIVATE);
SharedPreferences.Editor editor = settings.edit();
if (account != null) {
@ -391,10 +299,10 @@ public class NotesPreferenceActivity extends PreferenceActivity {
}
editor.commit();
// 清除最后同步时间
// clean up last sync time
setLastSyncTime(this, 0);
// 在后台线程中清除本地Google Tasks相关信息
// clean up local gtask related info
new Thread(new Runnable() {
public void run() {
ContentValues values = new ContentValues();
@ -404,18 +312,13 @@ public class NotesPreferenceActivity extends PreferenceActivity {
}
}).start();
// 显示设置成功提示
Toast.makeText(NotesPreferenceActivity.this,
getString(R.string.preferences_toast_success_set_accout, account),
Toast.LENGTH_SHORT).show();
}
}
/**
* 移除同步账户，并清理相关的本地同步信息
*/
private void removeSyncAccount() {
// 清除账户偏好设置和最后同步时间
SharedPreferences settings = getSharedPreferences(PREFERENCE_NAME, Context.MODE_PRIVATE);
SharedPreferences.Editor editor = settings.edit();
if (settings.contains(PREFERENCE_SYNC_ACCOUNT_NAME)) {
@ -426,7 +329,7 @@ public class NotesPreferenceActivity extends PreferenceActivity {
}
editor.commit();
// 在后台线程中清除本地Google Tasks相关信息
// clean up local gtask related info
new Thread(new Runnable() {
public void run() {
ContentValues values = new ContentValues();
@ -437,22 +340,12 @@ public class NotesPreferenceActivity extends PreferenceActivity {
}).start();
}
/**
* 获取当前同步账户名
* @param context 上下文
* @return 当前同步账户名，若无则返回空字符串
*/
public static String getSyncAccountName(Context context) {
SharedPreferences settings = context.getSharedPreferences(PREFERENCE_NAME,
Context.MODE_PRIVATE);
return settings.getString(PREFERENCE_SYNC_ACCOUNT_NAME, "");
}
/**
* 设置最后同步时间
* @param context 上下文
* @param time 最后同步时间的时间戳
*/
public static void setLastSyncTime(Context context, long time) {
SharedPreferences settings = context.getSharedPreferences(PREFERENCE_NAME,
Context.MODE_PRIVATE);
@ -461,32 +354,17 @@ public class NotesPreferenceActivity extends PreferenceActivity {
editor.commit();
}
/**
* 获取最后同步时间
* @param context 上下文
* @return 最后同步时间的时间戳，若无则返回0
*/
public static long getLastSyncTime(Context context) {
SharedPreferences settings = context.getSharedPreferences(PREFERENCE_NAME,
Context.MODE_PRIVATE);
return settings.getLong(PREFERENCE_LAST_SYNC_TIME, 0);
}
/**
* 同步状态广播接收器，监听同步状态变化并更新UI
*/
private class GTaskReceiver extends BroadcastReceiver {
/**
* 接收到广播时调用
* @param context 上下文
* @param intent 包含同步状态信息的意图
*/
@Override
public void onReceive(Context context, Intent intent) {
// 刷新UI
refreshUI();
// 如果正在同步，更新同步状态文本
if (intent.getBooleanExtra(GTaskSyncService.GTASK_SERVICE_BROADCAST_IS_SYNCING, false)) {
TextView syncStatus = (TextView) findViewById(R.id.prefenerece_sync_status_textview);
syncStatus.setText(intent
@ -496,15 +374,9 @@ public class NotesPreferenceActivity extends PreferenceActivity {
}
}
/**
* 处理选项菜单的点击事件
* @param item 被点击的菜单项
* @return true表示事件已处理，false表示未处理
*/
public boolean onOptionsItemSelected(MenuItem item) {
switch (item.getItemId()) {
case android.R.id.home:
// 点击返回按钮，返回笔记列表活动
Intent intent = new Intent(this, NotesListActivity.class);
intent.addFlags(Intent.FLAG_ACTIVITY_CLEAR_TOP);
startActivity(intent);

104
src/Notes-master/src/net/micode/notes/widget/NoteWidgetProvider.java
Unescape View File

@ -32,169 +32,101 @@ import net.micode.notes.tool.ResourceParser;
import net.micode.notes.ui.NoteEditActivity;
import net.micode.notes.ui.NotesListActivity;
/**
* 笔记小部件提供者抽象类
* 提供笔记桌面小部件的基础功能
*/
public abstract class NoteWidgetProvider extends AppWidgetProvider {
/** 数据库查询投影，包含笔记ID、背景颜色ID和摘要 */
public static final String [] PROJECTION = new String [] {
NoteColumns.ID, // 笔记ID
NoteColumns.BG_COLOR_ID, // 背景颜色ID
NoteColumns.SNIPPET // 笔记摘要
NoteColumns.ID,
NoteColumns.BG_COLOR_ID,
NoteColumns.SNIPPET
};
/** 投影列索引 - 笔记ID */
public static final int COLUMN_ID = 0;
/** 投影列索引 - 背景颜色ID */
public static final int COLUMN_BG_COLOR_ID = 1;
/** 投影列索引 - 笔记摘要 */
public static final int COLUMN_SNIPPET = 2;
/** 日志标签 */
private static final String TAG = "NoteWidgetProvider";
/**
* 当小部件被删除时调用，清除与该小部件关联的笔记信息
* @param context 上下文
* @param appWidgetIds 被删除的小部件ID数组
*/
@Override
public void onDeleted(Context context, int[] appWidgetIds) {
// 创建要更新的内容值，将WIDGET_ID设置为无效值
ContentValues values = new ContentValues();
values.put(NoteColumns.WIDGET_ID, AppWidgetManager.INVALID_APPWIDGET_ID);
// 遍历所有被删除的小部件ID
for (int i = 0; i < appWidgetIds.length; i++) {
// 更新与小部件关联且不在回收站中的笔记，清除其WIDGET_ID
context.getContentResolver().update(Notes.CONTENT_NOTE_URI,
values,
NoteColumns.WIDGET_ID + "=? AND " + NoteColumns.PARENT_ID + "<>?",
new String[] { String.valueOf(appWidgetIds[i]), String.valueOf(Notes.ID_TRASH_FOLER) });
NoteColumns.WIDGET_ID + "=?",
new String[] { String.valueOf(appWidgetIds[i])});
}
}
/**
* 获取与指定小部件关联的笔记信息
* @param context 上下文
* @param widgetId 小部件ID
* @return 包含笔记信息的Cursor，若无则返回null
*/
private Cursor getNoteWidgetInfo(Context context, int widgetId) {
// 查询与指定小部件ID关联且不在回收站中的笔记
return context.getContentResolver().query(Notes.CONTENT_NOTE_URI,
PROJECTION, // 查询的列
NoteColumns.WIDGET_ID + "=? AND " + NoteColumns.PARENT_ID + "<>?", // 查询条件
new String[] { String.valueOf(widgetId), String.valueOf(Notes.ID_TRASH_FOLER) }, // 参数值
null); // 排序方式
PROJECTION,
NoteColumns.WIDGET_ID + "=? AND " + NoteColumns.PARENT_ID + "<>?",
new String[] { String.valueOf(widgetId), String.valueOf(Notes.ID_TRASH_FOLER) },
null);
}
/**
* 更新小部件内容的公共方法，默认非隐私模式
* @param context 上下文
* @param appWidgetManager 小部件管理器
* @param appWidgetIds 要更新的小部件ID数组
*/
protected void update(Context context, AppWidgetManager appWidgetManager, int[] appWidgetIds) {
update(context, appWidgetManager, appWidgetIds, false);
}
/**
* 更新小部件内容的私有方法，支持隐私模式
* @param context 上下文
* @param appWidgetManager 小部件管理器
* @param appWidgetIds 要更新的小部件ID数组
* @param privacyMode 是否为隐私模式
*/
private void update(Context context, AppWidgetManager appWidgetManager, int[] appWidgetIds,
boolean privacyMode) {
// 遍历所有小部件ID
for (int i = 0; i < appWidgetIds.length; i++) {
// 只处理有效的小部件ID
if (appWidgetIds[i] != AppWidgetManager.INVALID_APPWIDGET_ID) {
// 默认背景颜色
int bgId = ResourceParser.getDefaultBgId(context);
String snippet = "";
// 创建跳转到笔记编辑活动的意图
Intent intent = new Intent(context, NoteEditActivity.class);
intent.setFlags(Intent.FLAG_ACTIVITY_SINGLE_TOP); // 避免创建新的活动实例
intent.putExtra(Notes.INTENT_EXTRA_WIDGET_ID, appWidgetIds[i]); // 传递小部件ID
intent.putExtra(Notes.INTENT_EXTRA_WIDGET_TYPE, getWidgetType()); // 传递小部件类型
intent.setFlags(Intent.FLAG_ACTIVITY_SINGLE_TOP);
intent.putExtra(Notes.INTENT_EXTRA_WIDGET_ID, appWidgetIds[i]);
intent.putExtra(Notes.INTENT_EXTRA_WIDGET_TYPE, getWidgetType());
// 获取与小部件关联的笔记信息
Cursor c = getNoteWidgetInfo(context, appWidgetIds[i]);
if (c != null && c.moveToFirst()) {
// 检查是否有多个笔记与同一小部件关联
if (c.getCount() > 1) {
Log.e(TAG, "Multiple message with same widget id:" + appWidgetIds[i]);
c.close();
return;
}
// 获取笔记信息
snippet = c.getString(COLUMN_SNIPPET);
bgId = c.getInt(COLUMN_BG_COLOR_ID);
intent.putExtra(Intent.EXTRA_UID, c.getLong(COLUMN_ID)); // 传递笔记ID
intent.setAction(Intent.ACTION_VIEW); // 设置操作为查看
intent.putExtra(Intent.EXTRA_UID, c.getLong(COLUMN_ID));
intent.setAction(Intent.ACTION_VIEW);
} else {
// 无关联笔记，显示默认提示文本
snippet = context.getResources().getString(R.string.widget_havenot_content);
intent.setAction(Intent.ACTION_INSERT_OR_EDIT); // 设置操作为插入或编辑
intent.setAction(Intent.ACTION_INSERT_OR_EDIT);
}
// 关闭Cursor
if (c != null) {
c.close();
}
// 创建RemoteViews以更新小部件UI
RemoteViews rv = new RemoteViews(context.getPackageName(), getLayoutId());
rv.setImageViewResource(R.id.widget_bg_image, getBgResourceId(bgId)); // 设置背景图片
intent.putExtra(Notes.INTENT_EXTRA_BACKGROUND_ID, bgId); // 传递背景颜色ID
rv.setImageViewResource(R.id.widget_bg_image, getBgResourceId(bgId));
intent.putExtra(Notes.INTENT_EXTRA_BACKGROUND_ID, bgId);
/**
* 生成待处理的意图，用于启动小部件的主活动
* Generate the pending intent to start host for the widget
*/
PendingIntent pendingIntent = null;
if (privacyMode) {
// 隐私模式下，显示访问模式提示并跳转到笔记列表
rv.setTextViewText(R.id.widget_text,
context.getString(R.string.widget_under_visit_mode));
pendingIntent = PendingIntent.getActivity(context, appWidgetIds[i], new Intent(
context, NotesListActivity.class), PendingIntent.FLAG_UPDATE_CURRENT);
} else {
// 正常模式下，显示笔记摘要并跳转到笔记编辑
rv.setTextViewText(R.id.widget_text, snippet);
pendingIntent = PendingIntent.getActivity(context, appWidgetIds[i], intent,
PendingIntent.FLAG_UPDATE_CURRENT);
}
// 设置小部件点击事件
rv.setOnClickPendingIntent(R.id.widget_text, pendingIntent);
// 更新小部件
appWidgetManager.updateAppWidget(appWidgetIds[i], rv);
}
}
}
/**
* 获取对应背景颜色ID的资源ID
* @param bgId 背景颜色ID
* @return 背景图片资源ID
*/
protected abstract int getBgResourceId(int bgId);
/**
* 获取小部件布局的资源ID
* @return 布局资源ID
*/
protected abstract int getLayoutId();
/**
* 获取小部件类型
* @return 小部件类型
*/
protected abstract int getWidgetType();
}

28
src/Notes-master/src/net/micode/notes/widget/NoteWidgetProvider_2x.java
Unescape View File

@ -23,49 +23,23 @@ import net.micode.notes.R;
import net.micode.notes.data.Notes;
import net.micode.notes.tool.ResourceParser;
/**
* 2x2笔记小部件提供者
* 提供2x2尺寸的桌面笔记小部件
*/
/**
* 2x2 大小的笔记小部件提供者
*/
public class NoteWidgetProvider_2x extends NoteWidgetProvider {
/**
* 当小部件需要更新时调用
* @param context 上下文
* @param appWidgetManager 小部件管理器
* @param appWidgetIds 要更新的小部件ID数组
*/
@Override
public void onUpdate(Context context, AppWidgetManager appWidgetManager, int[] appWidgetIds) {
// 调用父类的update方法更新小部件
super.update(context, appWidgetManager, appWidgetIds);
}
/**
* 获取2x2小部件的布局资源ID
* @return 布局资源ID
*/
@Override
protected int getLayoutId() {
return R.layout.widget_2x;
}
/**
* 获取2x2小部件对应背景颜色ID的资源ID
* @param bgId 背景颜色ID
* @return 背景图片资源ID
*/
@Override
protected int getBgResourceId(int bgId) {
return ResourceParser.WidgetBgResources.getWidget2xBgResource(bgId);
}
/**
* 获取2x2小部件的类型
* @return 小部件类型常量
*/
@Override
protected int getWidgetType() {
return Notes.TYPE_WIDGET_2X;

29
src/Notes-master/src/net/micode/notes/widget/NoteWidgetProvider_4x.java
Unescape View File

@ -23,49 +23,22 @@ import net.micode.notes.R;
import net.micode.notes.data.Notes;
import net.micode.notes.tool.ResourceParser;
/**
* 4x4笔记小部件提供者
* 提供4x4尺寸的桌面笔记小部件
*/
/**
* 4x4 大小的笔记小部件提供者
*/
public class NoteWidgetProvider_4x extends NoteWidgetProvider {
/**
* 当小部件需要更新时调用
* @param context 上下文
* @param appWidgetManager 小部件管理器
* @param appWidgetIds 要更新的小部件ID数组
*/
@Override
public void onUpdate(Context context, AppWidgetManager appWidgetManager, int[] appWidgetIds) {
// 调用父类的update方法更新小部件
super.update(context, appWidgetManager, appWidgetIds);
}
/**
* 获取4x4小部件的布局资源ID
* @return 布局资源ID
*/
@Override
protected int getLayoutId() {
return R.layout.widget_4x;
}
/**
* 获取4x4小部件对应背景颜色ID的资源ID
* @param bgId 背景颜色ID
* @return 背景图片资源ID
*/
@Override
protected int getBgResourceId(int bgId) {
return ResourceParser.WidgetBgResources.getWidget4xBgResource(bgId);
}
/**
* 获取4x4小部件的类型
* @return 小部件类型常量
*/
@Override
protected int getWidgetType() {
return Notes.TYPE_WIDGET_4X;

Write Preview
Loading…
Cancel
Save