Getting Java.lang.classcastexception: Android.os.binderproxy Every Time I Declare And Run Two Services

I am encountering following binder.proxy exception every time i declare and run two services. One service runs in different Process(Private to app) and another service runs in sam

Solution 1:

Ran into this issue (local service returning a BinderProxy), wanted to post what I'd found since I found this page while trying to debug. The short version as a run on sentence: starting a remote service creates a second instance of your Application class in a new process which then tries to bind to the local service that was started by the original Application instance as if it was a local service but since the service is running in the original process it's binding across processes and you get a BinderProxy instead of your expected Binder class.

There's a few things to keep in mind about Android services. Every service has an assigned process it will run in. If you don't assign a process in your Android Manifest it will run in the default process (the process where the Application, Activities, etc are run). Not giving a process name doesn't mean that it will run the service in the same process that you're binding to/starting the service from.

Let's say I have a MyApplication class which attempts to bind to two services on start up: one service running in the default process (we'll call this the LocalService), one running in a separate process (the RemoteService).

The user launches my app which creates a MyApplication instance in the default process. This instance then tries to bind to the LocalService. Android creates the LocalService in the default process and returns the LocalService's Binder class to the app (mBinder = (LocalBinder) service;). That's all good, we've successfully bound to the LocalService.

Next the app tries to bind to the RemoteService. Android creates a new process with the name you've supplied in the Android Manifest. However, before it can create the RemoteService it needs to create an Application for the service to run in. It creates a new MyApplication instance in the remote process and starts that up.

However, that new MyApplication instance running in a separate process tries to bind to the LocalService during start up. Because the LocalService is running in the default process this is a cross process binding but MyApplication expects this to be an in process binding. Android returns a BinderProxy, the second MyApplication instance tries to cast it to a LocalBinder and crashes. The fun part is that it crashes in a different process so your app and activity can actually continue running. You'll just never be able to bind to the remote service.

If you want to bind to a local service with an Application context and also use a remote service you'll need to handle the fact that Android will create another Application in the remote process when starting the remote service. I haven't bothered to try this (I just made my remote service a local service), but you could probably check the process name during the application's on create and not bind if it's not the default process.

Solution 2:

Found an answer after doing some research and debugging,

If we create and bind any service to a MainApplication class(then service gets binded to whole ApplicationContext or BaseContext) and if same application contains other services which are binded to Activity specific Context(s),

//Declared in MainApplication@OverridepublicvoidonServiceConnected(ComponentName className, IBinder service) {
                mBinder = (LocalBinder) service;
     }

In OnServiceConnected() We will get binder object for both the Services( SecondService Started in MainApplication(registered with BaseContext will get local binderObject) class and FirstService started MainActivity(will get android.os.binderProxyObject hence causing ClassCastException).

• So, to fix this issue one has to start all the application services from any Activity Context rather than using any Global Application Context. Also this issue is independent of the Processes

• Hence, I moved both SecondService and FirstService into MainActivity Context which fixed the issue.

MainActivity.java

privateButton mLanchServiceBtn;
    privateSecondService.LocalBinder mBinder;
    privateServiceConnection mConnection = newServiceConnection() {
            @OverridepublicvoidonServiceConnected(ComponentName className, IBinder service) {
                mBinder = (LocalBinder) service;
            }
            @OverridepublicvoidonServiceDisconnected(ComponentName arg0) {
            }
     };
        @OverrideprotectedvoidonCreate(Bundle savedInstanceState) {
            super.onCreate(savedInstanceState);
            setContentView(R.layout.activity_main);

            mLanchServiceBtn=(Button) findViewById(R.id.launch_btn);

            mLanchServiceBtn.setOnClickListener(this);



            //starting second service in activityIntent launch=newIntent(this,SecondService.class);
            startService(launch);

            //Binding to it bindService(launch, mConnection, BIND_AUTO_CREATE);
        }


        @OverridepublicbooleanonCreateOptionsMenu(Menu menu) {
            // Inflate the menu; this adds items to the action bar if it is present.getMenuInflater().inflate(R.menu.main, menu);
            returntrue;
        }

        @OverridepublicbooleanonOptionsItemSelected(MenuItem item) {
            int id = item.getItemId();
            if (id == R.id.action_settings) {
                returntrue;
            }
            returnsuper.onOptionsItemSelected(item);
        }


        @OverridepublicvoidonClick(View v) {

           //Starting FirstService also from MainActivityIntent launch=newIntent(this,FirstService.class);
            startService(launch);

        }
    }

Solution 3:

You can't call directly any methods of your remote services (or cast) because they live in different process so you can't get a reference to it's instance. But Android has specific interfaces to handle this interprocess communications (IPC). The easiest way is using android.os.Messenger (another is AIDL, more complex).

On your Service, your implementation of Service#onBind() will be a little bit different:

overridefunonBind(intent: Intent): IBinder? {
    mMessenger = Messenger(YourServiceHandler())
    return mMessenger.binder
}

And on your Activity implementation of ServiceConnection#onServiceConnected(serviceBinder: IBinder) you will not get a directly reference to your remote service instance, but instead create a Messenger that have a send(message: Message) interface so you can remotelly call the service functions:

overridefunonServiceConnected(className: ComponentName, service: IBinder) {
     mServiceMessenger = Messenger(service)
}

overridefunonCreate(){
    doStuff1Button.setOnClickListener{
         val msg = Message.obtain(null, YourRemoteService.MESSAGE_DO_STUFF_1, 0, 0)
         mServiceMessenger.send(msg)
    }
    doStuff1Button.setOnClickListener{
         val msg = Message.obtain(null, YourRemoteService.MESSAGE_DO_STUFF_2, 0, 0)
         mServiceMessenger.send(msg)
    }
}

Note that in the message is going a argument do stuff 1 or 2. You will get this back on your service handler Handler#onHandleMessage(message: Message) with the attribute what:

overridefunhandleMessage(message: Message) {
    when (message.what) {
         MESSAGE_DO_STUFF_1 -> doStuff1()
         MESSAGE_DO_STUFF_2 -> doStuff2()
    }
}

Complete guide can be found in this official documentation

Solution 4:

I tried above all solutions but none of those worked. If anyone was stuck same as myself try this based on @Coeffect answer. In my scenario service clients doesn't belong to my current application(process)

@OverridepublicvoidonServiceConnected(ComponentName className, IBinder service) {
       mBinder = LocalBinder.Stub.asInterface(service);
}