Android Academy · Leçon

Créer un Worker

Définissez le travail en arrière-plan dans un Worker.

Créer un Worker est une leçon Android Academy gratuite sur CoddyKit. Ceci est la leçon 2 sur 4. Tu peux lire la leçon complète ci-dessous gratuitement — puis la pratiquer en direct dans le navigateur avec un éditeur de code intégré et un tuteur IA 24/7. Elle fait partie du parcours d'apprentissage Android Academy, et ta progression se synchronise sur le web et l'application CoddyKit. Le cours Android Academy comprend 4 leçons au total.

Créer un travailleur

L’unité de travail en arrière-plan de WorkManager est un travailleur. Vous définissez la tâche en dérivant d’une classe de base de travail et en redéfinissant sa méthode de travail.

CoroutineWorker

Avec Kotlin, étendez CoroutineWorker. Sa fonction doWork() est une fonction suspend, ce qui vous permet d’appeler d’autres fonctions suspendues et de vous exécuter naturellement sur un répartiteur d’arrière-plan.

class UploadWorker(
    context: Context,
    params: WorkerParameters
) : CoroutineWorker(context, params) {
    override suspend fun doWork(): Result {
        // background work here
        return Result.success()
    }
}

Le constructeur

Chaque travailleur reçoit un Context et des WorkerParameters dans son constructeur, puis les transmet à la superclasse. WorkManager instancie votre travailleur pour vous ; vous n’appelez jamais directement le constructeur.

doWork renvoie un résultat

doWork() doit renvoyer un Result décrivant le résultat obtenu. Trois possibilités existent.

Result.success()
Result.retry()
Result.failure()

Result.success

Renvoyez Result.success() lorsque le travail est terminé. Le travail est retiré de la file d’attente. Vous pouvez joindre des données de sortie à transmettre au travail enchaîné.

override suspend fun doWork(): Result {
    uploadLogs()
    return Result.success()
}

Result.retry

Renvoyez Result.retry() en cas d’échec temporaire, par exemple une erreur réseau passagère. WorkManager relance le travailleur plus tard, conformément à sa stratégie de temporisation.

override suspend fun doWork(): Result {
    return try {
        syncData()
        Result.success()
    } catch (e: IOException) {
        Result.retry()
    }
}

Result.failure

Renvoyez Result.failure() en cas d’échec définitif que de nouvelles tentatives ne peuvent pas corriger, comme des données d’entrée invalides. Le travail s’arrête et les travaux enchaînés qui en dépendent ne s’exécuteront pas.

Lire les données d’entrée

Vous transmettez de petites données d’entrée via Data lors de la mise en file d’attente, puis vous les lisez avec inputData dans le travailleur. Gardez-les de petite taille : elles ne sont pas destinées aux charges utiles volumineuses.

override suspend fun doWork(): Result {
    val userId = inputData.getString("user_id") ?: return Result.failure()
    sync(userId)
    return Result.success()
}

Renvoyer des données de sortie

Les travailleurs peuvent renvoyer des données Data dans leur résultat ; les travailleurs enchaînés les reçoivent comme données d’entrée. C’est ainsi que vous transmettez les résultats entre les étapes.

val output = workDataOf("count" to 42)
return Result.success(output)

Travailler avec le bon répartiteur

CoroutineWorker exécute doWork() avec Dispatchers.Default par défaut. Pour les opérations d’entrée-sortie bloquantes, utilisez withContext(Dispatchers.IO) afin d’éviter de saturer le pool par défaut.

override suspend fun doWork(): Result = withContext(Dispatchers.IO) {
    readAndUploadFile()
    Result.success()
}

Garder les travailleurs autonomes

Un travailleur peut s’exécuter longtemps après avoir été planifié, dans un processus nouvellement créé. Ne vous fiez pas à l’état de l’application en mémoire ; transmettez ce dont vous avez besoin via les données d’entrée ou lisez-les depuis un stockage persistant.

Vérification rapide

Testez votre compréhension de la création d’un travailleur.

Récapitulatif

Vous avez créé un travailleur :

Étendez CoroutineWorker et redéfinissez doWork(), qui est suspendue
Renvoyez Result.success(), Result.retry() ou Result.failure()
Lisez inputData et renvoyez des données Data de sortie
Utilisez Dispatchers.IO pour les opérations bloquantes ; gardez les travailleurs autonomes

Ensuite : contraintes et planification.

Questions Fréquemment Posées

La leçon « Créer un Worker » est-elle gratuite ?

Oui — le texte complet de « Créer un Worker » est gratuit à lire ici sur le web. Pour la pratiquer de manière interactive (un éditeur de code intégré et un tuteur IA 24/7) et déverrouiller le reste du cours Android Academy, passe à CoddyKit PRO. Le cours Android Academy comprend 4 leçons au total.

Qu'est-ce que j'apprendrai dans « Créer un Worker » ?

Définissez le travail en arrière-plan dans un Worker. Tu pratiques Android Academy avec du code pratique que tu exécutes directement dans le navigateur, et un tuteur IA 24/7 répond à tes questions au fur et à mesure que tu avances dans la leçon.

Dois-je avoir de l'expérience pour commencer Android Academy ?

Aucune expérience préalable n'est requise. Android Academy sur CoddyKit est structuré pour les débutants jusqu'aux apprenants avancés, donc tu peux commencer ici ou depuis le début et avancer à ton rythme. Ceci est la leçon 2 sur 4.

Combien de temps prend la leçon « Créer un Worker » ?

La plupart des leçons CoddyKit prennent environ 5–10 minutes. Chacune est courte et interactive, tu progresses régulièrement et tu repiques exactement où tu t'es arrêté sur le web et l'app.

Peux-tu écrire et exécuter du code dans cette leçon Android Academy ?

Oui. Chaque leçon Android Academy inclut un éditeur de code intégré, tu écris et exécutes du vrai code directement dans ton navigateur et tu reçois des retours IA instantanés — aucune configuration locale requise.

Toutes les leçons de ce cours

← Retour à Android Academy