Android equivalente a NSNotificationCenter

Question

En el proceso de portar una aplicación de iPhone a Android, estoy buscando la mejor manera de comunicarse dentro de la aplicación. Intenciones parecen ser el camino a seguir, es esta la mejor opción (sólo)? NSUserDefaults parece de peso mucho más ligero que Intentos hacen tanto en rendimiento y codificación.

También me gustaría añadir que tengo una subclase solicitud de estado, pero tengo que hacer otra actividad consciente de un evento.

Answer 1

Usted podría intentar esto: http://developer.android.com/reference /java/util/Observer.html

Answer 2

La mejor encontrado equivalente I es LocalBroadcastManager que es parte de la < a href = "http://developer.android.com/sdk/compatibility-library.html"> paquete de compatibilidad con Android .

A partir de la documentación LocalBroadcastManager:

ayudante para inscribirse y enviar transmisiones de intentos de objetos locales dentro de su proceso. Esto se tiene una serie de ventajas sobre el envío de transmisiones globales con sendBroadcast (Intención):

• Usted sabe que los datos se están transmitiendo no van a salir de su aplicación, por lo que no necesita preocuparse por fugas de datos privados.
• No es posible para otras aplicaciones que envían estas transmisiones a su aplicación, por lo que no es necesario que preocuparse de tener agujeros de seguridad que pueden explotar.
• Es más eficiente que el envío de una emisión global a través del sistema.

Al utilizar esto, se puede decir que un Intent es un equivalente a un NSNotification. He aquí un ejemplo:

ReceiverActivity.java

Una actividad que los relojes de las notificaciones para el evento llamado "custom-event-name".

@Override
public void onCreate(Bundle savedInstanceState) {

  ...

  // Register to receive messages.
  // This is just like [[NSNotificationCenter defaultCenter] addObserver:...]
  // We are registering an observer (mMessageReceiver) to receive Intents
  // with actions named "custom-event-name".
  LocalBroadcastManager.getInstance(this).registerReceiver(mMessageReceiver,
      new IntentFilter("custom-event-name"));
}

// Our handler for received Intents. This will be called whenever an Intent
// with an action named "custom-event-name" is broadcasted.
private BroadcastReceiver mMessageReceiver = new BroadcastReceiver() {
  @Override
  public void onReceive(Context context, Intent intent) {
    // Get extra data included in the Intent
    String message = intent.getStringExtra("message");
    Log.d("receiver", "Got message: " + message);
  }
};

@Override
protected void onDestroy() {
  // Unregister since the activity is about to be closed.
  // This is somewhat like [[NSNotificationCenter defaultCenter] removeObserver:name:object:] 
  LocalBroadcastManager.getInstance(this).unregisterReceiver(mMessageReceiver);
  super.onDestroy();
}

SenderActivity.java

La segunda actividad que envía / transmite notificaciones.

@Override
public void onCreate(Bundle savedInstanceState) {

  ...

  // Every time a button is clicked, we want to broadcast a notification.
  findViewById(R.id.button_send).setOnClickListener(new View.OnClickListener() {
    @Override
    public void onClick(View v) {
      sendMessage();
    }
  });
}

// Send an Intent with an action named "custom-event-name". The Intent sent should 
// be received by the ReceiverActivity.
private void sendMessage() {
  Log.d("sender", "Broadcasting message");
  Intent intent = new Intent("custom-event-name");
  // You can also include some extra data.
  intent.putExtra("message", "This is my message!");
  LocalBroadcastManager.getInstance(this).sendBroadcast(intent);
}

Con el código anterior, cada vez que se hace clic en el botón R.id.button_send, un Intento se transmite y se recibe por mMessageReceiver en ReceiverActivity.

La salida de depuración debería tener este aspecto:

01-16 10:35:42.413: D/sender(356): Broadcasting message
01-16 10:35:42.421: D/receiver(356): Got message: This is my message! 

Answer 3

Aquí es algo similar a la respuesta @Shiki, pero desde el ángulo de los desarrolladores de iOS y el centro de notificaciones.

En primer lugar crear algún tipo de servicio NotificationCenter:

public class NotificationCenter {

 public static void addObserver(Context context, NotificationType notification, BroadcastReceiver responseHandler) {
    LocalBroadcastManager.getInstance(context).registerReceiver(responseHandler, new IntentFilter(notification.name()));
 }

 public static void removeObserver(Context context, BroadcastReceiver responseHandler) {
    LocalBroadcastManager.getInstance(context).unregisterReceiver(responseHandler);
 }

 public static void postNotification(Context context, NotificationType notification, HashMap<String, String> params) {
    Intent intent = new Intent(notification.name());
    // insert parameters if needed
    for(Map.Entry<String, String> entry : params.entrySet()) {
        String key = entry.getKey();
        String value = entry.getValue();
        intent.putExtra(key, value);
    }
    LocalBroadcastManager.getInstance(context).sendBroadcast(intent);
 }
}

A continuación, también necesitan algún tipo de enumeración de estar seguro de errores en la codificación de las cadenas - (NotificationType):

public enum NotificationType {

   LoginResponse;
   // Others

}

Aquí es (observadores agregar / eliminar) el uso por ejemplo en las actividades:

public class LoginActivity extends AppCompatActivity{

    private BroadcastReceiver loginResponseReceiver = new BroadcastReceiver() {
        @Override
        public void onReceive(Context context, Intent intent) {
           // do what you need to do with parameters that you sent with notification

           //here is example how to get parameter "isSuccess" that is sent with notification
           Boolean result = Boolean.valueOf(intent.getStringExtra("isSuccess"));
        }
    };
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_login);

        //subscribe to notifications listener in onCreate of activity
        NotificationCenter.addObserver(this, NotificationType.LoginResponse, loginResponseReceiver);
    }

    @Override
    protected void onDestroy() {
        // Don't forget to unsubscribe from notifications listener
        NotificationCenter.removeObserver(this, loginResponseReceiver);
        super.onDestroy();
    }
}

y aquí está la forma en que finalmente posterior notificación a NotificationCenter de algunos de devolución de llamada o servicio resto o lo que sea:

public void loginService(final Context context, String username, String password) {
    //do some async work, or rest call etc.
    //...

    //on response, when we want to trigger and send notification that our job is finished
    HashMap<String,String> params = new HashMap<String, String>();          
    params.put("isSuccess", String.valueOf(false));
    NotificationCenter.postNotification(context, NotificationType.LoginResponse, params);
}

eso es todo, saludos!

Answer 4

Se podría utilizar este: http://developer.android.com/reference /android/content/BroadcastReceiver.html , lo que da un comportamiento similar.

Puede registrar los receptores mediante programación a través Context.registerReceiver (BroadcastReceiver, IntentFilter) y se captará a las intenciones enviadas a través de Context.sendBroadcast (Intención).

Tenga en cuenta, sin embargo, que un receptor no recibirá notificaciones si su actividad (contexto) ha puesto en pausa.

Answer 5

He encontrado que el uso de EventBus de guayaba lib es la forma más sencilla de publicación-suscripción al estilo de comunicación entre los componentes sin necesidad de los componentes a registrarse de forma explícita entre sí

ver su muestra en https://code.google.com/p/ guayaba-bibliotecas / wiki / EventBusExplained

// Class is typically registered by the container.
class EventBusChangeRecorder {
  @Subscribe public void recordCustomerChange(ChangeEvent e) {
    recordChange(e.getChange());
  }

// somewhere during initialization
eventBus.register(this);

}

// much later
public void changeCustomer() {
  eventBus.post(new ChangeEvent("bla bla") );
} 

puede añadir esta lib simplemente en Android Studio mediante la adición de una dependencia a su build.gradle:

compile 'com.google.guava:guava:17.0'

Answer 6

Se puede usar referencias débiles.

De esta forma podría gestionar la memoria de sí mismo y añadir y eliminar observadores a su gusto.

Cuando addObserver agregar estos parámetros -. Reparto en el que el contexto de la actividad que va a agregar que en la interfaz vacía, añadir un nombre de notificación, y llamar al método a la interfaz de ejecución

El método para ejecutar la interfaz tendría una función que se llama ejecución para devolver los datos que está pasando algo como esto

public static interface Themethodtorun {
        void run(String notification_name, Object additional_data);
    }

Crea una clase de observación que invoca una referencia con una interfaz vacía. También la construcción de su interfaz Themethodtorun a partir del contexto que se pasa en el addObserver.

Añadir a la observación de una estructura de datos.

Para llamar sería el mismo método, sin embargo todo lo que necesita hacer es encontrar el nombre de la notificación específico en la estructura de datos, utilice el Themethodtorun.run (notification_name, datos).

Esto enviará una devolución de llamada a donde quiera que ha creado un observador con un nombre específico de notificación. No se olvide de quitarlos cuando su hecho!

Esta es una buena referencia para referencias débiles.

http://learningviacode.blogspot.co. NZ / 2014/02 / débiles referencias-en-java.html

Estoy en el proceso de carga de este código a GitHub. Mantenga los ojos abiertos!