LocalNotification avec AlarmManager et BroadcastReceiver pas de tir Android, O (oreo)

Bonjour j'ai mes notifications locales en cours d'exécution sur les androïdes avant SDK 26

Mais dans un Android O j'ai le message d'avertissement suivant, et le récepteur de radiodiffusion n'est pas déclenché.

W/BroadcastQueue: Background execution not allowed: receiving Intent { act=package.name.action.LOCAL_NOTIFICATION cat=[com.category.LocalNotification] flg=0x14 (has extras) } to package.name/com.category.localnotifications.LocalNotificationReceiver

De ce que j'ai lu récepteurs de radiodiffusion sont plus limités dans android O, mais si oui, comment dois-je planifier la diffusion, si je le veux lancer, même si la principale activité n'est pas en cours d'exécution?

Dois-je utiliser les services au lieu de récepteurs?

C'est le AlarmManager lancer code:

public void Schedule(String aID, String aTitle, String aBody, int aNotificationCode, long aEpochTime)
{
    Bundle lExtras = new Bundle();
    lExtras.putInt("icon", f.getDefaultIcon());
    lExtras.putString("title", aTitle);
    lExtras.putString("message", aBody);
    lExtras.putString("id", aID);
    lExtras.putInt("requestcode", aNotificationCode);

    Intent lIntent = 
      new Intent(LocalNotificationScheduler.ACTION_NAME)
      .addCategory(NotificationsUtils.LocalNotifCategory)
      .putExtras(lExtras);

    PendingIntent lPendIntent = PendingIntent.getBroadcast(f.getApplicationContext(), aNotificationCode,
                                                           lIntent, PendingIntent.FLAG_UPDATE_CURRENT);

    AlarmManager lAlarmMgr = (AlarmManager) f.getSystemService(Context.ALARM_SERVICE);
    lAlarmMgr.set(AlarmManager.RTC, 1000, lPendIntent);
}

C'est le récepteur de code:

public class LocalNotificationReceiver extends BroadcastReceiver {

public static native void   nativeReceiveLocalNotification (String aID, String aTitle, String aMessage, boolean aOnForeground );

/** This method receives the alarms set by LocalNotificationScheduler,
*   notifies the CAndroidNotifications c++ class, and (if needed) ships a notification banner 
*/
@Override
public void onReceive(Context aContext, Intent aIntent)
{
    Toast.makeText(context, text, duration).show();
}

}

C'est le manifeste:

<receiver android:name="com.category.localnotifications.LocalNotificationReceiver">
        <intent-filter>
            <action android:name="${applicationId}.action.LOCAL_NOTIFICATION" />
            <category android:name="com.category.LocalNotification" />
        </intent-filter>
    </receiver>

vérifier oreo lignes directrices, les services en arrière-plan a été supprimé. Utilisation planificateur de travail ou de la tâche lorsque l'application est en arrière plan.
Oui mais je veux recevoir une notification après un certain temps, même si l'activité principale n'est pas en cours d'exécution juste comme il était en marche avant. Est-ce possible?
Pouvez-vous essayer de démarrer l'intention explicitement comme dans gist.github.com/yccheok/d39b434470a4135104efae76ec75afc2 ?

OriginalL'auteur Hug | 2017-08-22

18

Android O sont assez nouveau à jour. Donc, j'essaye de digérer et de fournir que des informations aussi précises que possible.

De https://developer.android.com/about/versions/oreo/background.html#broadcasts
- Applications qui ciblent Android 8.0 ou supérieur ne peut plus s'inscrire récepteurs de radiodiffusion pour implicite des émissions dans leur manifeste.
  - Les applications peuvent utiliser Context.registerReceiver() lors de l'exécution d'enregistrer un récepteur pour tout émission, que implicite ou explicite.
- Apps pouvez continuer à vous inscrire explicite émissions dans leur manifeste.
Aussi, dans https://developer.android.com/training/scheduling/alarms.html , les exemples sont à l'aide de diffusion explicite, et ne mentionne rien de spécial concernant Android O.

Puis-je vous suggérer d'essayer de diffusion explicite que suivre?
```
public static void startAlarmBroadcastReceiver(Context context, long delay) {
    Intent _intent = new Intent(context, AlarmBroadcastReceiver.class);
    PendingIntent pendingIntent = PendingIntent.getBroadcast(context, 0, _intent, 0);
    AlarmManager alarmManager = (AlarmManager)context.getSystemService(Context.ALARM_SERVICE);
    //Remove any previous pending intent.
    alarmManager.cancel(pendingIntent);
    alarmManager.set(AlarmManager.RTC_WAKEUP, System.currentTimeMillis() + delay, pendingIntent);        
}
```
AlarmBroadcastReceiver
```
public class AlarmBroadcastReceiver extends BroadcastReceiver {


    @Override
    public void onReceive(Context context, Intent intent) {
    }

}
```
Dans AndroidManifest, il suffit de définir la classe comme
```
<receiver android:name="org.yccheok.AlarmBroadcastReceiver" >
</receiver>
```
Pouvez-vous s'il vous plaît corriger cette ligne Apps that target Android 8.0 or higher can no longer register broadcast receivers for implicit broadcasts avec celui-ci Apps that target Android 8.0 or higher can no longer register broadcast receivers for implicit broadcasts that are defined statically within our application manifest. Parce que, selon android docs developer.android.com/about/versions/oreo/... Contexte.registerReceiver() est encore autorisé au moment de l'exécution pour enregistrer un récepteur pour une diffusion quelconque, qu'il soit implicite ou explicite.

OriginalL'auteur Cheok Yan Cheng

Aujourd'hui, j'ai eu le même problème et ma notification n'a pas de travail. J'ai pensé Alarm manager ne travaille pas dans Oreo mais le problème était avec Notification. Dans Oreo nous avons besoin d'ajouter Channel id. Jetez un oeil dans mon nouveau code:

int notifyID = 1; 
String CHANNEL_ID = "your_name";//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(HomeActivity.this)
            .setContentTitle("Your title")
            .setContentText("Your message")
            .setSmallIcon(R.drawable.notification)
            .setChannelId(CHANNEL_ID)
            .build();

Cochez cette solution. Il a travaillé comme un charme.

https://stackoverflow.com/a/43093261/4698320

Je suis en train de montrer ma méthode:

public static void pendingListNotification(Context context, String totalCount) {
String CHANNEL_ID = "your_name";//The id of the channel.
CharSequence name = context.getResources().getString(R.string.app_name);//The user-visible name of the channel.
int importance = NotificationManager.IMPORTANCE_HIGH;
NotificationCompat.Builder mBuilder;
Intent notificationIntent = new Intent(context, HomeActivity.class);
Bundle bundle = new Bundle();
bundle.putString(AppConstant.PENDING_NOTIFICATION, AppConstant.TRUE);//PENDING_NOTIFICATION TRUE
notificationIntent.putExtras(bundle);
notificationIntent.setFlags(Intent.FLAG_ACTIVITY_CLEAR_TOP | Intent.FLAG_ACTIVITY_MULTIPLE_TASK);
PendingIntent contentIntent = PendingIntent.getActivity(context, 0, notificationIntent, PendingIntent.FLAG_UPDATE_CURRENT);
NotificationManager mNotificationManager = (NotificationManager) context.getSystemService(Context.NOTIFICATION_SERVICE);
if (android.os.Build.VERSION.SDK_INT >= 26) {
NotificationChannel mChannel = new NotificationChannel(CHANNEL_ID, name, importance);
mNotificationManager.createNotificationChannel(mChannel);
mBuilder = new NotificationCompat.Builder(context)
//               .setContentText("4")
.setSmallIcon(R.mipmap.logo)
.setPriority(Notification.PRIORITY_HIGH)
.setLights(Color.RED, 300, 300)
.setChannelId(CHANNEL_ID)
.setContentTitle(context.getResources().getString(R.string.yankee));
} else {
mBuilder = new NotificationCompat.Builder(context)
//               .setContentText("4")
.setSmallIcon(R.mipmap.logo)
.setPriority(Notification.PRIORITY_HIGH)
.setLights(Color.RED, 300, 300)
.setContentTitle(context.getResources().getString(R.string.yankee));
}
mBuilder.setContentIntent(contentIntent);
int defaults = 0;
defaults = defaults | Notification.DEFAULT_LIGHTS;
defaults = defaults | Notification.DEFAULT_VIBRATE;
defaults = defaults | Notification.DEFAULT_SOUND;
mBuilder.setDefaults(defaults);
mBuilder.setContentText(context.getResources().getString(R.string.you_have) + " " + totalCount + " " + context.getResources().getString(R.string.new_pending_delivery));//You have new pending delivery.
mBuilder.setAutoCancel(true);
mNotificationManager.notify(NOTIFICATION_ID, mBuilder.build());
}

OriginalL'auteur Däñish Shärmà

Créer le AlarmManager par la définition d'une intention explicite (définir explicitement le nom de la classe du récepteur de radiodiffusion):

private static PendingIntent getReminderReceiverIntent(Context context) {
Intent intent = new Intent("your_package_name.ReminderReceiver");
//create an explicit intent by defining a class
intent.setClass(context, ReminderReceiver.class);
PendingIntent pendingIntent = PendingIntent.getBroadcast(context, 0, intent, PendingIntent.FLAG_UPDATE_CURRENT);
return pendingIntent;
}

Aussi ne pas oublier de créer un canal de notification pour Android Oreo API (26) lors de la création de l'avis:

NotificationManager notificationManager = (NotificationManager) context.getSystemService(Context.NOTIFICATION_SERVICE);
if (VERSION.SDK_INT >= VERSION_CODES.O) {
notificationManager.createNotificationChannel(NotificationFactory.createNotificationChannel(context));
} else {
notificationManager.notify(NotificationsHelper.NOTIFICATION_ID_REMINDER, notificationBuilder.build());
}

OriginalL'auteur box

essayer ce code pour android O 8.1

Intent nIntent = new Intent("android.media.action.DISPLAY_NOTIFICATION");
nIntent.addCategory("android.intent.category.DEFAULT");
nIntent.putExtra("message", "test");
nIntent.setClass(this, AlarmReceiver.class);
PendingIntent broadcast = PendingIntent.getBroadcast(getAppContext(), 100, nIntent, PendingIntent.FLAG_UPDATE_CURRENT);

OriginalL'auteur keyur sojitra

Vous devez vous connecter pour publier un commentaire.

AlarmBroadcastReceiver