Come definire le callback in Android?


Answers

Quando succede qualcosa a mio avviso, sparo un evento che la mia attività sta ascoltando:

// VISTA DICHIARATA (PERSONALIZZATA)

    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 NELL'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: developer.android.com/guide/components/…

Question

Durante il più recente Google IO, c'era una presentazione sull'implementazione di applicazioni client restful. Sfortunatamente, era solo una discussione di alto livello senza codice sorgente dell'implementazione.

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

Come dichiaro quali sono questi metodi?

Capisco l'idea di un callback - un pezzo di codice che viene chiamato dopo che è accaduto un certo evento, ma non so come implementarlo. L'unico modo in cui ho implementato le richiamate finora è stato l'override di vari metodi (ad esempio, adActivityResult).

Mi sento come se avessi una comprensione di base del modello di progettazione, ma continuo a essere inciampato su come gestire il percorso di ritorno.




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

Handler può essere utilizzato per eseguire callback nel corrente o in un altro thread, passandogli Message s. il Message contiene i dati da utilizzare dalla richiamata. un Handler.Callback può essere passato al costruttore di Handler per evitare di estendere direttamente Handler. quindi, per eseguire qualche 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 LocalBroadcast per questo scopo. Ecco una rapida quide

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

È così che puoi attivarlo

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

unRegister ricevitore in onPause:

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