Android O - Ancien service de premier plan au démarrage fonctionnant toujours?

Donc, avec Android O, vous avez besoin de votre service en cours d'exécution comme un avant-plan service si vous souhaitez recevoir plus que juste un peu de l'emplacement des mises à jour à l'heure.

J'ai remarqué que l'ancienne méthode de démarrage d'un premier plan de service ne semble pas fonctionner sur O.
c'est à dire

startForeground(NOTIFICATION_ID, getNotification());

Selon les changements de comportement guide ici:
https://developer.android.com/preview/behavior-changes.html

La NotificationManager.startServiceInForeground() méthode commence par un premier plan de service. L'ancienne façon de commencer un premier plan de service ne fonctionne plus.

Si la nouvelle méthode ne fonctionne que lorsque le ciblage de O, il semble que l'ancienne méthode qui semble fonctionner sur un joint périphérique si le ciblage de O ou pas.

Modifier
Y compris par exemple:

Google exemple de projet LocationUpdatesForegroundService a effectivement un exemple de travail où vous pouvez voir le problème de première main.
https://github.com/googlesamples/android-play-location/tree/master/LocationUpdatesForegroundService

La startForeground méthode semble fonctionner sans problème si le ciblage et la compilation à l'encontre de l'API de niveau 25 OU le ciblage et la compilation de contre O (comme indiqué ici: https://developer.android.com/preview/migration.html#uya)

Donc, à reproduire:

Configurer l'application gradle comme mentionné dans le précédent lien
Ouvrez l'application
Demande de l'emplacement des mises à jour
Fermer l'application (soit via le bouton de retour ou le bouton d'accueil)

Service est en cours d'exécution dans le premier plan (indiqué par l'icône de notification de l'ombre). Emplacement des mises à jour sont à venir à travers comme prévu (toutes les 10 secondes), même sur un dispositif en cours d'exécution O. Ce que je suis en manque ici?

source d'informationauteur the_new_mr

Cela a fonctionné pour moi.

Dans la catégorie d'Activité, de service de démarrage à l'aide de startForegroundService() au lieu de startService()

    Intent myService = new Intent(this, MyService.class);

    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
        startForegroundService(myService);
    } else {
        startService(myService);
    }

Maintenant dans la classe de Service dans onStartCommand() faire comme suit

@Override
public int onStartCommand(Intent intent, int flags, int startId) {
    ......
    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {

        Notification.Builder builder = new Notification.Builder(this, ANDROID_CHANNEL_ID)
                .setContentTitle(getString(R.string.app_name))
                .setContentText(text)
                .setAutoCancel(true);

        Notification notification = builder.build();
        startForeground(1, notification);

    } else {

        NotificationCompat.Builder builder = new NotificationCompat.Builder(this)
                .setContentTitle(getString(R.string.app_name))
                .setContentText(text)
                .setPriority(NotificationCompat.PRIORITY_DEFAULT)
                .setAutoCancel(true);

        Notification notification = builder.build();

        startForeground(1, notification);
    }
    return START_NOT_STICKY;
}

Remarque: L'Utilisation De De Notification.Générateur de au lieu de NotificationCompat.Générateur de fait le travail. Seulement dans la Notification.Builder vous devez fournir l'ID de Canal qui est nouvelle fonctionnalité d'Android Oreo.

Espère que ça fonctionne!

5

Vous commencez généralement à votre service à partir d'un récepteur de radiodiffusion à l'aide de startService. Ils disent qu'il n'est plus possible (ou fiabilité) pour appeler startServicecar il existe maintenant d'arrière-plan des limites, de sorte que vous devez appeler startServiceInForeground à la place. Cependant à partir de docs c'est pas vraiment clair lorsque cela se produit parce que l'application est dans la liste blanche lorsqu'il reçoit une diffusion de l'intention, de sorte qu'il ne sait pas exactement quand startService jette IllegalStateException.
3

L'héritage de façon de commencer un premier plan de service fonctionne même quand l'application est au premier plan, mais la méthode recommandée pour démarrer un premier plan de service pour les Applications qui ciblent les API de niveau 26/Android O est l'utilisation de la nouvellement introduite NotificationManager#startServiceInForeground méthode pour créer un premier plan de service dans la première place.

L'ancien mode de démarrage du service en arrière-plan puis en faire la promotion à l'avant-plan ne fonctionnera pas si l'application est en arrière-plan, en raison de l'exécution en arrière-plan des limites de Android O.

Processus de Migration, et des mesures sont documentés ici. https://developer.android.com/preview/features/background.html#migration

Dans l'Activité (ou de tout contexte que démarre le premier plan de service), appelons cela:

ContextCompat.startForegroundService(context, serviceClass);

Lorsque le service a commencé, créer un canal de notification à l'aide du code similaire à ce que Android docs direpuis créer un et de l'utiliser:

final Builder builder = new NotificationCompat.Builder(context, CHANNEL_ID).setSmallIcon(...)//
            .setPriority(...).setCategory(...).setContentTitle(...).setContentText(...).setTicker(...);
//and maybe other preparations to the notification...
startForeground(notificationId, builder.build());

1

Comme aussi @Kislingk mentionné dans un commentaire NotificationManager.startServiceInForeground a été supprimé. Il a été marqué comme obsolète w/la s'engager 08992ac.

À partir de la validation du message:

Plutôt que d'exiger un a-priori de Notification être fourni pour
démarrer un service directement dans le premier plan de l'état, nous adoptons deux étapes
composé de fonctionnement de l'entreprise, du service en cours de travail, même à partir d'un
exécution en arrière-plan de l'état. Contexte#startForegroundService() n'est pas
l'objet à l'arrière-plan de restrictions, avec l'exigence que l'
service officiellement le premier plan de l'état via startForeground() à l'intérieur
5 secondes. Si le service ne le fait pas, il est arrêté par le système d'exploitation et
l'application est mise en cause avec un service de l'ANR.

- Je ajouter de l'échantillon si certains ont besoin avec backstack constructeur

    val notifyManager = getSystemService(NOTIFICATION_SERVICE) as NotificationManager
val playIntent    = Intent(this, this::class.java).setAction(PAUSE)
val cancelIntent  = Intent(this, this::class.java).setAction(EXIT)
val stop          = PendingIntent.getService(this, 1, playIntent, PendingIntent.FLAG_UPDATE_CURRENT)
val exit          = PendingIntent.getService(this, 2, cancelIntent, PendingIntent.FLAG_UPDATE_CURRENT)
val builder = if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
notifyManager.createNotificationChannel(NotificationChannel(NOTIFICATION_ID_CHANNEL_ID, getString(R.string.app_name), NotificationManager.IMPORTANCE_HIGH))
NotificationCompat.Builder(this, NOTIFICATION_ID_CHANNEL_ID)
} else
NotificationCompat.Builder(this)
builder.apply {
setContentTitle(station.name)
setContentText(metaToText(meta) )
setSmallIcon(R.drawable.ic_play_arrow_white_24px)
setAutoCancel(false)
if (Build.VERSION.SDK_INT < Build.VERSION_CODES.O) priority = Notification.PRIORITY_MAX
addAction(R.drawable.ic_stop_white_24px, getString(R.string.player_notification_stop), stop)
addAction(R.drawable.ic_close_white_24px, getString(R.string.player_notification_exit), exit)
}
val stackBuilder = TaskStackBuilder.create(this)
stackBuilder.addParentStack(PlayerActivity::class.java)
stackBuilder.addNextIntent(Intent(this, PlayerActivity::class.java))
builder.setContentIntent(stackBuilder.getPendingIntent(0, PendingIntent.FLAG_UPDATE_CURRENT))
startForeground(NOTIFICATION_ID, builder.build())

Vous devez vous connecter pour publier un commentaire.