Android 显示使用中的相机表面

我想创建一个应用程序，用相机预览每10秒拍摄一次照片。我通过一项活动来创造它，一切都很顺利。

---

现在我想知道，是否有任何方法可以在服务中拍照，并在拍照前显示相机预览，所有这些都在服务中进行

您可以使用OpenGL纹理从服务中显示相机预览

摄影机辅助对象：

public class CameraHelper {
    private final static String TAG = "CameraHelper";

    private static Camera sCamera;
    private static Camera.Parameters sParameters;
    public synchronized static Camera getCameraInstance(){
        if (sCamera == null) {
            try {
                sCamera = Camera.open(); // attempt to get a Camera instance
            }
            catch (Exception e) {}
        }

        if (sCamera != null) {
            sParameters = sCamera.getParameters();
            getFormats();
        }
        return sCamera; // returns null if camera is unavailable
    }

    public static void getFormats() {
         List<Size> picSizes = sParameters.getSupportedPictureSizes();
         Size s = picSizes.get(1);
         sParameters.setPictureSize(s.width, s.height);
         picSizes = sParameters.getSupportedPreviewSizes();
         Size previewSize = picSizes.get(picSizes.size() - 1);
         sParameters.setPreviewSize(previewSize.width, previewSize.width);
         sParameters.setPreviewFormat(ImageFormat.JPEG);
    }

    public synchronized static void releaseCamera() {
        if (sCamera != null) {
            sCamera.stopPreview();
            sCamera.release();        // release the camera for other applications
            sCamera = null;
        }
    }
}

公共类摄像机帮助器{
私有最终静态字符串TAG=“CameraHelper”；
私人静态摄像机；
私人静态摄像机。参数参数分光计；
公共同步静态摄影机getCameraInstance（）{
if（sCamera==null）{
试一试{
sCamera=Camera.open（）；//尝试获取一个Camera实例
}
捕获（例外e）{}
}
if（sCamera！=null）{
sParameters=sCamera.getParameters（）；
getFormats（）；
}
return sCamera；//如果摄像机不可用，则返回null
}
公共静态void getFormats（）{
List picsize=sParameters.getSupportedPictureSizes（）；
大小s=picsize.get（1）；
sParameters.setPictureSize（s.宽度，s.高度）；
picSizes=sParameters.getSupportedPreviewSizes（）；
Size previewSize=picSizes.get（picSizes.Size（）-1）；
sParameters.setPreviewSize（previewSize.width，previewSize.width）；
sParameters.setPreviewFormat（ImageFormat.JPEG）；
}
公共同步静态无效释放摄影机（）{
if（sCamera！=null）{
sCamera.stopPreview（）；
sCamera.release（）；//为其他应用程序释放相机
sCamera=null；
}
}
}

服务：

public class CameraServiceTexture extends Service {
    private final static String TAG = "CameraServiceTexture";
    private Camera mCamera;

    @Override public IBinder onBind(Intent arg0) {
        return null;
    }

    @Override public int onStartCommand(Intent intent, int flags, int startId) {
        new PictureThread().start();
        return START_STICKY;
    }

    private class PictureThread extends Thread {
        SurfaceTexture texture;
        private byte[] callbackBuffer;
        public void run() {
            mCamera = CameraHelper.getCameraInstance();

            int textures[] = new int[1];
            GLES20.glGenTextures(1, textures, 0);
            GLES20.glBindTexture(GLES20.GL_TEXTURE_2D, textures[0]);
            int width  = 4; // size of preview
            int height = 4;  // size of preview
            GLES20.glTexImage2D(GLES20.GL_TEXTURE_2D, 0, GLES20.GL_RGBA, width,
                    height, 0, GLES20.GL_RGBA, GLES20.GL_UNSIGNED_BYTE, null);
            GLES20.glTexParameteri(GLES20.GL_TEXTURE_2D, GLES20.GL_TEXTURE_WRAP_S, GLES20.GL_CLAMP_TO_EDGE);
            GLES20.glTexParameteri(GLES20.GL_TEXTURE_2D, GLES20.GL_TEXTURE_WRAP_T, GLES20.GL_CLAMP_TO_EDGE);
            GLES20.glTexParameteri(GLES20.GL_TEXTURE_2D, GLES20.GL_TEXTURE_MAG_FILTER, GLES20.GL_LINEAR);
            GLES20.glTexParameteri(GLES20.GL_TEXTURE_2D, GLES20.GL_TEXTURE_MIN_FILTER, GLES20.GL_LINEAR);

            texture = new SurfaceTexture(textures[0]);
            texture.setDefaultBufferSize(4, 4);

            try {
                mCamera.setPreviewTexture(texture);
            } catch (IOException e1) {
                e1.printStackTrace();
            }

            Size previewSize=mCamera.getParameters().getPreviewSize();
            int dataBufferSize=(int)(previewSize.height*previewSize.width*
                                   (ImageFormat.getBitsPerPixel(mCamera.getParameters().getPreviewFormat())/8.0));
            callbackBuffer = new byte[dataBufferSize];

            mCamera.addCallbackBuffer(callbackBuffer);
            //mCamera.setPreviewCallback(previewCallback);
            mCamera.setPreviewCallbackWithBuffer(previewCallback);

            mCamera.startPreview();


            time = System.currentTimeMillis();
        }

        private int mMaxCount = 100;
        private int mCount = 0;
        private long time;

        private final Camera.PictureCallback jpegCallBack = new Camera.PictureCallback() {
            @Override public void onPictureTaken(byte[] data, Camera camera) {
                long currentTime = System.currentTimeMillis();
                Log.i(TAG, "onPictureTaken " + data.length + " " + (currentTime - time));
                time = currentTime;
                texture.updateTexImage();
                mCamera.startPreview();
                ++mCount;
                if (mCount < mMaxCount) {
                    mCamera.takePicture(null, null, jpegCallBack);
                }
            }
        };

        private final Camera.PreviewCallback previewCallback = new Camera.PreviewCallback() {
            @Override public void onPreviewFrame(byte[] data, Camera camera) {
                long currentTime = System.currentTimeMillis();
                Log.i(TAG, "onPreviewFrame " + data.length + " " + (currentTime - time));
                time = currentTime;
                mCamera.addCallbackBuffer(callbackBuffer);
            }
        };

    }
}

公共类CameraServiceTexture扩展服务{
私有最终静态字符串TAG=“CameraServiceTexture”；
私人摄像机麦卡梅拉；
@重写公共IBinder onBind（意图arg0）{
返回null；
}
@覆盖公共int onStartCommand（Intent Intent、int标志、int startId）{
新建PictureThread（）.start（）；
返回开始时间；
}
私有类PictureThread扩展线程{
表面结构；
专用字节[]callbackBuffer；
公开募捐{
mCamera=CameraHelper.getCameraInstance（）；
int纹理[]=新int[1]；
GLES20.glGenTextures（1，纹理，0）；
GLES20.glBindTexture（GLES20.GL_TEXTURE_2D，纹理[0]）；
int width=4；//预览的大小
int height=4；//预览的大小
GLES20.glTexImage2D（GLES20.GL_纹理_2D，0，GLES20.GL_RGBA，宽度，
高度，0，GLES20.GL_RGBA，GLES20.GL_无符号字节，null）；
GLES20.glTexParameteri（GLES20.GL_纹理_2D、GLES20.GL_纹理_包裹、GLES20.GL_夹紧至边缘）；
GLES20.glTexParameteri（GLES20.GL_纹理2D、GLES20.GL_纹理包裹、GLES20.GL_夹紧至边缘）；
GLES20.glTexParameteri（GLES20.GL_纹理_2D，GLES20.GL_纹理_MAG_过滤器，GLES20.GL_线性）；
GLES20.glTexParameteri（GLES20.GL_纹理_2D，GLES20.GL_纹理_最小_过滤器，GLES20.GL_线性）；
纹理=新的表面纹理（纹理[0]）；
设置默认缓冲区大小（4,4）；
试一试{
mCamera.setPreviewTexture（纹理）；
}捕获（IOE1异常）{
e1.printStackTrace（）；
}
大小previewSize=mCamera.getParameters（）.getPreviewSize（）；
int-dataBufferSize=（int）（previewSize.height*previewSize.width*
（ImageFormat.getBitsPerPixel（mCamera.getParameters（）.getPreviewFormat（））/8.0）；
callbackBuffer=新字节[dataBufferSize]；
添加callbackBuffer（callbackBuffer）；
//mCamera.setPreviewCallback（previewCallback）；
mCamera.setPreviewCallbackWithBuffer（previewCallback）；
mCamera.startPreview（）；
时间=System.currentTimeMillis（）；
}
私有整数mMaxCount=100；
私有整数mCount=0；
私人时间长；
private final Camera.PictureCallback jpegCallBack=新建Camera.PictureCallback（）{
@覆盖公共void onPictureTaken（字节[]数据，摄像头）{
长currentTime=System.currentTimeMillis（）；
Log.i（标记“onPictureTaken”+data.length++（currentTime-time））；
时间=当前时间；
texture.updateMaximage（）；
mCamera.startPreview（）；
++mCount；
如果（mCount

您可以使用OpenGL纹理显示服务中的相机预览

摄影机辅助对象：

public class CameraHelper {
    private final static String TAG = "CameraHelper";

    private static Camera sCamera;
    private static Camera.Parameters sParameters;
    public synchronized static Camera getCameraInstance(){
        if (sCamera == null) {
            try {
                sCamera = Camera.open(); // attempt to get a Camera instance
            }
            catch (Exception e) {}
        }

        if (sCamera != null) {
            sParameters = sCamera.getParameters();
            getFormats();
        }
        return sCamera; // returns null if camera is unavailable
    }

    public static void getFormats() {
         List<Size> picSizes = sParameters.getSupportedPictureSizes();
         Size s = picSizes.get(1);
         sParameters.setPictureSize(s.width, s.height);
         picSizes = sParameters.getSupportedPreviewSizes();
         Size previewSize = picSizes.get(picSizes.size() - 1);
         sParameters.setPreviewSize(previewSize.width, previewSize.width);
         sParameters.setPreviewFormat(ImageFormat.JPEG);
    }

    public synchronized static void releaseCamera() {
        if (sCamera != null) {
            sCamera.stopPreview();
            sCamera.release();        // release the camera for other applications
            sCamera = null;
        }
    }
}

公共类摄像机帮助器{
私有最终静态字符串TAG=“CameraHelper”；
私人静态摄像机；
私人静态摄像机。参数参数分光计；
公共同步静态摄影机getCameraInstance（）{
if（sCamera==null）{
试一试{
sCamera=Camera.open（）；//尝试获取一个Camera实例
}
捕获（例外e）{}
}
if（sCamera！=null）{
sParameters=sCamera.getParameters（）；
getFormats（）；
}
return sCamera；//如果摄像机不可用，则返回null
}
公共静态void getFormats（）{
List picsize=sParameters.getSupportedPictureSizes（）；
s