android监听应用卸载
㈠ android程序如何监听到自己被卸载这个事件。
手段略曲折
首先给你的程序注册读取log权限，
<uses-permissionandroid:name="android.permission.READ_LOGS"/>
然后在你的程序里开一个后台线程，不停的读取log，当你的应用（包括其他任何应用）被卸载时，系统的ActivityManager会打印出一行log，大概是removing:你的包名。这个时机是在卸载界面点击确定后的一瞬间触发的，如下图
但是不能保证用户就会点确定真把你的卸载了。。所以自己权衡吧。
这是我在网上找到的唯一方法
代码如下：
privatevoidListenLog(){
Threadt=newThread(newRunnable(){
publicvoidrun(){
//TODOAuto-generatedmethodstub
Log.v("Fuck","Startlisteninglog");
String[]cmds={"logcat","-c"};
StringshellCmd="logcat";
Processprocess=null;
InputStreamis=null;
DataInputStreamdis=null;
Stringline="";
Runtimeruntime=Runtime.getRuntime();
try{
intwaitValue;
waitValue=runtime.exec(cmds).waitFor();
process=runtime.exec(shellCmd);
is=process.getInputStream();
dis=newDataInputStream(is);
while((line=dis.readLine())!=null&&mKeepListenFlag){
if(!line.contains("Fuck")){
Log.v("Fuck",line);
//这里只是把每个log都打印了一遍，可以再此判断line里是否有removing字样，然后做些处理
}
}
Log.v("Fuck","finishedlisten");
}catch(InterruptedExceptione){
e.printStackTrace();
}catch(IOExceptionie){
ie.printStackTrace();
}finally{
try{
if(dis!=null){
dis.close();
}
if(is!=null){
is.close();
}
if(process!=null){
process.destroy();
}
}catch(Exceptione){
e.printStackTrace();
}
}
}
});
//mKeepListenFlag是个成员变量，是为了让程序结束时终止线程的，否则可能产生程序多次启动，然后这个线程就启动了多个。Android线程可不会因为Activity的退出而终止。
mKeepListenFlag=true;
t.start();
}
㈡ Android：adb卸载系统应用软技能
首先，通过adb卸载应用，需要Android系统允许adb调试，正常的手机通过多次点击版本号，都可以进入开发者模式，在开发者模式允许adb调试。在某些Android机顶盒系统，系统是禁用adb调试的。
在Windows或者Mac系统下，打开命令行终端（命令提示符）。
这里以Android机顶盒和Windows系统为例，电脑和机顶盒连接在同个局域网，并知道机顶盒的IP地址。
注意: Android系统原生并不支持 adb root 。以及一些手机Android系统定制厂商并没有提供支持，如果需要root，可能需要向手机厂商申请，例如某米手机。如果是自己公司定制，可以将root文件加到系统中，提供定制，方便应用层的伙伴调试。
上面的2、3、4步骤也可以换成下面步骤，原理是一致。
没有root权限下，卸载系统应用APK,需要获取应用包名。
由于现在手机厂商和机顶盒定制较高，底层adb支持的力度都不一样。上面的方式可能会失效。但值得一试。
觉得本文章对你有用就点个赞吧，铁子
㈢ 如何完全手动地卸载掉Android的某app
清楚应用数据和卸载应用，直接执行命令：
* String cmd = "pm clear " + packageName; 或者 * String cmd = "pm clear " + packageName + " HERE";
* String cmd = "pm uninstall " + packageName; 或者 * String cmd = "pm uninstall " + packageName + " HERE";
* String cmd = "pm install " + apk_path; 或者 * String cmd = "pm uninstall " + apk_path+ " HERE";
且在清楚数据之后应用本身的Service和Alarm定时会自动取消掉，进程也随之结束， 以此类推adb所有命令都可以这样执行。
package com.app.exit.demo;
import java.io.IOException;
import android.util.Log;
/**
* 运行命令管理器
* 等同于在PC端adb shell之后执行命令，pm clear packageName
* 但是只能回自己操作，不能清除其他应用的数据；
* 卸载其他应用(限root设备或者厂商提供接口)
* @author hulk
*
*/
public class RuntimeCmdManager {
private static final String TAG = "RuntimeCmdManager";
/**
* 清除应用缓存的用户数据，同时停止所有服务和Alarm定时task
* String cmd = "pm clear " + packageName;
* String cmd = "pm clear " + packageName + " HERE";
* Runtime.getRuntime().exec(cmd)
* @param packageName
* @return
*/
public static Process clearAppUserData(String packageName) {
Process p = execRuntimeProcess("pm clear " + packageName);
if (p == null) {
LogTag.log("Clear app data packageName:" + packageName
+ ", FAILED !");
} else {
LogTag.log("Clear app data packageName:" + packageName
+ ", SUCCESS !");
}
return p;
}
/**
* 卸载应用，只能对root设备有效
* String cmd = "pm uninstall " + packageName;
* Runtime.getRuntime().exec("pm uninstall " + packageName)
* @param packageName
* @return
*/
public static Process uninstallApp(String packageName) {
Process p = execRuntimeProcess("pm uninstall " + packageName);
if (p == null) {
LogTag.log("Uninstall app packageName:" + packageName + ", FAILED !");
} else {
LogTag.log("Uninstall app packageName:" + packageName + ", SUCCESS !");
}
return p;
}
public static Process execRuntimeProcess(String commond) {
Process p = null;
try {
p = Runtime.getRuntime().exec(commond);
} catch (IOException e) {
LogTag.log("exec Runtime commond:" + commond + ", IOException" + e);
e.printStackTrace();
}
LogTag.log("exec Runtime commond:" + commond + ", Process:" + p);
return p;
}
}
彻底退出应用，不清除数据的方法：
停止应用中所有Service。调用ActivityManager.killBackgroundProcesses(packageName);
示例：
package com.app.exit.demo;
import java.util.List;
import android.support.v7.app.ActionBarActivity;
import android.app.ActivityManager;
import android.app.AlarmManager;
import android.app.PendingIntent;
import android.app.ActivityManager.RunningServiceInfo;
import android.content.Context;
import android.content.Intent;
import android.content.pm.PackageInfo;
import android.content.pm.PackageManager;
import android.content.pm.ServiceInfo;
import android.os.Bundle;
import android.util.Log;
import android.view.Menu;
import android.view.MenuItem;
import android.view.View;
import android.view.View.OnClickListener;
import android.widget.Button;
import android.widget.TextView;
public class MainActivity extends ActionBarActivity {
private static final String TAG = "MainActivity";
public static final int ALARM_INTERVAL_MILLIS = 10 * 1000;
TextView mMsgTv;
Button exitAppBtn;
List runningServices;
ActivityManager mActivityManager;
List packageInfos;
ServiceInfo[] serviceInfos;
AlarmManager mAlarmManager;
private PendingIntent operation;
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
mMsgTv = (TextView) findViewById(R.id.msg_tv);
exitAppBtn = (Button) findViewById(R.id.btn_exit_app);
exitAppBtn.setOnClickListener(new OnClickListener() {
@Override
public void onClick(View v) {
finish();
}
});
LogTag.i("" + this);
mAlarmManager = (AlarmManager) getSystemService(Context.ALARM_SERVICE);
mActivityManager = (ActivityManager) getSystemService(ACTIVITY_SERVICE);
startServices();
runningServices = mActivityManager.getRunningServices(10000);
// proccessRunningServices(false);
packageInfos = getPackageManager().getInstalledPackages(
PackageManager.GET_SERVICES);
processPackageInfos(false);
setRepeating();
}
/**
* 定时启动SecondActivity，清除自身数据或者卸载
*/
private void setRepeating() {
if (operation == null) {
operation = getSecondPendingIntent();
}
long startTime = System.currentTimeMillis() + ALARM_INTERVAL_MILLIS;
mAlarmManager.setRepeating(AlarmManager.RTC_WAKEUP, startTime,
ALARM_INTERVAL_MILLIS, operation);
}
private PendingIntent getSecondPendingIntent() {
Intent intent = new Intent(getApplicationContext(),
SecondActivity.class);
PendingIntent operation = PendingIntent.getActivity(
getApplicationContext(), 0, intent, 0);
return operation;
}
private void startServices() {
startService(new Intent(this, MyService1.class));
startService(new Intent(this, MyService2.class));
}
private void processPackageInfos(boolean isStop) {
for (PackageInfo pinfo : packageInfos) {
if (getPackageName().equals(pinfo.packageName)) {
serviceInfos = pinfo.services;
for (ServiceInfo sinfo : serviceInfos) {
if (isStop) {
boolean result = stopPackageService(this,
getPackageName(), sinfo.name);
Log.w(TAG, "Stop sinfo.name: " + sinfo.name
+ ", result=" + result);
} else {
Log.d(TAG, "sinfo.name: " + sinfo.name);
}
}
}
}
}
private void proccessRunningServices(boolean isStop) {
if (runningServices == null) {
Log.w(TAG, "runningServices is null !! ");
return;
}
for (RunningServiceInfo runningServiceInfo : runningServices) {
String serviceName = runningServiceInfo.service.getClassName();
String process = runningServiceInfo.process;
if ("com.app.exit.demo".equals(process)) {
if (isStop) {
boolean result = stopPackageService(getApplication(),
getPackageName(), serviceName);
Log.w(TAG, "stopService " + serviceName + ", result= "
+ result);
} else {
Log.i(TAG, "runningServiceInfo.process=" + process
+ ",runningServiceInfo.pid="
+ runningServiceInfo.pid
+ ", runningServiceInfo.getClass=" + serviceName);
}
}
}
}
private boolean stopPackageService(Context context, String packageName,
String serviceName) {
Intent service = new Intent();
service.setClassName(packageName, serviceName);
return context.stopService(service);
}
@Override
protected void onDestroy() {
super.onDestroy();
killProcess();
LogTag.i("onDestroy: " + this);
}
private void killProcess() {
// proccessRunningServices(true);
processPackageInfos(true);
String packageName = getPackageName();
mActivityManager.killBackgroundProcesses(packageName);
}
@Override
public boolean onCreateOptionsMenu(Menu menu) {
// Inflate the menu; this adds items to the action bar if it is present.
getMenuInflater().inflate(R.menu.main, menu);
return true;
}
@Override
public boolean onOptionsItemSelected(MenuItem item) {
// Handle action bar item clicks here. The action bar will
// automatically handle clicks on the Home/Up button, so long
// as you specify a parent activity in AndroidManifest.xml.
int id = item.getItemId();
if (id == R.id.action_settings) {
return true;
}
return super.onOptionsItemSelected(item);
}
}
注意Manifest配置：
<manifest xmlns:android="http://schemas.android.com/apk/res/android" package="com.app.exit.demo"
android:versionCode="1"
android:versionName="1.0" >
android:minSdkVersion="8"
android:targetSdkVersion="21" />
android:allowBackup="true"
android:icon="@drawable/ic_launcher"
android:label="@string/app_name"
android:theme="@style/AppTheme" >
android:name=".MainActivity"
android:label="@string/app_name" >
android:name=".SecondActivity"
android:label="SecondActivity"
android:launchMode="singleTask" >
㈣ android程序怎样监听自身程序被安装和卸载
这个我想到的就一种方法,读取Log信息,然后判断是否被安装,其实系统安装成功之后,会发广播的,很详细,但是这种广播最好是第三方软件坚定为好,自己就没法监听,我前一阵子做升级,就像用这个,但是没用成,最后只是下载apk成功之后,发送给服务器日志信息,感觉自己监听自己,功能实现上好像有些矛盾,个人意见..
㈤ android应用是如何监听自己是否被卸载的呢
Activity启动时fork出C端进程轮询目录：
1 package main.activity;
2
3 import pym.test.uninstalledmoniter.R;
4 import android.app.Activity;
5 import android.os.Bundle;
6 import android.util.Log;
7
8 /**
9 * @author pengyiming
10 * @note 监听此应用是否被卸载，若被卸载则弹出卸载反馈
11 *
12 */
13
14 public class UninstalledMoniterActivity extends Activity
15 {
16 /* 数据段begin */
17 private static final String TAG = "UninstalledMoniterActivity";
18 /* 数据段end */
19
20 /* 函数段begin */
21 private native void init();
22 static
23 {
24 Log.d(TAG, "load libuninstalled_moniter");
25 System.loadLibrary("uninstalled_moniter");
26 }
27
28 @Override
29 public void onCreate(Bundle savedInstanceState)
30 {
31 super.onCreate(savedInstanceState);
32 Log.d(TAG, "onCreate");
33
34 setContentView(R.layout.uninstalled_moniter_layout);
35
36 init();
37 }
38 /* 函数段end */
39 }
核心——native方法头文件：
1 /* 头文件begin */
2 #include <jni.h>
3 #include <stdio.h>
4 #include <string.h>
5 #include <android/log.h>
6 #include <unistd.h>
7 /* 头文件end */
8
9 /* 宏定义begin */
10 //清0宏
11 #define MEM_ZERO(pDest, destSize) memset(pDest, 0, destSize)
12
13 //LOG宏定义
14 #define LOG_INFO(tag, msg) __android_log_write(ANDROID_LOG_INFO, tag, msg)
15 #define LOG_DEBUG(tag, msg) __android_log_write(ANDROID_LOG_DEBUG, tag, msg)
16 #define LOG_WARN(tag, msg) __android_log_write(ANDROID_LOG_WARN, tag, msg)
17 #define LOG_ERROR(tag, msg) __android_log_write(ANDROID_LOG_ERROR, tag, msg)
18 /* 宏定义end */
19
20 #ifndef _Included_main_activity_UninstalledMoniterActivity
21 #define _Included_main_activity_UninstalledMoniterActivity
22 #ifdef __cplusplus
23 extern "C" {
24 #endif
25
26 #undef main_activity_UninstalledMoniterActivity_MODE_PRIVATE
27 #define main_activity_UninstalledMoniterActivity_MODE_PRIVATE 0L
28 #undef main_activity_UninstalledMoniterActivity_MODE_WORLD_READABLE
29 #define main_activity_UninstalledMoniterActivity_MODE_WORLD_READABLE 1L
30 #undef main_activity_UninstalledMoniterActivity_MODE_WORLD_WRITEABLE
31 #define main_activity_UninstalledMoniterActivity_MODE_WORLD_WRITEABLE 2L
32 #undef main_activity_UninstalledMoniterActivity_MODE_APPEND
33 #define main_activity_UninstalledMoniterActivity_MODE_APPEND 32768L
34 #undef main_activity_UninstalledMoniterActivity_MODE_MULTI_PROCESS
35 #define main_activity_UninstalledMoniterActivity_MODE_MULTI_PROCESS 4L
36 #undef main_activity_UninstalledMoniterActivity_BIND_AUTO_CREATE
37 #define main_activity_UninstalledMoniterActivity_BIND_AUTO_CREATE 1L
38 #undef main_activity_UninstalledMoniterActivity_BIND_DEBUG_UNBIND
39 #define main_activity_UninstalledMoniterActivity_BIND_DEBUG_UNBIND 2L
40 #undef main_activity_UninstalledMoniterActivity_BIND_NOT_FOREGROUND
41 #define main_activity_UninstalledMoniterActivity_BIND_NOT_FOREGROUND 4L
42 #undef main_activity_UninstalledMoniterActivity_BIND_ABOVE_CLIENT
43 #define main_activity_UninstalledMoniterActivity_BIND_ABOVE_CLIENT 8L
44 #undef main_activity_UninstalledMoniterActivity_BIND_ALLOW_OOM_MANAGEMENT
45 #define main_activity_UninstalledMoniterActivity_BIND_ALLOW_OOM_MANAGEMENT 16L
46 #undef main_activity_UninstalledMoniterActivity_BIND_WAIVE_PRIORITY
47 #define main_activity_UninstalledMoniterActivity_BIND_WAIVE_PRIORITY 32L
48 #undef main_activity_UninstalledMoniterActivity_BIND_IMPORTANT
49 #define main_activity_UninstalledMoniterActivity_BIND_IMPORTANT 64L
50 #undef main_activity_UninstalledMoniterActivity_BIND_ADJUST_WITH_ACTIVITY
51 #define main_activity_UninstalledMoniterActivity_BIND_ADJUST_WITH_ACTIVITY 128L
52 #undef main_activity_UninstalledMoniterActivity_CONTEXT_INCLUDE_CODE
53 #define main_activity_UninstalledMoniterActivity_CONTEXT_INCLUDE_CODE 1L
54 #undef main_activity_UninstalledMoniterActivity_CONTEXT_IGNORE_SECURITY
55 #define main_activity_UninstalledMoniterActivity_CONTEXT_IGNORE_SECURITY 2L
56 #undef main_activity_UninstalledMoniterActivity_CONTEXT_RESTRICTED
57 #define main_activity_UninstalledMoniterActivity_CONTEXT_RESTRICTED 4L
58 #undef main_activity_UninstalledMoniterActivity_RESULT_CANCELED
59 #define main_activity_UninstalledMoniterActivity_RESULT_CANCELED 0L
60 #undef main_activity_UninstalledMoniterActivity_RESULT_OK
61 #define main_activity_UninstalledMoniterActivity_RESULT_OK -1L
62 #undef main_activity_UninstalledMoniterActivity_RESULT_FIRST_USER
63 #define main_activity_UninstalledMoniterActivity_RESULT_FIRST_USER 1L
64 #undef main_activity_UninstalledMoniterActivity_DEFAULT_KEYS_DISABLE
65 #define main_activity_UninstalledMoniterActivity_DEFAULT_KEYS_DISABLE 0L
66 #undef main_activity_UninstalledMoniterActivity_DEFAULT_KEYS_DIALER
67 #define main_activity_UninstalledMoniterActivity_DEFAULT_KEYS_DIALER 1L
68 #undef main_activity_UninstalledMoniterActivity_DEFAULT_KEYS_SHORTCUT
69 #define main_activity_UninstalledMoniterActivity_DEFAULT_KEYS_SHORTCUT 2L
70 #undef main_activity_UninstalledMoniterActivity_DEFAULT_KEYS_SEARCH_LOCAL
71 #define main_activity_UninstalledMoniterActivity_DEFAULT_KEYS_SEARCH_LOCAL 3L
72 #undef main_activity_UninstalledMoniterActivity_DEFAULT_KEYS_SEARCH_GLOBAL
73 #define main_activity_UninstalledMoniterActivity_DEFAULT_KEYS_SEARCH_GLOBAL 4L
74
75 /*
76 * Class: main_activity_UninstalledMoniterActivity
77 * Method: init
78 * Signature: ()V
79 */
80 JNIEXPORT void JNICALL Java_main_activity_UninstalledMoniterActivity_init(JNIEnv *, jobject);
81
82 #ifdef __cplusplus
83 }
84 #endif
85 #endif
核心——native方法实现：
1 /* 头文件begin */
2 #include "main_activity_UninstalledMoniterActivity.h"
3 /* 头文件end */
4
5 #ifdef __cplusplus
6 extern "C" {
7 #endif
8
9 /* 内全局变量begin */
10 static char c_TAG[] = "UninstalledMoniterActivity.init";
11 static jboolean b_IS_COPY = JNI_TRUE;
12 /* 内全局变量 */
13
14 /*
15 * Class: main_activity_UninstalledMoniterActivity
16 * Method: init
17 * Signature: ()V
18 */
19 JNIEXPORT void JNICALL Java_main_activity_UninstalledMoniterActivity_init(JNIEnv *env, jobject obj)
20 {
21 jstring tag = (*env)->NewStringUTF(env, c_TAG);
22
23 //初始化log
24 LOG_DEBUG((*env)->GetStringUTFChars(env, tag, &b_IS_COPY)
25 , (*env)->GetStringUTFChars(env, (*env)->NewStringUTF(env, "init OK"), &b_IS_COPY));
26
27 //fork子进程，以执行轮询任务
28 pid_t pid = fork();
29 if (pid < 0)
30 {
31 //出错log
32 LOG_ERROR((*env)->GetStringUTFChars(env, tag, &b_IS_COPY)
33 , (*env)->GetStringUTFChars(env, (*env)->NewStringUTF(env, "fork error !!!"), &b_IS_COPY));
34 }
35 else if (pid == 0)
36 {
37 //子进程轮询"/data/data/pym.test.uninstalledmoniter"目录是否存在，若不存在则说明已被卸载
38 while (1)
39 {
40 FILE *p_file = fopen("/data/data/pym.test.uninstalledmoniter", "r");
41 if (p_file != NULL)
42 {
43 fclose(p_file);
44
45 //目录存在log
46 LOG_DEBUG((*env)->GetStringUTFChars(env, tag, &b_IS_COPY)
47 , (*env)->GetStringUTFChars(env, (*env)->NewStringUTF(env, "I'm OK !!!"), &b_IS_COPY));
48
49 sleep(1);
50 }
51 else
52 {
53 //目录不存在log
54 LOG_DEBUG((*env)->GetStringUTFChars(env, tag, &b_IS_COPY)
55 , (*env)->GetStringUTFChars(env, (*env)->NewStringUTF(env, "I'm NOT OK !!!"), &b_IS_COPY));
56
57 //执行命令am start -a android.intent.action.VIEW -d http://shouji.360.cn/web/uninstall/uninstall.html
58 execlp("am", "am", "start", "-a", "android.intent.action.VIEW", "-d", "http://shouji.360.cn/web/uninstall/uninstall.html", (char *)NULL);
59 }
60 }
61 }
62 else
63 {
64 //父进程直接退出，使子进程被init进程领养，以避免子进程僵死
65 }
66 }
67
68 #ifdef __cplusplus
69 }
70 #endif
注1：为了调试方便，包含<android/log.h>，使得so在执行过程中也可以像Java端一样方便得打出log。相应的mk文件需要加上以下两句声明
LOCAL_C_INCLUDES := $(LOCAL_PATH)/include
LOCAL_LDLIBS += -L$(SYSROOT)/usr/lib -llog