Wie definiert man Rückrufe in Android?

Question

Auf der letzten Google IO gab es einen Vortrag über die Implementierung von Restful-Client-Anwendungen. Leider war es nur eine Diskussion auf hohem Niveau ohne Quellcode der Implementierung.

In diesem Diagramm gibt es auf dem Rückweg verschiedene Rückrufe zu anderen Methoden.

Wie erkläre ich, um welche Methoden es sich handelt?

Ich verstehe die Idee eines Rückrufs - ein Stück Code, das aufgerufen wird, nachdem ein bestimmtes Ereignis eingetreten ist, aber ich weiß nicht, wie man es implementiert. Die einzige Möglichkeit, wie ich bisher Rückrufe implementiert habe, war das Überschreiben verschiedener Methoden (onActivityResult zum Beispiel).

Ich habe das Gefühl, dass ich ein grundlegendes Verständnis des Entwurfsmusters habe, aber ich stolpere immer wieder darüber, wie ich den Rückweg behandeln soll.

Answer 1

In vielen Fällen haben Sie eine Schnittstelle und geben ein Objekt weiter, das diese Schnittstelle implementiert. Dialoge haben zum Beispiel den OnClickListener.

Nur ein zufälliges Beispiel:

// The callback interface
interface MyCallback {
    void callbackCall();
}

// The class that takes the callback
class Worker {
   MyCallback callback;

   void onEvent() {
      callback.callbackCall();
   }
}

// Option 1:

class Callback implements MyCallback {
   void callbackCall() {
      // callback code goes here
   }
}

worker.callback = new Callback();

// Option 2:

worker.callback = new MyCallback() {

   void callbackCall() {
      // callback code goes here
   }
};

Wahrscheinlich habe ich bei Option 2 die Syntax durcheinander gebracht. Es ist noch früh.

Answer 2

Wenn in meiner Ansicht etwas passiert, löse ich ein Ereignis aus, auf das meine Aktivität wartet:

// DEKLARIERT IN DER (BENUTZERDEFINIERTEN) ANSICHT

    private OnScoreSavedListener onScoreSavedListener;
    public interface OnScoreSavedListener {
        public void onScoreSaved();
    }
    // ALLOWS YOU TO SET LISTENER && INVOKE THE OVERIDING METHOD 
    // FROM WITHIN ACTIVITY
    public void setOnScoreSavedListener(OnScoreSavedListener listener) {
        onScoreSavedListener = listener;
    }

// ERKLÄRT IN AKTIVITÄT

    MyCustomView slider = (MyCustomView) view.findViewById(R.id.slider)
    slider.setOnScoreSavedListener(new OnScoreSavedListener() {
        @Override
        public void onScoreSaved() {
            Log.v("","EVENT FIRED");
        }
    });

Wenn Sie mehr über die Kommunikation (Rückrufe) zwischen Fragmenten erfahren möchten, lesen Sie hier: http://developer.Android.com/guide/components/fragments.html#CommunicatingWithActivity

Answer 3

Es ist nicht nötig, eine neue Schnittstelle zu definieren, wenn man eine bestehende verwenden kann: android.os.Handler.Callback . Übergeben Sie ein Objekt vom Typ Callback, und rufen Sie die Callback-Funktion handleMessage(Message msg) .

Answer 4

Beispiel für die Implementierung einer Callback-Methode über eine Schnittstelle.

Definieren Sie die Schnittstelle, NewInterface.java .

Paket javaapplication1;

public interface NewInterface {
    void callback();
}

Erstellen Sie eine neue Klasse, NewClass.java . Es wird die Callback-Methode in der Hauptklasse aufrufen.

package javaapplication1;

public class NewClass {

    private NewInterface mainClass;

    public NewClass(NewInterface mClass){
        mainClass = mClass;
    }

    public void calledFromMain(){
        //Do somthing...

        //call back main
        mainClass.callback();
    }
}

Die Hauptklasse, JavaApplication1.java, implementiert die Schnittstelle NewInterface - callback() Methode. Sie wird das Objekt NewClass erstellen und aufrufen. Dann ruft das NewClass-Objekt seinerseits die callback()-Methode auf.

package javaapplication1;
public class JavaApplication1 implements NewInterface{

    NewClass newClass;

    public static void main(String[] args) {

        System.out.println("test...");

        JavaApplication1 myApplication = new JavaApplication1();
        myApplication.doSomething();

    }

    private void doSomething(){
        newClass = new NewClass(this);
        newClass.calledFromMain();
    }

    @Override
    public void callback() {
        System.out.println("callback");
    }

}

Answer 5

Um die Antwort von dragon ein wenig zu verdeutlichen (da ich eine Weile gebraucht habe, um herauszufinden, was man mit Handler.Callback ):

Handler kann verwendet werden, um Rückrufe im aktuellen oder einem anderen Thread auszuführen, indem man es Message s. die Message enthält Daten, die vom Rückruf verwendet werden sollen. a Handler.Callback kann an den Konstruktor von Handler um zu vermeiden, dass Handler direkt erweitert wird, um also Code per Callback vom aktuellen Thread auszuführen:

Message message = new Message();
<set data to be passed to callback - eg message.obj, message.arg1 etc - here>

Callback callback = new Callback() {
    public boolean handleMessage(Message msg) {
        <code to be executed during callback>
    }
};

Handler handler = new Handler(callback);
handler.sendMessage(message);

EDIT: gerade realisiert, es gibt einen besseren Weg, um das gleiche Ergebnis zu erhalten (abzüglich der Kontrolle über genau, wenn der Rückruf ausgeführt wird):

post(new Runnable() {
    @Override
    public void run() {
        <code to be executed during callback>
    }
});