Communication between service and intentservice

Question

I am new to Android development, and I try to get some practice with service and intentservice.

This is my service class:

public class MyBaseService extends Service {

private double[] returnData;

public MyBaseService() {
}

@Override
public void onCreate() {
    returnData = new double[//dataSise];
}

/** The service is starting, due to a call to startService() */
@Override
public int onStartCommand(Intent intent, int flags, int startId) {
    try {
        for (Map.Entry<Integer, Double[]> mapEntry : dataMap.entrySet()) {

            doXYZ(mapEntry.getValue());
            Arrays.sort(returnData);
        }
    } catch (IOException e) {
        e.printStackTrace();
    }

    Intent intents = new Intent();
    intents.setAction(ACTION_SEND_TO_ACTIVITY);
    sendBroadcast(intents);
    return START_STICKY;
}

/** A client is binding to the service with bindService() */
@Override
public IBinder onBind(Intent arg0) {
    return mBinder;
}

public class MyBinder extends Binder {
    public MyBaseService getService() {
        return MyBaseService.this;
    }
}

/** Called when a client is binding to the service with bindService()*/
@Override
public void onRebind(Intent intent) {

}

/** Called when The service is no longer used and is being destroyed */
@Override
public void onDestroy() {
    super.onDestroy();
}


private void doXYZ(double[] data) {
    int gallerySize = galleryFiles.length;

    for (int i=0; i<data.length; ++i) {
        Intent cfIntent = new Intent(this, MyIntentService.class);
        compareFeatureIntent.putExtra(MyIntentService.COMPARING_INDEX, i);
        startService(cfIntent);
    }

}

BroadcastReceiver mReceiver;

// use this as an inner class like here or as a top-level class
public class MyReceiver extends BroadcastReceiver {

    @Override
    public void onReceive(Context context, Intent intent) {
        int index = intent.getIntExtra(MyIntentService.COMPARING_INDEX, 0);
        double scores = intent.getDoubleArrayExtra(MyIntentService.COMPARING_SCORE);
        data[index] = scores[0];
    }

    // constructor
    public MyReceiver(){
    }
}

}

And this is intentservice class:

public class MyIntentService extends IntentService {
protected static final String ACTION_COMPARE_FEATURES = "CompareFeatures";
protected static final String COMPARING_SCORE = "Score";
protected static final String COMPARING_INDEX = "Index";

public MyIntentService() {
    super("MyIntentService");
}

@Override
protected void onHandleIntent(Intent intent) {

    int index = (int)intent.getLongExtra(COMPARING_INDEX, 0);

    // This is long operation
    double[] scores = getScores(index);

    Intent intents = new Intent();
    intents.setAction(ACTION_COMPARE_FEATURES);
    intent.putExtra(COMPARING_SCORE, scores);
    intent.putExtra(COMPARING_INDEX, index);
    sendBroadcast(intents);
}

}

The scenario is that I want to start MyBaseService class inside main activity. Inside MyBaseService, I need to do a long run operation and need to iterate that operation many times. So, I put that long operation in MyIntentService, and start MyIntentService in a loop.

MyIntentService will produce some data, and I want to get that data back in MyBaseService class to do some further operations.

The Problem I am facing with communication between MyBaseService and MyIntentService. Because MyBaseService will start MyIntentSerice many times, my initial solution is to sendBroadcast() from MyIntentService, and register receiver in MyBaseService.

So, my questions are:

1. Is my design with MyBaseService MyIntentService efficient? If not, how should I do to archive the result I want?

2. If sendBroadcast() is a right direction, how should I register in MyBaseService?

Answer 1

Your architecture is fine. There are several ways to do this but this approach is OK.

You can register the BroadcastReceiver in MyBaseSerice.onStartCommand() and unregister it in MyBaseService.onDestroy().

You will need to determine how to shutdown MyBaseService. Either the Activity can do it or MyBaseService will need to keep track of the number of replies it is waiting for from the IntentService and as soon as it gets the last one it can shut itself down by calling stopSelf().