Ich möchte eine App schreiben, die Push-Benachrichtigungen von einem Server empfängt. Ich habe ein paar Methoden gefunden, um dies zu tun.

1. SMS - Fangen Sie die eingehende SMS ab und initiieren Sie einen Pull vom Server
2. Fragen Sie den Server regelmäßig ab

Jeder hat seine eigenen Grenzen. SMS - keine Garantie bei Ankunft. Poll kann den Akku entladen.

Haben Sie bitte einen besseren Vorschlag? Vielen Dank.

Die offizielle Antwort von Google ist das Android Cloud to Device Messaging Framework (veraltet) Google Cloud Messaging (veraltet) Firebase Cloud Messaging

Es funktioniert unter Android> = 2.2 (auf Telefonen mit dem Play Store).

( Cross-Posting von einer Antwort, die ich auf eine ähnliche Frage gegeben habe - Unterstützt Android Push-Benachrichtigungen in Echtzeit? )

Ich habe vor kurzem angefangen, mit MQTT http://mqtt.org für Android zu spielen, um so etwas zu tun (dh Push-Benachrichtigung, die nicht SMS, sondern datengesteuert ist, fast sofortige Nachrichtenübermittlung, keine Abfrage usw.).

Ich habe einen Blog-Beitrag mit Hintergrundinformationen dazu, falls es hilfreich ist

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

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

Mein Verständnis / meine Erfahrung mit Android Push-Benachrichtigungen sind:

1. C2DM GCM - Wenn Ihre Ziel-Android-Plattform 2.2+ ist, dann machen Sie es. Nur ein Haken: Gerätebenutzer müssen immer mit einem Google-Konto angemeldet sein , um die Nachrichten zu erhalten.

2. MQTT - Pub / Sub-basierter Ansatz, benötigt eine aktive Verbindung vom Gerät, kann die Batterie entladen, wenn sie nicht sinnvoll implementiert wird.

3. Diakon - Kann auf lange Sicht aufgrund der begrenzten Unterstützung durch die Community nicht gut sein.

Bearbeiten : Hinzugefügt am 25. November 2013

GCM - Google sagt ...

Für Geräte vor 3.0 müssen Benutzer ihr Google-Konto auf ihren Mobilgeräten einrichten. Ein Google-Konto ist auf Geräten mit Android 4.0.4 oder höher nicht erforderlich. *

Android Cloud to Device Messaging Framework

Wichtig: C2DM wurde am 26. Juni 2012 offiziell abgelehnt. Dies bedeutet, dass C2DM keine neuen Benutzer und Kontingentanforderungen mehr akzeptiert. C2DM werden keine neuen Funktionen hinzugefügt. Apps, die C2DM verwenden, funktionieren jedoch weiterhin. Bestehende C2DM-Entwickler werden aufgefordert, auf die neue Version von C2DM mit dem Namen Google Cloud Messaging für Android (GCM) zu migrieren. Weitere Informationen finden Sie im Dokument zur Migration von C2DM zu GCM. Entwickler müssen GCM für Neuentwicklungen verwenden.

Bitte überprüfen Sie den folgenden Link:

http://developer.android.com/guide/google/gcm/index.html

Hier habe ich einige Schritte geschrieben, um RegID und Benachrichtigung von Grund auf neu zu erhalten

1. App in Google Cloud erstellen / registrieren
2. Richten Sie das Cloud SDK mit Entwicklung ein
3. Projekt für GCM konfigurieren
4. Geräteregistrierungs-ID abrufen
5. Push-Benachrichtigungen senden
6. Push-Benachrichtigungen erhalten

Das vollständige Tutorial finden Sie unter dem folgenden URL-Link

Erste Schritte mit Android Push Notification: Neueste Google Cloud Messaging (GCM) - Schritt für Schritt vollständige Anleitung

Code-Snip zum Abrufen der Registrierungs-ID (Geräte-Token für Push-Benachrichtigung).

Projekt für GCM konfigurieren

Aktualisieren Sie die AndroidManifest-Datei

Um GCM in unserem Projekt zu aktivieren, müssen wir einige Berechtigungen in unsere Manifestdatei einfügen. Gehen Sie zu AndroidManifest.xml und fügen Sie den folgenden Code hinzu: Berechtigung hinzufügen

<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" />

GCM Broadcast Receiver-Deklaration hinzufügen

Fügen Sie die GCM Broadcast Receiver-Deklaration in Ihr Anwendungs-Tag ein

<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/>

Fügen Sie die GCM-Servie-Deklaration hinzu

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

Registrierungs-ID abrufen (Geräte-Token für Push-Benachrichtigung)

Gehen Sie jetzt zu Ihrer Start- / Begrüßungsaktivität

Fügen Sie Konstanten und Klassenvariablen hinzu

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;

Aktualisieren Sie die 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 speichern Sie REGISTRATION_KEY. Es ist wichtig, dass Sie eine PN-Nachricht an GCM senden. Sie auch, dass dies für alle Geräte eindeutig ist. Wenn Sie diese Option verwenden, sendet nur GCM eine Push-Benachrichtigung.

Push-Benachrichtigungen erhalten

GCM Broadcast Receiver Class hinzufügen

Da wir in unserer Manifest-Datei bereits "GcmBroadcastReceiver.java" deklariert haben, können Sie diesen Klassenaktualisierungsempfänger-Klassencode auf diese Weise erstellen

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

GCM-Serviceklasse hinzufügen

Da wir in unserer Manifest-Datei bereits "GcmBroadcastReceiver.java" deklariert haben, können Sie diesen Klassenaktualisierungsempfänger-Klassencode auf diese Weise erstellen

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

Es gibt eine neue Open-Source-Initiative zur Entwicklung einer Java-Bibliothek für Push-Benachrichtigungen auf Android basierend auf dem Meteor-Webserver. Sie können es im Deacon Project Blog nachlesen , wo Sie Links zu Meteor und dem GitHub-Repository des Projekts finden. Wir brauchen Entwickler, also bitte verbreiten Sie das Wort!

Sie können Xtify ( http://developer.xtify.com ) verwenden - sie haben einen Push-Benachrichtigungs-Webservice, der mit ihrem SDK funktioniert. Es ist kostenlos und hat bisher sehr gut für mich funktioniert.

oder....

3) Stellen Sie eine Verbindung zum Server her, senden Sie alle paar Minuten Keep-Alives, und der Server kann sofort Nachrichten senden. So funktioniert Google Mail, Google Talk usw.

Ich empfehle die Verwendung von GCM - Google Cloud Messaging für Android. Es ist kostenlos und sollte für einfache Zwecke sehr einfach sein.

Es ist jedoch erforderlich, einen Server auf der dritten Seite zu warten, um die Benachrichtigungen in Ihrem Namen zu senden. Wenn Sie vermeiden möchten, dass es einige sehr gute industrielle Lösungen für den Android-Push-Benachrichtigungsdienst gibt:

• Urban Airship - kostenlose bis zu 1 Million Benachrichtigungen pro Monat, danach werden Ihnen 1000 Benachrichtigungen berechnet
• PushApps - kostenlos für 1 Million Benachrichtigungen pro Monat und unbegrenzte Benachrichtigungen für 19,99 pro Monat
• PushWoosh - kostenlos für 1M-Geräte, Premium- Tarife ab 39 EURO

Diclaimer - Ich arbeite in PushApps und verwende deren Produkt seit über einem Jahr in meinen Anwendungen.

Ab dem 18.05.2016 ist Firebase Googles einheitliche Plattform für mobile Entwickler, einschließlich Push-Benachrichtigungen.

Ich fürchte, Sie haben beide möglichen Methoden gefunden. Zumindest anfangs wollte Google eine GChat-API implementieren, die Sie für eine Push / Pull-Implementierung verwenden konnten. Leider wurde diese Bibliothek von Android 1.0 geschnitten.

Ich weiß nicht, ob das noch nützlich ist. So etwas habe ich mit einer Java-Bibliothek bei erreicht http://www.pushlets.com/ erreicht.

Obwohl es in einem Dienst ausgeführt wird, wird Android nicht daran gehindert, es herunterzufahren und den Listener-Thread zu beenden.

Google C2DM wird jetzt abgeschrieben. Dafür müssen Sie den neuen Dienst GCM (Google Cloud Messaging) verwenden. Informationen zur Dokumentation finden Sie unter http://developer.android.com/guide/google/gcm/gs.html

C2DM: Ihre App-Benutzer müssen über das Google Mail-Konto verfügen.

MQTT: Wenn Ihre Verbindung 1024 erreicht hat, funktioniert sie nicht mehr, da das "Select Model" von Linux verwendet wird.

Es gibt einen kostenlosen Push-Service und eine API für Android. Sie können sie ausprobieren: http://push-notification.org

Kostenlose und einfache Methode:

Wenn Ihre Zielgruppe nicht groß ist (weniger als 1000) und Sie zunächst einen kostenlosen Service wünschen, ist Airbop der beste und bequemste.

Airbop-Website Sie verwendet den Google Cloud Messaging-Dienst über ihre API und bietet eine gute Leistung. Ich habe es für zwei meiner Projekte verwendet und es war einfach, es umzusetzen.

Services wie und Urbanship sind ausgezeichnet, bieten jedoch einen vollständigen Bereitstellungsstapel und nicht nur Push-Benachrichtigungen.

Wenn nur der Push-Service Ihr Ziel ist, funktioniert Airbop einwandfrei.

Ich habe Pushwoosh nicht verwendet , aber es ist auch eine gute Wahl. Es ermöglicht den kostenlosen Push auf 1.000.000 Geräte

Ich würde vorschlagen, sowohl SMS als auch HTTP zu verwenden. Wenn der Benutzer nicht angemeldet ist, senden Sie seinem Telefon eine SMS, um ihn zu benachrichtigen, dass eine Nachricht wartet.

So funktioniert dieser Ericsson Labs-Dienst: https://labs.ericsson.com/apis/mobile-java-push/

Wenn Sie dies selbst implementieren, ist es schwierig, die eingehende SMS zu löschen, ohne dass der Benutzer sie sieht. Oder vielleicht ist es in Ordnung, wenn sie es in Ihrem Fall sehen.

Sieht so aus: SMS mit BroadCastReceiver - Android löschen

Ja, das Schreiben von Code wie diesem kann gefährlich sein und Sie können möglicherweise das Leben einer Person ruinieren, da Ihre Anwendung eine SMS gelöscht hat, die sie nicht haben sollte.

Sie können Google Cloud Messaging oder GCM verwenden . Es ist kostenlos und einfach zu bedienen. Sie können auch Push-Server von Drittanbietern wie PushWoosh verwenden , um mehr Flexibilität zu erhalten

Es gibt viele Server von Drittanbietern wie Urban Airship , Xtify, Mainline , ... die das Senden nicht nur auf Android, sondern auch auf iOS, Windows Phone ... ermöglichen.

Firebase Cloud Messaging (FCM) ist die neue Version von GCM. FCM ist eine plattformübergreifende Messaging-Lösung, mit der Sie Nachrichten sicher und kostenlos senden können. Vererbt die zentrale Infrastruktur von GCM, um Nachrichten zuverlässig auf Android, iOS, Web (Javascript), Unity und C ++ zu übermitteln.

Bis zum 10. April 2018 hat Google GCM abgelehnt. Die GCM-Server- und Client-APIs sind veraltet und werden am 11. April 2019 entfernt. Google empfiehlt die Migration von GCM-Anwendungen auf Firebase Cloud Messaging (FCM), das die zuverlässige und skalierbare GCM-Infrastruktur erbt.

Ressource

Sie können Pusher verwenden

Es handelt sich um einen gehosteten Dienst, mit dem Web- und Mobilanwendungen ganz einfach Echtzeitdaten und -funktionen hinzufügen können.
Pusher bietet Bibliotheken zur Integration in alle wichtigen Laufzeiten und Frameworks.

PHP, Ruby, Python, Java, .NET, Go and Nodeauf dem Server
JavaScript, Objective-C (iOS) and Java (Android)auf dem Client.