Zugriff auf den UI-Thread-Handler über einen Dienst

Ich versuche etwas Neues auf Android, für das ich auf den Handler des UI-Threads zugreifen muss.

Ich kenne folgendes:

1. Der UI-Thread verfügt über einen eigenen Handler und Looper
2. Jede Nachricht wird in die Nachrichtenwarteschlange des UI-Threads gestellt
3. Der Looper nimmt das Ereignis auf und gibt es an den Handler weiter
4. Der Handler verarbeitet die Nachricht und sendet das spezifische Ereignis an die Benutzeroberfläche

Ich möchte meinen Dienst haben, der den UI-Thread-Handler abrufen und eine Nachricht in diesen Handler einfügen muss. Damit diese Nachricht verarbeitet und an die Benutzeroberfläche ausgegeben wird. Hier ist der Dienst ein normaler Dienst, der von einer Anwendung gestartet wird.

Ich würde gerne wissen, ob dies möglich ist. Wenn ja, schlagen Sie bitte einige Codefragmente vor, damit ich es versuchen kann.

Grüße Girish

Dieser Codeausschnitt erstellt einen Handler, der dem Hauptthread (UI) zugeordnet ist:

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

Sie können dann Dinge zur Ausführung im Hauptthread (UI) wie folgt posten:

handler.post(runnable_to_call_from_main_thread);

Wenn der Handler selbst aus dem Hauptthread (UI) erstellt wird, kann das Argument der Kürze halber weggelassen werden:

Handler handler = new Handler();

Das Android Dev Führer auf Prozesse und Threads hat weitere Informationen.

Erstellen Sie ein Messengeran Ihr angehängtes Objekt Handlerund übergeben Sie es Messengeran das Service(z. B. in einem IntentExtra für startService()). Das Servicekann dann ein senden , Messageum die Handlerüber die Messenger. Hier ist eine Beispielanwendung, die dies demonstriert.

Im Moment bevorzuge ich die Verwendung von Eventbusbibliotheken wie Otto für diese Art von Problem. Abonnieren Sie einfach die gewünschten Komponenten (Aktivität):

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

Geben Sie dann eine Rückrufmethode an:

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

und dann, wenn Ihr Dienst eine Anweisung wie folgt ausführt:

bus.post(new TimeLeftEvent(340));

Dieses POJO wird an Ihre oben genannte Aktivität und alle anderen abonnierenden Komponenten weitergegeben. Einfach und elegant.

Ich schlage vor, folgenden Code zu versuchen:

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

        //UI THREAD CODE HERE



    });

Sie können Werte über den Broadcast-Empfänger abrufen ...... wie folgt: Erstellen Sie zunächst Ihren eigenen IntentFilter als,

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

Erstellen Sie dann den BroadcastReceiver der inneren Klasse als:

    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");
        }
    }
};

Registrieren Sie jetzt Ihren Rundfunkempfänger in onResume () als,

registerReceiver(broadcastReceiver, intentFilter);

Und schließlich entfernen Sie die Registrierung von BroadcastReceiver in onDestroy () als,

unregisterReceiver(broadcastReceiver);

Jetzt der wichtigste Teil ... Sie müssen die Sendung von jedem Ort aus starten, an dem Sie Werte senden müssen.

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

....Prost :)

So kotlinkönnen Sie es machen

Angenommen, Sie möchten eine Toast-Nachricht vom Dienst anzeigen

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

Lösung:

1. Erstellen Sie einen Handler mit Looper aus dem Hauptthread: requestHandler
2. Erstellen Sie eine Handlerwith Looperfrom Main Thread: responseHandler- und override- handleMessageMethode
3. Veröffentlichen Sie eine ausführbare Aufgabe auf requestHandler
4. RunnableRufen Sie innerhalb der Task sendMessage für responseHandler auf
5. Dieser sendMessageErgebnisaufruf von handleMessage in responseHandler.
6. Holen Sie sich Attribute aus dem Messageund verarbeiten Sie es, aktualisieren Sie die Benutzeroberfläche

Beispielcode:

    /* 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);
    }