如何在Android中设置图片库的缩略图视图

我使用最新的camera2 API开发了一个摄像头应用程序，我想在屏幕上设置画廊的缩略图，就像jellybean和ICS中的摄像头。有人能帮我吗？？怎么做

XML

爪哇

公共类SecondActivity扩展活动{
私有最终静态字符串TAG=“Camera2testJ”；
私人规模的mPreviewSize；
私有纹理视图mTextureView；
私人摄像设备；
私人CaptureRequest.Builder mPreviewBuilder；
私人摄像机拍摄会议回顾；
私人按钮；
专用静态最终SparseIntArray方向=新SparseIntArray（）；
静止的{
方向。附加（Surface.ROTATION_0,90）；
方向。附加（Surface.ROTATION_90,0）；
方向。附加（Surface.ROTATION_180，270）；
方向。附加（Surface.ROTATION_270，180）；
}
@凌驾
创建时受保护的void（Bundle savedInstanceState）{
super.onCreate（savedInstanceState）；
requestWindowFeature（窗口。功能\u无\u标题）；
getWindow（）.setFlags（WindowManager.LayoutParams.FLAG_全屏，WindowManager.LayoutParams.FLAG_全屏）；
setContentView（R.layout.activity_秒）；
mTextureView=（TextureView）findViewById（R.id.texture）；
mTextureView.setSurfaceTextureListener（mSurfaceTextureListener）；
mBtnShot=（按钮）findviewbyd（R.id.btn_takepicture）；
setOnClickListener（新的OnClickListener（）{
@凌驾
公共void onClick（视图v）{
Log.e（标记“mBtnShot clicked”）；
拍摄照片（）；
}
});
}
受保护的无效照片（）{
Log.e（标签“takePicture”）；
if（null==mCameraDevice）{
Log.e（标记“mCameraDevice为null，返回”）；
返回；
}
CameraManager=（CameraManager）getSystemService（Context.CAMERA_服务）；
试一试{
CameraCharacteristics characteristics=manager.getCameraCharacteristics（mCameraDevice.getId（））；
Size[]jpegsize=null；
如果（特征！=null）{
JPEG大小=特征
.get（摄影机特性.SCALER\u流\u配置\u映射）
.getOutputSizes（ImageFormat.JPEG）；
}
整数宽度=640；
内部高度=480；
if（jpegSizes！=null&&0<TextureView
android:id="@+id/texture"
android:layout_width="match_parent"
android:layout_height="match_parent"
android:layout_alignParentStart="true"
android:layout_alignParentTop="true" />

<Button
android:id="@+id/btn_takepicture"
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:layout_gravity="center"
android:text="picture" />
</RelativeLayout>

public class SecondActivity extends Activity {

private final static String TAG = "Camera2testJ";
private Size mPreviewSize;

private TextureView mTextureView;
private CameraDevice mCameraDevice;
private CaptureRequest.Builder mPreviewBuilder;
private CameraCaptureSession mPreviewSession;

private Button mBtnShot;



private static final SparseIntArray ORIENTATIONS = new SparseIntArray();

static {
    ORIENTATIONS.append(Surface.ROTATION_0, 90);
    ORIENTATIONS.append(Surface.ROTATION_90, 0);
    ORIENTATIONS.append(Surface.ROTATION_180, 270);
    ORIENTATIONS.append(Surface.ROTATION_270, 180);
}

@Override
protected void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    requestWindowFeature(Window.FEATURE_NO_TITLE);
    getWindow().setFlags(WindowManager.LayoutParams.FLAG_FULLSCREEN, WindowManager.LayoutParams.FLAG_FULLSCREEN);
    setContentView(R.layout.activity_second);

    mTextureView = (TextureView)findViewById(R.id.texture);
    mTextureView.setSurfaceTextureListener(mSurfaceTextureListener);

    mBtnShot = (Button)findViewById(R.id.btn_takepicture);
    mBtnShot.setOnClickListener(new OnClickListener() {

        @Override
        public void onClick(View v) {
            Log.e(TAG, "mBtnShot clicked");
            takePicture();
        }

    });

}

protected void takePicture() {
    Log.e(TAG, "takePicture");
    if(null == mCameraDevice) {
        Log.e(TAG, "mCameraDevice is null, return");
        return;
    }

    CameraManager manager = (CameraManager) getSystemService(Context.CAMERA_SERVICE);
    try {
        CameraCharacteristics characteristics = manager.getCameraCharacteristics(mCameraDevice.getId());

        Size[] jpegSizes = null;
        if (characteristics != null) {
            jpegSizes = characteristics
                    .get(CameraCharacteristics.SCALER_STREAM_CONFIGURATION_MAP)
                    .getOutputSizes(ImageFormat.JPEG);
        }
        int width = 640;
        int height = 480;
        if (jpegSizes != null && 0 < jpegSizes.length) {
            width = jpegSizes[0].getWidth();
            height = jpegSizes[0].getHeight();
        }

        ImageReader reader = ImageReader.newInstance(width, height, ImageFormat.JPEG, 1);
        List<Surface> outputSurfaces = new ArrayList<Surface>(2);
        outputSurfaces.add(reader.getSurface());
        outputSurfaces.add(new Surface(mTextureView.getSurfaceTexture()));

        final CaptureRequest.Builder captureBuilder = mCameraDevice.createCaptureRequest(CameraDevice.TEMPLATE_STILL_CAPTURE);
        captureBuilder.addTarget(reader.getSurface());
        captureBuilder.set(CaptureRequest.CONTROL_MODE, CameraMetadata.CONTROL_MODE_AUTO);

        // Orientation
        int rotation = getWindowManager().getDefaultDisplay().getRotation();
        captureBuilder.set(CaptureRequest.JPEG_ORIENTATION, ORIENTATIONS.get(rotation));

        final File file = new File(Environment.getExternalStorageDirectory()+"/DCIM", "pic.jpg");

        ImageReader.OnImageAvailableListener readerListener = new ImageReader.OnImageAvailableListener() {

            @Override
            public void onImageAvailable(ImageReader reader) {

                Image image = null;
                try {
                    image = reader.acquireLatestImage();
                    ByteBuffer buffer = image.getPlanes()[0].getBuffer();
                    byte[] bytes = new byte[buffer.capacity()];
                    buffer.get(bytes);
                    save(bytes);
                } catch (FileNotFoundException e) {
                    e.printStackTrace();
                } catch (IOException e) {
                    e.printStackTrace();
                } finally {
                    if (image != null) {
                        image.close();
                    }
                }
            }

            private void save(byte[] bytes) throws IOException {
                OutputStream output = null;
                try {
                    output = new FileOutputStream(file);
                    output.write(bytes);
                } finally {
                    if (null != output) {
                        output.close();
                    }
                }
            }

        };

        HandlerThread thread = new HandlerThread("CameraPicture");
        thread.start();
        final Handler backgroudHandler = new Handler(thread.getLooper());
        reader.setOnImageAvailableListener(readerListener, backgroudHandler);

        final CameraCaptureSession.CaptureCallback captureListener = new CameraCaptureSession.CaptureCallback() {

            @Override
            public void onCaptureCompleted(CameraCaptureSession session,
                                           CaptureRequest request, TotalCaptureResult result) {

                super.onCaptureCompleted(session, request, result);
                Toast.makeText(SecondActivity.this, "Saved:"+file, Toast.LENGTH_SHORT).show();
                startPreview();
            }

        };

        mCameraDevice.createCaptureSession(outputSurfaces, new CameraCaptureSession.StateCallback() {

            @Override
            public void onConfigured(CameraCaptureSession session) {

                try {
                    session.capture(captureBuilder.build(), captureListener, backgroudHandler);
                } catch (CameraAccessException e) {

                    e.printStackTrace();
                }
            }

            @Override
            public void onConfigureFailed(CameraCaptureSession session) {

            }
        }, backgroudHandler);

    } catch (CameraAccessException e) {
        e.printStackTrace();
    }

}

@Override
protected void onResume() {
    super.onResume();
    Log.e(TAG, "onResume");
}

private void openCamera() {

    CameraManager manager = (CameraManager) getSystemService(Context.CAMERA_SERVICE);
    Log.e(TAG, "openCamera E");
    try {
        String cameraId = manager.getCameraIdList()[0];
        CameraCharacteristics characteristics = manager.getCameraCharacteristics(cameraId);
        StreamConfigurationMap map = characteristics.get(CameraCharacteristics.SCALER_STREAM_CONFIGURATION_MAP);
        mPreviewSize = map.getOutputSizes(SurfaceTexture.class)[0];

        manager.openCamera(cameraId, mStateCallback, null);
    } catch (CameraAccessException e) {
        e.printStackTrace();
    }
    Log.e(TAG, "openCamera X");
}

private TextureView.SurfaceTextureListener mSurfaceTextureListener = new TextureView.SurfaceTextureListener(){

    @Override
    public void onSurfaceTextureAvailable(SurfaceTexture surface, int width, int height) {
        Log.e(TAG, "onSurfaceTextureAvailable, width="+width+",height="+height);
        openCamera();
    }

    @Override
    public void onSurfaceTextureSizeChanged(SurfaceTexture surface,
                                            int width, int height) {
        Log.e(TAG, "onSurfaceTextureSizeChanged");
    }

    @Override
    public boolean onSurfaceTextureDestroyed(SurfaceTexture surface) {
        return false;
    }

    @Override
    public void onSurfaceTextureUpdated(SurfaceTexture surface) {
        //Log.e(TAG, "onSurfaceTextureUpdated");
    }

};

private CameraDevice.StateCallback mStateCallback = new CameraDevice.StateCallback() {

    @Override
    public void onOpened(CameraDevice camera) {

        Log.e(TAG, "onOpened");
        mCameraDevice = camera;
        startPreview();
    }

    @Override
    public void onDisconnected(CameraDevice camera) {

        Log.e(TAG, "onDisconnected");
    }

    @Override
    public void onError(CameraDevice camera, int error) {

        Log.e(TAG, "onError");
    }

};

@Override
protected void onPause() {

    Log.e(TAG, "onPause");
    super.onPause();
    if (null != mCameraDevice) {
        mCameraDevice.close();
        mCameraDevice = null;
    }
}

protected void startPreview() {

    if(null == mCameraDevice || !mTextureView.isAvailable() || null == mPreviewSize) {
        Log.e(TAG, "startPreview fail, return");
        return;
    }

    SurfaceTexture texture = mTextureView.getSurfaceTexture();
    if(null == texture) {
        Log.e(TAG,"texture is null, return");
        return;
    }

    texture.setDefaultBufferSize(mPreviewSize.getWidth(), mPreviewSize.getHeight());
    Surface surface = new Surface(texture);

    try {
        mPreviewBuilder = mCameraDevice.createCaptureRequest(CameraDevice.TEMPLATE_PREVIEW);
    } catch (CameraAccessException e) {

        e.printStackTrace();
    }
    mPreviewBuilder.addTarget(surface);

    try {
        mCameraDevice.createCaptureSession(Arrays.asList(surface), new CameraCaptureSession.StateCallback() {

            @Override
            public void onConfigured(CameraCaptureSession session) {

                mPreviewSession = session;
                updatePreview();
            }

            @Override
            public void onConfigureFailed(CameraCaptureSession session) {

                Toast.makeText(SecondActivity.this, "onConfigureFailed", Toast.LENGTH_LONG).show();
            }
        }, null);
    } catch (CameraAccessException e) {

        e.printStackTrace();
    }
}

protected void updatePreview() {

    if(null == mCameraDevice) {
        Log.e(TAG, "updatePreview error, return");
    }

    mPreviewBuilder.set(CaptureRequest.CONTROL_MODE, CameraMetadata.CONTROL_MODE_AUTO);
    HandlerThread thread = new HandlerThread("CameraPreview");
    thread.start();
    Handler backgroundHandler = new Handler(thread.getLooper());

    try {
        mPreviewSession.setRepeatingRequest(mPreviewBuilder.build(), null, backgroundHandler);
    } catch (CameraAccessException e) {

        e.printStackTrace();
    }
}
}