How to put an app main thread to sleep, to show progress dialog changes?

I have an开发者_JS百科 app and want to put the main thread to sleep for 1500ms, so I can show a ProgressDialog, but I don't know how to do it. It's possible to stop an app main thread? I can achieve the same goal using another thread right?

Stopping the main thread is usually a bad idea as it would also stop all UI interaction processing.

Try making the progress dialog modal. This will prevent the user from doing anything on your UI until the dialog is gone. I think this will achieve what you want to do and is compatible with how Android works

not a good idea to do this, but if you have to use this

try {
    Thread.sleep(1500);
} catch (InterruptedException e) {
    //handle
}

Don't stop main UI thread! It will freeze UI. I can imagine that you show progress dialog during some background operation. Once this operation is complete just post something to update UI via handler.

The point of progress dialog is to interact with user while something long is executing. Otherwise you would not even need background operation and progress dialog. You would just do you operation in main UI thread and wait for UI to unfreeze.

What you're asking for should be unnecessary and as Carsten said, is a bad idea. It's a cardinal rule that you both never interrupt the UI thread and also only update elements of the UI on that thread. While a Dialog and any of it's subclasses are shown, nothing in the background will receive any input, so while it's up... though the main thread is running, nothing should be happening besides what is going on in the Dialog.

What you're probably looking to do is use something like an AsyncTask() to show your ProgressDialog, do some work, then dismiss it when that work is done.

To do something like this, you'll want to use "Runnables" along with a "Handler." As others mentioned, you don't want to stop the main UI thread. Since there is only one, you won't be showing ANY updates if you make it sleep or wait. See a small sample below of running code on another thread.

The main thing to take out of this is that sleeping the main thread means stopping any and all visual updates.

// Class Variables
private Handler mHandler;

@Override
public void onCreate(){
    // Create a Handler Object
    // In Layman's terms, Handlers can run processes off the main
    //    User interface thread. 
    mHandler = new Handler();

    // Post a "Runnable" after a delay in milliseconds
    // On a separate thread, the progressDialog_Runnable
    //    will call the function "createProgressDialog"
    mHandler.postDelayed(progressDialog_Runnable, 250); 
}

// Runnables (Process to run on separate thread)
private Runnable progressDialog_Runnable;
{
    progressDialog_Runnable = new Runnable(){
        @Override
        public void run() {
            createProgressDialog();
        }
    };  
}

// Method you create to make the progress dialog
private void createProgressDialog(){
    //... Run this code on a separate thread via Runnable
}

Sleep 10s on a thread in Kotlin

try {
    Thread.sleep(10000)
} catch (e: InterruptedException) {
    //handle
}