詳解Android中的Context抽象類

關於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。