I have a service which is binded to application context like this:
getApplicationContext().bindService(
new Intent(this, ServiceUI.class),
serviceConnection,
Context.BIND_AUTO_CREATE
);
protected void onDestroy() {
super.onDestroy();
getApplicationContext().unbindService(serviceConnection);
}
For some reason, only sometimes the application context does not bind properly (I can't fix that part), however in onDestroy() I do unbindservice which throws an error
java.lang.IllegalArgumentException: Service not registered: tools.cdevice.Devices$mainServiceConnection.
My question is: Is there a way to call unbindservice safely or check if it is already bound to a service before unbinding it?
Thanks in advance.
Try this:
boolean isBound = false;
...
isBound = getApplicationContext().bindService( new Intent(getApplicationContext(), ServiceUI.class), serviceConnection, Context.BIND_AUTO_CREATE );
...
if (isBound)
getApplicationContext().unbindService(serviceConnection);
Note:
You should use same context for binding a service and unbinding a service. If you are binding Service with getApplicationContext() so you should also use getApplicationContext.unbindService(..)
Here you can find a nice explanation and source codes how to work with bound services. In your case you should override methods (onServiceConnected and onServiceDisconnected) of ServiceConnection object. Then you can just check mBound variable in your code.
Doing exactly what Andrey Novikov proposed didn't work for me.
I simply replaced:
getApplicationContext().unbindService(serviceConnection);
With:
unbindService(serviceConnection);
I found there are two issues. Attempting to bind more than once and also attempting to unbind more than once.
Solution:
public class ServiceConnectionManager implements ServiceConnection {
private final Context context;
private final Class<? extends Service> service;
private boolean attemptingToBind = false;
private boolean bound = false;
public ServiceConnectionManager(Context context, Class<? extends Service> service) {
this.context = context;
this.service = service;
}
public void bindToService() {
if (!attemptingToBind) {
attemptingToBind = true;
context.bindService(new Intent(context, service), this, Context.BIND_AUTO_CREATE);
}
}
#Override
public void onServiceConnected(ComponentName componentName, IBinder iBinder) {
attemptingToBind = false;
bound = true;
}
#Override
public void onServiceDisconnected(ComponentName componentName) {
bound = false;
}
public void unbindFromService() {
attemptingToBind = false;
if (bound) {
context.unbindService(this);
bound = false;
}
}
}
Why do we get this error?
When you try to unregister a service which is not registered.
What are some common examples?
Binding and Unbinding a service with different Context.
calling unBind(mserviceConnection) more than bind(...)
First point is self explanatory. Lets explore the second source of error more deeply. Debug your bind() and unbind() calls. If you see calls in these order then your application will end up getting the IllegalArgumentException.
How can we avoid this?
There are two ways you should consider to bind and unbind a service in Activity. Android docs recommend that
If you want to interact with a service only when the Activity is visible then
bindService() in onStart() and unbindService() in onStop()
Your Activity {
#Override
public void onStart(){
super.onStart();
bindService(intent, mConnection , Context.BIND_AUTO_CREATE);
}
#Override
public void onStop(){
super.onStop();
unbindService(mConnection);
}
}
If you want to interact with a service even an Activity is in Background then
bindService() in onCreate() and unbindService() in onDestroy()
Your Activity {
#Override
public void onCreate(Bindle sis){
super.onCreate(sis);
....
bindService(intent, mConnection , Context.BIND_AUTO_CREATE);
}
#Override
public void onDestroy() {
super.onDestroy();
unbindService(mConnection);
}
}
I think that guide is not completely correct as mentioned here Surya Wijaya Madjid. Memory leaks can occur when bound service is destryed and not re-connected yet.
I think that this approach is needed:
Service mService;
private final ServiceConnection mServiceConnection = new ServiceConnection()
{
boolean bound = false;
#Override
public void onServiceDisconnected(ComponentName name)
{
mService = null;
}
#Override
public void onServiceConnected(ComponentName name, IBinder service)
{
mService = ((MyService.ServiceBinder) service).getService();
if (!bound)
{
// do some action - service is bound for the first time
bound = true;
}
}
};
#Override
public void onDestroy()
{
if (mService != null)
{
// do some finalization with mService
}
if (mServiceConnection.bound)
{
mServiceConnection.bound = false;
unbindService(mServiceConnection);
}
super.onDestroy();
}
public void someMethod()
{
if (mService != null)
{
// to test whether Service is available, I have to test mService, not mServiceConnection.bound
}
}
Use a variable to record if you have ever bind to a service, and unbind it if the variable is true.
See android official example :
http://androidxref.com/9.0.0_r3/xref/development/samples/ApiDemos/src/com/example/android/apis/app/RemoteService.java#376
Not sure about all the above answers, it seemed far too complicated while none of these would fit the issue I had.
Only binding/unbinding once at a time, and the service was definitely bound at the time of the unbind() call. Don't want to leak anything, so I just made sure I was using the same context for the bind() and unbind() calls and that solved it permanently! Doing something like this:
any_context.getApplicationContext().bind(...);
...
another_context.getApplicationContext().unbind(...);
Related
I'm stuck in a problem with a service binding that is giving me nuts.
I got an activity that is binding a service, and is frequent that the user go in and out of that activity.
The problem comes when the user goes out first time of the activity this one unBinds the service and when is going in again, do not binds again.
The activity calls the binding service this way:
#Override
protected void onStart() {
super.onStart();
Intent intent = new Intent(this, CService.class);
intent.putExtra("id_local", (String) getIntent().getExtras().get("id_local"));
intent.putExtra("id_send", (String) getIntent().getExtras().get("id_send"));
bindService(intent, mConnection, Context.BIND_AUTO_CREATE);
registerReceiver(uiUpdated, new IntentFilter("SERVER_MESAGE"));
mBound = true;
}
Where the mConnection is defined that way:
private ServiceConnection mConnection = new ServiceConnection() {
#Override
public void onServiceConnected(ComponentName className,
IBinder service) {
CService.LocalBinder binder =(CService.LocalBinder) service;
mService = binder.getService();
Log.d("Service", "onServiceConnected");
mBound = true;
}
#Override
public void onServiceDisconnected(ComponentName arg0) {
Log.d("Service", "onServiceDisconnected");
mBound = false;
}
};
And in the onStop I unbindService:
#Override
protected void onStop() {
if (mBound) {
Log.d("ActivityStop", "Stoping activity");
unregisterReceiver(uiUpdated);
unbindService(mConnection);
mBound = false;
}
super.onStop();
}
The onBind in the service is that one:
#Override
public IBinder onBind(Intent intent) {
final String id_local = intent.getStringExtra("id_local");
final String id_send = intent.getStringExtra("id_send");
if (!misatgesList.isEmpty()) {
misatgesList.clear();
}
mBackGroundTimer.schedule(new TimerTask() {
#Override
public void run() {
String serverResult = restRecive(id_local, id_send,
misatgesList.size());
if (serverResult != null) {
misatgesList.addAll(procesMisatges(serverResult,
id_local));
Intent i = new Intent("SERVER_MESAGE");
i.putExtra("recive", serverResult);
sendBroadcast(i);
}
}
}, 0, 1000);
return mBinder;
}
And the onUnBind is that one:
#Override
public boolean onUnbind(Intent intent) {
mBackGroundTimer.cancel();
misatgesList.clear();
Log.d("ServiceOnUnBind", "ServiceOnUnBind");
//stopSelf();
return super.onUnbind(intent);
}
So my question would be, how I can bind again the service when the activity goes in again? Or what should I do to keep the binding alive until the user goes in the activity?
I found the solution!
What I meant was how to call again the onBind. That is done using the onRebind, that alows you to call again the onBind.
So, I created the onRebind:
#Override
public void onRebind(Intent intent) {
super.onRebind(intent);
}
Also, for the onRebind to work, you have to turn the return in the onUnbind to true.
#Override
public boolean onUnbind(Intent intent) {
mBackGroundTimer.cancel();
misatgesList.clear();
Log.d("ServiceOnUnBind", "ServiceOnUnBind");
//return super.onUnbind(intent);
return true;
}
For more explanation, check there: Bound Services
Use getApplicationContext() API when binding to your service from Activity as below:
getApplicationContext().bindService(intent, mConnection, Context.BIND_AUTO_CREATE);
getApplicationContext returns the global application context - the difference from other contexts is that for example, an activity context may be destroyed (or otherwise made unavailable) by Android when your activity ends. The Application context remains available all the while your Application object exists (which is not tied to a specific Activity)
I'm binding to an android Service as demonstrated in the JavaDoc
private boolean bound = false;
private MyService service = null;
private final ServiceConnection connection = new ServiceConnection() {
#Override
public void onServiceConnected(ComponentName name, IBinder service) {
Log.i(TAG, "Service connected");
service = (MyService) service;
}
#Override
public void onServiceDisconnected(ComponentName name) {
Log.i(TAG, "Service disconnected");
service = null;
}
};
#Override
public void onResume() {
super.onResume();
Intent intent = new Intent(this, MyService.class);
if (bindService(intent, connection, Context.BIND_ABOVE_CLIENT)) {
bound = true;
} else {
Log.w(TAG, "Service bind failed");
}
}
#Override
public void onPause() {
if (bound) {
unbindService(connection);
bound = false;
}
super.onPause();
}
Sometimes, the Service stops itself calling stopSelf or is stopped by stopService, resulting in all clients being unbound. But the variable bound here is still true, so onPause will throw the following Exception:
java.lang.IllegalArgumentException: Service not registered: de.ncoder.sensorsystem.android.app.MainActivity$1#359da29
at android.app.LoadedApk.forgetServiceDispatcher(LoadedApk.java:1022)
at android.app.ContextImpl.unbindService(ContextImpl.java:1802)
at android.content.ContextWrapper.unbindService(ContextWrapper.java:550)
at de.ncoder.sensorsystem.android.app.MainActivity.onPause(MainActivity.java:121)
at android.app.Activity.performPause(Activity.java:6044)
...
Is there a simple way to check if a Service is still bound and alive?
As far as I know, onServiceDisconnected will leave bindings active (as it is only called under extreme circumstances, where the Service is hopefully being restarted soon), so setting bound to false there won't help.
In the most situations you would like to have service running while an activity is bind to it. The solutions for this case - add flag BIND_AUTO_CREATE to service binding call and service will run until you call unbind even if stopService or stopSelf were called.
Otherwise, as far as I know, the only option is to catch the exception.
When you call stopSelf() in your service then your onSerivceDisconnected() will get called
So change bound value to false in onSerivceDisconnected() of your Activity
#Override
public void onServiceDisconnected(ComponentName name) {
Log.i(TAG, "Service disconnected");
bound=false;
service = null;
}
I have several Android Services that I want to bind to in my Activity, so I can monitor several actions from the user.
To be able to bind every Service, and I will have several, do I need several private ServiceConnections in my activity like the following?
/** Defines callbacks for service binding, passed to bindService() */
private ServiceConnection mConnection = new ServiceConnection() {
#Override
public void onServiceConnected(ComponentName className,
IBinder service) {
// We've bound to LocalService, cast the IBinder and get LocalService instance
GPSLocalBinder gpsBinder = (GPSLocalBinder) service;
PhotoLocalBinder photoBinder = (PhotoLocalBinder) service;
gpsService = gpsBinder.getService();
photoService = photoBinder.getService();
mGpsBound = true;
mPhotoBound = true;
}
#Override
public void onServiceDisconnected(ComponentName arg0) {
mGpsBound = false;
mPhotoBound = false;
}
};
Or do I need a manager class between my Activity and the Services that provides better usage and understanding of the bounded Services?
Is there a need to have one serviceConnection for each android
service?
I assume you're asking if you can reuse the same serviceConnection for multiple services. There's no need to have one for each service connection, but this is probably the best approach. I see in your code this
GPSLocalBinder gpsBinder = (GPSLocalBinder) service;
PhotoLocalBinder photoBinder = (PhotoLocalBinder) service;
gpsService = gpsBinder.getService();
photoService = photoBinder.getService();
This is very confusing... this seems like a service can be cast into two different services!!
You'll realize that the onServiceConnected callback is where most of the magic happens, where you (the Activity) finally can get a pointer to your Service and start calling methods and interact with your service. If you want to reuse the same serviceConnection for different services you'd need to find out which custom subclass the IBinder object belongs to and then cast appropriately. Ufff, too much trouble. I would recommend having one serviceConnection per service.
Or do i need a manager class between my activity and the services that
provides better usage and understanding of the bounded services?
For both this and your first question, you can do whatever you want. There's no approach better than the other (IMHO) and the best one is the one you understand better and makes you feel more comfortable.
A single ServiceConnection instance can be used for binding to multiple Services.
In ServiceConnection.onServiceConnected(), you'd have to check which service was bound (using className.getClassName() or className.getPackageName()) and put it in the appropriate field/variable, etc.
I used this thread as a reference, though I modified it to match my needs.
private static final int SERVICE_1_INDEX = 0;
private static final int SERVICE_2_INDEX = 1;
/** Array of the subclasses of {#link BaseService}s which have been bound */
private BaseService[] mServices;
/** ServiceConnection which handles the binding/unbinding of the services */
private MyServiceConnection mServiceConnection;
#Override
public void onViewCreated(View view, #Nullable Bundle savedInstanceState) {
super.onViewCreated(view, savedInstanceState);
mServiceConnection = new MyServiceConnection();
}
#Override
public void onResume() {
super.onResume();
bindServices();
}
#Override
public void onPause() {
super.onPause();
unbindServices();
}
private void bindServices() {
Intent service1Intent = new Intent(getActivity().getApplicationContext(), MyService1.class);
Intent service2Intent = new Intent(getActivity().getApplicationContext(), MyService2.class);
getContext().bindService(service1Intent, mServiceConnection, Context.BIND_AUTO_CREATE);
getContext().bindService(service2Intent, mServiceConnection, Context.BIND_AUTO_CREATE);
}
private void unbindServices() {
if (mServiceConnection != null) {
getContext().unbindService(mServiceConnection);
}
}
private class MyServiceConnection implements ServiceConnection {
public void onServiceConnected(ComponentName className, IBinder boundService ) {
Log.d("className(bound)", className.getClassName());
Log.d("className(Service1)", MyService1.class.getName());
Log.d("className(Service2)", MyService2.class.getName());
BaseService.LocalBinder binder = (BaseService.LocalBinder) boundService;
if (className.getClassName().equals(MyService1.class.getName())) {
mServices[SERVICE_1_INDEX] = binder.getService();
// call method on your service like:
// binder.getService().someMethod();
// (you may need to cast to your actual Service)
}
else {
mBaseServices[SERVICE_2_INDEX] = binder.getService();
// call method on the service like in if-block
}
}
public void onServiceDisconnected(ComponentName className) {
if (className.getClassName().equals(MyService1.class.getName())) {
mBaseServices[SERVICE_1_INDEX] = null;
}
else {
mBaseServices[SERVICE_2_INDEX] = null;
}
}
}
I start my service in onCreate() (if onCreate is called the first time) and call bindService in onStart(). The service probaply works, but after calling bindService my local instance of the service is still null. Furthermore, is seems to be that getService() is not called.?
Here is some code:
#Override
protected void onCreate(Bundle savedInstanceState) {
...
if(savedInstanceState == null){
final Intent i = new Intent(this, HostService.class);
startService(i);
}
}
protected void onStart(){
super.onStart();
bindService(new Intent(this, StartGameActivity.class), connection, Context.BIND_AUTO_CREATE);
}
private ServiceConnection connection = new ServiceConnection(){
#Override
public void onServiceConnected(ComponentName arg0, IBinder arg1) {
HostBinder binder = (HostBinder) arg1;
hostService = binder.getService();
isBound = true;
}
#Override
public void onServiceDisconnected(ComponentName arg0) {
isBound = false;
}
};
and in HostService:
...
private HostBinder binder = new HostBinder();
...
public class HostBinder extends Binder{
HostService getService(){
Log.d(TAG, "getService");
return HostService.this;
}
}
#Override
public IBinder onBind(Intent arg0) {
return binder;
}
Why is hostService still null, after onStart() is called and why is getService is not getting called ("getService" is not print in LogCat)?
thx & regards
You don't need to call startService(); it will be started by bindService().
In your onStart() method, you're creating an intent to launch StartGameActivity.class. Was that what you wanted, or did you mean to launch HostService.class?
If neither of those are your problem, we need more to go on. Can you put a logging statement inside your onServiceConnected() and onBind() methods so you can be sure they're called?
Any logcat messages that look interesting?
Are you talking to your service via the binder, or via messaging?
I got a problem with binding a service:
I use following code:
protected void onCreate(){
...
button.setOnClickListener(new OnClickListener(){
#Override
public void onClick(View v) {
if(mService != null)
Log.e(TAG, "is instantiated (onClick)!");
});
}
protected void onStart(){
super.onStart();
bindService(new Intent(this, HostService.class), connection, Context.BIND_AUTO_CREATE);
if(mService == null)
Log.e(TAG, "is null (onStart)!");
}
...
After starting my activity "is null (onStart)!" is printed in LogCat.
When I click the button "is instantiated (onClick)!" is printed.
Why bindService() doesnt instantiate my service-instance mService directly and how can I solve the problems referring to this?
thx & regards
Why bindService() doesn't instantiate my service-instance mService directly
bindService() is asynchronous, like many operations in Android, so it occurred after your test in onStart.
how can I solve the problems referring to this?
Put your business logic in onServiceConnected() of your ServiceConnection, instead of immediately after the bindService() call.
Here is an example of the ServiceConnection code:
private ServiceConnection sConn;
private Messenger messenger;
...
#Override
protected void onCreate(Bundle savedInstanceState) {
// Service Connection to handle system callbacks
sConn = new ServiceConnection() {
#Override
public void onServiceDisconnected(ComponentName name) {
messenger = null;
}
#Override
public void onServiceConnected(ComponentName name, IBinder service) {
// We are conntected to the service
messenger = new Messenger(service);
}
};
// We bind to the service
bindService(new Intent(this, ConvertService.class), sConn,
Context.BIND_AUTO_CREATE);
}
This is from Francesco Azzola's good example.