Android " tylko oryginalny wątek, który stworzył hierarchię widoków, może dotykać jego widoków."

Rozwiązałem to umieszczając runOnUiThread( new Runnable(){ .. wewnątrz run():

thread = new Thread(){
        @Override
        public void run() {
            try {
                synchronized (this) {
                    wait(5000);

                    runOnUiThread(new Runnable() {
                        @Override
                        public void run() {
                            dbloadingInfo.setVisibility(View.VISIBLE);
                            bar.setVisibility(View.INVISIBLE);
                            loadingText.setVisibility(View.INVISIBLE);
                        }
                    });

                }
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            Intent mainActivity = new Intent(getApplicationContext(),MainActivity.class);
            startActivity(mainActivity);
        };
    };  
    thread.start();

Moje rozwiązanie:

private void setText(final TextView text,final String value){
    runOnUiThread(new Runnable() {
        @Override
        public void run() {
            text.setText(value);
        }
    });
}

Wywołanie tej metody w wątku tła.

Zazwyczaj każda akcja z interfejsem użytkownika musi być wykonana w głównym lub UI wątku, czyli tym, w którym wykonywane są onCreate() i obsługa zdarzeń. Jednym ze sposobów na upewnienie się o tym jest użycie runOnUiThread(), innym jest użycie programów obsługi.

ProgressBar.setProgress() ma mechanizm, dla którego zawsze będzie uruchamiany na głównym wątku, dlatego zadziałał.

Zobacz Bezbolesne Gwintowanie .

Byłem w tej sytuacji, ale znalazłem rozwiązanie z obiektem obsługi.

W moim przypadku, chcę zaktualizować Progresdialog z obserwator wzór . My view implementuje observer i nadpisuje metodę aktualizacji.

Więc mój główny wątek tworzy widok, a inny wątek wywołuje metodę update, która aktualizuje Progresdialop i....:

Tylko oryginalny wątek, który stworzył hierarchię widoków, może dotknąć jego widoki.

Możliwe jest Rozwiąż problem z obiektem obsługi.

Poniżej różne części mojego kodu:

public class ViewExecution extends Activity implements Observer{

    static final int PROGRESS_DIALOG = 0;
    ProgressDialog progressDialog;
    int currentNumber;

    public void onCreate(Bundle savedInstanceState) {

        currentNumber = 0;
        final Button launchPolicyButton =  ((Button) this.findViewById(R.id.launchButton));
        launchPolicyButton.setOnClickListener(new OnClickListener() {

            @Override
            public void onClick(View v) {
                showDialog(PROGRESS_DIALOG);
            }
        });
    }

    @Override
    protected Dialog onCreateDialog(int id) {
        switch(id) {
        case PROGRESS_DIALOG:
            progressDialog = new ProgressDialog(this);
            progressDialog.setProgressStyle(ProgressDialog.STYLE_HORIZONTAL);
            progressDialog.setMessage("Loading");
            progressDialog.setCancelable(true);
            return progressDialog;
        default:
            return null;
        }
    }

    @Override
    protected void onPrepareDialog(int id, Dialog dialog) {
        switch(id) {
        case PROGRESS_DIALOG:
            progressDialog.setProgress(0);
        }

    }

    // Define the Handler that receives messages from the thread and update the progress
    final Handler handler = new Handler() {
        public void handleMessage(Message msg) {
            int current = msg.arg1;
            progressDialog.setProgress(current);
            if (current >= 100){
                removeDialog (PROGRESS_DIALOG);
            }
        }
    };

    // The method called by the observer (the second thread)
    @Override
    public void update(Observable obs, Object arg1) {

        Message msg = handler.obtainMessage();
        msg.arg1 = ++currentPluginNumber;
        handler.sendMessage(msg);
    }
}

To wyjaśnienie można znaleźć na tej stronie, i musisz przeczytać "przykładowy Progresdialog z drugim wątkiem".

Możesz użyć funkcji obsługi, aby usunąć Widok bez zakłócania głównego wątku interfejsu użytkownika. Oto przykładowy kod

new Handler(Looper.getMainLooper()).post(new Runnable() {
    @Override
    public void run() {
          //do stuff like remove view etc
          adapter.remove(selecteditem);
          }
    });

Kotlin koroutines może uczynić Twój kod bardziej zwięzłym i czytelnym w ten sposób:

MainScope().launch {
    withContext(Dispatchers.Default) {
        //TODO("Background processing...")
    }
    TODO("Update UI here!")
}

Lub odwrotnie:

GlobalScope.launch {
    //TODO("Background processing...")
    withContext(Dispatchers.Main) {
        // TODO("Update UI here!")
    }
    TODO("Continue background processing...")
}

Widzę, że zaakceptowałeś odpowiedź @ providence. Na wszelki wypadek możesz również użyć obsługi! Najpierw wykonaj pola int.

    private static final int SHOW_LOG = 1;
    private static final int HIDE_LOG = 0;

Następnie utwórz instancję obsługi jako pole.

    //TODO __________[ Handler ]__________
    @SuppressLint("HandlerLeak")
    protected Handler handler = new Handler()
    {
        @Override
        public void handleMessage(Message msg)
        {
            // Put code here...

            // Set a switch statement to toggle it on or off.
            switch(msg.what)
            {
            case SHOW_LOG:
            {
                ads.setVisibility(View.VISIBLE);
                break;
            }
            case HIDE_LOG:
            {
                ads.setVisibility(View.GONE);
                break;
            }
            }
        }
    };

Stwórz metodę.

//TODO __________[ Callbacks ]__________
@Override
public void showHandler(boolean show)
{
    handler.sendEmptyMessage(show ? SHOW_LOG : HIDE_LOG);
}

Wreszcie, umieścić to w metodzie onCreate().

showHandler(true);

Miałem podobny problem i moje rozwiązanie jest brzydkie, ale działa:

void showCode() {
    hideRegisterMessage(); // Hides view 
    final Handler handler = new Handler();
    handler.postDelayed(new Runnable() {
        @Override
        public void run() {
            showRegisterMessage(); // Shows view
        }
    }, 3000); // After 3 seconds
}

Użyj tego kodu i nie musisz runOnUiThread funkcji:

private Handler handler;
private Runnable handlerTask;

void StartTimer(){
    handler = new Handler();   
    handlerTask = new Runnable()
    {
        @Override 
        public void run() { 
            // do something  
            textView.setText("some text");
            handler.postDelayed(handlerTask, 1000);    
        }
    };
    handlerTask.run();
}

Używam Handler z Looper.getMainLooper(). Dla mnie zadziałało.

    Handler handler = new Handler(Looper.getMainLooper()) {
        @Override
        public void handleMessage(Message msg) {
              // Any UI task, example
              textView.setText("your text");
        }
    };
    handler.sendEmptyMessage(1);

Jest to jawne wywołanie błędu. Mówi, że każdy wątek stworzył Widok, tylko ten, który może dotknąć jego widoków. Dzieje się tak dlatego, że utworzony Widok znajduje się w przestrzeni tego wątku. Tworzenie widoku (GUI) odbywa się w głównym wątku interfejsu użytkownika. Tak więc zawsze używasz wątku interfejsu, aby uzyskać dostęp do tych metod.

Na powyższym obrazku zmienna progress znajduje się wewnątrz przestrzeni wątku interfejsu użytkownika. Tak więc tylko wątek interfejsu użytkownika może uzyskać dostęp do tej zmiennej. Tutaj masz dostęp do postępu poprzez new Thread () i dlatego masz błąd.

Miałem do czynienia z podobnym problemem i żadna z wyżej wymienionych metod nie zadziałała dla mnie. W końcu to mi się udało:

Device.BeginInvokeOnMainThread(() =>
    {
        myMethod();
    });

Znalazłem ten klejnot tutaj .

Stało się tak, gdy poprosiłem o zmianę interfejsu z doInBackground z Asynctask zamiast używać onPostExecute.

Radzenie sobie z UI w onPostExecute rozwiązało mój problem.

Pracowałam z klasą, która nie zawierała odniesienia do kontekstu. Więc nie było możliwe dla mnie, aby użyć runOnUIThread(); użyłem view.post(); i to zostało rozwiązane.

timer.scheduleAtFixedRate(new TimerTask() {

    @Override
    public void run() {
        final int currentPosition = mediaPlayer.getCurrentPosition();
        audioMessage.seekBar.setProgress(currentPosition / 1000);
        audioMessage.tvPlayDuration.post(new Runnable() {
            @Override
            public void run() {
                audioMessage.tvPlayDuration.setText(ChatDateTimeFormatter.getDuration(currentPosition));
            }
        });
    }
}, 0, 1000);

Przy użyciu AsyncTask zaktualizuj interfejs użytkownika w onpostexecute metodzie

    @Override
    protected void onPostExecute(String s) {
   // Update UI here

     }

Jeśli nie chcesz używać runOnUiThread API, możesz zaimplementować AsynTask dla operacji, które trwają kilka sekund. Ale w takim przypadku, również po przetworzeniu pracy w doinBackground(), musisz zwrócić gotowy widok w onPostExecute(). Implementacja systemu Android umożliwia interakcję z widokami tylko głównego wątku interfejsu użytkownika.

Odpowiedź Kotlina

Musimy użyć wątku UI do zadania z true way. Możemy użyć wątku UI w Kotlinie:

runOnUiThread(Runnable {
   //TODO: Your job is here..!
})

@canerkaseler

To jest ślad stosu wspomnianego wyjątku

        at android.view.ViewRootImpl.checkThread(ViewRootImpl.java:6149)
        at android.view.ViewRootImpl.requestLayout(ViewRootImpl.java:843)
        at android.view.View.requestLayout(View.java:16474)
        at android.view.View.requestLayout(View.java:16474)
        at android.view.View.requestLayout(View.java:16474)
        at android.view.View.requestLayout(View.java:16474)
        at android.widget.RelativeLayout.requestLayout(RelativeLayout.java:352)
        at android.view.View.requestLayout(View.java:16474)
        at android.widget.RelativeLayout.requestLayout(RelativeLayout.java:352)
        at android.view.View.setFlags(View.java:8938)
        at android.view.View.setVisibility(View.java:6066)

Więc jeśli pójdziesz i kopiesz to dowiesz się

void checkThread() {
    if (mThread != Thread.currentThread()) {
        throw new CalledFromWrongThreadException(
                "Only the original thread that created a view hierarchy can touch its views.");
    }
}

Gdzie mthread jest inicjalizacją w konstruktorze jak poniżej

mThread = Thread.currentThread();

Chodzi mi tylko o to, że kiedy tworzyliśmy konkretny widok, tworzyliśmy go w wątku UI, a później próbowaliśmy go modyfikować w wątku roboczym.

Możemy to zweryfikować za pomocą poniższego fragmentu kodu

Thread.currentThread().getName()

Kiedy nadmuchujemy layout, a później gdzie dostajesz wyjątek.

Jeśli po prostu chcesz unieważnić (wywołać funkcję repaint/redraw) z wątku innego niż UI, użyj postInvalidate ()

myView.postInvalidate();

Spowoduje to opublikowanie żądania unieważnienia w wątku UI.

Aby uzyskać więcej informacji: what-does-postinvalidate-do

Dla mnie problemem było to, że dzwoniłem onProgressUpdate() wprost z mojego kodu. To nie powinno być zrobione. Zadzwoniłem publishProgress() zamiast tego i to rozwiązało błąd.

W moim przypadku, Mam EditText w adapterze i jest już w wątku UI. Jednak gdy ta aktywność się ładuje, ulega awarii z tym błędem.

Moim rozwiązaniem jest to, że muszę usunąć <requestFocus /> z EditText w XML.

Dla osób zmagających się w Kotlinie działa to tak:

lateinit var runnable: Runnable //global variable

 runOnUiThread { //Lambda
            runnable = Runnable {

                //do something here

                runDelayedHandler(5000)
            }
        }

        runnable.run()

 //you need to keep the handler outside the runnable body to work in kotlin
 fun runDelayedHandler(timeToWait: Long) {

        //Keep it running
        val handler = Handler()
        handler.postDelayed(runnable, timeToWait)
    }

Jeśli znajdujesz się w fragmencie, musisz również uzyskać obiekt activity, ponieważ runOnUIThread jest metodą na aktywności.

Przykład w Kotlinie z jakimś otaczającym kontekstem, aby był jaśniejszy - ten przykład nawiguje od fragmentu kamery do fragmentu galerii:

// Setup image capture listener which is triggered after photo has been taken
imageCapture.takePicture(
       outputOptions, cameraExecutor, object : ImageCapture.OnImageSavedCallback {

           override fun onError(exc: ImageCaptureException) {
           Log.e(TAG, "Photo capture failed: ${exc.message}", exc)
        }

        override fun onImageSaved(output: ImageCapture.OutputFileResults) {
                        val savedUri = output.savedUri ?: Uri.fromFile(photoFile)
                        Log.d(TAG, "Photo capture succeeded: $savedUri")
               
             //Do whatever work you do when image is saved         
             
             //Now ask navigator to move to new tab - as this
             //updates UI do on the UI thread           
             activity?.runOnUiThread( {
                 Navigation.findNavController(
                        requireActivity(), R.id.fragment_container
                 ).navigate(CameraFragmentDirections
                        .actionCameraToGallery(outputDirectory.absolutePath))
              })

Możesz to zrobić w ten sposób.

Https://developer.android.com/reference/android/view/View#post (java. lang. Runnable)

Proste podejście

currentTime.post(new Runnable(){
            @Override
            public void run() {
                 currentTime.setText(time);     
            }
        }

Zapewnia również opóźnienie

Https://developer.android.com/reference/android/view/View#postDelayed(java.lang.Runnable,%20long)

Rozwiązany: po prostu umieść tę metodę w klasie doInBackround... and pass the message

public void setProgressText(final String progressText){
        Handler handler = new Handler(Looper.getMainLooper()) {
            @Override
            public void handleMessage(Message msg) {
                // Any UI task, example
                progressDialog.setMessage(progressText);
            }
        };
        handler.sendEmptyMessage(1);

    }

W moim przypadku, wywołanie zbyt wiele razy w krótkim czasie spowoduje ten błąd, po prostu umieścić czas, który upłynął sprawdzanie nic nie zrobić, jeśli zbyt krótki, np. zignorować, jeśli funkcja zostanie wywołana mniej niż 0.5 sekundy: {]}

    private long mLastClickTime = 0;

    public boolean foo() {
        if ( (SystemClock.elapsedRealtime() - mLastClickTime) < 500) {
            return false;
        }
        mLastClickTime = SystemClock.elapsedRealtime();

        //... do ui update
    }

Jeśli nie możesz znaleźć UIThread, możesz użyć tego sposobu .

Yourcurrentcontext oznacza, że musisz przeanalizować bieżący kontekst

 new Thread(new Runnable() {
        public void run() {
            while (true) {
                (Activity) yourcurrentcontext).runOnUiThread(new Runnable() {
                    public void run() { 
                        Log.d("Thread Log","I am from UI Thread");
                    }
                });
                try {
                    Thread.sleep(1000);
                } catch (Exception ex) {

                }
            }
        }
    }).start();

W Kotlin po prostu umieść swój kod w metodzie runonuithread activity

runOnUiThread{
    // write your code here, for example
    val task = Runnable {
            Handler().postDelayed({
                var smzHtcList = mDb?.smzHtcReferralDao()?.getAll()
                tv_showSmzHtcList.text = smzHtcList.toString()
            }, 10)

        }
    mDbWorkerThread.postTask(task)
}

RunOnUIThread nie wydaje się działać dla mnie, ale następujące skończyło się rozwiązaniem moich problemów.

            _ = MainThread.InvokeOnMainThreadAsync(async () =>
           {
               this.LoadApplication(Startup.Init(this.ConfigureServices));

               var authenticationService = App.ServiceProvider.GetService<AuthenticationService>();
               if (authenticationService.AuthenticationResult == null)
               {
                   await authenticationService.AuthenticateAsync(AuthenticationUserFlow.SignUpSignIn, CrossCurrentActivity.Current.Activity).ConfigureAwait(false);
               }
           });

W trakcie uruchamiania.Metoda Init jest reactiveui routing i to musi być wywołane w głównym wątku. Ta metoda wywoływania akceptuje również asynchroniczne/oczekujące lepsze niż RunOnUIThread.

Więc gdziekolwiek muszę wywoływać metody na mainthreadzie używam tego.

Proszę o komentarz, jeśli ktoś wie coś, czego Nie wiem I może pomóc mi poprawić moją aplikację.