詳解Android中的Context抽象類別_Android

關於Context我們首先應該知道：
（1）它描述的是一個應用程式環境的資訊，即上下文。
（2）該類是一個抽象(abstract class)類，Android提供了該抽象類別的具體實作類別(後面我們會講到是ContextIml類)。
（3）通過它我們可以擷取應用程式的資源和類，也包括一些應用層級操作，例如：啟動一個Activity，發送廣播，接受Intent資訊等。。

於是，我們可以利用該Context對象去構建應用層級操作(application-level operations) 。
一、Context相關類的繼承關係

相關類介紹：
Context類路徑： /frameworks/base/core/java/android/content/Context.java
說明：抽象類別，提供了一組通用的API。原始碼(部分)如下：   

public abstract class Context {    ...    public abstract Object getSystemService(String name); //獲得系統級服務    public abstract void startActivity(Intent intent);   //通過一個Intent啟動Activity    public abstract ComponentName startService(Intent service); //啟動Service    //根據檔案名稱得到SharedPreferences對象    public abstract SharedPreferences getSharedPreferences(String name,int mode);    ... } 

 
ContextIml.java類  路徑 ：/frameworks/base/core/java/android/app/ContextImpl.java
說明：該Context類的實作類別為ContextIml，該類實現了Context類的功能。請注意，該函數的大部分功能都是直接調用其屬性mPackageInfo去完成，這點我們後面會講到。    原始碼(部分)如下：

/**  * Common implementation of Context API, which provides the base  * context object for Activity and other application components.  */ class ContextImpl extends Context{   //所有Application程式公用一個mPackageInfo對象   /*package*/ ActivityThread.PackageInfo mPackageInfo;      @Override   public Object getSystemService(String name){     ...     else if (ACTIVITY_SERVICE.equals(name)) {       return getActivityManager();     }      else if (INPUT_METHOD_SERVICE.equals(name)) {       return InputMethodManager.getInstance(this);     }   }    @Override   public void startActivity(Intent intent) {     ...     //開始啟動一個Activity     mMainThread.getInstrumentation().execStartActivity(       getOuterContext(), mMainThread.getApplicationThread(), null, null, intent, -1);   } } 

ContextWrapper類 路徑 ：\frameworks\base\core\java\android\content\ContextWrapper.java
說明： 正如其名稱一樣，該類只是對Context類的一種封裝，該類的建構函式包含了一個真正的Context引用，即ContextIml對象。原始碼(部分)如下：

public class ContextWrapper extends Context {   Context mBase; //該屬性指向一個ContextIml執行個體，一般在建立Application、Service、Activity時賦值      //建立Application、Service、Activity，會調用該方法給mBase屬性賦值   protected void attachBaseContext(Context base) {     if (mBase != null) {       throw new IllegalStateException("Base context already set");     }     mBase = base;   }   @Override   public void startActivity(Intent intent) {     mBase.startActivity(intent); //調用mBase執行個體方法   } } 

ContextThemeWrapper類 路徑：/frameworks/base/core/java/android/view/ContextThemeWrapper.java
說明：該類內部包含了主題(Theme)相關的介面，即android:theme屬性指定的。只有Activity需要主題，Service不需要主題，所以Service直接繼承於ContextWrapper類。
原始碼(部分)如下：

public class ContextThemeWrapper extends ContextWrapper {    //該屬性指向一個ContextIml執行個體，一般在建立Application、Service、Activity時賦值        private Context mBase;   //mBase賦值方式同樣有一下兩種    public ContextThemeWrapper(Context base, int themeres) {       super(base);       mBase = base;       mThemeResource = themeres;    }     @Override    protected void attachBaseContext(Context newBase) {       super.attachBaseContext(newBase);       mBase = newBase;    } } 

Activity類 、Service類 、Application類本質上都是Context子類， 更多資訊大家可以自行參考原始碼進行理解。
 
二、 什麼時候建立Context執行個體 
 
熟悉了Context的繼承關係後，我們接下來分析應用程式在什麼情況需要建立Context對象的？應用程式建立Context執行個體的情況有如下幾種情況：
（1）建立Application 對象時， 而且整個App共一個Application對象
（2）建立Service對象時
（3）建立Activity對象時
 
因此應用程式App共有的Context數目公式為：
 
總Context執行個體個數 = Service個數 + Activity個數 + 1（Application對應的Context執行個體）
 
具體建立Context的時機：
 
1、建立Application對象的時機
 
每個應用程式在第一次啟動時，都會首先建立Application對象。如果對應用程式啟動一個Activity(startActivity)流程比較清楚的話，建立Application的時機在建立handleBindApplication()方法中，該函數位於 ActivityThread.java類中 ，如下：

//建立Application時同時建立的ContextIml執行個體 private final void handleBindApplication(AppBindData data){   ...   ///建立Application對象   Application app = data.info.makeApplication(data.restrictedBackupMode, null);   ... }  public Application makeApplication(boolean forceDefaultAppClass, Instrumentation instrumentation) {   ...   try {     java.lang.ClassLoader cl = getClassLoader();     ContextImpl appContext = new ContextImpl();  //建立一個ContextImpl對象執行個體     appContext.init(this, null, mActivityThread); //初始化該ContextIml執行個體的相關屬性     ///建立一個Application對象      app = mActivityThread.mInstrumentation.newApplication(         cl, appClass, appContext);     appContext.setOuterContext(app); //將該Application執行個體傳遞給該ContextImpl執行個體        }    ... } 

2、建立Activity對象的時機 
通過startActivity()或startActivityForResult()請求啟動一個Activity時，如果系統檢測需要建立一個Activity對象時，就會回調handleLaunchActivity()方法，該方法繼而調用performLaunchActivity()方法，去建立一個Activity執行個體，並且回調onCreate()，onStart()方法等， 函數都位於 ActivityThread.java類 ，如下：

//建立一個Activity執行個體時同時建立ContextIml執行個體 private final void handleLaunchActivity(ActivityRecord r, Intent customIntent) {   ...   Activity a = performLaunchActivity(r, customIntent); //啟動一個Activity } private final Activity performLaunchActivity(ActivityRecord r, Intent customIntent) {   ...   Activity activity = null;   try {     //建立一個Activity對象執行個體     java.lang.ClassLoader cl = r.packageInfo.getClassLoader();     activity = mInstrumentation.newActivity(cl, component.getClassName(), r.intent);   }   if (activity != null) {     ContextImpl appContext = new ContextImpl();   //建立一個Activity執行個體     appContext.init(r.packageInfo, r.token, this);  //初始化該ContextIml執行個體的相關屬性     appContext.setOuterContext(activity);      //將該Activity資訊傳遞給該ContextImpl執行個體     ...   }   ...   } 

3、建立Service對象的時機
 通過startService或者bindService時，如果系統檢測到需要新建立一個Service執行個體，就會回調handleCreateService()方法，完成相關資料操作。handleCreateService()函數位於 ActivityThread.java類，如下：

//建立一個Service執行個體時同時建立ContextIml執行個體 private final void handleCreateService(CreateServiceData data){   ...   //建立一個Service執行個體   Service service = null;   try {     java.lang.ClassLoader cl = packageInfo.getClassLoader();     service = (Service) cl.loadClass(data.info.name).newInstance();   } catch (Exception e) {   }   ...   ContextImpl context = new ContextImpl(); //建立一個ContextImpl對象執行個體   context.init(packageInfo, null, this);  //初始化該ContextIml執行個體的相關屬性   //獲得我們之前建立的Application對象資訊   Application app = packageInfo.makeApplication(false, mInstrumentation);   //將該Service資訊傳遞給該ContextImpl執行個體   context.setOuterContext(service);   ... } 

 
另外，需要強調一點的是，通過對ContextImp的分析可知，其方法的大多數操作都是直接調用其屬性mPackageInfo(該屬性類
型為PackageInfo)的相關方法而來。這說明ContextImp是一種輕量級類，而PackageInfo才是真正重量級的類。而一個App裡的
所有ContextIml執行個體，都對應同一個packageInfo對象。
           
三、利用Context擷取SharedPreferences類
給大家分析利用Context擷取SharedPreferences類的使用方法，SharedPreferences類想必大家都使用過，其一般擷取方
法就是通過調用getSharedPreferences()方法去根據相關資訊擷取SharedPreferences對象。具體流程如下：
1 、調用  getSharedPreferences()擷取對應的的檔案，該函數實現功能如下：

//Context類待用資料集合，以索引值對儲存了所有讀取該xml檔案後所形成的資料集合 private static final HashMap<File, SharedPreferencesImpl> sSharedPrefs =      new HashMap<File, SharedPreferencesImpl>();   @Override public SharedPreferences getSharedPreferences(String name, int mode){    //其所對應的SharedPreferencesImpl對象 ，該對象已一個HashMap集合儲存了我們對該檔案序列化結果    SharedPreferencesImpl sp;     File f = getSharedPrefsFile(name); //該包下是否存在對應的檔案，不存在就建立一個    synchronized (sSharedPrefs) {    //是否已經讀取過該檔案，是就直接返回該SharedPreferences對象      sp = sSharedPrefs.get(f);      if (sp != null && !sp.hasFileChanged()) {        //Log.i(TAG, "Returning existing prefs " + name + ": " + sp);        return sp;      }    }    //以下為序列化該xml檔案，同時將資料寫到map集合中       Map map = null;    if (f.exists() && f.canRead()) {      try {        str = new FileInputStream(f);        map = XmlUtils.readMapXml(str);        str.close();      }       ...    }        synchronized (sSharedPrefs) {      if (sp != null) {        //Log.i(TAG, "Updating existing prefs " + name + " " + sp + ": " + map);        sp.replace(map);  //更新資料集合      } else {        sp = sSharedPrefs.get(f);        if (sp == null) {           //建立一個SharedPreferencesImpl對象，並且設定其相關屬性          sp = new SharedPreferencesImpl(f, mode, map);           sSharedPrefs.put(f, sp);        }      }      return sp;    } } 

 
2、 SharedPreferences 不過是個介面，它定義了一些操作xml檔案的方法，其真正實作類別為SharedPreferencesImpl ，該類是ContextIml的內部類，該類如下：

//soga，這種形式我們在分析Context ContextIml時接觸過  //SharedPreferences只是一種介面，其真正實作類別是SharedPreferencesImpl類 private static final class SharedPreferencesImpl implements SharedPreferences{    private Map mMap; //儲存了該檔案序列化結果後的操作， 索引值對形式        //通過key值擷取對應的value值    public String getString(String key, String defValue) {      synchronized (this) {        String v = (String)mMap.get(key);        return v != null ? v : defValue;      }    }    ...    //獲得該SharedPreferencesImpl對象對應的Edito類，對資料進行操作    public final class EditorImpl implements Editor {      private final Map<String, Object> mModified = Maps.newHashMap(); //儲存了對索引值變化的集合    } } 

 
基本上擷取SharedPreferences 對象就是這麼來的。

四、在任意位置擷取應用程式Context
1、在任意位置擷取應用程式Context
Android程式中訪問資源時需要提供Context，一般來說只有在各種component中（Activity, Provider等等)才能方便的使用api來擷取Context;喜歡編程的人都知道，編寫工具類可以有效實現代碼複用，而在Android下某些工具類的編寫很讓人困惑，例如：我們要在工具類中擷取SharedPreferences，那就需要Context的支援。

為瞭解決這寫由Context帶來的麻煩，我們可以自訂一個Application類來實現這種功能。

import android.app.Application;public class ContextUtil extends Application {  private static ContextUtil instance;  public static ContextUtil getInstance() {    return instance;  }  @Override  public void onCreate() {    // TODO Auto-generated method stub    super.onCreate();    instance = this;  }}

然後在manifest中<application>中加入Android：name="mypackage.ContextUtil",這樣我們就可以在任何一個類下面擷取Context，例如：Context c=ContextUtil.getInstance();

2、context注意事項：

在android中context可以作很多操作，但是最主要的功能是載入和訪問資源。在android中有兩種context，一種是 application context，一種是activity context，通常我們在各種類和方法間傳遞的是activity context。
比如一個activity的onCreate：

protected void onCreate(Bundle state) {    super.onCreate(state);    TextView label = new TextView(this); //傳遞context給view control    label.setText("Leaks are bad");    setContentView(label);}

把activity context傳遞給view，意味著view擁有一個指向activity的引用，進而引用activity佔有的資源：view hierachy, resource等。
這樣如果context發生記憶體泄露的話，就會泄露很多記憶體。
這裡泄露的意思是gc沒有辦法回收activity的記憶體。

Leaking an entire activity是很容易的一件事。

當旋轉螢幕的時候，系統會銷毀當前的activity，儲存狀態資訊，再建立一個新的。

比如我們寫了一個應用程式，它需要載入一個很大的圖片，我們不希望每次旋轉屏 幕的時候都銷毀這個圖片，重新載入。實現這個要求的簡單想法就是定義一個靜態Drawable，這樣Activity 類建立銷毀它始終儲存在記憶體中。
實作類別似：

public class myactivity extends Activity {    private static Drawable sBackground;    protected void onCreate(Bundle state) {        super.onCreate(state);        TextView label = new TextView(this);        label.setText("Leaks are bad");        if (sBackground == null) {            sBackground = getDrawable(R.drawable.large_bitmap);        }    label.setBackgroundDrawable(sBackground);//drawable attached to a view    setContentView(label);    }}

這段程式看起來很簡單，但是卻問題很大。當旋轉螢幕的時候會有leak（即gc沒法銷毀activity）。
我們剛才說過，旋轉螢幕的時候系統會銷毀當前的activity。但是當drawable和view關聯後，drawable儲存了view的 reference，即sBackground儲存了label的引用，而label儲存了activity的引用。既然drawable不能銷毀，它所 引用和間接引用的都不能銷毀，這樣系統就沒有辦法銷毀當前的activity，於是造成了記憶體泄露。gc對這種類型的記憶體泄露是無能為力的。

避免這種記憶體泄露的方法是避免activity中的任何對象的生命週期長過activity，避免由於對象對 activity的引用導致activity不能正常被銷毀。我們可以使用application context。application context伴隨application的一生，與activity的生命週期無關。application context可以通過Context.getApplicationContext或者Activity.getApplication方法擷取。

避免context相關的記憶體泄露，記住以下幾點：
（1）不要讓生命週期長的對象引用activity context，即保證引用activity的對象要與activity本身生命週期是一樣的
（2）對於生命週期長的對象，可以使用application context
（3）避免非靜態內部類，盡量使用靜態類，避免生命週期問題，注意內部類對外部對象引用導致的生命週期變化

3、擷取別的包的Context

Android中有Context的概念，想必大家都知道。Context可以做很多事情，開啟activity、發送廣播、開啟本包下檔案夾和資料庫、擷取classLoader、擷取資源等等。如果我們得到了一個包的Context對象，那我們基本上可以做這個包自己能做的大部分事情。
Context有個createPackageContext方法，可以建立另外一個包的上下文，這個執行個體不同於它本身的Context執行個體，但是功能是一樣的。

這個方法有兩個參數：
（1）packageName包名，要得到Context的包名
（2）flags標誌位，有CONTEXT_INCLUDE_CODE和CONTEXT_IGNORE_SECURITY兩個選項。 CONTEXT_INCLUDE_CODE的意思是包括代碼，也就是說可以執行這個包裡面的代碼。CONTEXT_IGNORE_SECURITY的意思是忽略安全警告，如果不加這個標誌的話，有些功能是用不了的，會出現安全警告。

下面給個小例子，執行另外一個包裡面的某個類的方法。另外一個包的包名是chroya.demo,類名Main，方法名print，代碼如下：

package chroya.demo;  import android.app.Activity; import android.os.Bundle; import android.util.Log;  class Main extends Activity {      @Override   public void onCreate(Bundle savedInstanceState) {     super.onCreate(savedInstanceState);   }      public void print(String msg) {     Log.d("Main", "msg:"+ msg);   } } package chroya.demo;  import android.app.Activity; import android.os.Bundle; import android.util.Log;  class Main extends Activity {      @Override   public void onCreate(Bundle savedInstanceState) {     super.onCreate(savedInstanceState);   }      public void print(String msg) {     Log.d("Main", "msg:"+ msg);   } } 

本包的調用Main的print方法的代碼塊如下：

Context c = createPackageContext("chroya.demo", Context.CONTEXT_INCLUDE_CODE | Context.CONTEXT_IGNORE_SECURITY); //載入這個類 Class clazz = c.getClassLoader().loadClass("chroya.demo.Main"); //建立一個執行個體 Object owner = clazz.newInstance(); //擷取print方法，傳入參數並執行 Object obj = clazz.getMethod("print", String.class).invoke(owner,"Hello"); Context c = createPackageContext("chroya.demo", Context.CONTEXT_INCLUDE_CODE | Context.CONTEXT_IGNORE_SECURITY); //載入這個類 Class clazz = c.getClassLoader().loadClass("chroya.demo.Main"); //建立一個執行個體 Object owner = clazz.newInstance(); //擷取print方法，傳入參數並執行 Object obj = clazz.getMethod("print", String.class).invoke(owner, "Hello"); 

ok，這樣，我們就調用了chroya.demo包的Main類的print方法，執行結果，列印出了Hello。