Accéder au gestionnaire de threads de l'interface utilisateur à partir d'un service

J'essaie quelque chose de nouveau sur Android pour lequel j'ai besoin d'accéder au gestionnaire du thread d'interface utilisateur.

Je sais ce qui suit:

1. Le thread d'interface utilisateur a son propre gestionnaire et son propre boucleur
2. Tout message sera placé dans la file d'attente des messages du fil d'interface utilisateur
3. Le boucleur récupère l'événement et le transmet au gestionnaire
4. Le gestionnaire gère le message et envoie l'événement spécifique à l'interface utilisateur

Je veux avoir mon service qui doit obtenir le gestionnaire de threads de l'interface utilisateur et mettre un message dans ce gestionnaire. Pour que ce message soit traité et envoyé à l'interface utilisateur. Ici, le service sera un service normal qui sera démarré par une application.

Je voudrais savoir si cela est possible. Si tel est le cas, veuillez suggérer des extraits de code afin que je puisse l'essayer.

Cordialement Girish

Cet extrait de code construit un gestionnaire associé au thread principal (UI): This snippet of code constructs a Handler associated with the main (UI) thread:

Handler handler = new Handler(Looper.getMainLooper());

Vous pouvez ensuite publier des éléments pour exécution dans le thread principal (UI) comme suit:

handler.post(runnable_to_call_from_main_thread);

Si le gestionnaire lui-même est créé à partir du thread principal (UI), l'argument peut être omis par souci de concision:

Handler handler = new Handler();

Le guide de développement Android sur les processus et les threads contient plus d'informations.

Créez un Messengerobjet attaché à votre Handleret passez-le Messengerau Service(par exemple, dans un Intentextra pour startService()). Le Servicepeut alors envoyer un Messageau Handlervia le Messenger. Voici un exemple d'application démontrant cela.

Pour le moment, je préfère utiliser la bibliothèque de bus d'événements comme Otto pour ce genre de problème. Abonnez-vous simplement aux composants souhaités (activité):

protected void onResume() {
    super.onResume();
    bus.register(this);
}

Ensuite, fournissez une méthode de rappel:

public void onTimeLeftEvent(TimeLeftEvent ev) {
    // process event..
}

puis lorsque votre service exécute une instruction comme celle-ci:

bus.post(new TimeLeftEvent(340));

Ce POJO sera transmis à votre activité ci-dessus et à tous les autres composants d'abonnement. Simple et élégant.

Je suggère d'essayer le code suivant:

    new Handler(Looper.getMainLooper()).post(() -> {

        //UI THREAD CODE HERE



    });

Vous pouvez obtenir des valeurs via le récepteur de diffusion ... comme suit, créez d'abord votre propre IntentFilter en tant que,

Intent intentFilter=new IntentFilter();
intentFilter.addAction("YOUR_INTENT_FILTER");

Puis créez la classe interne BroadcastReceiver comme,

    private BroadcastReceiver broadcastReceiver = new BroadcastReceiver() {
    /** Receives the broadcast that has been fired */
    @Override
    public void onReceive(Context context, Intent intent) {
        if(intent.getAction()=="YOUR_INTENT_FILTER"){
           //HERE YOU WILL GET VALUES FROM BROADCAST THROUGH INTENT EDIT YOUR TEXTVIEW///////////
           String receivedValue=intent.getStringExtra("KEY");
        }
    }
};

Enregistrez maintenant votre récepteur de diffusion dans onResume () en tant que,

registerReceiver(broadcastReceiver, intentFilter);

Et enfin désenregistrer BroadcastReceiver dans onDestroy () comme,

unregisterReceiver(broadcastReceiver);

Maintenant, la partie la plus importante ... Vous devez déclencher la diffusion à partir de l'endroit où vous devez envoyer des valeurs ..... alors faites comme,

Intent i=new Intent();
i.setAction("YOUR_INTENT_FILTER");
i.putExtra("KEY", "YOUR_VALUE");
sendBroadcast(i);

....à votre santé :)

En kotlinthats comment vous pouvez le faire

Disons si vous souhaitez afficher le message Toast du service

val handler = Handler(Looper.getMainLooper())
handler.post {
   Toast.makeText(context, "This is my message",Toast.LENGTH_LONG).show()
}

Solution:

1. Créer un gestionnaire avec Looper partir du thread principal: requestHandler
2. Créer un Handleravec à Looperpartir du thread principal: responseHandler et overridehandleMessage méthode de
3. publier un Runnable tâche sur RequestHandler
4. À l'intérieur Runnable tâche, appelez sendMessage sur responseHandler
5. Ce sendMessage appel de résultat de handleMessage dans responseHandler.
6. Obtenez des attributs de Messageet traitez-les, mettez à jour l'interface utilisateur

Exemple de code:

    /* Handler from UI Thread to send request */

    Handler requestHandler = new Handler(Looper.getMainLooper());

     /* Handler from UI Thread to process messages */

    final Handler responseHandler = new Handler(Looper.getMainLooper()) {
        @Override
        public void handleMessage(Message msg) {

            /* Processing handleMessage */

            Toast.makeText(MainActivity.this,
                    "Runnable completed with result:"+(String)msg.obj,
                    Toast.LENGTH_LONG)
                    .show();
        }
    };

    for ( int i=0; i<10; i++) {
        Runnable myRunnable = new Runnable() {
            @Override
            public void run() {
                try {
                   /* Send an Event to UI Thread through message. 
                      Add business logic and prepare message by 
                      replacing example code */

                    String text = "" + (++rId);
                    Message msg = new Message();

                    msg.obj = text.toString();
                    responseHandler.sendMessage(msg);
                    System.out.println(text.toString());

                } catch (Exception err) {
                    err.printStackTrace();
                }
            }
        };
        requestHandler.post(myRunnable);
    }