Android équivalent à NSNotificationCenter

Question

Dans le processus de portage d'une application iPhone sur Android à, je suis à la recherche de la meilleure façon de communiquer au sein de l'application. Intentions semblent être la voie à suivre, est-ce la meilleure option (seulement)? NSUserDefaults semble poids beaucoup plus léger que Intentions font à la fois la performance et le codage.

Je dois aussi ajouter que j'ai une sous-classe de demande d'état, mais je dois faire une autre activité au courant d'un événement.

Answer 1

Vous pouvez essayer ceci: http://developer.android.com/reference /java/util/Observer.html

Answer 2

Le Flights I équivalent est LocalBroadcastManager qui fait partie du < a href = "http://developer.android.com/sdk/compatibility-library.html"> Android support package .

De la documentation LocalBroadcastManager:

  

Aide pour vous inscrire et envoyer des émissions de Intentions aux objets locaux au sein de votre processus. Ceci est a un certain nombre d'avantages par rapport l'envoi d'émissions mondiales avec sendBroadcast (intention):

     

  
• Vous savez que les données que vous diffusez ne quitteront pas votre application, donc ne pas besoin de vous soucier des fuites de données privées.
  
• Il est impossible pour d'autres applications d'envoyer ces émissions à votre application, de sorte que vous n'avez pas besoin de vous soucier d'avoir des trous de sécurité qu'ils peuvent exploiter.
  
• Il est plus efficace que l'envoi d'une diffusion mondiale par le système.
  

Lorsque vous utilisez, vous pouvez dire qu'un Intent est équivalent à un NSNotification. Voici un exemple:

ReceiverActivity.java

Une activité qui surveille les notifications pour l'événement nommé "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 deuxième activité qui envoie / notifications diffuse.

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

Avec le code ci-dessus, chaque fois que vous cliquez sur le bouton R.id.button_send, une intention et est diffusé est reçu par mMessageReceiver dans ReceiverActivity.

La sortie de débogage devrait ressembler à ceci:

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

Voici quelque chose de similaire à la réponse @Shiki, mais sous l'angle des développeurs iOS et le centre de notification.

Tout d'abord créer une sorte de service 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);
 }
}

Ensuite, vous aurez également besoin un certain type de ENUM pour être sûr d'erreurs dans le codage avec des chaînes - (NotificationType):

public enum NotificationType {

   LoginResponse;
   // Others

}

Voici l'utilisation (ajouter / supprimer des observateurs), par exemple dans les activités:

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

et est enfin là comment nous notification courrier à NotificationCenter de certains rappel ou d'un service de repos ou que ce soit:

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

Ca y est, cheers!

Answer 4

Vous pouvez utiliser ceci: http://developer.android.com/reference /android/content/BroadcastReceiver.html , ce qui donne un comportement similaire.

Vous pouvez enregistrer des récepteurs par programme Context.registerReceiver (BroadcastReceiver, IntentFilter) et il saisira les intentions envoyés par Context.sendBroadcast (intention).

Il faut toutefois souligner qu'un récepteur ne sera pas recevoir des notifications si son activité (contexte) a été mis en pause.

Answer 5

Je trouve que l'utilisation de EventBus de goyave lib est le moyen le plus simple pour publier-style s'abonner communication entre les composants sans nécessiter les composants à inscrire explicitement un autre

voir leur échantillon sur https://code.google.com/p/ goyave bibliothèques / 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") );
} 

vous pouvez ajouter cette lib simplement sur Android Studio en ajoutant une dépendance à votre build.gradle:

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

Answer 6

Vous pouvez utiliser des références faibles.

De cette façon, vous pouvez gérer la mémoire et vous-même ajouter et supprimer des observateurs comme vous s'il vous plaît.

Lorsque vous ajoutez addObserver ces paramètres -. Fonte ce contexte de l'activité que vous ajoutez dans l'interface vide, ajouter un nom de notification, et appeler la méthode à l'interface d'exécution

La méthode pour exécuter l'interface aurait une fonction qui est appelée terme pour renvoyer les données que vous passez quelque chose comme ceci

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

Créer une classe d'observation qui invoque une référence avec une interface vide. Aussi construire votre interface Themethodtorun du contexte étant passé dans le addObserver.

Ajouter l'observation d'une structure de données.

Pour appeler ce serait la même méthode mais tout ce que vous devez faire est de trouver le nom de notification spécifique dans la structure de données, utilisez la Themethodtorun.run (notification_name, données).

envoie un rappel à l'endroit où jamais vous avez créé un observateur avec un nom de notification spécifique. Ne pas oublier de les enlever quand votre fait!

Ceci est une bonne référence pour les références faibles.

http://learningviacode.blogspot.co. nz / 2014/02 / faibles références-en-java.html

Je suis en train de télécharger ce code GitHub. Gardez les yeux ouverts!