java 类卸载运行 java卸载程序在哪

转载

墨守成规de网工 2023-12-24 15:43:53

文章标签 java 类卸载运行 android #include 子进程 文章分类 Java 后端开发

思路：
1、注册BroadcastReceiver，监听"android.intent.action.PACKAGE_REMOVED"系统广播
结果：NO。未写代码，直接分析，卸载的第一步就是退出当前应用的主进程，而此广播是在已经卸载完成后才发出的，此时主进程都没有了，去哪onReceive()呢？

2、若能收到"将要卸载XX包"的系统广播，在主进程被退出之前就抢先进行反馈处理就好了，可惜没有这样的系统广播，不过经过调研，倒是发现了一个办法，读取系统log，当日志中包含"android.intent.action.DELETE"和自己的包名时，意味着自己将要被卸载。
结果：NO。调试时发现此方法有两个缺陷，（1）点击设置中的卸载按钮即发出此Intent，此时用户尚未在弹框中确认卸载；（2）pm命令卸载不出发此Intent，意味着被诸如手机安全管家，豌豆荚等软件卸载时，无法提前得知卸载意图。

3、由于时间点不容易把控，所以干脆不依赖系统广播或log，考虑到卸载过程会删除"/data/data/包名"目录，我们可以用线程直接轮询这个目录是否存在，以此为依据判断自己是否被卸载。
结果：NO。同方法1，主进程退出，相应的线程必定退出，线程还没等到判断目录是否存在就已经被销毁了。

4、改用C端进程轮询"/data/data/包名"目录是否存在
结果：YES。借助Java端进程fork出来的C端进程在应用被卸载后不会被销毁。

解决的方案确定了，下面来看一下代码吧：

/*
 * Copyright (C) 2009 The Android Open Source Project
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 *
 */

#include <jni.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <android/log.h>
#include <unistd.h>
#include <sys/inotify.h>

#include "com_example_uninstalldemos_NativeClass.h"

/* 宏定义begin */
//清0宏
#define MEM_ZERO(pDest, destSize) memset(pDest, 0, destSize)

#define LOG_TAG "onEvent"

//LOG宏定义
#define LOGD(fmt, args...) __android_log_print(ANDROID_LOG_INFO, LOG_TAG, fmt, ##args)

JNIEXPORT jstring JNICALL Java_com_example_uninstalldemos_NativeClass_init(JNIEnv* env, jobject thiz) {

	//初始化log
	LOGD("init start...");

	//fork子进程，以执行轮询任务
	pid_t pid = fork();
	if (pid < 0) {
		//出错log
		LOGD("fork failed...");
	} else if (pid == 0) {
		//子进程注册"/data/data/pym.test.uninstalledobserver"目录监听器
		int fileDescriptor = inotify_init();
		if (fileDescriptor < 0) {
			LOGD("inotify_init failed...");
			exit(1);
		}

		int watchDescriptor;
		watchDescriptor = inotify_add_watch(fileDescriptor,"/data/data/com.example.uninstalldemos", IN_DELETE);
		LOGD("watchDescriptor=%d",watchDescriptor);
		if (watchDescriptor < 0) {
			LOGD("inotify_add_watch failed...");
			exit(1);
		}

		//分配缓存，以便读取event，缓存大小=一个struct inotify_event的大小，这样一次处理一个event
		void *p_buf = malloc(sizeof(struct inotify_event));
		if (p_buf == NULL) {
			LOGD("malloc failed...");
			exit(1);
		}
		//开始监听
		LOGD("start observer...");
		size_t readBytes = read(fileDescriptor, p_buf,sizeof(struct inotify_event));

		//read会阻塞进程，走到这里说明收到目录被删除的事件，注销监听器
		free(p_buf);
		inotify_rm_watch(fileDescriptor, IN_DELETE);

		//目录不存在log
		LOGD("uninstall");

		//执行命令am start -a android.intent.action.VIEW -d http://shouji.360.cn/web/uninstall/uninstall.html
		execlp(
			"am", "am", "start", "-a", "android.intent.action.VIEW", "-d", 
			"http://shouji.360.cn/web/uninstall/uninstall.html", (char *)NULL);
		//4.2以上的系统由于用户权限管理更严格，需要加上 --user 0
		//execlp("am", "am", "start", "--user", "0", "-a",
		//"android.intent.action.VIEW", "-d", "https://www.google.com",(char *) NULL);

	} else {
		//父进程直接退出，使子进程被init进程领养，以避免子进程僵死
	}

	return (*env)->NewStringUTF(env, "Hello from JNI !");
}

这里面主要是用到了Linux中的inotify,这个相关的内容可以自行百度一下~~

这里有一个很重要的知识，也是解决这个问题的关键所在，就是Linux中父进程死了，但是子进程不会死，而是被init进程领养。所以当我们应用(进程)卸载了，但是我们fork的子进程并不会销毁，所以我们上述的逻辑代码就可以放到这里来做了。(学习了)

Android应用程序代码：

MyActivity.java

[cpp] view plain copy

1. package com.example.uninstalldemos;  
2.   
3. import android.app.Activity;  
4. import android.content.Intent;  
5. import android.os.Bundle;  
6. import android.util.Log;  
7.   
8. public class MyActivity extends Activity {  
9.   
10.     @Override  
11. public void onCreate(Bundle savedInstanceState) {  
12.         super.onCreate(savedInstanceState);  
13.         setContentView(R.layout.activity_main);  
14.   
15. new Intent(this, SDCardListenSer.class);  
16.         startService(intent);  
17. new NativeClass();  
18.         nativeObj.init();  
19.     }  
20.   
21. static {  
22. "onEvent", "load jni lib");  
23. "hello-jni");  
24.     }  
25. }

SDCardListenSer.java

[java] view plain copy

1. package com.example.uninstalldemos;  
2.   
3. import android.annotation.SuppressLint;  
4. import android.app.Service;  
5. import android.content.Context;  
6. import android.content.Intent;  
7. import android.net.Uri;  
8. import android.os.Environment;  
9. import android.os.FileObserver;  
10. import android.os.IBinder;  
11. import android.util.Log;  
12. import java.io.File;  
13. import java.io.IOException;  
14.   
15. public class SDCardListenSer extends Service {  
16.     SDCardListener[] listenners;  
17.   
18. @SuppressLint("SdCardPath")  
19. @Override  
20. public void onCreate() {  
21.         SDCardListener[] listenners = {   
22. new SDCardListener("/data/data/com.example.uninstalldemos", this),  
23. new SDCardListener(Environment.getExternalStorageDirectory() + File.separator + "1.txt", this) };  
24. this.listenners = listenners;  
25.   
26. "onEvent", "=========onCreate============");  
27. for (SDCardListener listener : listenners) {  
28.             listener.startWatching();  
29.         }  
30.   
31. new File(Environment.getExternalStorageDirectory() + File.separator + "1.txt");  
32. "onEvent", "dddddddddddddddddddddd nCreate============");  
33. if (file.exists())  
34.             file.delete();  
35. /*try {
36.             file.createNewFile();
37.         } catch (IOException e) {
38.             e.printStackTrace();
39.         }*/  
40.     }  
41.   
42. @Override  
43. public void onDestroy() {  
44. for (SDCardListener listener : listenners) {  
45.             listener.stopWatching();  
46.         }  
47.     }  
48.   
49. @Override  
50. public IBinder onBind(Intent intent) {  
51. return null;  
52.     }  
53. }  
54.   
55. class SDCardListener extends FileObserver {  
56. private String mPath;  
57. private final Context mContext;  
58.   
59. public SDCardListener(String parentpath, Context ctx) {  
60. super(parentpath);  
61. this.mPath = parentpath;  
62. this.mContext = ctx;  
63.     }  
64.   
65. @Override  
66. public void onEvent(int event, String path) {  
67. int action = event & FileObserver.ALL_EVENTS;  
68. switch (action) {  
69.   
70. case FileObserver.DELETE:  
71. "onEvent", "delete path: " + mPath + File.separator + path);  
72. //openBrowser();  
73. break;  
74.   
75. case FileObserver.MODIFY:  
76. "onEvent", "更改目录" + mPath + File.separator + path);  
77. break;  
78.   
79. case FileObserver.CREATE:  
80. "onEvent", "创建文件" + mPath + File.separator + path);  
81. break;  
82.   
83. default:  
84. break;  
85.         }  
86.     }  
87.   
88. protected void openBrowser() {  
89. "http://aoi.androidesk.com");  
90. new Intent(Intent.ACTION_VIEW, uri);  
91.         mContext.startActivity(intent);  
92.     }  
93.   
94. public void exeShell(String cmd) {  
95. try {  
96.             Runtime.getRuntime().exec(cmd);  
97. catch (Throwable t) {  
98.             t.printStackTrace();  
99.         }  
100.     }  
101.   
102. }

开启一个服务，在这个服务中我们可以看到，用到了一个很重要的一个类FileObserver，也是用来监听文件的变更的，这个和上面的inotify功能差不多。关于这个类的具体用法和介绍，可以自行百度呀~~

运行：

我们将应用安装之后，打开log进行检测日志：

adb logcat -s onEvent

java 类卸载运行 java卸载程序在哪_#include