PubNub Push Benachrichtigung

Question

Ich plane, PubNub zu verwenden, um Push-Benachrichtigungen über Mobile Push Gateways zu senden. Mein Plan ist, einen Kanal für jeden Benutzer zu haben, dem die Registrierungs-ID zugeordnet ist. Und wenn ich eine Benachrichtigung senden möchte, wird mein PHP-Server den einzigartigen Kanal des Benutzers abonnieren und eine Nachricht veröffentlichen, um den Kanal abzubestellen.

Unterstützt PubNub die PHP-Sprache zur Veröffentlichung von Push-Benachrichtigungen (PNmessage)? Ist das obige Modell zum Senden von Push-Benachrichtigungen über PubNub gültig?

Answer 1

Sie müssen die Push-Benachrichtigung von Pubnub nicht abonnieren. Veröffentlichen Sie die Nachricht einfach im pubnub-Kanal des Nutzers und aktivieren Sie die Push-Benachrichtigung auf Android für diesen bestimmten Kanal. Sie erhalten die Push-Benachrichtigung an dem Ort, an dem Sie GCM-Benachrichtigungen erhalten. Für die Ex-lassen der Kanal 410 So auf Android Seite,

Pubnub.enablePushNotificationsForChannel("410"); 

In Ihrem GCMListenerService schreiben Sie Nachrichten empfangen können.

Falls Sie nicht GCM verwenden,

Auf Android-Seite schreiben,

public void subscribe() { 
    String[] channels = {PrefUtils.getUserId(context) + "", ChatUtils.getDeliveryChannel(PrefUtils.getUserId(context)), ChatUtils.getReadChannel(PrefUtils.getUserId(context))}; 
    try { 
     this.getPubnubInstance().subscribe(channels, new Callback() { 
      @Override 
      public void successCallback(String channel, Object message) { 
       super.successCallback(channel, message); 
       if (PubnubWrapper.this.onPubnubMessageReceiveListener != null) 
        PubnubWrapper.this.onPubnubMessageReceiveListener.onMessageReceived(channel, message); 
      } 

      @Override 
      public void connectCallback(String channel, Object message) { 
       super.connectCallback(channel, message); 
      } 

      @Override 
      public void reconnectCallback(String channel, Object message) { 
       super.reconnectCallback(channel, message); 
      } 

      @Override 
      public void disconnectCallback(String channel, Object message) { 
       super.disconnectCallback(channel, message); 
      } 

      @Override 
      public void errorCallback(String channel, PubnubError error) { 
       super.errorCallback(channel, error); 
      } 
     }); 
    } catch (PubnubException e) { 
     e.printStackTrace(); 
    } 
} 

Sie Mitteilung innerhalb der Rückrufe des successCallback Verfahren empfangen kann. Aber Sie müssen sicherstellen, dass eine Pubnub-Instanz ausgeführt wird, was in Android schmerzhaft ist.

Ich habe ein vollwertiges Chat-Modul mit Pubnub implementiert. Wenn die App im Vordergrund ist, verwende ich die subscription-Methode von Pubnub und nicht oush-Benachrichtigungen, da sie schneller sind. Im Hintergrund melde ich mich von Kanälen ab und aktiviere Push-Benachrichtigungen. Wie folgt aus:

public void subscribeAndDisablePush(String gcm_token) { 
    String[] channels = {PrefUtils.getUserId(context) + "", ChatUtils.getDeliveryChannel(PrefUtils.getUserId(context)), ChatUtils.getReadChannel(PrefUtils.getUserId(context))}; 
    getPubnubInstance().disablePushNotificationsOnChannels(channels, gcm_token); 
    try { 
     getPubnubInstance().subscribe(channels, new Callback() { 
      @Override 
      public void successCallback(String channel, Object message) { 
       super.successCallback(channel, message); 
      } 
     }); 
    } catch (PubnubException e) { 
     e.printStackTrace(); 
    } 
} 

public void unsubscribeAndEnablePush(String gcm_token) { 
    String[] channels = {PrefUtils.getUserId(context) + "", ChatUtils.getDeliveryChannel(PrefUtils.getUserId(context)), ChatUtils.getReadChannel(PrefUtils.getUserId(context))}; 
    getPubnubInstance().enablePushNotificationsOnChannels(channels, gcm_token, new Callback() { 
     @Override 
     public void successCallback(String channel, Object message) { 
      super.successCallback(channel, message); 
      Log.e("Subscribed", "YES"); 
     } 

     @Override 
     public void errorCallback(String channel, PubnubError error) { 
      super.errorCallback(channel, error); 
      Log.e("Subscribed", "No"); 
     } 
    }); 
    getPubnubInstance().unsubscribe(channels); 
} 

Inside My Anwendungsklasse mache ich das:

Foreground.init(this).addListener(new Foreground.Listener() { 
     @Override 
     public void onBecameForeground() { 
      PubnubWrapper.getInstance().subscribeAndDisablePushNotifications(); 
     } 

     @Override 
     public void onBecameBackground() { 
          PubnubWrapper.getInstance().unsubscribeAndEnablePushNotifications(); 

      } 
     } 
    }); 

Und ja, das ist Foreground.java:

public class Foreground implements Application.ActivityLifecycleCallbacks { 

public static final long CHECK_DELAY = 500; 
public static final String TAG = Foreground.class.getName(); 

public interface Listener { 

    public void onBecameForeground(); 

    public void onBecameBackground(); 

} 

private static Foreground instance; 

private boolean foreground = false, paused = true; 
private Handler handler = new Handler(); 
private List<Listener> listeners = new CopyOnWriteArrayList<Listener>(); 
private Runnable check; 

/** 
* Its not strictly necessary to use this method - _usually_ invoking 
* get with a Context gives us a path to retrieve the Application and 
* initialise, but sometimes (e.g. in test harness) the ApplicationContext 
* is != the Application, and the docs make no guarantees. 
* 
* @param application 
* @return an initialised Foreground instance 
*/ 
public static Foreground init(Application application){ 
    if (instance == null) { 
     instance = new Foreground(); 
     application.registerActivityLifecycleCallbacks(instance); 
    } 
    return instance; 
} 

public static Foreground get(Application application){ 
    if (instance == null) { 
     init(application); 
    } 
    return instance; 
} 

public static Foreground get(Context ctx){ 
    if (instance == null) { 
     Context appCtx = ctx.getApplicationContext(); 
     if (appCtx instanceof Application) { 
      init((Application)appCtx); 
     } 
     throw new IllegalStateException(
      "Foreground is not initialised and " + 
      "cannot obtain the Application object"); 
    } 
    return instance; 
} 

public static Foreground get(){ 
    if (instance == null) { 
     throw new IllegalStateException(
      "Foreground is not initialised - invoke " + 
      "at least once with parameterised init/get"); 
    } 
    return instance; 
} 

public boolean isForeground(){ 
    return foreground; 
} 

public boolean isBackground(){ 
    return !foreground; 
} 

public void addListener(Listener listener){ 
    listeners.add(listener); 
} 

public void removeListener(Listener listener){ 
    listeners.remove(listener); 
} 

@Override 
public void onActivityResumed(Activity activity) { 
    paused = false; 
    boolean wasBackground = !foreground; 
    foreground = true; 

    if (check != null) 
     handler.removeCallbacks(check); 

    if (wasBackground){ 
     Log.i(TAG, "went foreground"); 
     for (Listener l : listeners) { 
      try { 
       l.onBecameForeground(); 
      } catch (Exception exc) { 
       Log.e(TAG, "Listener threw exception!", exc); 
      } 
     } 
    } else { 
     Log.i(TAG, "still foreground"); 
    } 
} 

@Override 
public void onActivityPaused(Activity activity) { 
    paused = true; 

    if (check != null) 
     handler.removeCallbacks(check); 

    handler.postDelayed(check = new Runnable(){ 
     @Override 
     public void run() { 
      if (foreground && paused) { 
       foreground = false; 
       Log.i(TAG, "went background"); 
       for (Listener l : listeners) { 
        try { 
         l.onBecameBackground(); 
        } catch (Exception exc) { 
         Log.e(TAG, "Listener threw exception!", exc); 
        } 
       } 
      } else { 
       Log.i(TAG, "still foreground"); 
      } 
     } 
    }, CHECK_DELAY); 
} 

@Override 
public void onActivityCreated(Activity activity, Bundle savedInstanceState) {} 

@Override 
public void onActivityStarted(Activity activity) {} 

@Override 
public void onActivityStopped(Activity activity) {} 

@Override 
public void onActivitySaveInstanceState(Activity activity, Bundle outState) {} 

@Override 
public void onActivityDestroyed(Activity activity) {} 

}