enviar - Notificaciones Push en la plataforma Android

notificaciones push android java

Question

Estoy buscando escribir una aplicación que reciba alertas enviadas desde un servidor. Encontré un par de métodos para hacer esto.

1. SMS: intercepta el SMS entrante e inicia una extracción desde el servidor
2. Encuestar el servidor periódicamente

Cada uno tiene sus propias limitaciones. SMS- sin garantía en el tiempo de llegada. El sondeo puede agotar la batería.

¿Tienes una sugerencia mejor por favor? Muchas gracias.

Answer 1

( Publicación cruzada de una respuesta que di a una pregunta similar: ¿Android es compatible con la notificación de inserción casi en tiempo real? )

Hace poco comencé a jugar con MQTT http://mqtt.org para Android como una forma de hacer este tipo de cosas (es decir, notificaciones push que no son SMS sino datos, entrega de mensajes casi inmediata, no sondeos, etc.)

Tengo una publicación en el blog con información de fondo sobre esto en caso de que sea útil.

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

(Nota: MQTT es una tecnología de IBM, y debo señalar que trabajo para IBM).

Answer 2

A partir del 18/05/2016, Firebase es la plataforma unificada de Google para desarrolladores móviles que incluye notificaciones push.

Answer 3

C2DM: los usuarios de la aplicación deben tener la cuenta de gmail.

MQTT: cuando su conexión llegó a 1024, dejará de funcionar debido a que usó el "modelo de selección" de linux.

Hay un servicio push gratuito y una api para android, puedes probarlo: http://push-notification.org

Answer 4

Existe un nuevo esfuerzo de código abierto para desarrollar una biblioteca de Java para notificaciones push en Android basada en el servidor web Meteor. Puede verlo en Deacon , donde encontrará enlaces a Meteor y al repositorio GitHub del proyecto. Necesitamos desarrolladores, así que por favor, corre la voz!

Answer 5

Google C2DM se ha depreciado ahora, para eso, debe usar el nuevo servicio GCM (Google Cloud Messaging). Para obtener documentación, consulte http://developer.android.com/guide/google/gcm/gs.html

Answer 6

Hay muchos servidores de terceros como Urban Airship , Xtify, Mainline , ... lo que permite enviar no solo en Android, sino también en iOs, Windows Phone ...

Answer 7

La respuesta oficial de Google es el marco de mensajería de nube a dispositivo de Android (en desuso) Mensajería en la nube de Google (en desuso) Mensajería en la nube de Firebase

Funcionará en Android> = 2.2 (en teléfonos que tienen Play Store).

Answer 8

Me temo que has encontrado ambos métodos posibles. Google, al menos inicialmente, iba a implementar una API GChat que podría usar para una implementación push / pull. Lamentablemente, esa biblioteca fue cortada por Android 1.0.

Answer 9

Mi comprensión / experiencia con la notificación de inserción de Android son:

1. C2DM GCM : si su plataforma de Android objetivo es 2.2+, entonces hágalo. Solo una captura, los usuarios de dispositivos deben estar siempre conectados con una cuenta de Google para recibir los mensajes.

2. MQTT : enfoque basado en Pub / Sub, necesita una conexión activa desde el dispositivo, puede agotar la batería si no se implementa sensiblemente.

3. Deacon : puede no ser bueno a largo plazo debido al apoyo limitado de la comunidad.

Edición : Agregado el 25 de noviembre de 2013

GCM - Google dice ...

Para dispositivos pre-3.0, esto requiere que los usuarios configuren su cuenta de Google en sus dispositivos móviles. Una cuenta de Google no es un requisito en dispositivos con Android 4.0.4 o superior. *

Answer 10

No sé si esto sigue siendo útil. Logré algo como esto con una biblioteca de java en http://www.pushlets.com/

Aunque lo hagas en un servicio, no evitarás que Android lo cierre y el hilo del que escucha.

Answer 11

Puede usar Google Cloud Messaging o developer.android.com/guide/google/gcm/index.html , es gratis y fácil de usar. También puedes usar servidores push de terceros como PushWoosh que te da más flexibilidad

Answer 12

Puede usar Xtify ( http://developer.xtify.com ): tienen un servicio web de notificaciones push que funciona con su SDK. Es gratis y hasta ahora, ha funcionado muy bien para mí.

Answer 13

Puedes usar Pusher

Es un servicio alojado que hace que sea muy fácil agregar datos y funciones en tiempo real a las aplicaciones web y móviles.
Pusher ofrece bibliotecas para integrarse en todos los principales tiempos de ejecución y marcos.

PHP, Ruby, Python, Java, .NET, Go and Node en el servidor
JavaScript, Objective-C (iOS) and Java (Android) en el cliente.

Answer 14

Recomiendo usar GCM: Google Cloud Messaging para Android Es gratis, y para usos simples debería ser muy fácil.

Sin embargo, se requiere mantener un tercer servidor para enviar las notificaciones en su nombre. Si desea evitar que haya algunas soluciones industriales muy buenas para el servicio de notificaciones push de Android:

• Dirigible urbano : gratis hasta 1 millón de notificaciones por mes, luego se le cobran por 1000 notificaciones
• PushApps : gratis para notificaciones de 1M por mes, y notificaciones ilimitadas por 19.99 por mes
• PushWoosh : gratis para dispositivos 1M, los planes premium son de 39 euros

Diclaimer : trabajo en PushApps y también uso su producto en mis aplicaciones desde hace más de un año.

Answer 15

Yo sugeriría usar tanto SMS como HTTP. Si el usuario no ha iniciado sesión, envíe un SMS a su teléfono para notificarle que hay un mensaje en espera.

Así es como funciona este servicio de Ericsson Labs: https://labs.ericsson.com/apis/mobile-java-push/

Si implementa esto usted mismo, la parte difícil es eliminar el SMS entrante sin que el usuario lo vea. O tal vez está bien si lo ven en tu caso.

Parece que esto funciona: Eliminar SMS usando BroadCastReceiver - Android

Sí, escribir un código como este puede ser peligroso y potencialmente arruinar la vida de alguien porque su aplicación eliminó un SMS que no debería tener.

Answer 16

o....

3) Mantenga una conexión con el servidor, envíe keep-alives cada pocos minutos y el servidor puede enviar mensajes instantáneamente. Así es como funciona Gmail, Google Talk, etc.

Answer 17

Firebase Cloud Messaging (FCM) es la nueva versión de GCM. FCM es una solución de mensajería multiplataforma que le permite enviar mensajes de forma segura y gratuita. Hereda la infraestructura central de GCM para entregar mensajes de manera confiable en Android, iOS, Web (javascript), Unity y C ++.

A partir del 10 de abril de 2018, Google ha desaprobado el GCM. Las API de servidor y cliente de GCM están en desuso y se eliminarán el 11 de abril de 2019. Google recomienda migrar las aplicaciones de GCM a Firebase Cloud Messaging (FCM), que hereda la infraestructura de GCM confiable y escalable.

Resource

Answer 18

Aquí he escrito algunos pasos para Cómo obtener RegID y notificación a partir de cero

1. Crear / Registrar aplicación en Google Cloud
2. Configurar Cloud SDK con Desarrollo
3. Configurar proyecto para GCM
4. Obtener ID de registro del dispositivo
5. Enviar notificaciones push
6. Recibir notificaciones push

Puedes encontrar el tutorial completo en el siguiente enlace de URL

Comenzando con la Notificación Push de Android: el último Google Cloud Messaging (GCM) - tutorial completo paso a paso

Recorte del código para obtener el ID de registro (token de dispositivo para notificación push).

Configurar proyecto para GCM

Actualizar el archivo AndroidManifest

Para habilitar GCM en nuestro proyecto, necesitamos agregar pocos permisos en nuestro archivo de manifiesto Vaya a AndroidManifest.xml y agregue el código a continuación Agregar permiso

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

Agregar la declaración del receptor de difusión GCM

agregue la declaración del receptor de difusión GCM en su etiqueta de aplicación

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

Agregar declaración de servicio GCM

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

Obtener ID de registro (token de dispositivo para notificación push)

Ahora ve a tu Actividad de Lanzamiento / Splash

Añadir constantes y variables de clase

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;

Actualizar los métodos OnCreate y OnResume

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

Nota : almacene REGISTRATION_KEY, es importante para enviar el Mensaje PN a GCM. Tenga en cuenta que esto será único para todos los dispositivos, ya que solo GCM enviará notificaciones push.

Recibir notificaciones push

Añadir GCM Broadcast Receiver Class

Como ya hemos declarado "GcmBroadcastReceiver.java" en nuestro archivo Manifest, creamos este código de clase de receptor de actualización de clase de esta manera

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

Agregar clase de servicio GCM

Como ya hemos declarado "GcmBroadcastReceiver.java" en nuestro archivo Manifest, creamos este código de clase de receptor de actualización de clase de esta manera

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

Answer 19

Android Cloud to Device Messaging Framework

Importante: C2DM ha quedado oficialmente en desuso el 26 de junio de 2012. Esto significa que C2DM ha dejado de aceptar nuevos usuarios y solicitudes de cuotas. No se agregarán nuevas funciones a C2DM. Sin embargo, las aplicaciones que utilizan C2DM continuarán funcionando. Se recomienda a los desarrolladores de C2DM existentes que migren a la nueva versión de C2DM, llamada Google Cloud Messaging para Android (GCM). Consulte el documento Migración de C2DM a GCM para obtener más información. Los desarrolladores deben usar GCM para nuevos desarrollos.

Por favor revise el siguiente enlace:

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

Answer 20

Método gratuito y fácil:

Si su base de usuarios objetivo no es grande (menos de 1000) y desea comenzar con un servicio gratuito, Airbop es el mejor y más conveniente.

Sitio web de Airbop Utiliza el servicio Google Cloud Messaging a través de su API y proporciona un buen rendimiento. Lo he usado para dos de mis proyectos y fue fácil implementarlo.

Los servicios como y Urbanship son excelentes, pero proporcionan una pila de implementación completa y no solo las notificaciones push.

Si su único objetivo es el servicio push, Airbop funcionará bien.

No he usado PushWoosh , pero también es una gran opción. Permite empujar a 1.000.000 dispositivos de forma gratuita.