libGDX using android device camera

Question

I am trying to implement a barcode scanning function in my Libgdx project. i have tried to follow : https://github.com/libgdx/libgdx/wiki/Integrating-libgdx-and-the-device-camera but it seems to be outdated.

Does anyone have a clue on how to get the device camera working in libgdx?

Answer 1

I have a project that implemented the android camera. Heres the important code:

Manifest

<uses-permission android:name="android.permission.CAMERA"/>
<uses-permission android:name="android.permission.WRITE_EXTERNAL_STORAGE"/>
<uses-permission android:name="android.permission.READ_EXTERNAL_STORAGE"/>
<uses-feature android:name="android.hardware.camera"/>
<uses-feature android:name="android.hardware.camera.autofocus" />
<uses-permission android:name="android.permission.RECEIVE_BOOT_COMPLETED"/>

AndroidDeviceCameraController (New Class)

import android.graphics.Bitmap;
import android.hardware.Camera;
import android.view.ViewGroup;
import android.view.ViewGroup.LayoutParams;
import android.view.ViewParent;

import com.badlogic.gdx.files.FileHandle;
import com.badlogic.gdx.graphics.Pixmap;

import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.util.List;

public class AndroidDeviceCameraController implements DeviceCameraControl,            
Camera.PictureCallback, Camera.AutoFocusCallback {

private static final int ONE_SECOND_IN_MILI = 1000;
private final MainActivity activity;
private CameraSurface cameraSurface;
private byte[] pictureData;
FileHandle jpgfile;
Pixmap pixmap;
FileHandle jpgfile2;
Pixmap pixmap2;

public AndroidDeviceCameraController(MainActivity activity) {
    this.activity = activity;
}

@Override
public synchronized void prepareCamera() {

    activity.setFixedSize(960,640);
    if (cameraSurface == null) {
        cameraSurface = new CameraSurface(activity);
    }
    activity.addContentView( cameraSurface, new LayoutParams(     
LayoutParams.WRAP_CONTENT, LayoutParams.WRAP_CONTENT ) );

}

@Override
public synchronized void startPreview() {
    setCameraParametersForPicture(cameraSurface.getCamera());
    if (cameraSurface != null && cameraSurface.getCamera() != null) {
        cameraSurface.getCamera().startPreview();
    }
}

@Override
public synchronized void stopPreview() {
    if (cameraSurface != null) {
        ViewParent parentView = cameraSurface.getParent();
        if (parentView instanceof ViewGroup) {
            ViewGroup viewGroup = (ViewGroup) parentView;
            viewGroup.removeView(cameraSurface);
        }
        if (cameraSurface.getCamera() != null) {
            cameraSurface.getCamera().stopPreview();
        }
    }
    activity.restoreFixedSize();
}


public void setCameraParametersForPicture(Camera camera) {
    camera.setDisplayOrientation(90);
    Camera.Parameters p = camera.getParameters();
    List<Camera.Size> supportedSizes = p.getSupportedPictureSizes();
    int maxSupportedWidth = -1;
    int maxSupportedHeight = -1;
    for (Camera.Size size : supportedSizes) {
        if (size.width > maxSupportedWidth) {
            maxSupportedWidth = size.width;
            maxSupportedHeight = size.height;
        }
    }
    p.setPictureSize(maxSupportedWidth, maxSupportedHeight);
    p.setFocusMode(Camera.Parameters.FOCUS_MODE_AUTO);
    camera.setParameters( p );

}

@Override
public synchronized void takePicture() {
    setCameraParametersForPicture(cameraSurface.getCamera());
    cameraSurface.getCamera().autoFocus(this);

}

@Override
public synchronized void onAutoFocus(boolean success, Camera camera) {
    if (success) {
        if (camera != null) {
            camera.startPreview();
            ShutterCallback shutterCallback = new ShutterCallback() {
                @Override
                public void onShutter() {

                }
            };
            camera.takePicture(shutterCallback, null, null, this);
        }
    }
}

@Override
public synchronized void onPictureTaken(byte[] pictureData, Camera camera) {
    main.makefoto = true;
    this.pictureData = pictureData;
}

@Override
public synchronized byte[] getPictureData() {
    return pictureData;
}

@Override
public void prepareCameraAsync() {
    Runnable r = new Runnable() {
        public void run() {
            prepareCamera();
        }
    };
    activity.post(r);
}

@Override
public synchronized void startPreviewAsync() {
    Runnable r = new Runnable() {
        public void run() {
            startPreview();
        }
    };
    activity.post(r);
}

@Override
public synchronized void stopPreviewAsync() {
    Runnable r = new Runnable() {
        public void run() {
            stopPreview();
        }
    };
    activity.post(r);

}

@Override
public synchronized byte[] takePictureAsync(long timeout) {
    timeout *= ONE_SECOND_IN_MILI;
    pictureData = null;
    Runnable r = new Runnable() {
        public void run() {
            takePicture();
        }
    };
    activity.post(r);
    while (pictureData == null && timeout > 0) {
        try {
            Thread.sleep(ONE_SECOND_IN_MILI);
            timeout -= ONE_SECOND_IN_MILI;
        } catch (InterruptedException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    }
    if (pictureData == null) {
        cameraSurface.getCamera().cancelAutoFocus();
    }

    return pictureData;
}

public void convert() {
    new Thread(new Runnable() {
        @Override
        public void run() {
            FileOutputStream fos;
            int x=0,y=0;
            int xl=0,yl=0;
            try {
                Bitmap bmp = Bitmap.createBitmap(pixmap.getWidth(), 
 pixmap.getHeight(), Bitmap.Config.ARGB_8888);
                for (x=0,xl=pixmap.getWidth(); x<xl;x++) {
                    for (y=0,yl=pixmap.getHeight(); y<yl;y++) {
                        int color = pixmap.getPixel(x, y);
                        // RGBA => ARGB
                        int RGB = color >> 8;
                        int A = (color & 0x000000ff) << 24;
                        int ARGB = A | RGB;
                        bmp.setPixel(x, y, ARGB);
                    }
                }
                fos = new FileOutputStream(jpgfile.file());
                bmp.compress(Bitmap.CompressFormat.JPEG, 90, fos);
                fos.close();
            } catch (FileNotFoundException e) {
                e.printStackTrace();
            } catch (IOException e) {
                e.printStackTrace();
            } catch (IllegalArgumentException e) {
                e.printStackTrace();
            }
            jpgfile = jpgfile2;
            pixmap = pixmap2;
        }
    }).start();
}

@Override
public void saveAsJpeg(FileHandle jpgfile, Pixmap pixmap) {
    convert();
    this.jpgfile = jpgfile;
    this.pixmap = pixmap;
    jpgfile2 = this.jpgfile;
    pixmap2 = this.pixmap;


}


@Override
public boolean isReady() {
    if (cameraSurface!=null && cameraSurface.getCamera() != null) {
        return true;
    }
    return false;
}
}