පහත ව්‍යතිරේකයේ අර්ථය කුමක්ද; මම එය නිවැරදි කරන්නේ කෙසේද?

කේතය මෙයයි:

Toast toast = Toast.makeText(mContext, "Something", Toast.LENGTH_SHORT);

ව්යතිරේකය මෙයයි:

java.lang.RuntimeException: Can't create handler inside thread that has not called Looper.prepare()
     at android.os.Handler.<init>(Handler.java:121)
     at android.widget.Toast.<init>(Toast.java:68)
     at android.widget.Toast.makeText(Toast.java:231)

ඔබ එය අමතන්නේ සේවක නූලකින්. ඔබට ඇමතිය යුතුයිToast.makeText()ප්‍රධාන ත්‍රෙඩ් එකෙන්ම (සහ UI සමඟ කටයුතු කරන වෙනත් බොහෝ කාර්යයන්). උදාහරණයක් ලෙස ඔබට හසුරුවන්නෙකු භාවිතා කළ හැකිය.

ප්‍රලේඛනයේ UI Thread සමඟ සන්නිවේදනය කිරීම බලන්න . කෙටියෙන්:

// Set this up in the UI thread.

mHandler = new Handler(Looper.getMainLooper()) {
    @Override
    public void handleMessage(Message message) {
        // This is where you do your work in the UI thread.
        // Your worker tells you in the message what to do.
    }
};

void workerThread() {
    // And this is how you call it from the worker thread:
    Message message = mHandler.obtainMessage(command, parameter);
    message.sendToTarget();
}

වෙනත් විකල්ප:

ඔබට AsyncTask භාවිතා කළ හැකිය , එය පසුබිමේ ධාවනය වන බොහෝ දේ සඳහා හොඳින් ක්‍රියා කරයි. එහි ප්‍රගතිය දැක්වීමට ඔබට ඇමතිය හැකි කොකු ඇත, එය සිදු වූ විට.

ඔබට Activity.runOnUiThread () ද භාවිතා කළ හැකිය .

ඔබට Toast.makeText(...)UI නූලෙන් ඇමතිය යුතුය :

activity.runOnUiThread(new Runnable() {
  public void run() {
    Toast.makeText(activity, "Hello", Toast.LENGTH_SHORT).show();
  }
});

මෙය වෙනත් (අනුපිටපත්) SO පිළිතුරකින් පිටපත් කර ඇත.

යාවත්කාලීන කිරීම - 2016

හොඳම විකල්පය භාවිතා කිරීමයි RxAndroid(සඳහා විශේෂිත සබඳතා RxJavaසඳහා) Pතුළ MVPදත්ත දැමිමේ භාර ගන්නා ලෙස ය.

Observableඔබගේ පවතින ක්‍රමයෙන් ආපසු යාමෙන් ආරම්භ කරන්න.

private Observable<PojoObject> getObservableItems() {
    return Observable.create(subscriber -> {

        for (PojoObject pojoObject: pojoObjects) {
            subscriber.onNext(pojoObject);
        }
        subscriber.onCompleted();
    });
}

මේ ආකාරයෙන් නිරීක්ෂණය කළ හැකි දේ භාවිතා කරන්න -

getObservableItems().
subscribeOn(Schedulers.io()).
observeOn(AndroidSchedulers.mainThread()).
subscribe(new Observer<PojoObject> () {
    @Override
    public void onCompleted() {
        // Print Toast on completion
    }

    @Override
    public void onError(Throwable e) {}

    @Override
    public void onNext(PojoObject pojoObject) {
        // Show Progress
    }
});
}

-------------------------------------------------- -------------------------------------------------- ------------------------------

මම දන්නවා මම ටිකක් පරක්කුයි නමුත් මෙන්න යනවා. ඇන්ඩ්‍රොයිඩ් මූලික වශයෙන් ක්‍රියා කරන්නේ UI නූල් සහ පසුබිම් නූල් යන නූල් වර්ග දෙකක ය . ඇන්ඩ්‍රොයිඩ් ප්‍රලේඛනයට අනුව -

මෙම ගැටළුව විසඳීම සඳහා UI නූල් වලින් පිටත සිට ඇන්ඩ්‍රොයිඩ් UI මෙවලම් කට්ටලයට ප්‍රවේශ නොවන්න, ඇන්ඩ්‍රොයිඩ් වෙනත් නූල් වලින් UI නූල් වෙත ප්‍රවේශ වීමට ක්‍රම කිහිපයක් ඉදිරිපත් කරයි. උදව් කළ හැකි ක්‍රම ලැයිස්තුවක් මෙන්න:

Activity.runOnUiThread(Runnable)  
View.post(Runnable)  
View.postDelayed(Runnable, long)

දැන් මෙම ගැටළුව විසඳීම සඳහා විවිධ ක්රම තිබේ.

කේත නියැදියකින් මම එය පැහැදිලි කරමි:

runOnUiThread

new Thread()
{
    public void run()
    {
        myactivity.this.runOnUiThread(new Runnable()
        {
            public void run()
            {
                //Do your UI operations like dialog opening or Toast here
            }
        });
    }
}.start();

ලූපර්

නූල් සඳහා පණිවිඩ පුඩුවක් ධාවනය කිරීමට භාවිතා කරන පන්තිය. පෙරනිමියෙන් නූල් වලට පණිවිඩ ලූපයක් සම්බන්ධ නොවේ; එකක් නිර්මාණය කිරීමට, ලූපය ධාවනය කිරීමට අවශ්‍ය නූල් එකේ සූදානම් () අමතන්න, ඉන්පසු ලූප් () ලූපය නතර වන තුරු පණිවිඩ සැකසීමට එය කරන්න.

class LooperThread extends Thread {
    public Handler mHandler;

    public void run() {
        Looper.prepare();

        mHandler = new Handler() {
            public void handleMessage(Message msg) {
                // process incoming messages here
            }
        };

        Looper.loop();
    }
}

අසින්ක් ටාස්ක්

ඔබේ පරිශීලක අතුරුමුහුණතෙහි අසමමුහුර්ත වැඩ කිරීමට AsyncTask ඔබට ඉඩ දෙයි. එය සේවක ත්‍රෙඩ් එකක අවහිර කිරීමේ මෙහෙයුම් සිදු කරන අතර ප්‍රති the ල UI නූල් මත ප්‍රකාශයට පත් කරයි.

public void onClick(View v) {
    new CustomTask().execute((Void[])null);
}


private class CustomTask extends AsyncTask<Void, Void, Void> {

    protected Void doInBackground(Void... param) {
        //Do some work
        return null;
    }

    protected void onPostExecute(Void param) {
        //Print Toast or open dialog
    }
}

හසුරුවන්නා

නූල් පණිවිඩ පණිවිඩයක් හා සම්බන්ධ පණිවුඩ සහ ධාවනය කළ හැකි වස්තු යැවීමට සහ සැකසීමට හෑන්ඩ්ලර් ඔබට ඉඩ දෙයි.

Message msg = new Message();


new Thread()
{
    public void run()
    {
        msg.arg1=1;
        handler.sendMessage(msg);
    }
}.start();



Handler handler = new Handler(new Handler.Callback() {

    @Override
    public boolean handleMessage(Message msg) {
        if(msg.arg1==1)
        {
            //Print Toast or open dialog        
        }
        return false;
    }
});

Toast.makeText()කැඳවිය යුත්තේ ප්‍රධාන / යූඅයි නූල් වලින් පමණි. Looper.getMainLooper ()එය සාක්ෂාත් කර ගැනීමට ඔබට උපකාරී වේ:

ජාවා

new Handler(Looper.getMainLooper()).post(new Runnable() {
    @Override
    public void run() {
        Toast toast = Toast.makeText(mContext, "Something", Toast.LENGTH_SHORT);
    }
});

කොට්ලින්

Handler(Looper.getMainLooper()).post {
                    Toast.makeText(mContext, "Something", Toast.LENGTH_SHORT)
                }

මෙම ක්‍රමයේ වාසියක් නම් ඔබට එය ක්‍රියාකාරකම් හෝ සන්දර්භය නොමැතිව භාවිතා කළ හැකිය.

හසුරුවන්නාට පෙර ලූපර් සූදානම් නොවීම නිසා ධාවන කාල එක්ස්පෙන්ෂන් දුටු විට මෙය උත්සාහ කරන්න.

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

handler.postDelayed(new Runnable() {
  @Override
  public void run() {
  // Run your task here
  }
}, 1000 );

මම එකම ගැටලුවකට මුහුණ දුන් අතර, මම එය නිවැරදි කළ ආකාරය මෙන්න:

private final class UIHandler extends Handler
{
    public static final int DISPLAY_UI_TOAST = 0;
    public static final int DISPLAY_UI_DIALOG = 1;

    public UIHandler(Looper looper)
    {
        super(looper);
    }

    @Override
    public void handleMessage(Message msg)
    {
        switch(msg.what)
        {
        case UIHandler.DISPLAY_UI_TOAST:
        {
            Context context = getApplicationContext();
            Toast t = Toast.makeText(context, (String)msg.obj, Toast.LENGTH_LONG);
            t.show();
        }
        case UIHandler.DISPLAY_UI_DIALOG:
            //TBD
        default:
            break;
        }
    }
}

protected void handleUIRequest(String message)
{
    Message msg = uiHandler.obtainMessage(UIHandler.DISPLAY_UI_TOAST);
    msg.obj = message;
    uiHandler.sendMessage(msg);
}

UIHandler නිර්මාණය කිරීම සඳහා, ඔබ පහත සඳහන් දෑ සිදු කළ යුතුය:

    HandlerThread uiThread = new HandlerThread("UIHandler");
    uiThread.start();
    uiHandler = new UIHandler((HandlerThread) uiThread.getLooper());

මෙය උපකාරී වේ යැයි සිතමි.

දෝෂයක් සඳහා හේතුව:

සේවක නූල් යනු පසුබිම් කාර්යයන් කිරීම සඳහා වන අතර ඔබ runOnUiThread වැනි ක්‍රමයක් අමතන්නේ නැත්නම් ඔබට සේවක නූල් තුළ UI හි කිසිවක් පෙන්විය නොහැක . RunOnUiThread ඇමතීමෙන් තොරව ඔබ UI නූල් මත කිසිවක් පෙන්වීමට උත්සාහ කරන්නේ නම්, a java.lang.RuntimeException.

ඒ නිසා, ඔබ තුළ නම් activityනමුත් ඉල්ලා Toast.makeText()සේවකයෙකු නූල් සිට මෙය කරන්න:

runOnUiThread(new Runnable() 
{
   public void run() 
   {
      Toast toast = Toast.makeText(getApplicationContext(), "Something", Toast.LENGTH_SHORT).show();    
   }
}); 

ඉහත කේතය මඟින් ඔබ ටෝස්ට් පණිවිඩය UI threadඇතුළත runOnUiThreadක්‍රමය ලෙස හඳුන්වන බැවින් එය පෙන්වන බව සහතික කරයි . එබැවින් තවත් නැත java.lang.RuntimeException.

ඒකයි මම කළේ.

new Handler(Looper.getMainLooper()).post(new Runnable() {
    @Override
    public void run() {
        Toast(...);
    }
});

බාහිර කොටස් වලින් සිදුවන වෙනස්කම් වලට දෘශ්‍ය සංරචක "අගුළු දමා" ඇත. එබැවින්, ටෝස්ට් ප්‍රධාන තිරය මඟින් කළමනාකරණය කරන ප්‍රධාන තිරයේ දේවල් පෙන්වන බැවින්, ඔබ මෙම කේතය එම ත්‍රෙඩ් එක මත ධාවනය කළ යුතුය. උපකාරී වන බලාපොරොත්තුව :)

මම පහත සඳහන් දේ කරන තුරු මට මෙම දෝෂය ඇතිවිය.

public void somethingHappened(final Context context)
{
    Handler handler = new Handler(Looper.getMainLooper());
    handler.post(
        new Runnable()
        {
            @Override
            public void run()
            {
                Toast.makeText(context, "Something happened.", Toast.LENGTH_SHORT).show();
            }
        }
    );
}

මෙය තනි පන්තියක් බවට පත් කළේය:

public enum Toaster {
    INSTANCE;

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

    public void postMessage(final String message) {
        handler.post(
            new Runnable() {
                @Override
                public void run() {
                    Toast.makeText(ApplicationHolder.INSTANCE.getCustomApplication(), message, Toast.LENGTH_SHORT)
                        .show();
                }
            }
        );
    }

}

 runOnUiThread(new Runnable() {
            public void run() {
                Toast.makeText(mContext, "Message", Toast.LENGTH_SHORT).show();
            }
        });

පුදුමාකාර කොට්ලින් විසඳුම:

runOnUiThread {
    // Add your ui thread code here
}

එයට හේතුව Toast.makeText () සේවක නූලකින් ඇමතීමයි. එය මේ ආකාරයට ප්‍රධාන UI නූල් වලින් ඇමතිය යුතුය

runOnUiThread(new Runnable() {
      public void run() {
        Toast toast = Toast.makeText(mContext, "Something", Toast.LENGTH_SHORT);
      }
 });

චිකෝබර්ඩ්ගේ පිළිතුර මට වැඩ කළේය. මා කළ එකම වෙනස වූයේ මට කළ යුතු UIHandler නිර්මාණය කිරීමයි

HandlerThread uiThread = new HandlerThread("UIHandler");

සූර්යග්‍රහණය වෙනත් කිසිවක් පිළිගැනීම ප්‍රතික්ෂේප කළේය. මම හිතන්නේ තේරුමක් තියෙනවා.

එසේම uiHandlerඑය පැහැදිලිවම කොතැනක හෝ අර්ථ දක්වා ඇති පන්ති ගෝලීය වේ. ඇන්ඩ්‍රොයිඩ් මෙය කරන්නේ කෙසේද සහ සිදුවන්නේ කුමක්ද යන්න තේරුම් ගැනීමට මම තවමත් හිමිකම් නොකියමි, නමුත් එය ක්‍රියාත්මක වීම ගැන මම සතුටු වෙමි. දැන් මම එය අධ්‍යයනය කර ඇන්ඩ්‍රොයිඩ් කරන්නේ කුමක්ද සහ මට මේ සියලු වළලු සහ ලූප හරහා යා යුත්තේ ඇයි දැයි තේරුම් ගත හැකිදැයි බලන්නෙමි. චිකෝබර්ඩ්ගේ උදව්වට ස්තූතියි.

පළමු ඇමතුම Looper.prepare()ලබාගෙන Toast.makeText().show()අවසන් ඇමතුම අමතන්න Looper.loop():

Looper.prepare() // to be able to make toast
Toast.makeText(context, "not connected", Toast.LENGTH_LONG).show()
Looper.loop()

Rxjava සහ RxAndroid පරිශීලකයා සඳහා:

public static void shortToast(String msg) {
    Observable.just(msg)
            .observeOn(AndroidSchedulers.mainThread())
            .subscribe(message -> {
                Toast.makeText(App.getInstance(), message, Toast.LENGTH_SHORT).show();
            });
}

මගේ ඇමතුම් ආපසු දෙබස් පෙන්වීමට උත්සාහ කරන විට මම එකම ගැටලුවකට මුහුණ දෙමින් සිටියෙමි.

ක්‍රියාකාරීත්වයේ සාමාජික ක්‍රියාකාරකම් මට්ටමින් - භාවිතා කරන විශේෂිත ක්‍රමවේදයන් සමඟ මම එය විසඳා ගතිමිrunOnUiThread(..)

public void showAuthProgressDialog() {
    runOnUiThread(new Runnable() {
        @Override
        public void run() {
            mAuthProgressDialog = DialogUtil.getVisibleProgressDialog(SignInActivity.this, "Loading ...");
        }
    });
}

public void dismissAuthProgressDialog() {
    runOnUiThread(new Runnable() {
        @Override
        public void run() {
            if (mAuthProgressDialog == null || ! mAuthProgressDialog.isShowing()) {
                return;
            }
            mAuthProgressDialog.dismiss();
        }
    });
}

Handler handler2;  
HandlerThread handlerThread=new HandlerThread("second_thread");
handlerThread.start();
handler2=new Handler(handlerThread.getLooper());

දැන් හෑන්ඩ්ලර් 2 ප්‍රධාන ත්‍රෙඩ් එකට වඩා පණිවිඩ හැසිරවීමට වෙනස් ත්‍රෙඩ් එකක් භාවිතා කරයි.

ත්‍රෙඩ් එකක සංවාදයක් හෝ ටෝස්ටරයක් ​​ප්‍රදර්ශනය කිරීම සඳහා වඩාත් සංක්ෂිප්ත ක්‍රමය වන්නේ ක්‍රියාකාරකම් වස්තුව භාවිතා කිරීමයි.

උදාහරණයක් වශයෙන්:

new Thread(new Runnable() {
    @Override
    public void run() {
        myActivity.runOnUiThread(new Runnable() {
            public void run() {
                myActivity.this.processingWaitDialog = new ProgressDialog(myActivity.this.getContext());
                myActivity.this.processingWaitDialog.setProgressStyle(ProgressDialog.STYLE_SPINNER);
                myActivity.this.processingWaitDialog.setMessage("abc");
                myActivity.this.processingWaitDialog.setIndeterminate(true);
                myActivity.this.processingWaitDialog.show();
            }
        });
        expenseClassify.serverPost(
                new AsyncOperationCallback() {
                    public void operationCompleted(Object sender) {
                        myActivity.runOnUiThread(new Runnable() {
                            public void run() {
                                if (myActivity.this.processingWaitDialog != null 
                                        && myActivity.this.processingWaitDialog.isShowing()) {
                                    myActivity.this.processingWaitDialog.dismiss();
                                    myActivity.this.processingWaitDialog = null;
                                }
                            }
                        }); // .runOnUiThread(new Runnable()
...

ලැම්බඩා භාවිතා කිරීම:

activity.runOnUiThread(() -> Toast.makeText(activity, "Hello", Toast.LENGTH_SHORT).show());

ටෝස්ට්, ඇලර්ට් ඩයලොග්ස් යූඅයි නූල් මත ධාවනය කිරීමට අවශ්‍යයි, ඔබට ඒවා ඇන්ඩ්‍රොයිඩ් සංවර්ධනයේදී නිසි ලෙස භාවිතා කිරීමට අසින්ක්ටාස්ක් භාවිතා කළ හැකිය.නමුත් සමහර අවස්ථාවලදී අපට කාලය ඉකුත්වීම රිසිකරණය කිරීමට අවශ්‍ය වේ, එබැවින් අපි නූල් භාවිතා කරන්නෙමු , නමුත් නූල් වලදී අපට ටෝස්ට්, ඇලර්ට් ඩයලොග් භාවිතා කළ නොහැක. AsyncTask හි. එබැවින් අපට උත්පතන සඳහා වෙනම හෑන්ඩ්ලර් අවශ්‍ය වේ.

public void onSigned() {
    Thread thread = new Thread(){
        @Override
        public void run() {
            try{
                sleep(3000);
                Message message = new Message();
                message.what = 2;
                handler.sendMessage(message);
            } catch (Exception e){
                e.printStackTrace();
            }
        }
    };
    thread.start();
}

ඉහත උදාහරණයේ දී මට මගේ නූල් 3sec තුළ නිදා ගැනීමට අවශ්‍ය වන අතර මට ටෝස්ට් පණිවිඩයක් පෙන්වීමට අවශ්‍ය වූ පසු, ඒ සඳහා ඔබේ ප්‍රධාන පෙළේ ක්‍රියාත්මක කිරීමේ හසුරුවන්න.

handler = new Handler() {
       public void handleMessage(Message msg) {
           switch(msg.what){
              case 1:
              Toast.makeText(getActivity(),"cool",Toast.LENGTH_SHORT).show();
              break;
           }
           super.handleMessage(msg);
       }
};

මම මෙහි ස්විච් කේස් භාවිතා කළෙමි, මන්ද ඔබට විවිධ පණිවිඩ එකම ආකාරයකින් පෙන්වීමට අවශ්‍ය නම්, ඔබට හැන්ඩ්ලර් පන්තිය තුළ ස්විච් කේස් භාවිතා කළ හැකිය ... මෙය ඔබට උපකාරී වනු ඇතැයි බලාපොරොත්තු වෙමි

මෙය සාමාන්‍යයෙන් සිදුවන්නේ ප්‍රධාන නූල් මත යමක් ඕනෑම පසුබිම් නූලකින් කැඳවූ විටය. උදාහරණයක් ලෙස උදාහරණයක් බලමු.

private class MyTask extends AsyncTask<Void, Void, Void> {


@Override
protected Void doInBackground(Void... voids) {
        textView.setText("Any Text");
        return null;
    }
}

ඉහත උදාහරණයේ දී, අපි වැඩකරන නූල් මත පමණක් ක්‍රියාත්මක වන doInBackground () ක්‍රමයෙන් ප්‍රධාන UI ත්‍රෙඩ් එකේ පෙළ දර්ශනය සකස් කරමු.

මට එකම ගැටළුවක් ඇති අතර, මම එය ටෝස්ට් ඔන් පෝස්ට්එක්ස්කියුට් () අසින්ක්ටාස්ක් <> හි අභිබවා යන ශ්‍රිතයට ඇතුළත් කිරීමෙන් එය නිවැරදි කළෙමි.

ඔබට UI නූල් මත ටෝස්ට් සෑදිය යුතුය. පහත උදාහරණය සොයා ගන්න.

runOnUiThread(new Runnable() {
  public void run() {
    Toast.makeText(activity, "YOUR_MESSAGE", Toast.LENGTH_SHORT).show();
  }
});

ටෝස්ට් පණිවිඩය ප්‍රදර්ශනය කිරීම සඳහා කරුණාකර මෙම ලිපිය බලන්න

කොරොටින් භාවිතා කරමින් කෝට්ලින් සඳහා විසඳුම මෙන්න:

MainScope () විසින් CoroutineScope සමඟ ඔබේ පන්තිය දිගු කරන්න:

class BootstrapActivity :  CoroutineScope by MainScope() {}

ඉන්පසු මෙය සරලව කරන්න:

launch {
        // whatever you want to do in the main thread
    }

කොරෝටීන් සඳහා පරායත්තතා එකතු කිරීමට අමතක නොකරන්න:

org.jetbrains.kotlinx:kotlinx-coroutines-core:${Versions.kotlinCoroutines}
org.jetbrains.kotlinx:kotlinx-coroutines-android:${Versions.kotlinCoroutines}

ජාවා 8

new Handler(Looper.getMainLooper()).post(() -> showToast() //work in the UI thread;

Coroutine එය පරිපූර්ණව කරනු ඇත

CoroutineScope(Job() + Dispatchers.Main).launch {
                        Toast.makeText(context, "yourmessage",Toast.LENGTH_LONG).show()}

ප්‍රධාන නොවන නූල් "සන්දර්භය" වෙතින් පණිවිඩය පෙන්වීමට මම පහත කේතය භාවිතා කරමි,

@FunctionalInterface
public interface IShowMessage {
    Context getContext();

    default void showMessage(String message) {
        final Thread mThread = new Thread() {
            @Override
            public void run() {
                try {
                    Looper.prepare();
                    Toast.makeText(getContext(), message, Toast.LENGTH_LONG).show();
                    Looper.loop();
                } catch (Exception error) {
                    error.printStackTrace();
                    Log.e("IShowMessage", error.getMessage());
                }
            }
        };
        mThread.start();
    }
}

ඉන්පසු පහත පරිදි භාවිතා කරන්න:

class myClass implements IShowMessage{

  showMessage("your message!");
 @Override
    public Context getContext() {
        return getApplicationContext();
    }
}