numeros - Cómo definir rellamadas en Android

como bloquear un contacto en el celular

Question

Durante el Google IO más reciente, hubo una presentación sobre la implementación de aplicaciones de cliente relajantes. Desafortunadamente, fue solo una discusión de alto nivel sin un código fuente de la implementación.

En este diagrama, en la ruta de retorno hay varias devoluciones de llamada diferentes a otros métodos.

¿Cómo declaro cuáles son estos métodos?

Entiendo la idea de una devolución de llamada: un fragmento de código que se llama después de que se haya producido un determinado evento, pero no sé cómo implementarlo. La única forma en que he implementado devoluciones de llamada hasta ahora ha sido la anulación de varios métodos (en el resultado de la actividad, por ejemplo).

Siento que tengo una comprensión básica del patrón de diseño, pero sigo tropezando con la forma de manejar la ruta de retorno.

Answer 1

Cuando sucede algo, desde mi punto de vista disparo un evento que mi actividad está escuchando:

// DECLARED IN (CUSTOM) VIEW

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

// DECLARADO EN ACTIVIDAD

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

Si desea obtener más información sobre la comunicación (devoluciones de llamada) entre fragmentos, consulte aquí: developer.android.com/guide/components/…

Answer 2

Ejemplo para implementar el método de devolución de llamada usando la interfaz.

Definir la interfaz, NewInterface.java .

paquete javaapplication1;

public interface NewInterface {
    void callback();
}

Crea una nueva clase, NewClass.java . Llamará al método de devolución de llamada en la clase principal.

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 clase principal, JavaApplication1.java, para implementar la interfaz NewInterface - callback () método. Creará y llamará al objeto NewClass. Luego, el objeto NewClass volverá a llamar su método de devolución de llamada ().

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 3

En muchos casos, tiene una interfaz y transmite un objeto que la implementa. Los cuadros de diálogo, por ejemplo, tienen OnClickListener.

Solo como un ejemplo al azar:

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

Probablemente arruiné la sintaxis en la opción 2. Es temprano.

Answer 4

No es necesario definir una nueva interfaz cuando puede usar una existente: android.os.Handler.Callback . Pase un objeto de tipo Callback e invoque el handleMessage(Message msg) la devolución de handleMessage(Message msg) .

Answer 5

También puede usar LocalBroadcast para este propósito. Aquí hay una guía rápida

Crear un receptor de difusión:

   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
    }

Así es como puedes dispararlo

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

unRegister receptor en onPause:

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

Answer 6

para aclarar un poco la respuesta de Dragon (ya que me llevó un tiempo averiguar qué hacer con Handler.Callback ):

Handler se puede usar para ejecutar devoluciones de llamada en el hilo actual o en otro, pasándolo Message s. el Message contiene datos que se utilizarán a partir de la devolución de llamada. un Handler.Callback se puede pasar al constructor de Handler para evitar extender Handler directamente. por lo tanto, para ejecutar algún código a través de una devolución de llamada desde el hilo actual:

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

EDITAR: acaba de darse cuenta de que hay una mejor manera de obtener el mismo resultado (menos el control de exactamente cuándo ejecutar la devolución de llamada):

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