当应用程序关闭或关闭时，我如何保持后台android服务运行

大家好
我有新闻应用程序，我想在每次更新时推送通知。
我使用socketIO从服务器进行监听， 我的安卓服务问题我想在关闭时保持服务运行|终止。 我已经在应用程序运行时启动了我的服务，并返回onStartCommand start\u STICKY\u兼容性 当应用程序关闭时，它可以正常工作，但当操作系统停止服务时，它不会再次启动 有什么帮助吗？

注意：我忽略应用程序的电池优化

我的服务课：

class ServicesMain: Service() {
    override fun onBind(p0: Intent?): IBinder? {
       return  null;
    }
    @SuppressLint("TrulyRandom")
    fun handleSSLHandshake() {
        try {
            val trustAllCerts = arrayOf<TrustManager>(object : X509TrustManager {
                override fun getAcceptedIssuers(): Array<X509Certificate>? {
                    return null;
                }

                override fun checkClientTrusted(certs: Array<X509Certificate>, authType: String) {}
                override fun checkServerTrusted(certs: Array<X509Certificate>, authType: String) {}
            })
            val sc = SSLContext.getInstance("SSL")
            sc.init(null, trustAllCerts, SecureRandom())
            HttpsURLConnection.setDefaultSSLSocketFactory(sc.socketFactory)
            HttpsURLConnection.setDefaultHostnameVerifier { arg0, arg1 -> true }
        } catch (ignored: Exception) {
        }
    }
@RequiresApi(Build.VERSION_CODES.O)
fun  startSocket(){
    handleSSLHandshake()
    runBroadcast()
    Log.d("TAG", "BroadcastReceiver: ")
    Timer().schedule(object : TimerTask() {
        override fun run() {
            Log.d("TAG", "run: ${socket!!.connected()} ")

        }

    }, 0, 10000)



}
    private var socket: Socket? = null;

    @SuppressLint("RestrictedApi")
    @RequiresApi(Build.VERSION_CODES.O)
    fun runBroadcast() {
        val myHostnameVerifier = HostnameVerifier { _, _ ->
            return@HostnameVerifier true
        }

        val trustAllCerts = arrayOf<TrustManager>(object : X509TrustManager {
            override fun checkClientTrusted(chain: Array<X509Certificate>, authType: String) {}

            override fun checkServerTrusted(chain: Array<X509Certificate>, authType: String) {}

            override fun getAcceptedIssuers(): Array<X509Certificate> {
                return arrayOf()
            }
        })

        val sslContext = SSLContext.getInstance("TLS")
        sslContext.init(null, trustAllCerts, null)

        val okHttpClient = OkHttpClient.Builder()
                .hostnameVerifier(myHostnameVerifier)
                .sslSocketFactory(sslContext.socketFactory, trustAllCerts[0] as X509TrustManager)
                .readTimeout(0, TimeUnit.MILLISECONDS).writeTimeout(0, TimeUnit.MILLISECONDS).build()

        val options = IO.Options()
        options.transports = arrayOf(Polling.NAME)
        options.webSocketFactory = okHttpClient
        options.callFactory=okHttpClient
        options.secure = true
        socket = IO.socket("https://....", options);

        socket!!.connect().on("message", Emitter.Listener { args ->


            val jsonObject = JSONObject(args[0] as String)

            val calendarTime = jsonObject.getLong("starttime") - (Calendar.getInstance().timeInMillis)

            println(calendarTime)

            val builder = Constraints.Builder()
                    .setRequiredNetworkType(NetworkType.CONNECTED)
            val data: Data.Builder = Data.Builder()
            data.putStringArray("data", arrayOf<String>(jsonObject.getString("title"), jsonObject.getString("subject"), jsonObject.getString("id")))


            val oneTimeWorkRequest = OneTimeWorkRequest.Builder(NotificationEvetns::class.java).setInputData(data.build()).setConstraints(builder.build())
                    .setInitialDelay(calendarTime, TimeUnit.MILLISECONDS).addTag(jsonObject.getString("id")).build()
            this.let { WorkManager.getInstance(it).enqueue(oneTimeWorkRequest) }
        })


}

    override fun onTaskRemoved(rootIntent: Intent?) {

        super.onTaskRemoved(rootIntent)
        Log.d("TAG", "onTaskRemoved: ")
    }

    override fun onStartCommand(intent: Intent?, flags: Int, startId: Int): Int {
        Log.d("TAG", "onStartCommand: ")

        return  START_STICKY_COMPATIBILITY
    }




    @RequiresApi(Build.VERSION_CODES.O)
    override fun onCreate() {
        super.onCreate()

        startSocket()
    }


    override fun onDestroy() {
        super.onDestroy()
        socket?.disconnect()
    }

    override fun onTrimMemory(level: Int) {
        super.onTrimMemory(level)
        Log.d("TAG", "onTrimMemory: ")
    }

}

类服务main:Service（）{
覆盖乐趣绑定（p0：意图？）：IBinder{
返回null；
}
@SuppressLint（“TrulyRandom”）
有趣的握手{
试一试{
val trustAllCerts=arrayOf（对象：X509TrustManager{
覆盖有趣的GetAcceptedAssuers（）：数组{
返回null；
}
重写fun checkClientTrusted（证书：数组，authType:String）{}
重写fun checkServerTrusted（证书：数组，authType:String）{}
})
val sc=SSLContext.getInstance（“SSL”）
sc.init（null，trustAllCerts，SecureRandom（））
HttpsURLConnection.setDefaultSSLSocketFactory（sc.socketFactory）
HttpsURLConnection.setDefaultHostnameVerifier{arg0，arg1->true}
}捕获（忽略：异常）{
}
}
@RequiresApi（Build.VERSION\u code.O）
趣味startSocket（）{
握手
运行广播（）
Log.d（“标记”，“广播接收器：”）
Timer（）.schedule（对象：TimerTask（））{
覆盖趣味跑（）{
Log.d（“标记”，“运行：${socket！！.connected（）}”）
}
}, 0, 10000)
}
私有变量套接字：套接字？=null；
@SuppressLint（“RestrictedApi”）
@RequiresApi（Build.VERSION\u code.O）
趣味跑步广播（）{
val myHostnameVerifier=HostnameVerifier{{{{，}->
return@HostnameVerifier真的
}
val trustAllCerts=arrayOf（对象：X509TrustManager{
重写fun checkClientTrusted（链：数组，authType:String）{}
重写fun checkServerTrusted（链：数组，authType:String）{}
重写GetAcceptedAssuers（）：数组{
返回数组（）
}
})
val sslContext=sslContext.getInstance（“TLS”）
sslContext.init（null，trustAllCerts，null）
val okHttpClient=okHttpClient.Builder（）
.hostnameVerifier（myHostnameVerifier）
.sslSocketFactory（sslContext.socketFactory，信任证书[0]作为X509TrustManager）
.readTimeout（0，TimeUnit.millizes）.writeTimeout（0，TimeUnit.millizes）.build（）
val options=IO.options（）
options.transports=arrayOf（Polling.NAME）
options.webSocketFactory=okHttpClient
options.callFactory=okHttpClient
options.secure=true
套接字=IO.socket（“https://....“，选项）；
socket！！.connect（）.on（“消息”，发射器.Listener{args->
val jsonObject=jsonObject（参数[0]为字符串）
val calendarTime=jsonObject.getLong（“starttime”）-（Calendar.getInstance（）.timeInMillis）
println（日历时间）
val builder=Constraints.builder（）
.setRequiredNetworkType（NetworkType.CONNECTED）
val数据：data.Builder=data.Builder（）
data.putStringArray（“数据”、arrayOf（jsonObject.getString（“标题”）、jsonObject.getString（“主题”）、jsonObject.getString（“id”））
val oneTimeWorkRequest=oneTimeWorkRequest.Builder（NotificationEvetns:：class.java）.setInputData（data.build（））.setConstraints（Builder.build（））
.setInitialDelay（calendarTime，TimeUnit.millizes）.addTag（jsonObject.getString（“id”））.build（）
this.let{WorkManager.getInstance（it.enqueue（oneTimeWorkRequest）}
})
}
覆盖onTaskRemoved（rootIntent:Intent？）{
super.onTaskRemoved（rootIntent）
Log.d（“标记”，“onTaskRemoved:”）
}
覆盖启动命令（intent:intent？，标志：Int，startId:Int）：Int{
Log.d（“TAG”，“onStartCommand:”）
返回开始\u粘性\u兼容性
}
@RequiresApi（Build.VERSION\u code.O）
重写fun onCreate（）{
super.onCreate（）
startSocket（）
}
重写onDestroy（）{
super.ondestory（）
插座？.disconnect（）
}
覆盖直接性（级别：Int）{
超级无限期（级别）
Log.d（“标记”，“非直接性：”）
}
}

你不能，在现代版本的Android上不行。你可以制作一个最不可能被杀死的前台服务（前台应用程序之外），但你不能指望它不会被杀死。相反，您可以编写代码，这样它就不需要了——主要是通过使用WorkManager进行触发式后台工作。除非你正在编写一个服务器，在这种情况下，我会说你应该使用另一个操作系统，Android是不合适的

---

对于来自您提到的服务器的消息，我会使用FCM推送消息，而不是长期的直接服务器连接。

WorkManager用于在通知开始时推送通知前台如何在不显示通知的情况下启动它？@JawadFadel您不能。他们之所以这么做，是为了在用户不知情的情况下阻止应用程序在后台运行。实际上，你要做的就是安卓试图阻止你做的一切。