Looper java android ошибка

UPDATE — 2016

The best alternative is to use RxAndroid (specific bindings for RxJava) for the P in MVP to take charge fo data.

Start by returning Observable from your existing method.

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

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

Use this Observable like this —

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

———————————————————————————————————————————-

I know I am a little late but here goes.
Android basically works on two thread types namely UI thread and background thread. According to android documentation —

Do not access the Android UI toolkit from outside the UI thread to fix this problem, Android offers several ways to access the UI thread from other threads. Here is a list of methods that can help:

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

Now there are various methods to solve this problem.

I will explain it by code sample:

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

LOOPER

Class used to run a message loop for a thread. Threads by default do
not have a message loop associated with them; to create one, call
prepare() in the thread that is to run the loop, and then loop() to
have it process messages until the loop is stopped.

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

AsyncTask allows you to perform asynchronous work on your user
interface. It performs the blocking operations in a worker thread and
then publishes the results on the UI thread, without requiring you to
handle threads and/or handlers yourself.

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

Handler

A Handler allows you to send and process Message and Runnable objects
associated with a thread’s MessageQueue.

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

Can’t create handler inside thread that has not called looper.prepare() is an error that frequently occurs when you’re working with threads in any Android project.

If you can’t understand what exactly is wrong and why you’re seeing this error, don’t worry because we have you covered. Read on as we break down the problem to make it easier to understand and see what you can do to solve it.

You’re seeing this error because you’re trying to show or manipulate a UI or user interface component like Toast from a non-UI thread. For instance, you might be calling it from the worker thread when you need to call it from the main thread.

– Calling a UI Component From a Non-UI Worker Thread

There are a few things you should get out of the way first and learn why you’re making Android call looper prepare. Before anything else, you need to re-evaluate why you’re trying to use a handler in a thread that’s not a UI thread, which is basically a system-supplied looper.

You should also know that handlers are only because of loopers, and anyone who uses a handler uses it in a UI thread since this thread runs a looper.

Think of a looper like a dispatcher that dispatches different events to the handlers mentioned in your code. The events can be anything ranging from timers expiring to button presses. The basic idea of a UI code is that it should respond to the event and quickly go back to the system.

Another thing you need to understand to fully comprehend the error is the worker thread. This is something you set up to execute on its own without any user interaction. Android provides special mechanisms that allow a worker thread to inform or signal to the UI how it’s doing and when it’s done.

So if you want to use a handler in the worker thread instead of the main or UI thread on which your app runs, you need to be well-versed in loopers and how they’re used. You’re seeing this problem not because you want to create a handler but because you’re trying to call or show a UI component from a non-UI or worker thread.

How To Fix Can’t Create Handler Inside Thread That Has Not Called Looper.prepare()

Android basically has two kinds of threads: the background thread and the UI thread. Android’s official documentation states that to fix this problem, you shouldn’t access the Android UI toolkit from outside the UI thread. Instead, Android provides various ways to solve this create handler issue.

Let’s go over all of them one by one.

– Run On UI Thread Android

The run on UI thread function runs the action specified in the parameters on the UI thread. If the current thread is already the UI thread, the action will be executed immediately. But if the current thread isn’t a UI thread, then the action is sent to the UI thread’s event queue. Here’s a code snippet with this function to help you understand it better:

– Use Looper

Looper is the class used for running the message loop for a thread. By default, threads don’t have any message loop associated with them, and to create one, you first need to call prepare() within the thread that will run the loop.

Then you’ll have to run loop() so that it processes the messages until the loop stops. Let’s go over a Looper.prepare() example to help you understand how and where to use Looper.

class LooperThread extends Thread {
public Handler mHandler;
public void run() {
Looper.prepare();
mHandler = new Handler() {
public void handleMessage(Message msg) {
//process incoming messages}
};
Looper.loop();
} }

And if you’re using Kotlin, the following is a Kotlin handler(looper example). Note that one benefit of using this method is that you can directly run the UI code without any Context or Activity.

– AsyncTask

As the name suggests, with AsyncTask, you can do asynchronous work on the user interface. The function essentially performs blocking operations on a worker thread and publishes the results to the UI thread.

With this function, you don’t need to handle the handlers or threads yourself. Here’s a code snippet to help you understand the use better:

public void onClick(View v) {
new CustomTask().execute((Void[]null);
}
private class CustomTask extends AsyncTask {
protected Void doInBackground(Void… param) {
// do something
return null;
}
protected void onPostExecute(Void param) {
//open dialog or print Toast}
}

AsyncTask works quite well for nearly all the things that run in the background. You can call its hooks to know its progress and also when it’s done. And while it’s convenient, note that it can leak contexts if you don’t use it correctly. Also, keep in mind that it’s officially deprecated, so it’s best not to use it.

In some cases, you might get an error saying the current thread has not called looper prepare forcing synchronous mode. This means that you shouldn’t use AsyncTask for the task you want to perform; instead, use a synchronous function like SyncHttpClient.

– Handler

With a handler, you can process and message Runnable and Message objects associated with the MessageQueue of a thread. Let’s quickly go over a code snippet to understand its use.

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){
//Open dialog or print Toast}
return false; }
});

FAQ

1. What Is a Looper in Android?

The Android.os.Looper is a class that’s used to run the message loop for a particular thread. By default, there’s no message loop associated with threads, and you have to call prepare() and then the loop() function so that it can process the messages until the loop stops.

2. Which Thread Will Process a Message Posted to a Handler?

All the input events and UI operations are handled by Android from a single thread called the UI or Main thread. The way this works is that Android collects all the events that take place in this thread and adds them to a queue. This queue is then processed with an instance of the Android Looper class.

3. What Is a UI Thread?

The User Interface or UI thread in Android is basically a Thread element whose purpose is to update the application elements, either explicitly or implicitly. So, if you want to make changes to the attributes or update the elements present in the application layer, i.e., the front end of your application, you’ll have to use the UI thread.

4. What Is the Difference Between Looper and Handler?

Both are different abstractions; looper is an abstraction of the event loop, while the handler inserts or removes event to and from the queue via events and handle them when they’re processed.

Conclusion

Now that you’ve gone through the whole article understanding why you’re seeing the “can’t create handler inside thread that has not called looper.prepare()” error is simple. To sum up, here are the key points we discussed in this article so that you’re fully equipped to solve this issue:

• Android has 2 kinds of threads: the main thread and the background thread.
• The error occurs when you try to show UI components from a non-UI or worker thread. You should call it in the main thread.
• There are many ways to fix this issue. For instance, you can use run on UI thread, Loopers, or Handlers.
• You can also use AsyncTask, but you should be careful when doing so. This is because it’s deprecated and tends to leak contexts.

Once you go over the different fixes mentioned here, we’re sure that you can quickly solve the issue and get your program to run as it should!

UPDATE — 2016

The best alternative is to use RxAndroid (specific bindings for RxJava) for the P in MVP to take charge fo data.

Start by returning Observable from your existing method.

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

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

Use this Observable like this —

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

———————————————————————————————————————————-

I know I am a little late but here goes.
Android basically works on two thread types namely UI thread and background thread. According to android documentation —

Do not access the Android UI toolkit from outside the UI thread to fix this problem, Android offers several ways to access the UI thread from other threads. Here is a list of methods that can help:

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

Now there are various methods to solve this problem.

I will explain it by code sample:

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

LOOPER

Class used to run a message loop for a thread. Threads by default do
not have a message loop associated with them; to create one, call
prepare() in the thread that is to run the loop, and then loop() to
have it process messages until the loop is stopped.

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

AsyncTask allows you to perform asynchronous work on your user
interface. It performs the blocking operations in a worker thread and
then publishes the results on the UI thread, without requiring you to
handle threads and/or handlers yourself.

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

Handler

A Handler allows you to send and process Message and Runnable objects
associated with a thread’s MessageQueue.

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

i’m getting this error which i can’t understand why. I’m fairly new to java. What i’m trying to do is start a new thread which will handle all the save image processes.

Error:

 java.lang.RuntimeException: Can't create handler inside thread that has not called Looper.prepare()
                at android.os.Handler.<init>(Handler.java:200)
                at android.os.Handler.<init>(Handler.java:114)
                at android.app.Dialog.<init>(Dialog.java:108)
                at android.app.AlertDialog.<init>(AlertDialog.java:125)
                at android.app.AlertDialog$Builder.create(AlertDialog.java:967)
                at android.app.AlertDialog$Builder.show(AlertDialog.java:986)
                at com.example.matts.myapplication.MainActivity$1.handleMessage(MainActivity.java:37)
                at com.example.matts.myapplication.Saving.run(Saving.java:54)
                at java.lang.Thread.run(Thread.java:818)

Here’s my code.

Main:

package com.example..myapplication;

import android.app.Activity;
import android.app.AlertDialog;
import android.content.DialogInterface;
import android.content.Intent;
import android.graphics.Bitmap;
import android.graphics.BitmapFactory;
import android.net.Uri;
import android.os.Environment;
import android.os.Handler;
import android.os.Message;
import android.provider.MediaStore;
import android.os.Bundle;
import android.util.Log;
import android.view.View;
import android.widget.ImageView;
import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.util.Date;
import java.text.SimpleDateFormat;


public class MainActivity extends Activity {

    static final int REQUEST_IMAGE_CAPTURE = 1;
    ImageView imageView;
    private static final String TAG = "MyActivity";
    Bitmap image;

    Handler goodHandler = new Handler() {
        @Override
        public void handleMessage(Message message) {
            AlertDialog.Builder builder = new AlertDialog.Builder(getApplicationContext());
            builder.setMessage("File Saved").show();

        }

    };

    Handler badHandler = new Handler() {
        @Override
        public void handleMessage(Message message) {
            AlertDialog.Builder builder = new AlertDialog.Builder(getApplicationContext());
            builder.setMessage("File Save failed").show();

        }

    };



    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        openCamera();
        setContentView(R.layout.activity_main);
        findViewById(R.id.captureImage).bringToFront();
        findViewById(R.id.saveImage).bringToFront();
        imageView = (ImageView) findViewById(R.id.imageView2);

    }

    protected void onSaveInstanceState(Bundle outState){
        File file = new File(Environment.getExternalStorageDirectory() + File.separator + "TMP.jpg");
        file.delete();
    }

    public void openCamera() {
        Intent takePictureIntent = new Intent(MediaStore.ACTION_IMAGE_CAPTURE);
        File file = new File(Environment.getExternalStorageDirectory() + File.separator + "TMP.jpg");
        takePictureIntent.putExtra(MediaStore.EXTRA_OUTPUT, Uri.fromFile(file));
        startActivityForResult(takePictureIntent, REQUEST_IMAGE_CAPTURE);
    }


    protected void onActivityResult(int requestCode, int resultCode, Intent data) {
        //Check that request code matches ours:
        if (requestCode == REQUEST_IMAGE_CAPTURE) {
            //Get our saved file into a bitmap object:
            File file = new File(Environment.getExternalStorageDirectory() + File.separator + "TMP.jpg");
            Bitmap image = decodeSampledBitmapFromFile(file.getAbsolutePath(), 1000, 700);
            imageView.setImageBitmap(image);
        }
    }

// Reduce the amount of dynamic heap used by expanding the JPEG into a memory array that's already scaled to match the size of the destination view
    public static Bitmap decodeSampledBitmapFromFile(String path, int reqWidth, int reqHeight) { // BEST QUALITY MATCH
        //First decode with inJustDecodeBounds=true to check dimensions
        final BitmapFactory.Options options = new BitmapFactory.Options();
        options.inJustDecodeBounds = true;
        BitmapFactory.decodeFile(path, options);

        // Calculate inSampleSize, Raw height and width of image
        final int height = options.outHeight;
        final int width = options.outWidth;
        options.inPreferredConfig = Bitmap.Config.RGB_565;
        int inSampleSize = 1;

        if (height > reqHeight) {
            inSampleSize = Math.round((float) height / (float) reqHeight);
        }
        int expectedWidth = width / inSampleSize;

        if (expectedWidth > reqWidth) {
            //if(Math.round((float)width / (float)reqWidth) > inSampleSize) // If bigger SampSize..
            inSampleSize = Math.round((float) width / (float) reqWidth);
        }

        options.inSampleSize = inSampleSize;

        // Decode bitmap with inSampleSize set
        options.inJustDecodeBounds = false;

        return BitmapFactory.decodeFile(path, options);
    }

    public void capture_btn(View v) {
        Intent takePictureIntent = new Intent(MediaStore.ACTION_IMAGE_CAPTURE);
        File file = new File(Environment.getExternalStorageDirectory() + File.separator + "TMP.jpg");
        takePictureIntent.putExtra(MediaStore.EXTRA_OUTPUT, Uri.fromFile(file));
        startActivityForResult(takePictureIntent, REQUEST_IMAGE_CAPTURE);
    }



    public void storeImage(Bitmap image) {
        imageView.buildDrawingCache();
        Bitmap bm_img = imageView.getDrawingCache();
        Saving saving = new Saving(bm_img, goodHandler, badHandler);
        Thread thread = new Thread(saving);
        thread.start();
    }

    public void save_btn(View v) {
        DialogInterface.OnClickListener dialogClickListener = new DialogInterface.OnClickListener() {
            @Override
            public void onClick(DialogInterface dialog, int which) {
                switch (which){
                    case DialogInterface.BUTTON_POSITIVE:
                        storeImage(image);


                        break;

                    case DialogInterface.BUTTON_NEGATIVE:

                        break;
                }
            }
        };

        AlertDialog.Builder builder = new AlertDialog.Builder(this);
        builder.setMessage("Are you sure?").setPositiveButton("Yes", dialogClickListener)
                .setNegativeButton("No", dialogClickListener).show();

    } //notification messages
}

Saving:

package com.example..myapplication;

import android.graphics.Bitmap;
import android.os.Environment;
import android.os.Message;
import android.util.Log;
import android.os.Handler;


import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.text.SimpleDateFormat;
import java.util.Date;


public class Saving implements Runnable {
    private Bitmap image;
    private android.os.Handler goodHandler;
    private android.os.Handler badHandler;
    private static final String TAG = "Saving";

    public Saving(Bitmap in, Handler hinGood,Handler hinBad) {
        image = in;
        goodHandler = hinGood;
        badHandler = hinBad;


    }

    @Override
    public void run() {
        File file = getOutputMediaFile();
        if (file == null) {
            return;
        }
        try {
            FileOutputStream fos = new FileOutputStream(file);
            image.compress(Bitmap.CompressFormat.PNG, 90, fos);
            fos.close();
        } catch (FileNotFoundException e) {
            Log.d(TAG, "File not found: " + e.getMessage());
            badHandler.handleMessage(new Message());
            return;
        } catch (IOException e) {
            Log.d(TAG, "Error accessing file: " + e.getMessage());
            badHandler.handleMessage(new Message());
            return;
        }
        goodHandler.handleMessage(new Message());


    }

    public File getOutputMediaFile(){
        // To be safe, you should check that the SDCard is mounted
        // using Environment.getExternalStorageState() before doing this.
        File mediaStorageDir = new File(Environment.getExternalStorageDirectory()
                + "/Pictures/Wiki_camera"
                + "/Photos");

        // This location works best if you want the created images to be shared
        // between applications and persist after your app has been uninstalled.

        // Create the storage directory if it does not exist
        if (! mediaStorageDir.exists()){
            if (! mediaStorageDir.mkdirs()){
                return null;
            }
        }
        // Create a media file name
        String timeStamp = new SimpleDateFormat("ddMMyyyy_HHmm").format(new Date());
        File mediaFile;
        String mImageName="camera_wiki"+ timeStamp +".jpg";
        mediaFile = new File(mediaStorageDir.getPath() + File.separator + mImageName);
        return mediaFile;
    }

}

I’ve added whole of the main class and the saving class.