目前已有章节大家可以去学习也可以参考一下
1.从零开始安卓端相机功能开发（一）了解用什么去开发以及流程
2.从零开始安卓端相机功能开发（二）让我们来开发一个相机
3.从零开始开发Android相机app（三）简单介绍图像滤镜功能
让我们来开发一个相机
如有需要源代码的话可以下载安卓简单相机（1）
文章目录
1.让我们来看看我们要开发的相机有什么功能
我们来设计我们的布局当然这个只是最简单的
我们可以从这里看出来一共是五个功能页面
- Framelayout这个是相机显示的界面
- 从左边到右边依次是：相片预览功能，拍照功能，录像功能，设置功能
- 其中的设置功能里面的功能就跟我们上面的图差不多了。
申请权限
先把AndroidManifest中的用户允许权限先写入
<uses-permission android:name="android.permission.CAMERA" /> <!--调用相机-->
<uses-permission android:name="android.permission.WRITE_EXTERNAL_STORAGE" /> <!--写入数据-->
<uses-permission android:name="android.permission.RECORD_AUDIO" /> <!--对焦-->
<uses-permission android:name="android.permission.ACCESS_FINE_LOCATION" /> <!--通过GPS芯片接收卫星的定位信息，定位精度达10米以内-->
<uses-feature android:name="android.hardware.camera" />
2.首先我们先把activity_main布局页面设计好
<?xml version="1.0" encoding="utf-8"?>
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
android:layout_width="match_parent"
android:layout_height="match_parent"
android:orientation="vertical">
<FrameLayout
android:id="@+id/camera_preview"
android:layout_width="fill_parent"
android:layout_height="450dp"
android:layout_alignBottom="@+id/button_settings"
android:layout_alignParentStart="true" />
<RelativeLayout
android:layout_width="fill_parent"
android:layout_height="wrap_content"
android:orientation="horizontal"
android:padding="5dp">
<ImageView
android:id="@+id/capture_setting"
android:layout_width="48dp"
android:layout_height="48dp"
android:layout_alignParentEnd="true"
android:layout_alignParentTop="true"
android:background="@drawable/ic_action_setting" />
<LinearLayout
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:layout_centerHorizontal="true"
android:orientation="horizontal">
//这个可以换成你自己的图片id我是用安卓自带的image asset直接生成icon的
<ImageView
android:id="@+id/capture_photo"
android:layout_width="48dp"
android:layout_height="48dp"
android:src="@drawable/ic_action_camera"
android:layout_marginRight="20dp"/>
<ImageView
android:id="@+id/capture_video"
android:layout_width="48dp"
android:layout_height="48dp"
android:background="@drawable/ic_action_video"/>
</LinearLayout>
<ImageView
//这个是预览的窗口
android:id="@+id/media_preview"
android:layout_width="60dp"
android:layout_height="60dp"
android:layout_alignParentLeft="true"
android:layout_centerVertical="true"
android:background="#000"
android:visibility="visible" />
</RelativeLayout>
</LinearLayout>
3.添加CameraPreview类
从布局层面来说，我们想要添加相机预览实际上就是在FrameLayout中再添加一个View，这个View可以理解为一个“控件”，就像之前的TextView，也是View中的一种，只不过相机预览这个View的内容是会一直变化的预览帧。因为Android并没有提供相机预览这个View，所以需要我们自己创造一个，而这个View我们就起名叫做CameraPreview。
我们新建一个CameraPreview.class
这里主要是存放相机所使用的功能，也就是我们需要使用的拍照和录像功能，还有对焦，双手放到缩小这些功能都是放在这个位置的。
import android.content.Context;
import android.content.SharedPreferences;
import android.graphics.Bitmap;
import android.graphics.Rect;
import android.graphics.RectF;
import android.hardware.Camera;
import android.media.CamcorderProfile;
import android.media.MediaRecorder;
import android.media.ThumbnailUtils;
import android.net.Uri;
import android.os.Environment;
import android.preference.PreferenceManager;
import android.provider.MediaStore;
import android.util.Log;
import android.view.Display;
import android.view.MotionEvent;
import android.view.Surface;
import android.view.SurfaceHolder;
import android.view.SurfaceView;
import android.view.ViewGroup;
import android.view.WindowManager;
import android.widget.ImageView;
import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Date;
import java.util.List;
public class CameraPreview extends SurfaceView implements SurfaceHolder.Callback {
public static final int MEDIA_TYPE_IMAGE = 1;
public static final int MEDIA_TYPE_VIDEO = 2;
private static final String TAG = "CameraDemo";
private SurfaceHolder mHolder;
private Camera mCamera;
private MediaRecorder mMediaRecorder;
private Uri outputMediaFileUri;
private String outputMediaFileType;
private float oldDist = 1f;
//拍照
//拍照主要用到的是Camera的takePicture()方法，通过指定回调函数，将照片数据写入到文件中。
public void takePicture(final ImageView view) {
mCamera.takePicture(null, null, new Camera.PictureCallback() {
@Override
public void onPictureTaken(byte[] data, Camera camera) {
File pictureFile = getOutputMediaFile(MEDIA_TYPE_IMAGE);
if (pictureFile == null) {
Log.d(TAG, "Error creating media file, check storage permissions");
return;
}
try {
FileOutputStream fos = new FileOutputStream(pictureFile);
fos.write(data);
fos.close();
view.setImageURI(outputMediaFileUri);
camera.startPreview();
} catch (FileNotFoundException e) {
Log.d(TAG, "File not found: " + e.getMessage());
} catch (IOException e) {
Log.d(TAG, "Error accessing file: " + e.getMessage());
}
}
});
}
//开始录像
// 录像部分的代码很多，但其中绝大部分都是来自Android官方文档的，基本就是一个不变的套路。
// 录像是交给MediaRecorder类在做，大体上来说就是实例化一个MediaRecorder，
// 向其指定一系列参数，然后start()开始录像，stop()结束录像。
public boolean startRecording() {
if (prepareVideoRecorder()) {
mMediaRecorder.start();
return true;
} else {
releaseMediaRecorder();
}
return false;
}
public void stopRecording(final ImageView view) {
if (mMediaRecorder != null) {
mMediaRecorder.stop();
Bitmap thumbnail = ThumbnailUtils.createVideoThumbnail(outputMediaFileUri.getPath(), MediaStore.Video.Thumbnails.MINI_KIND);
view.setImageBitmap(thumbnail);
}
releaseMediaRecorder();
}
public boolean isRecording() {
return mMediaRecorder != null;
}
public CameraPreview(Context context) {
super(context);
mHolder = getHolder();
mHolder.addCallback(this);
}
public Camera getCameraInstance() {
if (mCamera == null) {
try {
mCamera = Camera.open();
} catch (Exception e) {
Log.d(TAG, "camera is not available");
}
}
return mCamera;
}
//surfaceChanged()、surfaceCreated()和surfaceDestroyed()，这三个方法会对应在Surface内容变化、Surface生成和Surface销毁时触发。
public void surfaceCreated(SurfaceHolder holder) {
getCameraInstance();
try {
mCamera.setPreviewDisplay(holder);
mCamera.startPreview();
} catch (IOException e) {
Log.d(TAG, "Error setting camera preview: " + e.getMessage());
}
}
//成员变量mHolder保存这个Surface的“持有者”（还是Holder顺口），而只有Holder才能对对应的Surface进行修改。成员变量mCamera保存相机Camera的实例。
public void surfaceDestroyed(SurfaceHolder holder) {
mHolder.removeCallback(this);
mCamera.setPreviewCallback(null);
mCamera.stopPreview();
mCamera.release();
mCamera = null;
}
public void surfaceChanged(SurfaceHolder holder, int format, int w, int h) {
int rotation = getDisplayOrientation();
mCamera.setDisplayOrientation(rotation);
Camera.Parameters parameters = mCamera.getParameters();
parameters.setRotation(rotation);
mCamera.setParameters(parameters);
adjustDisplayRatio(rotation);
}
//计算尺寸
private void adjustDisplayRatio(int rotation) {
ViewGroup parent = ((ViewGroup) getParent());
Rect rect = new Rect();
parent.getLocalVisibleRect(rect);
int width = rect.width();
int height = rect.height();
Camera.Size previewSize = mCamera.getParameters().getPreviewSize();
int previewWidth;
int previewHeight;
if (rotation == 90 || rotation == 270) {
previewWidth = previewSize.height;
previewHeight = previewSize.width;
} else {
previewWidth = previewSize.width;
previewHeight = previewSize.height;
}
if (width * previewHeight > height * previewWidth) {
final int scaledChildWidth = previewWidth * height / previewHeight;
layout((width - scaledChildWidth) / 2, 0,
(width + scaledChildWidth) / 2, height);
} else {
final int scaledChildHeight = previewHeight * width / previewWidth;
layout(0, (height - scaledChildHeight) / 2,
width, (height + scaledChildHeight) / 2);
}
}
//计算旋转角度
// 相机预览的旋转角度需要根据相机预览目前的旋转角度，
// 以及设备屏幕的旋转角度计算得到，不过还好Android官方给了示例代码。
public int getDisplayOrientation() {
android.hardware.Camera.CameraInfo camInfo =
new android.hardware.Camera.CameraInfo();
android.hardware.Camera.getCameraInfo(Camera.CameraInfo.CAMERA_FACING_BACK, camInfo);
Display display = ((WindowManager) getContext().getSystemService(Context.WINDOW_SERVICE)).getDefaultDisplay();
int rotation = display.getRotation();
int degrees = 0;
switch (rotation) {
case Surface.ROTATION_0:
degrees = 0;
break;
case Surface.ROTATION_90:
degrees = 90;
break;
case Surface.ROTATION_180:
degrees = 180;
break;
case Surface.ROTATION_270:
degrees = 270;
break;
}
int result = (camInfo.orientation - degrees + 360) % 360;
return result;
}
//getDisplayOrientation()用来获取相机预览需要旋转的角度。
// 前面一部分获得设备屏幕的旋转角度
// 即由重力传感器自动旋转屏幕的角度
// 然后得到相机原先的旋转角度camInfo.orientation，
// 最后通过运算得到新的相机预览需要旋转的角度。
private boolean prepareVideoRecorder() {
mCamera = getCameraInstance();
mMediaRecorder = new MediaRecorder();
mCamera.unlock();
mMediaRecorder.setCamera(mCamera);
mMediaRecorder.setAudioSource(MediaRecorder.AudioSource.CAMCORDER);
mMediaRecorder.setVideoSource(MediaRecorder.VideoSource.CAMERA);
mMediaRecorder.setProfile(CamcorderProfile.get(CamcorderProfile.QUALITY_HIGH));
SharedPreferences prefs = PreferenceManager.getDefaultSharedPreferences(getContext());
String prefVideoSize = prefs.getString("video_size", "");
String[] split = prefVideoSize.split("x");
mMediaRecorder.setVideoSize(Integer.parseInt(split[0]), Integer.parseInt(split[1]));
mMediaRecorder.setOutputFile(getOutputMediaFile(MEDIA_TYPE_VIDEO).toString());
mMediaRecorder.setPreviewDisplay(mHolder.getSurface());
int rotation = getDisplayOrientation();
mMediaRecorder.setOrientationHint(rotation);
try {
mMediaRecorder.prepare();
} catch (IllegalStateException e) {
Log.d(TAG, "IllegalStateException preparing MediaRecorder: " + e.getMessage());
releaseMediaRecorder();
return false;
} catch (IOException e) {
Log.d(TAG, "IOException preparing MediaRecorder: " + e.getMessage());
releaseMediaRecorder();
return false;
}
return true;
}
private void releaseMediaRecorder() {
if (mMediaRecorder != null) {
mMediaRecorder.reset();
mMediaRecorder.release();
mMediaRecorder = null;
mCamera.lock();
}
}
//生成文件名
// 因为拍照录像都是对相机的操作，所以这部分绝大多数都是在CameraPreview中添加代码
// 首先我们添加生成文件名这一功能，
// 我们采用通用的做法，生成的文件名首先标记是照片还是视频，然后是拍摄的时间，比
private File getOutputMediaFile(int type) {
File mediaStorageDir = new File(Environment.getExternalStoragePublicDirectory(
Environment.DIRECTORY_PICTURES), TAG);
if (!mediaStorageDir.exists()) {
if (!mediaStorageDir.mkdirs()) {
Log.d(TAG, "failed to create directory");
return null;
}
}
String timeStamp = new SimpleDateFormat("yyyyMMdd_HHmmss").format(new Date());
File mediaFile;
if (type == MEDIA_TYPE_IMAGE) {
mediaFile = new File(mediaStorageDir.getPath() + File.separator +
"IMG_" + timeStamp + ".jpg");
outputMediaFileType = "image/*";
} else if (type == MEDIA_TYPE_VIDEO) {
mediaFile = new File(mediaStorageDir.getPath() + File.separator +
"VID_" + timeStamp + ".mp4");
outputMediaFileType = "video/*";
} else {
return null;
}
outputMediaFileUri = Uri.fromFile(mediaFile);
return mediaFile;
}
public Uri getOutputMediaFileUri() {
return outputMediaFileUri;
}
public String getOutputMediaFileType() {
return outputMediaFileType;
}
/*捕获触摸事件*/
public boolean onTouchEvent(MotionEvent event) {
if (event.getPointerCount() == 1) {
handleFocusMetering(event, mCamera);
} else {
switch (event.getAction() & MotionEvent.ACTION_MASK) {
case MotionEvent.ACTION_POINTER_DOWN:
oldDist = getFingerSpacing(event);
break;
case MotionEvent.ACTION_MOVE:
float newDist = getFingerSpacing(event);
if (newDist > oldDist) {
handleZoom(true, mCamera);
} else if (newDist < oldDist) {
handleZoom(false, mCamera);
}
oldDist = newDist;
break;
}
}
return true;
}
private void handleZoom(boolean isZoomIn, Camera camera) {
Camera.Parameters params = camera.getParameters();
if (params.isZoomSupported()) {
int maxZoom = params.getMaxZoom();
int zoom = params.getZoom();
if (isZoomIn && zoom < maxZoom) {
zoom++;
} else if (zoom > 0) {
zoom--;
}
params.setZoom(zoom);
camera.setParameters(params);
} else {
Log.i(TAG, "zoom not supported");
}
}
//设置对焦区域
private void handleFocusMetering(MotionEvent event, Camera camera) {
int viewWidth = getWidth();
int viewHeight = getHeight();
Rect focusRect = calculateTapArea(event.getX(), event.getY(), 1f, viewWidth, viewHeight);
Rect meteringRect = calculateTapArea(event.getX(), event.getY(), 1.5f, viewWidth, viewHeight);
camera.cancelAutoFocus();
Camera.Parameters params = camera.getParameters();
if (params.getMaxNumFocusAreas() > 0) {
List<Camera.Area> focusAreas = new ArrayList<>();
focusAreas.add(new Camera.Area(focusRect, 800));
params.setFocusAreas(focusAreas);
} else {
Log.i(TAG, "focus areas not supported");
}
if (params.getMaxNumMeteringAreas() > 0) {
List<Camera.Area> meteringAreas = new ArrayList<>();
meteringAreas.add(new Camera.Area(meteringRect, 800));
params.setMeteringAreas(meteringAreas);
} else {
Log.i(TAG, "metering areas not supported");
}
final String currentFocusMode = params.getFocusMode();
params.setFocusMode(Camera.Parameters.FOCUS_MODE_MACRO);
camera.setParameters(params);
camera.autoFocus(new Camera.AutoFocusCallback() {
@Override
public void onAutoFocus(boolean success, Camera camera) {
Camera.Parameters params = camera.getParameters();
params.setFocusMode(currentFocusMode);
camera.setParameters(params);
}
});
}
private static float getFingerSpacing(MotionEvent event) {
float x = event.getX(0) - event.getX(1);
float y = event.getY(0) - event.getY(1);
return (float) Math.sqrt(x * x + y * y);
}
//使用坐标转换
//相机预览中心是(0, 0)，左上角是(-1000, -1000)，右下角是(1000, 1000)。
// 其中蓝色的矩形就是一个对焦区域，
// 相机以此区域进行对焦。
// 这个坐标系可以让我们免于实际尺寸的困扰，
// 还有一个好处就是这个坐标系不会受预览内容的旋转的影响，
// 就是说只需要做一次坐标变换就好了。
private static Rect calculateTapArea(float x, float y, float coefficient, int width, int height) {
float focusAreaSize = 300;
int areaSize = Float.valueOf(focusAreaSize * coefficient).intValue();
int centerX = (int) (x / width * 2000 - 1000);
int centerY = (int) (y / height * 2000 - 1000);
int halfAreaSize = areaSize / 2;
RectF rectF = new RectF(clamp(centerX - halfAreaSize, -1000, 1000)
, clamp(centerY - halfAreaSize, -1000, 1000)
, clamp(centerX + halfAreaSize, -1000, 1000)
, clamp(centerY + halfAreaSize, -1000, 1000));
return new Rect(Math.round(rectF.left), Math.round(rectF.top), Math.round(rectF.right), Math.round(rectF.bottom));
}
private static int clamp(int x, int min, int max) {
if (x > max) {
return max;
}
if (x < min) {
return min;
}
return x;
}
}
3.接着我们写MainActivity
这里主要就是存放点击事件和UI的一些交互我们可以在这里修改相机的点击和设置setting页面的一些功能的跳转和点击显示，把预览图片的界面给做出来然后显示到这里。
mport android.app.Activity;
import android.content.Intent;
import android.os.Bundle;
import android.preference.PreferenceManager;
import android.view.View;
import android.widget.Button;
import android.widget.FrameLayout;
import android.widget.ImageView;
public class MainActivity extends Activity {
private CameraPreview mPreview;
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
initCamera();
//绑定设置
Button buttonSettings = (Button) findViewById(R.id.button_settings);
buttonSettings.setOnClickListener(new View.OnClickListener() {
@Override
public void onClick(View v) {
getFragmentManager().beginTransaction().replace(R.id.camera_preview, new SettingsFragment()).addToBackStack(null).commit();
}
});
//绑定照片预览
final ImageView mediaPreview = (ImageView) findViewById(R.id.media_preview);
//绑定拍照
final ImageView buttonCapturePhoto = (ImageView) findViewById(R.id.button_capture_photo);
buttonCapturePhoto.setOnClickListener(new View.OnClickListener() {
@Override
public void onClick(View v) {
mPreview.takePicture(mediaPreview);
}
});
//绑定录像机
final ImageView buttonCaptureVideo = (ImageView) findViewById(R.id.button_capture_video);
//创建录像的点击事件
buttonCaptureVideo.setOnClickListener(new View.OnClickListener() {
@Override
public void onClick(View v) {
if (mPreview.isRecording()) {
mPreview.stopRecording(mediaPreview);
} else {
if (mPreview.startRecording()) {
}
}
}
});
mediaPreview.setOnClickListener(new View.OnClickListener() {
@Override
public void onClick(View v) {
Intent intent = new Intent(MainActivity.this, ShowPhotoVideo.class);
intent.setDataAndType(mPreview.getOutputMediaFileUri(), mPreview.getOutputMediaFileType());
startActivityForResult(intent, 0);
}
});
}
private void initCamera() {
mPreview = new CameraPreview(this);
FrameLayout preview = (FrameLayout) findViewById(R.id.camera_preview);
preview.addView(mPreview);
//设置显示的设置菜单
SettingsFragment.passCamera(mPreview.getCameraInstance());
PreferenceManager.setDefaultValues(this, R.xml.preferences, false);
SettingsFragment.setDefault(PreferenceManager.getDefaultSharedPreferences(this));
SettingsFragment.init(PreferenceManager.getDefaultSharedPreferences(this));
}
//重载onResume
// 为了安全起见，也对onPause()重载，在MainActivity中加入
public void onPause() {
super.onPause();
mPreview = null;
}
public void onResume() {
super.onResume();
if (mPreview == null) {
initCamera();
}
}
}
4.我们来写设置功能
设置功能如下
首先我们需要编写一个PreferenceFragment设置界面如果不清楚的话可以看我的这一篇文章
安卓中preferenceFragment的使用
<?xml version="1.0" encoding="utf-8"?>
<PreferenceScreen xmlns:android="http://schemas.android.com/apk/res/android">
<ListPreference
android:key="preview_size"
android:title="相机预览分辨率" />
<ListPreference
android:key="picture_size"
android:title="照片分辨率" />
<ListPreference
android:key="video_size"
android:title="视频分辨率" />
<SwitchPreference
android:defaultValue="true"
android:key="gps_data"
android:title="地理位置" />
<ListPreference
android:defaultValue="auto"
android:key="flash_mode"
android:title="闪光灯" />
<ListPreference
android:key="focus_mode"
android:title="对焦模式" />
<ListPreference
android:defaultValue="auto"
android:key="white_balance"
android:title="白平衡" />
<ListPreference
android:defaultValue="auto"
android:key="scene_mode"
android:title="场景" />
<ListPreference
android:defaultValue="0"
android:key="exposure_compensation"
android:title="曝光补偿" />
<ListPreference
android:defaultValue="100"
android:entries="@array/pref_jpegQuality"
android:entryValues="@array/pref_jpegQuality"
android:key="jpeg_quality"
android:title="照片品质" />
arrys
<?xml version="1.0" encoding="utf-8"?>
<resources>
<string-array name="pref_jpegQuality">
<item>100</item>
<item>90</item>
<item>80</item>
<item>70</item>
<item>60</item>
<item>50</item>
</string-array>
</resources>
好了下面我们来实现这些功能
import android.content.SharedPreferences;
import android.hardware.Camera;
import android.os.Bundle;
import android.preference.ListPreference;
import android.preference.Preference;
import android.preference.PreferenceFragment;
import android.preference.PreferenceGroup;
import java.util.ArrayList;
import java.util.List;
public class SettingsFragment extends PreferenceFragment implements SharedPreferences.OnSharedPreferenceChangeListener {
public static final String KEY_PREF_PREV_SIZE = "preview_size";
public static final String KEY_PREF_PIC_SIZE = "picture_size";
public static final String KEY_PREF_VIDEO_SIZE = "video_size";
public static final String KEY_PREF_FLASH_MODE = "flash_mode";
public static final String KEY_PREF_FOCUS_MODE = "focus_mode";
public static final String KEY_PREF_WHITE_BALANCE = "white_balance";
public static final String KEY_PREF_SCENE_MODE = "scene_mode";
public static final String KEY_PREF_GPS_DATA = "gps_data";
public static final String KEY_PREF_EXPOS_COMP = "exposure_compensation";
public static final String KEY_PREF_JPEG_QUALITY = "jpeg_quality";
static Camera mCamera;
static Camera.Parameters mParameters;
public void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
addPreferencesFromResource(R.xml.preferences);
getActivity().setTheme(R.style.PreferenceTheme);
loadSupportedPreviewSize();//动态加载预览分辨率即相机预览时屏幕显示的分辨率大小
loadSupportedPictureSize();//动态加载图片大小
loadSupportedVideoeSize();//动态加载录像大小
loadSupportedFlashMode();//动态加载闪光灯开启
loadSupportedFocusMode();//动态开启对焦
loadSupportedWhiteBalance();//动态加载白平衡
loadSupportedSceneMode();//动态加载场景开启
loadSupportedExposeCompensation();//动态加载曝光补偿
initSummary(getPreferenceScreen());
}
//获得一个打开的相机
public static void passCamera(Camera camera) {
/*passCamera()用来将相机传输给SettingsFragment，SettingsFragment将相机保存到静态成员变量mCamera中
getParameters()则用来获取相机参数，
将相机参数保存到静态成员变量mParameters中。*/
mCamera = camera;
mParameters = camera.getParameters();
}
//动态加载默认值
public static void setDefault(SharedPreferences sharedPrefs) {
/*SharedPreferences由MainActivity提供，是操作Preference的接口，既可以读取也可以写入。
SharedPreferences.Editor就是编辑Preference，其putString()将key-value对写入到APP中，
注意最后需要apply()保存这些更改（也可以用commit()，但效率会低一些）。
具体怎么找到value代码很简单，
就是通过mParameters获取此时相机预览的参数，然后转换为特定形式的String，就作为value返回了。*/
String valPreviewSize = sharedPrefs.getString(KEY_PREF_PREV_SIZE, null);
if (valPreviewSize == null) {
SharedPreferences.Editor editor = sharedPrefs.edit();
editor.putString(KEY_PREF_PREV_SIZE, getDefaultPreviewSize());
editor.putString(KEY_PREF_PIC_SIZE, getDefaultPictureSize());
editor.putString(KEY_PREF_VIDEO_SIZE, getDefaultVideoSize());
editor.putString(KEY_PREF_FOCUS_MODE, getDefaultFocusMode());
editor.apply();
}
}
private static String getDefaultPreviewSize() {
Camera.Size previewSize = mParameters.getPreviewSize();
return previewSize.width + "x" + previewSize.height;
}
private static String getDefaultPictureSize() {
Camera.Size pictureSize = mParameters.getPictureSize();
return pictureSize.width + "x" + pictureSize.height;
}
private static String getDefaultVideoSize() {
Camera.Size VideoSize = mParameters.getPreferredPreviewSizeForVideo();
return VideoSize.width + "x" + VideoSize.height;
}
private static String getDefaultFocusMode() {
List<String> supportedFocusModes = mParameters.getSupportedFocusModes();
if (supportedFocusModes.contains("continuous-picture")) {
return "continuous-picture";
}
return "continuous-video";
}
public static void init(SharedPreferences sharedPref) {
setPreviewSize(sharedPref.getString(KEY_PREF_PREV_SIZE, ""));
setPictureSize(sharedPref.getString(KEY_PREF_PIC_SIZE, ""));
setFlashMode(sharedPref.getString(KEY_PREF_FLASH_MODE, ""));
setFocusMode(sharedPref.getString(KEY_PREF_FOCUS_MODE, ""));
setWhiteBalance(sharedPref.getString(KEY_PREF_WHITE_BALANCE, ""));
setSceneMode(sharedPref.getString(KEY_PREF_SCENE_MODE, ""));
setExposComp(sharedPref.getString(KEY_PREF_EXPOS_COMP, ""));
setJpegQuality(sharedPref.getString(KEY_PREF_JPEG_QUALITY, ""));
setGpsData(sharedPref.getBoolean(KEY_PREF_GPS_DATA, false));
mCamera.stopPreview();
mCamera.setParameters(mParameters);
mCamera.startPreview();
}
private void loadSupportedPreviewSize() {
cameraSizeListToListPreference(mParameters.getSupportedPreviewSizes(), KEY_PREF_PREV_SIZE);
}
private void loadSupportedPictureSize() {
cameraSizeListToListPreference(mParameters.getSupportedPictureSizes(), KEY_PREF_PIC_SIZE);
}
private void loadSupportedVideoeSize() {
cameraSizeListToListPreference(mParameters.getSupportedVideoSizes(), KEY_PREF_VIDEO_SIZE);
}
private void loadSupportedFlashMode() {
stringListToListPreference(mParameters.getSupportedFlashModes(), KEY_PREF_FLASH_MODE);
}
private void loadSupportedFocusMode() {
stringListToListPreference(mParameters.getSupportedFocusModes(), KEY_PREF_FOCUS_MODE);
}
private void loadSupportedWhiteBalance() {
stringListToListPreference(mParameters.getSupportedWhiteBalance(), KEY_PREF_WHITE_BALANCE);
}
private void loadSupportedSceneMode() {
stringListToListPreference(mParameters.getSupportedSceneModes(), KEY_PREF_SCENE_MODE);
}
private void loadSupportedExposeCompensation() {
int minExposComp = mParameters.getMinExposureCompensation();
int maxExposComp = mParameters.getMaxExposureCompensation();
List<String> exposComp = new ArrayList<>();
for (int value = minExposComp; value <= maxExposComp; value++) {
exposComp.add(Integer.toString(value));
}
stringListToListPreference(exposComp, KEY_PREF_EXPOS_COMP);
}
private void cameraSizeListToListPreference(List<Camera.Size> list, String key) {
List<String> stringList = new ArrayList<>();
for (Camera.Size size : list) {
String stringSize = size.width + "x" + size.height;
stringList.add(stringSize);
}
stringListToListPreference(stringList, key);
}
private void stringListToListPreference(List<String> list, String key) {
final CharSequence[] charSeq = list.toArray(new CharSequence[list.size()]);
ListPreference listPref = (ListPreference) getPreferenceScreen().findPreference(key);
listPref.setEntries(charSeq);
listPref.setEntryValues(charSeq);
}
//给SettingsFragment添加监听事件
public void onSharedPreferenceChanged(SharedPreferences sharedPreferences, String key) {
updatePrefSummary(findPreference(key));
switch (key) {
case KEY_PREF_PREV_SIZE:
setPreviewSize(sharedPreferences.getString(key, ""));
break;
case KEY_PREF_PIC_SIZE:
setPictureSize(sharedPreferences.getString(key, ""));
break;
case KEY_PREF_FOCUS_MODE:
setFocusMode(sharedPreferences.getString(key, ""));
break;
case KEY_PREF_FLASH_MODE:
setFlashMode(sharedPreferences.getString(key, ""));
break;
case KEY_PREF_WHITE_BALANCE:
setWhiteBalance(sharedPreferences.getString(key, ""));
break;
case KEY_PREF_SCENE_MODE:
setSceneMode(sharedPreferences.getString(key, ""));
break;
case KEY_PREF_EXPOS_COMP:
setExposComp(sharedPreferences.getString(key, ""));
break;
case KEY_PREF_JPEG_QUALITY:
setJpegQuality(sharedPreferences.getString(key, ""));
break;
case KEY_PREF_GPS_DATA:
setGpsData(sharedPreferences.getBoolean(key, false));
break;
}
mCamera.stopPreview();
mCamera.setParameters(mParameters);
mCamera.startPreview();
}
private static void setPreviewSize(String value) {
String[] split = value.split("x");
mParameters.setPreviewSize(Integer.parseInt(split[0]), Integer.parseInt(split[1]));
}
private static void setPictureSize(String value) {
String[] split = value.split("x");
mParameters.setPictureSize(Integer.parseInt(split[0]), Integer.parseInt(split[1]));
}
private static void setFocusMode(String value) {
mParameters.setFocusMode(value);
}
private static void setFlashMode(String value) {
mParameters.setFlashMode(value);
}
private static void setWhiteBalance(String value) {
mParameters.setWhiteBalance(value);
}
private static void setSceneMode(String value) {
mParameters.setSceneMode(value);
}
private static void setExposComp(String value) {
mParameters.setExposureCompensation(Integer.parseInt(value));
}
private static void setJpegQuality(String value) {
mParameters.setJpegQuality(Integer.parseInt(value));
}
private static void setGpsData(Boolean value) {
if (value.equals(false)) {
mParameters.removeGpsData();
}
}
private static void initSummary(Preference pref) {
if (pref instanceof PreferenceGroup) {
PreferenceGroup prefGroup = (PreferenceGroup) pref;
for (int i = 0; i < prefGroup.getPreferenceCount(); i++) {
initSummary(prefGroup.getPreference(i));
}
} else {
updatePrefSummary(pref);
}
}
private static void updatePrefSummary(Preference pref) {
if (pref instanceof ListPreference) {
pref.setSummary(((ListPreference) pref).getEntry());
}
}
@Override
public void onResume() {
super.onResume();
getPreferenceScreen().getSharedPreferences()
.registerOnSharedPreferenceChangeListener(this);
}
@Override
public void onPause() {
super.onPause();
getPreferenceScreen().getSharedPreferences()
.unregisterOnSharedPreferenceChangeListener(this);
}
}
5.添加预览功能
import android.app.Activity;
import android.net.Uri;
import android.os.Bundle;
import android.widget.ImageView;
import android.widget.MediaController;
import android.widget.RelativeLayout;
import android.widget.VideoView;
public class ShowPhotoVideo extends Activity {
public void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
RelativeLayout relativeLayout = new RelativeLayout(this);
RelativeLayout.LayoutParams layoutParams = new RelativeLayout.LayoutParams(RelativeLayout.LayoutParams.MATCH_PARENT, RelativeLayout.LayoutParams.MATCH_PARENT);
layoutParams.addRule(RelativeLayout.CENTER_IN_PARENT);
Uri uri = getIntent().getData();
if (getIntent().getType().equals("image/*")) {
ImageView view = new ImageView(this);
view.setImageURI(uri);
view.setLayoutParams(layoutParams);
relativeLayout.addView(view);
} else {
MediaController mc = new MediaController(this);
VideoView view = new VideoView(this);
mc.setAnchorView(view);
mc.setMediaPlayer(view);
view.setMediaController(mc);
view.setVideoURI(uri);
view.start();
view.setLayoutParams(layoutParams);
relativeLayout.addView(view);
}
setContentView(relativeLayout, layoutParams);
}
}
好了至此我们已经完成一个相机所需要的功能了所以接下来我们需要去开发滤镜功能了。
本文参考自Android相机开发系列
如有需要源代码的话可以下载安卓简单相机（1）
版权声明：本文内容由互联网用户自发贡献，该文观点仅代表作者本人。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如发现本站有涉嫌侵权/违法违规的内容， 请发送邮件至 举报，一经查实，本站将立刻删除。
文章由极客之音整理，本文链接：https://www.bmabk.com/index.php/post/134160.html
