Personnalisé JobIntentService onHandleWork pas appelé

J'ai eu le même problème (qui a bien fonctionné sur un pré-O de l'appareil, aucune indication de quelque chose qui se passe, que ce soit sur un joint périphérique). Aujourd'hui, j'ai essayé de nouveau avec exactement le même code que hier, maintenant il fonctionne seule différence est que j'ai redémarré l'appareil entre les deux.

Ma théorie actuelle est que mon premier programme d'installation n'a pas fonctionné; mes que l'on fait et juste redéploiement nouveau code n'est pas clair sur les brisées de l'état de la JobScheduler; un redémarrage ou une désinstallation/réinstallation du paquet n'.

Le programme d'installation qui travaille maintenant (migré à partir d'un ancien IntentService):

<service
    android:name=".MyJobIntentService"
    android:exported="false"
    android:permission="android.permission.BIND_JOB_SERVICE"/>

et de commencer avec

Intent intent = new Intent(); 
intent.putExtra(EXTRA_NAME, extraValue);
JobIntentService.enqueueWork(context, MyJobIntentService.class, FIXED_JOB_ID, intent);

Noter que l'intention est pas une intention explicite (c'est à dire, la Nomcomposant n'est pas défini).

C'est ce qui a fonctionné pour moi,

Supprimer la IBind Remplacer comme suggéré par @agirardello

et a ajouté ce qui suit

    @Override
    public int onStartCommand(@Nullable Intent intent, int flags, int startId) {
        return super.onStartCommand(intent, flags, startId);
    }

N'ai aucune idée de pourquoi cela a fonctionné.

J'ai rencontré un peu le même problème avec onHandleWork pas être appelé la deuxième fois, après la migration de Service à JobIntentService. Les journaux indiquent que enqueueWork a été appelé, mais onHandleWork était en cours d'exécution seulement la première et semblait être coincé.

Après certains plus de creuser et de journalisation, j'ai découvert que la différence est que dans un "coincé" scénario il n'y a JobIntentService#onDestroy même si toutes les opérations dans onHandleWork ont été effectuées et apparemment fini.

S'est avéré que le coupable était bindService appel de service à l'activité du cycle de vie qui a été la prévention de l'élimination du premier emploi et pour une raison que l'appel de enqueueWork après cette condition était à l'origine du service "coincé" et de ne jamais exécuter une des opérations suivantes onHandleWork de nouveau.

Donc, ici, c'est un mauvais journal d'événements dans lesquels JobIntentService semble être coincé après le premier appel n'déclenchement onHandleWork de nouveau:

enqueueWork -> first call
onHandleWork started (log in the first line)
onHandleWork finished (log in the last line)
enqueueWork -> second call
enqueueWork -> third call

Et ici est le bon journal des événements avec JobIntentService fonctionne correctement après la suppression de bindService appel:

enqueueWork -> first call
onHandleWork started (log in the first line)
onHandleWork finished (log in the last line)
onDestroy (service is destroyed after the job is finished)
enqueueWork -> second call
onHandleWork started (log in the first line)
onHandleWork finished (log in the last line)
onDestroy
enqueueWork -> third call
onHandleWork started (log in the first line)
onHandleWork finished (log in the last line)
onDestroy

Espère que ce sera utile à quelqu'un.

Juste essayer de sortir et de l'exécution de l'Android à nouveau en Studio. Puis tester à nouveau.
Dans mon cas, la version d'Android Studio est v 3.3.1.
Voir l'exemple de code qui fonctionne correctement.

public class CustomizedIntentService extends JobIntentService
{
    public static final String MY_ACTION = "action.SOME_ACTION";
    private static final int MY_JOB_INTENT_SERVICE_ID = 500;

    public CustomizedIntentService() {
    }

    //Helper Methods to start this JobIntentService.
    public static void enqueueJobAction(Context context, String action) {
        Intent intent = new Intent(context, CustomizedIntentService.class);
        intent.setAction(MY_ACTION);

        enqueueWork(context, CustomizedIntentService.class, MY_JOB_INTENT_SERVICE_ID, intent);
    }

    @Override
    protected void onHandleWork(@NonNull Intent intent) {
        String action = intent.getAction();

        //action will be "action.SOME_ACTION"
    }

    @Override
    public void onCreate() {
        super.onCreate();
    }

    @Override
    public void onDestroy() {
        super.onDestroy();
    }

    @Override
    public boolean onStopCurrentWork() {
        return super.onStopCurrentWork();
    }
}

//début de la JobIntentService que vous en avez besoin.

CustomizedIntentService.enqueueJobAction(contexte, CustomizedIntentService.MY_ACTION);

J'ai enfin trouvé la solution pour ce problème LoL

Si vous remplacez le "onBind" méthode et u appeler le travail à l'aide de la "enqueueWork" méthode, vous devez retourner la liaison vers le moteur de la ce:

@Override @Nullable
    public IBinder onBind(@NonNull Intent intent) {
        [... Do What You Want ... ]
        return super.onBind(intent);
    }

Afin de retourner l'IBinder de la "super.onBind" la méthode, de sorte que vous devez utiliser pour se lier à la JobIntentService.

Si vous souhaitez lier et de revenir un autre classeur, vous pouvez le faire:

@Override @Nullable
    public IBinder onBind(@NonNull Intent intent) {
        IBinder binder = initSynchronizer();
        new Thread(
                () -> onHandleWork(intent)
            ).start();
        return binder;
    }

Donc en commençant par vous "onHandleWork" dans un autre Thread.
De cette façon, vous pouvez utiliser:

"bindService(....., JobIntentService.BIND_AUTO_CREATE);"

de lier le service et le retour de votre Classeur.
De toute façon quand vous séparer de service, le service va se faire tuer, et si elle est toujours exécuter vous ne pouvez pas lier de nouveau à elle, car le service a été tué, mais le thread dans lequel le "onHandleWork" est toujours en cours...

Alors je vous suggérons d'utiliser cette version est disponible uniquement si vous avez à faire une tâche qui a besoin de communiquer avec l'activité jusqu'à ce qu'elle est en vie et le besoin de continuer à travailler si l'activité a été tué (sans la possibilité de se lier à nouveau le jobService, mais seulement pour en commencer une nouvelle...)

Pour ne pas tuer le service après la unbind vous avez besoin pour démarrer en "premier plan", le "stopForeground" dans le "onDestroy". De cette façon, vous service être encore en vie juste pour le thread qui est de la manipulation de la "onHandleWork" méthodes.

J'espère que google va résoudre ce sh*t rapide LoL, j'ai converti l'ensemble de l'ancien "Service" et "IntentService" à la nouvelle de l'emploi mais... ils travaillent vraiment pire qu'avant!

Bye, ont une belle codage 😉

Je pense que avez ce problème, depuis que j'ai essayer de porter un Toast du texte à l'intérieur de onHandleWork(), mais en fait le problème était que c'était mal et que je devrais utiliser un Gestionnaire. Il est peut-être le problème si on utilise par exemple AsyncTask des sous-classes pour l'exécuter sur un autre fil à l'intérieur de onHandleWork(), ce qui est une très mauvaise idée.