Normal Notification Builder no muestra notificaciones en Android O.
¿Cómo puedo mostrar notificaciones en Android 8 Oreo?
¿Hay algún código nuevo que agregar para mostrar notificaciones en Android O?
Normal Notification Builder no muestra notificaciones en Android O.
¿Cómo puedo mostrar notificaciones en Android 8 Oreo?
¿Hay algún código nuevo que agregar para mostrar notificaciones en Android O?
Respuestas:
En Android O es imprescindible usar un canal con su generador de notificaciones
a continuación hay un código de muestra:
// Sets an ID for the notification, so it can be updated.
int notifyID = 1;
String CHANNEL_ID = "my_channel_01";// The id of the channel.
CharSequence name = getString(R.string.channel_name);// The user-visible name of the channel.
int importance = NotificationManager.IMPORTANCE_HIGH;
NotificationChannel mChannel = new NotificationChannel(CHANNEL_ID, name, importance);
// Create a notification and set the notification channel.
Notification notification = new Notification.Builder(MainActivity.this)
.setContentTitle("New Message")
.setContentText("You've received new messages.")
.setSmallIcon(R.drawable.ic_notify_status)
.setChannelId(CHANNEL_ID)
.build();
O con compatibilidad de manejo por:
NotificationCompat notification =
new NotificationCompat.Builder(this)
.setSmallIcon(R.drawable.notification_icon)
.setContentTitle("My notification")
.setContentText("Hello World!")
.setChannelId(CHANNEL_ID).build();
NotificationManager mNotificationManager =
(NotificationManager) getSystemService(Context.NOTIFICATION_SERVICE);
mNotificationManager.createNotificationChannel(mChannel);
// Issue the notification.
mNotificationManager.notify(notifyID , notification);
o si quieres una solución simple, usa el siguiente código:
NotificationManager mNotificationManager =
(NotificationManager) getSystemService(Context.NOTIFICATION_SERVICE);
if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
mNotificationManager.createNotificationChannel(mChannel);
}
Actualizaciones: referencia NotificationCompat.Builder
NotificationCompat.Builder(Context context)
Este constructor quedó en desuso en el nivel de API 26.0.0, por lo que debe usar
Builder(Context context, String channelId)
así que no es necesario setChannelId
con el nuevo constructor.
Y debe usar la última biblioteca de AppCompat actualmente 26.0.2
compile "com.android.support:appcompat-v7:26.0.+"
Fuente del canal de desarrolladores de Android en Youtube
Además, puedes consultar los documentos oficiales de Android
NotificationCompat.Builder(Context, String)
constructor? Estoy usando (entre otras cosas): - compileSdkVersion 26
- buildToolsVersion '26.0.2'
- compile 'com.android.support:appcompat-v7:26.0.0-beta2'
y aún así no acepta mi constructor usando un Context and String. ¿Algunas ideas?
Aquí publico algunas funciones de solución rápida con manejo de intenciones
public void showNotification(Context context, String title, String body, Intent intent) {
NotificationManager notificationManager = (NotificationManager) context.getSystemService(Context.NOTIFICATION_SERVICE);
int notificationId = 1;
String channelId = "channel-01";
String channelName = "Channel Name";
int importance = NotificationManager.IMPORTANCE_HIGH;
if (android.os.Build.VERSION.SDK_INT >= android.os.Build.VERSION_CODES.O) {
NotificationChannel mChannel = new NotificationChannel(
channelId, channelName, importance);
notificationManager.createNotificationChannel(mChannel);
}
NotificationCompat.Builder mBuilder = new NotificationCompat.Builder(context, channelId)
.setSmallIcon(R.mipmap.ic_launcher)
.setContentTitle(title)
.setContentText(body);
TaskStackBuilder stackBuilder = TaskStackBuilder.create(context);
stackBuilder.addNextIntent(intent);
PendingIntent resultPendingIntent = stackBuilder.getPendingIntent(
0,
PendingIntent.FLAG_UPDATE_CURRENT
);
mBuilder.setContentIntent(resultPendingIntent);
notificationManager.notify(notificationId, mBuilder.build());
}
Además de esta respuesta , debe crear el canal de notificación antes de que pueda usarse.
if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
/* Create or update. */
NotificationChannel channel = new NotificationChannel("my_channel_01",
"Channel human readable title",
NotificationManager.IMPORTANCE_DEFAULT);
mNotificationManager.createNotificationChannel(channel);
}
También debe usar canales solo si su targetSdkVersion es 26 o superior.
Si está utilizando NotificationCompat.Builder, también necesita actualizar a la versión beta de la biblioteca de soporte: https://developer.android.com/topic/libraries/support-library/revisions.html#26-0-0- beta2 (para poder llamar setChannelId
al generador de compatibilidad).
Tenga cuidado ya que esta actualización de la biblioteca eleva minSdkLevel a 14.
public class MyFirebaseMessagingServices extends FirebaseMessagingService {
private NotificationChannel mChannel;
private NotificationManager notifManager;
@Override
public void onMessageReceived(RemoteMessage remoteMessage) {
if (remoteMessage.getData().size() > 0) {
try {
JSONObject jsonObject = new JSONObject(remoteMessage.getData());
displayCustomNotificationForOrders(jsonObject.getString("title"), jsonObject.getString("description"));
} catch (JSONException e) {
e.printStackTrace();
}
}
}
private void displayCustomNotificationForOrders(String title, String description) {
if (notifManager == null) {
notifManager = (NotificationManager) getSystemService
(Context.NOTIFICATION_SERVICE);
}
if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
NotificationCompat.Builder builder;
Intent intent = new Intent(this, Dashboard.class);
intent.addFlags(Intent.FLAG_ACTIVITY_CLEAR_TOP);
PendingIntent pendingIntent;
int importance = NotificationManager.IMPORTANCE_HIGH;
if (mChannel == null) {
mChannel = new NotificationChannel
("0", title, importance);
mChannel.setDescription(description);
mChannel.enableVibration(true);
notifManager.createNotificationChannel(mChannel);
}
builder = new NotificationCompat.Builder(this, "0");
intent.setFlags(Intent.FLAG_ACTIVITY_CLEAR_TOP |
Intent.FLAG_ACTIVITY_SINGLE_TOP);
pendingIntent = PendingIntent.getActivity(this, 1251, intent, PendingIntent.FLAG_ONE_SHOT);
builder.setContentTitle(title)
.setSmallIcon(getNotificationIcon()) // required
.setContentText(description) // required
.setDefaults(Notification.DEFAULT_ALL)
.setAutoCancel(true)
.setLargeIcon(BitmapFactory.decodeResource
(getResources(), R.mipmap.logo))
.setBadgeIconType(R.mipmap.logo)
.setContentIntent(pendingIntent)
.setSound(RingtoneManager.getDefaultUri
(RingtoneManager.TYPE_NOTIFICATION));
Notification notification = builder.build();
notifManager.notify(0, notification);
} else {
Intent intent = new Intent(this, Dashboard.class);
intent.addFlags(Intent.FLAG_ACTIVITY_CLEAR_TOP);
PendingIntent pendingIntent = null;
pendingIntent = PendingIntent.getActivity(this, 1251, intent, PendingIntent.FLAG_ONE_SHOT);
Uri defaultSoundUri = RingtoneManager.getDefaultUri(RingtoneManager.TYPE_NOTIFICATION);
NotificationCompat.Builder notificationBuilder = new NotificationCompat.Builder(this)
.setContentTitle(title)
.setContentText(description)
.setAutoCancel(true)
.setColor(ContextCompat.getColor(getBaseContext(), R.color.colorPrimary))
.setSound(defaultSoundUri)
.setSmallIcon(getNotificationIcon())
.setContentIntent(pendingIntent)
.setStyle(new NotificationCompat.BigTextStyle().setBigContentTitle(title).bigText(description));
NotificationManager notificationManager = (NotificationManager) getSystemService(Context.NOTIFICATION_SERVICE);
notificationManager.notify(1251, notificationBuilder.build());
}
}
private int getNotificationIcon() {
boolean useWhiteIcon = (Build.VERSION.SDK_INT >= Build.VERSION_CODES.LOLLIPOP);
return useWhiteIcon ? R.mipmap.logo : R.mipmap.logo;
}
}
Si no puede recibir la notificación push en la versión 26+ SDK?
Su solución está aquí:
public static void showNotification(Context context, String title, String messageBody) {
boolean isLoggedIn = SessionManager.getInstance().isLoggedIn();
Log.e(TAG, "User logged in state: " + isLoggedIn);
Intent intent = null;
if (isLoggedIn) {
//goto notification screen
intent = new Intent(context, MainActivity.class);
intent.putExtra(Extras.EXTRA_JUMP_TO, DrawerItems.ITEM_NOTIFICATION);
} else {
//goto login screen
intent = new Intent(context, LandingActivity.class);
}
intent.addFlags(Intent.FLAG_ACTIVITY_CLEAR_TOP);
PendingIntent pendingIntent = PendingIntent.getActivity(context, 0 /* Request code */, intent, PendingIntent.FLAG_ONE_SHOT);
//Uri defaultSoundUri= RingtoneManager.getDefaultUri(RingtoneManager.TYPE_NOTIFICATION);
//Bitmap largeIcon = BitmapFactory.decodeResource(getResources(), R.drawable.ic_app_notification_icon);
String channel_id = createNotificationChannel(context);
NotificationCompat.Builder notificationBuilder = new NotificationCompat.Builder(context, channel_id)
.setContentTitle(title)
.setContentText(messageBody)
.setStyle(new NotificationCompat.BigTextStyle().bigText(messageBody))
/*.setLargeIcon(largeIcon)*/
.setSmallIcon(R.drawable.app_logo_color) //needs white icon with transparent BG (For all platforms)
.setColor(ContextCompat.getColor(context, R.color.colorPrimaryDark))
.setVibrate(new long[]{1000, 1000})
.setSound(Settings.System.DEFAULT_NOTIFICATION_URI)
.setContentIntent(pendingIntent)
.setPriority(Notification.PRIORITY_HIGH)
.setAutoCancel(true);
NotificationManager notificationManager = (NotificationManager) context.getSystemService(Context.NOTIFICATION_SERVICE);
notificationManager.notify((int) ((new Date(System.currentTimeMillis()).getTime() / 1000L) % Integer.MAX_VALUE) /* ID of notification */, notificationBuilder.build());
}
public static String createNotificationChannel(Context context) {
// NotificationChannels are required for Notifications on O (API 26) and above.
if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
// The id of the channel.
String channelId = "Channel_id";
// The user-visible name of the channel.
CharSequence channelName = "Application_name";
// The user-visible description of the channel.
String channelDescription = "Application_name Alert";
int channelImportance = NotificationManager.IMPORTANCE_DEFAULT;
boolean channelEnableVibrate = true;
// int channelLockscreenVisibility = Notification.;
// Initializes NotificationChannel.
NotificationChannel notificationChannel = new NotificationChannel(channelId, channelName, channelImportance);
notificationChannel.setDescription(channelDescription);
notificationChannel.enableVibration(channelEnableVibrate);
// notificationChannel.setLockscreenVisibility(channelLockscreenVisibility);
// Adds NotificationChannel to system. Attempting to create an existing notification
// channel with its original values performs no operation, so it's safe to perform the
// below sequence.
NotificationManager notificationManager = (NotificationManager) context.getSystemService(Context.NOTIFICATION_SERVICE);
assert notificationManager != null;
notificationManager.createNotificationChannel(notificationChannel);
return channelId;
} else {
// Returns null for pre-O (26) devices.
return null;
}
}
NotificationCompat.Builder notifyBuilder = new NotificationCompat.Builder (context, channel_id)
-> Aquí recibirá una notificación push usando channel_id
automáticas en su dispositivo, que consiste en una versión de 26+ SDK.
-> Porque, el NotificationCompat.Builder(context)
método está en desuso ahora usará una versión actualizada que tiene dos parámetros, uno es el contexto y el otro es channel_id.
-> NotificationCompat.Builder(context, channel_id)
método actualizado. intentalo.
-> En la versión 26+ SDK del dispositivo, creará channel_id cada vez.
Utilice esta clase para la notificación de Android 8
public class NotificationHelper {
private Context mContext;
private NotificationManager mNotificationManager;
private NotificationCompat.Builder mBuilder;
public static final String NOTIFICATION_CHANNEL_ID = "10001";
public NotificationHelper(Context context) {
mContext = context;
}
/**
* Create and push the notification
*/
public void createNotification(String title, String message)
{
/**Creates an explicit intent for an Activity in your app**/
Intent resultIntent = new Intent(mContext , SomeOtherActivity.class);
resultIntent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
PendingIntent resultPendingIntent = PendingIntent.getActivity(mContext,
0 /* Request code */, resultIntent,
PendingIntent.FLAG_UPDATE_CURRENT);
mBuilder = new NotificationCompat.Builder(mContext);
mBuilder.setSmallIcon(R.mipmap.ic_launcher);
mBuilder.setContentTitle(title)
.setContentText(message)
.setAutoCancel(false)
.setSound(Settings.System.DEFAULT_NOTIFICATION_URI)
.setContentIntent(resultPendingIntent);
mNotificationManager = (NotificationManager) mContext.getSystemService(Context.NOTIFICATION_SERVICE);
if (android.os.Build.VERSION.SDK_INT >= android.os.Build.VERSION_CODES.O)
{
int importance = NotificationManager.IMPORTANCE_HIGH;
NotificationChannel notificationChannel = new NotificationChannel(NOTIFICATION_CHANNEL_ID, "NOTIFICATION_CHANNEL_NAME", importance);
notificationChannel.enableLights(true);
notificationChannel.setLightColor(Color.RED);
notificationChannel.enableVibration(true);
notificationChannel.setVibrationPattern(new long[]{100, 200, 300, 400, 500, 400, 300, 200, 400});
assert mNotificationManager != null;
mBuilder.setChannelId(NOTIFICATION_CHANNEL_ID);
mNotificationManager.createNotificationChannel(notificationChannel);
}
assert mNotificationManager != null;
mNotificationManager.notify(0 /* Request Code */, mBuilder.build());
}
}
Prueba este código:
public class FirebaseMessagingServices extends com.google.firebase.messaging.FirebaseMessagingService {
private static final String TAG = "MY Channel";
Bitmap bitmap;
@Override
public void onMessageReceived(RemoteMessage remoteMessage) {
super.onMessageReceived(remoteMessage);
Utility.printMessage(remoteMessage.getNotification().getBody());
// Check if message contains a data payload.
if (remoteMessage.getData().size() > 0) {
Log.d(TAG, "Message data payload: " + remoteMessage.getData());
String title = remoteMessage.getData().get("title");
String body = remoteMessage.getData().get("body");
String message = remoteMessage.getData().get("message");
String imageUri = remoteMessage.getData().get("image");
String msg_id = remoteMessage.getData().get("msg-id");
Log.d(TAG, "1: " + title);
Log.d(TAG, "2: " + body);
Log.d(TAG, "3: " + message);
Log.d(TAG, "4: " + imageUri);
if (imageUri != null)
bitmap = getBitmapfromUrl(imageUri);
}
sendNotification(message, bitmap, title, msg_id);
}
}
private void sendNotification(String message, Bitmap image, String title,String msg_id) {
int notifyID = 0;
try {
notifyID = Integer.parseInt(msg_id);
} catch (NumberFormatException e) {
e.printStackTrace();
}
String CHANNEL_ID = "my_channel_01"; // The id of the channel.
Intent intent = new Intent(this, HomeActivity.class);
intent.putExtra("title", title);
intent.putExtra("message", message);
intent.addFlags(Intent.FLAG_ACTIVITY_CLEAR_TOP);
PendingIntent pendingIntent = PendingIntent.getActivity(this, 0 /* Request code */, intent,
PendingIntent.FLAG_ONE_SHOT);
Uri defaultSoundUri = RingtoneManager.getDefaultUri(RingtoneManager.TYPE_NOTIFICATION);
NotificationCompat.Builder notificationBuilder = new NotificationCompat.Builder(this, "01")
.setContentTitle(title)
.setSmallIcon(R.mipmap.ic_notification)
.setStyle(new NotificationCompat.BigTextStyle()
.bigText(message))
.setContentText(message)
.setAutoCancel(true)
.setSound(defaultSoundUri)
.setChannelId(CHANNEL_ID)
.setContentIntent(pendingIntent);
if (image != null) {
notificationBuilder.setStyle(new NotificationCompat.BigPictureStyle() //Set the Image in Big picture Style with text.
.bigPicture(image)
.setSummaryText(message)
.bigLargeIcon(null));
}
NotificationManager notificationManager =
(NotificationManager) getSystemService(Context.NOTIFICATION_SERVICE);
if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) { // For Oreo and greater than it, we required Notification Channel.
CharSequence name = "My New Channel"; // The user-visible name of the channel.
int importance = NotificationManager.IMPORTANCE_HIGH;
NotificationChannel channel = new NotificationChannel(CHANNEL_ID,name, importance); //Create Notification Channel
notificationManager.createNotificationChannel(channel);
}
notificationManager.notify(notifyID /* ID of notification */, notificationBuilder.build());
}
public Bitmap getBitmapfromUrl(String imageUrl) { //This method returns the Bitmap from Url;
try {
URL url = new URL(imageUrl);
HttpURLConnection connection = (HttpURLConnection) url.openConnection();
connection.setDoInput(true);
connection.connect();
InputStream input = connection.getInputStream();
Bitmap bitmap = BitmapFactory.decodeStream(input);
return bitmap;
} catch (Exception e) {
// TODO Auto-generated catch block
e.printStackTrace();
return null;
}
}
}
Aplicación de demostración de notificaciones de Android para Android O, así como versiones inferiores de API. Aquí está la mejor aplicación de demostración en GitHub-Demo 1 y GitHub-Demo 2 .
Este es un error en la versión 11.8.0 de la API de Firebase, por lo que si reduce la versión de API no enfrentará este problema.
Estaba teniendo el mismo problema en Oreo y descubrí que si primero creas tu canal con NotificationManager.IMPORTANCE_NONE, luego lo actualizas más tarde, el canal mantendrá el nivel de importancia original.
Esto está respaldado por la documentación de capacitación de Notificación de Google que dice:
Después de crear un canal de notificación, no puede cambiar los comportamientos de notificación: el usuario tiene control total en ese punto.
Eliminar y volver a instalar la aplicación te permitirá restablecer los comportamientos del canal.
Es mejor evitar usar IMPORTANCE_NONE a menos que desee suprimir las notificaciones para ese canal, es decir, hacer uso de notificaciones silenciosas.
Así es como lo haces
private fun sendNotification() {
val notificationId = 100
val chanelid = "chanelid"
val intent = Intent(this, MainActivity::class.java)
intent.setFlags(Intent.FLAG_ACTIVITY_NEW_TASK or Intent.FLAG_ACTIVITY_CLEAR_TASK)
val pendingIntent = PendingIntent.getActivity(this, 0, intent, 0)
if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) { // you must create a notification channel for API 26 and Above
val name = "my channel"
val description = "channel description"
val importance = NotificationManager.IMPORTANCE_DEFAULT
val channel = NotificationChannel(chanelid, name, importance);
channel.setDescription(description);
// Register the channel with the system; you can't change the importance
// or other notification behaviors after this
val notificationManager = getSystemService(NotificationManager::class.java)
notificationManager.createNotificationChannel(channel)
}
val mBuilder = NotificationCompat.Builder(this, chanelid)
.setSmallIcon(R.drawable.ic_notification)
.setContentTitle("Want to Open My App?")
.setContentText("Open my app and see good things")
.setPriority(NotificationCompat.PRIORITY_DEFAULT)
.setContentIntent(pendingIntent)
.setAutoCancel(true) // cancel the notification when clicked
.addAction(R.drawable.ic_check, "YES", pendingIntent) //add a btn to the Notification with a corresponding intent
val notificationManager = NotificationManagerCompat.from(this);
notificationManager.notify(notificationId, mBuilder.build());
}
Lea el tutorial completo en => https://developer.android.com/training/notify-user/build-notification
CHANNEL_ID
en NotificationChannel y Notification.Builder debe ser el mismo, pruebe este código:
String CHANNEL_ID = "my_channel_01";
NotificationChannel channel = new NotificationChannel(CHANNEL_ID, "Solveta Unread", NotificationManager.IMPORTANCE_DEFAULT);
Notification.Builder notification = new Notification.Builder(getApplicationContext(), CHANNEL_ID);
Bueno, en mi caso, tengo Android 8.1.0 y número de modelo vivo1811 , y he intentado con todas las soluciones anteriores, pero nada funciona.
Así que, por fin, escribí al soporte de Firebase y luego sobre la depuración adicional, recibí esto: "No se pudo transmitir a la aplicación detenida": asegúrese de que la aplicación no se haya detenido por la fuerza " .
Y esta fue la respuesta del equipo de Firebase ->
Este es un problema conocido causado por una optimización de la batería implementada por algunos OEM. Cuando se desliza una aplicación en el conmutador de aplicaciones, la aplicación se trata como si se hubiera detenido forzosamente, lo que no es el comportamiento predeterminado de Android. El desafortunado efecto secundario de esto es que puede hacer que el servicio FCM de su aplicación deje de ejecutarse. Estamos trabajando para mejorar este comportamiento desde nuestro extremo, pero la solución real debe venir del lado del OEM.
Aquí OEM significa fabricante de equipos originales .
Para cualquiera que tenga dificultades con esto después de probar las soluciones anteriores, asegúrese de que la identificación del canal utilizada al crear el canal de notificación sea idéntica a la identificación del canal que configuró en el generador de notificaciones.
const val CHANNEL_ID = "EXAMPLE_CHANNEL_ID"
// create notification channel
val notificationChannel = NotificationChannel(CHANNEL_ID,
NOTIFICATION_NAME, NotificationManager.IMPORTANCE_HIGH)
// building notification
NotificationCompat.Builder(context)
.setSmallIcon(android.R.drawable.ic_input_add)
.setContentTitle("Title")
.setContentText("Subtitle")
.setPriority(NotificationCompat.PRIORITY_MAX)
.setChannelId(CHANNEL_ID)
private void addNotification() {
NotificationCompat.Builder builder =
new NotificationCompat.Builder(this)
.setSmallIcon(R.drawable.ic_launcher_background)
.setContentTitle("Notifications Example")
.setContentText("This is a test notification");
Intent notificationIntent = new Intent(this, MainActivity.class);
PendingIntent contentIntent = PendingIntent.getActivity(this, 0, notificationIntent,
PendingIntent.FLAG_UPDATE_CURRENT);
builder.setContentIntent(contentIntent);
// Add as notification
NotificationManager manager = (NotificationManager) getSystemService(Context.NOTIFICATION_SERVICE);
if (android.os.Build.VERSION.SDK_INT >= android.os.Build.VERSION_CODES.O)
{
NotificationChannel nChannel = new NotificationChannel(NOTIFICATION_CHANNEL_ID, "NOTIFICATION_CHANNEL_NAME", NotificationManager.IMPORTANCE_HIGH);
nChannel.enableLights(true);
assert manager != null;
builder.setChannelId(NOTIFICATION_CHANNEL_ID);
manager.createNotificationChannel(nChannel);
}
assert manager != null;
manager.notify(0, builder.build());
}
El siguiente método mostrará la notificación , con texto grande y congelación habilitada (la notificación no se eliminará incluso después de deslizar el usuario). Necesitamos el servicio NotificationManager
public static void showNotificationOngoing(Context context,String title) {
NotificationManager notificationManager =
(NotificationManager) context.getSystemService(NOTIFICATION_SERVICE);
PendingIntent contentIntent = PendingIntent.getActivity(context, 0,
new Intent(context, MainActivity.class), PendingIntent.FLAG_UPDATE_CURRENT);
Notification.Builder notificationBuilder = new Notification.Builder(context)
.setContentTitle(title + DateFormat.getDateTimeInstance().format(new Date()) + ":" + accuracy)
.setContentText(addressFragments.toString())
.setSmallIcon(R.mipmap.ic_launcher)
.setContentIntent(contentIntent)
.setOngoing(true)
.setStyle(new Notification.BigTextStyle().bigText(addressFragments.toString()))
.setAutoCancel(true);
notificationManager.notify(3, notificationBuilder.build());
}
Método para eliminar notificaciones
public static void removeNotification(Context context){
NotificationManager notificationManager =
(NotificationManager) context.getSystemService(NOTIFICATION_SERVICE);
notificationManager.cancelAll();
}
Enlace fuente
fun pushNotification(message: String?, clickAtion: String?) {
val ii = Intent(clickAtion)
ii.addFlags(Intent.FLAG_ACTIVITY_CLEAR_TOP)
val pendingIntent = PendingIntent.getActivity(this, REQUEST_CODE, ii, PendingIntent.FLAG_ONE_SHOT)
val soundUri = RingtoneManager.getDefaultUri(RingtoneManager.TYPE_NOTIFICATION)
val largIcon = BitmapFactory.decodeResource(applicationContext.resources,
R.mipmap.ic_launcher)
val notificationManager = getSystemService(Context.NOTIFICATION_SERVICE) as NotificationManager
val channelId = "default_channel_id"
val channelDescription = "Default Channel"
// Since android Oreo notification channel is needed.
//Check if notification channel exists and if not create one
if (android.os.Build.VERSION.SDK_INT >= android.os.Build.VERSION_CODES.O) {
var notificationChannel = notificationManager.getNotificationChannel(channelId)
if (notificationChannel != null) {
val importance = NotificationManager.IMPORTANCE_HIGH //Set the importance level
notificationChannel = NotificationChannel(channelId, channelDescription, importance)
// notificationChannel.lightColor = Color.GREEN //Set if it is necesssary
notificationChannel.enableVibration(true) //Set if it is necesssary
notificationManager.createNotificationChannel(notificationChannel)
val noti_builder = NotificationCompat.Builder(this)
.setContentTitle("MMH")
.setContentText(message)
.setSmallIcon(R.drawable.ic_launcher_background)
.setChannelId(channelId)
.build()
val random = Random()
val id = random.nextInt()
notificationManager.notify(id,noti_builder)
}
}
else
{
val notificationBuilder = NotificationCompat.Builder(this)
.setSmallIcon(R.mipmap.ic_launcher).setColor(resources.getColor(R.color.colorPrimary))
.setVibrate(longArrayOf(200, 200, 0, 0, 0))
.setContentTitle(getString(R.string.app_name))
.setLargeIcon(largIcon)
.setContentText(message)
.setAutoCancel(true)
.setStyle(NotificationCompat.BigTextStyle().bigText(message))
.setSound(soundUri)
.setContentIntent(pendingIntent)
val random = Random()
val id = random.nextInt()
notificationManager.notify(id, notificationBuilder.build())
}
}
El siguiente código funciona para mí en Oreo, puedes probar esto. espero que funcione para ti
private Void sendNotification (Contexto ctx, Título de cadena, Número de notificación int, Mensaje de cadena, Subtexto de cadena, Intención de intención) {
try {
PendingIntent pendingIntent = PendingIntent.getActivity(ctx, notificationNumber, intent,
PendingIntent.FLAG_UPDATE_CURRENT);
Uri url = null;
NotificationCompat.Builder notificationBuilder = null;
try {
if (Build.VERSION.SDK_INT >= 26) {
try{
NotificationManager notificationManager = (NotificationManager)getApplicationContext().getSystemService(Context.NOTIFICATION_SERVICE);
notificationManager.deleteNotificationChannel(CHANNEL_ID_1);
notificationManager.deleteNotificationChannel(CHANNEL_ID_2);
if(!intent.getStringExtra("type").equalsIgnoreCase(""+TYPE_REQUEST)){
NotificationChannel breaking = new NotificationChannel(CHANNEL_ID_1, CHANNEL_ID_1_NAME, NotificationManager.IMPORTANCE_HIGH);
breaking.setShowBadge(false);
breaking.enableLights(true);
breaking.enableVibration(true);
breaking.setLightColor(Color.WHITE);
breaking.setVibrationPattern(new long[]{100, 200, 100, 200, 100, 200, 100});
breaking.setSound(url,new AudioAttributes.Builder().build());
notificationBuilder = new NotificationCompat.Builder(this,CHANNEL_ID_1)
.setSmallIcon(R.mipmap.ic_launcher);
notificationManager.createNotificationChannel(breaking);
}else{
NotificationChannel politics = new NotificationChannel(CHANNEL_ID_2,CHANNEL_ID_2_NAME, NotificationManager.IMPORTANCE_DEFAULT);
politics.setShowBadge(false);
politics.enableLights(true);
politics.enableVibration(true);
politics.setLightColor(Color.BLUE);
politics.setVibrationPattern(new long[]{100, 200, 100, 200, 100});
politics.setSound(url,new AudioAttributes.Builder().build());
notificationBuilder = new NotificationCompat.Builder(this,CHANNEL_ID_2)
.setSmallIcon(R.mipmap.ic_launcher);
notificationManager.createNotificationChannel(politics);
}
}catch (Exception e){
e.printStackTrace();
}
} else {
notificationBuilder = new NotificationCompat.Builder(ctx)
.setSmallIcon(R.mipmap.ic_launcher);
}
} catch (Exception e) {
e.printStackTrace();
}
if (notificationBuilder == null) {
notificationBuilder = new NotificationCompat.Builder(ctx)
.setSmallIcon(R.mipmap.ic_launcher);
}
notificationBuilder.setContentTitle(title);
notificationBuilder.setSubText(subtext);
notificationBuilder.setAutoCancel(true);
notificationBuilder.setContentIntent(pendingIntent);
notificationBuilder.setNumber(notificationNumber);
NotificationManager notificationManager =
(NotificationManager) ctx.getSystemService(Context.NOTIFICATION_SERVICE);
notificationManager.notify(notificationNumber, notificationBuilder.build());
} catch (Exception e) {
e.printStackTrace();
}
}
En Android Oreo, la aplicación de notificación se realiza mediante el uso de canales y la clase NotificationHelper. Debe tener una identificación y un nombre de canal.
Primero tienes que crear una clase NotificationHelper
public class NotificationHelper extends ContextWrapper {
private static final String EDMT_CHANNEL_ID="com.example.safna.notifier1.EDMTDEV";
private static final String EDMT_CHANNEL_NAME="EDMTDEV Channel";
private NotificationManager manager;
public NotificationHelper(Context base)
{
super(base);
createChannels();
}
private void createChannels()
{
NotificationChannel edmtChannel=new NotificationChannel(EDMT_CHANNEL_ID,EDMT_CHANNEL_NAME,NotificationManager.IMPORTANCE_DEFAULT);
edmtChannel.enableLights(true);
edmtChannel.enableVibration(true);
edmtChannel.setLightColor(Color.GREEN);
edmtChannel.setLockscreenVisibility(Notification.VISIBILITY_PRIVATE);
getManager().createNotificationChannel(edmtChannel);
}
public NotificationManager getManager()
{
if (manager==null)
manager=(NotificationManager)getSystemService(Context.NOTIFICATION_SERVICE);
return manager;
}
public NotificationCompat.Builder getEDMTChannelNotification(String title,String body)
{
return new NotificationCompat.Builder(getApplicationContext(),EDMT_CHANNEL_ID)
.setContentText(body)
.setContentTitle(title)
.setSmallIcon(R.mipmap.ic_launcher_round)
.setAutoCancel(true);
}
}
Cree un botón en el archivo xml de actividad, luego en la actividad principal
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
helper=new NotificationHelper(this);
btnSend=(Button)findViewById(R.id.btnSend);
btnSend.setOnClickListener(new View.OnClickListener() {
@Override
public void onClick(View v) {
String title="Title";
String content="Content";
Notification.Builder builder=helper.getEDMTChannelNotification(title,content);
helper.getManager().notify(new Random().nextInt(),builder.build());
}
});
}
Luego ejecuta tu proyecto
Debe crear un canal de notificación para el nivel de API superior a 26 (oreo).
`NotificationChannel channel = new NotificationChannel(STRING_ID,CHANNEL_NAME,NotificationManager.IMPORTANCE_HIGH);
STRING_ID = stringid channelid es el mismo que en Notification.Builder como este
`Notification notification = new Notification.Builder(this,STRING_ID)
.setSmallIcon(android.R.drawable.ic_menu_help)
.setContentTitle("Hello Notification")
.setContentText("It is Working")
.setContentIntent(pendingIntent)
.build();`
La identificación del canal en la notificación y en la notificación debe ser la misma. El código completo es así ...
@RequiresApi(api = Build.VERSION_CODES.O)
private void callNotification2() {
Intent intent = new Intent(getApplicationContext(),MainActivity.class);
PendingIntent pendingIntent = PendingIntent.getActivity(this,11,
intent,PendingIntent.FLAG_UPDATE_CURRENT);
Notification notification = new Notification.Builder(this,"22")
.setSmallIcon(android.R.drawable.ic_menu_help)
.setContentTitle("Hello Notification")
.setContentText("It is Working")
.setContentIntent(pendingIntent)
.build();
NotificationChannel channel = new
NotificationChannel("22","newName",NotificationManager.IMPORTANCE_HIGH);
NotificationManager manager = (NotificationManager)
getSystemService(NOTIFICATION_SERVICE);
manager.createNotificationChannel(channel);
manager.notify(11,notification);
}'
En primer lugar, si no sabe, desde Android Oreo, es decir, el nivel 26 de API, es obligatorio que las notificaciones se registren con un canal.
En ese caso, muchos tutoriales pueden confundirlo porque muestran un ejemplo diferente de notificación arriba o abajo.
Así que aquí hay un código común que se ejecuta en oreo arriba y abajo:
String CHANNEL_ID = "MESSAGE";
String CHANNEL_NAME = "MESSAGE";
NotificationManagerCompat manager = NotificationManagerCompat.from(MainActivity.this);
if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
NotificationChannel channel = new NotificationChannel(CHANNEL_ID, CHANNEL_NAME,
NotificationManager.IMPORTANCE_DEFAULT);
manager.createNotificationChannel(channel);
}
Notification notification = new NotificationCompat.Builder(MainActivity.this,CHANNEL_ID)
.setSmallIcon(R.drawable.ic_android_black_24dp)
.setContentTitle(TitleTB.getText().toString())
.setContentText(MessageTB.getText().toString())
.build();
manager.notify(getRandomNumber(), notification); // In case you pass a number instead of getRandoNumber() then the new notification will override old one and you wont have more then one notification so to do so u need to pass unique number every time so here is how we can do it by "getRandoNumber()"
private static int getRandomNumber() {
Date dd= new Date();
SimpleDateFormat ft =new SimpleDateFormat ("mmssSS");
String s=ft.format(dd);
return Integer.parseInt(s);
}
Video Tutorial: VIDEO DE YOUTUBE
En caso de que quiera descargar esta demo: Enlace GitHub
NotificationCompat.Builder notificationBuilder = new NotificationCompat.Builder(this, "CHANNEL_ID")
........
NotificationManager mNotificationManager =
(NotificationManager) getSystemService(Context.NOTIFICATION_SERVICE);
if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
CharSequence name = "Hello";// The user-visible name of the channel.
int importance = NotificationManager.IMPORTANCE_HIGH;
NotificationChannel mChannel = new NotificationChannel(CHANNEL_ID, name, importance);
mNotificationManager.createNotificationChannel(mChannel);
}
mNotificationManager.notify(notificationId, notificationBuilder.build());