FirebaseMessagingService Singleton? Steuern der Instanz

Question

Ich habe ein Problem mit der Verwendung der FirebaseMessagingService. Die FirebaseMessagingService funktioniert gut. Ich erhalte die Nachrichten und die Benachrichtigungen. Aber ich muss die Nachricht an Aktivität geöffnet senden und eine Methode in Aktivität aufrufen.

Ich habe versucht, einen Listener zu erstellen, aber beim Empfang einer Nachricht wird eine neue Instanz erstellt und der Listener ist null. Ich verstehe, dass FirebaseMessagingService instanziiert ist, wenn eine Nachricht empfangen werden soll. Also dachte ich in Singleton und Zuhörer zusammen, arbeite nicht, der Hörer bleibt null.

Hat jemand eine Idee, wie ich eine Nachricht an Aktivität öffnen kann?

Answer 1

Ich glaube nicht, dass irgendwelche Listener dafür benötigt werden. Sobald Sie die Nachricht in onMessageReceived() erhalten, senden Sie es einfach mit LocalBroadcastmanager. und empfange diese Sendung in deiner Aktivität.

Unten finden Sie die Code-Snippet zu erreichen, was Sie wollen:

MyFirebaseMessagingService.java:

@Override 
public void onMessageReceived(RemoteMessage remoteMessage) { 
     Intent intent = new Intent(**Action**); 
     intent.putExtra("Some Payload", message.getBody()); 
     mLocalBroadcastManager.sendBroadcast(intent); 
} 

MainActivity.java:

private LocalBroadcastManager mLocalBroadcastManager; 
private BroadcastReceiver mBroadcastReceiver = new BroadcastReceiver() { 
    @Override 
    public void onReceive(Context context, Intent intent) { 

    } 
}; 

@Override 
protected void onStart() { 
    super.onStart(); 
    registerBroadcastReceiver(); 
} 

@Override 
protected void onStop() { 
    super.onStop(); 
    unregisterBroadcastReceiver(); 
} 

private void registerBroadcastReceiver() { 
    mLocalBroadcastManager = LocalBroadcastManager.getInstance(this); 
    IntentFilter intentFilter = new IntentFilter(); 
    intentFilter.addAction(**Action**); 
    mLocalBroadcastManager.registerReceiver(mBroadcastReceiver, intentFilter); 
} 

private void unregisterBroadcastReceiver() { 
    mLocalBroadcastManager.unregisterReceiver(mBroadcastReceiver); 
} 

Answer 2

voll Sorgfalt obwohl keine Einschränkungen zu überschreiten von Datengrößen, die mit Intents übergeben werden können siehe hier https://code.google.com/p/android/issues/detail?id=5878

Ich habe Ihre Frage ohne Code verstanden. Hier ist so ziemlich eine schlüsselfertige Lösung für Sie, die funktionieren sollte. Ich verwende diese Methode sehr, um Daten zwischen Diensten und Aktivitäten zu übertragen.

Das erste, was Sie tun müssen, ist die Daten, die Sie weitergeben wollen, in etwas zu konvertieren, das durch eine Absicht weitergegeben werden kann.

Strings sind einfach zu arbeiten mit so in Zeichenfolge konvertieren und in einer Absicht. Auf der Aktivitätsseite mit onCreate und onNewIntent können Sie diese Daten problemlos erhalten. Dann wandeln Sie es zurück, wie immer Sie wünschen. Siehe Code unten für ein Beispiel.

Das Arbeiten mit Rundfunkempfängern bietet Ihnen die Möglichkeit, Datenlecks zu verursachen, wenn der Empfänger nicht registriert ist. Es passiert, wenn Ihre App abstürzt und der unRegister nicht heruntergefahren wird.

In Ihrem FirebaseMessagingService Klasse

import android.os.AsyncTask; 
    import com.google.firebase.messaging.FirebaseMessagingService; 
    import com.google.firebase.messaging.RemoteMessage; 
    import org.json.JSONException; 
    import org.json.JSONObject; 
    import java.util.Map; 

    /** 
    * Created by acopp 
    * Date: 12/31/2016. 
    * Time: 1:41 PM 

    * You have permission to use this file for any reason that is not for evil doing 
    */ 

    public class FBMService extends FirebaseMessagingService { 
     static String TAG = "FBMService"; 
     static String FBMServiceAction = "FBMService.Action"; 

     @Override 
     public void onMessageReceived(RemoteMessage remoteMessage) { 
      MainActivity.passIntent(this,FBMServiceAction,getString(remoteMessage)); 
     } 
     String getString(RemoteMessage message){ 
      Map<String, String> messageData = message.getData(); 
      JSONObject j = new JSONObject(); 
      for (String key : messageData.keySet()) { 
       String value = messageData.get(key); 
       try { 
        j.put(key, value); 
       } catch (JSONException e) { 
        e.printStackTrace(); 
       } 
      } 
      return j.toString(); 
     } 

    } 

Aktivität Klasse

//In your activity class 

    import android.app.Activity; 
    import android.content.Context; 
    import android.content.Intent; 
    import android.os.AsyncTask; 
    import android.os.Bundle; 
    import android.util.Log; 
    import org.json.JSONException; 
    import org.json.JSONObject; 
    import java.util.HashMap; 
    import java.util.Iterator; 
    import java.util.Map; 

    /** 
    * Created by acopp 
    * Date: 12/31/2016. 
    * Time: 1:41 PM 
    * You have permission to use this file for any reason that is not for evil doing 
    */ 

    public class MainActivity extends Activity { 
     private String TAG = "MainActivity"; 

     //Call this from FBMService to start your activity or if your activity is start to receive a new intent 
     static void passIntent(Context context, String action, String messageDataString) { 
      Intent intent = new Intent(context, MainActivity.class); 
      intent.setFlags(Intent.FLAG_ACTIVITY_NEW_TASK); 
      intent.putExtra("action", action); 
      intent.putExtra("message", messageDataString); 
      context.startActivity(intent); 
     } 

     @Override 
     protected void onCreate(Bundle savedInstanceState) { 
      super.onCreate(savedInstanceState); 
      Log.d(TAG, "onCreate"); 
      intentHandler(getIntent()); 
     } 
     @Override 
     protected void onNewIntent(Intent intent) { 
      super.onNewIntent(intent); 
      Log.d(TAG, "onNewIntent"); 
      intentHandler(intent); 
     } 
     //Use an intent handler to manage onNewIntent and onCreate the same way 
     void intentHandler(Intent intent) { 
      if (intent.hasExtra("action")) { 
       String action = intent.getStringExtra("action"); 
       if(action.equals(FBMService.FBMServiceAction)){ 
        if (intent.hasExtra("message")) { 
         String messageDataString = intent.getStringExtra("message"); 
         new iterEat().execute(messageDataString); 
        } 
       } 
      } 
     } 
     //Convert your string to a HashMap in the background off the main thread 
     class iterEat extends AsyncTask<String,Void,Map<String, String> > { 
      @Override 
      protected Map<String, String> doInBackground(String... rm) { 
       String messageDataString = rm[0]; 
       try{ 
        return fromString(messageDataString); 
       }catch (NullPointerException e){ 
        return null; 
       } 
      } 
      @Override 
      protected void onPostExecute(Map<String, String> s) { 
       //Your data is pooped out here 
       Map<String, String> messageData = s;//PLOP 
      } 
     } 

     Map<String, String> fromString(String jsonString) throws NullPointerException{ 
      try { 
       Map<String, String> messageData = new HashMap<>(); 
       JSONObject j = new JSONObject(jsonString); 
       Iterator<String> i = j.keys(); 
       while(i.hasNext()){ 
        String key = i.next(); 
        String value = j.getString(key); 
        messageData.put(key,value); 
       } 
       return messageData; 

      } catch (JSONException e) { 
       throw new NullPointerException("Didn't work"); 
      } 
     } 
    }