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

温雍敬<代码注释>

Browse Source
pull/4/head
温雍敬 2 years ago
parent cd865ae253
commit 586f9278ef
3 changed files with 198 additions and 188 deletions
Show Stats Download Patch File Download Diff File

80
src/main/java/net/micode/notes/ui/NotesListAdapter.java
Unescape View File

@ -31,56 +31,56 @@ import java.util.HashSet;
import java.util.Iterator; import java.util.Iterator;
public class NotesListAdapter extends CursorAdapter { public class NotesListAdapter extends CursorAdapter {//继承了CursorAdapter
private static final String TAG = "NotesListAdapter"; private static final String TAG = "NotesListAdapter";
private Context mContext; private Context mContext;
private HashMap<Integer, Boolean> mSelectedIndex; private HashMap<Integer, Boolean> mSelectedIndex;//HashMap是一个散列表，储存键值对的映射关系
private int mNotesCount; private int mNotesCount;
private boolean mChoiceMode; private boolean mChoiceMode;//选择模式标志
public static class AppWidgetAttribute { public static class AppWidgetAttribute {//桌面widget的属性，包括编号和类型
public int widgetId; public int widgetId;
public int widgetType; public int widgetType;
}; };//父类对象置空
public NotesListAdapter(Context context) { public NotesListAdapter(Context context) {//初始化便签链接
super(context, null); super(context, null);
mSelectedIndex = new HashMap<Integer, Boolean>(); mSelectedIndex = new HashMap<Integer, Boolean>();
mContext = context; mContext = context;//新建一个视图来存储光标所指向的数据
mNotesCount = 0; mNotesCount = 0;
} }
@Override @Override
public View newView(Context context, Cursor cursor, ViewGroup parent) { public View newView(Context context, Cursor cursor, ViewGroup parent) {//利用NotesListLtem类创建新布局
return new NotesListItem(context); return new NotesListItem(context);
} }
@Override @Override
public void bindView(View view, Context context, Cursor cursor) { public void bindView(View view, Context context, Cursor cursor) {//将已经存在的视图和鼠标指向的数据进行捆绑
if (view instanceof NotesListItem) { if (view instanceof NotesListItem) {
NoteItemData itemData = new NoteItemData(context, cursor); NoteItemData itemData = new NoteItemData(context, cursor);//新建一个项目选项并且用bind跟将view和鼠标，内容，便签数据捆绑在一起
((NotesListItem) view).bind(context, itemData, mChoiceMode, ((NotesListItem) view).bind(context, itemData, mChoiceMode,
isSelectedItem(cursor.getPosition())); isSelectedItem(cursor.getPosition()));
} }
} }
public void setCheckedItem(final int position, final boolean checked) { public void setCheckedItem(final int position, final boolean checked) {//设置勾选框
mSelectedIndex.put(position, checked); mSelectedIndex.put(position, checked);//根据定位和是否勾选设置下标
notifyDataSetChanged(); notifyDataSetChanged();
} }
public boolean isInChoiceMode() { public boolean isInChoiceMode() {
return mChoiceMode; return mChoiceMode;
} }//判断单选按钮是否勾选
public void setChoiceMode(boolean mode) { public void setChoiceMode(boolean mode) {//重置下标，并根据参数mode设置选项
mSelectedIndex.clear(); mSelectedIndex.clear();
mChoiceMode = mode; mChoiceMode = mode;
} }
public void selectAll(boolean checked) { public void selectAll(boolean checked) {//选择全部选项，遍历所有光标可用的位置在判断为便签类型之后勾选单项框
Cursor cursor = getCursor(); Cursor cursor = getCursor();
for (int i = 0; i < getCount(); i++) { for (int i = 0; i < getCount(); i++) {//历可用光标位置，如果光标移动且光标当前指向的便签项目类型为TYPE_NOTE则设置为勾选状态
if (cursor.moveToPosition(i)) { if (cursor.moveToPosition(i)) {
if (NoteItemData.getNoteType(cursor) == Notes.TYPE_NOTE) { if (NoteItemData.getNoteType(cursor) == Notes.TYPE_NOTE) {
setCheckedItem(i, checked); setCheckedItem(i, checked);
@ -89,15 +89,15 @@ public class NotesListAdapter extends CursorAdapter {
} }
} }
public HashSet<Long> getSelectedItemIds() { public HashSet<Long> getSelectedItemIds() {//建立选择项目的ID的HASH表
HashSet<Long> itemSet = new HashSet<Long>(); HashSet<Long> itemSet = new HashSet<Long>();
for (Integer position : mSelectedIndex.keySet()) { for (Integer position : mSelectedIndex.keySet()) {//遍历所有的关键
if (mSelectedIndex.get(position) == true) { if (mSelectedIndex.get(position) == true) {
Long id = getItemId(position); Long id = getItemId(position);
if (id == Notes.ID_ROOT_FOLDER) { if (id == Notes.ID_ROOT_FOLDER) {//原文件不需要添加，则将id该下标假如选项集合中
Log.d(TAG, "Wrong item id, should not happen"); Log.d(TAG, "Wrong item id, should not happen");
} else { } else {
itemSet.add(id); itemSet.add(id);//将该id加入到选项集合当中
} }
} }
} }
@ -105,22 +105,22 @@ public class NotesListAdapter extends CursorAdapter {
return itemSet; return itemSet;
} }
public HashSet<AppWidgetAttribute> getSelectedWidget() { public HashSet<AppWidgetAttribute> getSelectedWidget() {//建立桌面widget选项表
HashSet<AppWidgetAttribute> itemSet = new HashSet<AppWidgetAttribute>(); HashSet<AppWidgetAttribute> itemSet = new HashSet<AppWidgetAttribute>();
for (Integer position : mSelectedIndex.keySet()) { for (Integer position : mSelectedIndex.keySet()) {//遍历被选中的列表
if (mSelectedIndex.get(position) == true) { if (mSelectedIndex.get(position) == true) {
Cursor c = (Cursor) getItem(position); Cursor c = (Cursor) getItem(position);//获取条目
if (c != null) { if (c != null) {
AppWidgetAttribute widget = new AppWidgetAttribute(); AppWidgetAttribute widget = new AppWidgetAttribute();
NoteItemData item = new NoteItemData(mContext, c); NoteItemData item = new NoteItemData(mContext, c);//新建widget并更新ID和类型，最后添加到选项表中
widget.widgetId = item.getWidgetId(); widget.widgetId = item.getWidgetId();
widget.widgetType = item.getWidgetType(); widget.widgetType = item.getWidgetType();
itemSet.add(widget); itemSet.add(widget);//加入条目集合
/** /**
* Don't close cursor here, only the adapter could close it * Don't close cursor here, only the adapter could close it
*/ */
} else { } else {
Log.e(TAG, "Invalid cursor"); Log.e(TAG, "Invalid cursor");//设置标签，无效的cursor
return null; return null;
} }
} }
@ -128,14 +128,14 @@ public class NotesListAdapter extends CursorAdapter {
return itemSet; return itemSet;
} }
public int getSelectedCount() { public int getSelectedCount() {//获取选项个数
Collection<Boolean> values = mSelectedIndex.values(); Collection<Boolean> values = mSelectedIndex.values();
if (null == values) { if (null == values) {
return 0; return 0;
} }
Iterator<Boolean> iter = values.iterator(); Iterator<Boolean> iter = values.iterator();//初始化迭代器
int count = 0; int count = 0;
while (iter.hasNext()) { while (iter.hasNext()) {//如果iter后面还有，则count加一
if (true == iter.next()) { if (true == iter.next()) {
count++; count++;
} }
@ -143,40 +143,40 @@ public class NotesListAdapter extends CursorAdapter {
return count; return count;
} }
public boolean isAllSelected() { public boolean isAllSelected() {//判断是否全选
int checkedCount = getSelectedCount(); int checkedCount = getSelectedCount();
return (checkedCount != 0 && checkedCount == mNotesCount); return (checkedCount != 0 && checkedCount == mNotesCount);
} }
public boolean isSelectedItem(final int position) { public boolean isSelectedItem(final int position) {//判断是否为选项表
if (null == mSelectedIndex.get(position)) { if (null == mSelectedIndex.get(position)) {
return false; return false;
} }
return mSelectedIndex.get(position); return mSelectedIndex.get(position);//判断Item是否被选中的状态
} }
@Override @Override
protected void onContentChanged() { protected void onContentChanged() {//activity内容变动时调用calcNotesCount计算便签数量
super.onContentChanged(); super.onContentChanged();//执行父类函数
calcNotesCount(); calcNotesCount();
} }
@Override @Override
public void changeCursor(Cursor cursor) { public void changeCursor(Cursor cursor) {
super.changeCursor(cursor); super.changeCursor(cursor);//重载父类函数
calcNotesCount(); calcNotesCount();
} }
private void calcNotesCount() { private void calcNotesCount() {//实现方式类似前面代码中的selectAll函数
mNotesCount = 0; mNotesCount = 0;
for (int i = 0; i < getCount(); i++) { for (int i = 0; i < getCount(); i++) {//获取总数同时遍历
Cursor c = (Cursor) getItem(i); Cursor c = (Cursor) getItem(i);
if (c != null) { if (c != null) {//判断语句，如果光标不是null，那么便得到信息，便签数目加1
if (NoteItemData.getNoteType(c) == Notes.TYPE_NOTE) { if (NoteItemData.getNoteType(c) == Notes.TYPE_NOTE) {//若选项的数据类型为便签类型，那么计数+1
mNotesCount++; mNotesCount++;
} }
} else { } else {
Log.e(TAG, "Invalid cursor"); Log.e(TAG, "Invalid cursor");//否则就将设置为无效的光标
return; return;
} }
} }

92
src/main/java/net/micode/notes/ui/NotesListItem.java
Unescape View File

@ -30,80 +30,82 @@ import net.micode.notes.tool.DataUtils;
import net.micode.notes.tool.ResourceParser.NoteItemBgResources; import net.micode.notes.tool.ResourceParser.NoteItemBgResources;
public class NotesListItem extends LinearLayout { public class NotesListItem extends LinearLayout {// 构建便签列表的各个项目的详细具体信息
private ImageView mAlert; private ImageView mAlert;//闹钟图片
private TextView mTitle; private TextView mTitle;//标题
private TextView mTime; private TextView mTime;//时间
private TextView mCallName; private TextView mCallName;//闹铃名称
private NoteItemData mItemData; private NoteItemData mItemData;//标签数据
private CheckBox mCheckBox; private CheckBox mCheckBox;勾选框
public NotesListItem(Context context) { public NotesListItem(Context context) {// 初始化基本信息
super(context); super(context);//调用父类具有相同形参的函数
inflate(context, R.layout.note_item, this); inflate(context, R.layout.note_item, this);//inflate()作用就是将xml定义的一个布局找出来
mAlert = (ImageView) findViewById(R.id.iv_alert_icon); mAlert = (ImageView) findViewById(R.id.iv_alert_icon);//findViewById用于从contentView中查找指定ID的View，转换出来的形式根据需要而定
mTitle = (TextView) findViewById(R.id.tv_title); mTitle = (TextView) findViewById(R.id.tv_title);//获取题目
mTime = (TextView) findViewById(R.id.tv_time); mTime = (TextView) findViewById(R.id.tv_time);//获取时间
mCallName = (TextView) findViewById(R.id.tv_name); mCallName = (TextView) findViewById(R.id.tv_name);//获取标题
mCheckBox = (CheckBox) findViewById(android.R.id.checkbox); mCheckBox = (CheckBox) findViewById(android.R.id.checkbox);//获取复选框
} }
public void bind(Context context, NoteItemData data, boolean choiceMode, boolean checked) { public void bind(Context context, NoteItemData data, boolean choiceMode, boolean checked) {//根据data的属性对各个控件的属性的控制，
if (choiceMode && data.getType() == Notes.TYPE_NOTE) { // 主要是可见性Visibility，内容setText，格式setTextAppearance
if (choiceMode && data.getType() == Notes.TYPE_NOTE) {//如果处于选择模式并且是便签类型时，设置为可见及勾选，否则设置为不可见。
mCheckBox.setVisibility(View.VISIBLE); mCheckBox.setVisibility(View.VISIBLE);
mCheckBox.setChecked(checked); mCheckBox.setChecked(checked);//设置勾选
} else { } else {
mCheckBox.setVisibility(View.GONE); mCheckBox.setVisibility(View.GONE);//否则设置复选框不可见
} }
mItemData = data; mItemData = data;//把数据传给标签
if (data.getId() == Notes.ID_CALL_RECORD_FOLDER) { if (data.getId() == Notes.ID_CALL_RECORD_FOLDER) {//设置控件属性，通过判断保存到文件夹的ID、当前ID以及父ID之间关系决定
mCallName.setVisibility(View.GONE); mCallName.setVisibility(View.GONE);//设置setText 的style
mAlert.setVisibility(View.VISIBLE); mAlert.setVisibility(View.VISIBLE);//设置提醒闹钟可见
mTitle.setTextAppearance(context, R.style.TextAppearancePrimaryItem); mTitle.setTextAppearance(context, R.style.TextAppearancePrimaryItem);//设置外观风格
mTitle.setText(context.getString(R.string.call_record_folder_name) mTitle.setText(context.getString(R.string.call_record_folder_name)
+ context.getString(R.string.format_folder_files_count, data.getNotesCount())); + context.getString(R.string.format_folder_files_count, data.getNotesCount()));//设置标题内容
mAlert.setImageResource(R.drawable.call_record); mAlert.setImageResource(R.drawable.call_record);//设置图片来源
} else if (data.getParentId() == Notes.ID_CALL_RECORD_FOLDER) { } else if (data.getParentId() == Notes.ID_CALL_RECORD_FOLDER) {//闹钟设置
mCallName.setVisibility(View.VISIBLE); mCallName.setVisibility(View.VISIBLE);
mCallName.setText(data.getCallName()); mCallName.setText(data.getCallName());//联系人姓名可见
mTitle.setTextAppearance(context,R.style.TextAppearanceSecondaryItem); mTitle.setTextAppearance(context,R.style.TextAppearanceSecondaryItem);//编写联系人姓名文本框
mTitle.setText(DataUtils.getFormattedSnippet(data.getSnippet())); mTitle.setText(DataUtils.getFormattedSnippet(data.getSnippet()));
if (data.hasAlert()) { if (data.hasAlert()) {//如果当前便签存在提醒时间
mAlert.setImageResource(R.drawable.clock); mAlert.setImageResource(R.drawable.clock);//设置图片来源
mAlert.setVisibility(View.VISIBLE); mAlert.setVisibility(View.VISIBLE);//
} else { } else {
mAlert.setVisibility(View.GONE); mAlert.setVisibility(View.GONE);
} }//否则设置提醒图标不可见
} else { } else {
mCallName.setVisibility(View.GONE); mCallName.setVisibility(View.GONE);//如果父类和当前id均与保存在文件夹中的id不同，设置联系人姓名不可见
mTitle.setTextAppearance(context, R.style.TextAppearancePrimaryItem); mTitle.setTextAppearance(context, R.style.TextAppearancePrimaryItem);
if (data.getType() == Notes.TYPE_FOLDER) { if (data.getType() == Notes.TYPE_FOLDER) {//设置标题格式
mTitle.setText(data.getSnippet() mTitle.setText(data.getSnippet()//设置便签标题内容为便签的前面部分的内容+文件数+便签数
+ context.getString(R.string.format_folder_files_count, + context.getString(R.string.format_folder_files_count,
data.getNotesCount())); data.getNotesCount()));
mAlert.setVisibility(View.GONE); mAlert.setVisibility(View.GONE);
} else { } else {
mTitle.setText(DataUtils.getFormattedSnippet(data.getSnippet())); mTitle.setText(DataUtils.getFormattedSnippet(data.getSnippet()));
if (data.hasAlert()) { //若没有设置标题，将标题设置为内容前面部分
if (data.hasAlert()) {//若存在提醒时间
mAlert.setImageResource(R.drawable.clock); mAlert.setImageResource(R.drawable.clock);
mAlert.setVisibility(View.VISIBLE); mAlert.setVisibility(View.VISIBLE);
} else { } else {
mAlert.setVisibility(View.GONE); mAlert.setVisibility(View.GONE);//否则设置威不可见
} }
} }
} }
mTime.setText(DateUtils.getRelativeTimeSpanString(data.getModifiedDate())); mTime.setText(DateUtils.getRelativeTimeSpanString(data.getModifiedDate()));
setBackground(data); setBackground(data);//设置背景
} }
private void setBackground(NoteItemData data) { private void setBackground(NoteItemData data) {//根据data的文件属性来设置背景
int id = data.getBgColorId(); int id = data.getBgColorId();//获取id，用此id用来获取背景颜色
if (data.getType() == Notes.TYPE_NOTE) { if (data.getType() == Notes.TYPE_NOTE) {//若是note型文件，则4种情况，对于4种不同情况的背景来源
if (data.isSingle() || data.isOneFollowingFolder()) { if (data.isSingle() || data.isOneFollowingFolder()) {//单个数据或只有一个文件夹
setBackgroundResource(NoteItemBgResources.getNoteBgSingleRes(id)); setBackgroundResource(NoteItemBgResources.getNoteBgSingleRes(id));//设置背景颜色为单个便签背景
} else if (data.isLast()) { } else if (data.isLast()) {
setBackgroundResource(NoteItemBgResources.getNoteBgLastRes(id)); setBackgroundResource(NoteItemBgResources.getNoteBgLastRes(id));
} else if (data.isFirst() || data.isMultiFollowingFolder()) { } else if (data.isFirst() || data.isMultiFollowingFolder()) {
@ -118,5 +120,5 @@ public class NotesListItem extends LinearLayout {
public NoteItemData getItemData() { public NoteItemData getItemData() {
return mItemData; return mItemData;
} }//返回当前便签的文件信息
} }

214
src/main/java/net/micode/notes/ui/NotesPreferenceActivity.java
Unescape View File

@ -49,60 +49,64 @@ import net.micode.notes.gtask.remote.GTaskSyncService;
public class NotesPreferenceActivity extends PreferenceActivity { public class NotesPreferenceActivity extends PreferenceActivity {
//NotesPreferenceActivity，在小米便签中主要实现的是对背景颜色和字体大小的数据储存。
// 继承了PreferenceActivity主要功能为对系统信息和配置进行自动保存的Activity
public static final String PREFERENCE_NAME = "notes_preferences"; 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_SYNC_ACCOUNT_NAME = "pref_key_account_name";
//同步时间
public static final String PREFERENCE_LAST_SYNC_TIME = "pref_last_sync_time"; 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"; 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 PREFERENCE_SYNC_ACCOUNT_KEY = "pref_sync_account_key";
//同步账户密码
private static final String AUTHORITIES_FILTER_KEY = "authorities"; private static final String AUTHORITIES_FILTER_KEY = "authorities";
//设置本地密码
private PreferenceCategory mAccountCategory; private PreferenceCategory mAccountCategory;
//设置账户分组
private GTaskReceiver mReceiver; private GTaskReceiver mReceiver;
//同步任务接收器
private Account[] mOriAccounts; private Account[] mOriAccounts;
//账户
private boolean mHasAddedAccount; private boolean mHasAddedAccount;
// 账户的has标记
@Override @Override
protected void onCreate(Bundle icicle) { protected void onCreate(Bundle icicle) {//创建一个activity，在函数里要完成所有的正常静态设置
super.onCreate(icicle); super.onCreate(icicle);//.执行父类创建函数
/* using the app icon for navigation */ /* using the app icon for navigation */
getActionBar().setDisplayHomeAsUpEnabled(true); getActionBar().setDisplayHomeAsUpEnabled(true);//给左上角图标的左边加上一个返回的图标
addPreferencesFromResource(R.xml.preferences); addPreferencesFromResource(R.xml.preferences);
mAccountCategory = (PreferenceCategory) findPreference(PREFERENCE_SYNC_ACCOUNT_KEY); mAccountCategory = (PreferenceCategory) findPreference(PREFERENCE_SYNC_ACCOUNT_KEY);
mReceiver = new GTaskReceiver(); //根据同步账户密码进行账户分组
IntentFilter filter = new IntentFilter(); mReceiver = new GTaskReceiver();//设置同步任务接收器
IntentFilter filter = new IntentFilter();//设置过滤项
filter.addAction(GTaskSyncService.GTASK_SERVICE_BROADCAST_NAME); filter.addAction(GTaskSyncService.GTASK_SERVICE_BROADCAST_NAME);
registerReceiver(mReceiver, filter); registerReceiver(mReceiver, filter);
//注册监听器，和对应的filter绑定
mOriAccounts = null; mOriAccounts = null;
View header = LayoutInflater.from(this).inflate(R.layout.settings_header, null); View header = LayoutInflater.from(this).inflate(R.layout.settings_header, null);
getListView().addHeaderView(header, null, true); getListView().addHeaderView(header, null, true);
//从xml获取Listview，获取listvivew，ListView的作用:用于列出所有选择
} }
@Override @Override
protected void onResume() { protected void onResume() {//activity交互功能的实现，用于接受用户的输入
super.onResume(); super.onResume();//
// need to set sync account automatically if user has added a new // need to set sync account automatically if user has added a new
// account // account
if (mHasAddedAccount) { if (mHasAddedAccount) {//若用户新加了账户则自动设置同步账户
Account[] accounts = getGoogleAccounts(); Account[] accounts = getGoogleAccounts();//获取google同步账户
if (mOriAccounts != null && accounts.length > mOriAccounts.length) { if (mOriAccounts != null && accounts.length > mOriAccounts.length) {//若账户不为空且账户增加
for (Account accountNew : accounts) { for (Account accountNew : accounts) {//遍历账户
boolean found = false; boolean found = false;//更新账户
for (Account accountOld : mOriAccounts) { for (Account accountOld : mOriAccounts) {//循环判断当前账户列表中的账户是否与新建账户名相同
if (TextUtils.equals(accountOld.name, accountNew.name)) { if (TextUtils.equals(accountOld.name, accountNew.name)) {
found = true; found = true;
break; break;//.若是没有找到旧的账户，那么同步账号中就只添加新账户
} }
} }
if (!found) { if (!found) {
@ -117,70 +121,72 @@ public class NotesPreferenceActivity extends PreferenceActivity {
} }
@Override @Override
protected void onDestroy() { protected void onDestroy() {//销毁Activity
if (mReceiver != null) { if (mReceiver != null) {
unregisterReceiver(mReceiver); unregisterReceiver(mReceiver);//执行销毁操作
} }
super.onDestroy(); super.onDestroy();
} }
private void loadAccountPreference() { private void loadAccountPreference() {//设置账户信息
mAccountCategory.removeAll(); mAccountCategory.removeAll();//移除所有分组
Preference accountPref = new Preference(this); Preference accountPref = new Preference(this);//默认账户为当前账户
final String defaultAccount = getSyncAccountName(this); final String defaultAccount = getSyncAccountName(this);
accountPref.setTitle(getString(R.string.preferences_account_title)); accountPref.setTitle(getString(R.string.preferences_account_title));//首选项的大小标题
accountPref.setSummary(getString(R.string.preferences_account_summary)); accountPref.setSummary(getString(R.string.preferences_account_summary));//与google task同步便签记录
accountPref.setOnPreferenceClickListener(new OnPreferenceClickListener() { accountPref.setOnPreferenceClickListener(new OnPreferenceClickListener() {//设置preference的的监听器
public boolean onPreferenceClick(Preference preference) { public boolean onPreferenceClick(Preference preference) {//功能描述：响应偏好对应元素的点击
if (!GTaskSyncService.isSyncing()) { //函数实现：判断是否处于同步模式和默认的数据，指向不同的操作
if (!GTaskSyncService.isSyncing()) {//若不在同步状态
if (TextUtils.isEmpty(defaultAccount)) { if (TextUtils.isEmpty(defaultAccount)) {
// the first time to set account // the first time to set account
showSelectAccountAlertDialog(); showSelectAccountAlertDialog();
} else { } else {
// if the account has already been set, we need to promp // if the account has already been set, we need to promp
// user about the risk // user about the risk
showChangeAccountConfirmAlertDialog(); showChangeAccountConfirmAlertDialog();//已有账户则显示确认对话框
} }
} else { } else {//若处于同步状态的情况下
Toast.makeText(NotesPreferenceActivity.this, Toast.makeText(NotesPreferenceActivity.this,
R.string.preferences_toast_cannot_change_account, Toast.LENGTH_SHORT) R.string.preferences_toast_cannot_change_account, Toast.LENGTH_SHORT)
.show(); .show();
} }//不能切换处于同步的账号
return true; return true;
} }
}); });
mAccountCategory.addPreference(accountPref); mAccountCategory.addPreference(accountPref);//根据新建首选项编辑新的账户分组
} }
private void loadSyncButton() { private void loadSyncButton() {//.设置同步按键和最近同步时间
Button syncButton = (Button) findViewById(R.id.preference_sync_button); Button syncButton = (Button) findViewById(R.id.preference_sync_button);
TextView lastSyncTimeView = (TextView) findViewById(R.id.prefenerece_sync_status_textview); TextView lastSyncTimeView = (TextView) findViewById(R.id.prefenerece_sync_status_textview);
//获取同步按键和同步时间显示
// set button state // set button state
if (GTaskSyncService.isSyncing()) { if (GTaskSyncService.isSyncing()) {//设置按钮状态
syncButton.setText(getString(R.string.preferences_button_sync_cancel)); if (GTaskSyncService.isSyncing()) {//若是在同步状态下
syncButton.setOnClickListener(new View.OnClickListener() { syncButton.setText(getString(R.string.preferences_button_sync_cancel));//
syncButton.setOnClickListener(new View.OnClickListener() {//设置监听器
public void onClick(View v) { public void onClick(View v) {
GTaskSyncService.cancelSync(NotesPreferenceActivity.this); GTaskSyncService.cancelSync(NotesPreferenceActivity.this);
} }
}); });
} else { } else {
syncButton.setText(getString(R.string.preferences_button_sync_immediately)); syncButton.setText(getString(R.string.preferences_button_sync_immediately));//非同步状态下按键显示“立即同步”，设置相关监听器
syncButton.setOnClickListener(new View.OnClickListener() { syncButton.setOnClickListener(new View.OnClickListener() {
public void onClick(View v) { public void onClick(View v) {//点击行为
GTaskSyncService.startSync(NotesPreferenceActivity.this); GTaskSyncService.startSync(NotesPreferenceActivity.this);
} }//开始操作
}); });
} }
syncButton.setEnabled(!TextUtils.isEmpty(getSyncAccountName(this))); syncButton.setEnabled(!TextUtils.isEmpty(getSyncAccountName(this)));
//如果没有账户，则不可选“立即同步”的按键
// set last sync time // set last sync time
if (GTaskSyncService.isSyncing()) { if (GTaskSyncService.isSyncing()) {
lastSyncTimeView.setText(GTaskSyncService.getProgressString()); lastSyncTimeView.setText(GTaskSyncService.getProgressString());
lastSyncTimeView.setVisibility(View.VISIBLE); lastSyncTimeView.setVisibility(View.VISIBLE);//根据当前同步服务器设置时间显示框的文本以及可见性
} else { } else {//设置显示内容
long lastSyncTime = getLastSyncTime(this); long lastSyncTime = getLastSyncTime(this);
if (lastSyncTime != 0) { if (lastSyncTime != 0) {
lastSyncTimeView.setText(getString(R.string.preferences_last_sync_time, lastSyncTimeView.setText(getString(R.string.preferences_last_sync_time,
@ -189,74 +195,75 @@ public class NotesPreferenceActivity extends PreferenceActivity {
lastSyncTimeView.setVisibility(View.VISIBLE); lastSyncTimeView.setVisibility(View.VISIBLE);
} else { } else {
lastSyncTimeView.setVisibility(View.GONE); lastSyncTimeView.setVisibility(View.GONE);
} }//最近同步时间为空设置同步时间不可见
} }
} }
private void refreshUI() { private void refreshUI() {
loadAccountPreference(); loadAccountPreference();
loadSyncButton(); loadSyncButton();
} }//刷新标签界面
private void showSelectAccountAlertDialog() { private void showSelectAccountAlertDialog() {//显示账户选择的对话框并进行账户的设置
AlertDialog.Builder dialogBuilder = new AlertDialog.Builder(this); AlertDialog.Builder dialogBuilder = new AlertDialog.Builder(this);
//创建一个新函数对话框
View titleView = LayoutInflater.from(this).inflate(R.layout.account_dialog_title, null); View titleView = LayoutInflater.from(this).inflate(R.layout.account_dialog_title, null);
//文本视图设置
TextView titleTextView = (TextView) titleView.findViewById(R.id.account_dialog_title); TextView titleTextView = (TextView) titleView.findViewById(R.id.account_dialog_title);
titleTextView.setText(getString(R.string.preferences_dialog_select_account_title)); titleTextView.setText(getString(R.string.preferences_dialog_select_account_title));
TextView subtitleTextView = (TextView) titleView.findViewById(R.id.account_dialog_subtitle); TextView subtitleTextView = (TextView) titleView.findViewById(R.id.account_dialog_subtitle);
subtitleTextView.setText(getString(R.string.preferences_dialog_select_account_tips)); subtitleTextView.setText(getString(R.string.preferences_dialog_select_account_tips));
dialogBuilder.setCustomTitle(titleView); dialogBuilder.setCustomTitle(titleView);//设置标题及子标题内容
dialogBuilder.setPositiveButton(null, null); dialogBuilder.setPositiveButton(null, null);//取消设置键按钮
Account[] accounts = getGoogleAccounts(); Account[] accounts = getGoogleAccounts();//获得谷歌当前账户列表
String defAccount = getSyncAccountName(this); String defAccount = getSyncAccountName(this);//默认账户
mOriAccounts = accounts; mOriAccounts = accounts;
mHasAddedAccount = false; mHasAddedAccount = false;//获得账户同步信息
if (accounts.length > 0) { if (accounts.length > 0) {//如果有账户，则显示所有账户名称
CharSequence[] items = new CharSequence[accounts.length]; CharSequence[] items = new CharSequence[accounts.length];
final CharSequence[] itemMapping = items; final CharSequence[] itemMapping = items;
int checkedItem = -1; int checkedItem = -1;
int index = 0; int index = 0;
for (Account account : accounts) { for (Account account : accounts) {//for循环检查账户列表
if (TextUtils.equals(account.name, defAccount)) { if (TextUtils.equals(account.name, defAccount)) {
checkedItem = index; checkedItem = index;//查询目标账户
} }
items[index++] = account.name; items[index++] = account.name;
} }
dialogBuilder.setSingleChoiceItems(items, checkedItem, dialogBuilder.setSingleChoiceItems(items, checkedItem,
new DialogInterface.OnClickListener() { new DialogInterface.OnClickListener() {//在对话框建立一个复选的对话框
public void onClick(DialogInterface dialog, int which) { public void onClick(DialogInterface dialog, int which) {//添加点击监听器
setSyncAccount(itemMapping[which].toString()); setSyncAccount(itemMapping[which].toString());//同步账户设置
dialog.dismiss(); dialog.dismiss();//取消对话框
refreshUI(); refreshUI();//刷新界面
} }
}); });
} }
View addAccountView = LayoutInflater.from(this).inflate(R.layout.add_account_text, null); View addAccountView = LayoutInflater.from(this).inflate(R.layout.add_account_text, null);
dialogBuilder.setView(addAccountView); dialogBuilder.setView(addAccountView);
//添加新账户，并为账户添加对话框视图
final AlertDialog dialog = dialogBuilder.show(); final AlertDialog dialog = dialogBuilder.show();//显示对话框
addAccountView.setOnClickListener(new View.OnClickListener() { addAccountView.setOnClickListener(new View.OnClickListener() {//响应点击添加账户请求
public void onClick(View v) { public void onClick(View v) {
mHasAddedAccount = true; mHasAddedAccount = true;
Intent intent = new Intent("android.settings.ADD_ACCOUNT_SETTINGS"); Intent intent = new Intent("android.settings.ADD_ACCOUNT_SETTINGS");
intent.putExtra(AUTHORITIES_FILTER_KEY, new String[] { intent.putExtra(AUTHORITIES_FILTER_KEY, new String[] {
"gmail-ls" "gmail-ls"
}); });//建立网络组件
startActivityForResult(intent, -1); startActivityForResult(intent, -1);//返回上一选项
dialog.dismiss(); dialog.dismiss();
} }
}); });
} }
private void showChangeAccountConfirmAlertDialog() { private void showChangeAccountConfirmAlertDialog() {//刷新标签界面
AlertDialog.Builder dialogBuilder = new AlertDialog.Builder(this); AlertDialog.Builder dialogBuilder = new AlertDialog.Builder(this);
//创建一个新的对话框
View titleView = LayoutInflater.from(this).inflate(R.layout.account_dialog_title, null); View titleView = LayoutInflater.from(this).inflate(R.layout.account_dialog_title, null);
TextView titleTextView = (TextView) titleView.findViewById(R.id.account_dialog_title); TextView titleTextView = (TextView) titleView.findViewById(R.id.account_dialog_title);
titleTextView.setText(getString(R.string.preferences_dialog_change_account_title, titleTextView.setText(getString(R.string.preferences_dialog_change_account_title,
@ -269,42 +276,42 @@ public class NotesPreferenceActivity extends PreferenceActivity {
getString(R.string.preferences_menu_change_account), getString(R.string.preferences_menu_change_account),
getString(R.string.preferences_menu_remove_account), getString(R.string.preferences_menu_remove_account),
getString(R.string.preferences_menu_cancel) getString(R.string.preferences_menu_cancel)
}; };//设置对话框自定义标题，对话框 可供选择的三种模式：改变同步账户，删除同步账户，取消
dialogBuilder.setItems(menuItemArray, new DialogInterface.OnClickListener() { dialogBuilder.setItems(menuItemArray, new DialogInterface.OnClickListener() {
public void onClick(DialogInterface dialog, int which) { public void onClick(DialogInterface dialog, int which) {
if (which == 0) { if (which == 0) {//若改变账户，则可显示该账户信息
showSelectAccountAlertDialog(); showSelectAccountAlertDialog();
} else if (which == 1) { } else if (which == 1) {
removeSyncAccount(); removeSyncAccount();
refreshUI(); refreshUI();
} }
} }
}); });//
dialogBuilder.show(); dialogBuilder.show();//显示对话框
} }
private Account[] getGoogleAccounts() { private Account[] getGoogleAccounts() {
AccountManager accountManager = AccountManager.get(this); AccountManager accountManager = AccountManager.get(this);
return accountManager.getAccountsByType("com.google"); return accountManager.getAccountsByType("com.google");
} }// 函数：获取谷歌账户，可通过账户管理器直接获取
private void setSyncAccount(String account) { private void setSyncAccount(String account) {//设置同步账户
if (!getSyncAccountName(this).equals(account)) { if (!getSyncAccountName(this).equals(account)) {//若该账户不在同步列表内
SharedPreferences settings = getSharedPreferences(PREFERENCE_NAME, Context.MODE_PRIVATE); SharedPreferences settings = getSharedPreferences(PREFERENCE_NAME, Context.MODE_PRIVATE);
SharedPreferences.Editor editor = settings.edit(); SharedPreferences.Editor editor = settings.edit();
if (account != null) { if (account != null) {
editor.putString(PREFERENCE_SYNC_ACCOUNT_NAME, account); editor.putString(PREFERENCE_SYNC_ACCOUNT_NAME, account);//若账户不为空，编辑账户的首选项
} else { } else {
editor.putString(PREFERENCE_SYNC_ACCOUNT_NAME, ""); editor.putString(PREFERENCE_SYNC_ACCOUNT_NAME, "");
} }
editor.commit(); editor.commit();//提交数据
// clean up last sync time // clean up last sync time
setLastSyncTime(this, 0); setLastSyncTime(this, 0);
// clean up local gtask related info // clean up local gtask related info
new Thread(new Runnable() { new Thread(new Runnable() {
public void run() { public void run() {//清除本地的gtask关联的信息 将一些参数设置为0或NULL
ContentValues values = new ContentValues(); ContentValues values = new ContentValues();
values.put(NoteColumns.GTASK_ID, ""); values.put(NoteColumns.GTASK_ID, "");
values.put(NoteColumns.SYNC_ID, 0); values.put(NoteColumns.SYNC_ID, 0);
@ -314,24 +321,24 @@ public class NotesPreferenceActivity extends PreferenceActivity {
Toast.makeText(NotesPreferenceActivity.this, Toast.makeText(NotesPreferenceActivity.this,
getString(R.string.preferences_toast_success_set_accout, account), getString(R.string.preferences_toast_success_set_accout, account),
Toast.LENGTH_SHORT).show(); Toast.LENGTH_SHORT).show();//将toast的文本信息置为“设置账户成功”并显示出来
} }
} }
private void removeSyncAccount() { private void removeSyncAccount() {//删除同步账户
SharedPreferences settings = getSharedPreferences(PREFERENCE_NAME, Context.MODE_PRIVATE); SharedPreferences settings = getSharedPreferences(PREFERENCE_NAME, Context.MODE_PRIVATE);
SharedPreferences.Editor editor = settings.edit(); SharedPreferences.Editor editor = settings.edit();//存放数据，设置共享首选项
if (settings.contains(PREFERENCE_SYNC_ACCOUNT_NAME)) { if (settings.contains(PREFERENCE_SYNC_ACCOUNT_NAME)) {//若当前账户首选项存在数据，就删除
editor.remove(PREFERENCE_SYNC_ACCOUNT_NAME); editor.remove(PREFERENCE_SYNC_ACCOUNT_NAME);
} }
if (settings.contains(PREFERENCE_LAST_SYNC_TIME)) { if (settings.contains(PREFERENCE_LAST_SYNC_TIME)) {//删除当前账户存在时间
editor.remove(PREFERENCE_LAST_SYNC_TIME); editor.remove(PREFERENCE_LAST_SYNC_TIME);
} }
editor.commit(); editor.commit();
// clean up local gtask related info // clean up local gtask related info
new Thread(new Runnable() { new Thread(new Runnable() {//
public void run() { public void run() {//清除本地的gtask关联的信息，将一些参数设置为0或NULL
ContentValues values = new ContentValues(); ContentValues values = new ContentValues();
values.put(NoteColumns.GTASK_ID, ""); values.put(NoteColumns.GTASK_ID, "");
values.put(NoteColumns.SYNC_ID, 0); values.put(NoteColumns.SYNC_ID, 0);
@ -340,49 +347,50 @@ public class NotesPreferenceActivity extends PreferenceActivity {
}).start(); }).start();
} }
public static String getSyncAccountName(Context context) { public static String getSyncAccountName(Context context) {//通过共享的首选项里的信息直接获取
SharedPreferences settings = context.getSharedPreferences(PREFERENCE_NAME, SharedPreferences settings = context.getSharedPreferences(PREFERENCE_NAME,
Context.MODE_PRIVATE); Context.MODE_PRIVATE);//获取同步账户名称
return settings.getString(PREFERENCE_SYNC_ACCOUNT_NAME, ""); return settings.getString(PREFERENCE_SYNC_ACCOUNT_NAME, "");
} }
public static void setLastSyncTime(Context context, long time) { public static void setLastSyncTime(Context context, long time) {//函数：设置最终同步的时间
SharedPreferences settings = context.getSharedPreferences(PREFERENCE_NAME, SharedPreferences settings = context.getSharedPreferences(PREFERENCE_NAME,
Context.MODE_PRIVATE); Context.MODE_PRIVATE);//从共享首选项中找到相关账户并获取其编辑器
SharedPreferences.Editor editor = settings.edit(); SharedPreferences.Editor editor = settings.edit();
editor.putLong(PREFERENCE_LAST_SYNC_TIME, time); editor.putLong(PREFERENCE_LAST_SYNC_TIME, time);
editor.commit(); editor.commit();
} }
public static long getLastSyncTime(Context context) { public static long getLastSyncTime(Context context) {////通过共享的首选项里的信息直接获取
SharedPreferences settings = context.getSharedPreferences(PREFERENCE_NAME, SharedPreferences settings = context.getSharedPreferences(PREFERENCE_NAME,
Context.MODE_PRIVATE); Context.MODE_PRIVATE);//通过共享，获取时间
return settings.getLong(PREFERENCE_LAST_SYNC_TIME, 0); return settings.getLong(PREFERENCE_LAST_SYNC_TIME, 0);
} }
private class GTaskReceiver extends BroadcastReceiver { private class GTaskReceiver extends BroadcastReceiver {
//响应收到的广播情况
@Override @Override
public void onReceive(Context context, Intent intent) { public void onReceive(Context context, Intent intent) {//获取随广播而来的Intent中的同步服务的数据
refreshUI(); refreshUI();
if (intent.getBooleanExtra(GTaskSyncService.GTASK_SERVICE_BROADCAST_IS_SYNCING, false)) { if (intent.getBooleanExtra(GTaskSyncService.GTASK_SERVICE_BROADCAST_IS_SYNCING, false)) {
TextView syncStatus = (TextView) findViewById(R.id.prefenerece_sync_status_textview); TextView syncStatus = (TextView) findViewById(R.id.prefenerece_sync_status_textview);
syncStatus.setText(intent syncStatus.setText(intent
.getStringExtra(GTaskSyncService.GTASK_SERVICE_BROADCAST_PROGRESS_MSG)); .getStringExtra(GTaskSyncService.GTASK_SERVICE_BROADCAST_PROGRESS_MSG));
} }//如果在同步状态，改变同步按钮显示的文本
} }
} }
public boolean onOptionsItemSelected(MenuItem item) { public boolean onOptionsItemSelected(MenuItem item) {//处理菜单选项
switch (item.getItemId()) { switch (item.getItemId()) {
case android.R.id.home: case android.R.id.home://返回主界面
Intent intent = new Intent(this, NotesListActivity.class); Intent intent = new Intent(this, NotesListActivity.class);
//开始创建活动
intent.addFlags(Intent.FLAG_ACTIVITY_CLEAR_TOP); intent.addFlags(Intent.FLAG_ACTIVITY_CLEAR_TOP);
startActivity(intent); startActivity(intent);
return true; return true;
default: default:
return false; return false;//若出现错误则返回
} }
} }
} }

Write Preview
Loading…
Cancel
Save