pjao9fvxr
/
Notes-Xiaomi
1
0
Fork 0
Code Issues Pull Requests 1 Packages Projects Releases Wiki Activity
Labels Milestones
New Pull Request

增加代码注释 #9

Merged
pjao9fvxr merged 3 commits from zhouzexin_branch into master 3 weeks ago
Conversation 0 Commits 3 Files Changed 6
6 changed files with 503 additions and 72 deletions
Show Stats Download Patch File Download Diff File

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

@ -16,17 +16,34 @@
package net.micode.notes.gtask.exception;
/**
* Google Tasks操作失败异常类
* 用于表示与Google Tasks服务器交互时的操作失败情况
*/
public class ActionFailureException extends RuntimeException {
// 序列化版本UID
private static final long serialVersionUID = 4425249765923293627L;
/**
* 无参构造函数
*/
public ActionFailureException() {
super();
}
/**
* 构造函数
* @param paramString 异常信息
*/
public ActionFailureException(String paramString) {
super(paramString);
}
/**
* 构造函数
* @param paramString 异常信息
* @param paramThrowable 引起此异常的原因
*/
public ActionFailureException(String paramString, Throwable paramThrowable) {
super(paramString, paramThrowable);
}

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

@ -16,17 +16,34 @@
package net.micode.notes.gtask.exception;
/**
* Google Tasks网络失败异常类
* 用于表示与Google Tasks服务器交互时的网络连接失败情况
*/
public class NetworkFailureException extends Exception {
// 序列化版本UID
private static final long serialVersionUID = 2107610287180234136L;
/**
* 无参构造函数
*/
public NetworkFailureException() {
super();
}
/**
* 构造函数
* @param paramString 异常信息
*/
public NetworkFailureException(String paramString) {
super(paramString);
}
/**
* 构造函数
* @param paramString 异常信息
* @param paramThrowable 引起此异常的原因
*/
public NetworkFailureException(String paramString, Throwable paramThrowable) {
super(paramString, paramThrowable);
}

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

@ -29,22 +29,44 @@ import net.micode.notes.ui.NotesListActivity;
import net.micode.notes.ui.NotesPreferenceActivity;
/**
* Google Tasks同步的异步任务类
* 继承自AsyncTask，用于在后台执行Google Tasks的同步操作
* 提供通知显示、进度更新和完成回调功能
*/
public class GTaskASyncTask extends AsyncTask<Void, String, Integer> {
// 同步通知的ID
private static int GTASK_SYNC_NOTIFICATION_ID = 5234235;
/**
* 同步完成监听器接口
* 用于在同步任务完成时回调通知
*/
public interface OnCompleteListener {
/**
* 同步完成时调用
*/
void onComplete();
}
// 上下文对象
private Context mContext;
// 通知管理器
private NotificationManager mNotifiManager;
// Google Task管理器实例
private GTaskManager mTaskManager;
// 完成监听器
private OnCompleteListener mOnCompleteListener;
/**
* 构造函数
* @param context 上下文对象
* @param listener 完成监听器
*/
public GTaskASyncTask(Context context, OnCompleteListener listener) {
mContext = context;
mOnCompleteListener = listener;
@ -53,52 +75,52 @@ public class GTaskASyncTask extends AsyncTask<Void, String, Integer> {
mTaskManager = GTaskManager.getInstance();
}
/**
* 取消同步任务
*/
public void cancelSync() {
mTaskManager.cancelSync();
}
/**
* 发布同步进度
* @param message 进度消息
*/
public void publishProgess(String message) {
publishProgress(new String[] {
message
});
}
// private void showNotification(int tickerId, String content) {
// Notification notification = new Notification(R.drawable.notification, mContext
// .getString(tickerId), System.currentTimeMillis());
// notification.defaults = Notification.DEFAULT_LIGHTS;
// notification.flags = Notification.FLAG_AUTO_CANCEL;
// PendingIntent pendingIntent;
// if (tickerId != R.string.ticker_success) {
// pendingIntent = PendingIntent.getActivity(mContext, 0, new Intent(mContext,
// NotesPreferenceActivity.class), 0);
// } else {
// pendingIntent = PendingIntent.getActivity(mContext, 0, new Intent(mContext,
// NotesListActivity.class), 0);
// }
// notification.setLatestEventInfo(mContext, mContext.getString(R.string.app_name), content,
// pendingIntent);
// mNotifiManager.notify(GTASK_SYNC_NOTIFICATION_ID, notification);
// }
private void showNotification(int tickerId, String content) {
PendingIntent pendingIntent;
if (tickerId != R.string.ticker_success) {
pendingIntent = PendingIntent.getActivity(mContext, 0, new Intent(mContext,
NotesPreferenceActivity.class), PendingIntent.FLAG_IMMUTABLE);
} else {
pendingIntent = PendingIntent.getActivity(mContext, 0, new Intent(mContext,
NotesListActivity.class), PendingIntent.FLAG_IMMUTABLE);
/**
* 显示同步通知
* @param tickerId 通知标题的字符串资源ID
* @param content 通知内容
*/
private void showNotification(int tickerId, String content) {
Notification notification = new Notification(R.drawable.notification, mContext
.getString(tickerId), System.currentTimeMillis());
notification.defaults = Notification.DEFAULT_LIGHTS;
notification.flags = Notification.FLAG_AUTO_CANCEL;
PendingIntent pendingIntent;
if (tickerId != R.string.ticker_success) {
pendingIntent = PendingIntent.getActivity(mContext, 0, new Intent(mContext,
NotesPreferenceActivity.class), 0);
} else {
pendingIntent = PendingIntent.getActivity(mContext, 0, new Intent(mContext,
NotesListActivity.class), 0);
}
notification.setLatestEventInfo(mContext, mContext.getString(R.string.app_name), content,
pendingIntent);
mNotifiManager.notify(GTASK_SYNC_NOTIFICATION_ID, notification);
}
Notification.Builder builder = new Notification.Builder(mContext)
.setAutoCancel(true)
.setContentTitle(mContext.getString(R.string.app_name))
.setContentText(content)
.setContentIntent(pendingIntent)
.setWhen(System.currentTimeMillis())
.setOngoing(true);
Notification notification=builder.getNotification();
mNotifiManager.notify(GTASK_SYNC_NOTIFICATION_ID, notification);
}
/**
* 在后台执行同步任务
* @param unused 未使用的参数
* @return 同步结果状态码
*/
@Override
protected Integer doInBackground(Void... unused) {
publishProgess(mContext.getString(R.string.sync_progress_login, NotesPreferenceActivity
@ -106,6 +128,10 @@ private void showNotification(int tickerId, String content) {
return mTaskManager.sync(mContext, this);
}
/**
* 更新同步进度
* @param progress 进度消息数组
*/
@Override
protected void onProgressUpdate(String... progress) {
showNotification(R.string.ticker_syncing, progress[0]);
@ -114,6 +140,10 @@ private void showNotification(int tickerId, String content) {
}
}
/**
* 同步任务完成后执行
* @param result 同步结果状态码
*/
@Override
protected void onPostExecute(Integer result) {
if (result == GTaskManager.STATE_SUCCESS) {

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

@ -61,35 +61,58 @@ import java.util.zip.Inflater;
import java.util.zip.InflaterInputStream;
/**
* Google Tasks客户端类
* 负责与Google Tasks服务器进行通信，处理登录、任务创建、更新、删除等操作
* 采用单例模式实现
*/
public class GTaskClient {
// 日志标签
private static final String TAG = GTaskClient.class.getSimpleName();
// Google Tasks基础URL
private static final String GTASK_URL = "https://mail.google.com/tasks/";
// Google Tasks GET请求URL
private static final String GTASK_GET_URL = "https://mail.google.com/tasks/ig";
// Google Tasks POST请求URL
private static final String GTASK_POST_URL = "https://mail.google.com/tasks/r/ig";
// 单例实例
private static GTaskClient mInstance = null;
// HTTP客户端实例
private DefaultHttpClient mHttpClient;
// 当前使用的GET请求URL
private String mGetUrl;
// 当前使用的POST请求URL
private String mPostUrl;
// 客户端版本号
private long mClientVersion;
// 是否已登录
private boolean mLoggedin;
// 上次登录时间
private long mLastLoginTime;
// 操作ID计数器
private int mActionId;
// 登录的Google账户
private Account mAccount;
// 更新操作的JSON数组
private JSONArray mUpdateArray;
/**
* 私有构造函数
* 初始化客户端参数
*/
private GTaskClient() {
mHttpClient = null;
mGetUrl = GTASK_GET_URL;
@ -102,6 +125,10 @@ public class GTaskClient {
mUpdateArray = null;
}
/**
* 获取单例实例
* @return GTaskClient实例
*/
public static synchronized GTaskClient getInstance() {
if (mInstance == null) {
mInstance = new GTaskClient();
@ -109,15 +136,20 @@ public class GTaskClient {
return mInstance;
}
/**
* 登录Google Tasks
* 检查是否需要重新登录，处理Google账户认证和Tasks登录
* @param activity 调用此方法的Activity实例
* @return 是否登录成功
*/
public boolean login(Activity activity) {
// we suppose that the cookie would expire after 5 minutes
// then we need to re-login
// 假设Cookie 5分钟后过期，需要重新登录
final long interval = 1000 * 60 * 5;
if (mLastLoginTime + interval < System.currentTimeMillis()) {
mLoggedin = false;
}
// need to re-login after account switch
// 切换账户后需要重新登录
if (mLoggedin
&& !TextUtils.equals(getSyncAccount().name, NotesPreferenceActivity
.getSyncAccountName(activity))) {
@ -136,7 +168,7 @@ public class GTaskClient {
return false;
}
// login with custom domain if necessary
// 必要时使用自定义域名登录
if (!(mAccount.name.toLowerCase().endsWith("gmail.com") || mAccount.name.toLowerCase()
.endsWith("googlemail.com"))) {
StringBuilder url = new StringBuilder(GTASK_URL).append("a/");
@ -151,7 +183,7 @@ public class GTaskClient {
}
}
// try to login with google official url
// 尝试使用Google官方URL登录
if (!mLoggedin) {
mGetUrl = GTASK_GET_URL;
mPostUrl = GTASK_POST_URL;
@ -164,6 +196,12 @@ public class GTaskClient {
return true;
}
/**
* 登录Google账户，获取认证令牌
* @param activity 调用此方法的Activity实例
* @param invalidateToken 是否使现有令牌失效
* @return 认证令牌，如果获取失败则返回null
*/
private String loginGoogleAccount(Activity activity, boolean invalidateToken) {
String authToken;
AccountManager accountManager = AccountManager.get(activity);
@ -189,7 +227,7 @@ public class GTaskClient {
return null;
}
// get the token now
// 获取认证令牌
AccountManagerFuture<Bundle> accountManagerFuture = accountManager.getAuthToken(account,
"goanna_mobile", null, activity, null, null);
try {
@ -207,10 +245,16 @@ public class GTaskClient {
return authToken;
}
/**
* 尝试登录Google Tasks
* 如果登录失败，尝试使令牌失效并重新登录
* @param activity 调用此方法的Activity实例
* @param authToken Google账户认证令牌
* @return 是否登录成功
*/
private boolean tryToLoginGtask(Activity activity, String authToken) {
if (!loginGtask(authToken)) {
// maybe the auth token is out of date, now let's invalidate the
// token and try again
// 认证令牌可能已过期，使令牌失效并重新尝试
authToken = loginGoogleAccount(activity, true);
if (authToken == null) {
Log.e(TAG, "login google account failed");
@ -225,6 +269,12 @@ public class GTaskClient {
return true;
}
/**
* 使用认证令牌登录Google Tasks
* 设置HTTP客户端，执行登录请求并获取Cookie和客户端版本
* @param authToken Google账户认证令牌
* @return 是否登录成功
*/
private boolean loginGtask(String authToken) {
int timeoutConnection = 10000;
int timeoutSocket = 15000;
@ -236,14 +286,14 @@ public class GTaskClient {
mHttpClient.setCookieStore(localBasicCookieStore);
HttpProtocolParams.setUseExpectContinue(mHttpClient.getParams(), false);
// login gtask
// 登录Google Tasks
try {
String loginUrl = mGetUrl + "?auth=" + authToken;
HttpGet httpGet = new HttpGet(loginUrl);
HttpResponse response = null;
response = mHttpClient.execute(httpGet);
// get the cookie now
// 获取认证Cookie
List<Cookie> cookies = mHttpClient.getCookieStore().getCookies();
boolean hasAuthCookie = false;
for (Cookie cookie : cookies) {
@ -255,7 +305,7 @@ public class GTaskClient {
Log.w(TAG, "it seems that there is no auth cookie");
}
// get the client version
// 获取客户端版本
String resString = getResponseContent(response.getEntity());
String jsBegin = "_setup(";
String jsEnd = ")}</script>";
@ -272,7 +322,7 @@ public class GTaskClient {
e.printStackTrace();
return false;
} catch (Exception e) {
// simply catch all exceptions
// 捕获所有异常
Log.e(TAG, "httpget gtask_url failed");
return false;
}
@ -280,10 +330,20 @@ public class GTaskClient {
return true;
}
/**
* 获取操作ID
* 自增并返回当前操作ID
* @return 唯一的操作ID
*/
private int getActionId() {
return mActionId++;
}
/**
* 创建HTTP POST请求
* 设置请求头和URL
* @return HttpPost实例
*/
private HttpPost createHttpPost() {
HttpPost httpPost = new HttpPost(mPostUrl);
httpPost.setHeader("Content-Type", "application/x-www-form-urlencoded;charset=utf-8");
@ -291,6 +351,13 @@ public class GTaskClient {
return httpPost;
}
/**
* 获取HTTP响应内容
* 处理不同的编码格式（gzip、deflate等）
* @param entity HTTP响应实体
* @return 响应内容字符串
* @throws IOException 如果读取响应内容时发生错误
*/
private String getResponseContent(HttpEntity entity) throws IOException {
String contentEncoding = null;
if (entity.getContentEncoding() != null) {
@ -323,6 +390,13 @@ public class GTaskClient {
}
}
/**
* 发送POST请求
* 向Google Tasks服务器发送请求并返回响应
* @param js 请求的JSON对象
* @return 响应的JSON对象
* @throws NetworkFailureException 如果网络请求失败
*/
private JSONObject postRequest(JSONObject js) throws NetworkFailureException {
if (!mLoggedin) {
Log.e(TAG, "please login first");
@ -336,7 +410,7 @@ public class GTaskClient {
UrlEncodedFormEntity entity = new UrlEncodedFormEntity(list, "UTF-8");
httpPost.setEntity(entity);
// execute the post
// 执行POST请求
HttpResponse response = mHttpClient.execute(httpPost);
String jsString = getResponseContent(response.getEntity());
return new JSONObject(jsString);
@ -360,6 +434,12 @@ public class GTaskClient {
}
}
/**
* 创建任务
* 向Google Tasks服务器发送创建任务请求
* @param task 要创建的任务对象
* @throws NetworkFailureException 如果网络请求失败
*/
public void createTask(Task task) throws NetworkFailureException {
commitUpdate();
try {
@ -373,7 +453,7 @@ public class GTaskClient {
// client_version
jsPost.put(GTaskStringUtils.GTASK_JSON_CLIENT_VERSION, mClientVersion);
// post
// 发送请求
JSONObject jsResponse = postRequest(jsPost);
JSONObject jsResult = (JSONObject) jsResponse.getJSONArray(
GTaskStringUtils.GTASK_JSON_RESULTS).get(0);
@ -386,6 +466,12 @@ public class GTaskClient {
}
}
/**
* 创建任务列表
* 向Google Tasks服务器发送创建任务列表请求
* @param tasklist 要创建的任务列表对象
* @throws NetworkFailureException 如果网络请求失败
*/
public void createTaskList(TaskList tasklist) throws NetworkFailureException {
commitUpdate();
try {
@ -396,10 +482,10 @@ public class GTaskClient {
actionList.put(tasklist.getCreateAction(getActionId()));
jsPost.put(GTaskStringUtils.GTASK_JSON_ACTION_LIST, actionList);
// client version
// client_version
jsPost.put(GTaskStringUtils.GTASK_JSON_CLIENT_VERSION, mClientVersion);
// post
// 发送请求
JSONObject jsResponse = postRequest(jsPost);
JSONObject jsResult = (JSONObject) jsResponse.getJSONArray(
GTaskStringUtils.GTASK_JSON_RESULTS).get(0);
@ -412,6 +498,11 @@ public class GTaskClient {
}
}
/**
* 提交更新
* 将待更新的操作发送到Google Tasks服务器
* @throws NetworkFailureException 如果网络请求失败
*/
public void commitUpdate() throws NetworkFailureException {
if (mUpdateArray != null) {
try {
@ -433,10 +524,17 @@ public class GTaskClient {
}
}
/**
* 添加更新节点
* 将节点的更新操作添加到待更新列表中
* 如果待更新列表超过10项，则立即提交更新
* @param node 要更新的节点
* @throws NetworkFailureException 如果网络请求失败
*/
public void addUpdateNode(Node node) throws NetworkFailureException {
if (node != null) {
// too many update items may result in an error
// set max to 10 items
// 过多的更新项可能导致错误
// 最大设置为10项
if (mUpdateArray != null && mUpdateArray.length() > 10) {
commitUpdate();
}
@ -447,6 +545,14 @@ public class GTaskClient {
}
}
/**
* 移动任务
* 将任务从一个任务列表移动到另一个任务列表，或在同一任务列表内移动
* @param task 要移动的任务
* @param preParent 移动前的父任务列表
* @param curParent 移动后的父任务列表
* @throws NetworkFailureException 如果网络请求失败
*/
public void moveTask(Task task, TaskList preParent, TaskList curParent)
throws NetworkFailureException {
commitUpdate();
@ -461,14 +567,13 @@ public class GTaskClient {
action.put(GTaskStringUtils.GTASK_JSON_ACTION_ID, getActionId());
action.put(GTaskStringUtils.GTASK_JSON_ID, task.getGid());
if (preParent == curParent && task.getPriorSibling() != null) {
// put prioring_sibing_id only if moving within the tasklist and
// it is not the first one
// 只有在同一任务列表内移动且不是第一个任务时，才设置prior_sibling_id
action.put(GTaskStringUtils.GTASK_JSON_PRIOR_SIBLING_ID, task.getPriorSibling());
}
action.put(GTaskStringUtils.GTASK_JSON_SOURCE_LIST, preParent.getGid());
action.put(GTaskStringUtils.GTASK_JSON_DEST_PARENT, curParent.getGid());
if (preParent != curParent) {
// put the dest_list only if moving between tasklists
// 只有在不同任务列表之间移动时，才设置dest_list
action.put(GTaskStringUtils.GTASK_JSON_DEST_LIST, curParent.getGid());
}
actionList.put(action);
@ -486,6 +591,12 @@ public class GTaskClient {
}
}
/**
* 删除节点
* 将节点标记为已删除并发送到服务器
* @param node 要删除的节点
* @throws NetworkFailureException 如果网络请求失败
*/
public void deleteNode(Node node) throws NetworkFailureException {
commitUpdate();
try {
@ -509,6 +620,12 @@ public class GTaskClient {
}
}
/**
* 获取所有任务列表
* 从Google Tasks服务器获取用户的所有任务列表
* @return 任务列表的JSON数组
* @throws NetworkFailureException 如果网络请求失败
*/
public JSONArray getTaskLists() throws NetworkFailureException {
if (!mLoggedin) {
Log.e(TAG, "please login first");
@ -547,6 +664,13 @@ public class GTaskClient {
}
}
/**
* 获取指定任务列表的任务
* 从Google Tasks服务器获取指定任务列表中的所有任务
* @param listGid 任务列表的GID
* @return 任务的JSON数组
* @throws NetworkFailureException 如果网络请求失败
*/
public JSONArray getTaskList(String listGid) throws NetworkFailureException {
commitUpdate();
try {
@ -575,10 +699,18 @@ public class GTaskClient {
}
}
/**
* 获取当前同步账户
* @return 当前使用的Google账户
*/
public Account getSyncAccount() {
return mAccount;
}
/**
* 重置更新数组
* 清空待更新的操作列表
*/
public void resetUpdateArray() {
mUpdateArray = null;
}

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

@ -23,25 +23,43 @@ import android.content.Intent;
import android.os.Bundle;
import android.os.IBinder;
/**
* Google Tasks同步服务类
* 用于管理Google Tasks的同步操作，包括启动同步、取消同步等功能
* 通过广播通知同步状态和进度
*/
public class GTaskSyncService extends Service {
// 同步操作类型的额外参数名称
public final static String ACTION_STRING_NAME = "sync_action_type";
// 启动同步操作的类型值
public final static int ACTION_START_SYNC = 0;
// 取消同步操作的类型值
public final static int ACTION_CANCEL_SYNC = 1;
// 无效操作的类型值
public final static int ACTION_INVALID = 2;
// 同步服务广播的名称
public final static String GTASK_SERVICE_BROADCAST_NAME = "net.micode.notes.gtask.remote.gtask_sync_service";
// 广播中同步状态的额外参数名称
public final static String GTASK_SERVICE_BROADCAST_IS_SYNCING = "isSyncing";
// 广播中同步进度的额外参数名称
public final static String GTASK_SERVICE_BROADCAST_PROGRESS_MSG = "progressMsg";
// 同步任务实例
private static GTaskASyncTask mSyncTask = null;
// 当前同步进度消息
private static String mSyncProgress = "";
/**
* 启动同步任务
* 如果当前没有同步任务在运行，则创建新的同步任务并执行
*/
private void startSync() {
if (mSyncTask == null) {
mSyncTask = new GTaskASyncTask(this, new GTaskASyncTask.OnCompleteListener() {
@ -56,17 +74,33 @@ public class GTaskSyncService extends Service {
}
}
/**
* 取消同步任务
* 如果当前有同步任务在运行，则取消该任务
*/
private void cancelSync() {
if (mSyncTask != null) {
mSyncTask.cancelSync();
}
}
/**
* 服务创建时调用
* 初始化同步任务实例为null
*/
@Override
public void onCreate() {
mSyncTask = null;
}
/**
* 处理服务启动命令
* 根据意图中的操作类型执行相应的同步操作
* @param intent 启动服务的意图
* @param flags 启动标志
* @param startId 服务启动ID
* @return 服务启动模式
*/
@Override
public int onStartCommand(Intent intent, int flags, int startId) {
Bundle bundle = intent.getExtras();
@ -86,6 +120,10 @@ public class GTaskSyncService extends Service {
return super.onStartCommand(intent, flags, startId);
}
/**
* 系统低内存时调用
* 取消当前正在运行的同步任务以释放内存
*/
@Override
public void onLowMemory() {
if (mSyncTask != null) {
@ -93,10 +131,20 @@ public class GTaskSyncService extends Service {
}
}
/**
* 绑定服务时调用
* 此服务不支持绑定，返回null
* @param intent 绑定服务的意图
* @return 服务的IBinder接口实例
*/
public IBinder onBind(Intent intent) {
return null;
}
/**
* 发送同步状态广播
* @param msg 同步进度消息
*/
public void sendBroadcast(String msg) {
mSyncProgress = msg;
Intent intent = new Intent(GTASK_SERVICE_BROADCAST_NAME);
@ -105,6 +153,10 @@ public class GTaskSyncService extends Service {
sendBroadcast(intent);
}
/**
* 静态方法，启动同步服务
* @param activity 调用此方法的Activity实例
*/
public static void startSync(Activity activity) {
GTaskManager.getInstance().setActivityContext(activity);
Intent intent = new Intent(activity, GTaskSyncService.class);
@ -112,16 +164,28 @@ public class GTaskSyncService extends Service {
activity.startService(intent);
}
/**
* 静态方法，取消同步服务
* @param context 调用此方法的上下文
*/
public static void cancelSync(Context context) {
Intent intent = new Intent(context, GTaskSyncService.class);
intent.putExtra(GTaskSyncService.ACTION_STRING_NAME, GTaskSyncService.ACTION_CANCEL_SYNC);
context.startService(intent);
}
/**
* 静态方法，检查是否正在同步
* @return 是否已开始同步且同步任务未完成
*/
public static boolean isSyncing() {
return mSyncTask != null;
}
/**
* 静态方法，获取同步进度字符串
* @return 当前同步进度消息
*/
public static String getProgressString() {
return mSyncProgress;
}

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

@ -32,36 +32,57 @@ import net.micode.notes.data.Notes.TextNote;
import net.micode.notes.tool.ResourceParser.NoteBgResources;
/**
* 工作笔记类，用于处理正在编辑的笔记
* 是Note类的包装类，提供更多功能和状态管理
* 支持创建新笔记、加载现有笔记、保存笔记等操作
*/
public class WorkingNote {
// Note for the working note
// 日志标签
private static final String TAG = "WorkingNote";
// 上下文对象
private Context mContext;
// 内部Note对象，用于实际数据操作
private Note mNote;
// Note Id
// 笔记ID
private long mNoteId;
// Note content
// 笔记内容
private String mContent;
// Note mode
// 笔记模式（如普通模式、检查列表模式）
private int mMode;
// 提醒日期
private long mAlertDate;
// 最后修改日期
private long mModifiedDate;
// 背景颜色ID
private int mBgColorId;
// 小组件ID
private int mWidgetId;
// 小组件类型
private int mWidgetType;
// 文件夹ID
private long mFolderId;
private Context mContext;
private static final String TAG = "WorkingNote";
// 是否已删除
private boolean mIsDeleted;
// 笔记设置变化监听器
private NoteSettingChangedListener mNoteSettingStatusListener;
/**
* 数据查询投影数组，用于获取笔记的具体数据内容
*/
public static final String[] DATA_PROJECTION = new String[] {
DataColumns.ID,
DataColumns.CONTENT,
@ -72,6 +93,9 @@ public class WorkingNote {
DataColumns.DATA4,
};
/**
* 笔记查询投影数组，用于获取笔记的基本信息
*/
public static final String[] NOTE_PROJECTION = new String[] {
NoteColumns.PARENT_ID,
NoteColumns.ALERTED_DATE,
@ -81,27 +105,41 @@ public class WorkingNote {
NoteColumns.MODIFIED_DATE
};
// DATA_PROJECTION中ID列的索引
private static final int DATA_ID_COLUMN = 0;
// DATA_PROJECTION中内容列的索引
private static final int DATA_CONTENT_COLUMN = 1;
// DATA_PROJECTION中MIME类型列的索引
private static final int DATA_MIME_TYPE_COLUMN = 2;
// DATA_PROJECTION中模式列的索引
private static final int DATA_MODE_COLUMN = 3;
// NOTE_PROJECTION中父ID列的索引
private static final int NOTE_PARENT_ID_COLUMN = 0;
// NOTE_PROJECTION中提醒日期列的索引
private static final int NOTE_ALERTED_DATE_COLUMN = 1;
// NOTE_PROJECTION中背景颜色ID列的索引
private static final int NOTE_BG_COLOR_ID_COLUMN = 2;
// NOTE_PROJECTION中小组件ID列的索引
private static final int NOTE_WIDGET_ID_COLUMN = 3;
// NOTE_PROJECTION中小组件类型列的索引
private static final int NOTE_WIDGET_TYPE_COLUMN = 4;
// NOTE_PROJECTION中修改日期列的索引
private static final int NOTE_MODIFIED_DATE_COLUMN = 5;
// New note construct
/**
* 创建新笔记的构造方法
* @param context 上下文对象
* @param folderId 文件夹ID
*/
private WorkingNote(Context context, long folderId) {
mContext = context;
mAlertDate = 0;
@ -114,7 +152,12 @@ public class WorkingNote {
mWidgetType = Notes.TYPE_WIDGET_INVALIDE;
}
// Existing note construct
/**
* 加载现有笔记的构造方法
* @param context 上下文对象
* @param noteId 笔记ID
* @param folderId 文件夹ID
*/
private WorkingNote(Context context, long noteId, long folderId) {
mContext = context;
mNoteId = noteId;
@ -124,6 +167,10 @@ public class WorkingNote {
loadNote();
}
/**
* 从数据库加载笔记的基本信息
* @throws IllegalArgumentException 如果找不到指定ID的笔记
*/
private void loadNote() {
Cursor cursor = mContext.getContentResolver().query(
ContentUris.withAppendedId(Notes.CONTENT_NOTE_URI, mNoteId), NOTE_PROJECTION, null,
@ -146,6 +193,10 @@ public class WorkingNote {
loadNoteData();
}
/**
* 从数据库加载笔记的具体数据内容
* @throws IllegalArgumentException 如果找不到指定ID的笔记数据
*/
private void loadNoteData() {
Cursor cursor = mContext.getContentResolver().query(Notes.CONTENT_DATA_URI, DATA_PROJECTION,
DataColumns.NOTE_ID + "=?", new String[] {
@ -174,6 +225,15 @@ public class WorkingNote {
}
}
/**
* 创建一个新的空笔记
* @param context 上下文对象
* @param folderId 文件夹ID
* @param widgetId 小组件ID
* @param widgetType 小组件类型
* @param defaultBgColorId 默认背景颜色ID
* @return 创建的空笔记对象
*/
public static WorkingNote createEmptyNote(Context context, long folderId, int widgetId,
int widgetType, int defaultBgColorId) {
WorkingNote note = new WorkingNote(context, folderId);
@ -183,10 +243,21 @@ public class WorkingNote {
return note;
}
/**
* 从数据库加载指定ID的笔记
* @param context 上下文对象
* @param id 笔记ID
* @return 加载的工作笔记对象
*/
public static WorkingNote load(Context context, long id) {
return new WorkingNote(context, id, 0);
}
/**
* 保存笔记到数据库
* 该方法是线程安全的，确保在多线程环境下正确保存笔记
* @return 保存成功返回true，否则返回false
*/
public synchronized boolean saveNote() {
if (isWorthSaving()) {
if (!existInDatabase()) {
@ -212,10 +283,18 @@ public class WorkingNote {
}
}
/**
* 检查笔记是否已存在于数据库中
* @return 存在返回true，否则返回false
*/
public boolean existInDatabase() {
return mNoteId > 0;
}
/**
* 判断笔记是否值得保存到数据库
* @return 如果笔记值得保存返回true，否则返回false
*/
private boolean isWorthSaving() {
if (mIsDeleted || (!existInDatabase() && TextUtils.isEmpty(mContent))
|| (existInDatabase() && !mNote.isLocalModified())) {
@ -225,10 +304,19 @@ public class WorkingNote {
}
}
/**
* 设置笔记设置变化监听器
* @param l 笔记设置变化监听器
*/
public void setOnSettingStatusChangedListener(NoteSettingChangedListener l) {
mNoteSettingStatusListener = l;
}
/**
* 设置笔记的提醒日期
* @param date 提醒日期（时间戳）
* @param set 是否设置提醒
*/
public void setAlertDate(long date, boolean set) {
if (date != mAlertDate) {
mAlertDate = date;
@ -239,6 +327,10 @@ public class WorkingNote {
}
}
/**
* 标记笔记为已删除或未删除
* @param mark true表示标记为已删除，false表示标记为未删除
*/
public void markDeleted(boolean mark) {
mIsDeleted = mark;
if (mWidgetId != AppWidgetManager.INVALID_APPWIDGET_ID
@ -247,6 +339,10 @@ public class WorkingNote {
}
}
/**
* 设置笔记的背景颜色ID
* @param id 背景颜色ID
*/
public void setBgColorId(int id) {
if (id != mBgColorId) {
mBgColorId = id;
@ -257,6 +353,10 @@ public class WorkingNote {
}
}
/**
* 设置笔记的检查列表模式
* @param mode 模式类型（0表示普通模式，1表示检查列表模式）
*/
public void setCheckListMode(int mode) {
if (mMode != mode) {
if (mNoteSettingStatusListener != null) {
@ -267,6 +367,10 @@ public class WorkingNote {
}
}
/**
* 设置笔记的小组件类型
* @param type 小组件类型
*/
public void setWidgetType(int type) {
if (type != mWidgetType) {
mWidgetType = type;
@ -274,6 +378,10 @@ public class WorkingNote {
}
}
/**
* 设置笔记的小组件ID
* @param id 小组件ID
*/
public void setWidgetId(int id) {
if (id != mWidgetId) {
mWidgetId = id;
@ -281,6 +389,10 @@ public class WorkingNote {
}
}
/**
* 设置笔记的工作文本内容
* @param text 笔记内容文本
*/
public void setWorkingText(String text) {
if (!TextUtils.equals(mContent, text)) {
mContent = text;
@ -288,80 +400,139 @@ public class WorkingNote {
}
}
/**
* 将普通笔记转换为通话记录笔记
* @param phoneNumber 电话号码
* @param callDate 通话日期（时间戳）
*/
public void convertToCallNote(String phoneNumber, long callDate) {
mNote.setCallData(CallNote.CALL_DATE, String.valueOf(callDate));
mNote.setCallData(CallNote.PHONE_NUMBER, phoneNumber);
mNote.setNoteValue(NoteColumns.PARENT_ID, String.valueOf(Notes.ID_CALL_RECORD_FOLDER));
}
/**
* 检查笔记是否设置了时钟提醒
* @return 如果设置了提醒返回true，否则返回false
*/
public boolean hasClockAlert() {
return (mAlertDate > 0 ? true : false);
}
/**
* 获取笔记的内容
* @return 笔记内容文本
*/
public String getContent() {
return mContent;
}
/**
* 获取笔记的提醒日期
* @return 提醒日期（时间戳）
*/
public long getAlertDate() {
return mAlertDate;
}
/**
* 获取笔记的最后修改日期
* @return 最后修改日期（时间戳）
*/
public long getModifiedDate() {
return mModifiedDate;
}
/**
* 获取笔记背景颜色的资源ID
* @return 背景颜色资源ID
*/
public int getBgColorResId() {
return NoteBgResources.getNoteBgResource(mBgColorId);
}
/**
* 获取笔记的背景颜色ID
* @return 背景颜色ID
*/
public int getBgColorId() {
return mBgColorId;
}
/**
* 获取笔记标题背景颜色的资源ID
* @return 标题背景颜色资源ID
*/
public int getTitleBgResId() {
return NoteBgResources.getNoteTitleBgResource(mBgColorId);
}
/**
* 获取笔记的检查列表模式
* @return 模式类型（0表示普通模式，1表示检查列表模式）
*/
public int getCheckListMode() {
return mMode;
}
/**
* 获取笔记的ID
* @return 笔记ID
*/
public long getNoteId() {
return mNoteId;
}
/**
* 获取笔记所在的文件夹ID
* @return 文件夹ID
*/
public long getFolderId() {
return mFolderId;
}
/**
* 获取笔记关联的小组件ID
* @return 小组件ID
*/
public int getWidgetId() {
return mWidgetId;
}
/**
* 获取笔记关联的小组件类型
* @return 小组件类型
*/
public int getWidgetType() {
return mWidgetType;
}
/**
* 笔记设置变化监听器接口
* 用于监听笔记设置的变化，如背景颜色、提醒时间、小组件和检查列表模式等
*/
public interface NoteSettingChangedListener {
/**
* Called when the background color of current note has just changed
* 当笔记的背景颜色发生变化时调用
*/
void onBackgroundColorChanged();
/**
* Called when user set clock
* 当用户设置或修改提醒时间时调用
* @param date 提醒日期（时间戳）
* @param set 是否设置提醒
*/
void onClockAlertChanged(long date, boolean set);
/**
* Call when user create note from widget
* 当用户通过小组件创建或修改笔记时调用
*/
void onWidgetChanged();
/**
* Call when switch between check list mode and normal mode
* @param oldMode is previous mode before change
* @param newMode is new mode
* 当笔记在检查列表模式和普通模式之间切换时调用
* @param oldMode 切换前的模式
* @param newMode 切换后的模式
*/
void onCheckListModeChanged(int oldMode, int newMode);
}

Write Preview
Loading…
Cancel
Save