Not able to make background service "unkillable"

Question

I read a lot of articles on forums, but wasn't able to make the "unkillable" background service work. I tried disabling the battery optimalization ( didn't work), making the foreground service ( since making app from api 24-31, didn't find solution on how to make it work, maybe the right way to do it), making the broadcast receiver - "restarter". (Of course this isn't all, but it is everything that has something to do with the service)

Manifest:

        <service android:name="PathToService" android:foregroundServiceType="dataSync|location" />

        <receiver
            android:enabled="true"
            android:name="PathToReciever"
            android:label="RestartServiceWhenStopped">
        </receiver>

Receiver:

    @Override
    public void onReceive(Context context, Intent intent) {
        context.startService(new Intent(context, SERVICE));
    }

Service:

    @Override
    public void onDestroy() {

        Intent broadcastIntent = new Intent(this, SERVICE);
        sendBroadcast(broadcastIntent);

    }

Answer 1

incase if your whole problem is that the OS just randomly destroys the service after a while, you could returning START_STICKY in the onStartCommand method in the foreground service

according to Android Developers documentation :

START_STICKY

If the system kills the service after onStartCommand() returns, recreate the service and call onStartCommand(), but do not redeliver the last intent. Instead, the system calls onStartCommand() with a null intent unless there are pending intents to start the service. In that case, those intents are delivered. This is suitable for media players (or similar services) that are not executing commands but are running indefinitely and waiting for a job.

if that's the case then it gets solved by this code :

@Override
    public int onStartCommand(Intent intent, int flags, int startId) {
        super.onStartCommand(intent, flags, startId);
        ... \\ whatever your code contains here
        return START_STICKY;
    }

maybe that's why I'm telling you that I didn't notice that anything is killing my service rather during my tests.

N.B : take care that the lifetime of foreground services is higher than background ones, as since api 28 there's some restrictions on background services that might make it quite unusable for long work assignment that you should consider either switching to foreground services or use long-running-workers.

Foreground service

A foreground service performs some operation that is noticeable to the user. For example, an audio app would use a foreground service to play an audio track. Foreground services must display a Notification. Foreground services continue running even when the user isn't interacting with the app.

When you use a foreground service, you must display a notification so that users are actively aware that the service is running. This notification cannot be dismissed unless the service is either stopped or removed from the foreground.

Background

A background service performs an operation that isn't directly noticed by the user. For example, if an app used a service to compact its storage, that would usually be a background service.

Note: If your app targets API level 26 or higher, the system imposes restrictions on running background services when the app itself isn't in the foreground. In most situations, for example, you shouldn't access location information from the background. Instead, schedule tasks using WorkManager.

you can also check that question and its answer for more clarity