Sequential AsyncTasks where each following use result from previous

I thought a bit about this and I was wondering which could be the best pattern to accomplish my request.

Real case:

I have many web calls which must be sequential and where every call must use the result of the previous. This is the concept of what I mean:

Suppose to have this db structure:

• User [id, server-side created info, infos]
• House [id, server-side created info, user ref, infos]
• Room [id, server-side created info, house ref, infos]

Suppose that with my app (offline) an user can create his user entity, N house entities and N room entities for each house.

Then, once done, the user is syncing data with server.

This is what should be done:

1. For each user, send user to webapi and read the server-side info.
2. For each house of the sent user, read the server-side info, send the house to webapi and read the server-side info.
3. For each room of the sent house, read the server-side info, send the room to webapi and read the server-side info.

This might be done this way:

• Create an AtomicInteger that is the count of all sync to be done.

Init this value with the sum of users, houses, rooms.

void syncDone() {
  if(totalSyncCounter.decrementAndGet() == 0){
    //sync finished, prompt user
  }
}

Create AsyncTasks

class SendUserToDbAsyncTask extends AsyncTask<User, Void, Integer> {

    UserSavedCallback _callback;

    public SendUserToDbAsyncTask(UserSavedCallback _callback) {
        this._callback = _callback;
    }

    @Override
    protected void onPreExecute() {
        super.onPreExecute();
    }

    @Override
    protected Integer doInBackground(User... users) {
        //save user and return the server-side value
        return serverSideInfo;
    }

    @Override
    protected void onPostExecute(Integer res) {
        super.onPostExecute(res);
        _callback.onResult(res);
    }
}

class SendHouseToDbAsyncTask extends AsyncTask<House, Void, Integer> {

    HouseSavedCallback _callback;

    public SendHouseToDbAsyncTask(HouseSavedCallback _callback) {
        this._callback = _callback;
    }

    @Override
    protected void onPreExecute() {
        super.onPreExecute();
    }

    @Override
    protected Integer doInBackground(House... houses) {
        //save user and return the server-side value
        return serverSideInfo;
    }

    @Override
    protected void onPostExecute(Integer res) {
        super.onPostExecute(res);
        _callback.onResult(res);
    }
}

class SendRoomToDbAsyncTask extends AsyncTask<User, Void, Integer> {

    RoomSavedCallback _callback;

    public SendRoomToDbAsyncTask(RoomSavedCallback _callback) {
        this._callback = _callback;
    }

    @Override
    protected void onPreExecute() {
        super.onPreExecute();
    }

    @Override
    protected Integer doInBackground(Room... rooms) {
        //save user and return the server-side value
        return serverSideInfo;
    }

    @Override
    protected void onPostExecute(Integer res) {
        super.onPostExecute(res);
        _callback.onResult(res);
    }
}

Logic:

void DoStuffs() {

  mySyncCounter = [users + houses + rooms];
  for (User user : users) {
    new SendUserToDbAsyncTask(new UserSavedCallback() {
      void onResult(){
        syncDone();
        for (House house : user.houses) {
          new SendHouseToDbAsyncTask(new HouseSavedCallback() {
            void onResult(){
              syncDone();
              for (Room room : house.rooms) {
                new SendRoomToDbAsyncTask(new RoomSavedCallback() {
                  void onResult(){
                    syncDone();
                }).execute(room);
              }
          }).execute(house);
        }
    }).execute(user);
  }
}

Obiouvsly it is just an example hand-wrote here on SO. I just want to make you get the point. I know I can make a single callback for all, init it outside the method, just create a single asynctask for everything, etc... but I'm not looking for any suggestion about optimizing this specific code, I just want to know how to perform multiple sequential async operations where every following operation use the return of the previous.

What is the best way for performing this kind of operations?

Is there a "cleaner" way of doing it?

Thanks

If I understand correctly.<br>
You could use ExecutorService to make calls to the sync server, and Semaphore to stop the thread as you like.<br>
Only you will have to use AsyncTask anyway, because the calls would only fail with ExecutorService