首先插入AppContext源码
package com.demo.app;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InvalidClassException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.io.Serializable;
import java.util.Hashtable;
import java.util.Properties;
import java.util.UUID;
import android.app.Application;
import android.content.Context;
import android.content.pm.PackageInfo;
import android.content.pm.PackageManager.NameNotFoundException;
import android.media.AudioManager;
import android.net.ConnectivityManager;
import android.net.NetworkInfo;
import android.os.Handler;
import android.os.Message;
import com.demo.app.api.ApiClient;
import com.demo.app.bean.NewsList;
import com.demo.app.common.StringUtils;
import com.demo.app.common.UIHelper;
/**
* 全局应用程序类：用于保存和调用全局应用配置及访问网络数据
*
* @version 1.0
* @created 2012-3-21
*/
public class AppContext extends Application {
public static final int NETTYPE_WIFI = 0x01;
public static final int NETTYPE_CMWAP = 0x02;
public static final int NETTYPE_CMNET = 0x03;
public static final int PAGE_SIZE = 10;// 默认分页大小
private static final int CACHE_TIME = 60 * 60000;// 缓存失效时间
private Hashtable<String, Object> memCacheRegion = new Hashtable<String, Object>();
private Handler unLoginHandler = new Handler() {
public void handleMessage(Message msg) {
if (msg.what == 1) {
UIHelper.ToastMessage(AppContext.this,
getString(R.string.msg_login_error));
}
}
};
@Override
public void onCreate() {
super.onCreate();
// 注册App异常崩溃处理器
Thread.setDefaultUncaughtExceptionHandler(AppException
.getAppExceptionHandler());
}
/**
* 检测当前系统声音是否为正常模式
*
* @return
*/
public boolean isAudioNormal() {
AudioManager mAudioManager = (AudioManager) getSystemService(AUDIO_SERVICE);
return mAudioManager.getRingerMode() == AudioManager.RINGER_MODE_NORMAL;
}
/**
* 应用程序是否发出提示音
*
* @return
*/
public boolean isAppSound() {
return isAudioNormal() && isVoice();
}
/**
* 检测网络是否可用
*
* @return
*/
public boolean isNetworkConnected() {
ConnectivityManager cm = (ConnectivityManager) getSystemService(Context.CONNECTIVITY_SERVICE);
NetworkInfo ni = cm.getActiveNetworkInfo();
return ni != null && ni.isConnectedOrConnecting();
}
/**
* 获取当前网络类型
*
* @return 0：没有网络 1：WIFI网络 2：WAP网络 3：NET网络
*/
public int getNetworkType() {
int netType = 0;
ConnectivityManager connectivityManager = (ConnectivityManager) getSystemService(Context.CONNECTIVITY_SERVICE);
NetworkInfo networkInfo = connectivityManager.getActiveNetworkInfo();
if (networkInfo == null) {
return netType;
}
int nType = networkInfo.getType();
if (nType == ConnectivityManager.TYPE_MOBILE) {
String extraInfo = networkInfo.getExtraInfo();
if (!StringUtils.isEmpty(extraInfo)) {
if (extraInfo.toLowerCase().equals("cmnet")) {
netType = NETTYPE_CMNET;
} else {
netType = NETTYPE_CMWAP;
}
}
} else if (nType == ConnectivityManager.TYPE_WIFI) {
netType = NETTYPE_WIFI;
}
return netType;
}
/**
* 判断当前版本是否兼容目标版本的方法
*
* @param VersionCode
* @return
*/
public static boolean isMethodsCompat(int VersionCode) {
int currentVersion = android.os.Build.VERSION.SDK_INT;
return currentVersion >= VersionCode;
}
/**
* 获取App安装包信息
*
* @return
*/
public PackageInfo getPackageInfo() {
PackageInfo info = null;
try {
info = getPackageManager().getPackageInfo(getPackageName(), 0);
} catch (NameNotFoundException e) {
e.printStackTrace(System.err);
}
if (info == null)
info = new PackageInfo();
return info;
}
/**
* 获取App唯一标识
*
* @return
*/
public String getAppId() {
String uniqueID = getProperty(AppConfig.CONF_APP_UNIQUEID);
if (StringUtils.isEmpty(uniqueID)) {
uniqueID = UUID.randomUUID().toString();
setProperty(AppConfig.CONF_APP_UNIQUEID, uniqueID);
}
return uniqueID;
}
/**
* 是否加载显示文章图片
*
* @return
*/
public boolean isLoadImage() {
String perf_loadimage = getProperty(AppConfig.CONF_LOAD_IMAGE);
// 默认是加载的
if (StringUtils.isEmpty(perf_loadimage))
return true;
else
return StringUtils.toBool(perf_loadimage);
}
/**
* 设置是否加载文章图片
*
* @param b
*/
public void setConfigLoadimage(boolean b) {
setProperty(AppConfig.CONF_LOAD_IMAGE, String.valueOf(b));
}
/**
* 是否发出提示音
*
* @return
*/
public boolean isVoice() {
String perf_voice = getProperty(AppConfig.CONF_VOICE);
// 默认是开启提示声音
if (StringUtils.isEmpty(perf_voice))
return true;
else
return StringUtils.toBool(perf_voice);
}
/**
* 设置是否发出提示音
*
* @param b
*/
public void setConfigVoice(boolean b) {
setProperty(AppConfig.CONF_VOICE, String.valueOf(b));
}
/**
* 是否左右滑动
*
* @return
*/
public boolean isScroll() {
String perf_scroll = getProperty(AppConfig.CONF_SCROLL);
// 默认是关闭左右滑动
if (StringUtils.isEmpty(perf_scroll))
return false;
else
return StringUtils.toBool(perf_scroll);
}
/**
* 设置是否左右滑动
*
* @param b
*/
public void setConfigScroll(boolean b) {
setProperty(AppConfig.CONF_SCROLL, String.valueOf(b));
}
/**
* 是否Https登录
*
* @return
*/
public boolean isHttpsLogin() {
String perf_httpslogin = getProperty(AppConfig.CONF_HTTPS_LOGIN);
// 默认是http
if (StringUtils.isEmpty(perf_httpslogin))
return false;
else
return StringUtils.toBool(perf_httpslogin);
}
/**
* 设置是是否Https登录
*
* @param b
*/
public void setConfigHttpsLogin(boolean b) {
setProperty(AppConfig.CONF_HTTPS_LOGIN, String.valueOf(b));
}
/**
* 清除保存的缓存
*/
public void cleanCookie() {
removeProperty(AppConfig.CONF_COOKIE);
}
/**
* 判断缓存数据是否可读
*
* @param cachefile
* @return
*/
private boolean isReadDataCache(String cachefile) {
return readObject(cachefile) != null;
}
/**
* 判断缓存是否存在
*
* @param cachefile
* @return
*/
private boolean isExistDataCache(String cachefile) {
boolean exist = false;
File data = getFileStreamPath(cachefile);
if (data.exists())
exist = true;
return exist;
}
/**
* 判断缓存是否失效
*
* @param cachefile
* @return
*/
public boolean isCacheDataFailure(String cachefile) {
boolean failure = false;
File data = getFileStreamPath(cachefile);
if (data.exists()
&& (System.currentTimeMillis() - data.lastModified()) > CACHE_TIME)
failure = true;
else if (!data.exists())
failure = true;
return failure;
}
/**
* 清除app缓存
*/
public void clearAppCache() {
// //清除webview缓存
// File file = CacheManager.getCacheFileBaseDir();
// if (file != null && file.exists() && file.isDirectory()) {
// for (File item : file.listFiles()) {
// item.delete();
// }
// file.delete();
// }
// deleteDatabase("webview.db");
// deleteDatabase("webview.db-shm");
// deleteDatabase("webview.db-wal");
// deleteDatabase("webviewCache.db");
// deleteDatabase("webviewCache.db-shm");
// deleteDatabase("webviewCache.db-wal");
// //清除数据缓存
// clearCacheFolder(getFilesDir(),System.currentTimeMillis());
// clearCacheFolder(getCacheDir(),System.currentTimeMillis());
// //2.2版本才有将应用缓存转移到sd卡的功能
// if(isMethodsCompat(android.os.Build.VERSION_CODES.FROYO)){
// clearCacheFolder(MethodsCompat.getExternalCacheDir(this),System.currentTimeMillis());
// }
// //清除编辑器保存的临时内容
// Properties props = getProperties();
// for(Object key : props.keySet()) {
// String _key = key.toString();
// if(_key.startsWith("temp"))
// removeProperty(_key);
// }
}
/**
* 清除缓存目录
*
* @param dir
* 目录
* @param numDays
* 当前系统时间
* @return
*/
private int clearCacheFolder(File dir, long curTime) {
int deletedFiles = 0;
if (dir != null && dir.isDirectory()) {
try {
for (File child : dir.listFiles()) {
if (child.isDirectory()) {
deletedFiles += clearCacheFolder(child, curTime);
}
if (child.lastModified() < curTime) {
if (child.delete()) {
deletedFiles++;
}
}
}
} catch (Exception e) {
e.printStackTrace();
}
}
return deletedFiles;
}
/**
* 将对象保存到内存缓存中
*
* @param key
* @param value
*/
public void setMemCache(String key, Object value) {
memCacheRegion.put(key, value);
}
/**
* 从内存缓存中获取对象
*
* @param key
* @return
*/
public Object getMemCache(String key) {
return memCacheRegion.get(key);
}
/**
* 保存磁盘缓存
*
* @param key
* @param value
* @throws IOException
*/
public void setDiskCache(String key, String value) throws IOException {
FileOutputStream fos = null;
try {
fos = openFileOutput("cache_" + key + ".data", Context.MODE_PRIVATE);
fos.write(value.getBytes());
fos.flush();
} finally {
try {
fos.close();
} catch (Exception e) {
}
}
}
/**
* 获取磁盘缓存数据
*
* @param key
* @return
* @throws IOException
*/
public String getDiskCache(String key) throws IOException {
FileInputStream fis = null;
try {
fis = openFileInput("cache_" + key + ".data");
byte[] datas = new byte[fis.available()];
fis.read(datas);
return new String(datas);
} finally {
try {
fis.close();
} catch (Exception e) {
}
}
}
/**
* 保存对象
*
* @param ser
* @param file
* @throws IOException
*/
public boolean saveObject(Serializable ser, String file) {
FileOutputStream fos = null;
ObjectOutputStream oos = null;
try {
fos = openFileOutput(file, MODE_PRIVATE);
oos = new ObjectOutputStream(fos);
oos.writeObject(ser);
oos.flush();
return true;
} catch (Exception e) {
e.printStackTrace();
return false;
} finally {
try {
oos.close();
} catch (Exception e) {
}
try {
fos.close();
} catch (Exception e) {
}
}
}
/**
* 读取对象
*
* @param file
* @return
* @throws IOException
*/
public Serializable readObject(String file) {
if (!isExistDataCache(file))
return null;
FileInputStream fis = null;
ObjectInputStream ois = null;
try {
fis = openFileInput(file);
ois = new ObjectInputStream(fis);
return (Serializable) ois.readObject();
} catch (FileNotFoundException e) {
} catch (Exception e) {
e.printStackTrace();
// 反序列化失败 - 删除缓存文件
if (e instanceof InvalidClassException) {
File data = getFileStreamPath(file);
data.delete();
}
} finally {
try {
ois.close();
} catch (Exception e) {
}
try {
fis.close();
} catch (Exception e) {
}
}
return null;
}
/**
* 获取新闻数据列表
*
* @return
* @throws AppException
*/
public NewsList getNewsList() throws AppException {
NewsList list = null;
String key = "newslist_";
if (isNetworkConnected() && !isReadDataCache(key)) {
try {
list = ApiClient.getNewsList(this);
} catch (AppException e) {
list = (NewsList) readObject(key);
if (list == null)
throw e;
}
} else {
list = (NewsList) readObject(key);
if (list == null)
list = new NewsList();
}
return list;
}
public boolean containsProperty(String key) {
Properties props = getProperties();
return props.containsKey(key);
}
public void setProperties(Properties ps) {
AppConfig.getAppConfig(this).set(ps);
}
public Properties getProperties() {
return AppConfig.getAppConfig(this).get();
}
public void setProperty(String key, String value) {
AppConfig.getAppConfig(this).set(key, value);
}
public String getProperty(String key) {
return AppConfig.getAppConfig(this).get(key);
}
public void removeProperty(String... key) {
AppConfig.getAppConfig(this).remove(key);
}
}
引用
http://www.pocketcn.com/forum-viewthread-tid-1565-fromuid-1477.html
“接触android已经有一段时间了，一直以为android程序的入口是配置文件中指定的Activity，最近看一个开源项目，发现里面实现了android 的Application类，才知道，android程序的真正入口是Application类的onCreate方法。”
http://www.cnblogs.com/elleniou/archive/2012/05/16/2502661.html
“Application和Activity,Service一样是android框架的一个系统组件，当android程序启动时系统会创建一个 application对象，用来存储系统的一些信息。通常我们是不需要指定一个Application的，这时系统会自动帮我们创建，如果需要创建自己 的Application，也很简单创建一个类继承 Application并在manifest的application标签中进行注册(只需要给Application标签增加个name属性把自己的 Application的名字定入即可)。
android系统会为每个程序运行时创建一个Application类的对象且仅创建一个，所以Application可以说是单例 (singleton)模式的一个类.且application对象的生命周期是整个程序中最长的，它的生命周期就等于这个程序的生命周期。因为它是全局 的单例的，所以在不同的Activity,Service中获得的对象都是同一个对象。所以通过Application来进行一些，数据传递，数据共享 等,数据缓存等操作。”
在这个程序的源码中AppContext就继承了Application类。
时间： 2024-11-08 16:36:50