Push-Benachrichtigungen in Android Platform

(cross-posting aus einer Antwort, die ich gab eine ähnliche Frage - Tut Android-support-Echtzeit push-Benachrichtigung? )

Ich habe vor kurzem angefangen zu spielen mit MQTT http://mqtt.org für Android-als ein Weg, das zu tun diese Art der Sache (d.h. push-Meldung, die nicht von SMS, sondern Daten getrieben, fast sofortige Nachrichtenübermittlung, nicht Umfragen, etc.)

Habe ich in einem blog-Beitrag mit hintergrund-Informationen zu diesem in Fall ist es hilfreich, die

http://dalelane.co.uk/blog/?p=938

(Hinweis: MQTT ist ein IBM-Technologie, und ich sollte darauf hinweisen, dass ich arbeite für die IBM.)

InformationsquelleAutor der Antwort dalelane

Ich hier geschrieben habe, einige Schritte, Wie Sie Registrierungs-id und Meldung von vorne anfangen

1. Erstellen/Registrieren, App auf Google Cloud
2. Setup-Cloud-SDK mit der Entwicklung
3. Konfigurieren Projekt für GCM
4. Get Device Registration ID
5. Senden Von Push-Benachrichtigungen
6. Push-Benachrichtigungen Empfangen

Finden Sie komplette tutorial in unter URL-link

die Erste Schritte mit Android Push Notification : Neueste Google-Cloud
Messaging (GCM) - Schritt für Schritt tutorial

Code-Ausschnitt zu bekommen Registrierungs-ID (Device-Token für die Push-Benachrichtigung).

Konfigurieren Projekt für GCM

Update AndroidManifest-Datei

Aktivieren GCM in unserem Projekt benötigen wir einige Berechtigung in unserem manifest-Datei
Gehen Sie zu AndroidManifest.xml und fügen Sie folgenden code
Fügen Sie Die Berechtigung

<uses-permission android:name="android.permission.INTERNET”/>
<uses-permission android:name="android.permission.GET_ACCOUNTS" />
<uses-permission android:name="android.permission.WAKE_LOCK" />

<uses-permission android:name="android.permission.VIBRATE" />

<uses-permission android:name=“.permission.RECEIVE" />
<uses-permission android:name=“<your_package_name_here>.permission.C2D_MESSAGE" />
<permission android:name=“<your_package_name_here>.permission.C2D_MESSAGE"
        android:protectionLevel="signature" />

Hinzufügen GCM Broadcast Receiver Erklärung

hinzufügen GCM-Broadcast-Empfänger die Erklärung in Ihrer Anwendung das tag

<application
        <receiver
            android:name=".GcmBroadcastReceiver"
            android:permission="com.google.android.c2dm.permission.SEND" ]]>
            <intent-filter]]>
                <action android:name="com.google.android.c2dm.intent.RECEIVE" />
                <category android:name="" />
            </intent-filter]]>

        </receiver]]>

<application/>

Hinzufügen GCM-Servie Erklärung

<application
     <service android:name=".GcmIntentService" />
<application/>

Bekommen Registrierungs-ID (Device-Token für die Push-Benachrichtigung)

Nun Gehen Sie zu Ihrem Start/Splash Activity

Hinzufügen, Konstanten und Klassen-Variablen

private final static int PLAY_SERVICES_RESOLUTION_REQUEST = 9000;
public static final String EXTRA_MESSAGE = "message";
public static final String PROPERTY_REG_ID = "registration_id";
private static final String PROPERTY_APP_VERSION = "appVersion";
private final static String TAG = "LaunchActivity";
protected String SENDER_ID = "Your_sender_id";
private GoogleCloudMessaging gcm =null;
private String regid = null;
private Context context= null;

Update OnCreate und OnResume Methoden

@Override
protected void onCreate(Bundle savedInstanceState)
{
     super.onCreate(savedInstanceState);
     setContentView(R.layout.activity_launch);
     context = getApplicationContext();
         if (checkPlayServices()) 
     {
            gcm = GoogleCloudMessaging.getInstance(this);
            regid = getRegistrationId(context);

            if (regid.isEmpty())
            {
                registerInBackground();
            }
            else
            {
            Log.d(TAG, "No valid Google Play Services APK found.");
            }
      }
 }

@Override protected void onResume()
{
       super.onResume();       checkPlayServices();
}


# Implement GCM Required methods (Add below methods in LaunchActivity)

private boolean checkPlayServices() {
        int resultCode = GooglePlayServicesUtil.isGooglePlayServicesAvailable(this);
        if (resultCode != ConnectionResult.SUCCESS) {
            if (GooglePlayServicesUtil.isUserRecoverableError(resultCode)) {
                GooglePlayServicesUtil.getErrorDialog(resultCode, this,
                        PLAY_SERVICES_RESOLUTION_REQUEST).show();
            } else {
                Log.d(TAG, "This device is not supported - Google Play Services.");
                finish();
            }
            return false;
        }
        return true;
 }

private String getRegistrationId(Context context) 
{
   final SharedPreferences prefs = getGCMPreferences(context);
   String registrationId = prefs.getString(PROPERTY_REG_ID, "");
   if (registrationId.isEmpty()) {
       Log.d(TAG, "Registration ID not found.");
       return "";
   }
   int registeredVersion = prefs.getInt(PROPERTY_APP_VERSION, Integer.MIN_VALUE);
   int currentVersion = getAppVersion(context);
   if (registeredVersion != currentVersion) {
        Log.d(TAG, "App version changed.");
        return "";
    }
    return registrationId;
}

private SharedPreferences getGCMPreferences(Context context) 
{
    return getSharedPreferences(LaunchActivity.class.getSimpleName(),
                Context.MODE_PRIVATE);
}

private static int getAppVersion(Context context) 
{
     try 
     {
         PackageInfo packageInfo = context.getPackageManager()
                    .getPackageInfo(context.getPackageName(), 0);
            return packageInfo.versionCode;
      } 
      catch (NameNotFoundException e) 
      {
            throw new RuntimeException("Could not get package name: " + e);
      }
}


private void registerInBackground() 
{     new AsyncTask() {
     Override
     protected Object doInBackground(Object... params) 
     {
          String msg = "";
          try 
          {
               if (gcm == null) 
               {
                        gcm = GoogleCloudMessaging.getInstance(context);
               }
               regid = gcm.register(SENDER_ID);               Log.d(TAG, "########################################");
               Log.d(TAG, "Current Device's Registration ID is: "+msg);     
          } 
          catch (IOException ex) 
          {
              msg = "Error :" + ex.getMessage();
          }
          return null;
     }     protected void onPostExecute(Object result) 
     { //to do here };
  }.execute(null, null, null);
}

Hinweis : bitte lagern Sie REGISTRATION_KEY, ist es wichtig für das versenden von PN-Nachricht zu GCM
halten Sie auch im Bergwerk-das wird einzigartig für alle Geräte, durch die Nutzung dieser nur, GCM senden Push-Benachrichtigung.

Push-Benachrichtigungen Empfangen

Hinzufügen GCM Broadcast Receiver-Klasse

Wie wir schon erklärt haben "GcmBroadcastReceiver.java" in unserem Manifest-Datei, So können diese Klasse erstellt
update Empfänger-Klasse code, der auf diese Weise

public class GcmBroadcastReceiver extends WakefulBroadcastReceiver {
    @Override
    public void onReceive(Context context, Intent intent) 
    {        ComponentName comp = new ComponentName(context.getPackageName(),
                GcmIntentService.class.getName());        startWakefulService(context, (intent.setComponent(comp)));
        setResultCode(Activity.RESULT_OK);
        Toast.makeText(context, “wow!! received new push notification", Toast.LENGTH_LONG).show();
    }
}

Hinzufügen GCM Service-Klasse

Wie wir schon erklärt haben "GcmBroadcastReceiver.java" in unserem Manifest-Datei, So können diese Klasse erstellt
update Empfänger-Klasse code, der auf diese Weise

public class GcmIntentService extends IntentService
{     public static final int NOTIFICATION_ID = 1;     private NotificationManager mNotificationManager;     private final static String TAG = "GcmIntentService";     public GcmIntentService() {
     super("GcmIntentService");     
     }     @Override
     protected void onHandleIntent(Intent intent) {
          Bundle extras = intent.getExtras();
          Log.d(TAG, "Notification Data Json :" + extras.getString("message"));

          GoogleCloudMessaging gcm = GoogleCloudMessaging.getInstance(this);
          String messageType = gcm.getMessageType(intent);          if (!extras.isEmpty()) {          if (GoogleCloudMessaging.MESSAGE_TYPE_SEND_ERROR
               .equals(messageType)) {
               sendNotification("Send error: " + extras.toString());
          } else if (GoogleCloudMessaging.MESSAGE_TYPE_DELETED
          .equals(messageType)) {
          sendNotification("Deleted messages on server: "
          + extras.toString());          //If it's a regular GCM message, do some work.
          } else if (GoogleCloudMessaging.MESSAGE_TYPE_MESSAGE
          .equals(messageType)) {
          //This loop represents the service doing some work.
          for (int i = 0; i < 5; i++) {
               Log.d(TAG," Working... " + (i + 1) + "/5 @ "
               + SystemClock.elapsedRealtime());               try {
                    Thread.sleep(5000);
               } catch (InterruptedException e) {
               }
             }
             Log.i(TAG, "Completed work @ " + SystemClock.elapsedRealtime());
             sendNotification(extras.getString("message"));
           }
        }        //Release the wake lock provided by the WakefulBroadcastReceiver.
        GcmBroadcastReceiver.completeWakefulIntent(intent);
     }     //Put the message into a notification and post it.
     //This is just one simple example of what you might choose to do with
     //a GCM message.
     private void sendNotification(String msg) {          mNotificationManager = (NotificationManager) this
          .getSystemService(Context.NOTIFICATION_SERVICE);
          PendingIntent contentIntent = PendingIntent.getActivity(this, 0,          new Intent(this, LaunchActivity.class), 0);

          NotificationCompat.Builder mBuilder = new NotificationCompat.Builder(          this)
          .setSmallIcon(R.drawable.icon)
          .setContentTitle("Ocutag Snap")
          .setStyle(new NotificationCompat.BigTextStyle().bigText(msg))
          .setContentText(msg)
          .setDefaults(Notification.DEFAULT_SOUND | Notification.DEFAULT_VIBRATE);

          mBuilder.setContentIntent(contentIntent);          mNotificationManager.notify(NOTIFICATION_ID, mBuilder.build());
     }
}

InformationsquelleAutor der Antwort swiftBoy

Es ist eine neue open-source-Bemühungen um Entwicklung einer Java-Bibliothek für die push-Benachrichtigungen auf Android-Basis auf der Meteor-web-server. Sie können check it out auf der Diakon Projekt Bloghier finden Sie links zu Meteor und das Projekt zu GitHub repository. Wir brauchen Entwickler, also bitte spread the word!

InformationsquelleAutor der Antwort mtbkrdave

oder....

3) eine Verbindung zu dem server, senden von keep-alives alle paar Minuten, und dann kann der server-push-Nachrichten sofort. Dies ist, wie Google Mail, Google Talk, etc. funktioniert.

InformationsquelleAutor der Antwort Isaac Waller

Als der 18/05/2016 FB Google ist die einheitliche Plattform für mobile-Entwickler, einschließlich push-Benachrichtigungen.

InformationsquelleAutor der Antwort Freek Nortier

Ich weiß nicht, ob dies noch sinnvoll. Ich erreichte so etwas wie dies mit einer java-Bibliothek an http://www.pushlets.com/

Lediglich, es zu tun in einem Dienst wird nicht verhindern, dass android Herunterfahren eine Tötung der listener-thread.

InformationsquelleAutor der Antwort n3utrino

C2DM: Ihre app-Nutzer müssen die Google Mail-Konto.

MQTT: wenn die Verbindung erreicht zu 1024, wird es aufhören zu arbeiten, weil es verwendet die "select model" von linux.

Gibt es einen kostenlosen push-Dienst und api für android, Sie können es versuchen: http://push-notification.org

InformationsquelleAutor der Antwort Jacky

Ich würde vorschlagen, mit SMS und HTTP. Wenn der Benutzer nicht angemeldet ist senden Sie Ihr Telefon eine SMS, um Sie zu Benachrichtigen, es ist eine Nachricht warten.

Das ist, wie dieses Ericsson Labs-Dienst funktioniert: https://labs.ericsson.com/apis/mobile-java-push/

Wenn Sie implementieren diese selbst der schwierige Teil ist zu löschen die ankommende SMS, ohne dass der Benutzer es zu sehen. Oder vielleicht ist es ok, wenn Sie sehen, dass es in Ihrem Fall.

Sieht aus wie das funktioniert:
Löschen von SMS-Nachrichten Über BroadCastReceiver - Android

Ja, code zu schreiben, kann gefährlich sein und Sie kann potenziell ruinieren das Leben anderer, weil Ihre Anwendung gelöscht, eine SMS-es nicht haben sollte.

InformationsquelleAutor der Antwort Sarel Botha

Es gibt eine Menge third-party-Servern wie Städtische LuftschiffXtify, Mainline... dessen schicken lassen nicht nur auf Android, sondern auch auf iOs, Windows Phone ...

InformationsquelleAutor der Antwort Panchine Lac