背景中的Android摄像头

我正在尝试创建一个android应用程序，一旦服务启动，它就可以在后台捕获图像。我能够捕获它并保存在SD卡上，但捕获的图像有点暗，我无法跟踪问题。 有什么可能

拍摄图像：

公共类MyService扩展服务{
麦克默拉照相机；
公共字符串imageEncodeString，imageName；
公共位图；
公共文件；
Camera.PictureCallback mPictureCallback=新建Camera.PictureCallback（）{
@凌驾
公共void onPictureTaken（字节[]数据，摄像头）{
如果（数据！=null）{
位图=位图工厂.decodeByteArray（数据，0，数据.length）；
if（位图！=null）{
imageName=String.valueOf（System.currentTimeMillis（）+“.jpg”）；
File basedir=新文件（Environment.getExternalStorageDirectory（）+“/dirr”）；
file=新文件（Environment.getExternalStorageDirectory（）+“/dirr”+file.separator+imageName）；
如果（！basedir.isDirectory（））{
basedir.mkdirs（）；
}
试一试{
createNewFile（）；
FileOutputStream otstream=新的FileOutputStream（文件）；
压缩（bitmap.CompressFormat.JPEG，100，otstream）；
字节[]img=新字节[0]；
otstream.write（img）；
otstream.flush（）；
otstream.close（）；
}catch（filenotfounde异常）{
e、 printStackTrace（）；
}捕获（IOE异常）{
e、 printStackTrace（）；
}
}
mCamera.startPreview（）；
}
}
};
公共MyService（）{
}
公共IBinder onBind（意向）{
//TODO:将通信通道返回到服务。
抛出新的UnsupportedOperationException（“尚未实现”）；
}
@凌驾
公共int onStartCommand（Intent Intent、int标志、int startId）{
Toast.makeText（MyService.this，“启动服务…”，Toast.LENGTH_SHORT.show（）；
Log.d（“标记”，“onStartCommand中的服务”）；
如果（检查摄像头硬件（此））{
mCamera=getCameraInstance（）；
if（mCamera！=null）{
SurfaceView sv=新的SurfaceView（本）；
WindowManager wm=（WindowManager）getSystemService（Context.WINDOW\u服务）；
WindowManager.LayoutParams params=新的WindowManager.LayoutParams（1，1，
WindowManager.LayoutParams.TYPE_SYSTEM_OVERLAY，
WindowManager.LayoutParams.FLAG\u WATCH\u Out\u TOUCH，
像素格式（透明）；
参数α=0；
SurfaceHolder sh=sv.getHolder（）；
sv.setZOrderOnTop（真）；
sh.setFormat（PixelFormat.TRANSPARENT）；
sh.addCallback（新的SurfaceHolder.Callback（）{
@凌驾
已创建的公共空白表面（表面持有人）{
Camera.Parameters=mCamera.getParameters（）；
parameters.setFocusMode（相机.参数.聚焦模式\u连续图像）；
parameters.setSceneMode（摄影机.parameters.SCENE\u模式\u自动）；
parameters.setWhiteBalance（摄像头.parameters.WHITE\u BALANCE\u AUTO）；
mCamera.setParameters（参数）；
Camera.Parameters p=mCamera.getParameters（）；
列表大小；
listSize=p.getSupportedPreviewSizes（）；
Camera.Size mPreviewSize=listSize.get（2）；
Log.v（“标记”、“预览宽度=“+mPreviewSize.width
+“预览高度=“+mPreviewSize.height”）；
p、 setPreviewSize（mPreviewSize.width、mPreviewSize.height）；
listSize=p.getSupportedPictureSizes（）；
Camera.Size=listSize.get（2）；
Log.v（“标记”、“捕获宽度=“+mPictureSize.width
+“捕获高度=”+mPictureSize.height）；
p、 setPictureSize（mPictureSize.width，mPictureSize.height）；
mCamera.setParameters（p）；
试一试{
mCamera.setPreviewDisplay（支架）；
}捕获（IOE异常）{
e、 printStackTrace（）；
}
//mCamera.startPreview（）；
//takePicture（null，null，mPictureCallback）；//用于拍摄。
//Log.d（“标记”，“捕获已开始”）；
//mCamera.stopPreview（）；
//mCamera.release（）；
//Log.d（“标记”，“捕获完成”）；
}
@凌驾
公共空白表面更改（表面文件夹持有者、整型格式、整型宽度、整型高度）{
}
@凌驾
公共空间表面覆盖（表面覆盖物持有人）{
mCamera.stopPreview（）；
mCamera.release（）；
}
});
wm.addView（sv，params）；
}否则{
Log.d（“标记”，“从服务获取摄像头失败”）；
}
}否则{
Log.d（“标签”，“设备上没有摄像头硬件”）；
}
new Handler（）.postDelayed（new Runnable（））{
@凌驾
公开募捐{
Log.d（“标记”，“捕获已开始”）；
mCamera.startPreview（）；
takePicture（null，null，mPictureCallback）；
可控震源=（可控震源）getSystemService（Context.可控震源\u服务）；
振动器。振动（1000）；
Log.d（“标记”，“捕获完成”）；
}
}, 5000);
返回super.onStartCommand（intent、flags、startId）；
}
@凌驾
public void onCreate（）{
public class MyService extends Service {

Camera mCamera;
public String imageEncodeString,imageName;
public Bitmap bitmap;
public File file;

Camera.PictureCallback mPictureCallback = new Camera.PictureCallback() {

    @Override
    public void onPictureTaken(byte[] data, Camera camera) {
        if (data != null) {
            bitmap = BitmapFactory.decodeByteArray(data, 0, data.length);

            if (bitmap != null) {
                imageName = String.valueOf(System.currentTimeMillis() + ".jpg");
                File basedir =  new File(Environment.getExternalStorageDirectory() + "/dirr");
                file = new File(Environment.getExternalStorageDirectory() + "/dirr" + File.separator + imageName);
                if (!basedir.isDirectory()) {
                    basedir.mkdirs();
                }
                try {
                    file.createNewFile();
                    FileOutputStream otstream = new FileOutputStream(file);
                    bitmap.compress(Bitmap.CompressFormat.JPEG,100,otstream);
                    byte[] img =new byte[0];
                    otstream.write(img);
                    otstream.flush();
                    otstream.close();
                } catch (FileNotFoundException e) {
                    e.printStackTrace();
                } catch (IOException e) {
                    e.printStackTrace();
                }

            }
            mCamera.startPreview();
        }

    }

};

public MyService() {

}

public IBinder onBind(Intent intent) {
    // TODO: Return the communication channel to the service.
    throw new UnsupportedOperationException("Not yet implemented");
}

@Override
public int onStartCommand(Intent intent, int flags, int startId) {
    Toast.makeText(MyService.this, "Starting Service...", Toast.LENGTH_SHORT).show();
    Log.d("TAG", "======= service in onStartCommand");

    if (checkCameraHardware(this)) {
        mCamera = getCameraInstance();
        if (mCamera != null) {
            SurfaceView sv = new SurfaceView(this);

           WindowManager wm = (WindowManager) getSystemService(Context.WINDOW_SERVICE);
            WindowManager.LayoutParams params = new WindowManager.LayoutParams(1, 1,
                    WindowManager.LayoutParams.TYPE_SYSTEM_OVERLAY,
                    WindowManager.LayoutParams.FLAG_WATCH_OUTSIDE_TOUCH,
                    PixelFormat.TRANSPARENT);
                    params.alpha = 0;

            SurfaceHolder sh = sv.getHolder();
            sv.setZOrderOnTop(true);
            sh.setFormat(PixelFormat.TRANSPARENT);

            sh.addCallback(new SurfaceHolder.Callback() {
                @Override
                public void surfaceCreated(SurfaceHolder holder) {
                    Camera.Parameters parameters = mCamera.getParameters();
                    parameters.setFocusMode(Camera.Parameters.FOCUS_MODE_CONTINUOUS_PICTURE);
                    parameters.setSceneMode(Camera.Parameters.SCENE_MODE_AUTO);
                    parameters.setWhiteBalance(Camera.Parameters.WHITE_BALANCE_AUTO);
                    mCamera.setParameters(parameters);

                    Camera.Parameters p = mCamera.getParameters();

                    List<Camera.Size> listSize;

                    listSize = p.getSupportedPreviewSizes();
                    Camera.Size mPreviewSize = listSize.get(2);
                    Log.v("TAG", "preview width = " + mPreviewSize.width
                            + " preview height = " + mPreviewSize.height);
                    p.setPreviewSize(mPreviewSize.width, mPreviewSize.height);

                    listSize = p.getSupportedPictureSizes();
                    Camera.Size mPictureSize = listSize.get(2);
                    Log.v("TAG", "capture width = " + mPictureSize.width
                            + " capture height = " + mPictureSize.height);
                    p.setPictureSize(mPictureSize.width, mPictureSize.height);
                    mCamera.setParameters(p);

                    try {
                        mCamera.setPreviewDisplay(holder);
                    } catch (IOException e) {
                        e.printStackTrace();
                    }
                    // mCamera.startPreview();
                    //  mCamera.takePicture(null, null, mPictureCallback); // used to takePicture.

                    // Log.d("TAG", "========= Capturing Started");

                    //  mCamera.stopPreview();
                    //  mCamera.release();
                    //  Log.d("TAG", "========== Capturing finished.");

                }

                @Override
                public void surfaceChanged(SurfaceHolder holder, int format, int width, int height) {

                }

                @Override
                public void surfaceDestroyed(SurfaceHolder holder) {
                    mCamera.stopPreview();
                    mCamera.release();
                }

            });
            wm.addView(sv, params);
        } else {
            Log.d("TAG", "==== get Camera from service failed");
        }
}else {
        Log.d("TAG", "==== There is no camera hardware on device.");
    }

    new Handler().postDelayed(new Runnable() {
        @Override
        public void run() {
            Log.d("TAG", "========= Capturing Started");
            mCamera.startPreview();
            mCamera.takePicture(null, null, mPictureCallback);
            Vibrator vibrator = (Vibrator)getSystemService(Context.VIBRATOR_SERVICE);
            vibrator.vibrate(1000);

            Log.d("TAG", "========== Capturing finished.");
        }
    }, 5000);

    return super.onStartCommand(intent, flags, startId);
}

@Override
public void onCreate() {

    super.onCreate();
}

@Override
public void onDestroy() {
    Toast.makeText(MyService.this, "Service Stopped...", Toast.LENGTH_SHORT).show();
}

public static boolean checkCameraHardware(Context context) {
    if (context.getPackageManager().hasSystemFeature(PackageManager.FEATURE_CAMERA)) {
        return true;
    } else {
        return false;
    }
}

public static Camera getCameraInstance() {
    Camera c = null;
    try {
        c = Camera.open();
    } catch (Exception e) {
        Log.d("TAG", "Open camera failed: " + e);
    }

    return c;
}

}