CODEWITHSUNDEEP
javaandroidmultithreadingsleep
spogebob92
spogebob92

Reputation: 1484

Sleep() in Android Java

I am following this tutorial to have a loading screen in my program. The tutorial says my activity should Sleep() using the Sleep() command, however it does not recognize Sleep() as a function and provides me with an error, asking if I would like to create a method called Sleep().

Here is the code sample:

public class LoadingScreenActivity extends Activity {

    //Introduce an delay
    private final int WAIT_TIME = 2500;

    @Override
    protected void onCreate(Bundle savedInstanceState) {

        // TODO Auto-generated method stub
        super.onCreate(savedInstanceState);
        System.out.println("LoadingScreenActivity screen started");

        setContentView(R.layout.loading_screen);
        findViewById(R.id.mainSpinner1).setVisibility(View.VISIBLE);

        new Handler().postDelayed(new Runnable(){ 

            @Override 
            public void run() {

                //Simulating a long running task
                this.Sleep(1000);
                System.out.println("Going to Profile Data");

                /* Create an Intent that will start the ProfileData-Activity. */
                Intent mainIntent = new Intent(LoadingScreenActivity.this,ProfileData.class); 
                LoadingScreenActivity.this.startActivity(mainIntent);
                LoadingScreenActivity.this.finish(); 
            } 
        }, WAIT_TIME);
    }
}

Upvotes: 29

Views: 106417

Answers (4)

Leon pvc
Leon pvc

Reputation: 31

use Thread.sleep(1000);

1000 is the number of milliseconds that the program will pause. 

try        
{
    Thread.sleep(1000);
} 
catch(InterruptedException ex) 
{
    Thread.currentThread().interrupt();
}

Keep in mind: Using this code is not recommended, because it is a delay of time but without control and may need more or less time.

Upvotes: 3

Karan_Rana
Karan_Rana

Reputation: 2823

You can use one of the folllowing methods:

Thread.sleep(timeInMills);

or

SystemClock.sleep(timeInMills);

SystemClock.sleep(milliseconds) is a utility function very similar to Thread.sleep(milliseconds), but it ignores InterruptedException. Use this function for delays if you do not use Thread.interrupt(), as it will preserve the interrupted state of the thread.

Upvotes: 64

323go
323go

Reputation: 14274

The code you posted is horrible. Please don't use that on an actual device. You will get an "Application Not Responding" error if you run something similar to this.

If you're using Handlers, keep in mind that a Handler is created on the thread where it runs. So calling new Handler().post(... on the UI thread will execute the runnable on the UI thread, including this "long running operation". The advantage is that you can create a Handler to the UI Thread which you can use later, as shown below.

To put the long running operation into a background thread, you need to create a Thread around the runnable, as shown below. Now if you want to update the UI once the long running operation is complete, you need to post that to the UI Thread, using a Handler.

Note that this functionality is a perfect fit for an AsyncTask which will make this look a lot cleaner than the pattern below. However, I included this to show how Handlers, Threads and Runnables relate.

public class LoadingScreenActivity extends Activity {

//Introduce a delay
    private final int WAIT_TIME = 2500;
    private Handler uiHandler;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        uiHandler = new Handler(); // anything posted to this handler will run on the UI Thread
        System.out.println("LoadingScreenActivity  screen started");
        setContentView(R.layout.loading_screen);
        findViewById(R.id.mainSpinner1).setVisibility(View.VISIBLE);

        Runnable onUi = new Runnable() {
            @Override 
            public void run() {
                // this will run on the main UI thread 
                Intent mainIntent = new Intent(LoadingScreenActivity.this,ProfileData.class); 
                LoadingScreenActivity.this.startActivity(mainIntent); 
                LoadingScreenActivity.this.finish(); 
            }
        }; 

        Runnable background = new Runnable() { 
            @Override 
            public void run() { 
                // This is the delay
                Thread.Sleep( WAIT_TIME );
                // This will run on a background thread
                //Simulating a long running task
                Thread.Sleep(1000);
                System.out.println("Going to Profile Data");
                uiHandler.post( onUi );
            }
        };

        new Thread( background ).start(); 
}

Upvotes: 5

MByD
MByD

Reputation: 137442

The function is Thread.sleep(long).

Note, however, that you should not perform a sleep on the UI thread.

Upvotes: 8

Related Questions