Android记事本示例剖析之三中讲了Activity的生命周期，并通过实验的方式研究了Activity的状态转换机制，之后又介绍了自定义控件。本文继续Android记事本示例的分析，主要讲解NoteEditor类和Content Provider机制。

       深入剖析NoteEditor类

　　首先来弄清楚“日志编辑“的状态转换，通过Android记事本示例剖析之三中的方法来做下面这样一个实验，首先进入“日志编辑”时会触发onCreate和onResume,然后用户通过Option Menu选择“Edit title”后，会触发onSaveInstanceState和onPause，最后，用户回到编辑界面，则再次触发onResume。

　　最终通过LogCat可以得到下图：

NoteEditor Logcat

       那么下面就按照上述顺序对此类进行剖析。首先是onCreate方法，一开始先获取导致进入“日志编辑”界面的intent,分析其操作类型可得知是“编辑日志”还是“新增日撒志”。

Java代码
  1. final Intent intent = getIntent();   
  2. // Do some setup based on the action being performed.   
  3. final String action = intent.getAction();  

       若是“编辑日志”，则设置当前状态为“编辑”，并保存待编辑日志的URI。

Java代码
  1. mState = STATE_EDIT;   
  2. mUri = intent.getData();  

       若是“新增日志”，则设置当前状态为“新增”，并通过content provider向数据库中新增一个“空白日志”，后者返回“空白日志”的URI。

Java代码
  1. mState = STATE_INSERT;   
  2. mUri = getContentResolver().insert(intent.getData(), null);   

       然后不管是“编辑”或“新增”，都需要从数据库中读取日志信息（当然，若是“新增”，读出来的肯定是空数据）。

Java代码
  1. mCursor = managedQuery(mUri, PROJECTION, null, null, null);  

       最后，类似于web应用中使用的Session,这里也将日志文本保存在InstanceState中，因此，若此activity的实例此前是处于stop状态，则我们可以从它那取出它原本的文本数据。

Java代码
  1. if (savedInstanceState != null)    
  2. {   
  3.      mOriginalContent = savedInstanceState.getString(ORIGINAL_CONTENT);   
  4. }   

       第二个来分析onResume函数，首先把游标置于第一行（也只有一行）。

Java代码
  1. mCursor.moveToFirst();  

       然后取出“正文”字段，这时有一个比较有趣的技巧，“设置文本”并不是调用setText，而是调用的setTextKeepState，后者相对于前者有一个优点，就是当界面此前stop掉，现在重新resume回来，那么此前光标所在位置仍然得以保存。而若使用setText，则光标会重置到行首。

Java代码
  1. String note = mCursor.getString(COLUMN_INDEX_NOTE);   
  2.             mText.setTextKeepState(note);  

       最后，将当前编辑的正文保存到一个字符串变量中，用于当activity被暂停时使用。

Java代码
  1. if (mOriginalContent == null)    
  2. {   
  3.      mOriginalContent = note;   
  4. }   

       通过前面的图可以得知，activity被暂停时，首先调用的是onSaveInstanceState函数。

Java代码
  1. outState.putString(ORIGINAL_CONTENT, mOriginalContent);  

       这里就仅仅将当前正编辑的正文保存到InstanceState中(类似于Session)。最后来看onPause函数，这里首先要考虑的是若activity正要关闭，并且编辑区没有正文，则将此日志删除。

Java代码
  1. if (isFinishing() && (length == 0) && !mNoteOnly)       
  2. {      
  3.      setResult(RESULT_CANCELED);      
  4.      deleteNote();      
  5. }   

       否则的话，就更新日志信息。

Java代码
  1.   ContentValues values = new ContentValues();   
  2.   if (!mNoteOnly)    
  3.   {   
  4.       values.put(Notes.MODIFIED_DATE, System.currentTimeMillis());   
  5.       if (mState == STATE_INSERT)   
  6.       {   
  7.           String title = text.substring(0, Math.min(30, length));   
  8.           if (length > 30)    
  9.           {   
  10.               int lastSpace = title.lastIndexOf(' ');   
  11.               if (lastSpace > 0)    
  12.               {   
  13.                    title = title.substring(0, lastSpace);   
  14.               }   
  15.           }   
  16.           values.put(Notes.TITLE, title);   
  17.       }   
  18.   }   
  19.   values.put(Notes.NOTE, text);   
  20.   getContentResolver().update(mUri, values, null, null);   
  21. }   

       在生成Option Menu的函数onCreateOptionsMenu中，我们再一次看到下面这段熟悉的代码了：

Java代码
  1. Intent intent = new Intent(null, getIntent().getData());   
  2. intent.addCategory(Intent.CATEGORY_ALTERNATIVE);   
  3. menu.addIntentOptions(Menu.CATEGORY_ALTERNATIVE, 0, 0,   
  4. new ComponentName(this, NoteEditor.class), null, intent, 0, null);  

       这种生成动态菜单的机制在Android示例程序剖析之记事本（二：Android菜单）这篇文章中已经介绍过了，就不赘述了。最后，来看下放弃日志和删除日志的实现，由于还没有接触到底层的content provider，这里都是通过getContentResolver()提供的update，delete，insert来向底层的content provider发出请求，由后者完成实际的数据库操作。

Java代码
  1. private final void cancelNote()       
  2. {      
  3.     if (mCursor != null)      
  4.     {      
  5.         if (mState == STATE_EDIT)       
  6.         {      
  7.              // Put the original note text back into the database      
  8.              mCursor.close();      
  9.              mCursor = null;      
  10.              ContentValues values = new ContentValues();      
  11.              values.put(Notes.NOTE, mOriginalContent);      
  12.              getContentResolver().update(mUri, values, null, null);      
  13.          }      
  14.          else if (mState == STATE_INSERT)       
  15.          {      
  16.              // We inserted an empty note, make sure to delete it      
  17.              deleteNote();      
  18.          }      
  19.     }      
  20.     setResult(RESULT_CANCELED);      
  21.     finish();      
  22. }      
  23. private final void deleteNote()       
  24. {      
  25.     if (mCursor != null)       
  26.     {      
  27.          mCursor.close();      
  28.          mCursor = null;      
  29.          getContentResolver().delete(mUri, null, null);      
  30.          mText.setText("");      
  31.     }      
  32. }  

       NotePadProvider类分析

       NotePadProvider就是所谓的content provider，它继承自android.content.ContentProvider，也是负责数据库层的核心类，主要提供五个功能：

　　1）查询数据

　　2）修改数据

　　3）添加数据

　　4）删除数据

　　5）返回数据类型

　　这五个功能分别对应下述五个可以重载的方法：

Java代码
  1. public int delete(Uri uri, String selection, String[] selectionArgs)    
  2. {   
  3.        return 0;   
  4. }   
  5. public String getType(Uri uri)    
  6. {   
  7.        return null;   
  8. }   
  9. public Uri insert(Uri uri, ContentValues values)    
  10. {   
  11.        return null;   
  12. }   
  13. public boolean onCreate()    
  14. {   
  15.        return false;   
  16. }   
  17. public Cursor query(Uri uri, String[] projection, String selection,   
  18.            String[] selectionArgs, String sortOrder)   
  19. {   
  20.        return null;   
  21. }   
  22. public int update(Uri uri, ContentValues values, String selection,   
  23.            String[] selectionArgs)    
  24. {   
  25.        return 0;   
  26. }  

       这些都要你自己实现，不同的实现就是对应不同的content-provider。但是activity使用content-provider不是直接创建一个对象，然后调用这些具体方法。

       而是调用managedQuery，getContentResolver().delete，update等来实现，这些函数其实是先找到符合条件的content-provider，然后再调用具体content-provider的函数来实现，那又是怎么找到content-provider，就是通过uri中的authority来找到content-provider，这些都是通过系统完成，应用程序不用操心，这样就达到了有效地隔离应用和内容提供者的具体实现的目的。

　　有了以上初步知识后，我们来看NotePadProvider是如何为上层提供数据库层支持的。下面这三个字段指明了数据库名称，数据库版本，数据表名称。

Java代码
  1. private static final String DATABASE_NAME = "note_pad.db";   
  2. private static final int DATABASE_VERSION = 2;   
  3. private static final String NOTES_TABLE_NAME = "notes";  

       实际的数据库操作其实都是通过一个私有静态类DatabaseHelper实现的，其构造函数负责创建指定名称和版本的数据库，onCreate函数则创建指定名称和各个数据域的数据表（就是简单的建表SQL语句）。onUpgrade负责删除数据表，再重新建表。

Java代码
  1. private static class DatabaseHelper extends SQLiteOpenHelper    
  2. {   
  3.         DatabaseHelper(Context context)    
  4.         {   
  5.             super(context, DATABASE_NAME, null, DATABASE_VERSION);   
  6.         }   
  7.         @Override  
  8.         public void onCreate(SQLiteDatabase db)    
  9.         {   
  10.             db.execSQL("CREATE TABLE " + NOTES_TABLE_NAME + " ("  
  11.                     + Notes._ID + " INTEGER PRIMARY KEY,"  
  12.                     + Notes.TITLE + " TEXT,"  
  13.                     + Notes.NOTE + " TEXT,"  
  14.                     + Notes.CREATED_DATE + " INTEGER,"  
  15.                     + Notes.MODIFIED_DATE + " INTEGER"  
  16.                     + ");");   
  17.         }   
  18.         @Override  
  19.         public void onUpgrade(SQLiteDatabase db, int oldVersion, int newVersion)    
  20.         {   
  21.             Log.w(TAG, "Upgrading database from version " + oldVersion + " to "  
  22.                     + newVersion + ", which will destroy all old data");   
  23.             db.execSQL("DROP TABLE IF EXISTS notes");   
  24.             onCreate(db);   
  25.         }   
  26. }  

       在Android示例程序剖析之记事本（一）这篇文章中我们已经见识到了getType函数的用处了，也正是通过它的解析，才能区分开到底是对全部日志还是对某一条日志进行操作。

Java代码
  1. public String getType(Uri uri)    
  2. {   
  3.         switch (sUriMatcher.match(uri))   
  4.         {   
  5.         case NOTES:   
  6.             return Notes.CONTENT_TYPE;   
  7.         case NOTE_ID:   
  8.             return Notes.CONTENT_ITEM_TYPE;   
  9.         default:   
  10.             throw new IllegalArgumentException("Unknown URI " + uri);   
  11.         }   
  12. }  

       上面的sUriMatcher.match是用来检测uri是否能够被处理，而sUriMatcher.match(uri)返回值其实是由下述语句决定的。

Java代码
  1. sUriMatcher = new UriMatcher(UriMatcher.NO_MATCH);   
  2. sUriMatcher.addURI(NotePad.AUTHORITY, "notes", NOTES);   
  3. sUriMatcher.addURI(NotePad.AUTHORITY, "notes/#", NOTE_ID);  

       sNotesProjectionMap这个私有字段是用来在上层应用使用的字段和底层数据库字段之间建立映射关系的，当然，这个程序里两处对应的字段都是一样（但并不需要一样）。

Java代码
  1. private static HashMap<String, String> sNotesProjectionMap;   
  2. static    
  3. {   
  4.         sNotesProjectionMap = new HashMap<String, String>();   
  5.         sNotesProjectionMap.put(Notes._ID, Notes._ID);   
  6.         sNotesProjectionMap.put(Notes.TITLE, Notes.TITLE);   
  7.         sNotesProjectionMap.put(Notes.NOTE, Notes.NOTE);   
  8.         sNotesProjectionMap.put(Notes.CREATED_DATE, Notes.CREATED_DATE);   
  9.         sNotesProjectionMap.put(Notes.MODIFIED_DATE, Notes.MODIFIED_DATE);   
  10. }  

       数据库的增，删，改，查操作基本都一样，具体可以参考官方文档，这里就仅仅以删除为例进行说明。一般可以分为三步来完成，首先打开数据库。

Java代码
  1. SQLiteDatabase db = mOpenHelper.getWritableDatabase();  

       然后根据URI指向的是日志列表还是某一篇日志，到数据库中执行删除动作。

Java代码
  1. switch (sUriMatcher.match(uri)) {   
  2. case NOTES:   
  3.      count = db.delete(NOTES_TABLE_NAME, where, whereArgs);   
  4.      break;   
  5. case NOTE_ID:   
  6.      String noteId = uri.getPathSegments().get(1);   
  7.      count = db.delete(NOTES_TABLE_NAME, Notes._ID + "=" + noteId + (!TextUtils.isEmpty(where) ? " AND (" + where + ')' : ""), whereArgs);   
  8.      break;   
  9. }  

       最后，一定记得通知上层：其传递下来的URI在底层数据库中已经发生了变化。

Java代码
  1. getContext().getContentResolver().notifyChange(uri, null);  

       改进NotePad

       首先我想指出NotePad的一个bug，其实这个小bug在2月份就有人向官方报告了，参见http://code.google.com/p/android/issues/detail?id=1909。NoteEditor类中的变量mNoteOnly根本就是没有用处的，因为它始终都是false，没有任何变化,所以可以删除掉。第二点是在NoteEditor类中，有下面这样的语句：

Java代码
  1. setResult(RESULT_OK, (new Intent()).setAction(mUri.toString()));   
  2. setResult(RESULT_CANCELED);  

       可到底想展示什么技术呢？实际上并没有完整展现出来，这里我对其进行修改后来指明。参见http://code.google.com/p/android/issues/detail?id=1671）。首先在NotesList类中增加一个变量

Java代码
  1. private static final int REQUEST_INSERT = 100;//请求插入标识符  

       然后修改onOptionsItemSelected函数如下：

Java代码
  1. @Override  
  2. public boolean onOptionsItemSelected(MenuItem item)    
  3. {   
  4.     switch (item.getItemId())   
  5.     {   
  6.     case MENU_ITEM_INSERT:   
  7.          this.startActivityForResult(new Intent(Intent.ACTION_INSERT, getIntent().getData()), REQUEST_INSERT);   
  8.          return true;   
  9.     }   
  10.     return super.onOptionsItemSelected(item);   
  11. }  

       最后重载onActivityResult函数来处理接收到的activity result。

Java代码
  1. protected void onActivityResult(int requestCode, int resultCode, Intent data)   
  2. {   
  3.      if(requestCode == REQUEST_INSERT)   
  4.      {   
  5.          if(resultCode==RESULT_OK)   
  6.          {   
  7.              Log.d(TAG, "OK!!!");   
  8.          }   
  9.          else if(resultCode==RESULT_CANCELED)   
  10.          {   
  11.              Log.d(TAG, "CANCELED!!!");   
  12.          }   
  13.      }   
  14. }  

       试试，当你在NoteEditor中保存或放弃日志时，观察LogCat，你可以看到下面这样的画面：

NoteEditor改进后的Logcat

本文发布：Android开发网
本文地址：http://www.jizhuomi.com/android/example/171.html
2012年8月22日
发布:鸡啄米 分类:Android开发实例 浏览: 评论:3