Android "뷰 계층 구조를 만든 원래 스레드 만 해당 뷰를 만질 수 있습니다."

Android에서 간단한 뮤직 플레이어를 만들었습니다. 각 노래의보기에는 다음과 같이 구현 된 SeekBar가 포함됩니다.

public class Song extends Activity implements OnClickListener,Runnable {
    private SeekBar progress;
    private MediaPlayer mp;

    // ...

    private ServiceConnection onService = new ServiceConnection() {
          public void onServiceConnected(ComponentName className,
            IBinder rawBinder) {
              appService = ((MPService.LocalBinder)rawBinder).getService(); // service that handles the MediaPlayer
              progress.setVisibility(SeekBar.VISIBLE);
              progress.setProgress(0);
              mp = appService.getMP();
              appService.playSong(title);
              progress.setMax(mp.getDuration());
              new Thread(Song.this).start();
          }
          public void onServiceDisconnected(ComponentName classname) {
              appService = null;
          }
    };

    public void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.song);

        // ...

        progress = (SeekBar) findViewById(R.id.progress);

        // ...
    }

    public void run() {
    int pos = 0;
    int total = mp.getDuration();
    while (mp != null && pos<total) {
        try {
            Thread.sleep(1000);
            pos = appService.getSongPosition();
        } catch (InterruptedException e) {
            return;
        } catch (Exception e) {
            return;
        }
        progress.setProgress(pos);
    }
}

이것은 잘 작동합니다. 이제 노래 진행의 초 / 분을 계산하는 타이머가 필요합니다. 나는를 넣어 그래서 TextView레이아웃에, 그것을 얻을 수 findViewById()있는 onCreate(), 및이를 넣어 run()후 progress.setProgress(pos):

String time = String.format("%d:%d",
            TimeUnit.MILLISECONDS.toMinutes(pos),
            TimeUnit.MILLISECONDS.toSeconds(pos),
            TimeUnit.MINUTES.toSeconds(TimeUnit.MILLISECONDS.toMinutes(
                    pos))
            );
currentTime.setText(time);  // currentTime = (TextView) findViewById(R.id.current_time);

그러나 마지막 줄은 나에게 예외를줍니다.

android.view.ViewRoot $ CalledFromWrongThreadException :보기 계층 구조를 만든 원래 스레드 만 해당보기를 만질 수 있습니다.

그러나 나는 기본적으로 여기 SeekBar에서보기를 만들고 onCreate나서 만지는 것과 똑같은 일을하고 있으며 run()나 에게이 불만을 제기하지는 않습니다.

UI를 업데이트하는 백그라운드 작업의 일부를 기본 스레드로 이동해야합니다. 이에 대한 간단한 코드가 있습니다.

runOnUiThread(new Runnable() {

    @Override
    public void run() {

        // Stuff that updates the UI

    }
});

에 대한 설명서 Activity.runOnUiThread.

백그라운드에서 실행중인 메소드 안에 이것을 중첩시키고 블록 중간에 업데이트를 구현하는 코드를 복사하여 붙여 넣으십시오. 가능한 한 적은 양의 코드 만 포함하십시오. 그렇지 않으면 백그라운드 스레드의 목적을 무너 뜨리기 시작합니다.

내가 넣어이 문제를 해결 runOnUiThread( new Runnable(){ ..내부 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();

이것에 대한 나의 해결책 :

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

백그라운드 스레드에서이 메소드를 호출하십시오.

일반적으로 사용자 인터페이스와 관련된 모든 작업은 기본 또는 UI 스레드에서 수행해야합니다. 즉 onCreate(), 이벤트 처리가 실행됩니다. 이를 확인하는 한 가지 방법은 runOnUiThread ()를 사용하는 것입니다. 하고 다른 방법은 핸들러를 사용하는 것입니다.

ProgressBar.setProgress() 메인 스레드에서 항상 실행되는 메커니즘이 있으므로 작동합니다.

무통 스레딩을 참조하십시오 .

나는이 상황에 있었지만 핸들러 객체로 해결책을 찾았습니다.

제 경우에는 관찰자 패턴 으로 ProgressDialog를 업데이트하고 싶습니다 . 내보기는 관찰자를 구현하고 업데이트 방법을 재정의합니다.

따라서 내 주요 스레드는 뷰를 만들고 다른 스레드는 ProgressDialop 및 ....을 업데이트하는 update 메서드를 호출합니다.

뷰 계층 구조를 만든 원래 스레드 만 해당 뷰를 만질 수 있습니다.

핸들러 오브젝트의 문제점을 해결할 수 있습니다.

아래 코드의 다른 부분 :

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

이 설명은 이 페이지 에서 찾을 수 있으며 "두 번째 스레드가있는 예제 ProgressDialog"를 읽어야합니다.

기본 UI 스레드를 방해하지 않고 핸들러를 사용하여보기를 삭제할 수 있습니다. 예제 코드는 다음과 같습니다

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

@providence의 답변을 수락하셨습니다. 만일의 경우에도 핸들러를 사용할 수도 있습니다! 먼저 int 필드를 수행하십시오.

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

다음으로 핸들러 인스턴스를 필드로 만듭니다.

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

방법을 만드십시오.

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

마지막으로 이것을 onCreate()방법에 넣으십시오 .

showHandler(true);

비슷한 문제가 있었고 해결책이 못 생겼지 만 작동합니다.

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
}

Handler와 함께 사용 합니다 Looper.getMainLooper(). 그것은 나를 위해 잘 작동했습니다.

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

이 코드를 사용하면 runOnUiThread작동 하지 않아도됩니다 .

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

이것은 명시 적으로 오류를 발생시킵니다. 어떤 스레드가 뷰를 만들 었는지, 그 뷰에만 닿을 수만 있습니다. 작성된 뷰가 해당 스레드의 공간 안에 있기 때문입니다. 뷰 생성 (GUI)은 UI (메인) 스레드에서 발생합니다. 따라서 항상 UI 스레드를 사용하여 해당 메소드에 액세스하십시오.

위 그림에서 progress 변수는 UI 스레드 공간 안에 있습니다. 따라서 UI 스레드 만이 변수에 액세스 할 수 있습니다. 여기에서 new Thread ()를 통해 진행 상황에 액세스하고 있으며 그 때문에 오류가 발생합니다.

이것은 UI doInBackground를 Asynctask대신 사용하여 UI 변경을 요청할 때 발생했습니다.onPostExecute .

UI를 다루는 것이 onPostExecute내 문제를 해결했습니다.

Kotlin 코 루틴은 다음과 같이 코드를보다 간결하고 읽기 쉽게 만들 수 있습니다.

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

혹은 그 반대로도:

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

컨텍스트에 대한 참조가 포함되지 않은 클래스로 작업하고있었습니다. 그래서 runOnUIThread();내가 사용한 것을 사용할 수 없었고 view.post();해결되었습니다.

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

AsyncTask를 사용 하는 경우 onPostExecute 메소드 에서 UI를 업데이트하십시오.

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

     }

나는 비슷한 문제에 직면 해 있었고 위에서 언급 한 방법 중 어느 것도 나를 위해 일하지 않았다. 결국, 이것은 나를 위해 속임수를했다 :

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

나는이 보석을 여기 에서 발견 했다 .

이것은 언급 된 예외의 스택 추적입니다

        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)

그래서 당신이 가서 파면 알게되면

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

mThread 가 아래와 같이 생성자에서 초기화되는 곳

mThread = Thread.currentThread();

우리가 특정보기를 만들 때 UI 스레드에서 만든 다음 나중에 작업자 스레드에서 수정하려고한다는 것을 의미합니다.

아래 코드 스 니펫을 통해 확인할 수 있습니다

Thread.currentThread().getName()

레이아웃을 팽창시키고 나중에 예외가 발생하는 경우.

runOnUiThreadAPI 를 사용하지 않으려면 실제로 AsynTask완료하는 데 몇 초가 걸리는 작업을 구현할 수 있습니다 . 그러나이 경우에도에서 작업을 처리 한 후 doinBackground()완료된보기를에 반환해야합니다 onPostExecute(). Android 구현에서는 기본 UI 스레드 만보기와 상호 작용할 수 있습니다.

비 UI 스레드에서 무효화 (재 페인트 / 다시 그리기 함수 호출)하려는 경우 postInvalidate ()

myView.postInvalidate();

이것은 UI 스레드에 무효화 요청을 게시합니다.

자세한 정보 : what-does-postinvalidate-do

나에게 문제는 onProgressUpdate()코드에서 명시 적 으로 호출했다는 것 입니다. 이 작업을 수행해서는 안됩니다. publishProgress()대신 전화를 걸어 오류를 해결했습니다.

내 경우에는 EditText Adaptor에 있으며 이미 UI 스레드에 있습니다. 그러나이 활동이로드되면이 오류와 충돌합니다.

내 솔루션은 <requestFocus />XML의 EditText에서 제거해야합니다 .

코 틀린에서 고군분투하는 사람들에게는 다음과 같이 작동합니다.

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

해결 :이 메소드를 doInBackround 클래스에 넣고 메시지를 전달하십시오.

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

    }

필자의 경우 호출자가 짧은 시간에 너무 여러 번 호출하면이 오류가 발생합니다. 시간이 너무 짧으면 아무것도하지 않도록 경과 시간을 확인하십시오. 예를 들어 함수가 0.5 초 미만으로 호출되면 무시하십시오.

    private long mLastClickTime = 0;

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

        //... do ui update
    }

UIThread를 찾을 수 없으면이 방법을 사용할 수 있습니다.

yourcurrentcontext이 말은, 당신은 현재 상황을 분석 할 필요가

 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();

코 틀린 답변

우리는 진정한 방법으로 작업을 위해 UI 스레드를 사용해야합니다. Kotlin에서 UI Thread를 사용할 수 있습니다 :

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

아리따움

Kotlin 에서는 단순히 runOnUiThread 활동 메소드에 코드를 넣습니다.

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