Come definire i callback in Android?

Durante l'ultimo IO di Google, è stata presentata una presentazione sull'implementazione di applicazioni client riposanti. Sfortunatamente, è stata solo una discussione di alto livello senza codice sorgente dell'implementazione.

In questo diagramma, sul percorso di ritorno ci sono vari callback diversi ad altri metodi.

Come dichiaro quali sono questi metodi?

Capisco l'idea di un callback - un pezzo di codice che viene chiamato dopo che si è verificato un determinato evento, ma non so come implementarlo. L'unico modo in cui ho implementato i callback finora è stato scavalcando vari metodi (ad esempio onActivityResult).

Mi sembra di avere una conoscenza di base del modello di progettazione, ma continuo a rimanere incastrato su come gestire il percorso di ritorno.

In molti casi, hai un'interfaccia e passi lungo un oggetto che lo implementa. Le finestre di dialogo, ad esempio, hanno OnClickListener.

Proprio come un esempio casuale:

// 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
   }
};

Probabilmente ho incasinato la sintassi nell'opzione 2. È presto.

Quando succede qualcosa a mio avviso, spengo un evento che la mia attività è in ascolto:

// DICHIARATO IN (CUSTOM) VISTA

    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;
    }

// DICHIARATO IN ATTIVITÀ

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

Se vuoi saperne di più sulla comunicazione (callback) tra i frammenti vedi qui: http://developer.android.com/guide/components/fragments.html#CommunicatingWithActivity

Non c'è bisogno di definire una nuova interfaccia quando si può usare uno esistente: android.os.Handler.Callback. Passa un oggetto di tipo Callback e invoca callback handleMessage(Message msg).

Esempio per implementare il metodo di callback usando l'interfaccia.

Definire l'interfaccia, NewInterface.java .

pacchetto javaapplication1;

public interface NewInterface {
    void callback();
}

Crea una nuova classe, NewClass.java . Chiamerà il metodo di callback nella classe principale.

package javaapplication1;

public class NewClass {

    private NewInterface mainClass;

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

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

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

La classe principale, JavaApplication1.java, per implementare l'interfaccia NewInterface - metodo callback (). Creerà e chiamerà l'oggetto NewClass. Quindi, l'oggetto NewClass richiamerà a sua volta il metodo callback ().

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");
    }

}

per chiarire un po 'la risposta del drago (dal momento che mi ci è voluto un po' per capire cosa fare con Handler.Callback):

Handlerpuò essere utilizzato per eseguire callback nel thread corrente o in un altro, passandolo Message. i Messagedati di conservazione da utilizzare dal callback. a Handler.Callbackpuò essere passato al costruttore di Handlerper evitare di estendere direttamente l'handler. quindi, per eseguire un po 'di codice tramite callback dal thread corrente:

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: appena realizzato c'è un modo migliore per ottenere lo stesso risultato (meno il controllo di esattamente quando eseguire il callback):

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

È inoltre possibile utilizzare LocalBroadcastper questo scopo. Ecco una breve guida

Creare un ricevitore di trasmissione:

   LocalBroadcastManager.getInstance(this).registerReceiver(
            mMessageReceiver, new IntentFilter("speedExceeded"));

private BroadcastReceiver mMessageReceiver = new BroadcastReceiver() {
    @Override
    public void onReceive(Context context, Intent intent) {
        String action = intent.getAction();
        Double currentSpeed = intent.getDoubleExtra("currentSpeed", 20);
        Double currentLatitude = intent.getDoubleExtra("latitude", 0);
        Double currentLongitude = intent.getDoubleExtra("longitude", 0);
        //  ... react to local broadcast message
    }

Ecco come attivarlo

Intent intent = new Intent("speedExceeded");
intent.putExtra("currentSpeed", currentSpeed);
intent.putExtra("latitude", latitude);
intent.putExtra("longitude", longitude);
LocalBroadcastManager.getInstance(this).sendBroadcast(intent);

unRegistra ricevitore in onPause:

protected void onPause() {
  super.onPause();
  LocalBroadcastManager.getInstance(this).unregisterReceiver(mMessageReceiver);
}