ui_m

src/ui(m)/NotesListActivity.java

@@ -0,0 +1,790 @@
+/*
+ * Copyright (c) 2010-2011, The MiCode Open Source Community (www.micode.net)
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *        http://www.apache.org/licenses/LICENSE-2.0
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package net.micode.notes.ui;
+
+import android.app.Activity;
+import android.app.AlertDialog;
+import android.app.Dialog;
+// ...（省略其他import）
+
+// NotesListActivity类继承自Activity，用于展示笔记列表
+public class NotesListActivity extends Activity implements OnClickListener, OnItemLongClickListener {
+    // 定义了一些查询操作的token，用于识别不同的查询请求
+    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;
+    // 偏好设置的键，用于检查是否显示过介绍信息
+    private static final String PREFERENCE_ADD_INTRODUCTION = "net.micode.notes.introduction";
+    // 枚举，表示不同的列表编辑状态
+    private enum ListEditState {
+        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 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)";
+    private final static int REQUEST_CODE_OPEN_NODE = 102;
+    private final static int REQUEST_CODE_NEW_NODE  = 103;
+
+    @Override
+    protected void onCreate(Bundle savedInstanceState) {
+        super.onCreate(savedInstanceState);
+        setContentView(R.layout.note_list);
+        initResources();
+
+        /**
+         * 当用户首次使用应用程序时插入介绍信息
+         */
+        setAppInfoFromRawRes();
+    }
+
+    /**
+     * 从raw资源文件中读取介绍信息，并将其保存为笔记
+     */
+    private void setAppInfoFromRawRes() {
+        SharedPreferences sp = PreferenceManager.getDefaultSharedPreferences(this);
+        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);
+                    char [] buf = new char[1024];
+                    int len = 0;
+                    while ((len = br.read(buf)) > 0) {
+                        sb.append(buf, 0, len);
+                    }
+                } else {
+                    Log.e(TAG, "Read introduction file error");
+                    return;
+                }
+            } catch (IOException e) {
+                e.printStackTrace();
+                return;
+            } finally {
+                if(in != null) {
+                    try {
+                        in.close();
+                    } catch (IOException e) {
+                        // TODO Auto-generated catch block
+                        e.printStackTrace();
+                    }
+                }
+            }
+
+            WorkingNote note = WorkingNote.createEmptyNote(this, Notes.ID_ROOT_FOLDER,
+                    AppWidgetManager.INVALID_APPWIDGET_ID, Notes.TYPE_WIDGET_INVALIDE,
+                    ResourceParser.RED);
+            note.setWorkingText(sb.toString());
+            if (note.saveNote()) {
+                sp.edit().putBoolean(PREFERENCE_ADD_INTRODUCTION, true).commit();
+            } else {
+                Log.e(TAG, "Save introduction note error");
+                return;
+            }
+        }
+    }
+
+    @Override
+    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);
+        } else {
+            super.onActivityResult(requestCode, resultCode, data);
+        }
+    }
+
+    /**
+     * 初始化活动所需的资源，包括内容解析器、适配器、列表视图等
+     */
+    private void initResources() {
+        mContentResolver = this.getContentResolver();
+        mBackgroundQueryHandler = new BackgroundQueryHandler(this.getContentResolver());
+        mCurrentFolderId = Notes.ID_ROOT_FOLDER;
+        mNotesListView = (ListView) findViewById(R.id.notes_list);
+        mNotesListView.addFooterView(LayoutInflater.from(this).inflate(R.layout.note_list_footer, null), null, false);
+        mNotesListView.setOnItemClickListener(new OnListItemClickListener());
+        mNotesListView.setOnItemLongClickListener(this);
+        mNotesListAdapter = new NotesListAdapter(this);
+        mNotesListView.setAdapter(mNotesListAdapter);
+        mAddNewNote = (Button) findViewById(R.id.btn_new_note);
+        mAddNewNote.setOnClickListener(this);
+        mAddNewNote.setOnTouchListener(new NewNoteOnTouchListener());
+        mDispatch = false;
+        mDispatchY = 0;
+        mOriginY = 0;
+        mTitleBar = (TextView) findViewById(R.id.tv_title_bar);
+        mState = ListEditState.NOTE_LIST;
+        mModeCallBack = new ModeCallback();
+    }
+    // 内部类，用于处理多点触控事件，当用户触摸“新建笔记”按钮时的特殊处理
+    private class NewNoteOnTouchListener implements OnTouchListener {
+        public boolean onTouch(View v, MotionEvent event) {
+            switch (event.getAction()) {
+                case MotionEvent.ACTION_DOWN: {
+                    // 计算屏幕高度和“新建笔记”按钮的高度差
+                    Display display = getWindowManager().getDefaultDisplay();
+                    int screenHeight = display.getHeight();
+                    int newNoteViewHeight = mAddNewNote.getHeight();
+                    int start = screenHeight - newNoteViewHeight;
+                    int eventY = start + (int) event.getY();
+                    // 根据UI设计师的要求，对“新建笔记”按钮的透明部分进行特殊处理
+                    if (event.getY() < (event.getX() * (-0.12) + 94)) {
+                        View view = mNotesListView.getChildAt(mNotesListView.getChildCount() - 1
+                                - mNotesListView.getFooterViewsCount());
+                        if (view != null && view.getBottom() > start
+                                && (view.getTop() < (start + 94))) {
+                            mOriginY = (int) event.getY();
+                            mDispatchY = eventY;
+                            event.setLocation(event.getX(), mDispatchY);
+                            mDispatch = true;
+                            return mNotesListView.dispatchTouchEvent(event);
+                        }
+                    }
+                    break;
+                }
+                case MotionEvent.ACTION_MOVE: {
+                    if (mDispatch) {
+                        mDispatchY += (int) event.getY() - mOriginY;
+                        event.setLocation(event.getX(), mDispatchY);
+                        return mNotesListView.dispatchTouchEvent(event);
+                    }
+                    break;
+                }
+                default: {
+                    if (mDispatch) {
+                        event.setLocation(event.getX(), mDispatchY);
+                        mDispatch = false;
+                        return mNotesListView.dispatchTouchEvent(event);
+                    }
+                    break;
+                }
+            }
+            return false;
+        }
+    };
+
+    /**
+     * 启动异步查询，获取笔记列表
+     */
+    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");
+    }
+
+    // 异步查询处理器，处理查询完成事件
+    private final class BackgroundQueryHandler extends AsyncQueryHandler {
+        public BackgroundQueryHandler(ContentResolver contentResolver) {
+            super(contentResolver);
+        }
+
+        @Override
+        protected void onQueryComplete(int token, Object cookie, Cursor cursor) {
+            switch (token) {
+                case FOLDER_NOTE_LIST_QUERY_TOKEN:
+                    mNotesListAdapter.changeCursor(cursor);
+                    break;
+                case FOLDER_LIST_QUERY_TOKEN:
+                    if (cursor != null && cursor.getCount() > 0) {
+                        showFolderListMenu(cursor);
+                    } else {
+                        Log.e(TAG, "Query folder failed");
+                    }
+                    break;
+                default:
+                    return;
+            }
+        }
+    }
+
+    /**
+     * 显示文件夹列表菜单，允许用户选择目标文件夹
+     */
+    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);
+        builder.setAdapter(adapter, new DialogInterface.OnClickListener() {
+            public void onClick(DialogInterface dialog, int which) {
+                DataUtils.batchMoveToFolder(mContentResolver,
+                        mNotesListAdapter.getSelectedItemIds(), adapter.getItemId(which));
+                Toast.makeText(
+                        NotesListActivity.this,
+                        getString(R.string.format_move_notes_to_folder,
+                                mNotesListAdapter.getSelectedCount(),
+                                adapter.getFolderName(NotesListActivity.this, which)),
+                        Toast.LENGTH_SHORT).show();
+                mModeCallBack.finishActionMode();
+            }
+        });
+        builder.show();
+    }
+    /**
+     * 创建新笔记的函数
+     */
+    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() {
+        new AsyncTask<Void, Void, HashSet<AppWidgetAttribute>>() {
+            protected HashSet<AppWidgetAttribute> doInBackground(Void... unused) {
+                HashSet<AppWidgetAttribute> widgets = mNotesListAdapter.getSelectedWidget();
+                if (!isSyncMode()) {
+                    // 如果不是同步模式，直接删除笔记
+                    if (DataUtils.batchDeleteNotes(mContentResolver, mNotesListAdapter
+                            .getSelectedItemIds())) {
+                    } else {
+                        Log.e(TAG, "Delete notes error, should not happens");
+                    }
+                } else {
+                    // 如果是同步模式，将删除的笔记移动到回收站文件夹
+                    if (!DataUtils.batchMoveToFolder(mContentResolver, mNotesListAdapter
+                            .getSelectedItemIds(), Notes.ID_TRASH_FOLER)) {
+                        Log.e(TAG, "Move notes to trash folder error, should not happens");
+                    }
+                }
+                return widgets;
+            }
+
+            @Override
+            protected void onPostExecute(HashSet<AppWidgetAttribute> widgets) {
+                if (widgets != null) {
+                    for (AppWidgetAttribute widget : widgets) {
+                        if (widget.widgetId != AppWidgetManager.INVALID_APPWIDGET_ID
+                                && widget.widgetType != Notes.TYPE_WIDGET_INVALIDE) {
+                            updateWidget(widget.widgetId, widget.widgetType);
+                        }
+                    }
+                }
+                mModeCallBack.finishActionMode();
+            }
+        }.execute();
+    }
+
+    /**
+     * 删除文件夹的函数
+     */
+    private void deleteFolder(long folderId) {
+        if (folderId == Notes.ID_ROOT_FOLDER) {
+            Log.e(TAG, "Wrong folder id, should not happen " + folderId);
+            return;
+        }
+
+        HashSet<Long> ids = new HashSet<Long>();
+        ids.add(folderId);
+        HashSet<AppWidgetAttribute> widgets = DataUtils.getFolderNoteWidget(mContentResolver,
+                folderId);
+        if (!isSyncMode()) {
+            // 如果不是同步模式，直接删除文件夹
+            DataUtils.batchDeleteNotes(mContentResolver, ids);
+        } else {
+            // 如果是同步模式，将删除的文件夹移动到回收站文件夹
+            DataUtils.batchMoveToFolder(mContentResolver, ids, Notes.ID_TRASH_FOLER);
+        }
+        if (widgets != null) {
+            for (AppWidgetAttribute widget : widgets) {
+                if (widget.widgetId != AppWidgetManager.INVALID_APPWIDGET_ID
+                        && widget.widgetType != Notes.TYPE_WIDGET_INVALIDE) {
+                    updateWidget(widget.widgetId, widget.widgetType);
+                }
+            }
+        }
+    }
+
+    /**
+     * 打开笔记项的函数
+     */
+    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) {
+        mCurrentFolderId = data.getId();
+        startAsyncNotesListQuery();
+        if (data.getId() == Notes.ID_CALL_RECORD_FOLDER) {
+            mState = ListEditState.CALL_RECORD_FOLDER;
+            mAddNewNote.setVisibility(View.GONE);
+        } else {
+            mState = ListEditState.SUB_FOLDER;
+        }
+        if (data.getId() == Notes.ID_CALL_RECORD_FOLDER) {
+            mTitleBar.setText(R.string.call_record_folder_name);
+        } else {
+            mTitleBar.setText(data.getSnippet());
+        }
+        mTitleBar.setVisibility(View.VISIBLE);
+    }
+
+    @Override
+    public void onClick(View v) {
+        switch (v.getId()) {
+            case R.id.btn_new_note:
+                createNewNote();
+                break;
+            default:
+                break;
+        }
+    }
+
+    /**
+     * 显示软键盘的函数
+     */
+    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) {
+        InputMethodManager inputMethodManager = (InputMethodManager) getSystemService(Context.INPUT_METHOD_SERVICE);
+        inputMethodManager.hideSoftInputFromWindow(view.getWindowToken(), 0);
+    }
+
+    /**
+     * 显示创建或修改文件夹对话框的函数
+     */
+    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);
+        showSoftInput();
+        if (!create) {
+            if (mFocusNoteDataItem != null) {
+                etName.setText(mFocusNoteDataItem.getSnippet());
+                builder.setTitle(getString(R.string.menu_folder_change_name));
+            } else {
+                Log.e(TAG, "The long click data item is null");
+                return;
+            }
+        } else {
+            etName.setText("");
+            builder.setTitle(this.getString(R.string.menu_create_folder));
+        }
+
+        builder.setPositiveButton(android.R.string.ok, null);
+        builder.setNegativeButton(android.R.string.cancel, new DialogInterface.OnClickListener() {
+            public void onClick(DialogInterface dialog, int which) {
+                hideSoftInput(etName);
+            }
+        });
+
+        final Dialog dialog = builder.setView(view).show();
+        final Button positive = (Button)dialog.findViewById(android.R.id.button1);
+        positive.setOnClickListener(new OnClickListener() {
+            public void onClick(View v) {
+                hideSoftInput(etName);
+                String name = etName.getText().toString();
+                if (DataUtils.checkVisibleFolderName(mContentResolver, name)) {
+                    Toast.makeText(NotesListActivity.this, getString(R.string.folder_exist, name),
+                            Toast.LENGTH_LONG).show();
+                    etName.setSelection(0, etName.length());
+                    return;
+                }
+                if (!create) {
+                    if (!TextUtils.isEmpty(name)) {
+                        ContentValues values = new ContentValues();
+                        values.put(NoteColumns.SNIPPET, name);
+                        values.put(NoteColumns.TYPE, Notes.TYPE_FOLDER);
+                        values.put(NoteColumns.LOCAL_MODIFIED, 1);
+                        mContentResolver.update(Notes.CONTENT_NOTE_URI, values, NoteColumns.ID
+                                + "=?", new String[] {
+                            String.valueOf(mFocusNoteDataItem.getId())
+                        });
+                    }
+                } else if (!TextUtils.isEmpty(name)) {
+                    ContentValues values = new ContentValues();
+                    values.put(NoteColumns.SNIPPET, name);
+                    values.put(NoteColumns.TYPE, Notes.TYPE_FOLDER);
+                    mContentResolver.insert(Notes.CONTENT_NOTE_URI, values);
+                }
+                dialog.dismiss();
+            }
+        });
+
+        if (TextUtils.isEmpty(etName.getText())) {
+            positive.setEnabled(false);
+        }
+        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) {
+                if (TextUtils.isEmpty(etName.getText())) {
+                    positive.setEnabled(false);
+                } else {
+                    positive.setEnabled(true);
+                }
+            }
+
+            public void afterTextChanged(Editable s) {
+                // TODO Auto-generated method stub
+            }
+        });
+    }
+
+    @Override
+    public void onBackPressed() {
+        switch (mState) {
+            case SUB_FOLDER:
+                mCurrentFolderId = Notes.ID_ROOT_FOLDER;
+                mState = ListEditState.NOTE_LIST;
+                startAsyncNotesListQuery();
+                mTitleBar.setVisibility(View.GONE);
+                break;
+            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:
+                super.onBackPressed();
+                break;
+            default:
+                break;
+        }
+    }
+
+    /**
+     * 更新Widget的函数
+     */
+    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);
+        } else if (appWidgetType == Notes.TYPE_WIDGET_4X) {
+            intent.setClass(this, NoteWidgetProvider_4x.class);
+        } else {
+            Log.e(TAG, "Unspported widget type");
+            return;
+        }
+
+        intent.putExtra(AppWidgetManager.EXTRA_APPWIDGET_IDS, new int[] {
+            appWidgetId
+        });
+
+        sendBroadcast(intent);
+        setResult(RESULT_OK, intent);
+    }
+    /**
+     * 为文件夹创建上下文菜单的监听器
+     */
+    private final OnCreateContextMenuListener mFolderOnCreateContextMenuListener = new OnCreateContextMenuListener() {
+        public void onCreateContextMenu(ContextMenu menu, View v, ContextMenuInfo menuInfo) {
+            if (mFocusNoteDataItem != null) {
+                menu.setHeaderTitle(mFocusNoteDataItem.getSnippet());
+                menu.add(0, MENU_FOLDER_VIEW, 0, R.string.menu_folder_view);
+                menu.add(0, MENU_FOLDER_DELETE, 0, R.string.menu_folder_delete);
+                menu.add(0, MENU_FOLDER_CHANGE_NAME, 0, R.string.menu_folder_change_name);
+            }
+        }
+    };
+
+    @Override
+    public void onContextMenuClosed(Menu menu) {
+        if (mNotesListView != null) {
+            mNotesListView.setOnCreateContextMenuListener(null);
+        }
+        super.onContextMenuClosed(menu);
+    }
+
+    @Override
+    public boolean onContextItemSelected(MenuItem item) {
+        if (mFocusNoteDataItem == null) {
+            Log.e(TAG, "The long click data item is null");
+            return false;
+        }
+        switch (item.getItemId()) {
+            case MENU_FOLDER_VIEW:
+                openFolder(mFocusNoteDataItem);
+                break;
+            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);
+                builder.setMessage(getString(R.string.alert_message_delete_folder));
+                builder.setPositiveButton(android.R.string.ok,
+                        new DialogInterface.OnClickListener() {
+                            public void onClick(DialogInterface dialog, int which) {
+                                deleteFolder(mFocusNoteDataItem.getId());
+                            }
+                        });
+                builder.setNegativeButton(android.R.string.cancel, null);
+                builder.show();
+                break;
+            case MENU_FOLDER_CHANGE_NAME:
+                showCreateOrModifyFolderDialog(false);
+                break;
+            default:
+                break;
+        }
+
+        return true;
+    }
+
+    @Override
+    public boolean onPrepareOptionsMenu(Menu menu) {
+        menu.clear();
+        if (mState == ListEditState.NOTE_LIST) {
+            getMenuInflater().inflate(R.menu.note_list, menu);
+            // 设置同步或取消同步的菜单项标题
+            menu.findItem(R.id.menu_sync).setTitle(
+                    GTaskSyncService.isSyncing() ? R.string.menu_sync_cancel : R.string.menu_sync);
+        } else if (mState == ListEditState.SUB_FOLDER) {
+            getMenuInflater().inflate(R.menu.sub_folder, menu);
+        } else if (mState == ListEditState.CALL_RECORD_FOLDER) {
+            getMenuInflater().inflate(R.menu.call_record_folder, menu);
+        } else {
+            Log.e(TAG, "Wrong state:" + mState);
+        }
+        return true;
+    }
+
+    @Override
+    public boolean onOptionsItemSelected(MenuItem item) {
+        switch (item.getItemId()) {
+            case R.id.menu_new_folder: {
+                showCreateOrModifyFolderDialog(true);
+                break;
+            }
+            case R.id.menu_export_text: {
+                exportNoteToText();
+                break;
+            }
+            case R.id.menu_sync: {
+                if (isSyncMode()) {
+                    if (TextUtils.equals(item.getTitle(), getString(R.string.menu_sync))) {
+                        GTaskSyncService.startSync(this);
+                    } else {
+                        GTaskSyncService.cancelSync(this);
+                    }
+                } else {
+                    startPreferenceActivity();
+                }
+                break;
+            }
+            case R.id.menu_setting: {
+                startPreferenceActivity();
+                break;
+            }
+            case R.id.menu_new_note: {
+                createNewNote();
+                break;
+            }
+            case R.id.menu_search:
+                onSearchRequested();
+                break;
+            default:
+                break;
+        }
+        return true;
+    }
+
+    @Override
+    public boolean onSearchRequested() {
+        startSearch(null, false, null /* appData */, false);
+        return true;
+    }
+
+    /**
+     * 导出笔记到文本文件的函数
+     */
+    private void exportNoteToText() {
+        final BackupUtils backup = BackupUtils.getInstance(NotesListActivity.this);
+        new AsyncTask<Void, Void, Integer>() {
+
+            @Override
+            protected Integer doInBackground(Void... unused) {
+                return backup.exportToText();
+            }
+
+            @Override
+            protected void onPostExecute(Integer result) {
+                if (result == BackupUtils.STATE_SD_CARD_UNMOUONTED) {
+                    AlertDialog.Builder builder = new AlertDialog.Builder(NotesListActivity.this);
+                    builder.setTitle(NotesListActivity.this
+                            .getString(R.string.failed_sdcard_export));
+                    builder.setMessage(NotesListActivity.this
+                            .getString(R.string.error_sdcard_unmounted));
+                    builder.setPositiveButton(android.R.string.ok, null);
+                    builder.show();
+                } else if (result == BackupUtils.STATE_SUCCESS) {
+                    AlertDialog.Builder builder = new AlertDialog.Builder(NotesListActivity.this);
+                    builder.setTitle(NotesListActivity.this
+                            .getString(R.string.success_sdcard_export));
+                    builder.setMessage(NotesListActivity.this.getString(
+                            R.string.format_exported_file_location, backup
+                                    .getExportedTextFileName(), backup.getExportedTextFileDir()));
+                    builder.setPositiveButton(android.R.string.ok, null);
+                    builder.show();
+                } 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));
+                    builder.setMessage(NotesListActivity.this
+                            .getString(R.string.error_sdcard_export));
+                    builder.setPositiveButton(android.R.string.ok, null);
+                    builder.show();
+                }
+            }
+
+        }.execute();
+    }
+
+    /**
+     * 检查是否处于同步模式的函数
+     */
+    private boolean isSyncMode() {
+        return NotesPreferenceActivity.getSyncAccountName(this).trim().length() > 0;
+    }
+
+    /**
+     * 启动偏好设置活动的函数
+     */
+    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 {
+
+        public void onItemClick(AdapterView<?> parent, View view, int position, long id) {
+            if (view instanceof NotesListItem) {
+                NoteItemData item = ((NotesListItem) view).getItemData();
+                if (mNotesListAdapter.isInChoiceMode()) {
+                    if (item.getType() == Notes.TYPE_NOTE) {
+                        position = position - mNotesListView.getHeaderViewsCount();
+                        mModeCallBack.onItemCheckedStateChanged(null, position, id,
+                                !mNotesListAdapter.isSelectedItem(position));
+                    }
+                    return;
+                }
+
+                switch (mState) {
+                    case NOTE_LIST:
+                        if (item.getType() == Notes.TYPE_FOLDER
+                                || item.getType() == Notes.TYPE_SYSTEM) {
+                            openFolder(item);
+                        } else if (item.getType() == Notes.TYPE_NOTE) {
+                            openNode(item);
+                        } else {
+                            Log.e(TAG, "Wrong note type in NOTE_LIST");
+                        }
+                        break;
+                    case SUB_FOLDER:
+                    case CALL_RECORD_FOLDER:
+                        if (item.getType() == Notes.TYPE_NOTE) {
+                            openNode(item);
+                        } else {
+                            Log.e(TAG, "Wrong note type in SUB_FOLDER");
+                        }
+                        break;
+                    default:
+                        break;
+                }
+            }
+        }
+
+    }
+
+    /**
+     * 开始查询目标文件夹的函数
+     */
+    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 + ")";
+
+        mBackgroundQueryHandler.startQuery(FOLDER_LIST_QUERY_TOKEN,
+                null,
+                Notes.CONTENT_NOTE_URI,
+                FoldersListAdapter.PROJECTION,
+                selection,
+                new String[] {
+                        String.valueOf(Notes.TYPE_FOLDER),
+                        String.valueOf(Notes.ID_TRASH_FOLER),
+                        String.valueOf(mCurrentFolderId)
+                },
+                NoteColumns.MODIFIED_DATE + " DESC");
+    }
+
+    @Override
+    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()) {
+                if (mNotesListView.startActionMode(mModeCallBack) != null) {
+                    mModeCallBack.onItemCheckedStateChanged(null, position, id, true);
+                    mNotesListView.performHapticFeedback(HapticFeedbackConstants.LONG_PRESS);
+                } else {
+                    Log.e(TAG, "startActionMode fails");
+                }
+            } else if (mFocusNoteDataItem.getType() == Notes.TYPE_FOLDER) {
+                mNotesListView.setOnCreateContextMenuListener(mFolderOnCreateContextMenuListener);
+            }
+        }
+        return false;
+    }
+}
+
+  

src/ui(m)/NotesPreferenceActivity.java

@@ -0,0 +1,471 @@
+/*
+ * Copyright (c) 2010-2011, The MiCode Open Source Community (www.micode.net)
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *        http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package net.micode.notes.ui;
+
+import android.accounts.Account;
+import android.accounts.AccountManager;
+import android.app.ActionBar;
+import android.app.AlertDialog;
+import android.content.BroadcastReceiver;
+import android.content.ContentValues;
+import android.content.Context;
+import android.content.DialogInterface;
+import android.content.Intent;
+import android.content.IntentFilter;
+import android.content.SharedPreferences;
+import android.os.Bundle;
+import android.preference.Preference;
+import android.preference.Preference.OnPreferenceClickListener;
+import android.preference.PreferenceActivity;
+import android.preference.PreferenceCategory;
+import android.text.TextUtils;
+import android.text.format.DateFormat;
+import android.view.LayoutInflater;
+import android.view.Menu;
+import android.view.MenuItem;
+import android.view.View;
+import android.widget.Button;
+import android.widget.TextView;
+import android.widget.Toast;
+
+import net.micode.notes.R;
+import net.micode.notes.data.Notes;
+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;
+
+    @Override
+    protected void onCreate(Bundle icicle) {
+        super.onCreate(icicle);
+
+        /* 使用应用程序图标进行导航 */
+        getActionBar().setDisplayHomeAsUpEnabled(true);
+
+        // 从资源文件中添加偏好设置
+        addPreferencesFromResource(R.xml.preferences);
+        // 获取账户类别
+        mAccountCategory = (PreferenceCategory) findPreference(PREFERENCE_SYNC_ACCOUNT_KEY);
+        // 创建GTask接收器
+        mReceiver = new GTaskReceiver();
+        // 创建意图过滤器
+        IntentFilter filter = new IntentFilter();
+        filter.addAction(GTaskSyncService.GTASK_SERVICE_BROADCAST_NAME);
+        // 注册接收器
+        registerReceiver(mReceiver, filter);
+
+        // 初始化原始账户数组
+        mOriAccounts = null;
+        // 从XML布局文件中加载设置头部
+        View header = LayoutInflater.from(this).inflate(R.layout.settings_header, null);
+        // 将头部添加到偏好列表中
+        getListView().addHeaderView(header, null, true);
+    }
+
+    @Override
+    protected void onResume() {
+        super.onResume();
+
+        // 自动设置同步账户，如果用户添加了新账户
+        if (mHasAddedAccount) {
+            Account[] accounts = getGoogleAccounts();
+            if (mOriAccounts != null && accounts.length > mOriAccounts.length) {
+                for (Account accountNew : accounts) {
+                    boolean found = false;
+                    for (Account accountOld : mOriAccounts) {
+                        if (TextUtils.equals(accountOld.name, accountNew.name)) {
+                            found = true;
+                            break;
+                        }
+                    }
+                    if (!found) {
+                        setSyncAccount(accountNew.name);
+                        break;
+                    }
+                }
+            }
+        }
+
+        // 刷新UI
+        refreshUI();
+    }
+
+    @Override
+    protected void onDestroy() {
+        // 如果接收器不为空，注销接收器
+        if (mReceiver != null) {
+            unregisterReceiver(mReceiver);
+        }
+        super.onDestroy();
+    }
+
+    /**
+     * 加载账户偏好设置。
+     */
+    private void loadAccountPreference() {
+        // 移除所有账户偏好设置
+        mAccountCategory.removeAll();
+
+        // 创建一个新的偏好设置
+        Preference accountPref = new Preference(this);
+        // 获取默认账户
+        final String defaultAccount = getSyncAccountName(this);
+        accountPref.setTitle(getString(R.string.preferences_account_title));
+        accountPref.setSummary(getString(R.string.preferences_account_summary));
+        accountPref.setOnPreferenceClickListener(new OnPreferenceClickListener() {
+            public boolean onPreferenceClick(Preference preference) {
+                // 如果GTask服务没有正在同步
+                if (!GTaskSyncService.isSyncing()) {
+                    // 如果默认账户为空
+                    if (TextUtils.isEmpty(defaultAccount)) {
+                        // 第一次设置账户
+                        showSelectAccountAlertDialog();
+                    } else {
+                        // 如果账户已经设置，提示用户风险
+                        showChangeAccountConfirmAlertDialog();
+                    }
+                } else {
+                    // 提示用户不能更改账户
+                    Toast.makeText(NotesPreferenceActivity.this,
+                            R.string.preferences_toast_cannot_change_account, Toast.LENGTH_SHORT)
+                            .show();
+                }
+                return true;
+            }
+        });
+
+        // 将账户偏好设置添加到账户类别中
+        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);
+
+        // 设置按钮状态
+        if (GTaskSyncService.isSyncing()) {
+            syncButton.setText(getString(R.string.preferences_button_sync_cancel));
+            syncButton.setOnClickListener(new View.OnClickListener() {
+                public void onClick(View v) {
+                    // 取消同步
+                    GTaskSyncService.cancelSync(NotesPreferenceActivity.this);
+                }
+            });
+        } else {
+            syncButton.setText(getString(R.string.preferences_button_sync_immediately));
+            syncButton.setOnClickListener(new View.OnClickListener() {
+                public void onClick(View v) {
+                    // 立即同步
+                    GTaskSyncService.startSync(NotesPreferenceActivity.this);
+                }
+            });
+        }
+        syncButton.setEnabled(!TextUtils.isEmpty(getSyncAccountName(this)));
+
+        // 设置最后同步时间
+        if (GTaskSyncService.isSyncing()) {
+            lastSyncTimeView.setText(GTaskSyncService.getProgressString());
+            lastSyncTimeView.setVisibility(View.VISIBLE);
+        } else {
+            long lastSyncTime = getLastSyncTime(this);
+            if (lastSyncTime != 0) {
+                lastSyncTimeView.setText(getString(R.string.preferences_last_sync_time,
+                        DateFormat.format(getString(R.string.preferences_last_sync_time_format),
+                                lastSyncTime)));
+                lastSyncTimeView.setVisibility(View.VISIBLE);
+            } else {
+                lastSyncTimeView.setVisibility(View.GONE);
+            }
+        }
+    }
+
+    /**
+     * 刷新UI。
+     */
+    private void refreshUI() {
+        // 加载账户偏好设置和同步按钮
+        loadAccountPreference();
+        loadSyncButton();
+    }
+
+    /**
+     * 显示选择账户的警告对话框。
+     */
+    private void showSelectAccountAlertDialog() {
+        // 创建警告对话框的构建器
+        AlertDialog.Builder dialogBuilder = new AlertDialog.Builder(this);
+
+        // 从XML布局文件中加载标题视图
+        View titleView = LayoutInflater.from(this).inflate(R.layout.account_dialog_title, null);
+        TextView titleTextView = (TextView) titleView.findViewById(R.id.account_dialog_title);
+        titleTextView.setText(getString(R.string.preferences_dialog_select_account_title));
+        TextView subtitleTextView = (TextView) titleView.findViewById(R.id.account_dialog_subtitle);
+        subtitleTextView.setText(getString(R.string.preferences_dialog_select_account_tips));
+
+        // 设置自定义标题
+        dialogBuilder.setCustomTitle(titleView);
+        dialogBuilder.setPositiveButton(null, null);
+
+        // 获取Google账户
+        Account[] accounts = getGoogleAccounts());
+        String defAccount = getSyncAccountName(this);
+
+        // 初始化原始账户数组和添加账户标志
+        mOriAccounts = accounts;
+        mHasAddedAccount = false;
+
+        // 如果账户数量大于0
+        if (accounts.length > 0) {
+            // 创建账户项
+            CharSequence[] items = new CharSequence[accounts.length];
+            final CharSequence[] itemMapping = items;
+            int checkedItem = -1;
+            int index = 0;
+            for (Account account : accounts) {
+                if (TextUtils.equals(account.name, defAccount)) {
+                    checkedItem = index;
+                }
+                items[index++] = account.name;
+            }
+            // 设置单选项目
+            dialogBuilder.setSingleChoiceItems(items, checkedItem,
+                    new DialogInterface.OnClickListener() {
+                        public void onClick(DialogInterface dialog, int which) {
+                            //设置同步账户
+	setSyncAccount(itemMapping[which].toString());
+	dialog.dismiss();
+	refreshUI();
+			}
+		});
+	}
+    // 从XML布局文件中加载添加账户视图
+    View addAccountView = LayoutInflater.from(this).inflate(R.layout.add_account_text, null);
+    dialogBuilder.setView(addAccountView);
+
+    // 显示警告对话框
+    final AlertDialog dialog = dialogBuilder.show();
+    addAccountView.setOnClickListener(new View.OnClickListener() {
+        public void onClick(View v) {
+            // 添加账户
+            mHasAddedAccount = true;
+            Intent intent = new Intent("android.settings.ADD_ACCOUNT_SETTINGS");
+            intent.putExtra(AUTHORITIES_FILTER_KEY, new String[] {
+                "gmail-ls"
+            });
+            startActivityForResult(intent, -1);
+            dialog.dismiss();
+        }
+    });
+}
+
+/**
+ * 显示更改账户的确认警告对话框。
+ */
+private void showChangeAccountConfirmAlertDialog() {
+    // 创建警告对话框的构建器
+    AlertDialog.Builder dialogBuilder = new AlertDialog.Builder(this);
+
+    // 从XML布局文件中加载标题视图
+    View titleView = LayoutInflater.from(this).inflate(R.layout.account_dialog_title, null);
+    TextView titleTextView = (TextView) titleView.findViewById(R.id.account_dialog_title);
+    titleTextView.setText(getString(R.string.preferences_dialog_change_account_title,
+            getSyncAccountName(this)));
+    TextView subtitleTextView = (TextView) titleView.findViewById(R.id.account_dialog_subtitle);
+    subtitleTextView.setText(getString(R.string.preferences_dialog_change_account_warn_msg));
+    dialogBuilder.setCustomTitle(titleView);
+
+    // 创建菜单项
+    CharSequence[] menuItemArray = new CharSequence[] {
+            getString(R.string.preferences_menu_change_account),
+            getString(R.string.preferences_menu_remove_account),
+            getString(R.string.preferences_menu_cancel)
+    };
+    dialogBuilder.setItems(menuItemArray, new DialogInterface.OnClickListener() {
+        public void onClick(DialogInterface dialog, int which) {
+            // 处理菜单项点击事件
+            if (which == 0) {
+                showSelectAccountAlertDialog();
+            } else if (which == 1) {
+                removeSyncAccount();
+                refreshUI();
+            }
+        }
+    });
+    dialogBuilder.show();
+}
+
+/**
+ * 获取Google账户。
+ */
+private Account[] getGoogleAccounts() {
+    // 获取账户管理器
+    AccountManager accountManager = AccountManager.get(this);
+    // 获取Google账户
+    return accountManager.getAccountsByType("com.google");
+}
+
+/**
+ * 设置同步账户。
+ */
+private void setSyncAccount(String account) {
+    // 如果同步账户不为空且与当前账户不同
+    if (!getSyncAccountName(this).equals(account)) {
+        // 获取共享首选项
+        SharedPreferences settings = getSharedPreferences(PREFERENCE_NAME, Context.MODE_PRIVATE);
+        SharedPreferences.Editor editor = settings.edit();
+        if (account != null) {
+            editor.putString(PREFERENCE_SYNC_ACCOUNT_NAME, account);
+        } else {
+            editor.putString(PREFERENCE_SYNC_ACCOUNT_NAME, "");
+        }
+        editor.commit();
+
+        // 清除最后同步时间
+        setLastSyncTime(this, 0);
+
+        // 清除本地gtask相关信息
+        new Thread(new Runnable() {
+            public void run() {
+                ContentValues values = new ContentValues();
+                values.put(NoteColumns.GTASK_ID, "");
+                values.put(NoteColumns.SYNC_ID, 0);
+                getContentResolver().update(Notes.CONTENT_NOTE_URI, values, null, null);
+            }
+        }).start();
+
+        // 提示用户设置账户成功
+        Toast.makeText(NotesPreferenceActivity.this,
+                getString(R.string.preferences_toast_success_set_accout, account),
+                Toast.LENGTH_SHORT).show();
+    }
+}
+
+/**
+ * 移除同步账户。
+ */
+private void removeSyncAccount() {
+    // 获取共享首选项
+    SharedPreferences settings = getSharedPreferences(PREFERENCE_NAME, Context.MODE_PRIVATE);
+    SharedPreferences.Editor editor = settings.edit();
+    if (settings.contains(PREFERENCE_SYNC_ACCOUNT_NAME)) {
+        editor.remove(PREFERENCE_SYNC_ACCOUNT_NAME);
+    }
+    if (settings.contains(PREFERENCE_LAST_SYNC_TIME)) {
+        editor.remove(PREFERENCE_LAST_SYNC_TIME);
+    }
+    editor.commit();
+
+    // 清除本地gtask相关信息
+    new Thread(new Runnable() {
+        public void run() {
+            ContentValues values = new ContentValues();
+            values.put(NoteColumns.GTASK_ID, "");
+            values.put(NoteColumns.SYNC_ID, 0);
+            getContentResolver().update(Notes.CONTENT_NOTE_URI, values, null, null);
+        }
+    }).start();
+}
+
+/**
+ * 获取同步账户名称。
+ */
+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) {
+    SharedPreferences settings = context.getSharedPreferences(PREFERENCE_NAME,
+            Context.MODE_PRIVATE);
+    SharedPreferences.Editor editor = settings.edit();
+    editor.putLong(PREFERENCE_LAST_SYNC_TIME, time);
+    editor.commit();
+}
+
+/**
+ * 获取最后同步时间。
+ */
+public static long getLastSyncTime(Context context) {
+    SharedPreferences settings = context.getSharedPreferences(PREFERENCE_NAME,
+            Context.MODE_PRIVATE);
+    return settings.getLong(PREFERENCE_LAST_SYNC_TIME, 0);
+}
+
+/**
+ * GTask接收器，用于接收GTask服务的广播。
+ */
+private class GTaskReceiver extends BroadcastReceiver {
+
+    @Override
+    public void onReceive(Context context, Intent intent) {
+        // 刷新UI
+        refreshUI();
+        if (intent.getBooleanExtra(GTaskSyncService.GTASK_SERVICE_BROADCAST_IS_SYNCING, false)) {
+            // 获取同步状态视图
+            TextView syncStatus = (TextView) findViewById(R.id.prefenerece_sync_status_textview);
+            syncStatus.setText(intent
+                    .getStringExtra(GTaskSyncService.GTASK_SERVICE_BROADCAST_PROGRESS_MSG));
+        }
+
+    }
+}
+
+/**
+ * 处理选项菜单项点击事件。
+ */
+public boolean onOptionsItemSelected(MenuItem item) {
+    switch (item.getItemId()) {
+        case android.R.id.home:
+            Intent intent = new Intent(this, NotesListActivity.class);
+            intent.addFlags(Intent.FLAG_ACTIVITY_CLEAR_TOP);
+            startActivity(intent);
+            return true;
+        default:
+            return false;
+    }
+}