mvpola2e5
/
gitProject
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

杨馥银 <代码注释>

Browse Source
yangfuyin_branch
LAPTOP-OFDKBR75\aa 2 years ago
parent 8ed1c0cb9b
commit dce0f14416
5 changed files with 159 additions and 2 deletions
Show Stats Download Patch File Download Diff File

17
src/main/java/net/micode/notes/gtask/remote/GTaskASyncTask.java
Unescape View File

@ -28,23 +28,29 @@ import net.micode.notes.R;
import net.micode.notes.ui.NotesListActivity;
import net.micode.notes.ui.NotesPreferenceActivity;
//实现GTask的异步操作过程
public class GTaskASyncTask extends AsyncTask<Void, String, Integer> {
private static int GTASK_SYNC_NOTIFICATION_ID = 5234235;
//通过interface实现多个接口，初始化异步的功能。
public interface OnCompleteListener {
void onComplete();
}
//文本内容
private Context mContext;
//实例化通知管理器
private NotificationManager mNotifiManager;
//实例化任务管理器
private GTaskManager mTaskManager;
//实例化监听器
private OnCompleteListener mOnCompleteListener;
//GTaskASyncTask类的构造函数
public GTaskASyncTask(Context context, OnCompleteListener listener) {
mContext = context;
mOnCompleteListener = listener;
@ -53,18 +59,22 @@ public class GTaskASyncTask extends AsyncTask<Void, String, Integer> {
mTaskManager = GTaskManager.getInstance();
}
//中断同步
public void cancelSync() {
mTaskManager.cancelSync();
}
//调用onProgressUpdate方法来更新进度条
public void publishProgess(String message) {
publishProgress(new String[] {
message
});
}
//向用户显示当前的同步状态
private void showNotification(int tickerId, String content) {
PendingIntent pendingIntent;
// 如果同步失败，那么从系统取得一个用于启动一个NotesPreferenceActivity的PendingIntent对象
if (tickerId != R.string.ticker_success) {
pendingIntent = PendingIntent.getActivity(mContext, 0, new Intent(mContext,
NotesPreferenceActivity.class), 0);
@ -87,6 +97,7 @@ public class GTaskASyncTask extends AsyncTask<Void, String, Integer> {
}
@Override
//异步执行后台线程将要完成的任务
protected Integer doInBackground(Void... unused) {
publishProgess(mContext.getString(R.string.sync_progress_login, NotesPreferenceActivity
.getSyncAccountName(mContext)));
@ -94,6 +105,7 @@ public class GTaskASyncTask extends AsyncTask<Void, String, Integer> {
}
@Override
//用于显示任务执行的进度
protected void onProgressUpdate(String... progress) {
showNotification(R.string.ticker_syncing, progress[0]);
if (mContext instanceof GTaskSyncService) {
@ -102,7 +114,9 @@ public class GTaskASyncTask extends AsyncTask<Void, String, Integer> {
}
@Override
//用于设置任务
protected void onPostExecute(Integer result) {
//若同步成功，则显示成功并展示出同步的账户与最新同步时间，若同步出现网络错误，则显示相应错误
if (result == GTaskManager.STATE_SUCCESS) {
showNotification(R.string.ticker_success, mContext.getString(
R.string.success_sync_account, mTaskManager.getSyncAccount()));
@ -118,6 +132,7 @@ public class GTaskASyncTask extends AsyncTask<Void, String, Integer> {
if (mOnCompleteListener != null) {
new Thread(new Runnable() {
//执行完后调用然后返回主线程中
public void run() {
mOnCompleteListener.onComplete();
}

27
src/main/java/net/micode/notes/gtask/remote/GTaskClient.java
Unescape View File

@ -61,17 +61,24 @@ import java.util.zip.Inflater;
import java.util.zip.InflaterInputStream;
//实现GTask的登录并进行GTASK任务的创建，创建任务列表，从网络上获取任务和任务列表的内容
public class GTaskClient {
//设置本类的TAG，作用是日志的打印输出和标识此类。
private static final String TAG = GTaskClient.class.getSimpleName();
//谷歌邮箱的URL
private static final String GTASK_URL = "https://mail.google.com/tasks/";
//传递URL
private static final String GTASK_GET_URL = "https://mail.google.com/tasks/ig";
//传递的url
private static final String GTASK_POST_URL = "https://mail.google.com/tasks/r/ig";
//后续使用的参数以及变量
private static GTaskClient mInstance = null;
//网络地址客户端
private DefaultHttpClient mHttpClient;
private String mGetUrl;
@ -90,6 +97,7 @@ public class GTaskClient {
private JSONArray mUpdateArray;
//GTaskClient的构造函数
private GTaskClient() {
mHttpClient = null;
mGetUrl = GTASK_GET_URL;
@ -102,6 +110,7 @@ public class GTaskClient {
mUpdateArray = null;
}
//获取实例，如果当前没有示例，则新建一个登陆的Gtask，如果有直接返回
public static synchronized GTaskClient getInstance() {
if (mInstance == null) {
mInstance = new GTaskClient();
@ -109,6 +118,7 @@ public class GTaskClient {
return mInstance;
}
//用来实现登录操作的函数
public boolean login(Activity activity) {
// we suppose that the cookie would expire after 5 minutes
// then we need to re-login
@ -164,6 +174,7 @@ public class GTaskClient {
return true;
}
//用以具体实现登录Google账号的方法，方法返回账号令牌
private String loginGoogleAccount(Activity activity, boolean invalidateToken) {
String authToken;
AccountManager accountManager = AccountManager.get(activity);
@ -207,6 +218,7 @@ public class GTaskClient {
return authToken;
}
//判断令牌对于登陆gtask账号是否有效的函数
private boolean tryToLoginGtask(Activity activity, String authToken) {
if (!loginGtask(authToken)) {
// maybe the auth token is out of date, now let's invalidate the
@ -225,6 +237,7 @@ public class GTaskClient {
return true;
}
//实现登录Gtask方法的函数
private boolean loginGtask(String authToken) {
int timeoutConnection = 10000;
int timeoutSocket = 15000;
@ -280,10 +293,12 @@ public class GTaskClient {
return true;
}
//得到用户的ID返回并加1
private int getActionId() {
return mActionId++;
}
//创建一个httpPost对象，用于向网络传输数据
private HttpPost createHttpPost() {
HttpPost httpPost = new HttpPost(mPostUrl);
httpPost.setHeader("Content-Type", "application/x-www-form-urlencoded;charset=utf-8");
@ -291,6 +306,7 @@ public class GTaskClient {
return httpPost;
}
//通过URL获取响应后返回的数据，使用getContentEncoding()获取网络上的资源和数据，返回值就是获取到的资源
private String getResponseContent(HttpEntity entity) throws IOException {
String contentEncoding = null;
if (entity.getContentEncoding() != null) {
@ -323,6 +339,7 @@ public class GTaskClient {
}
}
//通过JSON发送请求,利用UrlEncodedFormEntity entity和httpPost.setEntity把js中的内容放置到httpPost中后将资源再次放入json后返回
private JSONObject postRequest(JSONObject js) throws NetworkFailureException {
if (!mLoggedin) {
Log.e(TAG, "please login first");
@ -360,6 +377,7 @@ public class GTaskClient {
}
}
//创建单个任务，通过json获取TASK中的内容并创建对应的jsPost，使用setGid方法设置task的new_id
public void createTask(Task task) throws NetworkFailureException {
commitUpdate();
try {
@ -386,6 +404,7 @@ public class GTaskClient {
}
}
//创建任务列表
public void createTaskList(TaskList tasklist) throws NetworkFailureException {
commitUpdate();
try {
@ -412,6 +431,7 @@ public class GTaskClient {
}
}
//利用JSON提交更新数据
public void commitUpdate() throws NetworkFailureException {
if (mUpdateArray != null) {
try {
@ -433,6 +453,7 @@ public class GTaskClient {
}
}
//利用commitUpdate添加更新节点
public void addUpdateNode(Node node) throws NetworkFailureException {
if (node != null) {
// too many update items may result in an error
@ -447,6 +468,7 @@ public class GTaskClient {
}
}
//移动任务
public void moveTask(Task task, TaskList preParent, TaskList curParent)
throws NetworkFailureException {
commitUpdate();
@ -486,6 +508,7 @@ public class GTaskClient {
}
}
//删除操作节点
public void deleteNode(Node node) throws NetworkFailureException {
commitUpdate();
try {
@ -509,6 +532,7 @@ public class GTaskClient {
}
}
//获取任务列表，首先通过getURI在网上获取数据，在截取所需部分内容返回
public JSONArray getTaskLists() throws NetworkFailureException {
if (!mLoggedin) {
Log.e(TAG, "please login first");
@ -547,6 +571,7 @@ public class GTaskClient {
}
}
//获取任务列表
public JSONArray getTaskList(String listGid) throws NetworkFailureException {
commitUpdate();
try {
@ -575,10 +600,12 @@ public class GTaskClient {
}
}
//获得同步账户
public Account getSyncAccount() {
return mAccount;
}
//重置更新内容
public void resetUpdateArray() {
mUpdateArray = null;
}

54
src/main/java/net/micode/notes/gtask/remote/GTaskManager.java
Unescape View File

@ -47,10 +47,12 @@ import java.util.HashSet;
import java.util.Iterator;
import java.util.Map;
//声明GTask管理类，封装了对GTask进行管理的一些方法
public class GTaskManager {
//通过 getSimpleName()得到类的简写名称。然后赋值给TAG
private static final String TAG = GTaskManager.class.getSimpleName();
//进程状态：用0、1、2、3、4分别表示成功、网络错误、内部错误、同步中、取消同步
public static final int STATE_SUCCESS = 0;
public static final int STATE_NETWORK_ERROR = 1;
@ -61,6 +63,7 @@ public class GTaskManager {
public static final int STATE_SYNC_CANCELLED = 4;
// private 定义一系列不可被外部的类访问的量
private static GTaskManager mInstance = null;
private Activity mActivity;
@ -87,6 +90,7 @@ public class GTaskManager {
private HashMap<Long, String> mNidToGid;
//该类的构造函数
private GTaskManager() {
mSyncing = false;
mCancelled = false;
@ -99,6 +103,7 @@ public class GTaskManager {
mNidToGid = new HashMap<Long, String>();
}
//获取一个实例，通过GTaskManager()新建一个mInstance
public static synchronized GTaskManager getInstance() {
if (mInstance == null) {
mInstance = new GTaskManager();
@ -106,20 +111,25 @@ public class GTaskManager {
return mInstance;
}
//setActivityContext()用于获取当前的操作并更新至GTask中
public synchronized void setActivityContext(Activity activity) {
// used for getting authtoken
mActivity = activity;
}
//同步的总控制，包括同步前设置环境，进行同步，处理异常，同步结束清空缓存
public int sync(Context context, GTaskASyncTask asyncTask) {
if (mSyncing) {
Log.d(TAG, "Sync is in progress");
return STATE_SYNC_IN_PROGRESS;
}
mContext = context;
mContentResolver = mContext.getContentResolver();
//初始化各种标志变量
mSyncing = true;
mCancelled = false;
//对各种结构进行清空
mGTaskListHashMap.clear();
mGTaskHashMap.clear();
mMetaHashMap.clear();
@ -132,6 +142,7 @@ public class GTaskManager {
client.resetUpdateArray();
// login google task
//登录谷歌账号
if (!mCancelled) {
if (!client.login(mActivity)) {
throw new NetworkFailureException("login google task failed");
@ -139,10 +150,12 @@ public class GTaskManager {
}
// get the task list from google
//从谷歌获取任务清单
asyncTask.publishProgess(mContext.getString(R.string.sync_progress_init_list));
initGTaskList();
// do content sync work
//获取Google上的JSONtasklist转为本地TaskList
asyncTask.publishProgess(mContext.getString(R.string.sync_progress_syncing));
syncContent();
} catch (NetworkFailureException e) {
@ -168,6 +181,7 @@ public class GTaskManager {
return mCancelled ? STATE_SYNC_CANCELLED : STATE_SUCCESS;
}
//初始化GTask列表，将google上的JSONTaskList转为本地任务列表
private void initGTaskList() throws NetworkFailureException {
if (mCancelled)
return;
@ -247,6 +261,7 @@ public class GTaskManager {
}
}
//选择同步操作的类型并做好相应准备 具体做法是对每一种情况都把所有的任务判断一次，一旦发现是该种情况，就立即执行任务，否则判断下个任务
private void syncContent() throws NetworkFailureException {
int syncType;
Cursor c = null;
@ -260,6 +275,7 @@ public class GTaskManager {
}
// for local deleted note
//处理本地删除的note
try {
c = mContentResolver.query(Notes.CONTENT_NOTE_URI, SqlNote.PROJECTION_NOTE,
"(type<>? AND parent_id=?)", new String[] {
@ -290,6 +306,7 @@ public class GTaskManager {
syncFolder();
// for note existing in database
//对已经存在与数据库的节点进行同步
try {
c = mContentResolver.query(Notes.CONTENT_NOTE_URI, SqlNote.PROJECTION_NOTE,
"(type=? AND parent_id<>?)", new String[] {
@ -327,6 +344,7 @@ public class GTaskManager {
}
// go through remaining items
//访问保留的项目
Iterator<Map.Entry<String, Node>> iter = mGTaskHashMap.entrySet().iterator();
while (iter.hasNext()) {
Map.Entry<String, Node> entry = iter.next();
@ -337,6 +355,7 @@ public class GTaskManager {
// mCancelled can be set by another thread, so we neet to check one by
// one
// clear local delete table
//清除本地删除的表格
if (!mCancelled) {
if (!DataUtils.batchDeleteNotes(mContentResolver, mLocalDeleteIdMap)) {
throw new ActionFailureException("failed to batch-delete local deleted notes");
@ -351,6 +370,7 @@ public class GTaskManager {
}
//对文件夹进行同步，具体操作与之前的同步操作一致
private void syncFolder() throws NetworkFailureException {
Cursor c = null;
String gid;
@ -362,6 +382,7 @@ public class GTaskManager {
}
// for root folder
//同步根目录
try {
c = mContentResolver.query(ContentUris.withAppendedId(Notes.CONTENT_NOTE_URI,
Notes.ID_ROOT_FOLDER), SqlNote.PROJECTION_NOTE, null, null, null);
@ -391,6 +412,7 @@ public class GTaskManager {
}
// for call-note folder
//同步来电记录的文件夹
try {
c = mContentResolver.query(Notes.CONTENT_NOTE_URI, SqlNote.PROJECTION_NOTE, "(_id=?)",
new String[] {
@ -425,6 +447,7 @@ public class GTaskManager {
}
// for local existing folders
//同步已经存在的文件夹
try {
c = mContentResolver.query(Notes.CONTENT_NOTE_URI, SqlNote.PROJECTION_NOTE,
"(type=? AND parent_id<>?)", new String[] {
@ -461,6 +484,7 @@ public class GTaskManager {
}
// for remote add folders
//同步远程添加的文件夹
Iterator<Map.Entry<String, TaskList>> iter = mGTaskListHashMap.entrySet().iterator();
while (iter.hasNext()) {
Map.Entry<String, TaskList> entry = iter.next();
@ -476,6 +500,7 @@ public class GTaskManager {
GTaskClient.getInstance().commitUpdate();
}
//在之前对于各方面的同步操作中多次调用了这个函数，作用是依据不同的同步类型去调用不同的函数，以达到本地与远程同步的实际操作
private void doContentSync(int syncType, Node node, Cursor c) throws NetworkFailureException {
if (mCancelled) {
return;
@ -522,12 +547,14 @@ public class GTaskManager {
}
}
//增加本地节点的操作，传入参量为待增添的节点
private void addLocalNode(Node node) throws NetworkFailureException {
if (mCancelled) {
return;
}
SqlNote sqlNote;
//若待添加节点是任务列表中的节点，则进行操作，若待增添节点不是任务列表中的节点，进一步操作
if (node instanceof TaskList) {
if (node.getName().equals(
GTaskStringUtils.MIUI_FOLDER_PREFFIX + GTaskStringUtils.FOLDER_DEFAULT)) {
@ -555,6 +582,7 @@ public class GTaskManager {
}
}
//以下为判断便签中的数据条目
if (js.has(GTaskStringUtils.META_HEAD_DATA)) {
JSONArray dataArray = js.getJSONArray(GTaskStringUtils.META_HEAD_DATA);
for (int i = 0; i < dataArray.length(); i++) {
@ -585,17 +613,21 @@ public class GTaskManager {
}
// create the local node
//把getGid()获取的node节点Gid，用于设置本地Gtask的ID，然后更新本地便签
sqlNote.setGtaskId(node.getGid());
sqlNote.commit(false);
// update gid-nid mapping
//更新gid与nid的映射表
mGidToNid.put(node.getGid(), sqlNote.getId());
mNidToGid.put(sqlNote.getId(), node.getGid());
// update meta
//更新本地节点
updateRemoteMeta(node.getGid(), sqlNote);
}
//更新本地节点，两个传入参数，一个是待更新的节点，一个是指向待增加位置的指针
private void updateLocalNode(Node node, Cursor c) throws NetworkFailureException {
if (mCancelled) {
return;
@ -616,9 +648,11 @@ public class GTaskManager {
sqlNote.commit(true);
// update meta info
//升级meta
updateRemoteMeta(node.getGid(), sqlNote);
}
//这个函数是添加远程结点，参数node是要添加远程结点的本地结点，c是数据库的指针
private void addRemoteNode(Node node, Cursor c) throws NetworkFailureException {
if (mCancelled) {
return;
@ -628,6 +662,7 @@ public class GTaskManager {
Node n;
// update remotely
// 如果sqlNote是节点类型，则设置好它的参数以及更新哈希表，再把节点更新到远程数据里
if (sqlNote.isNoteType()) {
Task task = new Task();
task.setContentByLocalJSON(sqlNote.getContent());
@ -648,6 +683,7 @@ public class GTaskManager {
TaskList tasklist = null;
// we need to skip folder if it has already existed
//当文件夹存在则跳过，若不存在则创建新的文件夹
String folderName = GTaskStringUtils.MIUI_FOLDER_PREFFIX;
if (sqlNote.getId() == Notes.ID_ROOT_FOLDER)
folderName += GTaskStringUtils.FOLDER_DEFAULT;
@ -672,6 +708,7 @@ public class GTaskManager {
}
// no match we can add now
//若没有匹配的任务列表，则创建一个新的任务列表
if (tasklist == null) {
tasklist = new TaskList();
tasklist.setContentByLocalJSON(sqlNote.getContent());
@ -682,16 +719,19 @@ public class GTaskManager {
}
// update local note
//进行本地节点的更新
sqlNote.setGtaskId(n.getGid());
sqlNote.commit(false);
sqlNote.resetLocalModified();
sqlNote.commit(true);
// gid-id mapping
//进行gid与nid映射关系的更新
mGidToNid.put(n.getGid(), sqlNote.getId());
mNidToGid.put(sqlNote.getId(), n.getGid());
}
//更新远程结点，node是要更新的结点，c是数据库的指针
private void updateRemoteNode(Node node, Cursor c) throws NetworkFailureException {
if (mCancelled) {
return;
@ -700,13 +740,16 @@ public class GTaskManager {
SqlNote sqlNote = new SqlNote(mContext, c);
// update remotely
//远程更新
node.setContentByLocalJSON(sqlNote.getContent());
GTaskClient.getInstance().addUpdateNode(node);
// update meta
//更新元数据
updateRemoteMeta(node.getGid(), sqlNote);
// move task if necessary
//判断节点类型是否符合要求
if (sqlNote.isNoteType()) {
Task task = (Task) node;
TaskList preParentList = task.getParent();
@ -726,10 +769,12 @@ public class GTaskManager {
}
// clear local modified flag
//清除本地修改标记
sqlNote.resetLocalModified();
sqlNote.commit(true);
}
//更新远程的元数据节点
private void updateRemoteMeta(String gid, SqlNote sqlNote) throws NetworkFailureException {
if (sqlNote != null && sqlNote.isNoteType()) {
MetaData metaData = mMetaHashMap.get(gid);
@ -746,6 +791,7 @@ public class GTaskManager {
}
}
//刷新本地便签ID，从远程同步
private void refreshLocalSyncId() throws NetworkFailureException {
if (mCancelled) {
return;
@ -758,6 +804,10 @@ public class GTaskManager {
initGTaskList();
Cursor c = null;
//query语句：五个参数，NoteColumns.TYPE + " DESC"-----为按类型递减顺序返回查询结果。
// newString[{String.valueOf(Notes.TYPE_SYSTEM),String.valueOf(Notes.ID_TRASH_FOLER)}
//------ 为选择参数。"(type<>? AND parent_id<>?)"-------指明返回行过滤器。SqlNote.PROJECTION_NOTE
//-------- 应返回的数据列的名字。Notes.CONTENT_NOTE_URI--------contentProvider包含所有数据集所对应的uri
try {
c = mContentResolver.query(Notes.CONTENT_NOTE_URI, SqlNote.PROJECTION_NOTE,
"(type<>? AND parent_id<>?)", new String[] {
@ -790,10 +840,12 @@ public class GTaskManager {
}
}
//string类化getSyncAccount()
public String getSyncAccount() {
return GTaskClient.getInstance().getSyncAccount().name;
}
//取消同步，置mCancelled为true
public void cancelSync() {
mCancelled = true;
}

20
src/main/java/net/micode/notes/gtask/remote/GTaskSyncService.java
Unescape View File

@ -23,26 +23,34 @@ import android.content.Intent;
import android.os.Bundle;
import android.os.IBinder;
//由Service组件扩展而来，作用是提供GTask的同步服务
public class GTaskSyncService extends Service {
//定义了一系列静态变量，用来表示同步操作的状态。
public final static String ACTION_STRING_NAME = "sync_action_type";
//用数字0、1、2分别表示开始同步、取消同步、同步无效
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";
//GTask 广播服务消息
public final static String GTASK_SERVICE_BROADCAST_PROGRESS_MSG = "progressMsg";
private static GTaskASyncTask mSyncTask = null;
private static String mSyncProgress = "";
//开始一个同步工作
private void startSync() {
//若当前没有同步工作，申请一个task并把指针指向新任务，广播后执行
if (mSyncTask == null) {
mSyncTask = new GTaskASyncTask(this, new GTaskASyncTask.OnCompleteListener() {
public void onComplete() {
@ -56,20 +64,25 @@ public class GTaskSyncService extends Service {
}
}
//取消同步
private void cancelSync() {
// 如果有同步任务，则取消
if (mSyncTask != null) {
mSyncTask.cancelSync();
}
}
@Override
//初始化任务，直接把mSyncTask指针的值置为空
public void onCreate() {
mSyncTask = null;
}
@Override
//onStartCommand会告诉系统如何重启服务，如判断是否异常终止后重新启动，在何种情况下异常终止。返回值是一个(int)整形，有四种返回值。参数的flags表示启动服务的方式
public int onStartCommand(Intent intent, int flags, int startId) {
Bundle bundle = intent.getExtras();
//判断当前的同步状态，根据开始或取消，执行对应操作
if (bundle != null && bundle.containsKey(ACTION_STRING_NAME)) {
switch (bundle.getInt(ACTION_STRING_NAME, ACTION_INVALID)) {
case ACTION_START_SYNC:
@ -87,16 +100,19 @@ public class GTaskSyncService extends Service {
}
@Override
//发送广播
public void onLowMemory() {
if (mSyncTask != null) {
mSyncTask.cancelSync();
}
}
//用于绑定操作的函数
public IBinder onBind(Intent intent) {
return null;
}
//发送广播内容
public void sendBroadcast(String msg) {
mSyncProgress = msg;
Intent intent = new Intent(GTASK_SERVICE_BROADCAST_NAME);
@ -105,6 +121,7 @@ public class GTaskSyncService extends Service {
sendBroadcast(intent);
}
//对变量activity事件进行同步操作
public static void startSync(Activity activity) {
GTaskManager.getInstance().setActivityContext(activity);
Intent intent = new Intent(activity, GTaskSyncService.class);
@ -112,16 +129,19 @@ public class GTaskSyncService extends Service {
activity.startService(intent);
}
//取消同步
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);
}
//判断当前是否处于同步状态
public static boolean isSyncing() {
return mSyncTask != null;
}
//返回当前同步状态
public static String getProgressString() {
return mSyncProgress;
}

43
src/main/java/net/micode/notes/model/WorkingNote.java
Unescape View File

@ -32,6 +32,7 @@ import net.micode.notes.data.Notes.TextNote;
import net.micode.notes.tool.ResourceParser.NoteBgResources;
//声明WorkingNote类,创建小米便签的主要类，包括创建空便签，保存便签，加载小米便签内容，和设置小米便签的一些小部件之类的操作
public class WorkingNote {
// Note for the working note
private Note mNote;
@ -62,6 +63,7 @@ public class WorkingNote {
private NoteSettingChangedListener mNoteSettingStatusListener;
//声明 NOTE_PROJECTION字符串数组
public static final String[] DATA_PROJECTION = new String[] {
DataColumns.ID,
DataColumns.CONTENT,
@ -102,6 +104,7 @@ public class WorkingNote {
private static final int NOTE_MODIFIED_DATE_COLUMN = 5;
// New note construct
//缺省noteID的构造函数，直接使用内容和文件号新建便签
private WorkingNote(Context context, long folderId) {
mContext = context;
mAlertDate = 0;
@ -115,6 +118,7 @@ public class WorkingNote {
}
// Existing note construct
//加载便签
private WorkingNote(Context context, long noteId, long folderId) {
mContext = context;
mNoteId = noteId;
@ -124,6 +128,7 @@ public class WorkingNote {
loadNote();
}
//输出mNoteId的所有属性值
private void loadNote() {
Cursor cursor = mContext.getContentResolver().query(
ContentUris.withAppendedId(Notes.CONTENT_NOTE_URI, mNoteId), NOTE_PROJECTION, null,
@ -146,6 +151,7 @@ public class WorkingNote {
loadNoteData();
}
//加载便签数据
private void loadNoteData() {
Cursor cursor = mContext.getContentResolver().query(Notes.CONTENT_DATA_URI, DATA_PROJECTION,
DataColumns.NOTE_ID + "=?", new String[] {
@ -174,6 +180,7 @@ public class WorkingNote {
}
}
//创建空的Note，传参：context，文件夹id，widget，背景颜色
public static WorkingNote createEmptyNote(Context context, long folderId, int widgetId,
int widgetType, int defaultBgColorId) {
WorkingNote note = new WorkingNote(context, folderId);
@ -183,12 +190,16 @@ public class WorkingNote {
return note;
}
//导入一个新的正在写入的便签
public static WorkingNote load(Context context, long id) {
return new WorkingNote(context, id, 0);
}
//保存note
public synchronized boolean saveNote() {
//判断是否有价值去保存
if (isWorthSaving()) {
//当数据库中没有当前版本便签的时候才需要保存
if (!existInDatabase()) {
if ((mNoteId = Note.getNewNoteId(mContext, mFolderId)) == 0) {
Log.e(TAG, "Create new note fail with id:" + mNoteId);
@ -201,6 +212,7 @@ public class WorkingNote {
/**
* Update widget content if there exist any widget of this note
*/
//判断窗口大小是否变化，如果变化也要保存这个变化
if (mWidgetId != AppWidgetManager.INVALID_APPWIDGET_ID
&& mWidgetType != Notes.TYPE_WIDGET_INVALIDE
&& mNoteSettingStatusListener != null) {
@ -212,11 +224,14 @@ public class WorkingNote {
}
}
//判断便签是否已经存在于数据库中
public boolean existInDatabase() {
return mNoteId > 0;
}
//判断是否有保存的必要性
private boolean isWorthSaving() {
//如果是误删，或者是空的，或者在本地并没有修改，那么不需要保存
if (mIsDeleted || (!existInDatabase() && TextUtils.isEmpty(mContent))
|| (existInDatabase() && !mNote.isLocalModified())) {
return false;
@ -225,11 +240,14 @@ public class WorkingNote {
}
}
//设置监听“设置状态改变”
public void setOnSettingStatusChangedListener(NoteSettingChangedListener l) {
mNoteSettingStatusListener = l;
}
//设置提示日期
public void setAlertDate(long date, boolean set) {
//若 mAlertDate与data不同，则更改mAlertDate并设定NoteValue
if (date != mAlertDate) {
mAlertDate = date;
mNote.setNoteValue(NoteColumns.ALERTED_DATE, String.valueOf(mAlertDate));
@ -239,6 +257,7 @@ public class WorkingNote {
}
}
//设定删除标记
public void markDeleted(boolean mark) {
mIsDeleted = mark;
if (mWidgetId != AppWidgetManager.INVALID_APPWIDGET_ID
@ -247,9 +266,11 @@ public class WorkingNote {
}
}
//设置背景颜色为第ID号颜色
public void setBgColorId(int id) {
if (id != mBgColorId) {
mBgColorId = id;
//判断此id是否是背景颜色id，如果不是，则更新背景颜色
if (mNoteSettingStatusListener != null) {
mNoteSettingStatusListener.onBackgroundColorChanged();
}
@ -257,7 +278,9 @@ public class WorkingNote {
}
}
//设定检查列表模式
public void setCheckListMode(int mode) {
//如果传入的模式与原模式不同，则更改原模式为当前模式
if (mMode != mode) {
if (mNoteSettingStatusListener != null) {
mNoteSettingStatusListener.onCheckListModeChanged(mMode, mode);
@ -267,81 +290,101 @@ public class WorkingNote {
}
}
//设置窗口类型
public void setWidgetType(int type) {
//判断传入的类型是否与当前类型一样，否则更改为传入的类型并储存便签的窗口数据
if (type != mWidgetType) {
mWidgetType = type;
mNote.setNoteValue(NoteColumns.WIDGET_TYPE, String.valueOf(mWidgetType));
}
}
//设置窗口编号
public void setWidgetId(int id) {
// 判断传入是否与当前id一样，否则更改为传入id
if (id != mWidgetId) {
mWidgetId = id;
mNote.setNoteValue(NoteColumns.WIDGET_ID, String.valueOf(mWidgetId));
}
}
//设定编辑文本
public void setWorkingText(String text) {
//判断文本内容是否相同，否则更新文本
if (!TextUtils.equals(mContent, text)) {
mContent = text;
mNote.setTextData(DataColumns.CONTENT, mContent);
}
}
//转换成电话提醒的便签
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));
}
//判断是否有时钟提醒
public boolean hasClockAlert() {
return (mAlertDate > 0 ? true : false);
}
//获取便签内容
public String getContent() {
return mContent;
}
//获取待提醒日期
public long getAlertDate() {
return mAlertDate;
}
//获取修改之后的日期
public long getModifiedDate() {
return mModifiedDate;
}
//获取背景颜色资源ID
public int getBgColorResId() {
return NoteBgResources.getNoteBgResource(mBgColorId);
}
//获取背景颜色ID
public int getBgColorId() {
return mBgColorId;
}
//获取标题背景来源
public int getTitleBgResId() {
return NoteBgResources.getNoteTitleBgResource(mBgColorId);
}
//获取清单的模式
public int getCheckListMode() {
return mMode;
}
//获取便签ID
public long getNoteId() {
return mNoteId;
}
//获取文件夹ID
public long getFolderId() {
return mFolderId;
}
//获取窗口编号
public int getWidgetId() {
return mWidgetId;
}
//监听检测便签设置变化的接口
public int getWidgetType() {
return mWidgetType;
}
//监听便签内部所有属性改变，当便签的属性改变的时候，这个类里面会有相应的记录，但是这个类只有个框架。
public interface NoteSettingChangedListener {
/**
* Called when the background color of current note has just changed

Write Preview
Loading…
Cancel
Save