如何设置由相机拍摄到的ImageView图像。？ [英] How to set an image taken by the camera in to an imageview.?
本文介绍了如何设置由相机拍摄到的ImageView图像。？的处理方法，对大家解决问题具有一定的参考价值，需要的朋友们下面随着小编来一起学习吧！
问题描述
我使用的相机2 API创建我自己的相机，我想设置的相机带到一个ImageView的，这是另一个activity.I已经试过这code图像，但它不工作。点击拍照按钮的照片保存到SD卡的位置的时候，但它没有显示在第三活动图像视图（应收到的形象和设置为一个ImageView的）。我是通过一个传递图像作为位图对象intent.Can谁能帮助我？
摄像头活动
公共类SecondActivity延伸活动{
的ImageButton ImageButton的;
私有静态诠释RESULT_LOAD_IMAGE = 1;
私人最终静态字符串变量=Camera2testJ;
私人尺寸M previewSize;
私有静态最终诠释CAMERA_REQUEST = 1888;
私人TextureView mTextureView;
私人CameraDevice mCameraDevice;
私人CaptureRequest.Builder米previewBuilder;
私人CameraCaptureSession米previewSession;私人按钮cancelbtn;
私人的ImageButton mBtnShot;
公共字符串picturePath;
公共位图图片;
INT标志= 1;
私有静态最终SparseIntArray =战略方向新SparseIntArray（）;静态的 {
ORIENTATIONS.append（Surface.ROTATION_0，90）;
ORIENTATIONS.append（Surface.ROTATION_90，0）;
ORIENTATIONS.append（Surface.ROTATION_180，270）;
ORIENTATIONS.append（Surface.ROTATION_270，180）;
}@覆盖
保护无效的onCreate（捆绑savedInstanceState）{
super.onCreate（savedInstanceState）;
requestWindowFeature（Window.FEATURE_NO_TITLE）;
getWindow（）setFlags（WindowManager.LayoutParams.FLAG_FULLSCREEN，WindowManager.LayoutParams.FLAG_FULLSCREEN）。
的setContentView（R.layout.activity_second）;
loadPic（）;
mTextureView =（TextureView）findViewById（R.id.texture）;
mTextureView.setSurfaceTextureListener（mSurfaceTextureListener）; mBtnShot =（的ImageButton）findViewById（R.id.btn_takepicture）;
mBtnShot.setOnClickListener（新OnClickListener（）{ @覆盖
公共无效的onClick（视图v）{
Log.e（TAGmBtnShot点击）;
拍照片（）;
// sendImage（标志= 0）;
} }）; 的ImageButton =（的ImageButton）findViewById（R.id.buttonLoadPicture2）;
imagebutton.setOnClickListener（新OnClickListener（）{ @覆盖
公共无效的onClick（视图v）{
意图I =新意图（
Intent.ACTION_PICK，
android.provider.MediaStore.Images.Media.EXTERNAL_CONTENT_URI）; startActivityForResult（ⅰ，RESULT_LOAD_IMAGE）; } }）; cancelbtn =（按钮）findViewById（R.id.buttonLoadPicture3）;
cancelbtn.setOnClickListener（新OnClickListener（）{ @覆盖
公共无效的onClick（视图v）{
完（）; } }）;}保护无效takePicture（）{
Log.e（TAGtakePicture）;
如果（空== mCameraDevice）{
Log.e（TAGmCameraDevice为空，则返回）;
返回;
} CameraManager经理=（CameraManager）getSystemService（Context.CAMERA_SERVICE）;
尝试{
CameraCharacteristics特征= manager.getCameraCharacteristics（mCameraDevice.getId（））; 尺寸[] jpegSizes = NULL;
如果（特色！= NULL）{
jpegSizes =特性
获得（CameraCharacteristics.SCALER_STREAM_CONFIGURATION_MAP）
.getOutputSizes（ImageFormat.JPEG）;
}
INT宽度= 640;
INT高= 480;
如果（jpegSizes = NULL＆放大器;！＆安培; 0℃; jpegSizes.length）{
宽度= jpegSizes [0] .getWidth（）;
高度= jpegSizes [0] .getHeight（）;
} 的ImageReader读者= ImageReader.newInstance（宽度，高度，ImageFormat.JPEG，1）;
清单＆lt;表面＆GT; outputSurfaces =新的ArrayList＆lt;表面＆GT;（2）;
outputSurfaces.add（reader.getSurface（））;
outputSurfaces.add（新的表面（mTextureView.getSurfaceTexture（）））; 最后CaptureRequest.Builder captureBuilder = mCameraDevice.createCaptureRequest（CameraDevice.TEMPLATE_STILL_CAPTURE）;
captureBuilder.addTarget（reader.getSurface（））;
captureBuilder.set（CaptureRequest.CONTROL_MODE，CameraMetadata.CONTROL_MODE_AUTO）; //方向
INT旋转= getWindowManager（）getDefaultDisplay（）getRotation（）。
captureBuilder.set（CaptureRequest.JPEG_ORIENTATION，ORIENTATIONS.get（旋转））; 最终文件的文件=新的文件（Environment.getExternalStorageDirectory（）+/ DCIM，pic.jpg）; ImageReader.OnImageAvailableListener readerListener =新ImageReader.OnImageAvailableListener（）{ @覆盖
公共无效onImageAvailable（ImageReader的读者）{ 形象画像= NULL;
尝试{
图像= reader.acquireLatestImage（）;
ByteBuffer的缓冲液= image.getPlanes（）[0] .getBuffer（）;
字节[]字节=新字节[buffer.capacity（）];
buffer.get（字节）;
保存（字节）;
}赶上（FileNotFoundException异常五）{
e.printStackTrace（）;
}赶上（IOException异常五）{
e.printStackTrace（）;
} {最后
如果（形象！= NULL）{
image.close（）;
}
}
} 私人无效保存（字节[]字节）抛出IOException
OutputStream的输出= NULL;
尝试{
输出=新的FileOutputStream（文件）;
output.write（字节）;
} {最后
如果（NULL！=输出）{
output.close（）;
}
}
} }; HandlerThread线程=新HandlerThread（CameraPicture）;
thread.start（）;
最后的处理程序backgroudHandler =新的处理程序（thread.getLooper（））;
reader.setOnImageAvailableListener（readerListener，backgroudHandler）; 最后CameraCaptureSession.CaptureCallback captureListener =新CameraCaptureSession.CaptureCallback（）{ @覆盖
公共无效onCaptureCompleted（CameraCaptureSession会议上，
CaptureRequest要求，TotalCaptureResult结果）{ super.onCaptureCompleted（会话，请求，结果）;
Toast.makeText（SecondActivity.this，保存+文件，Toast.LENGTH_SHORT）.show（）; ////////////发送图像 / *标志=标志-1;
sendImage（标志）; * /
//启动preVIEW（）;
/////发送图像 } }; mCameraDevice.createCaptureSession（outputSurfaces，新CameraCaptureSession.StateCallback（）{ @覆盖
公共无效onConfigured（CameraCaptureSession会话）{ 尝试{
session.capture（captureBuilder.build（），captureListener，backgroudHandler）;
}赶上（CameraAccessException E）{ e.printStackTrace（）;
} }
@覆盖
公共无效onConfigureFailed（CameraCaptureSession会话）{ }
}，backgroudHandler）; }赶上（CameraAccessException E）{
e.printStackTrace（）;
}}@覆盖
保护无效onResume（）{
super.onResume（）;
Log.e（TAGonResume）;
}私人无效openCamera（）{ CameraManager经理=（CameraManager）getSystemService（Context.CAMERA_SERVICE）;
Log.e（TAGopenCamera E）;
尝试{
串cameraId = manager.getCameraIdList（）[0];
CameraCharacteristics特性= manager.getCameraCharacteristics（cameraId）;
StreamConfigurationMap地图= characteristics.get（CameraCharacteristics.SCALER_STREAM_CONFIGURATION_MAP）;
米previewSize = map.getOutputSizes（SurfaceTexture.class）[0]; manager.openCamera（cameraId，mStateCallback，NULL）;
}赶上（CameraAccessException E）{
e.printStackTrace（）;
}
Log.e（TAGopenCamera X）;
}私人TextureView.SurfaceTextureListener mSurfaceTextureListener =新TextureView.SurfaceTextureListener（）{ @覆盖
公共无效onSurfaceTextureAvailable（表面表面纹理，诠释的宽度，高度INT）{
Log.e（TAG，onSurfaceTextureAvailable，宽度=+宽+，高度=+高）;
开放式摄像头（）;
} @覆盖
公共无效onSurfaceTextureSizeChanged（表面表面纹理，
INT宽度，高度INT）{
Log.e（TAGonSurfaceTextureSizeChanged）;
} @覆盖
公共布尔onSurfaceTextureDestroyed（表面表面纹理）{
返回false;
} @覆盖
公共无效onSurfaceTextureUpdated（表面表面纹理）{
//Log.e(TAGonSurfaceTextureUpdated）;
}};私人CameraDevice.StateCallback mStateCallback =新CameraDevice.StateCallback（）{ @覆盖
公共无效onOpened（CameraDevice相机）{ Log.e（TAGonOpened）;
mCameraDevice =摄像头;
启动preVIEW（）;
} @覆盖
公共无效onDisconnected（CameraDevice相机）{ Log.e（TAGonDisconnected）;
} @覆盖
公共无效onerror的（CameraDevice摄像头，诠释错误）{ Log.e（TAG的onError）;
}};@覆盖
保护无效的onPause（）{ Log.e（TAG的onPause）;
super.onPause（）;
如果（NULL！= mCameraDevice）{
mCameraDevice.close（）;
mCameraDevice = NULL;
}
}保护无效启动preVIEW（）{ 如果（空== || mCameraDevice！mTextureView.isAvailable（）||空==米previewSize）{
Log.e（TAG，启动preVIEW失败，返回）;
返回;
} 质地表面纹理= mTextureView.getSurfaceTexture（）;
如果（空==纹理）{
Log.e（TAG，质地为空，则返回）;
返回;
} texture.setDefaultBufferSize（M previewSize.getWidth（），M previewSize.getHeight（））;
面面=新的表面（质感）; 尝试{
米previewBuilder = mCameraDevice.createCaptureRequest（CameraDevice.TEMPLATE_ preVIEW）;
}赶上（CameraAccessException E）{ e.printStackTrace（）;
}
米previewBuilder.addTarget（表面）; 尝试{
mCameraDevice.createCaptureSession（Arrays.asList（面），新CameraCaptureSession.StateCallback（）{ @覆盖
公共无效onConfigured（CameraCaptureSession会话）{ 米previewSession =会议;
更新preVIEW（）;
} @覆盖
公共无效onConfigureFailed（CameraCaptureSession会话）{ Toast.makeText（SecondActivity.thisonConfigureFailed，Toast.LENGTH_LONG）.show（）;
}
}， 空值）;
}赶上（CameraAccessException E）{ e.printStackTrace（）;
}}保护无效更新preVIEW（）{ 如果（空== mCameraDevice）{
Log.e（TAG，更新preVIEW错误，返回）;
} 米previewBuilder.set（CaptureRequest.CONTROL_MODE，CameraMetadata.CONTROL_MODE_AUTO）;
HandlerThread线程=新HandlerThread（摄像机preVIEW）;
thread.start（）;
处理器backgroundHandler =新的处理程序（thread.getLooper（））; 尝试{
米previewSession.setRepeatingRequest（M previewBuilder.build（），空，backgroundHandler）;
}赶上（CameraAccessException E）{ e.printStackTrace（）; }}
方法的onActivityResult
@覆盖
保护无效的onActivityResult（INT申请code，INT结果code，意图数据）{
super.onActivityResult（要求code，结果code，数据）; 如果（要求code == RESULT_LOAD_IMAGE＆放大器;＆安培;结果code == RESULT_OK＆放大器;＆安培;！NULL =数据）{
乌里selectedImage = data.getData（）;
的String [] = filePathColumn {MediaStore.Images.Media.DATA}; 光标光标= getContentResolver（）查询（selectedImage，
filePathColumn，NULL，NULL，NULL）;
cursor.moveToFirst（）; INT参数：columnIndex = cursor.getColumnIndex（filePathColumn [0]）;
picturePath = cursor.getString（参数：columnIndex）;
cursor.close（）;
标志=标志+ 1;
/ * ImageView的ImageView的=（ImageView的）findViewById（R.id.imgView2）;
imageView.setImageBitmap（BitmapFactory.de codeFILE（picturePath））; * /
sendImage（标志）; }
如果（要求code == CAMERA_REQUEST＆放大器;＆安培;结果code == RESULT_OK）{
捆绑额外= data.getExtras（）;
照片=（位图）extras.get（数据）; 旗旗= 1;
sendImage（标志）;
/ *照片=（位图）data.getExtras（）获得（数据）; * /
// imageView.setImageBitmap（照片）;
}}
公共无效sendImage（INT标志）
{
// ID =标志;
如果（标志== 2）{
意图myIntent1 =新意图（SecondActivity.this，ThirdActivity.class）;
myIntent1.putExtra（钥匙，picturePath）;
// myIntent1.putExtra（KEY2
SecondActivity.this.startActivity（myIntent1）;
}
如果（标志== 0）
{
意图myIntent1 =新意图（SecondActivity.this，ThirdActivity.class）;
myIntent1.putExtra（钥匙，照片）;
// myIntent1.putExtra（KEY2
SecondActivity.this.startActivity（myIntent1）;
}
}
无效loadPic（）
{
字符串BASEDIR = Environment.getExternalStorageDirectory（）getAbsolutePath（）。
字符串将pathName = BASEDIR +/ DCIM /摄像机/;
文件parentDir =新的文件（将pathName）; 文件[] =文件parentDir.listFiles（）;
日期lastDate = NULL;
串lastFileName;
布尔isFirstFile = TRUE; //为是肯定只是临时变量，我们是第一个文件
对于（文件文件：文件）{
如果（isFirstFile）{
lastDate =新的日期（file.lastModified（））;
isFirstFile = FALSE;
}
如果（file.getName（）的endsWith（JPG）|| file.getName（）的endsWith（JPEG））{
日期LASTMODDATE =新的日期（file.lastModified（））;
如果（lastModDate.after（lastDate））{
lastDate = LASTMODDATE;
lastFileName = file.getName（）; //字符串baseDir2 = Environment.getExternalStorageDirectory（）getAbsolutePath（）。
//字符串文件名= lastFileName;
字符串pathName2 =将pathName + lastFileName; //也许你的文件夹/ DCIM /摄像机/ BMP位图= BitmapFactory.de codeFILE（pathName2）;
的ImageButton按钮1 =（的ImageButton）findViewById（R.id.buttonLoadPicture2）;
button1.setImageBitmap（BMP）;
}
}
}
}}
解决方案
我认为你应该通过这样的位图：
意向意图=新意图（这一点，ThirdActivity.class）;
intent.putExtra（BitmapImage的，照片）;
，然后接受它为这样parcelable数据在你的第三个活动：
意向意图= getIntent（）;
位图位=（位图）intent.getParcelableExtra（BitmapImage的）;
，然后只设置位图到的ImageView
imageView.setImageBitmap（位图）;
希望这有助于，如果您有任何异常，你:)写
I am using camera 2 API for creating my own camera ,I want to set the image taken by the camera in to an imageView ,which is on another activity.I have tried this code but it is not working.when clicking the camera button the photo is saved to an sdcard location,but it is not showing on the image view in the third Activity(Which should recieve the image and set to an imageview).I am passing the image as bitmap object via an intent.Can anyone help me?
Camera Activity
public class SecondActivity extends Activity {
ImageButton imagebutton;
private static int RESULT_LOAD_IMAGE = 1;
private final static String TAG = "Camera2testJ";
private Size mPreviewSize;
private static final int CAMERA_REQUEST = 1888;
private TextureView mTextureView;
private CameraDevice mCameraDevice;
private CaptureRequest.Builder mPreviewBuilder;
private CameraCaptureSession mPreviewSession;
private Button cancelbtn;
private ImageButton mBtnShot;
public String picturePath;
public Bitmap photo;
int flag=1;
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);
loadPic();
mTextureView = (TextureView)findViewById(R.id.texture);
mTextureView.setSurfaceTextureListener(mSurfaceTextureListener);
mBtnShot = (ImageButton)findViewById(R.id.btn_takepicture);
mBtnShot.setOnClickListener(new OnClickListener() {
@Override
public void onClick(View v) {
Log.e(TAG, "mBtnShot clicked");
takePicture();
//sendImage(flag=0);
}
});
imagebutton=(ImageButton)findViewById(R.id.buttonLoadPicture2);
imagebutton.setOnClickListener(new OnClickListener() {
@Override
public void onClick(View v) {
Intent i = new Intent(
Intent.ACTION_PICK,
android.provider.MediaStore.Images.Media.EXTERNAL_CONTENT_URI);
startActivityForResult(i, RESULT_LOAD_IMAGE);
}
});
cancelbtn=(Button)findViewById(R.id.buttonLoadPicture3);
cancelbtn.setOnClickListener(new OnClickListener() {
@Override
public void onClick(View v) {
finish();
}
});
}
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();
////////////sending image
/* flag=flag-1;
sendImage(flag);*/
// startPreview();
/////sending image
}
};
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();
}
}
Method onActivityResult
@Override
protected void onActivityResult(int requestCode, int resultCode, Intent data) {
super.onActivityResult(requestCode, resultCode, data);
if (requestCode == RESULT_LOAD_IMAGE && resultCode == RESULT_OK && null != data) {
Uri selectedImage = data.getData();
String[] filePathColumn = { MediaStore.Images.Media.DATA };
Cursor cursor = getContentResolver().query(selectedImage,
filePathColumn, null, null, null);
cursor.moveToFirst();
int columnIndex = cursor.getColumnIndex(filePathColumn[0]);
picturePath = cursor.getString(columnIndex);
cursor.close();
flag=flag+1;
/* ImageView imageView = (ImageView) findViewById(R.id.imgView2);
imageView.setImageBitmap(BitmapFactory.decodeFile(picturePath));*/
sendImage(flag);
}
if (requestCode == CAMERA_REQUEST && resultCode == RESULT_OK) {
Bundle extras = data.getExtras();
photo = (Bitmap) extras.get("data");
flag=flag-1;
sendImage(flag);
/* photo = (Bitmap) data.getExtras().get("data");*/
// imageView.setImageBitmap(photo);
}
}
public void sendImage(int flag)
{
// id=flag;
if(flag==2) {
Intent myIntent1 = new Intent(SecondActivity.this, ThirdActivity.class);
myIntent1.putExtra("key", picturePath);
// myIntent1.putExtra("key2",
SecondActivity.this.startActivity(myIntent1);
}
if(flag==0)
{
Intent myIntent1 = new Intent(SecondActivity.this, ThirdActivity.class);
myIntent1.putExtra("key", photo);
// myIntent1.putExtra("key2",
SecondActivity.this.startActivity(myIntent1);
}
}
void loadPic()
{
String baseDir = Environment.getExternalStorageDirectory().getAbsolutePath();
String pathName = baseDir + "/DCIM/camera/";
File parentDir=new File(pathName);
File[] files = parentDir.listFiles();
Date lastDate = null;
String lastFileName;
boolean isFirstFile = true; //just temp variable for being sure that we are on the first file
for (File file : files) {
if(isFirstFile){
lastDate = new Date(file.lastModified());
isFirstFile = false;
}
if(file.getName().endsWith(".jpg") || file.getName().endsWith(".jpeg")){
Date lastModDate = new Date(file.lastModified());
if (lastModDate.after(lastDate)) {
lastDate = lastModDate;
lastFileName = file.getName();
// String baseDir2 = Environment.getExternalStorageDirectory().getAbsolutePath();
//String fileName = lastFileName;
String pathName2 = pathName +lastFileName;//maybe your folders are /DCIM/camera/
Bitmap bmp = BitmapFactory.decodeFile(pathName2);
ImageButton button1 = (ImageButton)findViewById(R.id.buttonLoadPicture2);
button1.setImageBitmap(bmp);
}
}
}
}}
解决方案
I think that you should pass the bitmap like this:
Intent intent = new Intent(this, ThirdActivity.class);
intent.putExtra("BitmapImage", photo);
and then receive it as parcelable data like this in your third activity:
Intent intent = getIntent();
Bitmap bitmap = (Bitmap) intent.getParcelableExtra("BitmapImage");
and then just set the bitmap to an ImageView
imageView.setImageBitmap(bitmap);
Hopefully this helps you :) Write if you have any exceptions
这篇关于如何设置由相机拍摄到的ImageView图像。？的文章就介绍到这了，希望我们推荐的答案对大家有所帮助，也希望大家多多支持IT屋！
查看全文
