在上一个方法完成之前调用的方法

Question

I'm working on a simple translation app as part of a university project. For the translation process, I query MyMemory's Translate API using Retrofit and I retrieve the translated output as a String. This is working fine for the most part, but it's causing some issues in other areas of my program.

When I make a call to retrieve a translation from the library, subsequent methods begin to run before the translation is fully recieved - this then prevents those methods from working fully since they rely on the received translation.

Here are some relevant snippets of my code that might explain the question better:

TranslateAPI: (Interface that i use to retrieve a translation)

public class TranslateAPI {
private static final String ENDPOINT = "http://api.mymemory.translated.net";
public final static String FRENCH = "FR";
public final static String ENGLISH = "EN";
public final static String ITALIAN = "IT";
public final static String GREEK = "EL";
public final static String SPANISH = "ES";
private final TranslateService mService;
String translation = "";

public interface TranslateService {
    @GET("/get")
    Call<TranslatedData> getTranslation(
            @Query("q") String textToTranslate,
            @Query(value = "langpair", encoded = true)
            String languagePair);
}

public TranslateAPI() {
    Retrofit retrofit = new Retrofit.Builder()
            .baseUrl(ENDPOINT)
            .addConverterFactory(GsonConverterFactory.create())
            .build();
    mService = retrofit.create(TranslateService.class);
}

public String translate(final String textToTranslate, final String fromLanguage, final String toLanguage) {
    mService.getTranslation(textToTranslate, URLEncoder.encode(fromLanguage + "|" + toLanguage))
            .enqueue(new Callback<TranslatedData>() {

                @Override
                public void onResponse(Response<TranslatedData> response, Retrofit retrofit) {
                    String output =
                            String.format(response.body().responseData.translatedText);
                    String.format("Translation of: %s, %s->%s = %s", textToTranslate,
                            fromLanguage, toLanguage, response.body().responseData.translatedText);
                    System.out.println("Result: " + output);
                    translation = output;
                    System.out.println("The result of the field translation is: " + translation);
                }

                @Override
                public void onFailure(Throwable t) {
                    System.out.println("[DEBUG]" + " RestApi onFailure - " + "");
                }
            });
    return translation;
}

}

In the code above, the translate(final String textToTranslate, final String fromLanguage, final String toLanguage ) method successfully returns the translated output as a string.

Now, to demonstrate exactly what goes wrong, assume the following code snippet for my main activity:

private void runChatBot() {
    translateOutput(input, targetLanguage); //calls the translate method of the TranslateAPI class
    System.out.println("translatedOutput value in MainActivity: " + translatedOutput);
    //Use translated output here

}

What happens here is that the print statement in runChatbot() executes before the call to the translation API. This is not the desired behaviour, as I would like the translateOutput() method to execute fully before any following instructions.

Any help is much appreciated. Thanks in advance :)

UPDATE: Current code after initial answers

TranslateAPI - Declarations

public interface Callbacks {
    void onTranslationReceived(String result);
    void onTranslationFailed();
}

TranslateAPI - translate()

    public void translate(final String textToTranslate, final String fromLanguage, final String toLanguage) {
    mService.getTranslation(textToTranslate, URLEncoder.encode(fromLanguage + "|" + toLanguage))
            .enqueue(new Callback<TranslatedData>() {

                @Override
                public void onResponse(Response<TranslatedData> response, Retrofit retrofit) {
                    String output =
                            String.format(response.body().responseData.translatedText);
                    String.format("Translation of: %s, %s->%s = %s", textToTranslate,
                            fromLanguage, toLanguage, response.body().responseData.translatedText);
                    System.out.println("Result: " + output);
                    translation = output;
                    System.out.println("The result of the field translation is: " + translation);
                }

                @Override
                public void onFailure(Throwable t) {
                    System.out.println("[DEBUG]" + " RestApi onFailure - " + "");
                }
            });
}

MainActivity:

    @Override
public void onTranslationReceived(String result) {
    runChatBot();
}

@Override
public void onTranslationFailed() {
    //Handle failure here
}

public void runChatBot() {
    translatedOutput = translateAPI.getTranslation();
    System.out.println("translatedOutput value in MainActivity: " + translatedOutput);
    userOutputView.setText(translatedOutput);
    ttsResponse(translatedOutput, TTSLanguage);
    setVisualCue(chatBot.getVisualMatch());
    chatBot.clearResults();
}

Answer 1

Since your translate() method is asynchronous, you should define a callback in TranslateAPI to send the result back to your Activity when the result is received. By doing this, you would then only perform work on the translation result once you know you've received a response from TranslateAPI .

So in TranslateAPI you would define a callback interface:

public interface Callbacks {
    void onTranslationReceived(String result);
}

Then you would have your Activity implement TranslateAPI.Callbacks and implement the callback like this:

public void onTranslationReceived(String result) {
    //do something with the result
    runChatBot(result); //or something similar
}

Then, once you receive the response in the callback, you do whatever it is you have to do with the translation result. This way, you know you will never be executing anything on the translated result until the translation is complete.

EDIT IN RESPONSE TO COMMENTS

---

So in order to actually send the response to your Activity once the translate response is received, you need to pass a reference to your Activity into TranslateAPI . Since your Activity implements the callbacks, you can simply pass this in: TranslateAPI translateApi = new TranslateAPI(this);

Then in your TranslateAPI , you'll need to take this reference and use it as the "listener" of your callbacks. So in TranslateAPI you'll want to define a variable like this private Callbacks listener; and you'll assign this in your TranslateAPI constructor the value that's passed in from the Activity. So your TranslateAPI constructor might look like this:

public TranslateAPI(Callbacks listener) {
    Retrofit retrofit = new Retrofit.Builder()
            .baseUrl(ENDPOINT)
            .addConverterFactory(GsonConverterFactory.create())
            .build();
    mService = retrofit.create(TranslateService.class);

    //this is the line you would add...
    this.listener = listener;
}

And then in your onResponse() callback in TranslateAPI , you simply pass the value to the listener, which passes it back to the implemented method in your Activity. Like this:

@Override
public void onResponse(Response<TranslatedData> response, Retrofit retrofit) {
    String output = String.format(response.body().responseData.translatedText);
    String.format("Translation of: %s, %s->%s = %s", textToTranslate, fromLanguage, toLanguage, response.body().responseData.translatedText);
    System.out.println("Result: " + output);
    translation = output;
    System.out.println("The result of the field translation is: " + translation);

    //this is the line you would add...
    listener.onTranslateReceived(translation);
}

Hope this helps clarify things. Let me know if you have any more questions!

Answer 2

this happens because code is executed asynchronous. Your retrofit network request takes some time to complete, so by default, java will execute the next line of code before it concludes. To solve this you must use the retrofit callback onResponse and onFailure.

I sugest you to create a new interface and pass it on constructor os method of your TranslateApiCode. Something like:

public interface OnTranslate {
  void onSuccess(); // here you can pass any object you need later
  void onError(); // here you can pass any object you need later
}



public String translate(final String textToTranslate, final String fromLanguage, final String toLanguage) {
mService.getTranslation(textToTranslate, URLEncoder.encode(fromLanguage + "|" + toLanguage))
        .enqueue(new Callback<TranslatedData>() {

            @Override
            public void onResponse(Response<TranslatedData> response, Retrofit retrofit) {
                String output =
                        String.format(response.body().responseData.translatedText);
                String.format("Translation of: %s, %s->%s = %s", textToTranslate,
                        fromLanguage, toLanguage, response.body().responseData.translatedText);
                System.out.println("Result: " + output);
                translation = output;
                System.out.println("The result of the field translation is: " + translation);

                myOnTranslateVariable.onSuccess(); 


            }

            @Override
            public void onFailure(Throwable t) {
                System.out.println("[DEBUG]" + " RestApi onFailure - " + "");
                myOnTranslateVariable.onError();
            }
        });
return translation;
}


private void runChatBot() {
  translateOutput(input, targetLanguage, new OnTranslate() {
    void onSucess() {
      System.out.println("translatedOutput value in MainActivity: " +     translatedOutput);
    }
    void onError() {
      System.out.println("some error happened");
    }


  }); //calls the translate method of the TranslateAPI class

 //Use translated output here

}

Answer 3

Try Using Handler to notify when translation is completed and then perform the required operations. Thanks