Googling around, I have seen this problem posted many times, some of the posts on this forum over that last few years. I have never seen anyone get a straight answer.
I have a foreground service that tries to stop itself after running for 2 hours by doing a this.StopSelf(). I've tried it when it's bound and when it's unbound. On the AVD and on a device.
It simply does not work. Is this a bug in Android? (running 2.3.3).
How can a service stop itself?
If you use a foreground service, you should call:
stopForeground(true);
Just like you start it with startForeground.
stopSelf is meant to be used for normal services. a foreground service is special... :)
By the way, in case your app should work on older devices, you should check the compatibility code offered here.
The only way I have found to stop a service with certainty is to use:
android.os.Process.killProcess(android.os.Process.myPid());
This behavior can be caused by using worker threads that have not finished when the stopSelf is called. If you are using worker threads, be careful how you employ this - you may leak memory if you don't clean up before executing the line.
I met a similar problem.Through my search found that: In other activity's onCreate method I bind the service,but not unbind it onDestory method.After fix that,when I call stopSelf then the service's onDestory method is call. I hope it can help you.
At same time,I find base from Android gover document.
A service can be both started and have connections bound to it. In such a case, the system will keep the service running as long as either it is started or there are one or more connections to it with the Context.BIND_AUTO_CREATE flag. Once neither of these situations hold, the service's onDestroy() method is called and the service is effectively terminated. All cleanup (stopping threads, unregistering receivers) should be complete upon returning from onDestroy().
I had this problem and searching I found this thread. My app's problem is that when service calls stopSelf(), the foreground activity that binds the service is still running. Thne stopSelf is called but the service is not destroyed as the foreground activity is still bound. When I leave the activity by pressing back or going to home screen, then the service is destroyed. In short, stopSelf won't work when a foreground activity is bound.
I encounter this issue of selfStop() that not working too.
The main idea to understand is that the Service WILL NOT stop,
if a running loop is still running (while(mDoWhile) for example).
Or any other issue that need to be destroyed / unregistered first.
So to make the stopSelf() or stopService(intent) works,
implement onDestroy() within your service:
#Override
public void onDestroy()
{
// Unregistered or disconnect what you need to
// For example: mGoogleApiClient.disconnect();
// Or break the while loop condition
// mDoWhile = false;
super.onDestroy();
}
if you both called startService and bindService.you should unbindService frist,otherwish the stopSelf will not work.
I was facing same problem too.
As we all know that Service runs on App's UI Thread. So, until you've Thread that is running in background in your service and you are calling stopSelf() then it won't work. For that you have to stop that Thread first and then execute stopSelf().
After stoping all background Thread from your Service stopSelf() method will definitely work.
The only way i had to kill the foreground service was to set stopwithtask=true in the manifest
<service
android:name="my.package.MyForegroundService"
android:foregroundServiceType="location"
android:stopWithTask="true"
android:permission="android.permission.BIND_NOTIFICATION_LISTENER_SERVICE">
</service>
In my case of foreground service, it was necessary to remove location updates, unregister sensors, etc.
Add the following code to OnStartCommand when you want to kill the service:
private void selfTerminate() {
stopForeground(true);
unregisterBarometer();
if (locCallBack != null) {
getFusedLocationProviderClient(this).removeLocationUpdates(locCallBack);
}
m_tripState.currentActivity.clock.stopClock();
stopSelf();
}
stopSelf might not destroy the service if the conditions are not favorable, but you can stopService with the application context. But make sure the service doesn't restart before calling stopService inside service.
stopService(applicationContext, MyService::class.java)
Related
while going through a code I found that before starting or stopping a service
a check was placed to confirm whether the service is already running or already stopped.
This was done using Activity Manager which gives information
about already running services in the System.
I want to know is this check necessary ?
what would happen if I call startService() for an already running service ?
What would happen if I call stopService() for an already stopped service ?
As it is mentioned in the Android docs
Note that multiple calls to Context.startService() do not nest (though
they do result in multiple corresponding calls to onStartCommand()),
so no matter how many times it is started a service will be stopped
once Context.stopService() or stopSelf() is called; however, services
can use their stopSelf(int) method to ensure the service is not
stopped until started intents have been processed.
So on your question
what would happen if I call startService() for an already running service ?
The onStartCommand() is called again and again but service once started cannot be started again or nested
What would happen if I call stopService() for an already stopped
service ?
When you call it first the onDestroy() method is called and later calls are ignored as service doesnt exist any more
If the service running, it does not create another instance, but onStartCommand() is still called on the existing instance.
You may look into Service Life cycle for more details.
Note that multiple calls to Context.startService() do not nest (though
they do result in multiple corresponding calls to onStartCommand()),
so no matter how many times it is started a service will be stopped
once Context.stopService() or stopSelf() is called; however, services
can use their stopSelf(int) method to ensure the service is not
stopped until started intents have been processed.
As for stopService, it wont affect anything even if the service in question is not running in my knowledge.
A service will only run once, no matter how many times you call startService().
Calling stopService() will make no effect on an already stopped service.Its like calling onDestroy() on a already destroyed Activity.
I am looking at the doc but it doesn't really explain this anywhere. I did find this:
The service will at this point continue running until Context.stopService()
or stopSelf() is called.
What this tells me is the Service will continue running, but that is assuming when orientation change occurs that the Activity/Fragment does not automatically stop services it has started. I also found this:
Using startService() overrides the default service lifetime that is managed by
bindService(Intent, ServiceConnection, int): it requires the service to remain
running until stopService(Intent) is called, regardless of whether any
clients are connected to it.
Can I assume that the Service will actually not stop until I explicitly call stopService?
for the title, answer is no.
A service doesn't stops when the calling activity/fragment changes orientation. It continues running unless or untill it is stopped explicitly
for the description, the answer is yes.
you definitely need to call either of the functions stopService() or stopSelf() to stop the service.
Yes.You have to stop it using stopService() method or you can use stopSelf() to stop when the the service is no longer needed.it will automatically stop the service.
I have a question related to how Android service behaves when stopped by system. As per my understanding, if system (OS) stops the service due to resources needed, it is responsibility of system to start it again. In this scenario, system would not call onDestroy() when stopping service and onCreate() when starting service, rather it would just call onStartCommand().
If I am creating a thread in onStartCommand(), how would I cleanup thread when system stops service. If I dont stop thread, onStartCommand() would create a new thread.
I think, it may come down to onStartCommand() parameters (intent, flags and startId). They might be different when system starts service after stopping it because it needed resources. Could anyone tell me what would be difference in parameters when service started by startService() command or by system itself (after stopping it)
I can create thread in onCreate() but I am not sure if thread still exists when system stops service. What would be the best way to handle this kind of scenario.
Thanks
As per my understanding, if system (OS) stops the service due to resources needed, it is responsibility of system to start it again.
That depends upon what you return from onStartCommand(). START_NOT_STICKY, for example, means the OS does not have to start your service again.
In this scenario, system would not call onDestroy() when stopping service and onCreate() when starting service, rather it would just call onStartCommand().
Whether it calls onDestroy() would depend a bit on how the service is stopped (e.g., directly or via process termination). However, it should still call onCreate() on the new instance, if and when the OS restarts the service.
If I am creating a thread in onStartCommand(), how would I cleanup thread when system stops service.
Ensure that in onDestroy(), something happens that will cause the thread to go away. Either onDestroy() will be called (and your service can do its cleanup), or your process is being terminated (and your thread goes away with it).
Could anyone tell me what would be difference in parameters when service started by startService() command or by system itself (after stopping it)
There is a START_FLAG_REDELIVERY that will be in the flags passed to onStartCommand(), but AFAIK it will only be set if you return START_REDELIVER_INTENT from onStartCommand().
From my little android knowledge I understand that android OS can kill my service under extreme memory conditions.
I have created a service that returns START_STICKY. The service is meant to run in background.
If android is about to kill my service, will it call onDestroy ?
And when it restarts it would it call onCreate ?
See here, the dev guide. http://developer.android.com/reference/android/app/Service.html#ProcessLifecycle
onCreate() is only called when the process starts, which can either be the first time the service is running, or if it was killed on restarted, essentially this is called whenever it starts.
onStartCommand() is called whenever a client calls startService().
When a service is destroyed / completely stopped, Android is supposed to call onDestroy() on that service. I think it's possible for that to not happen (e.g. process is killed not through Android system). In the case of a bound service, this is when there are not more active client binders.
Edit: onCreate() Service starts; onStartCommand()someone uses service; onDestroy()Service is killed / stopped.
If someone calls Context.startService() then the system will retrieve
the service (creating it and calling its onCreate() method if needed)
and then call its onStartCommand(Intent, int, int) method with the
arguments supplied by the client
...
A service can be both started and have connections bound to it. In
such a case, the system will keep the service running as long as
either it is started or there are one or more connections to it with
the Context.BIND_AUTO_CREATE flag. Once neither of these situations
hold, the service's onDestroy() method is called and the service is
effectively terminated. All cleanup (stopping threads, unregistering
receivers) should be complete upon returning from onDestroy().
http://developer.android.com/reference/android/app/Service.html
EDIT: Quick answer. Yes to both questions
If I have a service running in my Android phone and I shutdown, will the service call onDestroy? I want the service to perform a task just before the phone shuts down. Although the Google Droid guide says not to put such code in onDestroy, I do not know what else can be done.
If startService() is called to create your Service you should call stopService(), then onDestroy() will be called. If you use bindService() with BIND_AUTO_CREATE flag, than unbindService() caused onDestroy() automatically. What code they say shouldn't be put there? If it uses this Service of cause onDestroy() is not a good idea, if it's something like notification it's ok to put it there.