tool,ui,widget类里的代码 #14

Merged
ple74bfj6 merged 3 commits from zhongkai_branch into develop 3 weeks ago

@ -41,38 +41,34 @@ public class BackupUtils {
// Singleton stuff
private static BackupUtils sInstance;
public static synchronized BackupUtils getInstance(Context context) {
//ynchronized 关键字,代表这个方法加锁,防止多进程混乱
if (sInstance == null) {
//如果当前备份不存在,则新声明一个
sInstance = new BackupUtils(context);
}
return sInstance;
}
/**
* Following states are signs to represents backup or restore
* status
*/
// Currently, the sdcard is not mounted
// 当前 SD 卡未挂载
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;
//初始化类将该类设置为context接口格式提供了访问资源、启动组件、获取系统服务、管理文件、执行权限检查等。
private BackupUtils(Context context) {
mTextExport = new TextExport(context);
}
// 获取外部存储的根目录便于进行api操作
private static boolean externalStorageAvailable() {
return Environment.MEDIA_MOUNTED.equals(Environment.getExternalStorageState());
}
// mTextExport是一个静态内部类,提供了导出功能
public int exportToText() {
return mTextExport.exportToText();
}
@ -86,20 +82,20 @@ public class BackupUtils {
}
private static class TextExport {
private static final String[] NOTE_PROJECTION = {
private static final String[] NOTE_PROJECTION = { //文本基础信息
NoteColumns.ID,
NoteColumns.MODIFIED_DATE,
NoteColumns.SNIPPET,
NoteColumns.SNIPPET, //文本片段
NoteColumns.TYPE
};
//定义类级别的常量.p s f下面的 数字代表在字符串中存储位置
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 = {
private static final String[] DATA_PROJECTION = { //数据基础信息,这个数据是啥数据???
DataColumns.CONTENT,
DataColumns.MIME_TYPE,
DataColumns.DATA1,
@ -110,7 +106,7 @@ public class BackupUtils {
private static final int DATA_COLUMN_CONTENT = 0;
private static final int DATA_COLUMN_MIME_TYPE = 1;
private static final int DATA_COLUMN_MIME_TYPE = 1; //导出笔记时,先查询这条笔记的 DATA_COLUMN_MIME_TYPE 值,判断格式
private static final int DATA_COLUMN_CALL_DATE = 2;
@ -126,7 +122,7 @@ public class BackupUtils {
private String mFileDirectory;
public TextExport(Context context) {
TEXT_FORMAT = context.getResources().getStringArray(R.array.format_for_exported_note);
TEXT_FORMAT = context.getResources().getStringArray(R.array.format_for_exported_note);//从array.xml里获取字符串数组信息
mContext = context;
mFileName = "";
mFileDirectory = "";
@ -137,33 +133,33 @@ public class BackupUtils {
}
/**
* Export the folder identified by folder id to text
* 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
folderId //引用的别的类的啥父母ID
}, null);
if (notesCursor != null) {
if (notesCursor.moveToFirst()) {
if (notesCursor != null) { //遍历cursor的数据
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))));
mContext.getString(R.string.format_datetime_mdhm), //R.string.xxx 是一个引用字符串资源的标识符,它直接指向资源文件中的字符串,用gststring执行
notesCursor.getLong(NOTE_COLUMN_MODIFIED_DATE)))); //getXXXX是结构
// Query data belong to this note
String noteId = notesCursor.getString(NOTE_COLUMN_ID);
exportNoteToText(noteId, ps);
} while (notesCursor.moveToNext());
} while (notesCursor.moveToNext()); //没有下一个就终止,代表数据遍历完毕
}
notesCursor.close();
}
}
/**
* Export note identified by id to a print stream
* 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,
@ -175,14 +171,14 @@ public class BackupUtils {
if (dataCursor.moveToFirst()) {
do {
String mimeType = dataCursor.getString(DATA_COLUMN_MIME_TYPE);
if (DataConstants.CALL_NOTE.equals(mimeType)) {
if (DataConstants.CALL_NOTE.equals(mimeType)) { //有电话的note
// 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),
ps.println(String.format(getFormat(FORMAT_NOTE_CONTENT), //在导出内容时把phoneNumber填充到 “笔记内容的格式模板” 并打印出来
phoneNumber));
}
// Print call date
@ -216,9 +212,10 @@ public class BackupUtils {
}
/**
* Note will be exported as text which is user readable
* 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;
@ -229,22 +226,22 @@ public class BackupUtils {
Log.e(TAG, "get print stream error");
return STATE_SYSTEM_ERROR;
}
// First export folder and its notes
// First export folder and its notes 输出在文件夹中的便签
Cursor folderCursor = mContext.getContentResolver().query(
Notes.CONTENT_NOTE_URI,
NOTE_PROJECTION,
"(" + NoteColumns.TYPE + "=" + Notes.TYPE_FOLDER + " AND "
+ NoteColumns.PARENT_ID + "<>" + Notes.ID_TRASH_FOLER + ") OR "
+ NoteColumns.ID + "=" + Notes.ID_CALL_RECORD_FOLDER, null, null);
+ NoteColumns.ID + "=" + Notes.ID_CALL_RECORD_FOLDER, null, null); //xinxi
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 {
if(folderCursor.getLong(NOTE_COLUMN_ID) == Notes.ID_CALL_RECORD_FOLDER) { //这个判断何意味为啥一个cursor一个context
folderName = mContext.getString(R.string.call_record_folder_name); //Context.getString 是 Android 中用于从资源文件中获取字符串的方法
} else { //cursor.getString 是 Android 中用于从数据库中获取字符串类型数据的方法
folderName = folderCursor.getString(NOTE_COLUMN_SNIPPET);
}
if (!TextUtils.isEmpty(folderName)) {
@ -257,7 +254,7 @@ public class BackupUtils {
folderCursor.close();
}
// Export notes in root's folder
// Export notes in root's folder,输出根目录中的便签
Cursor noteCursor = mContext.getContentResolver().query(
Notes.CONTENT_NOTE_URI,
NOTE_PROJECTION,
@ -279,15 +276,16 @@ public class BackupUtils {
}
ps.close();
return STATE_SUCCESS;
return STATE_SUCCESS; //都能对应上
}
/**
* Get a print stream pointed to the file {@generateExportedTextFile}
* 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);
R.string.file_name_txt_format); //建一个指向 SD 卡指定目录的 TXT 导出文件
if (file == null) {
Log.e(TAG, "create file to exported failed");
return null;
@ -295,9 +293,9 @@ public class BackupUtils {
mFileName = file.getName();
mFileDirectory = mContext.getString(R.string.file_path);
PrintStream ps = null;
try {
try { //try catch语法
FileOutputStream fos = new FileOutputStream(file);
ps = new PrintStream(fos);
ps = new PrintStream(fos); //返回操作该文件的 PrintStream 输出流
} catch (FileNotFoundException e) {
e.printStackTrace();
return null;
@ -310,25 +308,25 @@ public class BackupUtils {
}
/**
* Generate the text file to store imported data
* Generate the text file to store imported data TXT
*/
private static File generateFileMountedOnSDcard(Context context, int filePathResId, int fileNameFormatResId) {
StringBuilder sb = new StringBuilder();
sb.append(Environment.getExternalStorageDirectory());
sb.append(context.getString(filePathResId));
File filedir = new File(sb.toString());
sb.append(context.getString(
sb.append(context.getString(
fileNameFormatResId,
DateFormat.format(context.getString(R.string.format_date_ymd),
System.currentTimeMillis())));
File file = new File(sb.toString());
File file = new File(sb.toString()); //stringbuilder转成srting再写进file
try {
if (!filedir.exists()) {
filedir.mkdir();
filedir.mkdir(); //文件目录
}
if (!file.exists()) {
file.createNewFile();
file.createNewFile(); //文件
}
return file;
} catch (SecurityException e) {

@ -37,6 +37,7 @@ import java.util.HashSet;
public class DataUtils {
public static final String TAG = "DataUtils";
//批量操作删除便签发生错误就返回flase删除成功就返回true
public static boolean batchDeleteNotes(ContentResolver resolver, HashSet<Long> ids) {
if (ids == null) {
Log.d(TAG, "the ids is null");
@ -46,32 +47,34 @@ public class DataUtils {
Log.d(TAG, "no id is in the hashset");
return true;
}
// 构建删除操作拼接标签ID到标签ContentUR
ArrayList<ContentProviderOperation> operationList = new ArrayList<ContentProviderOperation>();
for (long id : ids) {
if(id == Notes.ID_ROOT_FOLDER) {
Log.e(TAG, "Don't delete system folder root");
continue;
}
ContentProviderOperation.Builder builder = ContentProviderOperation
.newDelete(ContentUris.withAppendedId(Notes.CONTENT_NOTE_URI, id));
//创建一个 ContentProviderOperation.Builder删除指定id的标签 只查询 ID 为 id 的那一条记录
operationList.add(builder.build());
}
try {
ContentProviderResult[] results = resolver.applyBatch(Notes.AUTHORITY, operationList);
if (results == null || results.length == 0 || results[0] == null) {
if (results == null || results.length == 0 || results[0] == null) {////上面的一条执行数据库操作删除并返回结果数组
Log.d(TAG, "delete notes failed, ids:" + ids.toString());
return false;
}
return true;
} catch (RemoteException e) {
} catch (RemoteException e) { //记录错误信息
Log.e(TAG, String.format("%s: %s", e.toString(), e.getMessage()));
} catch (OperationApplicationException e) {
Log.e(TAG, String.format("%s: %s", e.toString(), e.getMessage()));
}
return false;
}
//便签转进新文件夹
public static void moveNoteToFoler(ContentResolver resolver, long id, long srcFolderId, long desFolderId) {
ContentValues values = new ContentValues();
values.put(NoteColumns.PARENT_ID, desFolderId);
@ -79,7 +82,7 @@ public class DataUtils {
values.put(NoteColumns.LOCAL_MODIFIED, 1);
resolver.update(ContentUris.withAppendedId(Notes.CONTENT_NOTE_URI, id), values, null, null);
}
//批量操作便签转进新文件夹
public static boolean batchMoveToFolder(ContentResolver resolver, HashSet<Long> ids,
long folderId) {
if (ids == null) {
@ -90,7 +93,7 @@ public class DataUtils {
ArrayList<ContentProviderOperation> operationList = new ArrayList<ContentProviderOperation>();
for (long id : ids) {
ContentProviderOperation.Builder builder = ContentProviderOperation
.newUpdate(ContentUris.withAppendedId(Notes.CONTENT_NOTE_URI, id));
.newUpdate(ContentUris.withAppendedId(Notes.CONTENT_NOTE_URI, id)); //创建更新,
builder.withValue(NoteColumns.PARENT_ID, folderId);
builder.withValue(NoteColumns.LOCAL_MODIFIED, 1);
operationList.add(builder.build());
@ -110,11 +113,21 @@ public class DataUtils {
}
return false;
}
/**
* Get the all folder count except system folders {@link Notes#TYPE_SYSTEM}}
*/
public static int getUserFolderCount(ContentResolver resolver) {
public static int getUserFolderCount(ContentResolver resolver) {
//查询设备中「类型为文件夹TYPE_FOLDER」且「父文件夹 ID 不等于回收站 IDID_TRASH_FOLER」的文件夹总数。
'''
Cursor query(
Uri uri, // 要查询的数据 URI
String[] projection, // 要返回的列字段null 表示所有列
String selection, // WHERE 子句(不含 "WHERE" 关键字)
String[] selectionArgs, // WHERE 子句中占位符 ? 的实际值
String sortOrder // 排序方式(如 "date DESC"
);
'''
Cursor cursor =resolver.query(Notes.CONTENT_NOTE_URI,
new String[] { "COUNT(*)" },
NoteColumns.TYPE + "=? AND " + NoteColumns.PARENT_ID + "<>?",
@ -125,7 +138,7 @@ public class DataUtils {
if(cursor != null) {
if(cursor.moveToFirst()) {
try {
count = cursor.getInt(0);
count = cursor.getInt(0);//从当前游标指向的行中,读取第 0 列(第一列)的整数类型数据
} catch (IndexOutOfBoundsException e) {
Log.e(TAG, "get folder count failed:" + e.toString());
} finally {
@ -135,11 +148,11 @@ public class DataUtils {
}
return count;
}
//变迁是否可见(没进回收站)
public static boolean visibleInNoteDatabase(ContentResolver resolver, long noteId, int type) {
Cursor cursor = resolver.query(ContentUris.withAppendedId(Notes.CONTENT_NOTE_URI, noteId),
null,
NoteColumns.TYPE + "=? AND " + NoteColumns.PARENT_ID + "<>" + Notes.ID_TRASH_FOLER,
NoteColumns.TYPE + "=? AND " + NoteColumns.PARENT_ID + "<>" + Notes.ID_TRASH_FOLER, //笔记的 parent_id 不能等于回收站的 ID即不在回收站中
new String [] {String.valueOf(type)},
null);
@ -152,7 +165,7 @@ public class DataUtils {
}
return exist;
}
//便签还存在否
public static boolean existInNoteDatabase(ContentResolver resolver, long noteId) {
Cursor cursor = resolver.query(ContentUris.withAppendedId(Notes.CONTENT_NOTE_URI, noteId),
null, null, null, null);
@ -166,7 +179,7 @@ public class DataUtils {
}
return exist;
}
//便签数据还存在否
public static boolean existInDataDatabase(ContentResolver resolver, long dataId) {
Cursor cursor = resolver.query(ContentUris.withAppendedId(Notes.CONTENT_DATA_URI, dataId),
null, null, null, null);
@ -180,12 +193,12 @@ public class DataUtils {
}
return exist;
}
//查看是否存在一个名字是XX的文件夹
public static boolean checkVisibleFolderName(ContentResolver resolver, String name) {
Cursor cursor = resolver.query(Notes.CONTENT_NOTE_URI, null,
NoteColumns.TYPE + "=" + Notes.TYPE_FOLDER +
" AND " + NoteColumns.PARENT_ID + "<>" + Notes.ID_TRASH_FOLER +
" AND " + NoteColumns.SNIPPET + "=?",
NoteColumns.TYPE + "=" + Notes.TYPE_FOLDER + //类型是文件夹
" AND " + NoteColumns.PARENT_ID + "<>" + Notes.ID_TRASH_FOLER +//没进回收站
" AND " + NoteColumns.SNIPPET + "=?", //存储在snippet的名字和下面的name一样
new String[] { name }, null);
boolean exist = false;
if(cursor != null) {
@ -196,9 +209,9 @@ public class DataUtils {
}
return exist;
}
//获得文件夹下的便签,并仅返回它们的 Widget ID 和 Widget 类型
public static HashSet<AppWidgetAttribute> getFolderNoteWidget(ContentResolver resolver, long folderId) {
Cursor c = resolver.query(Notes.CONTENT_NOTE_URI,
Cursor c = resolver.query(Notes.CONTENT_NOTE_URI, //获得便签
new String[] { NoteColumns.WIDGET_ID, NoteColumns.WIDGET_TYPE },
NoteColumns.PARENT_ID + "=?",
new String[] { String.valueOf(folderId) },
@ -223,7 +236,7 @@ public class DataUtils {
}
return set;
}
//获得电话号
public static String getCallNumberByNoteId(ContentResolver resolver, long noteId) {
Cursor cursor = resolver.query(Notes.CONTENT_DATA_URI,
new String [] { CallNote.PHONE_NUMBER },
@ -233,7 +246,7 @@ public class DataUtils {
if (cursor != null && cursor.moveToFirst()) {
try {
return cursor.getString(0);
return cursor.getString(0); //返回电话号
} catch (IndexOutOfBoundsException e) {
Log.e(TAG, "Get call number fails " + e.toString());
} finally {
@ -242,7 +255,7 @@ public class DataUtils {
}
return "";
}
//通过电话号和日期查找便签
public static long getNoteIdByPhoneNumberAndCallDate(ContentResolver resolver, String phoneNumber, long callDate) {
Cursor cursor = resolver.query(Notes.CONTENT_DATA_URI,
new String [] { CallNote.NOTE_ID },
@ -263,7 +276,7 @@ public class DataUtils {
}
return 0;
}
//通过id获得名字
public static String getSnippetById(ContentResolver resolver, long noteId) {
Cursor cursor = resolver.query(Notes.CONTENT_NOTE_URI,
new String [] { NoteColumns.SNIPPET },
@ -281,13 +294,13 @@ public class DataUtils {
}
throw new IllegalArgumentException("Note is not found with id: " + noteId);
}
//从一段文本snippet中提取作为标题
public static String getFormattedSnippet(String snippet) {
if (snippet != null) {
snippet = snippet.trim();
int index = snippet.indexOf('\n');
snippet = snippet.trim();//清空无用制表符
int index = snippet.indexOf('\n');//index即录字符串中第一个换行符 \n 出现的位置
if (index != -1) {
snippet = snippet.substring(0, index);
snippet = snippet.substring(0, index);//只获取换行前的部分(核心)。
}
}
return snippet;

@ -15,7 +15,7 @@
*/
package net.micode.notes.tool;
//定义一些与 Google TasksGTaskJSON 数据交互相关的常量字符串,为与 Google Tasks 同步相关的 JSON 数据结构提供标准化的字段名常量便于在GTask上同步
public class GTaskStringUtils {
public final static String GTASK_JSON_ACTION_ID = "action_id";

@ -19,7 +19,7 @@ package net.micode.notes.tool;
import android.content.Context;
import android.preference.PreferenceManager;
import net.micode.notes.R;
import net.micode.notes.R; //资源文件夹中的文件被编译成R类的一部分R类在编译过程中会生成
import net.micode.notes.ui.NotesPreferenceActivity;
public class ResourceParser {
@ -40,6 +40,7 @@ public class ResourceParser {
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,
@ -47,7 +48,7 @@ public class ResourceParser {
R.drawable.edit_green,
R.drawable.edit_red
};
//引用标题颜色资源
private final static int [] BG_EDIT_TITLE_RESOURCES = new int [] {
R.drawable.edit_title_yellow,
R.drawable.edit_title_blue,
@ -55,7 +56,7 @@ public class ResourceParser {
R.drawable.edit_title_green,
R.drawable.edit_title_red
};
public static int getNoteBgResource(int id) {
return BG_EDIT_RESOURCES[id];
}
@ -66,15 +67,15 @@ public class ResourceParser {
}
public static int getDefaultBgId(Context context) {
if (PreferenceManager.getDefaultSharedPreferences(context).getBoolean(
NotesPreferenceActivity.PREFERENCE_SET_BG_COLOR_KEY, false)) {
if (PreferenceManager.getDefaultSharedPreferences(context).getBoolean( //获得一个实例,指向该偏好框架在给定上下文中使用的默认文件
NotesPreferenceActivity.PREFERENCE_SET_BG_COLOR_KEY, false)) { //如果没指定就随机给个颜色
return (int) (Math.random() * NoteBgResources.BG_EDIT_RESOURCES.length);
} else {
return BG_DEFAULT_COLOR;
}
}
public static class NoteItemBgResources {
public static class NoteItemBgResources { //便签主题资源
private final static int [] BG_FIRST_RESOURCES = new int [] {
R.drawable.list_yellow_up,
R.drawable.list_blue_up,

@ -39,42 +39,49 @@ import net.micode.notes.tool.DataUtils;
import java.io.IOException;
//继承Activity //承诺实现clickdismiss接口不继承功能
public class AlarmAlertActivity extends Activity implements OnClickListener, OnDismissListener {
private long mNoteId;
private String mSnippet;
private static final int SNIPPET_PREW_MAX_LEN = 60;
MediaPlayer mPlayer;
@Override
@Override //创建闹钟行为
protected void onCreate(Bundle savedInstanceState) {
//调用其父类Activity的onCreate方法来实现对界面的图画绘制工作。
super.onCreate(savedInstanceState);
//onSaveInstanceState()来保存当前activity的状态信息
requestWindowFeature(Window.FEATURE_NO_TITLE);
//final类似stactic获得窗口对象
final Window win = getWindow();
//为窗口添加各种标志flags从而改变窗口的行为和外观
//屏幕锁定时显示窗口,便于锁屏时启动闹钟
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
| WindowManager.LayoutParams.FLAG_LAYOUT_INSET_DECOR);
//LayoutParams 布局参数,规定子视图如何放置
if (!isScreenOn()) {//不锁平时
win.addFlags(WindowManager.LayoutParams.FLAG_KEEP_SCREEN_ON//当这个window对用户是可见状态,则保持设备屏幕不关闭且不变暗
| WindowManager.LayoutParams.FLAG_TURN_SCREEN_ON//当window被添加或者显示,系统会点亮屏幕,
| WindowManager.LayoutParams.FLAG_ALLOW_LOCK_WHILE_SCREEN_ON//允许在屏幕开启的时候锁定屏幕
| WindowManager.LayoutParams.FLAG_LAYOUT_INSET_DECOR);//插入window的矩形大小,来确保内容不会被装饰物(如状态栏)掩盖
}
Intent intent = getIntent();
try {
try { //传递到当前组件的 URI 数据截取Uri内的字符串的第二个“/”右边的字符及id
mNoteId = Long.valueOf(intent.getData().getPathSegments().get(1));
//根据ID从数据库中获取标签的内容
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;
} catch (IllegalArgumentException e) {
e.printStackTrace();
e.printStackTrace();// 将异常的详细信息输出到标准错误流
return;
}
mPlayer = new MediaPlayer();
//如果不在回收站就显示文字并发出声音
if (DataUtils.visibleInNoteDatabase(getContentResolver(), mNoteId, Notes.TYPE_NOTE)) {
showActionDialog();
playAlarmSound();
@ -83,26 +90,27 @@ public class AlarmAlertActivity extends Activity implements OnClickListener, OnD
}
}
private boolean isScreenOn() {
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 {
mPlayer.setAudioStreamType(AudioManager.STREAM_ALARM);
}
try {
mPlayer.setDataSource(this, url);
mPlayer.setDataSource(this, url);//指定播放文件的路径
mPlayer.prepare();
mPlayer.setLooping(true);
mPlayer.setLooping(true);//设置循环播放
mPlayer.start();
} catch (IllegalArgumentException e) {
// TODO Auto-generated catch block
@ -120,34 +128,35 @@ public class AlarmAlertActivity extends Activity implements OnClickListener, OnD
}
private void showActionDialog() {
//AlertDialog.Builder是对话框组件用于显示信息
AlertDialog.Builder dialog = new AlertDialog.Builder(this);
dialog.setTitle(R.string.app_name);
dialog.setMessage(mSnippet);
dialog.setPositiveButton(R.string.notealert_ok, this);
dialog.setPositiveButton(R.string.notealert_ok, this); //setPositive/Negative/NeutralButton()设置:确定,取消,中立按钮;
if (isScreenOn()) {
dialog.setNegativeButton(R.string.notealert_enter, this);
dialog.setNegativeButton(R.string.notealert_enter, this); //取消
}
dialog.show().setOnDismissListener(this);
dialog.show().setOnDismissListener(this); //设置关闭监听
}
//选择negative时执行跳转到笔记 那可能positive仅关闭弹窗
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);
intent.setAction(Intent.ACTION_VIEW);//执行安卓内置操作查看数据
intent.putExtra(Intent.EXTRA_UID, mNoteId);//向目标页面传递笔记的ID
startActivity(intent);//触发页面跳转
break;
default:
break;
}
}
//取消监听后操作
public void onDismiss(DialogInterface dialog) {
stopAlarmSound();
finish();
}
//取消声音
private void stopAlarmSound() {
if (mPlayer != null) {
mPlayer.stop();

@ -27,7 +27,7 @@ import android.database.Cursor;
import net.micode.notes.data.Notes;
import net.micode.notes.data.Notes.NoteColumns;
//广播接收器用于响应来自其他应用程序或者系统的广播消息(可以使事件)
public class AlarmInitReceiver extends BroadcastReceiver {
private static final String [] PROJECTION = new String [] {
@ -39,24 +39,31 @@ public class AlarmInitReceiver extends BroadcastReceiver {
private static final int COLUMN_ALERTED_DATE = 1;
@Override
public void onReceive(Context context, Intent intent) {
public void onReceive(Context context, Intent intent) { //设置接收装置
//获取当前时间的常用方法。它返回自 1970 年 1 月 1 日 00:00:00.000 到当前时刻的时间距离
long currentDate = System.currentTimeMillis();
//查询未到响应时间且是有提醒类型的便签
Cursor c = context.getContentResolver().query(Notes.CONTENT_NOTE_URI,
PROJECTION,
NoteColumns.ALERTED_DATE + ">? AND " + NoteColumns.TYPE + "=" + Notes.TYPE_NOTE,
new String[] { String.valueOf(currentDate) },
null);
if (c != null) {
if (c.moveToFirst()) {
do {
long alertDate = c.getLong(COLUMN_ALERTED_DATE);
//显示intent格式明确启动应用中的AlarmReceiver类
Intent sender = new Intent(context, AlarmReceiver.class);
//指定要访问的资源URI(这里的uir是把id和contentUri连接后成一个新的Uri)
sender.setData(ContentUris.withAppendedId(Notes.CONTENT_NOTE_URI, c.getLong(COLUMN_ID)));
//(满足特定条件但这里是0即没有)向BroadcastReceiver发送执行sender的广播
PendingIntent pendingIntent = PendingIntent.getBroadcast(context, 0, sender, 0);
//获取 AlarmManager
AlarmManager alermManager = (AlarmManager) context
.getSystemService(Context.ALARM_SERVICE);
//set(int typelong startTimePendingIntent pi) ,设置一次性定时器,到达时间执行完就没了
alermManager.set(AlarmManager.RTC_WAKEUP, alertDate, pendingIntent);
//闹钟在睡眠状态下会唤醒系统并执行提示功能
} while (c.moveToNext());
}
c.close();

@ -20,11 +20,11 @@ import android.content.BroadcastReceiver;
import android.content.Context;
import android.content.Intent;
public class AlarmReceiver extends BroadcastReceiver {
public class AlarmReceiver extends BroadcastReceiver {//闹钟响应广播接收者
@Override
public void onReceive(Context context, Intent intent) {
intent.setClass(context, AlarmAlertActivity.class);
intent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
context.startActivity(intent);
intent.setClass(context, AlarmAlertActivity.class); //启动闹钟响应的行为
intent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK);//启动一个新的任务栈,为何要启动新的???
context.startActivity(intent);//执行
}
}

@ -27,7 +27,7 @@ import android.text.format.DateFormat;
import android.view.View;
import android.widget.FrameLayout;
import android.widget.NumberPicker;
//FrameLayout 是 Android 布局容器之一,用于在屏幕上开辟一块区域,将子控件按照添加顺序进行层叠显示
public class DateTimePicker extends FrameLayout {
private static final boolean DEFAULT_ENABLE_STATE = true;
@ -45,56 +45,56 @@ public class DateTimePicker extends FrameLayout {
private static final int MINUT_SPINNER_MAX_VAL = 59;
private static final int AMPM_SPINNER_MIN_VAL = 0;
private static final int AMPM_SPINNER_MAX_VAL = 1;
//XX选择器设置
//这里定义的四个变量全部是在设置闹钟时需要选择的变量(如日期、时、分、上午或者下午)
private final NumberPicker mDateSpinner;
private final NumberPicker mHourSpinner;
private final NumberPicker mMinuteSpinner;
private final NumberPicker mAmPmSpinner;
private Calendar mDate;
private String[] mDateDisplayValues = new String[DAYS_IN_ALL_WEEK];
private boolean mIsAm;
private String[] mDateDisplayValues = new String[DAYS_IN_ALL_WEEK];//
private boolean mIsAm; //12小时制是否上午
private boolean mIs24HourView;
private boolean mIs24HourView;//24小时制
private boolean mIsEnabled = DEFAULT_ENABLE_STATE;
private boolean mIsEnabled = DEFAULT_ENABLE_STATE; //是否启动?
private boolean mInitialising;
private boolean mInitialising; //是否正在初始化?
private OnDateTimeChangedListener mOnDateTimeChangedListener;
private NumberPicker.OnValueChangeListener mOnDateChangedListener = new NumberPicker.OnValueChangeListener() {
private OnDateTimeChangedListener mOnDateTimeChangedListener; //自定义接口,创建接口类型变量,外部实现功能可以调用onDateTimeChanged了
//系统接口,自己实现功能,当用户滑动日期滚轮(比如从 5 号滑到 6 号系统会自动调用onValueChange方法
private NumberPicker.OnValueChangeListener mOnDateChangedListener = new NumberPicker.OnValueChangeListener() { //日期变更
@Override
public void onValueChange(NumberPicker picker, int oldVal, int newVal) {
public void onValueChange(NumberPicker picker, int oldVal, int newVal) {
mDate.add(Calendar.DAY_OF_YEAR, newVal - oldVal);
updateDateControl();
onDateTimeChanged();
updateDateControl();//更新日期
onDateTimeChanged();//触发自定义接口的回调(把事件传给外部)[实现方法不在此类],作用未知??
}
};
private NumberPicker.OnValueChangeListener mOnHourChangedListener = new NumberPicker.OnValueChangeListener() {
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) {
if (!mIsAm && oldVal == HOURS_IN_HALF_DAY - 1 && newVal == HOURS_IN_HALF_DAY) {
cal.setTimeInMillis(mDate.getTimeInMillis());
Calendar cal = Calendar.getInstance(); //获取现在的日历
if (!mIs24HourView) { //12小时制
if (!mIsAm && oldVal == HOURS_IN_HALF_DAY - 1 && newVal == HOURS_IN_HALF_DAY) { //从十一点多调整到第二天0点日期加一。
cal.setTimeInMillis(mDate.getTimeInMillis());// set time to 1970 年 1 月 1 日的 00:00:00.000到Calendar对象表示的时间之间的毫秒数 after january 1 1970
cal.add(Calendar.DAY_OF_YEAR, 1);
isDateChanged = true;
} else if (mIsAm && oldVal == HOURS_IN_HALF_DAY && newVal == HOURS_IN_HALF_DAY - 1) {
} else if (mIsAm && oldVal == HOURS_IN_HALF_DAY && newVal == HOURS_IN_HALF_DAY - 1) {//从0点多调整到昨天点日期加一。
cal.setTimeInMillis(mDate.getTimeInMillis());
cal.add(Calendar.DAY_OF_YEAR, -1);
isDateChanged = true;
}
if (oldVal == HOURS_IN_HALF_DAY - 1 && newVal == HOURS_IN_HALF_DAY ||
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 {
if (oldVal == HOURS_IN_ALL_DAY - 1 && newVal == 0) {
} else {//24小时制
if (oldVal == HOURS_IN_ALL_DAY - 1 && newVal == 0) {//同上面日期切换逻辑
cal.setTimeInMillis(mDate.getTimeInMillis());
cal.add(Calendar.DAY_OF_YEAR, 1);
isDateChanged = true;
@ -104,8 +104,8 @@ public class DateTimePicker extends FrameLayout {
isDateChanged = true;
}
}
int newHour = mHourSpinner.getValue() % HOURS_IN_HALF_DAY + (mIsAm ? 0 : HOURS_IN_HALF_DAY);
mDate.set(Calendar.HOUR_OF_DAY, newHour);
int newHour = mHourSpinner.getValue() % HOURS_IN_HALF_DAY + (mIsAm ? 0 : HOURS_IN_HALF_DAY);//24小时制的小时时间数
mDate.set(Calendar.HOUR_OF_DAY, newHour); //通过set函数将新的Hour值传给mDate
onDateTimeChanged();
if (isDateChanged) {
setCurrentYear(cal.get(Calendar.YEAR));
@ -115,18 +115,18 @@ public class DateTimePicker extends FrameLayout {
}
};
private NumberPicker.OnValueChangeListener mOnMinuteChangedListener = new NumberPicker.OnValueChangeListener() {
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;
int offset = 0; //分钟导致的的小时切换
if (oldVal == maxValue && newVal == minValue) {
offset += 1;
offset += 1; //小时加一
} else if (oldVal == minValue && newVal == maxValue) {
offset -= 1;
offset -= 1; //小时减一
}
if (offset != 0) {
if (offset != 0) { //更新小时时间
mDate.add(Calendar.HOUR_OF_DAY, offset);
mHourSpinner.setValue(getCurrentHour());
updateDateControl();
@ -139,44 +139,44 @@ public class DateTimePicker extends FrameLayout {
updateAmPmControl();
}
}
mDate.set(Calendar.MINUTE, newVal);
mDate.set(Calendar.MINUTE, newVal);//通过set函数将新的minutes值传给mDate
onDateTimeChanged();
}
};
private NumberPicker.OnValueChangeListener mOnAmPmChangedListener = new NumberPicker.OnValueChangeListener() {
private NumberPicker.OnValueChangeListener mOnAmPmChangedListener = new NumberPicker.OnValueChangeListener() {//上下午变更
@Override
public void onValueChange(NumberPicker picker, int oldVal, int newVal) {
mIsAm = !mIsAm;
if (mIsAm) {
mIsAm = !mIsAm;//为啥要变成否定的
if (mIsAm) {//下午变成上午了24小时制减去12
mDate.add(Calendar.HOUR_OF_DAY, -HOURS_IN_HALF_DAY);
} else {
mDate.add(Calendar.HOUR_OF_DAY, HOURS_IN_HALF_DAY);
} else {//上午变下午就加12除余
mDate.add(Calendar.HOUR_OF_DAY, HOURS_IN_HALF_DAY);//
}
updateAmPmControl();
onDateTimeChanged();
}
};
public interface OnDateTimeChangedListener {
public interface OnDateTimeChangedListener {//接口要求实现onDateTimeChanged
void onDateTimeChanged(DateTimePicker view, int year, int month,
int dayOfMonth, int hourOfDay, int minute);
}
public DateTimePicker(Context context) {
public DateTimePicker(Context context) {// 获得1970 年 1 月 1 日的 00:00:00.000到Calendar对象表示的时间之间的毫秒数
this(context, System.currentTimeMillis());
}
public DateTimePicker(Context context, long date) {
this(context, date, DateFormat.is24HourFormat(context));
this(context, date, DateFormat.is24HourFormat(context));//把上一个函数的毫秒改成24小时制的日期格式
}
public DateTimePicker(Context context, long date, boolean is24HourView) {
super(context);
super(context);//super是啥
mDate = Calendar.getInstance();
mInitialising = true;
mIsAm = getCurrentHourOfDay() >= HOURS_IN_HALF_DAY;
inflate(context, R.layout.datetime_picker, this);
inflate(context, R.layout.datetime_picker, this);//inflate的作用
mDateSpinner = (NumberPicker) findViewById(R.id.date);
mDateSpinner.setMinValue(DATE_SPINNER_MIN_VAL);
@ -188,14 +188,14 @@ public class DateTimePicker extends FrameLayout {
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);
String[] stringsForAmPm = new DateFormatSymbols().getAmPmStrings();
mAmPmSpinner = (NumberPicker) findViewById(R.id.amPm);
mAmPmSpinner.setMinValue(AMPM_SPINNER_MIN_VAL);
mAmPmSpinner.setMaxValue(AMPM_SPINNER_MAX_VAL);
mAmPmSpinner.setDisplayedValues(stringsForAmPm);
mAmPmSpinner.setDisplayedValues(stringsForAmPm);//设置展示的字符串
mAmPmSpinner.setOnValueChangedListener(mOnAmPmChangedListener);
// update controls to initial state
@ -208,7 +208,7 @@ public class DateTimePicker extends FrameLayout {
// set to current time
setCurrentDate(date);
setEnabled(isEnabled());
setEnabled(isEnabled());//?
// set the content descriptions
mInitialising = false;
@ -241,6 +241,7 @@ public class DateTimePicker extends FrameLayout {
return mDate.getTimeInMillis();
}
//两种不同的参数,对应不同的设置现在时间的方法
/**
* Set the current date
*
@ -426,58 +427,87 @@ public class DateTimePicker extends FrameLayout {
if (mIs24HourView == is24HourView) {
return;
}
mIs24HourView = is24HourView;
mIs24HourView = is24HourView; //spinner拉条 就是选am还是pm时候用的
mAmPmSpinner.setVisibility(is24HourView ? View.GONE : View.VISIBLE);
int hour = getCurrentHourOfDay();
updateHourControl();
setCurrentHour(hour);
updateAmPmControl();
}
//
/**
*
*
*/
private void updateDateControl() {
Calendar cal = Calendar.getInstance();
cal.setTimeInMillis(mDate.getTimeInMillis());
// 计算起始日期当前日期减去3天DAYS_IN_ALL_WEEK/2=3再减1天得到一周前的日期
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);
// 每次循环增加一天,生成一周内的日期
cal.add(Calendar.DAY_OF_YEAR, 1);
// 格式化日期为"MM.dd EEEE"格式例如05.20 星期一)
mDateDisplayValues[i] = (String) DateFormat.format("MM.dd EEEE", cal);
}
// 设置日期显示值到选择器
mDateSpinner.setDisplayedValues(mDateDisplayValues);
// 将选择器默认值设置为中间位置(即当前日期)
mDateSpinner.setValue(DAYS_IN_ALL_WEEK / 2);
// 刷新选择器显示
mDateSpinner.invalidate();
}
/**
* /
* 24/
*/
private void updateAmPmControl() {
if (mIs24HourView) {
// 24小时制下隐藏上午/下午选择器
mAmPmSpinner.setVisibility(View.GONE);
} else {
// 12小时制下根据当前是上午还是下午设置选择器值
int index = mIsAm ? Calendar.AM : Calendar.PM;
mAmPmSpinner.setValue(index);
// 显示上午/下午选择器
mAmPmSpinner.setVisibility(View.VISIBLE);
}
}
/**
*
* 24
*/
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);
}
}
/**
* Set the callback that indicates the 'Set' button has been pressed.
* @param callback the callback, if null will do nothing
*
*
* @param callback null
*/
public void setOnDateTimeChangedListener(OnDateTimeChangedListener callback) {
mOnDateTimeChangedListener = callback;
}
/**
*
*
*/
private void onDateTimeChanged() {
if (mOnDateTimeChangedListener != null) {
// 调用监听器的onDateTimeChanged方法传递当前选择的年、月、日、时、分
mOnDateTimeChangedListener.onDateTimeChanged(this, getCurrentYear(),
getCurrentMonth(), getCurrentDay(), getCurrentHourOfDay(), getCurrentMinute());
}

@ -28,37 +28,39 @@ import android.content.DialogInterface;
import android.content.DialogInterface.OnClickListener;
import android.text.format.DateFormat;
import android.text.format.DateUtils;
//对话框弹出
public class DateTimePickerDialog extends AlertDialog implements OnClickListener {
private Calendar mDate = Calendar.getInstance();
private boolean mIs24HourView;
private OnDateTimeSetListener mOnDateTimeSetListener;
private OnDateTimeSetListener mOnDateTimeSetListener; //设置时间的接口
private DateTimePicker mDateTimePicker;
public interface OnDateTimeSetListener {
public interface OnDateTimeSetListener {//实现接口的函数调用
void OnDateTimeSet(AlertDialog dialog, long date);
}
public DateTimePickerDialog(Context context, long date) {
super(context);
super(context);//访问AlertDialog的context
mDateTimePicker = new DateTimePicker(context);
setView(mDateTimePicker);
mDateTimePicker.setOnDateTimeChangedListener(new OnDateTimeChangedListener() {
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());
updateTitle(mDate.getTimeInMillis());//根据新的日期时间更新对话框标题
}
});
mDate.setTimeInMillis(date);
mDate.set(Calendar.SECOND, 0);
mDateTimePicker.setCurrentDate(mDate.getTimeInMillis());
setButton(context.getString(R.string.datetime_dialog_ok), this);
//下面三行是日期时间选择器初始化的核心逻辑
mDate.setTimeInMillis(date); //导入calendar时间
mDate.set(Calendar.SECOND, 0);//秒数设为0
mDateTimePicker.setCurrentDate(mDate.getTimeInMillis());//设置为当前时间
setButton(context.getString(R.string.datetime_dialog_ok), this);//设置了确认和取消按钮
setButton2(context.getString(R.string.datetime_dialog_cancel), (OnClickListener)null);
set24HourView(DateFormat.is24HourFormat(this.getContext()));
updateTitle(mDate.getTimeInMillis());
@ -68,20 +70,21 @@ public class DateTimePickerDialog extends AlertDialog implements OnClickListener
mIs24HourView = is24HourView;
}
public void setOnDateTimeSetListener(OnDateTimeSetListener callBack) {
mOnDateTimeSetListener = callBack;
public void setOnDateTimeSetListener(OnDateTimeSetListener callBack) { //设置时间的接口
mOnDateTimeSetListener = callBack;
}
private void updateTitle(long date) {
int flag =
int flag = //亮点,位掩码设计 返回了结果是一个包含所有标志位的整数作为时间显示格式
DateUtils.FORMAT_SHOW_YEAR |
DateUtils.FORMAT_SHOW_DATE |
DateUtils.FORMAT_SHOW_TIME;
flag |= mIs24HourView ? DateUtils.FORMAT_24HOUR : DateUtils.FORMAT_24HOUR;
setTitle(DateUtils.formatDateTime(this.getContext(), date, flag));
}
public void onClick(DialogInterface arg0, int arg1) {
//再并上24小时格式或12小时格式
flag |= mIs24HourView ? DateUtils.FORMAT_24HOUR : DateUtils.FORMAT_12HOUR; //错误应为12HOUR
setTitle(DateUtils.formatDateTime(this.getContext(), date, flag)); //设置对话框标题
} //日期时间的本地化格式化
public void onClick(DialogInterface arg0, int arg1) {//点击确认按钮时调用
if (mOnDateTimeSetListener != null) {
mOnDateTimeSetListener.OnDateTimeSet(this, mDate.getTimeInMillis());
}

@ -29,33 +29,35 @@ import net.micode.notes.R;
public class DropdownMenu {
private Button mButton;
private PopupMenu mPopupMenu;
private PopupMenu mPopupMenu; //弹窗菜单
private Menu mMenu;
public DropdownMenu(Context context, Button button, int menuId) {
mButton = button;
mButton.setBackgroundResource(R.drawable.dropdown_icon);
mButton.setBackgroundResource(R.drawable.dropdown_icon);//绘制下拉菜单图标
mPopupMenu = new PopupMenu(context, mButton);
mMenu = mPopupMenu.getMenu();
mPopupMenu.getMenuInflater().inflate(menuId, mMenu);
mButton.setOnClickListener(new OnClickListener() {
mMenu = mPopupMenu.getMenu();//获取弹窗菜单的菜单对象
mPopupMenu.getMenuInflater().inflate(menuId, mMenu);//获得菜单
//第一个参数用于指定我们通过哪一个资源文件来创建菜单menuId。
// 第二个参数用于指定我们的菜单项将添加到哪一个 Meau 对象中
mButton.setOnClickListener(new OnClickListener() {//设置下拉菜单图标点击事件
public void onClick(View v) {
mPopupMenu.show();
}
});
}
public void setOnDropdownMenuItemClickListener(OnMenuItemClickListener listener) {
public void setOnDropdownMenuItemClickListener(OnMenuItemClickListener listener) {//设置下拉菜单选项点击事件监听
if (mPopupMenu != null) {
mPopupMenu.setOnMenuItemClickListener(listener);
}
}
public MenuItem findItem(int id) {
public MenuItem findItem(int id) {//根据菜单项的ID查找菜单项
return mMenu.findItem(id);
}
public void setTitle(CharSequence title) {
public void setTitle(CharSequence title) {//设置下拉菜单图标上的文本
mButton.setText(title);
}
}

@ -28,8 +28,8 @@ import net.micode.notes.R;
import net.micode.notes.data.Notes;
import net.micode.notes.data.Notes.NoteColumns;
public class FoldersListAdapter extends CursorAdapter {
//将cursor对象数据加载到界面的适配器
public class FoldersListAdapter extends CursorAdapter {//将文件夹数据转换成视图
public static final String [] PROJECTION = {
NoteColumns.ID,
NoteColumns.SNIPPET
@ -39,41 +39,43 @@ public class FoldersListAdapter extends CursorAdapter {
public static final int NAME_COLUMN = 1;
public FoldersListAdapter(Context context, Cursor c) {
super(context, c);
super(context, c);//调用父类构造方法,初始化上下文和游标
// TODO Auto-generated constructor stub
}
@Override
public View newView(Context context, Cursor cursor, ViewGroup parent) {
return new FolderListItem(context);
public View newView(Context context, Cursor cursor, ViewGroup parent) {//创建新的视图
return new FolderListItem(context);//创建一个新的FolderListItem视图
}
@Override
public void bindView(View view, Context context, Cursor cursor) {
if (view instanceof FolderListItem) {
public void bindView(View view, Context context, Cursor cursor) {//绑定视图与数据
if (view instanceof FolderListItem) {//判断视图是否为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);
((FolderListItem) view).bind(folderName);//将文件夹名称绑定到FolderListItem视图
}
}
public String getFolderName(Context context, int position) {
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 {
//布局管理器 之一,属于 ViewGroup 的子类,用于 将子View按照线性方向排列
private class FolderListItem extends LinearLayout {//文件夹列表项视图
private TextView mName;
public FolderListItem(Context context) {
super(context);
inflate(context, R.layout.folder_list_item, this);
mName = (TextView) findViewById(R.id.tv_folder_name);
inflate(context, R.layout.folder_list_item, this);//对 LayoutInflater.inflate()的简化
//将R.layout.folder_list_item布局文件实例化并添加到当前视图FolderListItem
mName = (TextView) findViewById(R.id.tv_folder_name);//获取布局文件中的TextView控件
}
public void bind(String name) {
mName.setText(name);
mName.setText(name);//将文件夹名称设置到TextView中
}
}

@ -74,17 +74,17 @@ import java.util.regex.Pattern;
public class NoteEditActivity extends Activity implements OnClickListener,
NoteSettingChangedListener, OnTextViewChangeListener {
private class HeadViewHolder {
public TextView tvModified;
private class HeadViewHolder {//头视图持有者类???
public TextView tvModified;//文本修改
public ImageView ivAlertIcon;
public ImageView ivAlertIcon;//图像提醒按钮?
public TextView tvAlertDate;
public TextView tvAlertDate;//文本提醒日期?
public ImageView ibSetBgColor;
public ImageView ibSetBgColor;//设置背景颜色图像视图
}
private static final Map<Integer, Integer> sBgSelectorBtnsMap = new HashMap<Integer, Integer>();
private static final Map<Integer, Integer> sBgSelectorBtnsMap = new HashMap<Integer, Integer>();//背景颜色选择按钮映射
static {
sBgSelectorBtnsMap.put(R.id.iv_bg_yellow, ResourceParser.YELLOW);
sBgSelectorBtnsMap.put(R.id.iv_bg_red, ResourceParser.RED);
@ -92,7 +92,7 @@ public class NoteEditActivity extends Activity implements OnClickListener,
sBgSelectorBtnsMap.put(R.id.iv_bg_green, ResourceParser.GREEN);
sBgSelectorBtnsMap.put(R.id.iv_bg_white, ResourceParser.WHITE);
}
//上下是反的为啥构建双向印射关系方便根据颜色值获取对应的选择按钮ID比如当前背景是红的红的按钮就是按下去的或者根据选择按钮ID获取对应的颜色值
private static final Map<Integer, Integer> sBgSelectorSelectionMap = new HashMap<Integer, Integer>();
static {
sBgSelectorSelectionMap.put(ResourceParser.YELLOW, R.id.iv_bg_yellow_select);
@ -102,14 +102,14 @@ public class NoteEditActivity extends Activity implements OnClickListener,
sBgSelectorSelectionMap.put(ResourceParser.WHITE, R.id.iv_bg_white_select);
}
private static final Map<Integer, Integer> sFontSizeBtnsMap = new HashMap<Integer, Integer>();
private static final Map<Integer, Integer> sFontSizeBtnsMap = new HashMap<Integer, Integer>();//字体大小选择按钮映射
static {
sFontSizeBtnsMap.put(R.id.ll_font_large, ResourceParser.TEXT_LARGE);
sFontSizeBtnsMap.put(R.id.ll_font_small, ResourceParser.TEXT_SMALL);
sFontSizeBtnsMap.put(R.id.ll_font_normal, ResourceParser.TEXT_MEDIUM);
sFontSizeBtnsMap.put(R.id.ll_font_super, ResourceParser.TEXT_SUPER);
}
//同颜色的映射关系
private static final Map<Integer, Integer> sFontSelectorSelectionMap = new HashMap<Integer, Integer>();
static {
sFontSelectorSelectionMap.put(ResourceParser.TEXT_LARGE, R.id.iv_large_select);
@ -150,7 +150,7 @@ public class NoteEditActivity extends Activity implements OnClickListener,
private Pattern mPattern;
@Override
protected void onCreate(Bundle savedInstanceState) {
protected void onCreate(Bundle savedInstanceState) {//创建活动时调用
super.onCreate(savedInstanceState);
this.setContentView(R.layout.note_edit);
@ -158,19 +158,19 @@ public class NoteEditActivity extends Activity implements OnClickListener,
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
* user load this activity, we should restore the former state/
*/
@Override
protected void onRestoreInstanceState(Bundle savedInstanceState) {
super.onRestoreInstanceState(savedInstanceState);
protected void onRestoreInstanceState(Bundle savedInstanceState) {//存储uid便于恢复活动状态时调用
super.onRestoreInstanceState(savedInstanceState); //使用 Intent Extra 在组件之间传递uid
if (savedInstanceState != null && savedInstanceState.containsKey(Intent.EXTRA_UID)) {
Intent intent = new Intent(Intent.ACTION_VIEW);
intent.putExtra(Intent.EXTRA_UID, savedInstanceState.getLong(Intent.EXTRA_UID));
Intent intent = new Intent(Intent.ACTION_VIEW); //创建一个意图,用于显示笔记详情,大小是action_view显示数据功能
intent.putExtra(Intent.EXTRA_UID, savedInstanceState.getLong(Intent.EXTRA_UID));//将uid添加到意图中用于之后再调出来
if (!initActivityState(intent)) {
finish();
return;
@ -185,56 +185,56 @@ public class NoteEditActivity extends Activity implements OnClickListener,
* then jump to the NotesListActivity
*/
mWorkingNote = null;
if (TextUtils.equals(Intent.ACTION_VIEW, intent.getAction())) {
long noteId = intent.getLongExtra(Intent.EXTRA_UID, 0);
mUserQuery = "";
if (TextUtils.equals(Intent.ACTION_VIEW, intent.getAction())) {//如果意图是查看操作
long noteId = intent.getLongExtra(Intent.EXTRA_UID, 0);//获取uid
mUserQuery = "";//初始化用户查询,用于后续搜索
/**
* Starting from the searched result
*/
if (intent.hasExtra(SearchManager.EXTRA_DATA_KEY)) {
noteId = Long.parseLong(intent.getStringExtra(SearchManager.EXTRA_DATA_KEY));
mUserQuery = intent.getStringExtra(SearchManager.USER_QUERY);
if (intent.hasExtra(SearchManager.EXTRA_DATA_KEY)) {//如果意图包含搜索数据键
noteId = Long.parseLong(intent.getStringExtra(SearchManager.EXTRA_DATA_KEY));//解析出笔记id
mUserQuery = intent.getStringExtra(SearchManager.USER_QUERY);//解析出用户查询
}
if (!DataUtils.visibleInNoteDatabase(getContentResolver(), noteId, Notes.TYPE_NOTE)) {
if (!DataUtils.visibleInNoteDatabase(getContentResolver(), noteId, Notes.TYPE_NOTE)) {//如果笔记数据库中不存在该笔记
Intent jump = new Intent(this, NotesListActivity.class);
startActivity(jump);
showToast(R.string.error_note_not_exist);
startActivity(jump);//执行跳转
showToast(R.string.error_note_not_exist);//显示笔记不存在的提示
finish();
return false;
} else {
mWorkingNote = WorkingNote.load(this, noteId);
mWorkingNote = WorkingNote.load(this, noteId);//加载笔记
if (mWorkingNote == null) {
Log.e(TAG, "load note failed with note id" + noteId);
finish();
return false;
}
}
getWindow().setSoftInputMode(
WindowManager.LayoutParams.SOFT_INPUT_STATE_HIDDEN
| WindowManager.LayoutParams.SOFT_INPUT_ADJUST_RESIZE);
} else if(TextUtils.equals(Intent.ACTION_INSERT_OR_EDIT, intent.getAction())) {
getWindow().setSoftInputMode( //控制软键盘的操作?
WindowManager.LayoutParams.SOFT_INPUT_STATE_HIDDEN //隐藏
| WindowManager.LayoutParams.SOFT_INPUT_ADJUST_RESIZE);//调整布局
} else if(TextUtils.equals(Intent.ACTION_INSERT_OR_EDIT, intent.getAction())) {//如果意图是插入或编辑操作
// New note
long folderId = intent.getLongExtra(Notes.INTENT_EXTRA_FOLDER_ID, 0);
long folderId = intent.getLongExtra(Notes.INTENT_EXTRA_FOLDER_ID, 0);//获取文件夹id
int widgetId = intent.getIntExtra(Notes.INTENT_EXTRA_WIDGET_ID,
AppWidgetManager.INVALID_APPWIDGET_ID);
AppWidgetManager.INVALID_APPWIDGET_ID);//获取小部件id
int widgetType = intent.getIntExtra(Notes.INTENT_EXTRA_WIDGET_TYPE,
Notes.TYPE_WIDGET_INVALIDE);
Notes.TYPE_WIDGET_INVALIDE);//获取小部件类型
int bgResId = intent.getIntExtra(Notes.INTENT_EXTRA_BACKGROUND_ID,
ResourceParser.getDefaultBgId(this));
ResourceParser.getDefaultBgId(this));//获取背景资源id
// Parse call-record note
String phoneNumber = intent.getStringExtra(Intent.EXTRA_PHONE_NUMBER);
long callDate = intent.getLongExtra(Notes.INTENT_EXTRA_CALL_DATE, 0);
if (callDate != 0 && phoneNumber != null) {
String phoneNumber = intent.getStringExtra(Intent.EXTRA_PHONE_NUMBER);//获取电话号码
long callDate = intent.getLongExtra(Notes.INTENT_EXTRA_CALL_DATE, 0);//获取调用日期
if (callDate != 0 && phoneNumber != null) {//如果调用日期和电话号码都不为空
if (TextUtils.isEmpty(phoneNumber)) {
Log.w(TAG, "The call record number is null");
}
long noteId = 0;
long noteId = 0;//初始化笔记id
if ((noteId = DataUtils.getNoteIdByPhoneNumberAndCallDate(getContentResolver(),
phoneNumber, callDate)) > 0) {
mWorkingNote = WorkingNote.load(this, noteId);
phoneNumber, callDate)) > 0) {//如果记录中根据电话号码和调用日期查询到笔记id
mWorkingNote = WorkingNote.load(this, noteId);//加载笔记
if (mWorkingNote == null) {
Log.e(TAG, "load call note failed with note id" + noteId);
finish();
@ -242,15 +242,15 @@ public class NoteEditActivity extends Activity implements OnClickListener,
}
} else {
mWorkingNote = WorkingNote.createEmptyNote(this, folderId, widgetId,
widgetType, bgResId);
mWorkingNote.convertToCallNote(phoneNumber, callDate);
widgetType, bgResId);//新建笔记
mWorkingNote.convertToCallNote(phoneNumber, callDate);//将笔记转换为call笔记
}
} else {
mWorkingNote = WorkingNote.createEmptyNote(this, folderId, widgetId, widgetType,
bgResId);
bgResId);//新建笔记
}
getWindow().setSoftInputMode(
getWindow().setSoftInputMode(//设置软键盘操作
WindowManager.LayoutParams.SOFT_INPUT_ADJUST_RESIZE
| WindowManager.LayoutParams.SOFT_INPUT_STATE_VISIBLE);
} else {
@ -258,32 +258,32 @@ public class NoteEditActivity extends Activity implements OnClickListener,
finish();
return false;
}
mWorkingNote.setOnSettingStatusChangedListener(this);
mWorkingNote.setOnSettingStatusChangedListener(this);//设置笔记设置状态改变监听器
return true;
}
@Override
protected void onResume() {
protected void onResume() {//已经oncreate后切出再次调用时初始化笔记界面
super.onResume();
initNoteScreen();
}
private void initNoteScreen() {
mNoteEditor.setTextAppearance(this, TextAppearanceResources
.getTexAppearanceResource(mFontSizeId));
if (mWorkingNote.getCheckListMode() == TextNote.MODE_CHECK_LIST) {
switchToListMode(mWorkingNote.getContent());
.getTexAppearanceResource(mFontSizeId));//设置文本字体外观资源
if (mWorkingNote.getCheckListMode() == TextNote.MODE_CHECK_LIST) {//根据笔记模式( 清单模式 或 普通模式 )初始化编辑器内容
switchToListMode(mWorkingNote.getContent());//切换到列表清单模式
} else {
mNoteEditor.setText(getHighlightQueryResult(mWorkingNote.getContent(), mUserQuery));
mNoteEditor.setSelection(mNoteEditor.getText().length());
mNoteEditor.setText(getHighlightQueryResult(mWorkingNote.getContent(), mUserQuery));//设置文本内容为高亮查询结果
mNoteEditor.setSelection(mNoteEditor.getText().length());//将光标定位到文本末尾,方便用户继续编辑
}
for (Integer id : sBgSelectorSelectionMap.keySet()) {
for (Integer id : sBgSelectorSelectionMap.keySet()) {//隐藏所有背景色选择器的 选中状态指示器
findViewById(sBgSelectorSelectionMap.get(id)).setVisibility(View.GONE);
}
mHeadViewPanel.setBackgroundResource(mWorkingNote.getTitleBgResId());
mNoteEditorPanel.setBackgroundResource(mWorkingNote.getBgColorResId());
mHeadViewPanel.setBackgroundResource(mWorkingNote.getTitleBgResId());//设置笔记标题界面的 背景资源
mNoteEditorPanel.setBackgroundResource(mWorkingNote.getBgColorResId());
mNoteHeaderHolder.tvModified.setText(DateUtils.formatDateTime(this,
mNoteHeaderHolder.tvModified.setText(DateUtils.formatDateTime(this, //显示笔记的 最后修改日期 ,并格式化显示
mWorkingNote.getModifiedDate(), DateUtils.FORMAT_SHOW_DATE
| DateUtils.FORMAT_NUMERIC_DATE | DateUtils.FORMAT_SHOW_TIME
| DateUtils.FORMAT_SHOW_YEAR));
@ -295,14 +295,14 @@ public class NoteEditActivity extends Activity implements OnClickListener,
showAlertHeader();
}
private void showAlertHeader() {
private void showAlertHeader() {//显示笔记的 闹钟提醒 信息
if (mWorkingNote.hasClockAlert()) {
long time = System.currentTimeMillis();
if (time > mWorkingNote.getAlertDate()) {
mNoteHeaderHolder.tvAlertDate.setText(R.string.note_alert_expired);
mNoteHeaderHolder.tvAlertDate.setText(R.string.note_alert_expired);//显示已过期信息
} else {
mNoteHeaderHolder.tvAlertDate.setText(DateUtils.getRelativeTimeSpanString(
mWorkingNote.getAlertDate(), time, DateUtils.MINUTE_IN_MILLIS));
mWorkingNote.getAlertDate(), time, DateUtils.MINUTE_IN_MILLIS));//显示剩余时间信息
}
mNoteHeaderHolder.tvAlertDate.setVisibility(View.VISIBLE);
mNoteHeaderHolder.ivAlertIcon.setVisibility(View.VISIBLE);
@ -313,13 +313,13 @@ public class NoteEditActivity extends Activity implements OnClickListener,
}
@Override
protected void onNewIntent(Intent intent) {
protected void onNewIntent(Intent intent) {//处理新的intent
super.onNewIntent(intent);
initActivityState(intent);
}
@Override
protected void onSaveInstanceState(Bundle outState) {
protected void onSaveInstanceState(Bundle outState) {//保存活动状态
super.onSaveInstanceState(outState);
/**
* For new note without note id, we should firstly save it to
@ -334,23 +334,23 @@ public class NoteEditActivity extends Activity implements OnClickListener,
}
@Override
public boolean dispatchTouchEvent(MotionEvent ev) {
public boolean dispatchTouchEvent(MotionEvent ev) {//处理触摸事件
if (mNoteBgColorSelector.getVisibility() == View.VISIBLE
&& !inRangeOfView(mNoteBgColorSelector, ev)) {
mNoteBgColorSelector.setVisibility(View.GONE);
&& !inRangeOfView(mNoteBgColorSelector, ev)) {//如果背景色选择器可见,且触摸事件不在范围内?
mNoteBgColorSelector.setVisibility(View.GONE);//隐藏背景色选择器
return true;
}
if (mFontSizeSelector.getVisibility() == View.VISIBLE
&& !inRangeOfView(mFontSizeSelector, ev)) {
mFontSizeSelector.setVisibility(View.GONE);
&& !inRangeOfView(mFontSizeSelector, ev)) {//如果字体大小选择器可见,且触摸事件不在范围内?
mFontSizeSelector.setVisibility(View.GONE);//隐藏字体大小选择器
return true;
}
return super.dispatchTouchEvent(ev);
return super.dispatchTouchEvent(ev);//将事件传递给父类处理
}
private boolean inRangeOfView(View view, MotionEvent ev) {
int []location = new int[2];
private boolean inRangeOfView(View view, MotionEvent ev) {//判断触摸事件是否在视图范围内
int []location = new int[2];//获取视图在屏幕上的坐标长度为2的整数数组
view.getLocationOnScreen(location);
int x = location[0];
int y = location[1];
@ -363,7 +363,7 @@ public class NoteEditActivity extends Activity implements OnClickListener,
return true;
}
private void initResources() {
private void initResources() {//初始化资源
mHeadViewPanel = findViewById(R.id.note_title);
mNoteHeaderHolder = new HeadViewHolder();
mNoteHeaderHolder.tvModified = (TextView) findViewById(R.id.tv_modified_date);
@ -398,16 +398,16 @@ public class NoteEditActivity extends Activity implements OnClickListener,
}
@Override
protected void onPause() {
super.onPause();
protected void onPause() {//在活动暂停时调用(切出去了)
super.onPause();//调用父类的onPause方法
if(saveNote()) {
Log.d(TAG, "Note data was saved with length:" + mWorkingNote.getContent().length());
}
clearSettingState();
clearSettingState();//清除设置状态
}
private void updateWidget() {
Intent intent = new Intent(AppWidgetManager.ACTION_APPWIDGET_UPDATE);
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) {
@ -417,30 +417,31 @@ public class NoteEditActivity extends Activity implements OnClickListener,
return;
}
intent.putExtra(AppWidgetManager.EXTRA_APPWIDGET_IDS, new int[] {
intent.putExtra(AppWidgetManager.EXTRA_APPWIDGET_IDS, new int[] {//添加应用小部件id
mWorkingNote.getWidgetId()
});
sendBroadcast(intent);
setResult(RESULT_OK, intent);
sendBroadcast(intent);//发送广播更新应用小部件
setResult(RESULT_OK, intent);//设置结果为成功,返回意图
}
public void onClick(View v) {
public void onClick(View v) {//点击事件处理,语法细节没看
int id = v.getId();
if (id == R.id.btn_set_bg_color) {
if (id == R.id.btn_set_bg_color) {//如果点击的是设置背景颜色按钮
mNoteBgColorSelector.setVisibility(View.VISIBLE);
findViewById(sBgSelectorSelectionMap.get(mWorkingNote.getBgColorId())).setVisibility(
- View.VISIBLE);
} else if (sBgSelectorBtnsMap.containsKey(id)) {
} 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)) {
} 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());
@ -453,17 +454,17 @@ public class NoteEditActivity extends Activity implements OnClickListener,
}
@Override
public void onBackPressed() {
public void onBackPressed() {//返回键处理
if(clearSettingState()) {
return;
}
saveNote();
saveNote();//保存笔记
super.onBackPressed();
}
private boolean clearSettingState() {
if (mNoteBgColorSelector.getVisibility() == View.VISIBLE) {
private boolean clearSettingState() {//清除设置状态
if (mNoteBgColorSelector.getVisibility() == View.VISIBLE) {//
mNoteBgColorSelector.setVisibility(View.GONE);
return true;
} else if (mFontSizeSelector.getVisibility() == View.VISIBLE) {
@ -473,29 +474,29 @@ public class NoteEditActivity extends Activity implements OnClickListener,
return false;
}
public void onBackgroundColorChanged() {
public void onBackgroundColorChanged() {//
findViewById(sBgSelectorSelectionMap.get(mWorkingNote.getBgColorId())).setVisibility(
View.VISIBLE);
mNoteEditorPanel.setBackgroundResource(mWorkingNote.getBgColorResId());
mHeadViewPanel.setBackgroundResource(mWorkingNote.getTitleBgResId());
View.VISIBLE);//显示选中的背景颜色
mNoteEditorPanel.setBackgroundResource(mWorkingNote.getBgColorResId());//设置笔记编辑面板的背景颜色
mHeadViewPanel.setBackgroundResource(mWorkingNote.getTitleBgResId());//设置标题栏的背景颜色
}
@Override
public boolean onPrepareOptionsMenu(Menu menu) {
public boolean onPrepareOptionsMenu(Menu menu) {//准备选项菜单
if (isFinishing()) {
return true;
}
clearSettingState();
menu.clear();
if (mWorkingNote.getFolderId() == Notes.ID_CALL_RECORD_FOLDER) {
getMenuInflater().inflate(R.menu.call_note_edit, menu);
if (mWorkingNote.getFolderId() == Notes.ID_CALL_RECORD_FOLDER) {//判断类型
getMenuInflater().inflate(R.menu.call_note_edit, menu);//如果是通话记录文件夹, 通话记录转化为菜单
} else {
getMenuInflater().inflate(R.menu.note_edit, menu);
}
if (mWorkingNote.getCheckListMode() == TextNote.MODE_CHECK_LIST) {
menu.findItem(R.id.menu_list_mode).setTitle(R.string.menu_normal_mode);
menu.findItem(R.id.menu_list_mode).setTitle(R.string.menu_normal_mode);//如果是列表模式, 菜单标题为普通模式
} else {
menu.findItem(R.id.menu_list_mode).setTitle(R.string.menu_list_mode);
menu.findItem(R.id.menu_list_mode).setTitle(R.string.menu_list_mode);//如果不是列表模式, 菜单标题为列表模式
}
if (mWorkingNote.hasClockAlert()) {
menu.findItem(R.id.menu_alert).setVisible(false);
@ -506,13 +507,13 @@ public class NoteEditActivity extends Activity implements OnClickListener,
}
@Override
public boolean onOptionsItemSelected(MenuItem item) {
public boolean onOptionsItemSelected(MenuItem item) {//处理选项菜单点击事件
switch (item.getItemId()) {
case R.id.menu_new_note:
case R.id.menu_new_note://新建笔记
createNewNote();
break;
case R.id.menu_delete:
AlertDialog.Builder builder = new AlertDialog.Builder(this);
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);
builder.setMessage(getString(R.string.alert_message_delete_note));
@ -526,25 +527,25 @@ public class NoteEditActivity extends Activity implements OnClickListener,
builder.setNegativeButton(android.R.string.cancel, null);
builder.show();
break;
case R.id.menu_font_size:
case R.id.menu_font_size://字体大小选择
mFontSizeSelector.setVisibility(View.VISIBLE);
findViewById(sFontSelectorSelectionMap.get(mFontSizeId)).setVisibility(View.VISIBLE);
break;
case R.id.menu_list_mode:
case R.id.menu_list_mode://列表模式切换
mWorkingNote.setCheckListMode(mWorkingNote.getCheckListMode() == 0 ?
TextNote.MODE_CHECK_LIST : 0);
break;
case R.id.menu_share:
case R.id.menu_share://分享笔记
getWorkingText();
sendTo(this, mWorkingNote.getContent());
break;
case R.id.menu_send_to_desktop:
case R.id.menu_send_to_desktop://发送到桌面
sendToDesktop();
break;
case R.id.menu_alert:
case R.id.menu_alert://设置提醒
setReminder();
break;
case R.id.menu_delete_remind:
case R.id.menu_delete_remind://删除提醒
mWorkingNote.setAlertDate(0, false);
break;
default:
@ -552,7 +553,7 @@ public class NoteEditActivity extends Activity implements OnClickListener,
}
return true;
}
//下面是上文相关函数的具体实现
private void setReminder() {
DateTimePickerDialog d = new DateTimePickerDialog(this, System.currentTimeMillis());
d.setOnDateTimeSetListener(new OnDateTimeSetListener() {
@ -569,7 +570,7 @@ public class NoteEditActivity extends Activity implements OnClickListener,
*/
private void sendTo(Context context, String info) {
Intent intent = new Intent(Intent.ACTION_SEND);
intent.putExtra(Intent.EXTRA_TEXT, info);
intent.putExtra(Intent.EXTRA_TEXT, info);//再intetn中添加标签为EXTRA_TEXT 值为info
intent.setType("text/plain");
context.startActivity(intent);
}
@ -590,17 +591,17 @@ public class NoteEditActivity extends Activity implements OnClickListener,
if (mWorkingNote.existInDatabase()) {
HashSet<Long> ids = new HashSet<Long>();
long id = mWorkingNote.getNoteId();
if (id != Notes.ID_ROOT_FOLDER) {
ids.add(id);
if (id != Notes.ID_ROOT_FOLDER) {//如果不是根文件夹
ids.add(id);//将笔记id添加到集合中
} else {
Log.d(TAG, "Wrong note id, should not happen");
}
if (!isSyncMode()) {
if (!DataUtils.batchDeleteNotes(getContentResolver(), ids)) {
if (!isSyncMode()) {//如果不是同步模式
if (!DataUtils.batchDeleteNotes(getContentResolver(), ids)) {//批量删除笔记
Log.e(TAG, "Delete Note error");
}
} else {
if (!DataUtils.batchMoveToFolder(getContentResolver(), ids, Notes.ID_TRASH_FOLER)) {
if (!DataUtils.batchMoveToFolder(getContentResolver(), ids, Notes.ID_TRASH_FOLER)) {//将笔记移动到回收站文件夹
Log.e(TAG, "Move notes to trash folder error, should not happens");
}
}
@ -612,7 +613,7 @@ public class NoteEditActivity extends Activity implements OnClickListener,
return NotesPreferenceActivity.getSyncAccountName(this).trim().length() > 0;
}
public void onClockAlertChanged(long date, boolean set) {
public void onClockAlertChanged(long date, boolean set) {//设置提醒时间
/**
* User could set clock to an unsaved note, so before setting the
* alert clock, we should save the note first
@ -646,33 +647,34 @@ public class NoteEditActivity extends Activity implements OnClickListener,
updateWidget();
}
public void onEditTextDelete(int index, String text) {
int childCount = mEditTextList.getChildCount();
public void onEditTextDelete(int index, String text) {//处理清单模式下删除列表项 的操作
int childCount = mEditTextList.getChildCount();//获取编辑框的子视图数量
if (childCount == 1) {
return;
}
for (int i = index + 1; i < childCount; i++) {
for (int i = index + 1; i < childCount; i++) {//遍历删除项index处之后的所有列表项 将它们的索引减1不会影响到后续的列表项的索引从而避免了索引错乱的问题
((NoteEditText) mEditTextList.getChildAt(i).findViewById(R.id.et_edit_text))
.setIndex(i - 1);
}
mEditTextList.removeViewAt(index);
mEditTextList.removeViewAt(index);//删除index处的子图
//亮点:小米笔记清单模式下的特殊设计 ,属于防误删的安全机制 ,主要为了保护用户内容,这是啥意思?
NoteEditText edit = null;
if(index == 0) {
edit = (NoteEditText) mEditTextList.getChildAt(0).findViewById(
R.id.et_edit_text);
} else {
edit = (NoteEditText) mEditTextList.getChildAt(index - 1).findViewById(
R.id.et_edit_text);
R.id.et_edit_text);//
}
int length = edit.length();
edit.append(text);
edit.requestFocus();
edit.setSelection(length);
int length = edit.length();//获取删除项index处之前的列表项的文本长度
edit.append(text);//将被删除项的文本追加到目标项末尾
edit.requestFocus();//将焦点自动切换到目标项
edit.setSelection(length);//将光标定位到合并前的文本末尾
}
public void onEditTextEnter(int index, String text) {
public void onEditTextEnter(int index, String text) {//处理清单模式下添加列表项的操作
/**
* Should not happen, check for debug
*/
@ -681,40 +683,40 @@ public class NoteEditActivity extends Activity implements OnClickListener,
}
View view = getListItem(text, index);
mEditTextList.addView(view, index);
NoteEditText edit = (NoteEditText) view.findViewById(R.id.et_edit_text);
mEditTextList.addView(view, index);//将新的列表项视图添加到编辑框中位置为index
NoteEditText edit = (NoteEditText) view.findViewById(R.id.et_edit_text);//获取新添加的列表项的编辑框
edit.requestFocus();
edit.setSelection(0);
for (int i = index + 1; i < mEditTextList.getChildCount(); i++) {
edit.setSelection(0);//将光标定位到新添加的列表项的文本开头
for (int i = index + 1; i < mEditTextList.getChildCount(); i++) {//索引加一
((NoteEditText) mEditTextList.getChildAt(i).findViewById(R.id.et_edit_text))
.setIndex(i);
}
}
private void switchToListMode(String text) {
private void switchToListMode(String text) {//将编辑框切换到清单模式
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
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);
mNoteEditor.setVisibility(View.GONE);//隐藏编辑框
mEditTextList.setVisibility(View.VISIBLE);
}
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);
private Spannable getHighlightQueryResult(String fullText, String userQuery) {//高亮显示用户查询的文本这里用了spannable是比较好的视图管理器
SpannableString spannable = new SpannableString(fullText == null ? "" : fullText);//存储高亮显示的文本
if (!TextUtils.isEmpty(userQuery)) {
mPattern = Pattern.compile(userQuery, Pattern.CASE_INSENSITIVE);//编译正则表达式
Matcher m = mPattern.matcher(fullText);//创建一个 Matcher 对象,用于对输入字符串进行匹配操作
int start = 0;
while (m.find(start)) {
while (m.find(start)) { //构建span字符串
spannable.setSpan(
new BackgroundColorSpan(this.getResources().getColor(
R.color.user_query_highlight)), m.start(), m.end(),
@ -725,28 +727,28 @@ public class NoteEditActivity extends Activity implements OnClickListener,
return spannable;
}
private View getListItem(String item, int index) {
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);
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) {
if (isChecked) {
edit.setPaintFlags(edit.getPaintFlags() | Paint.STRIKE_THRU_TEXT_FLAG);
CheckBox cb = ((CheckBox) view.findViewById(R.id.cb_edit_item)); //复选框用于让用户从有限数量的选项中选择一个或多个选项。
cb.setOnCheckedChangeListener(new OnCheckedChangeListener() {//复选框变化监听
public void onCheckedChanged(CompoundButton buttonView, boolean isChecked) {//
if (isChecked) {//PaintFlags是Android中用于控制文本绘制样式的位掩码 ,通过位运算组合多个绘制标志
edit.setPaintFlags(edit.getPaintFlags() | Paint.STRIKE_THRU_TEXT_FLAG);//添加删除线效果
} else {
edit.setPaintFlags(Paint.ANTI_ALIAS_FLAG | Paint.DEV_KERN_TEXT_FLAG);
edit.setPaintFlags(Paint.ANTI_ALIAS_FLAG | Paint.DEV_KERN_TEXT_FLAG);//清除删除线效果
}
}
});
if (item.startsWith(TAG_CHECKED)) {
if (item.startsWith(TAG_CHECKED)) {//如果列表项以(TAG_CHECKED)开头,则将复选框设置为选中状态
cb.setChecked(true);
edit.setPaintFlags(edit.getPaintFlags() | Paint.STRIKE_THRU_TEXT_FLAG);
item = item.substring(TAG_CHECKED.length(), item.length()).trim();
edit.setPaintFlags(edit.getPaintFlags() | Paint.STRIKE_THRU_TEXT_FLAG);//
item = item.substring(TAG_CHECKED.length(), item.length()).trim();//
} else if (item.startsWith(TAG_UNCHECKED)) {
cb.setChecked(false);
edit.setPaintFlags(Paint.ANTI_ALIAS_FLAG | Paint.DEV_KERN_TEXT_FLAG);
edit.setPaintFlags(Paint.ANTI_ALIAS_FLAG | Paint.DEV_KERN_TEXT_FLAG);//
item = item.substring(TAG_UNCHECKED.length(), item.length()).trim();
}
@ -756,25 +758,25 @@ public class NoteEditActivity extends Activity implements OnClickListener,
return view;
}
public void onTextChange(int index, boolean hasText) {
if (index >= mEditTextList.getChildCount()) {
public void onTextChange(int index, boolean hasText) {// 列表项文本变化事件
if (index >= mEditTextList.getChildCount()) {//检查索引是否超出范围
Log.e(TAG, "Wrong index, should not happen");
return;
}
if(hasText) {
if(hasText) {//如果列表项有文本
mEditTextList.getChildAt(index).findViewById(R.id.cb_edit_item).setVisibility(View.VISIBLE);
} else {
mEditTextList.getChildAt(index).findViewById(R.id.cb_edit_item).setVisibility(View.GONE);
}
}
public void onCheckListModeChanged(int oldMode, int newMode) {
if (newMode == TextNote.MODE_CHECK_LIST) {
public void onCheckListModeChanged(int oldMode, int newMode) {// 检查列表模式变化事件
if (newMode == TextNote.MODE_CHECK_LIST) {//如果切换到检查列表模式
switchToListMode(mNoteEditor.getText().toString());
} else {
if (!getWorkingText()) {
mWorkingNote.setWorkingText(mWorkingNote.getContent().replace(TAG_UNCHECKED + " ",
""));
""));//如果没有选中项,则将所有未选中项的文本删除
}
mNoteEditor.setText(getHighlightQueryResult(mWorkingNote.getContent(), mUserQuery));
mEditTextList.setVisibility(View.GONE);
@ -782,19 +784,19 @@ public class NoteEditActivity extends Activity implements OnClickListener,
}
}
private boolean getWorkingText() {
private boolean getWorkingText() {//获取选中项的文本
boolean hasChecked = false;
if (mWorkingNote.getCheckListMode() == TextNote.MODE_CHECK_LIST) {
if (mWorkingNote.getCheckListMode() == TextNote.MODE_CHECK_LIST) {//如果是检查列表模式
StringBuilder sb = new StringBuilder();
for (int i = 0; i < mEditTextList.getChildCount(); i++) {
for (int i = 0; i < mEditTextList.getChildCount(); i++) {//遍历所有列表项
View view = mEditTextList.getChildAt(i);
NoteEditText edit = (NoteEditText) view.findViewById(R.id.et_edit_text);
if (!TextUtils.isEmpty(edit.getText())) {
if (((CheckBox) view.findViewById(R.id.cb_edit_item)).isChecked()) {
sb.append(TAG_CHECKED).append(" ").append(edit.getText()).append("\n");
sb.append(TAG_CHECKED).append(" ").append(edit.getText()).append("\n");//如果列表项选中,则将其文本添加到 StringBuilder 中
hasChecked = true;
} else {
sb.append(TAG_UNCHECKED).append(" ").append(edit.getText()).append("\n");
sb.append(TAG_UNCHECKED).append(" ").append(edit.getText()).append("\n");//如果列表项未选中,则将其文本添加到 StringBuilder 中
}
}
}
@ -805,7 +807,7 @@ public class NoteEditActivity extends Activity implements OnClickListener,
return hasChecked;
}
private boolean saveNote() {
private boolean saveNote() {//保存笔记
getWorkingText();
boolean saved = mWorkingNote.saveNote();
if (saved) {
@ -821,29 +823,29 @@ public class NoteEditActivity extends Activity implements OnClickListener,
return saved;
}
private void sendToDesktop() {
private void sendToDesktop() {//将笔记发送到桌面
/**
* Before send message to home, we should make sure that current
* editing note is exists in databases. So, for new note, firstly
* save it
*/
if (!mWorkingNote.existInDatabase()) {
if (!mWorkingNote.existInDatabase()) {//如果笔记不存在于数据库中
saveNote();
}
if (mWorkingNote.getNoteId() > 0) {
if (mWorkingNote.getNoteId() > 0) {//如果笔记存在于数据库中
Intent sender = new Intent();
Intent shortcutIntent = new Intent(this, NoteEditActivity.class);
shortcutIntent.setAction(Intent.ACTION_VIEW);
shortcutIntent.setAction(Intent.ACTION_VIEW);//设置意图操作行为为查看
shortcutIntent.putExtra(Intent.EXTRA_UID, mWorkingNote.getNoteId());
sender.putExtra(Intent.EXTRA_SHORTCUT_INTENT, shortcutIntent);
sender.putExtra(Intent.EXTRA_SHORTCUT_INTENT, shortcutIntent);//将意图添加到发送者意图中
sender.putExtra(Intent.EXTRA_SHORTCUT_NAME,
makeShortcutIconTitle(mWorkingNote.getContent()));
makeShortcutIconTitle(mWorkingNote.getContent()));//将快捷图标标题添加到发送者意图中
sender.putExtra(Intent.EXTRA_SHORTCUT_ICON_RESOURCE,
Intent.ShortcutIconResource.fromContext(this, R.drawable.icon_app));
sender.putExtra("duplicate", true);
sender.setAction("com.android.launcher.action.INSTALL_SHORTCUT");
showToast(R.string.info_note_enter_desktop);
sender.putExtra("duplicate", true);//将重复项添加到发送者意图中
sender.setAction("com.android.launcher.action.INSTALL_SHORTCUT");//设置意图操作行为为安装快捷图标
showToast(R.string.info_note_enter_desktop);//显示提示消息(成功)
sendBroadcast(sender);
} else {
/**
@ -856,18 +858,18 @@ public class NoteEditActivity extends Activity implements OnClickListener,
}
}
private String makeShortcutIconTitle(String content) {
private String makeShortcutIconTitle(String content) {//创建快捷图标标题
content = content.replace(TAG_CHECKED, "");
content = content.replace(TAG_UNCHECKED, "");
return content.length() > SHORTCUT_ICON_TITLE_MAX_LEN ? content.substring(0,
SHORTCUT_ICON_TITLE_MAX_LEN) : content;
}
private void showToast(int resId) {
showToast(resId, Toast.LENGTH_SHORT);
private void showToast(int resId) {//显示短时间的提示消息
showToast(resId, Toast.LENGTH_SHORT);//
}
private void showToast(int resId, int duration) {
private void showToast(int resId, int duration) {//显示自定义时间长度的 Toast 消息
Toast.makeText(this, resId, duration).show();
}
}

@ -37,73 +37,111 @@ import net.micode.notes.R;
import java.util.HashMap;
import java.util.Map;
/**
* AndroidEditText
* /
*/
public class NoteEditText extends EditText {
private static final String TAG = "NoteEditText";
private int mIndex;
private int mSelectionStartBeforeDelete;
private static final String TAG = "NoteEditText"; // 日志标签
private int mIndex; // 当前编辑框在容器中的索引位置
private int mSelectionStartBeforeDelete; // 删除操作前的光标起始位置
private static final String SCHEME_TEL = "tel:" ;
private static final String SCHEME_HTTP = "http:" ;
private static final String SCHEME_EMAIL = "mailto:" ;
// 支持的链接协议常量
private static final String SCHEME_TEL = "tel:" ; // 电话协议
private static final String SCHEME_HTTP = "http:" ; // HTTP协议
private static final String SCHEME_EMAIL = "mailto:" ; // 邮件协议
// 协议到字符串资源的映射表,用于上下文菜单显示
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); // 邮件链接菜单
}
/**
* Call by the {@link NoteEditActivity} to delete or add edit text
* NoteEditActivity
*/
public interface OnTextViewChangeListener {
/**
* Delete current edit text when {@link KeyEvent#KEYCODE_DEL} happens
* and the text is null
*
* @param index
* @param text
*/
void onEditTextDelete(int index, String text);
/**
* Add edit text after current edit text when {@link KeyEvent#KEYCODE_ENTER}
* happen
*
* @param index
* @param text
*/
void onEditTextEnter(int index, String text);
/**
* Hide or show item option when text change
*
* @param index
* @param hasText
*/
void onTextChange(int index, boolean hasText);
}
private OnTextViewChangeListener mOnTextViewChangeListener;
private OnTextViewChangeListener mOnTextViewChangeListener; // 文本变化监听器实例
/**
* NoteEditText
* @param context
*/
public NoteEditText(Context context) {
super(context, null);
mIndex = 0;
}
/**
*
* @param index
*/
public void setIndex(int index) {
mIndex = index;
}
/**
* NoteEditActivity
* @param listener
*/
public void setOnTextViewChangeListener(OnTextViewChangeListener listener) {
mOnTextViewChangeListener = listener;
}
/**
* XMLNoteEditText
* @param context
* @param attrs XML
*/
public NoteEditText(Context context, AttributeSet attrs) {
super(context, attrs, android.R.attr.editTextStyle);
}
/**
* XMLNoteEditText
* @param context
* @param attrs XML
* @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();
@ -114,22 +152,30 @@ public class NoteEditText extends EditText {
Layout layout = getLayout();
int line = layout.getLineForVertical(y);
int off = layout.getOffsetForHorizontal(line, x);
Selection.setSelection(getText(), off);
Selection.setSelection(getText(), off); // 设置光标位置
break;
}
return super.onTouchEvent(event);
}
/**
*
* @param keyCode
* @param event
* @return
*/
@Override
public boolean onKeyDown(int keyCode, KeyEvent event) {
switch (keyCode) {
case KeyEvent.KEYCODE_ENTER:
// 回车键按下时交由onKeyUp处理
if (mOnTextViewChangeListener != null) {
return false;
}
break;
case KeyEvent.KEYCODE_DEL:
// 记录删除前的光标位置
mSelectionStartBeforeDelete = getSelectionStart();
break;
default:
@ -138,10 +184,17 @@ 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());
@ -152,10 +205,14 @@ 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));
// 通知Activity添加新的编辑框
mOnTextViewChangeListener.onEditTextEnter(mIndex + 1, text);
} else {
Log.d(TAG, "OnTextViewChangeListener was not seted");
@ -167,9 +224,16 @@ 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) {
// 失去焦点且文本为空时通知Activity隐藏相关选项
if (!focused && TextUtils.isEmpty(getText())) {
mOnTextViewChangeListener.onTextChange(mIndex, false);
} else {
@ -179,6 +243,10 @@ public class NoteEditText extends EditText {
super.onFocusChanged(focused, direction, previouslyFocusedRect);
}
/**
*
* @param menu
*/
@Override
protected void onCreateContextMenu(ContextMenu menu) {
if (getText() instanceof Spanned) {
@ -188,8 +256,10 @@ public class NoteEditText extends EditText {
int min = Math.min(selStart, selEnd);
int max = Math.max(selStart, selEnd);
// 查找选中区域内的URLSpan
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) {
@ -202,10 +272,11 @@ public class NoteEditText extends EditText {
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;
}

@ -26,57 +26,76 @@ import net.micode.notes.data.Notes.NoteColumns;
import net.micode.notes.tool.DataUtils;
/**
* CursorJava
*
*/
public class NoteItemData {
/**
*
*/
static final String [] PROJECTION = new String [] {
NoteColumns.ID,
NoteColumns.ALERTED_DATE,
NoteColumns.BG_COLOR_ID,
NoteColumns.CREATED_DATE,
NoteColumns.HAS_ATTACHMENT,
NoteColumns.MODIFIED_DATE,
NoteColumns.NOTES_COUNT,
NoteColumns.PARENT_ID,
NoteColumns.SNIPPET,
NoteColumns.TYPE,
NoteColumns.WIDGET_ID,
NoteColumns.WIDGET_TYPE,
NoteColumns.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, // 小部件类型
};
private static final int ID_COLUMN = 0;
private static final int ALERTED_DATE_COLUMN = 1;
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;
private static final int PARENT_ID_COLUMN = 7;
private static final int SNIPPET_COLUMN = 8;
private static final int TYPE_COLUMN = 9;
private static final int WIDGET_ID_COLUMN = 10;
private static final int WIDGET_TYPE_COLUMN = 11;
private long mId;
private long mAlertDate;
private int mBgColorId;
private long mCreatedDate;
private boolean mHasAttachment;
private long mModifiedDate;
private int mNotesCount;
private long mParentId;
private String mSnippet;
private int mType;
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;
/**
* Cursor
*/
private static final int ID_COLUMN = 0; // 笔记ID
private static final int ALERTED_DATE_COLUMN = 1; // 提醒日期
private static final int BG_COLOR_ID_COLUMN = 2; // 背景颜色ID
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; // 文件夹包含的笔记数量
private static final int PARENT_ID_COLUMN = 7; // 父文件夹ID
private static final int SNIPPET_COLUMN = 8; // 笔记内容摘要
private static final int TYPE_COLUMN = 9; // 笔记类型
private static final int WIDGET_ID_COLUMN = 10; // 小部件ID
private static final int WIDGET_TYPE_COLUMN = 11; // 小部件类型
// 笔记基本属性
private long mId; // 笔记唯一标识符
private long mAlertDate; // 提醒日期时间
private int mBgColorId; // 背景颜色ID
private long mCreatedDate; // 创建日期时间
private boolean mHasAttachment; // 是否包含附件
private long mModifiedDate; // 最后修改日期时间
private int mNotesCount; // 文件夹包含的笔记数量
private long mParentId; // 所属父文件夹ID
private String mSnippet; // 笔记内容摘要
private int mType; // 笔记类型(普通笔记/文件夹/系统文件夹)
private int mWidgetId; // 关联的小部件ID
private int mWidgetType; // 小部件类型
// 通话记录相关属性
private String mName; // 通话记录联系人姓名
private String mPhoneNumber; // 通话记录电话号码
// 列表位置状态
private boolean mIsLastItem; // 是否为列表最后一项
private boolean mIsFirstItem; // 是否为列表第一项
private boolean mIsOnlyOneItem; // 是否为列表唯一一项
private boolean mIsOneNoteFollowingFolder; // 是否是文件夹下的唯一笔记
private boolean mIsMultiNotesFollowingFolder; // 是否是文件夹下的多个笔记之一
/**
* Cursor
* @param cursor Cursor
*/
public NoteItemData(Context context, Cursor cursor) {
// 读取基本笔记属性
mId = cursor.getLong(ID_COLUMN);
mAlertDate = cursor.getLong(ALERTED_DATE_COLUMN);
mBgColorId = cursor.getInt(BG_COLOR_ID_COLUMN);
@ -87,18 +106,21 @@ public class NoteItemData {
mParentId = cursor.getLong(PARENT_ID_COLUMN);
mSnippet = cursor.getString(SNIPPET_COLUMN);
mSnippet = mSnippet.replace(NoteEditActivity.TAG_CHECKED, "").replace(
NoteEditActivity.TAG_UNCHECKED, "");
NoteEditActivity.TAG_UNCHECKED, "");// 清除清单模式的标签标记
mType = cursor.getInt(TYPE_COLUMN);
mWidgetId = cursor.getInt(WIDGET_ID_COLUMN);
mWidgetType = cursor.getInt(WIDGET_TYPE_COLUMN);
// 处理通话记录相关属性
mPhoneNumber = "";
if (mParentId == Notes.ID_CALL_RECORD_FOLDER) {
// 获取通话记录的电话号码
mPhoneNumber = DataUtils.getCallNumberByNoteId(context.getContentResolver(), mId);
if (!TextUtils.isEmpty(mPhoneNumber)) {
// 获取联系人姓名
mName = Contact.getContact(context, mPhoneNumber);
if (mName == null) {
mName = mPhoneNumber;
mName = mPhoneNumber; // 无联系人时显示电话号码
}
}
}
@ -106,27 +128,37 @@ public class NoteItemData {
if (mName == null) {
mName = "";
}
// 检查并设置当前项在列表中的位置关系
checkPostion(cursor);
}
/**
*
*/
private void checkPostion(Cursor cursor) {
// 检查基本位置状态
mIsLastItem = cursor.isLast() ? true : false;
mIsFirstItem = cursor.isFirst() ? true : false;
mIsOnlyOneItem = (cursor.getCount() == 1);
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;
mIsMultiNotesFollowingFolder = true; // 文件夹后有多个笔记
} else {
mIsOneNoteFollowingFolder = true;
mIsOneNoteFollowingFolder = true; // 文件夹后只有一个笔记
}
}
// 恢复到原位置
if (!cursor.moveToNext()) {
throw new IllegalStateException("cursor move to previous but can't move back");
}
@ -134,90 +166,179 @@ public class NoteItemData {
}
}
/**
*
* @return truefalse
*/
public boolean isOneFollowingFolder() {
return mIsOneNoteFollowingFolder;
}
/**
*
* @return truefalse
*/
public boolean isMultiFollowingFolder() {
return mIsMultiNotesFollowingFolder;
}
/**
*
* @return truefalse
*/
public boolean isLast() {
return mIsLastItem;
}
/**
*
* @return
*/
public String getCallName() {
return mName;
}
/**
*
* @return truefalse
*/
public boolean isFirst() {
return mIsFirstItem;
}
/**
*
* @return truefalse
*/
public boolean isSingle() {
return mIsOnlyOneItem;
}
/**
* ID
* @return
*/
public long getId() {
return mId;
}
/**
*
* @return
*/
public long getAlertDate() {
return mAlertDate;
}
/**
*
* @return
*/
public long getCreatedDate() {
return mCreatedDate;
}
/**
*
* @return truefalse
*/
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;
}
/**
* IDgetParentId()
* @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 truefalse
*/
public boolean hasAlert() {
return (mAlertDate > 0);
}
/**
*
* @return truefalse
*/
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);
}

@ -78,65 +78,72 @@ 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 MENU_FOLDER_DELETE = 0;
private static final int MENU_FOLDER_VIEW = 1;
private static final int MENU_FOLDER_CHANGE_NAME = 2;
/**
* Token
*/
private static final int FOLDER_NOTE_LIST_QUERY_TOKEN = 0; // 查询文件夹下的笔记列表
private static final int FOLDER_LIST_QUERY_TOKEN = 1; // 查询文件夹列表
/**
* 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; // 重命名文件夹
/**
* SharedPreferences
*/
private static final String PREFERENCE_ADD_INTRODUCTION = "net.micode.notes.introduction";
/**
*
*/
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;
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 ListEditState mState; // 当前列表状态
private BackgroundQueryHandler mBackgroundQueryHandler; // 异步查询处理器,用于后台加载数据
private NotesListAdapter mNotesListAdapter; // 笔记列表适配器负责数据与UI的绑定
private ListView mNotesListView; // 显示笔记列表的ListView组件
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; // ListView滚动速率
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;
/**
* startActivityForResult
*/
private final static int REQUEST_CODE_OPEN_NODE = 102; // 打开笔记的请求码
private final static int REQUEST_CODE_NEW_NODE = 103; // 新建笔记的请求码
@Override
protected void onCreate(Bundle savedInstanceState) {
protected void onCreate(Bundle savedInstanceState) {// 初始化活动,设置布局和资源
super.onCreate(savedInstanceState);
setContentView(R.layout.note_list);
initResources();
@ -148,7 +155,7 @@ public class NotesListActivity extends Activity implements OnClickListener, OnIt
}
@Override
protected void onActivityResult(int requestCode, int resultCode, Intent data) {
protected void onActivityResult(int requestCode, int resultCode, Intent data) {// 处理子活动返回结果
if (resultCode == RESULT_OK
&& (requestCode == REQUEST_CODE_OPEN_NODE || requestCode == REQUEST_CODE_NEW_NODE)) {
mNotesListAdapter.changeCursor(null);
@ -157,20 +164,23 @@ public class NotesListActivity extends Activity implements OnClickListener, OnIt
}
}
/**
* 使
*/
private void setAppInfoFromRawRes() {
SharedPreferences sp = PreferenceManager.getDefaultSharedPreferences(this);
if (!sp.getBoolean(PREFERENCE_ADD_INTRODUCTION, false)) {
SharedPreferences sp = PreferenceManager.getDefaultSharedPreferences(this);// 亮点SharedPreferences 是Android平台上一个轻量级的存储类主要用于保存应用的一些常用配置。它通过键值对的形式将数据保存在XML文件中
if (!sp.getBoolean(PREFERENCE_ADD_INTRODUCTION, false)) {// 检查是否已添加介绍笔记
StringBuilder sb = new StringBuilder();
InputStream in = null;
try {
in = getResources().openRawResource(R.raw.introduction);
if (in != null) {
InputStreamReader isr = new InputStreamReader(in);
BufferedReader br = new BufferedReader(isr);
InputStreamReader isr = new InputStreamReader(in, "UTF-8");// 亮点指定字符编码为UTF-8确保能够正确读取包含特殊字符的文本文件
BufferedReader br = new BufferedReader(isr);// 亮点BufferedReader 是Java IO库中的一个字符流类用于读取字符数据。它提供了缓冲区的功能能够一次读取多个字符提高了读取效率。
char [] buf = new char[1024];
int len = 0;
while ((len = br.read(buf)) > 0) {
sb.append(buf, 0, len);
sb.append(buf, 0, len);//将读取到的字符数组buf中的0到len-1位置的字符添加到StringBuilder中
}
} else {
Log.e(TAG, "Read introduction file error");
@ -203,12 +213,18 @@ public class NotesListActivity extends Activity implements OnClickListener, OnIt
}
}
/**
*
*/
@Override
protected void onStart() {
super.onStart();
startAsyncNotesListQuery();
}
/**
* UI
*/
private void initResources() {
mContentResolver = this.getContentResolver();
mBackgroundQueryHandler = new BackgroundQueryHandler(this.getContentResolver());
@ -231,11 +247,23 @@ public class NotesListActivity extends Activity implements OnClickListener, OnIt
mModeCallBack = new ModeCallback();
}
/**
*
*/
private class ModeCallback implements ListView.MultiChoiceModeListener, OnMenuItemClickListener {
/** 下拉菜单,用于显示选择操作选项 */
private DropdownMenu mDropDownMenu;
/** ActionMode实例用于管理多选模式的生命周期 */
private ActionMode mActionMode;
/** 移动菜单项,用于批量移动笔记 */
private MenuItem mMoveMenu;
/**
*
* @param mode ActionMode
* @param menu
* @return
*/
public boolean onCreateActionMode(ActionMode mode, Menu menu) {
getMenuInflater().inflate(R.menu.note_list_options, menu);
menu.findItem(R.id.delete).setOnMenuItemClickListener(this);
@ -269,12 +297,12 @@ public class NotesListActivity extends Activity implements OnClickListener, OnIt
return true;
}
private void updateMenu() {
private void updateMenu() {// 更新下拉菜单显示的选中项数量
int selectedCount = mNotesListAdapter.getSelectedCount();
// Update dropdown menu
String format = getResources().getString(R.string.menu_select_title, selectedCount);
mDropDownMenu.setTitle(format);
MenuItem item = mDropDownMenu.findItem(R.id.action_select_all);
MenuItem item = mDropDownMenu.findItem(R.id.action_select_all);// 查找选择所有项的菜单项
if (item != null) {
if (mNotesListAdapter.isAllSelected()) {
item.setChecked(true);
@ -286,33 +314,33 @@ public class NotesListActivity extends Activity implements OnClickListener, OnIt
}
}
public boolean onPrepareActionMode(ActionMode mode, Menu menu) {
public boolean onPrepareActionMode(ActionMode mode, Menu menu) {// 准备多选模式时的操作
// TODO Auto-generated method stub
return false;
}
public boolean onActionItemClicked(ActionMode mode, MenuItem item) {
public boolean onActionItemClicked(ActionMode mode, MenuItem item) {// 处理下拉菜单项点击事件
// TODO Auto-generated method stub
return false;
}
public void onDestroyActionMode(ActionMode mode) {
public void onDestroyActionMode(ActionMode mode) {// 多选模式结束时的操作
mNotesListAdapter.setChoiceMode(false);
mNotesListView.setLongClickable(true);
mAddNewNote.setVisibility(View.VISIBLE);
}
public void finishActionMode() {
public void finishActionMode() {// 结束多选模式
mActionMode.finish();
}
public void onItemCheckedStateChanged(ActionMode mode, int position, long id,
boolean checked) {
boolean checked) {// 处理列表项选中状态改变事件注意actionmode的生命周期
mNotesListAdapter.setCheckedItem(position, checked);
updateMenu();
}
public boolean onMenuItemClick(MenuItem item) {
public boolean onMenuItemClick(MenuItem item) {// 处理下拉菜单项点击事件
if (mNotesListAdapter.getSelectedCount() == 0) {
Toast.makeText(NotesListActivity.this, getString(R.string.menu_select_none),
Toast.LENGTH_SHORT).show();
@ -346,8 +374,7 @@ public class NotesListActivity extends Activity implements OnClickListener, OnIt
}
}
private class NewNoteOnTouchListener implements OnTouchListener {
private class NewNoteOnTouchListener implements OnTouchListener {// 处理"新建笔记"按钮的触摸事件
public boolean onTouch(View v, MotionEvent event) {
switch (event.getAction()) {
case MotionEvent.ACTION_DOWN: {
@ -359,7 +386,7 @@ public class NotesListActivity extends Activity implements OnClickListener, OnIt
/**
* Minus TitleBar's height
*/
if (mState == ListEditState.SUB_FOLDER) {
if (mState == ListEditState.SUB_FOLDER) {// 如果当前状态是子文件夹
eventY -= mTitleBar.getHeight();
start -= mTitleBar.getHeight();
}
@ -372,11 +399,11 @@ public class NotesListActivity extends Activity implements OnClickListener, OnIt
* 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)) {
if (event.getY() < (event.getX() * (-0.12) + 94)) {// 如果点击位置在"新建笔记"按钮的透明部分
View view = mNotesListView.getChildAt(mNotesListView.getChildCount() - 1
- mNotesListView.getFooterViewsCount());
- mNotesListView.getFooterViewsCount());// 获取列表项的底部视图
if (view != null && view.getBottom() > start
&& (view.getTop() < (start + 94))) {
&& (view.getTop() < (start + 94))) {// 如果点击位置在"新建笔记"按钮的透明部分且在列表项范围内
mOriginY = (int) event.getY();
mDispatchY = eventY;
event.setLocation(event.getX(), mDispatchY);
@ -386,7 +413,7 @@ public class NotesListActivity extends Activity implements OnClickListener, OnIt
}
break;
}
case MotionEvent.ACTION_MOVE: {
case MotionEvent.ACTION_MOVE: {// 处理"新建笔记"按钮的移动事件
if (mDispatch) {
mDispatchY += (int) event.getY() - mOriginY;
event.setLocation(event.getX(), mDispatchY);
@ -394,7 +421,7 @@ public class NotesListActivity extends Activity implements OnClickListener, OnIt
}
break;
}
default: {
default: {// 处理"新建笔记"按钮的其他事件
if (mDispatch) {
event.setLocation(event.getX(), mDispatchY);
mDispatch = false;
@ -408,27 +435,44 @@ public class NotesListActivity extends Activity implements OnClickListener, OnIt
};
/**
*
* ID使
*/
private void startAsyncNotesListQuery() {
String selection = (mCurrentFolderId == Notes.ID_ROOT_FOLDER) ? ROOT_FOLDER_SELECTION
: NORMAL_SELECTION;
mBackgroundQueryHandler.startQuery(FOLDER_NOTE_LIST_QUERY_TOKEN, null,
Notes.CONTENT_NOTE_URI, NoteItemData.PROJECTION, selection, new String[] {
String.valueOf(mCurrentFolderId)
}, NoteColumns.TYPE + " DESC," + NoteColumns.MODIFIED_DATE + " DESC");
}, NoteColumns.TYPE + " DESC," + NoteColumns.MODIFIED_DATE + " DESC" );// 按类型和修改日期排序
}
/**
*
*/
private final class BackgroundQueryHandler extends AsyncQueryHandler {
/**
*
* @param contentResolver 访
*/
public BackgroundQueryHandler(ContentResolver contentResolver) {
super(contentResolver);
}
/**
*
* @param token
* @param cookie
* @param cursor
*/
@Override
protected void onQueryComplete(int token, Object cookie, Cursor cursor) {
switch (token) {
case FOLDER_NOTE_LIST_QUERY_TOKEN:
case FOLDER_NOTE_LIST_QUERY_TOKEN:// 查询笔记列表
mNotesListAdapter.changeCursor(cursor);
break;
case FOLDER_LIST_QUERY_TOKEN:
case FOLDER_LIST_QUERY_TOKEN:// 查询文件夹列表
if (cursor != null && cursor.getCount() > 0) {
showFolderListMenu(cursor);
} else {
@ -441,7 +485,7 @@ public class NotesListActivity extends Activity implements OnClickListener, OnIt
}
}
private void showFolderListMenu(Cursor cursor) {
private void showFolderListMenu(Cursor cursor) {// 显示文件夹列表菜单
AlertDialog.Builder builder = new AlertDialog.Builder(NotesListActivity.this);
builder.setTitle(R.string.menu_title_select_folder);
final FoldersListAdapter adapter = new FoldersListAdapter(this, cursor);
@ -462,14 +506,14 @@ public class NotesListActivity extends Activity implements OnClickListener, OnIt
builder.show();
}
private void createNewNote() {
private void createNewNote() {// 创建新笔记
Intent intent = new Intent(this, NoteEditActivity.class);
intent.setAction(Intent.ACTION_INSERT_OR_EDIT);
intent.putExtra(Notes.INTENT_EXTRA_FOLDER_ID, mCurrentFolderId);
this.startActivityForResult(intent, REQUEST_CODE_NEW_NODE);
}
private void batchDelete() {
private void batchDelete() {// 批量删除笔记
new AsyncTask<Void, Void, HashSet<AppWidgetAttribute>>() {
protected HashSet<AppWidgetAttribute> doInBackground(Void... unused) {
HashSet<AppWidgetAttribute> widgets = mNotesListAdapter.getSelectedWidget();
@ -492,7 +536,7 @@ public class NotesListActivity extends Activity implements OnClickListener, OnIt
}
@Override
protected void onPostExecute(HashSet<AppWidgetAttribute> widgets) {
protected void onPostExecute(HashSet<AppWidgetAttribute> widgets) {// 批量删除笔记完成后的回调处理
if (widgets != null) {
for (AppWidgetAttribute widget : widgets) {
if (widget.widgetId != AppWidgetManager.INVALID_APPWIDGET_ID
@ -506,7 +550,7 @@ public class NotesListActivity extends Activity implements OnClickListener, OnIt
}.execute();
}
private void deleteFolder(long folderId) {
private void deleteFolder(long folderId) {// 删除文件夹
if (folderId == Notes.ID_ROOT_FOLDER) {
Log.e(TAG, "Wrong folder id, should not happen " + folderId);
return;
@ -533,14 +577,14 @@ public class NotesListActivity extends Activity implements OnClickListener, OnIt
}
}
private void openNode(NoteItemData data) {
private void openNode(NoteItemData data) {// 打开笔记
Intent intent = new Intent(this, NoteEditActivity.class);
intent.setAction(Intent.ACTION_VIEW);
intent.putExtra(Intent.EXTRA_UID, data.getId());
this.startActivityForResult(intent, REQUEST_CODE_OPEN_NODE);
}
private void openFolder(NoteItemData data) {
private void openFolder(NoteItemData data) {// 打开文件夹
mCurrentFolderId = data.getId();
startAsyncNotesListQuery();
if (data.getId() == Notes.ID_CALL_RECORD_FOLDER) {
@ -567,19 +611,19 @@ public class NotesListActivity extends Activity implements OnClickListener, OnIt
}
}
private void showSoftInput() {
private void showSoftInput() {// 显示软键盘
InputMethodManager inputMethodManager = (InputMethodManager) getSystemService(Context.INPUT_METHOD_SERVICE);
if (inputMethodManager != null) {
inputMethodManager.toggleSoftInput(InputMethodManager.SHOW_FORCED, 0);
}
}
private void hideSoftInput(View view) {
private void hideSoftInput(View view) {// 隐藏软键盘
InputMethodManager inputMethodManager = (InputMethodManager) getSystemService(Context.INPUT_METHOD_SERVICE);
inputMethodManager.hideSoftInputFromWindow(view.getWindowToken(), 0);
}
private void showCreateOrModifyFolderDialog(final boolean 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);
final EditText etName = (EditText) view.findViewById(R.id.et_foler_name);
@ -606,7 +650,7 @@ public class NotesListActivity extends Activity implements OnClickListener, OnIt
final Dialog dialog = builder.setView(view).show();
final Button positive = (Button)dialog.findViewById(android.R.id.button1);
positive.setOnClickListener(new OnClickListener() {
positive.setOnClickListener(new OnClickListener() {// 确认创建或修改文件夹
public void onClick(View v) {
hideSoftInput(etName);
String name = etName.getText().toString();
@ -617,7 +661,7 @@ public class NotesListActivity extends Activity implements OnClickListener, OnIt
return;
}
if (!create) {
if (!TextUtils.isEmpty(name)) {
if (!TextUtils.isEmpty(name)) {// 修改文件夹名称
ContentValues values = new ContentValues();
values.put(NoteColumns.SNIPPET, name);
values.put(NoteColumns.TYPE, Notes.TYPE_FOLDER);
@ -627,7 +671,7 @@ public class NotesListActivity extends Activity implements OnClickListener, OnIt
String.valueOf(mFocusNoteDataItem.getId())
});
}
} else if (!TextUtils.isEmpty(name)) {
} else if (!TextUtils.isEmpty(name)) {// 创建新文件夹
ContentValues values = new ContentValues();
values.put(NoteColumns.SNIPPET, name);
values.put(NoteColumns.TYPE, Notes.TYPE_FOLDER);
@ -637,19 +681,19 @@ public class NotesListActivity extends Activity implements OnClickListener, OnIt
}
});
if (TextUtils.isEmpty(etName.getText())) {
if (TextUtils.isEmpty(etName.getText())) {// 输入框为空时禁用确认按钮
positive.setEnabled(false);
}
/**
* When the name edit text is null, disable the positive button
*/
etName.addTextChangedListener(new TextWatcher() {
etName.addTextChangedListener(new TextWatcher() {// 监听输入框文本变化
public void beforeTextChanged(CharSequence s, int start, int count, int after) {
// TODO Auto-generated method stub
}
public void onTextChanged(CharSequence s, int start, int before, int count) {
public void onTextChanged(CharSequence s, int start, int before, int count) {// 输入框文本变化时更新确认按钮状态
if (TextUtils.isEmpty(etName.getText())) {
positive.setEnabled(false);
} else {
@ -657,7 +701,7 @@ public class NotesListActivity extends Activity implements OnClickListener, OnIt
}
}
public void afterTextChanged(Editable s) {
public void afterTextChanged(Editable s) {// 输入框文本变化后更新确认按钮状态
// TODO Auto-generated method stub
}
@ -665,22 +709,22 @@ public class NotesListActivity extends Activity implements OnClickListener, OnIt
}
@Override
public void onBackPressed() {
public void onBackPressed() {// 处理返回键事件
switch (mState) {
case SUB_FOLDER:
case SUB_FOLDER:// 返回上一级文件夹
mCurrentFolderId = Notes.ID_ROOT_FOLDER;
mState = ListEditState.NOTE_LIST;
startAsyncNotesListQuery();
mTitleBar.setVisibility(View.GONE);
break;
case CALL_RECORD_FOLDER:
case CALL_RECORD_FOLDER:// 返回上一级通话记录文件夹
mCurrentFolderId = Notes.ID_ROOT_FOLDER;
mState = ListEditState.NOTE_LIST;
mAddNewNote.setVisibility(View.VISIBLE);
mTitleBar.setVisibility(View.GONE);
startAsyncNotesListQuery();
break;
case NOTE_LIST:
case NOTE_LIST:// 返回主界面
super.onBackPressed();
break;
default:
@ -688,7 +732,7 @@ public class NotesListActivity extends Activity implements OnClickListener, OnIt
}
}
private void updateWidget(int appWidgetId, int appWidgetType) {
private void updateWidget(int appWidgetId, int appWidgetType) {// 更新指定应用小部件
Intent intent = new Intent(AppWidgetManager.ACTION_APPWIDGET_UPDATE);
if (appWidgetType == Notes.TYPE_WIDGET_2X) {
intent.setClass(this, NoteWidgetProvider_2x.class);
@ -707,7 +751,7 @@ public class NotesListActivity extends Activity implements OnClickListener, OnIt
setResult(RESULT_OK, intent);
}
private final OnCreateContextMenuListener mFolderOnCreateContextMenuListener = new OnCreateContextMenuListener() {
private final OnCreateContextMenuListener mFolderOnCreateContextMenuListener = new OnCreateContextMenuListener() {// 文件夹上下文菜单创建监听
public void onCreateContextMenu(ContextMenu menu, View v, ContextMenuInfo menuInfo) {
if (mFocusNoteDataItem != null) {
menu.setHeaderTitle(mFocusNoteDataItem.getSnippet());
@ -719,7 +763,7 @@ public class NotesListActivity extends Activity implements OnClickListener, OnIt
};
@Override
public void onContextMenuClosed(Menu menu) {
public void onContextMenuClosed(Menu menu) {// 上下文菜单关闭时移除监听
if (mNotesListView != null) {
mNotesListView.setOnCreateContextMenuListener(null);
}
@ -733,10 +777,10 @@ public class NotesListActivity extends Activity implements OnClickListener, OnIt
return false;
}
switch (item.getItemId()) {
case MENU_FOLDER_VIEW:
case MENU_FOLDER_VIEW:// 查看文件夹
openFolder(mFocusNoteDataItem);
break;
case MENU_FOLDER_DELETE:
case MENU_FOLDER_DELETE:// 删除文件夹
AlertDialog.Builder builder = new AlertDialog.Builder(this);
builder.setTitle(getString(R.string.alert_title_delete));
builder.setIcon(android.R.drawable.ic_dialog_alert);
@ -750,7 +794,7 @@ public class NotesListActivity extends Activity implements OnClickListener, OnIt
builder.setNegativeButton(android.R.string.cancel, null);
builder.show();
break;
case MENU_FOLDER_CHANGE_NAME:
case MENU_FOLDER_CHANGE_NAME:// 重命名文件夹
showCreateOrModifyFolderDialog(false);
break;
default:
@ -761,7 +805,7 @@ public class NotesListActivity extends Activity implements OnClickListener, OnIt
}
@Override
public boolean onPrepareOptionsMenu(Menu menu) {
public boolean onPrepareOptionsMenu(Menu menu) {// 准备选项菜单
menu.clear();
if (mState == ListEditState.NOTE_LIST) {
getMenuInflater().inflate(R.menu.note_list, menu);
@ -779,19 +823,19 @@ public class NotesListActivity extends Activity implements OnClickListener, OnIt
}
@Override
public boolean onOptionsItemSelected(MenuItem item) {
public boolean onOptionsItemSelected(MenuItem item) {// 选项菜单项点击事件处理
switch (item.getItemId()) {
case R.id.menu_new_folder: {
case R.id.menu_new_folder: {// 新建文件夹
showCreateOrModifyFolderDialog(true);
break;
}
case R.id.menu_export_text: {
case R.id.menu_export_text: {// 导出笔记为文本文件
exportNoteToText();
break;
}
case R.id.menu_sync: {
case R.id.menu_sync: {// 同步笔记
if (isSyncMode()) {
if (TextUtils.equals(item.getTitle(), getString(R.string.menu_sync))) {
if (TextUtils.equals(item.getTitle(), getString(R.string.menu_sync))) {// 同步笔记
GTaskSyncService.startSync(this);
} else {
GTaskSyncService.cancelSync(this);
@ -801,17 +845,23 @@ public class NotesListActivity extends Activity implements OnClickListener, OnIt
}
break;
}
case R.id.menu_setting: {
case R.id.menu_setting: {// 打开偏好设置
startPreferenceActivity();
break;
}
case R.id.menu_new_note: {
case R.id.menu_new_note: {// 新建笔记
createNewNote();
break;
}
case R.id.menu_search:
case R.id.menu_search: {// 搜索笔记
onSearchRequested();
break;
}
case R.id.menu_search:{
onSearchRequested();
break;
}
default:
break;
}
@ -819,24 +869,24 @@ public class NotesListActivity extends Activity implements OnClickListener, OnIt
}
@Override
public boolean onSearchRequested() {
public boolean onSearchRequested() {// 搜索笔记
startSearch(null, false, null /* appData */, false);
return true;
}
private void exportNoteToText() {
private void exportNoteToText() {// 导出笔记为文本文件
final BackupUtils backup = BackupUtils.getInstance(NotesListActivity.this);
new AsyncTask<Void, Void, Integer>() {
@Override
protected Integer doInBackground(Void... unused) {
protected Integer doInBackground(Void... unused) {// 后台导出笔记为文本文件
return backup.exportToText();
}
@Override
protected void onPostExecute(Integer result) {
protected void onPostExecute(Integer result) {// 导出笔记为文本文件完成后的回调
if (result == BackupUtils.STATE_SD_CARD_UNMOUONTED) {
AlertDialog.Builder builder = new AlertDialog.Builder(NotesListActivity.this);
AlertDialog.Builder builder = new AlertDialog.Builder(NotesListActivity.this);// 导出笔记为文本文件失败对话框
builder.setTitle(NotesListActivity.this
.getString(R.string.failed_sdcard_export));
builder.setMessage(NotesListActivity.this
@ -844,7 +894,7 @@ public class NotesListActivity extends Activity implements OnClickListener, OnIt
builder.setPositiveButton(android.R.string.ok, null);
builder.show();
} else if (result == BackupUtils.STATE_SUCCESS) {
AlertDialog.Builder builder = new AlertDialog.Builder(NotesListActivity.this);
AlertDialog.Builder builder = new AlertDialog.Builder(NotesListActivity.this);// 导出笔记为文本文件成功对话框
builder.setTitle(NotesListActivity.this
.getString(R.string.success_sdcard_export));
builder.setMessage(NotesListActivity.this.getString(
@ -852,7 +902,7 @@ public class NotesListActivity extends Activity implements OnClickListener, OnIt
.getExportedTextFileName(), backup.getExportedTextFileDir()));
builder.setPositiveButton(android.R.string.ok, null);
builder.show();
} else if (result == BackupUtils.STATE_SYSTEM_ERROR) {
} else if (result == BackupUtils.STATE_SYSTEM_ERROR) {// 导出笔记为文本文件系统错误对话框
AlertDialog.Builder builder = new AlertDialog.Builder(NotesListActivity.this);
builder.setTitle(NotesListActivity.this
.getString(R.string.failed_sdcard_export));
@ -866,19 +916,19 @@ public class NotesListActivity extends Activity implements OnClickListener, OnIt
}.execute();
}
private boolean isSyncMode() {
private boolean isSyncMode() {// 判断是否为同步模式
return NotesPreferenceActivity.getSyncAccountName(this).trim().length() > 0;
}
private void startPreferenceActivity() {
private void startPreferenceActivity() {// 打开偏好设置活动
Activity from = getParent() != null ? getParent() : this;
Intent intent = new Intent(from, NotesPreferenceActivity.class);
from.startActivityIfNeeded(intent, -1);
}
private class OnListItemClickListener implements OnItemClickListener {
private class OnListItemClickListener implements OnItemClickListener {// 列表项点击监听器
public void onItemClick(AdapterView<?> parent, View view, int position, long id) {
public void onItemClick(AdapterView<?> parent, View view, int position, long id) {// 列表项点击事件
if (view instanceof NotesListItem) {
NoteItemData item = ((NotesListItem) view).getItemData();
if (mNotesListAdapter.isInChoiceMode()) {
@ -890,9 +940,9 @@ public class NotesListActivity extends Activity implements OnClickListener, OnIt
return;
}
switch (mState) {
switch (mState) {// 根据当前状态处理点击事件
case NOTE_LIST:
if (item.getType() == Notes.TYPE_FOLDER
if (item.getType() == Notes.TYPE_FOLDER// 点击文件夹项
|| item.getType() == Notes.TYPE_SYSTEM) {
openFolder(item);
} else if (item.getType() == Notes.TYPE_NOTE) {
@ -917,7 +967,7 @@ public class NotesListActivity extends Activity implements OnClickListener, OnIt
}
private void startQueryDestinationFolders() {
private void startQueryDestinationFolders() {// 查询目标文件夹
String selection = NoteColumns.TYPE + "=? AND " + NoteColumns.PARENT_ID + "<>? AND " + NoteColumns.ID + "<>?";
selection = (mState == ListEditState.NOTE_LIST) ? selection:
"(" + selection + ") OR (" + NoteColumns.ID + "=" + Notes.ID_ROOT_FOLDER + ")";
@ -935,7 +985,7 @@ public class NotesListActivity extends Activity implements OnClickListener, OnIt
NoteColumns.MODIFIED_DATE + " DESC");
}
public boolean onItemLongClick(AdapterView<?> parent, View view, int position, long id) {
public boolean onItemLongClick(AdapterView<?> parent, View view, int position, long id) {// 列表项长按事件
if (view instanceof NotesListItem) {
mFocusNoteDataItem = ((NotesListItem) view).getItemData();
if (mFocusNoteDataItem.getType() == Notes.TYPE_NOTE && !mNotesListAdapter.isInChoiceMode()) {

@ -31,81 +31,80 @@ import java.util.HashSet;
import java.util.Iterator;
public class NotesListAdapter extends CursorAdapter {
private static final String TAG = "NotesListAdapter";
private Context mContext;
private HashMap<Integer, Boolean> mSelectedIndex;
private int mNotesCount;
private boolean mChoiceMode;
public static class AppWidgetAttribute {
public int widgetId;
public int widgetType;
public class NotesListAdapter extends CursorAdapter {//Adapter作为Activity和ListView之间的适配器将Cursor数据转换为ListView可以理解的视图格式
private static final String TAG = "NotesListAdapter"; // 日志标签
private Context mContext; // 上下文对象
private HashMap<Integer, Boolean> mSelectedIndex; // 选中项索引映射
private int mNotesCount; // 笔记数量(排除文件夹)
private boolean mChoiceMode; // 是否处于选择模式
public static class AppWidgetAttribute { // 小部件属性类用于存储小部件的ID和类型
public int widgetId; // 小部件ID
public int widgetType; // 小部件类型
};
public NotesListAdapter(Context context) {
public NotesListAdapter(Context context) { // 构造函数创建NotesListAdapter实例
super(context, null);
mSelectedIndex = new HashMap<Integer, Boolean>();
mSelectedIndex = new HashMap<Integer, Boolean>(); // 初始化选中项映射
mContext = context;
mNotesCount = 0;
}
@Override
public View newView(Context context, Cursor cursor, ViewGroup parent) {
return new NotesListItem(context);
return new NotesListItem(context); // 创建新的NotesListItem
}
@Override
public void bindView(View view, Context context, Cursor cursor) {
if (view instanceof NotesListItem) {
NoteItemData itemData = new NoteItemData(context, cursor);
((NotesListItem) view).bind(context, itemData, mChoiceMode,
NoteItemData itemData = new NoteItemData(context, cursor); // 创建数据模型
((NotesListItem) view).bind(context, itemData, mChoiceMode, // 绑定数据到视图
isSelectedItem(cursor.getPosition()));
}
}
public void setCheckedItem(final int position, final boolean checked) {
mSelectedIndex.put(position, checked);
notifyDataSetChanged();
mSelectedIndex.put(position, checked); // 更新选中状态
notifyDataSetChanged(); // 通知数据变化刷新UI
}
public boolean isInChoiceMode() {
return mChoiceMode;
return mChoiceMode; // 检查是否处于选择模式
}
public void setChoiceMode(boolean mode) {
mSelectedIndex.clear();
mChoiceMode = mode;
mSelectedIndex.clear(); // 清除之前的选中状态
mChoiceMode = mode; // 更新模式标志
}
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);
if (NoteItemData.getNoteType(cursor) == Notes.TYPE_NOTE) { // 只处理普通笔记,跳过文件夹
setCheckedItem(i, checked); // 设置选中状态
}
}
}
}
public HashSet<Long> getSelectedItemIds() {
public HashSet<Long> getSelectedItemIds() {// 获取选中项的ID集合
HashSet<Long> itemSet = new HashSet<Long>();
for (Integer position : mSelectedIndex.keySet()) {
if (mSelectedIndex.get(position) == true) {
Long id = getItemId(position);
Long id = getItemId(position); // 获取选中项的ID
if (id == Notes.ID_ROOT_FOLDER) {
Log.d(TAG, "Wrong item id, should not happen");
} else {
itemSet.add(id);
itemSet.add(id); // 添加到集合
}
}
}
return itemSet;
}
public HashSet<AppWidgetAttribute> getSelectedWidget() {
public HashSet<AppWidgetAttribute> getSelectedWidget() {// 获取选中项的小部件属性集合
HashSet<AppWidgetAttribute> itemSet = new HashSet<AppWidgetAttribute>();
for (Integer position : mSelectedIndex.keySet()) {
if (mSelectedIndex.get(position) == true) {
@ -113,12 +112,10 @@ public class NotesListAdapter extends CursorAdapter {
if (c != null) {
AppWidgetAttribute widget = new AppWidgetAttribute();
NoteItemData item = new NoteItemData(mContext, c);
widget.widgetId = item.getWidgetId();
widget.widgetType = item.getWidgetType();
widget.widgetId = item.getWidgetId(); // 获取小部件ID
widget.widgetType = item.getWidgetType(); // 获取小部件类型
itemSet.add(widget);
/**
* Don't close cursor here, only the adapter could close it
*/
// Don't close cursor here, only the adapter could close it
} else {
Log.e(TAG, "Invalid cursor");
return null;
@ -128,7 +125,7 @@ public class NotesListAdapter extends CursorAdapter {
return itemSet;
}
public int getSelectedCount() {
public int getSelectedCount() {// 获取选中项数量
Collection<Boolean> values = mSelectedIndex.values();
if (null == values) {
return 0;
@ -140,39 +137,39 @@ public class NotesListAdapter extends CursorAdapter {
count++;
}
}
return count;
return count; // 返回选中项数量
}
public boolean isAllSelected() {
public boolean isAllSelected() {// 检查是否所有笔记都被选中
int checkedCount = getSelectedCount();
return (checkedCount != 0 && checkedCount == mNotesCount);
return (checkedCount != 0 && checkedCount == mNotesCount);
}
public boolean isSelectedItem(final int position) {
public boolean isSelectedItem(final int position) {// 检查指定位置的项是否被选中
if (null == mSelectedIndex.get(position)) {
return false;
}
return mSelectedIndex.get(position);
return mSelectedIndex.get(position); // 检查指定位置的项是否被选中
}
@Override
protected void onContentChanged() {
super.onContentChanged();
calcNotesCount();
calcNotesCount(); // 当内容变化时,重新计算笔记数量
}
@Override
public void changeCursor(Cursor cursor) {
super.changeCursor(cursor);
calcNotesCount();
calcNotesCount(); // 当游标变化时,重新计算笔记数量
}
private void 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) {
if (NoteItemData.getNoteType(c) == Notes.TYPE_NOTE) { // 只统计普通笔记,排除文件夹
mNotesCount++;
}
} else {

@ -31,13 +31,16 @@ 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;
private ImageView mAlert; // 提醒图标(时钟或通话记录图标)
private TextView mTitle; // 笔记/文件夹标题或内容摘要
private TextView mTime; // 最后修改时间
private TextView mCallName; // 通话记录来电者名称(仅通话记录显示)
private NoteItemData mItemData; // 当前列表项的数据模型
private CheckBox mCheckBox; // 选择模式下的复选框(用于批量操作)
/**
*
*/
public NotesListItem(Context context) {
super(context);
inflate(context, R.layout.note_item, this);
@ -48,7 +51,13 @@ public class NotesListItem extends LinearLayout {
mCheckBox = (CheckBox) findViewById(android.R.id.checkbox);
}
/**
* UI
* @param data
* @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);
@ -57,6 +66,7 @@ public class NotesListItem extends LinearLayout {
}
mItemData = data;
// 处理通话记录文件夹
if (data.getId() == Notes.ID_CALL_RECORD_FOLDER) {
mCallName.setVisibility(View.GONE);
mAlert.setVisibility(View.VISIBLE);
@ -64,7 +74,9 @@ 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);
@ -75,7 +87,9 @@ public class NotesListItem extends LinearLayout {
} else {
mAlert.setVisibility(View.GONE);
}
} else {
}
// 处理普通文件夹和笔记
else {
mCallName.setVisibility(View.GONE);
mTitle.setTextAppearance(context, R.style.TextAppearancePrimaryItem);
@ -94,14 +108,20 @@ public class NotesListItem extends LinearLayout {
}
}
}
// 设置最后修改时间(相对时间格式)
mTime.setText(DateUtils.getRelativeTimeSpanString(data.getModifiedDate()));
// 根据数据类型和位置设置背景
setBackground(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()) {
@ -112,10 +132,14 @@ public class NotesListItem extends LinearLayout {
setBackgroundResource(NoteItemBgResources.getNoteBgNormalRes(id));
}
} else {
// 文件夹使用统一背景
setBackgroundResource(NoteItemBgResources.getFolderBgRes());
}
}
/**
*
*/
public NoteItemData getItemData() {
return mItemData;
}

@ -48,27 +48,37 @@ import net.micode.notes.data.Notes.NoteColumns;
import net.micode.notes.gtask.remote.GTaskSyncService;
/**
*
*
*/
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;
/** GTask同步广播接收器 */
private GTaskReceiver mReceiver;
/** 原始账户列表,用于检测是否添加了新账户 */
private Account[] mOriAccounts;
/** 是否添加了新账户的标志 */
private boolean mHasAddedAccount;
/**
*
* @param icicle
*/
@Override
protected void onCreate(Bundle icicle) {
super.onCreate(icicle);
@ -88,6 +98,9 @@ public class NotesPreferenceActivity extends PreferenceActivity {
getListView().addHeaderView(header, null, true);
}
/**
* UI
*/
@Override
protected void onResume() {
super.onResume();
@ -116,6 +129,9 @@ public class NotesPreferenceActivity extends PreferenceActivity {
refreshUI();
}
/**
*
*/
@Override
protected void onDestroy() {
if (mReceiver != null) {
@ -124,6 +140,9 @@ public class NotesPreferenceActivity extends PreferenceActivity {
super.onDestroy();
}
/**
*
*/
private void loadAccountPreference() {
mAccountCategory.removeAll();
@ -154,6 +173,9 @@ 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);
@ -193,11 +215,17 @@ public class NotesPreferenceActivity extends PreferenceActivity {
}
}
/**
* UI
*/
private void refreshUI() {
loadAccountPreference();
loadSyncButton();
}
/**
* Google
*/
private void showSelectAccountAlertDialog() {
AlertDialog.Builder dialogBuilder = new AlertDialog.Builder(this);
@ -254,6 +282,9 @@ public class NotesPreferenceActivity extends PreferenceActivity {
});
}
/**
*
*/
private void showChangeAccountConfirmAlertDialog() {
AlertDialog.Builder dialogBuilder = new AlertDialog.Builder(this);
@ -283,11 +314,19 @@ public class NotesPreferenceActivity extends PreferenceActivity {
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);
@ -318,6 +357,9 @@ public class NotesPreferenceActivity extends PreferenceActivity {
}
}
/**
*
*/
private void removeSyncAccount() {
SharedPreferences settings = getSharedPreferences(PREFERENCE_NAME, Context.MODE_PRIVATE);
SharedPreferences.Editor editor = settings.edit();
@ -330,7 +372,7 @@ public class NotesPreferenceActivity extends PreferenceActivity {
editor.commit();
// clean up local gtask related info
new Thread(new Runnable() {
new Thread(new Runnable() {//清空一系列数据thread多线程操作避免阻塞主线程
public void run() {
ContentValues values = new ContentValues();
values.put(NoteColumns.GTASK_ID, "");
@ -340,13 +382,20 @@ public class NotesPreferenceActivity extends PreferenceActivity {
}).start();
}
public static String getSyncAccountName(Context context) {
/**
*
* @return
*/
public static String getSyncAccountName(Context context) {//
SharedPreferences settings = context.getSharedPreferences(PREFERENCE_NAME,
Context.MODE_PRIVATE);
return settings.getString(PREFERENCE_SYNC_ACCOUNT_NAME, "");
}
public static void setLastSyncTime(Context context, long time) {
/**
*
*/
public static void setLastSyncTime(Context context, long time) {//
SharedPreferences settings = context.getSharedPreferences(PREFERENCE_NAME,
Context.MODE_PRIVATE);
SharedPreferences.Editor editor = settings.edit();
@ -354,16 +403,20 @@ public class NotesPreferenceActivity extends PreferenceActivity {
editor.commit();
}
public static long getLastSyncTime(Context context) {
/**
*
* @return
*/
public static long getLastSyncTime(Context context) {//
SharedPreferences settings = context.getSharedPreferences(PREFERENCE_NAME,
Context.MODE_PRIVATE);
return settings.getLong(PREFERENCE_LAST_SYNC_TIME, 0);
}
private class GTaskReceiver extends BroadcastReceiver {
private class GTaskReceiver extends BroadcastReceiver {// 处理同步状态更新广播
@Override
public void onReceive(Context context, Intent intent) {
public void onReceive(Context context, Intent intent) {// 处理同步状态更新广播
refreshUI();
if (intent.getBooleanExtra(GTaskSyncService.GTASK_SERVICE_BROADCAST_IS_SYNCING, false)) {
TextView syncStatus = (TextView) findViewById(R.id.prefenerece_sync_status_textview);
@ -374,7 +427,11 @@ public class NotesPreferenceActivity extends PreferenceActivity {
}
}
public boolean onOptionsItemSelected(MenuItem item) {
/**
*
* @param item
*/
public boolean onOptionsItemSelected(MenuItem item) {//
switch (item.getItemId()) {
case android.R.id.home:
Intent intent = new Intent(this, NotesListActivity.class);

@ -32,11 +32,11 @@ import net.micode.notes.tool.ResourceParser;
import net.micode.notes.ui.NoteEditActivity;
import net.micode.notes.ui.NotesListActivity;
public abstract class NoteWidgetProvider extends AppWidgetProvider {
public abstract class NoteWidgetProvider extends AppWidgetProvider {//笔记小部件提供器
public static final String [] PROJECTION = new String [] {
NoteColumns.ID,
NoteColumns.BG_COLOR_ID,
NoteColumns.SNIPPET
NoteColumns.SNIPPET//笔记摘要
};
public static final int COLUMN_ID = 0;
@ -46,9 +46,9 @@ public abstract class NoteWidgetProvider extends AppWidgetProvider {
private static final String TAG = "NoteWidgetProvider";
@Override
public void onDeleted(Context context, int[] appWidgetIds) {
ContentValues values = new ContentValues();
values.put(NoteColumns.WIDGET_ID, AppWidgetManager.INVALID_APPWIDGET_ID);
public void onDeleted(Context context, int[] appWidgetIds) {//删除小部件时调用
ContentValues values = new ContentValues();//创建内容值对象,用于更新数据库
values.put(NoteColumns.WIDGET_ID, AppWidgetManager.INVALID_APPWIDGET_ID);//将小部件ID设置为无效值
for (int i = 0; i < appWidgetIds.length; i++) {
context.getContentResolver().update(Notes.CONTENT_NOTE_URI,
values,
@ -59,18 +59,18 @@ public abstract class NoteWidgetProvider extends AppWidgetProvider {
private Cursor getNoteWidgetInfo(Context context, int widgetId) {
return context.getContentResolver().query(Notes.CONTENT_NOTE_URI,
PROJECTION,
PROJECTION,//查询投影,指定要返回的列
NoteColumns.WIDGET_ID + "=? AND " + NoteColumns.PARENT_ID + "<>?",
new String[] { String.valueOf(widgetId), String.valueOf(Notes.ID_TRASH_FOLER) },
null);
}
protected void update(Context context, AppWidgetManager appWidgetManager, int[] appWidgetIds) {
update(context, appWidgetManager, appWidgetIds, false);
update(context, appWidgetManager, appWidgetIds, false);//false
}
private void update(Context context, AppWidgetManager appWidgetManager, int[] appWidgetIds,
boolean privacyMode) {
boolean privacyMode) {//更新小部件,是上面的实现方式
for (int i = 0; i < appWidgetIds.length; i++) {
if (appWidgetIds[i] != AppWidgetManager.INVALID_APPWIDGET_ID) {
int bgId = ResourceParser.getDefaultBgId(context);
@ -90,36 +90,38 @@ public abstract class NoteWidgetProvider extends AppWidgetProvider {
snippet = c.getString(COLUMN_SNIPPET);
bgId = c.getInt(COLUMN_BG_COLOR_ID);
intent.putExtra(Intent.EXTRA_UID, c.getLong(COLUMN_ID));
intent.setAction(Intent.ACTION_VIEW);
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);//设置意图操作,插入或编辑笔记
}
if (c != null) {
c.close();
}
RemoteViews rv = new RemoteViews(context.getPackageName(), getLayoutId());
RemoteViews rv = new RemoteViews(context.getPackageName(), getLayoutId());//创建远程视图对象,用于更新小部件的布局
/*App Widget使RemoteViewsView? RemoteViews View
Android*/
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;
PendingIntent pendingIntent = null;//创建挂起意图对象,用于启动主活动
if (privacyMode) {
rv.setTextViewText(R.id.widget_text,
context.getString(R.string.widget_under_visit_mode));
context.getString(R.string.widget_under_visit_mode));//设置小部件文本为隐私模式下的提示文本
pendingIntent = PendingIntent.getActivity(context, appWidgetIds[i], new Intent(
context, NotesListActivity.class), PendingIntent.FLAG_UPDATE_CURRENT);
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);
rv.setOnClickPendingIntent(R.id.widget_text, pendingIntent);//设置小部件文本点击事件,启动挂起意图
appWidgetManager.updateAppWidget(appWidgetIds[i], rv);//更新小部件布局
}
}
}

@ -24,10 +24,10 @@ import net.micode.notes.data.Notes;
import net.micode.notes.tool.ResourceParser;
public class NoteWidgetProvider_2x extends NoteWidgetProvider {
public class NoteWidgetProvider_2x extends NoteWidgetProvider {//小部件2x布局类
@Override
public void onUpdate(Context context, AppWidgetManager appWidgetManager, int[] appWidgetIds) {
super.update(context, appWidgetManager, appWidgetIds);
super.update(context, appWidgetManager, appWidgetIds);//调用父类更新方法
}
@Override

@ -24,14 +24,14 @@ import net.micode.notes.data.Notes;
import net.micode.notes.tool.ResourceParser;
public class NoteWidgetProvider_4x extends NoteWidgetProvider {
public class NoteWidgetProvider_4x extends NoteWidgetProvider {//小部件4x布局类
@Override
public void onUpdate(Context context, AppWidgetManager appWidgetManager, int[] appWidgetIds) {
super.update(context, appWidgetManager, appWidgetIds);
super.update(context, appWidgetManager, appWidgetIds);//调用父类更新方法
}
protected int getLayoutId() {
return R.layout.widget_4x;
return R.layout.widget_4x;//返回4x布局资源ID
}
@Override

Loading…
Cancel
Save