解决完全退出Activity 实现实例(兼容1.6；2.1；2.2；2.3 ; 4.0 )

Intent startMain = new Intent(mContext,tabView.class);//这里根据自己需要填写自己的class

                startMain.addCategory(Intent.CATEGORY_HOME);

                startMain.setFlags(Intent.FLAG_ACTIVITY_NEW_TASK);

                mContext.startActivity(startMain);

                try {//原因目前不明，但不加的话就会关闭不了系统 

                    Thread.sleep(1000); 

                } catch (InterruptedException e) { 

                    Log.e(TAG, "Error : ", e); 

                } 

                android.os.Process.killProcess(android.os.Process.myPid());

package org.wp.activity;

import java.io.File;
import java.io.FileOutputStream;
import java.io.FilenameFilter;
import java.io.PrintWriter;
import java.io.StringWriter;
import java.io.Writer;
import java.lang.Thread.UncaughtExceptionHandler;
import java.lang.reflect.Field;
import java.util.Arrays;
import java.util.Properties;
import java.util.TreeSet;

import android.content.Context;
import android.content.pm.PackageInfo;
import android.content.pm.PackageManager;
import android.content.pm.PackageManager.NameNotFoundException;
import android.os.Build;
import android.os.Looper;
import android.util.Log;
import android.widget.Toast;

/**
 *
 *
 * UncaughtExceptionHandler：线程未捕获异常控制器是用来处理未捕获异常的。
 *                           如果程序出现了未捕获异常默认情况下则会出现强行关闭对话框
 *                           实现该接口并注册为程序中的默认未捕获异常处理
 *                           这样当未捕获异常发生时，就可以做些异常处理操作
 *                           例如：收集异常信息，发送错误报告 等。
 *
 * UncaughtException处理类,当程序发生Uncaught异常的时候,由该类来接管程序,并记录发送错误报告.
 */
public class CrashHandler implements UncaughtExceptionHandler {
 /** Debug Log Tag */
 public static final String TAG = "CrashHandler";
 /** 是否开启日志输出, 在Debug状态下开启, 在Release状态下关闭以提升程序性能 */
 public static final boolean DEBUG = true;
 /** CrashHandler实例 */
 private static CrashHandler INSTANCE;
 /** 程序的Context对象 */
 private Context mContext;
 /** 系统默认的UncaughtException处理类 */
 private Thread.UncaughtExceptionHandler mDefaultHandler;
 
 /** 使用Properties来保存设备的信息和错误堆栈信息 */
 private Properties mDeviceCrashInfo = new Properties();
 private static final String VERSION_NAME = "versionName";
 private static final String VERSION_CODE = "versionCode";
 private static final String STACK_TRACE = "STACK_TRACE";
 /** 错误报告文件的扩展名 */
 private static final String CRASH_REPORTER_EXTENSION = ".cr";
 
 /** 保证只有一个CrashHandler实例 */
 private CrashHandler() {
 }

 /** 获取CrashHandler实例 ,单例模式 */
 public static CrashHandler getInstance() {
  if (INSTANCE == null)
   INSTANCE = new CrashHandler();
  return INSTANCE;
 }
 
 /**
  * 初始化,注册Context对象, 获取系统默认的UncaughtException处理器, 设置该CrashHandler为程序的默认处理器
  *
  * @param ctx
  */
 public void init(Context ctx) {
  mContext = ctx;
  mDefaultHandler = Thread.getDefaultUncaughtExceptionHandler();
  Thread.setDefaultUncaughtExceptionHandler(this);
 }
 
 /**
  * 当UncaughtException发生时会转入该函数来处理
  */
 @Override
 public void uncaughtException(Thread thread, Throwable ex) {
  if (!handleException(ex) && mDefaultHandler != null) {
   // 如果用户没有处理则让系统默认的异常处理器来处理
   mDefaultHandler.uncaughtException(thread, ex);
  } else {
   // Sleep一会后结束程序
   // 来让线程停止一会是为了显示Toast信息给用户，然后Kill程序
   try {
    Thread.sleep(3000);
   } catch (InterruptedException e) {
    Log.e(TAG, "Error : ", e);
   }
   android.os.Process.killProcess(android.os.Process.myPid());
   System.exit(10);
  }
 }

 /**
  * 自定义错误处理,收集错误信息 发送错误报告等操作均在此完成. 开发者可以根据自己的情况来自定义异常处理逻辑
  *
  * @param ex
  * @return true:如果处理了该异常信息;否则返回false
  */
 private boolean handleException(Throwable ex) {
  if (ex == null) {
   return true;
  }
  final String msg = ex.getLocalizedMessage();
  // 使用Toast来显示异常信息
  new Thread() {
   @Override
   public void run() {
    // Toast 显示需要出现在一个线程的消息队列中
    Looper.prepare();
    Toast.makeText(mContext, "程序出错啦:" + msg, Toast.LENGTH_LONG).show();
    Looper.loop();
   }
  }.start();
  // 收集设备信息
  collectCrashDeviceInfo(mContext);
  // 保存错误报告文件
  String crashFileName = saveCrashInfoToFile(ex);
  // 发送错误报告到服务器
  sendCrashReportsToServer(mContext);
  return true;
 }

 /**
  * 收集程序崩溃的设备信息
  *
  * @param ctx
  */
 public void collectCrashDeviceInfo(Context ctx) {
  try {
   // Class for retrieving various kinds of information related to the
   // application packages that are currently installed on the device.
   // You can find this class through getPackageManager().
   PackageManager pm = ctx.getPackageManager();
   // getPackageInfo(String packageName, int flags)
   // Retrieve overall information about an application package that is installed on the system.
   // public static final int GET_ACTIVITIES
   // Since: API Level 1 PackageInfo flag: return information about activities in the package in activities.
   PackageInfo pi = pm.getPackageInfo(ctx.getPackageName(), PackageManager.GET_ACTIVITIES);
   if (pi != null) {
    // public String versionName The version name of this package,
    // as specified by the <manifest> tag's versionName attribute.
    mDeviceCrashInfo.put(VERSION_NAME, pi.versionName == null ? "not set" : pi.versionName);
    // public int versionCode The version number of this package,
    // as specified by the <manifest> tag's versionCode attribute.
    mDeviceCrashInfo.put(VERSION_CODE, pi.versionCode);
   }
  } catch (NameNotFoundException e) {
   Log.e(TAG, "Error while collect package info", e);
  }
  // 使用反射来收集设备信息.在Build类中包含各种设备信息,
  // 例如: 系统版本号,设备生产商 等帮助调试程序的有用信息
  // 返回 Field 对象的一个数组，这些对象反映此 Class 对象所表示的类或接口所声明的所有字段
  Field[] fields = Build.class.getDeclaredFields();
  for (Field field : fields) {
   try {
    // setAccessible(boolean flag)
    // 将此对象的 accessible 标志设置为指示的布尔值。
    // 通过设置Accessible属性为true,才能对私有变量进行访问，不然会得到一个IllegalAccessException的异常
    field.setAccessible(true);
    mDeviceCrashInfo.put(field.getName(), field.get(null));
    if (DEBUG) {
     Log.d(TAG, field.getName() + " : " + field.get(null));
    }
   } catch (Exception e) {
    Log.e(TAG, "Error while collect crash info", e);
   }
  }
 }
 
 /**
  * 保存错误信息到文件中
  *
  * @param ex
  * @return
  */
 private String saveCrashInfoToFile(Throwable ex) {
  Writer info = new StringWriter();
  PrintWriter printWriter = new PrintWriter(info);
  // printStackTrace(PrintWriter s)
  // 将此 throwable 及其追踪输出到指定的 PrintWriter
  ex.printStackTrace(printWriter);

  // getCause() 返回此 throwable 的 cause；如果 cause 不存在或未知，则返回 null。
  Throwable cause = ex.getCause();
  while (cause != null) {
   cause.printStackTrace(printWriter);
   cause = cause.getCause();
  }

  // toString() 以字符串的形式返回该缓冲区的当前值。
  String result = info.toString();
  printWriter.close();
  mDeviceCrashInfo.put(STACK_TRACE, result);

  try {
   long timestamp = System.currentTimeMillis();
   String fileName = "crash-" + timestamp + CRASH_REPORTER_EXTENSION;
   // 保存文件
   FileOutputStream trace = mContext.openFileOutput(fileName, Context.MODE_PRIVATE);
   mDeviceCrashInfo.store(trace, "");
   trace.flush();
   trace.close();
   return fileName;
  } catch (Exception e) {
   Log.e(TAG, "an error occured while writing report file...", e);
  }
  return null;
 }
 
 /**
  * 把错误报告发送给服务器,包含新产生的和以前没发送的.
  *
  * @param ctx
  */
 private void sendCrashReportsToServer(Context ctx) {
  String[] crFiles = getCrashReportFiles(ctx);
  if (crFiles != null && crFiles.length > 0) {
   TreeSet<String> sortedFiles = new TreeSet<String>();
   sortedFiles.addAll(Arrays.asList(crFiles));

   for (String fileName : sortedFiles) {
    File cr = new File(ctx.getFilesDir(), fileName);
    postReport(cr);
    cr.delete();// 删除已发送的报告
   }
  }
 }

 /**
  * 获取错误报告文件名
  *
  * @param ctx
  * @return
  */
 private String[] getCrashReportFiles(Context ctx) {
  File filesDir = ctx.getFilesDir();
  // 实现FilenameFilter接口的类实例可用于过滤器文件名
  FilenameFilter filter = new FilenameFilter() {
   // accept(File dir, String name)
   // 测试指定文件是否应该包含在某一文件列表中。
   public boolean accept(File dir, String name) {
    return name.endsWith(CRASH_REPORTER_EXTENSION);
   }
  };
  // list(FilenameFilter filter)
  // 返回一个字符串数组，这些字符串指定此抽象路径名表示的目录中满足指定过滤器的文件和目录
  return filesDir.list(filter);
 }

 private void postReport(File file) {
  // TODO 使用HTTP Post 发送错误报告到服务器
  // 这里不再详述,开发者可以根据OPhoneSDN上的其他网络操作
  // 教程来提交错误报告
 }

 /**
  * 在程序启动时候, 可以调用该函数来发送以前没有发送的报告
  */
 public void sendPreviousReportsToServer() {
  sendCrashReportsToServer(mContext);
 }
}

public class ImagecachetacticsdemoActivity extends Activity {
public void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.item);

/*FMU*/
imageCacheManager = ImageCacheManager.getImageCacheService(this,
ImageCacheManager.MODE_FIXED_MEMORY_USED, "memory");
imageCacheManager.setMax_Memory(1024 * 1024);

/*FTU*/
// imageCacheManager = ImageCacheManager.getImageCacheService(this,
// ImageCacheManager.MODE_FIXED_TIMED_USED, "time");
// imageCacheManager.setDelay_millisecond(3 * 60 * 1000);

/*LRU*/
// imageCacheManager = ImageCacheManager.getImageCacheService(this,
// ImageCacheManager.MODE_LEAST_RECENTLY_USED, "num");
// imageCacheManager.setMax_num(5);

// imageCacheManager = ImageCacheManager.getImageCacheService(this,
// ImageCacheManager.MODE_NO_CACHE_USED, "nocache");

mImageView = (ImageView) findViewById(R.id.imageView);
new DownloadTask()
.execute("http://www.touxiang99.com/uploads/allimg/110417/1_110417112640_2.jpg");
}

private class DownloadTask extends AsyncTask<String, Void, Bitmap> {

@Override
protected Bitmap doInBackground(String... params) {
try {
return imageCacheManager.downlaodImage(new URL(params[0]));
} catch (IOException e) {
e.printStackTrace();
}
return null;
}

@Override
protected void onPostExecute(Bitmap result) {

mImageView.setImageBitmap(result);
super.onPostExecute(result);
}

@Override
protected void onPreExecute() {
mImageView.setImageResource(R.drawable.ic_launcher);
super.onPreExecute();
}

}

private ImageView mImageView;
private ImageCacheManager imageCacheManager;

} 

{"userbean":{"Uid":"100196","Showname":"u75afu72c2u7684u7334u5b50","Avtar":null,"State":1}}

// TODO 状态处理 500 200
                int res = 0;
                res = httpClient.execute(httpPost).getStatusLine().getStatusCode();
                if (res == 200) {
                    /*
                     * 当返回码为200时，做处理
                     * 得到服务器端返回json数据，并做处理
                     * */
                    HttpResponse httpResponse = httpClient.execute(httpPost);
                    StringBuilder builder = new StringBuilder();
                    BufferedReader bufferedReader2 = new BufferedReader(
                            new InputStreamReader(httpResponse.getEntity().getContent()));
                    String str2 = "";
                    for (String s = bufferedReader2.readLine(); s != null; s = bufferedReader2
                            .readLine()) {
                        builder.append(s);
                    }
                    Log.i("cat", ">>>>>>" + builder.toString());

JSONObject jsonObject = new JSONObject(builder.toString())
                        .getJSONObject("userbean");

                String Uid;
                String Showname;
                String Avtar;
                String State;

                Uid = jsonObject.getString("Uid");
                Showname = jsonObject.getString("Showname");
                Avtar = jsonObject.getString("Avtar");
                State = jsonObject.getString("State");

            jaddrobj = GetJsonAddr(String.valueOf(dLat),

String.valueOf(dLong));

if (jaddrobj==null) {

jaddrobj = SysUtil.GetJsonAddr(String.valueOf(dLat),

String.valueOf(dLong));

}

if (jaddrobj!=null) {

jsobj = jaddrobj.getJSONObject("Status");

if(jsobj.getString("code").equals("200")){

jplacearr = jaddrobj.getJSONArray("Placemark");

jplaceobj = jplacearr.getJSONObject(0);

address = jplaceobj.getString("address");

grobaldata.myAddress = address;// 当前地址放到全局变量里

   grobaldata.curAddress = address;// 当前地址放到全局变量里

   city = jplaceobj.getJSONObject("AddressDetails").getJSONObject("Country")

    .getJSONObject("AdministrativeArea").getJSONObject("Locality")

    .getString("LocalityName");

}

else {

rtValue = "error";

}

}

* IP 地址对 Google 地图 API 地址解析器的访问可能被永久阻止。

*

* @param latitude

*            纬度

* @param longitude

*            经度

* @return JSONObject

*

* @author lvqiyong

*/

/*例子如下:

* {

 "name": "29.871398,121.5817",

 "Status": {

   "code": 200,

   "request": "geocode"

 },

 "Placemark": [ {

   "id": "p1",

   "address": "中国浙江省宁波市江东区中兴路360号 邮政编码: 315040",

   "AddressDetails": {

  "Accuracy" : 8,

  "Country" : {

     "AdministrativeArea" : {

        "AdministrativeAreaName" : "浙江省",

        "Locality" : {

           "DependentLocality" : {

              "DependentLocalityName" : "江东区",

              "Thoroughfare" : {

                 "ThoroughfareName" : "中兴路360号"

              }

           },

           "LocalityName" : "宁波市"

        }

     },

     "CountryName" : "中国",

     "CountryNameCode" : "CN"

  }

},

   "ExtendedData": {

     "LatLonBox": {

       "north": 29.8737610,

       "south": 29.8710630,

       "east": 121.5832290,

       "west": 121.5805310

     }

   },

   "Point": {

     "coordinates": [ 121.5818800, 29.8724120, 0 ]

   }

 } ]

}*/

public static JSONObject GetJsonAddr(String latitude, String longitude) {

// 也可以是http://maps.google.cn/maps/geo?output=csv&key=abcdef&q=%s,%s，不过解析出来的是英文地址

// 密钥可以随便写一个key=abc

// output=csv,也可以是xml或json，采用默认的方式是output=json

String url = String

.format(

"http://ditu.google.cn/maps/geo?key=abcdef&q=%s,%s",

latitude, longitude);

HttpGet httpGet = new HttpGet(url);

        HttpClient client = new DefaultHttpClient(); 

        HttpResponse response; 

        StringBuilder stringBuilder = new StringBuilder(); 

        try { 

            response = client.execute(httpGet); 

           /* HttpEntity entity = response.getEntity(); 

            InputStream stream = entity.getContent(); 

            int b; 

            while ((b = stream.read()) != -1) { 

                stringBuilder.append((char) b); 

            }*/

            HttpEntity entity = response.getEntity();

BufferedReader br = new BufferedReader(new InputStreamReader(entity

.getContent()));

String result = br.readLine();

while (result != null) {

stringBuilder.append(result);

result = br.readLine();

}

        } catch (ClientProtocolException e) { 

        } catch (IOException e) { 

        } 

        JSONObject jsonObject = new JSONObject(); 

        try { 

            jsonObject = new JSONObject(stringBuilder.toString()); 

        } catch (JSONException e) { 

            e.printStackTrace(); 

        } 

        return jsonObject; 

}