Calling Webservice with consistent behavior in android

Question

I know how to save states and restore them, but I just get confused when I have to do work with the Web services and to update UI. For times I was using the AsyncTask but then I came to point where I loose my activity/fragment context for example when I rotate the device. So in this way, I am thinking how other apps are handling such situations.

If I use the IntentService and call my web service from there, then I came to think that for each web service I have to make IntentService differently, and update the UI of each activity and fragment I have to make the BroadcastReceiver for each activity and fragments.

So what is a good practice for calling web service from the activity and the fragments?

How can I Update UI when the service return arrives (or call next service based on first services results)?

Answer 1

I noticed a comment you made:

...and my webservices are soap and I cant change them

The way I'm currently calling my web service, which is also SOAP, is via an Intent. I do this by passing in the data that I'm submitting to the Web service with putExtra then receiving it on my WebService, as you probably do right now. I then get the result from that web call and process it inside an AsyncTask, the async task will then utilize EventBus to post to Results as needed which are received on my MainThread via ThreadMode.Main.

So with that said, I highly recommend the use of a library called EventBus from Greenrobot.

You greatly simplify communication between Activities and Fragments, You can get started immediately using a default EventBus instance available from anywhere in your code. For example, you can do the following.

EventBus.getDefault().post(new ModelForOtherActivityToSee(data));

In the model, you can include anything you want, and react accordingly when received.

The best part is that when received, EventBus handles how the data will be executed by either running ASYNC, MAIN, BACKGROUND

• ASYNC - Event handler methods are called in a separate thread. This is always independent from the posting thread and the main thread. Posting events never wait for event handler methods using this mode. Event handler methods should use this mode if their execution might take some time, e.g. for network access. Avoid triggering a large number of long-running asynchronous handler methods at the same time to limit the number of concurrent threads. EventBus uses a thread pool to efficiently reuse threads from completed asynchronous event handler notifications.

• Background - Subscribers will be called in a background thread. If posting thread is not the main thread, event handler methods will be called directly in the posting thread. If the posting thread is the main thread, EventBus uses a single background thread that will deliver all its events sequentially. Event handlers using this mode should try to return quickly to avoid blocking the background thread.

• MAIN -Subscribers will be called in Android’s main thread (sometimes referred to as UI thread). If the posting thread is the main thread, event handler methods will be called directly (synchronously like described for ThreadMode.POSTING). Event handlers using this mode must return quickly to avoid blocking the main thread.

An example of receiving an event broadcasted from EventBus:

//ThreadMode can be ASYNC, MAIN, BACKGROUND
@Subscribe(threadMode = ThreadMode.MAIN)  
public void onMessageEvent(ModelForOtherActivityToSee eventModel) {
   /* Do something with eventModel received, this runs on UI thread */
};

Full example on how to use EventBus:

1 - Open your build.gradle for the app and set your dependency for EventBus:

dependencies { compile 'org.greenrobot:eventbus:3.0.0'}

2 - Create your first model to use in publishing an EventBus, I will use a very simplistic example of a model:

package com.myapp.models.eventbusmodels;

public final class EventBusMyModel {
    private final String dataRaw

    public EventBusMyModel(final String rawData) {
        this.dataRaw = rawData;
    }

    public String getRawData() {
        return this.dataRaw;
    }
}

3 - Now all that's left is pushing out a broadcast by using from anywhere.

EventBus.post(new EventBusModel("My Data here"));

4 - To enable Activities/Fragments to receive events from EventBus you must attach and detach, this is what I mean. From inside an Activity on the onResume() and onStop() overrides:

public class SomeActivity {
    @Override
    protected void onResume() {
        if(!EventBus.getDefault().isRegistered(this))
            EventBus.getDefault().register(this);
    }

    @Override
    protected void onStop() {
        if(EventBus.getDefault().isRegistered(this))
            EventBus.getDefault().unregister(this);
        super.onStop();
    }
}

5 - The final thing to do is receive that broadcast, you can receive it in Any Fragment, Activity, or in all your fragments/activities. Here's an example from inside the SomeActivity:

@Subscribe(threadMode = ThreadMode.MAIN)
public void eventThisNameDoesNotMatter(final EventBusMyModel resultModel) {
   String receivedData = resultModel.getRawData();
   //Do whatever with receivedData. Since we are on ThreadMode.MAIN, this is on the UI thread.
}

Answer 2

If you want your data to be instantly available through configuration changes (which you do), then you probably want to use Loaders.

It gives the developer a mechanism of loading data asynchronously for an activity or fragment. Since loaders are specifically designed to solve the issue of async loading, one does not have to spend too much time designing async tasks to handle all different scenarios efficiently.

Good article about Loaders https://medium.com/google-developers/making-loading-data-on-android-lifecycle-aware-897e12760832

Answer 3

Try using retrofit. It's a great networking libraries for Android apps and it's easy to use.

The entire network call + JSON/XML parsing is completely handled by it (with help from Gson for JSON parsing). Documentation is great and the community is huge.

check out this sample.