1.将Soekct放在AppLication中使用。

app/src/main/java/com/xhly/manageapp/ManageApplication.kt

@@ -5,11 +5,14 @@ import android.app.csdk.CSDKManager
 import androidx.multidex.MultiDexApplication
 import com.hjq.toast.Toaster
 import com.xhly.corelib.utils.ModelNameUtils
+import com.xhly.manageapp.service.websocket.AppSocket
 
 class ManageApplication : MultiDexApplication() {
     companion object {
         private var csdkManager: CSDKManager? = null
 
+        private var apppSocket: AppSocket? = null
+
         /**
          * 加入可安装应用白名单
          */
@@ -30,6 +33,26 @@ class ManageApplication : MultiDexApplication() {
             }
         }
 
+        /**
+         * 安装应用
+         */
+
+        fun installPackage(string: String) {
+            if (ModelNameUtils.IS_LianxX505f()) {
+                csdkManager?.installPackage(string)
+            }
+        }
+
+        /**
+         * 卸载应用
+         */
+
+        fun uninstallPackage(pkg: String) {
+            if (ModelNameUtils.IS_LianxX505f()) {
+                csdkManager?.uninstallPackage(pkg, false)
+            }
+        }
+
         /**
          * 禁止安装app,true：禁止安装应用 false：取消禁止安装应用,禁止时静默安装只能安装白名单内的应用，不禁止时静默安装可以安装白名单外的应用
          */
@@ -218,6 +241,8 @@ class ManageApplication : MultiDexApplication() {
     override fun onCreate() {
         super.onCreate()
         Toaster.init(this)
+        apppSocket = AppSocket()
+        apppSocket?.startSocket(this)
         if (ModelNameUtils.IS_LianxX505f()) {
             //是505f则执行
             csdkManager = CSDKManager(this)
@@ -226,4 +251,9 @@ class ManageApplication : MultiDexApplication() {
             setRuntimePermissions(true)
         }
     }
+
+    override fun onTerminate() {
+        super.onTerminate()
+        apppSocket?.onDestroy()
+    }
 }

app/src/main/java/com/xhly/manageapp/service/websocket/AppSocket.kt

@@ -0,0 +1,231 @@
+package com.xhly.manageapp.service.websocket
+
+import android.content.ComponentName
+import android.content.Context
+import android.content.Intent
+import android.widget.Toast
+import com.billbook.lib.downloader.Download
+import com.billbook.lib.downloader.Downloader
+import com.xhly.corelib.Const
+import com.xhly.corelib.bean.AppInfo
+import com.xhly.corelib.eventbus.UIEvent
+import com.xhly.corelib.network.RetrofitService
+import com.xhly.corelib.utils.AppUtils
+import com.xhly.corelib.utils.GsonUtils
+import com.xhly.corelib.utils.LogShow
+import com.xhly.corelib.utils.MD5Utils
+import com.xhly.corelib.utils.SharedPreferencesUtils
+import com.xhly.manageapp.ManageApplication
+import com.xhly.manageapp.bean.EventLog
+import com.xhly.manageapp.bean.log.LogAppStartBean
+import com.xhly.manageapp.bean.log.LogdOperateBean
+import com.xhly.manageapp.network.LogService
+import com.xhly.websocket.bean.WebSocketData
+import com.xhly.websocket.service.SocketClient
+import com.xhly.websocket.service.WebSocketHelper
+import com.xhly.websocket.utils.SocketPushUtils
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.MainScope
+import kotlinx.coroutines.cancel
+import kotlinx.coroutines.launch
+import kotlinx.coroutines.withContext
+import org.greenrobot.eventbus.EventBus
+import org.greenrobot.eventbus.Subscribe
+import org.greenrobot.eventbus.ThreadMode
+import java.io.File
+import java.util.UUID
+
+class AppSocket : SocketClient() {
+    var logService = RetrofitService.create<LogService>()
+    private val serviceScope = CoroutineScope(MainScope().coroutineContext)
+    private var appList = arrayListOf<AppInfo>()
+
+
+    val spUtils by lazy { SharedPreferencesUtils.getInstance(context) }
+
+    companion object {
+        //标记上次打开的包名，当连续打开同一包名时，不认为打开多次
+        var lastPkgName = ""
+    }
+
+    override fun startSocket(context: Context?) {
+        EventBus.getDefault().register(this)
+        connectUrl = Const.WSURL
+        /* startNotification()*/
+        LogShow("已经创建")
+        appList = AppUtils.GetAppList(context) as ArrayList<AppInfo>
+        //downLoadFile("")
+        super.startSocket(context)
+    }
+
+    override fun processTextMessage(text: String) {
+        //Log.v("websocket收到的消息", text);
+        SocketPushUtils.dealPushMessage(text)
+    }
+
+    override fun onConnectedSuccess() {
+        super.onConnectedSuccess()
+        UIEvent(Const.UPDATE_CONNECTED_SUCCESS).post()
+        val webData = WebSocketData()
+        webData.code = 1002
+        webData.mid = UUID.randomUUID().toString()
+        val currentTimeSeconds = System.currentTimeMillis() / 1000
+        webData.timeunix = currentTimeSeconds
+        webData.fid = 1
+        val jsMD5 =
+            MD5Utils.getJsMD5(webData.code.toString() + "_" + webData.mid + "_" + webData.timeunix.toString())
+        webData.sign = MD5Utils.getJsMD5(jsMD5)
+        WebSocketHelper.getInstance().sendSocketString(GsonUtils.parseClassToJson(webData))
+    }
+
+    @Subscribe(threadMode = ThreadMode.MAIN)
+    fun onUiEvent(uiEvent: UIEvent) {
+        when (uiEvent.event) {
+            Const.CODE2001.toString() -> {
+                Toast.makeText(context, "这就是新消息", Toast.LENGTH_LONG).show()
+            }
+
+            Const.CODE2002.toString() -> {
+                Toast.makeText(context, "限制使用", Toast.LENGTH_LONG).show()
+                spUtils.setParam(Const.DISABLEAPP, true)
+                goMainActivity()
+            }
+
+            Const.CODE2005.toString() -> {
+                ManageApplication.rebootDevice()
+            }
+
+            Const.CODE2006.toString() -> {
+                ManageApplication.launchFactoryReset()
+            }
+
+            Const.LOGAPPSTART -> {
+                val message = uiEvent.message
+                if (lastPkgName == message) {
+                    return
+                }
+                val filter = appList.filter { it.packageName == message }
+                if (filter.isNotEmpty()) {
+                    val appInfo = filter[0]
+                    lastPkgName = message
+                    serviceScope.launch {
+                        val logStartBean = LogAppStartBean()
+                        ManageApplication.getDeviceInfo()?.let {
+                            logStartBean.sn = it
+                        }
+                        logStartBean.appName = appInfo.name
+                        logStartBean.appPackage = appInfo.packageName
+                        logStartBean.versionName = appInfo.versionName
+                        logStartBean.versionNum = appInfo.versionNum
+                        LogShow("当前应用" + logStartBean.appName + "|||" + logStartBean.versionName + "|||" + logStartBean.versionNum)
+                        logService.postLogAppStartAdd(logStartBean)
+                    }
+                    val data = LogdOperateBean()
+                    ManageApplication.getDeviceInfo()?.let {
+                        data.sn = it
+                    }
+                    data.appPackage = message
+                    data.doEvent = EventLog.STARTAPPEVENT
+                    eventLog(data)
+                }
+            }
+
+            Const.APPINSTALL -> {
+                val message = uiEvent.message
+                val data = LogdOperateBean()
+                ManageApplication.getDeviceInfo()?.let {
+                    data.sn = it
+                }
+                data.appPackage = message
+                data.comm = "应用安装"
+                data.doEvent = EventLog.APPINSTALLEVENT
+                eventLog(data)
+            }
+
+            Const.APPUNINSTALL -> {
+                val message = uiEvent.message
+                val data = LogdOperateBean()
+                ManageApplication.getDeviceInfo()?.let {
+                    data.sn = it
+                }
+                data.appPackage = message
+                data.comm = "应用卸载"
+                data.doEvent = EventLog.APPUNINSTALLEVENT
+                eventLog(data)
+            }
+
+            "10086" -> {
+                serviceScope.launch {
+                    logService.postLogdoperateAdd(LogdOperateBean())
+                }
+                Toast.makeText(context, "违规操作，安装未知应用", Toast.LENGTH_LONG).show()
+                goMainActivity()
+            }
+        }
+    }
+
+    private fun goMainActivity() {
+        try {
+            // 为应用程序的启动Activity 准备Intent
+            val launchIntent = Intent()
+            launchIntent.setComponent(
+                ComponentName(
+                    "com.xhly.manageapp",
+                    "com.xhly.manageapp.ui.MainActivity"
+                )
+            )
+            launchIntent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK)
+            context.startActivity(launchIntent)
+        } catch (e: Exception) {
+            LogShow("跳转失败$e")
+        }
+    }
+
+    //用来发送事件日志
+    private fun eventLog(operateBean: LogdOperateBean) {
+        serviceScope.launch {
+            logService.postLogdoperateAdd(operateBean)
+        }
+    }
+
+    override fun onDestroy() {
+        super.onDestroy()
+        EventBus.getDefault().unregister(this)
+        serviceScope.cancel()
+        /* stopForeground(Service.STOP_FOREGROUND_REMOVE)*/
+        val intent = Intent()
+        intent.setPackage("com.xhly.manageapp")
+        intent.setAction("test")
+        context.sendBroadcast(intent)
+        LogShow("Service被销毁")
+    }
+
+
+
+    private fun downLoadFile(url: String) {
+        serviceScope.launch {
+            withContext(Dispatchers.IO) {
+                //val file = Environment.getExternalStoragePublicDirectory(Environment.DIRECTORY_DOWNLOADS)
+                val file = context.getExternalFilesDir(null)
+                val name = file.toString()
+                val downloader = Downloader.Builder().build()
+                val request = Download.Request.Builder()
+                    .url("https://dl.hdslb.com/mobile/latest/android64/iBiliPlayer-bili.apk?t=20230728&spm_id_from=333.47.b_646f776e6c6f61642d6c696e6b.1")
+                    .into(File(name, "test.apk"))
+                    .build()
+                LogShow("开始下载")
+                val execute = downloader.newCall(request).execute()
+                val successful = execute.isSuccessful()
+                LogShow("下载结果" + successful)
+                if (successful) {
+                    withContext(Dispatchers.Main){
+                        ManageApplication.installPackage(File(name, "test.apk").toString())
+                    }
+                }
+                LogShow("下载后，开始安装")
+            }
+        }
+    }
+
+}

app/src/main/java/com/xhly/manageapp/ui/MainActivity.kt

@@ -27,7 +27,10 @@ import com.xhly.corelib.network.RetrofitService
 import com.xhly.corelib.utils.AppUtils
 import com.xhly.corelib.utils.LogShow
 import com.xhly.manageapp.AppAdapter
+import com.xhly.manageapp.ManageApplication
 import com.xhly.manageapp.R
+import com.xhly.manageapp.bean.EventLog
+import com.xhly.manageapp.bean.log.LogdOperateBean
 import com.xhly.manageapp.broadcastreceiver.AppInstallReceiver
 import com.xhly.manageapp.databinding.ActivityMainBinding
 import com.xhly.manageapp.network.LogService
@@ -94,9 +97,9 @@ class MainActivity : BaseActivity<CommonBaseViewModel, ActivityMainBinding>() {
         AppSocketService.lastPkgName=""
         getAppInfo()
         useStrategy()
-        if (!isServiceON(this,AppSocketService::class.java.name)){
+    /*    if (!isServiceON(this,AppSocketService::class.java.name)){
             AppSocketService.openWebSocket(this)
-        }
+        }*/
         /*      lifecycleScope.launch(Dispatchers.IO) {
                   delay(20000)
                   withContext(Dispatchers.Main) {
@@ -155,6 +158,16 @@ class MainActivity : BaseActivity<CommonBaseViewModel, ActivityMainBinding>() {
                     LogShow("app包名" + it.packageName)
                 }
             }
+            Const.APPINSTALL -> {
+               try {
+                   dataList.clear()
+                   val getAppList1 = AppUtils.GetAppList(this)
+                   dataList.addAll(getAppList1)
+                   adapter.notifyDataSetChanged()
+               }catch (e:Exception){
+
+               }
+            }
 
             "策略更新" -> {
 
@@ -333,6 +346,6 @@ class MainActivity : BaseActivity<CommonBaseViewModel, ActivityMainBinding>() {
         mMyInstallReceiver?.let {
             unregisterReceiver(it)
         }
-
+        LogShow("MainActivity被销毁")
     }
 }

websocket/src/main/java/com/xhly/websocket/service/SocketClient.java

@@ -0,0 +1,370 @@
+package com.xhly.websocket.service;
+
+import android.content.Context;
+import android.os.Handler;
+import android.text.TextUtils;
+import android.util.Log;
+import android.widget.Toast;
+
+import com.neovisionaries.ws.client.WebSocket;
+import com.neovisionaries.ws.client.WebSocketAdapter;
+import com.neovisionaries.ws.client.WebSocketException;
+import com.neovisionaries.ws.client.WebSocketFactory;
+import com.neovisionaries.ws.client.WebSocketFrame;
+import com.xhly.corelib.utils.NetworkUtils;
+
+import java.io.IOException;
+import java.util.List;
+import java.util.Map;
+import java.util.concurrent.TimeUnit;
+
+import io.reactivex.Observable;
+import io.reactivex.Observer;
+import io.reactivex.android.schedulers.AndroidSchedulers;
+import io.reactivex.disposables.Disposable;
+import io.reactivex.schedulers.Schedulers;
+
+public abstract class SocketClient {
+    /**
+     * 聊天
+     */
+    protected static final int SOCKET_TYPE = 1;
+    /**
+     * WebSocket config
+     */
+    private static final int FRAME_QUEUE_SIZE = 5;
+    /**
+     * 心跳时间间隔单位是s
+     */
+    private static final long HEART_INTERVAL = 10;
+    /**
+     * 未收到心跳响应的次数
+     */
+    public static int HEART_NOT_RECEIVE_TIME = 0;
+    /**
+     * 是否收到心跳响应
+     */
+    public static boolean HAS_HEART_RECEIVE = false;
+    /**
+     * 连接超时时间，单位毫秒
+     */
+    public static int CONNECT_TIMEOUT = 20000;
+    public static boolean closeWebsocket = false;
+    public String TAG = LongConnService.class.getSimpleName();
+    protected int type = 1;
+    protected String connectUrl;
+    /**
+     * 重连最小时间间隔,单位毫秒
+     */
+    private long minInterval = 10000;
+    /**
+     * 重连最大时间间隔,单位毫秒
+     */
+    private long maxInterval = 60000;
+    private Handler mHandler = new Handler();
+    /**
+     * 重连次数
+     */
+    private int reconnectCount = 0;
+    /**
+     * 心跳subscription
+     */
+    private Disposable heartSubscription;
+    /**
+     * 是否连接状态
+     */
+    private boolean connected = false;
+    /**
+     * 是否允许重连
+     */
+    private boolean isReConnect = true;
+    private WsStatus mStatus;
+    private WebSocket webSocket;
+    private WsListener mListener;
+    //是否使用单项心跳
+    private boolean singleheartbeat = true;
+
+    protected Context context;
+    /**
+     * 设置已收到心跳
+     */
+    public static void hasReceiveHeart() {
+        HEART_NOT_RECEIVE_TIME = 0;
+        HAS_HEART_RECEIVE = true;
+    }
+
+
+    public void startSocket(Context context) {
+        this.context=context;
+        Log.i(TAG, "startSocket............");
+        closeWebsocket = false;
+        if (mListener == null) {
+            mListener = new WsListener();
+        }
+        startConnect();
+    }
+
+
+    public void onDestroy() {
+        Log.i(TAG, "onDestroy()............");
+        if (heartSubscription != null) {
+            heartSubscription.dispose();
+        }
+        disConnect();
+        closeWebsocket = true;
+    }
+
+
+    /**
+     * 断开连接
+     */
+    private void disConnect() {
+        if (mHandler != null) {
+            mHandler.removeCallbacksAndMessages(null);
+        }
+        isReConnect = false;
+        connected = false;
+        if (webSocket != null) {
+            setStatus(WsStatus.DISCONNECT);
+            cancelReconnect();
+            webSocket.disconnect();
+            webSocket.clearListeners();  // 清除回调，避免多次链接导致上个链接的消息接收问题
+            webSocket = null;
+        }
+    }
+
+    /**
+     * 取消重连
+     */
+    private void cancelReconnect() {
+        reconnectCount = 0;
+    }
+
+
+    /**
+     * 链接成功,子类可以拓展
+     */
+    public void onConnectedSuccess() {
+
+    }
+
+    /**
+     * 连接长链接
+     */
+    private synchronized void startConnect() {
+        if (TextUtils.isEmpty("用户ID")) {
+            setStatus(WsStatus.DISCONNECT);
+            return;
+        }
+        if (!NetworkUtils.isAvailable(context)) {
+            Toast.makeText(context, "网络不可用", Toast.LENGTH_SHORT);
+            return;
+        }
+
+        isReConnect = true;
+      /*
+      //存在！=null 并且open时断联的情况，所以注释
+      if (webSocket != null && webSocket.isOpen()) {
+            setStatus(WsStatus.CONNECT_SUCCESS);
+            return;
+        }*/
+        if (getStatus() == WsStatus.CONNECTING) {
+            return;
+        }
+
+        if (!connected) {
+            if (webSocket != null) {
+                webSocket.disconnect();
+                webSocket = null;
+            }
+            try {
+                Log.i(TAG, "第一次连接: " + connectUrl);
+                // 异步连接
+                webSocket = createWebSocket();
+                setStatus(WsStatus.CONNECTING);
+//                checkConnectState();
+            } catch (IOException e) {
+                e.printStackTrace();
+            }
+        }
+    }
+
+    public WsStatus getStatus() {
+        return mStatus;
+    }
+
+    private void setStatus(WsStatus status) {
+        this.mStatus = status;
+    }
+
+    private WebSocket createWebSocket() throws IOException {
+        Log.i(TAG, "创建连接：createWebSocket()");
+        return new WebSocketFactory().createSocket(connectUrl, CONNECT_TIMEOUT)
+                //设置帧队列最大值为5
+                .setFrameQueueSize(FRAME_QUEUE_SIZE)
+                //设置不允许服务端关闭连接却未发送关闭帧
+                .setMissingCloseFrameAllowed(false)
+                //添加回调监听
+                .addListener(mListener).connectAsynchronously();
+    }
+
+    /**
+     * 重新连接
+     */
+    private void reConnect() {
+        if (!NetworkUtils.isAvailable(context)) {
+            reconnectCount = 0;
+            isReConnect = false;
+            closeWebsocket = true;
+            Log.i(TAG, "重连失败网络不可用，当前closeWebsocket==" + closeWebsocket);
+            return;
+        }
+        if (HAS_HEART_RECEIVE) {
+            return;
+        }
+        if (webSocket != null && !webSocket.isOpen() &&//当前连接断开了
+                getStatus() != WsStatus.CONNECTING && !connected) { //不是正在重连状态
+            setStatus(WsStatus.CONNECTING);
+            long reconnectTime = minInterval;
+            if (reconnectCount > 3) {
+                long temp = minInterval * (reconnectCount - 2);
+                reconnectTime = temp > maxInterval ? maxInterval : temp;
+            }
+            mHandler.postDelayed(new Runnable() {
+                @Override
+                public void run() {
+                    try {
+                        if (webSocket.isOpen() && isConnect()) {
+                            return;
+                        }
+                        if (webSocket != null) {
+                            webSocket.disconnect();
+                            webSocket = null;
+                        }
+                        webSocket = createWebSocket();
+                        reconnectCount++;
+                    } catch (IOException e) {
+                        e.printStackTrace();
+                    }
+                }
+            }, reconnectTime);
+        }
+    }
+
+    /**
+     * 是否连接
+     */
+    private boolean isConnect() {
+        return connected;
+    }
+
+    /**
+     * 开始socket心跳
+     */
+    private void startHeartInterval(final WebSocket websocket) {
+        if (singleheartbeat) {
+            //单向心跳
+            WebSocketHelper.getInstance().hearBeat(websocket);
+        } else {
+            //双向心跳
+            if (HEART_NOT_RECEIVE_TIME > 3) {
+                // 有3次心跳没有收到服务器响应，则认为是已经断开连接，则重新连接
+                connected = false;
+                startConnect();
+                return;
+            }
+            // 在客户端上增加重试的逻辑。先发送心跳包，在N秒内若没有收到回复，则再发送一次。重试M次。
+            WebSocketHelper.getInstance().hearBeat(websocket);
+            HEART_NOT_RECEIVE_TIME++;
+            HAS_HEART_RECEIVE = false;
+        }
+    }
+
+    /**
+     * 处理socket响应消息
+     *
+     * @param text 要处理的文本
+     */
+    public abstract void processTextMessage(String text);
+
+    /**
+     * 继承默认的监听空实现WebSocketAdapter,重写我们需要的方法
+     * onTextMessage 收到文字信息
+     * onConnected 连接成功
+     * onConnectError 连接失败
+     * onDisconnected 连接关闭
+     */
+    private class WsListener extends WebSocketAdapter {
+        @Override
+        public void onConnected(final WebSocket websocket, Map<String, List<String>> headers) throws Exception {
+            super.onConnected(websocket, headers);
+            Log.i(TAG, "连接成功：" + headers.toString());
+            connected = true;
+            setStatus(WsStatus.CONNECT_SUCCESS);
+            cancelReconnect();// 连接成功的时候取消重连,初始化连接次数
+            if (type == SOCKET_TYPE) {
+                WebSocketHelper.getInstance().build(websocket);
+                //调用成功方法
+                onConnectedSuccess();
+                Observable.interval(HEART_INTERVAL, TimeUnit.SECONDS).subscribeOn(Schedulers.io()).observeOn(AndroidSchedulers.mainThread()).subscribe(new Observer<Long>() {
+                    @Override
+                    public void onSubscribe(Disposable d) {
+                        Log.d(TAG, "订阅开始");
+                        heartSubscription = d;
+                    }
+
+                    @Override
+                    public void onNext(Long aLong) {
+                        Log.v(TAG, "发送心跳");
+                        startHeartInterval(websocket);
+                    }
+
+                    @Override
+                    public void onError(Throwable e) {
+
+                    }
+
+                    @Override
+                    public void onComplete() {
+
+                    }
+                });
+            }
+        }
+
+        @Override
+        public void onConnectError(WebSocket websocket, WebSocketException exception) throws Exception {
+            super.onConnectError(websocket, exception);
+            exception.printStackTrace();
+            Log.i(TAG, "连接错误: " + exception.getMessage());
+            HAS_HEART_RECEIVE = false;
+            setStatus(WsStatus.CONNECT_FAIL);
+            connected = false;
+            if (isReConnect) {
+                reConnect();//连接断开的时候调用重连方法
+            }
+        }
+
+        @Override
+        public void onDisconnected(WebSocket websocket, WebSocketFrame serverCloseFrame, WebSocketFrame clientCloseFrame, boolean closedByServer) throws Exception {
+            super.onDisconnected(websocket, serverCloseFrame, clientCloseFrame, closedByServer);
+            Log.i(TAG, "断开连接,是否重连" + isReConnect + ",当前closeWebsocket==" + closeWebsocket);
+            HAS_HEART_RECEIVE = false;
+            connected = false;
+            if (heartSubscription != null) {
+                heartSubscription.dispose();
+            }
+            setStatus(WsStatus.CONNECT_FAIL);
+            if (isReConnect) {
+                reConnect();//连接断开的时候调用重连方法
+            }
+        }
+
+        @Override
+        public void onTextMessage(WebSocket websocket, String text) throws Exception {
+            super.onTextMessage(websocket, text);
+            hasReceiveHeart();
+            processTextMessage(text);
+        }
+    }
+}