android的context
来源:互联网 发布:照片扑克牌制作软件 编辑:程序博客网 时间:2024/09/21 09:01
结合了两篇文章
http://blog.csdn.net/aomandeshangxiao/article/details/7008636
android中context及全局变量小析
今天在研究context的时候,对application和activity context有了一定的了解,下面是从网上复制过来的资料,
Application context和Activity context的区别:
这是两种不同的context,也是最常见的两种。第一种中context的生命周期与Application的生命周期相关的,context随着Application的销毁而销毁,伴随application的一生,与activity的生命周期无关。第二种中的context跟Activity的生命周期是相关的,但是对一个Application来说,Activity可以销毁几次,那么属于Activity的context就会销毁多次。至于用哪种context,得看应用场景,个人感觉用Activity的context好一点,不过也有的时候必须使用Application的context。application context可以通过Context.getApplicationContext或者Activity.getApplication方法获取。
还有就是,在使用context的时候,小心内存泄露,防止内存泄露,注意一下几个方面:
1. 不要让生命周期长的对象引用activity context,即保证引用activity的对象要与activity本身生命周期是一样的
2. 对于生命周期长的对象,可以使用application context
3. 避免非静态的内部类,尽量使用静态类,避免生命周期问题,注意内部类对外部对象引用导致的生命周期变化
现在回到正题,说一下android全局变量,在平时的开发过程中,有时候可能会需要一些全局数据,来让应用中的所有Activity和View都能访问到,大家在遇到这种情况时,可能首先会想到自己定义一个类,然后创建很多静态成员,android已经为我们提供了这种情况的解决方案:
在Android中,有一个Application类,在Activity中可以使用getApplication()方法获得实例,使用它就可以获得当前应用的主题、资源文件中的内容等,这个类更灵活的一个特性就是可以被继承,来添加自己的全局属性。例如开发一个游戏,需要保存分数,那么我们就可以继承Application,下面是个demo,用的是http://www.eoeandroid.com/thread-30257-1-1.html上面的代码,其实上面那段话也是对它的修改。
首先,先写个Application的子类:
- import android.app.Application;
- public class GameApplication extends Application {
- private int score;
- public int getScore() {
- return score;
- }
- public void setScore(int score) {
- this.score = score;
- }
- }
然后在manifest.xml文件里面修改:
- <application android:name=".GameApplication" android:icon="@drawable/icon" android:label="@string/app_name">
- <activity android:name=".DemoActivity"
- android:label="@string/app_name">
- <intent-filter>
- <action android:name="android.intent.action.MAIN" />
- <category android:name="android.intent.category.LAUNCHER" />
- </intent-filter>
- </activity>
- <activity android:name="ResultActivity"></activity>
- </application>
注意到添加了android:name=".GameApplication" 。
修改完了以后,再往下看:
- public class DemoActivity extends Activity {
- public Button button;
- @Override
- public void onCreate(Bundle savedInstanceState) {
- super.onCreate(savedInstanceState);
- setContentView(R.layout.main);
- button=(Button)findViewById(R.id.button);
- ((GameApplication)getApplication()).setScore(100);
- button.setOnClickListener(new View.OnClickListener() {
- public void onClick(View v) {
- Intent intent=new Intent();
- intent.setClass(DemoActivity.this, ResultActivity.class);
- startActivity(intent);
- }
- });
- }
- }
- public class ResultActivity extends Activity {
- @Override
- protected void onCreate(Bundle savedInstanceState) {
- // TODO Auto-generated method stub
- super.onCreate(savedInstanceState);
- setContentView(R.layout.other);
- TextView tv=(TextView)findViewById(R.id.tv);
- int score=((GameApplication)getApplicationContext()).getScore();
- tv.setText("你的成绩是:"+score);
- }
- }
这只是个简单的例子,当然,想要完成以上功能,使用intent传值就可以了,这样还显得麻烦,但是,如果有很多activity,使用这种方法就会发现很有用,是不是使用sharepreference也可以完成类似功能呢,可以,但是,效率方面就要比这个差很多了,sharepreference主要是用来存储数据,你可以退出程序时把所需要保存的简单数据保存到sharepreference里面,当然复杂的数据,还得使用sqllite。
http://blog.csdn.net/hyx1990/article/details/7584789
Android:在任意位置获取应用程序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。
http://blog.csdn.net/qinjuning/article/details/7310620
Android中Context详解 ---- 你所不知道的Context
大家好, 今天给大家介绍下我们在应用开发中最熟悉而陌生的朋友-----Context类 ,说它熟悉,是应为我们在开发中
时刻的在与它打交道,例如:Service、BroadcastReceiver、Activity等都会利用到Context的相关方法 ; 说它陌生,完全是
因为我们真正的不懂Context的原理、类结构关系。一个简单的问题是,一个应用程序App中存在多少个Context实例对象呢?
一个、两个? 在此先卖个关子吧。读了本文,相信您会豁然开朗的 。
Context,中文直译为“上下文”,SDK中对其说明如下:
Interface to global information about an application environment. This is an abstract class whose implementation
is provided by the Android system. It allows access to application-specific resources and classes, as well as up-calls
for application-level operations such as launching activities, broadcasting and receiving intents, etc
从上可知一下三点,即:
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类的使用方法,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里的更多方法请大家参照源代码认真学习吧。
- 关于android的 context
- Android的Context简介
- android context的别
- Android Context的意义
- android context的作用
- android的context
- android的context
- Android的context浅析
- Android的context
- android的context
- android的Context理解
- android 里面的Context
- Android里的Context
- android的Context
- Android Context 的理解
- Android的Context
- android Context的使用
- Android Context的区别
- Android中Bitmap,byte[],Drawable相互转化
- 多线程概念
- uva-442 Matrix Chain Multiplication
- 织梦仿站第十二课:网站搜索页 的仿制
- linux内核设计与实现(第六章)----内核数据结构
- android的context
- hive中的Order By
- POJ 2002
- Qt中QTableWidget用法总结
- 静态变量(类变量),实例变量,常量;静态方法(类方法),实例方法
- 在 x86 上面交叉编译 gstreamer for ARM/MIPS
- Python正则-多行匹配
- 三种水桶,等分为两半问题
- ZOJ 3499 Median