Android entspricht NSNotificationCenter

Question

Im Prozess der Portierung eine iPhone-Anwendung über android, ich bin auf der Suche nach dem besten Weg innerhalb der App zu kommunizieren. Intents scheint der Weg zu sein, um zu gehen, ist dies die beste (nur) Option? NSUserDefaults scheint viel leichter als Intents tun in Leistung und Codierung.

Ich möchte auch hinzufügen, ich habe eine Anwendung, Unterklasse für den Zustand, aber ich brauche eine andere Tätigkeit Kenntnis von einem Ereignis zu machen.

Answer 1

Sie können dies versuchen: http://developer.android.com/reference /java/util/Observer.html

Answer 2

Die beste Äquivalent ich gefunden LocalBroadcastManager , die Teil der ist < a href = "http://developer.android.com/sdk/compatibility-library.html"> Android Support Package .

Von der LocalBroadcastManager Dokumentation:

Helper für sich registrieren und Sendungen von Intents auf lokale Objekte in Ihrem Prozess senden. Dies hat eine Reihe von Vorteilen gegenüber globale Sendungen mit sendBroadcast Senden (Intent):

• Sie wissen, dass die Daten, die Sie senden Ihre App nicht verlassen, also nicht über undichte private Daten zu sorgen brauchen.
• Es ist nicht möglich, für andere Anwendungen, die diese Sendungen zu Ihrer App zu senden, so dass Sie nicht darüber, dass Sicherheitslücken zu sorgen brauchen können sie nutzen.
• Es ist effizienter als eine globale Ausstrahlung durch das System zu senden.

Wenn diese verwenden, können Sie sagen, dass ein Intent ein Äquivalent zu einem NSNotification ist. Hier ein Beispiel:

ReceiverActivity.java

Eine Aktivität, die Uhren für Benachrichtigungen für den Fall genannt "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

Die zweite Aktivität, die / Sendungen Benachrichtigungen sendet.

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

Mit dem obigen Code wird jedes Mal, wenn die Taste R.id.button_send geklickt haben, eine Intent ausgestrahlt wird und von mMessageReceiver in ReceiverActivity erhalten.

Die Debug-Ausgabe sollte wie folgt aussehen:

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

Hier ist etwas ähnlich wie @Shiki Antwort, aber aus der Sicht der iOS-Entwickler und Notification Center.

Erstellen Sie zunächst eine Art von NotificationCenter Service:

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

Dann werden Sie auch einige Aufzählungstypen müssen bei der Codierung mit Strings sicher von Fehlern sein - (NotificationType):

public enum NotificationType {

   LoginResponse;
   // Others

}

Hier sind die Nutzung (Hinzufügen / Entfernen Beobachter) zum Beispiel in Tätigkeiten:

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

und hier ist schließlich, wie wir Post Mitteilung an NotificationCenter von einem Rückruf oder Ruhe Service oder was auch immer:

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

Das ist es, prost!

Answer 4

Sie können diese verwenden: http://developer.android.com/reference /android/content/BroadcastReceiver.html , die ein ähnliches Verhalten gibt.

Sie können Empfänger registrieren programmatisch durch Context.registerReceiver (BroadcastReceiver, IntentFilter) und es wird Absichten erfassen durch Context.sendBroadcast gesendet (Intent).

Beachten Sie jedoch, dass ein Empfänger keine Benachrichtigungen erhalten, wenn ihre Tätigkeit (Kontext) wurde angehalten.

Answer 5

Ich fand, dass die Nutzung von EventBus von Guava lib ist der einfachste Weg für Publish-Subscribe-Stil Kommunikation zwischen Komponenten, ohne dass die Komponenten explizit registriert miteinander

sehen ihre Probe auf https://code.google.com/p/ Guave-Bibliotheken / 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") );
} 

Sie können diese lib einfach auf Android Studio hinzufügen, indem Sie eine Abhängigkeit zu Ihrem build.gradle hinzufügen:

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

Answer 6

Sie könnten schwache Verweise verwenden.

So können Sie den Speicher selbst verwalten können und hinzufügen und entfernen Beobachter als Sie bitte.

Wenn Sie addObserver diese Parameter hinzufügen -. Guss dass Kontext aus der Tätigkeit Sie es hinzufügen, um die leere Schnittstelle, eine Benachrichtigung Name, und rufen Sie die Methode zur Lauf Schnittstelle

Die Methode Schnittstelle ausgeführt werden soll, eine Funktion, die Lauf aufgerufen, um die Daten zurückgeben, dass Sie so etwas wie dieses sind vorbei

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

Erstellen Sie eine Beobachtung Klasse, die einen Verweis mit einem leeren Schnittstelle aufruft. Auch konstruiert Ihre Themethodtorun Schnittstelle aus dem Kontext, in dem addObserver geleitet wird.

Fügen Sie die Beobachtung auf eine Datenstruktur.

es nennen würde die gleiche Methode, aber alles, was Sie tun müssen, ist die spezifische Meldung Name in der Datenstruktur zu finden, verwenden Sie die Themethodtorun.run (notification_name, Daten).

Dies wird einen Rückruf senden, wo immer erstellt man einen Beobachter mit einem bestimmten Benachrichtigung Namen. Vergessen Sie nicht, um sie zu entfernen, wenn Sie fertig sind!

Das ist eine gute Referenz für schwache Verweise.

http://learningviacode.blogspot.co. nz / 2014/02 / schwach Verweise-in-java.html

Ich bin in dem Prozess diesen Code auf Github zu. Halten Sie die Augen offen!