Android Camera

最新推荐文章于 2025-04-14 08:30:00 发布
最新推荐文章于 2025-04-14 08:30:00 发布
阅读量118 收藏
点赞数
CC 4.0 BY-SA版权
分类专栏： Android随记 文章标签： Android OS F# UP
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/a51884020/article/details/83885529 
package myj.cameratest;

import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;
import android.app.Activity;
import android.app.Notification;
import android.content.Intent;
import android.content.pm.ActivityInfo;
import android.graphics.Bitmap;
import android.graphics.BitmapFactory;
import android.graphics.PixelFormat;
import android.hardware.Camera;
import android.hardware.Camera.PictureCallback;
import android.hardware.Camera.ShutterCallback;
import android.os.Bundle;
import android.os.Environment;
import android.util.Log;
import android.view.MotionEvent;
import android.view.SurfaceHolder;
import android.view.SurfaceView;
import android.view.View;
import android.view.Window;
import android.view.WindowManager;
import android.view.View.OnTouchListener;
import android.widget.Button;
import android.widget.ImageButton;
import android.widget.Toast;

public class CameraTest extends Activity implements SurfaceHolder.Callback{
    /** Called when the activity is first created. */
	private Bitmap[] bmps = new Bitmap[6];
	private Camera mCamera; 
	private ImageButton mButton,mButton1,mButton2;
	//  private Button returnTomainmenu;
	private SurfaceView mSurfaceView; 
	private SurfaceHolder holder; 
    private AutoFocusCallback mAutoFocusCallback = 
	                            new AutoFocusCallback(); 
	private String path="CameraTest";
	private Bitmap bmp = null;
	private int cnt=1;
	private int count;
	private boolean isFocused = false;
    @Override
    public void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        this.getWindow().setFlags(WindowManager.LayoutParams.FLAG_FULLSCREEN,
                WindowManager.LayoutParams.FLAG_FULLSCREEN);
		/* 隐藏标题栏 */
		requestWindowFeature(Window.FEATURE_NO_TITLE);
		/* 设定屏幕显示为横向 */
		this.setRequestedOrientation(ActivityInfo.SCREEN_ORIENTATION_LANDSCAPE);
        setContentView(R.layout.main);
        Bundle bl = new Bundle();
        mSurfaceView = (SurfaceView) findViewById(R.id.mSurfaceView); 
        holder = mSurfaceView.getHolder();
        holder.addCallback(CameraTest.this); 
        holder.setType(SurfaceHolder.SURFACE_TYPE_PUSH_BUFFERS);
        mButton = (ImageButton)findViewById(R.id.myButton);
        mButton1 = (ImageButton)findViewById(R.id.myButton1);  //搜索按钮（1、保存文件，读取上传）  
        mButton2 = (ImageButton)findViewById(R.id.myButton2);  //重拍按钮（放弃保存文件，并重新拍照）
        /* 按钮效果处理 */
        mButton.setOnTouchListener(new OnTouchListener() {
        	//@Override
        	public boolean onTouch(View v, MotionEvent event) {
    			// TODO Auto-generated method stub
//        		Bitmap bm;
    			if(event.getAction() == MotionEvent.ACTION_DOWN){
                    //更改为按下时的背景图片
    				bmps[0] = BitmapFactory.decodeResource(getResources(), R.drawable.takepicture2);
    				mButton.setImageBitmap(bmps[0]);
//                    v.setBackgroundResource(R.drawable.barcodesearch2);//这行经测试不好使
    			}else if(event.getAction() == MotionEvent.ACTION_UP){
                    //改为抬起时的图片
    				bmps[1] = BitmapFactory.decodeResource(getResources(), R.drawable.takepicture);
    				mButton.setImageBitmap(bmps[1]);
//                    v.setBackgroundResource(R.drawable.barcodesearch);
    			}
    			return false;
    			}
    	});
        mButton1.setOnTouchListener(new OnTouchListener() {
        	//@Override
        	public boolean onTouch(View v, MotionEvent event) {
    			// TODO Auto-generated method stub
//        		Bitmap bm;
    			if(event.getAction() == MotionEvent.ACTION_DOWN){
                    //更改为按下时的背景图片
    				bmps[2] = BitmapFactory.decodeResource(getResources(), R.drawable.search2);
    				mButton1.setImageBitmap(bmps[2]);
//                    v.setBackgroundResource(R.drawable.barcodesearch2);//这行经测试不好使
    			}else if(event.getAction() == MotionEvent.ACTION_UP){
                    //改为抬起时的图片
    				bmps[3] = BitmapFactory.decodeResource(getResources(), R.drawable.search);
    				mButton1.setImageBitmap(bmps[3]);
//                    v.setBackgroundResource(R.drawable.barcodesearch);
    			}
    			return false;
    			}
    	});
        mButton2.setOnTouchListener(new OnTouchListener() {
        	//@Override
        	public boolean onTouch(View v, MotionEvent event) {
    			// TODO Auto-generated method stub
//        		Bitmap bm;
    			if(event.getAction() == MotionEvent.ACTION_DOWN){
                    //更改为按下时的背景图片
    				bmps[4] = BitmapFactory.decodeResource(getResources(), R.drawable.takepicture2);
    				mButton2.setImageBitmap(bmps[4]);
//                    v.setBackgroundResource(R.drawable.barcodesearch2);//这行经测试不好使
    			}else if(event.getAction() == MotionEvent.ACTION_UP){
                    //改为抬起时的图片
    				bmps[5] = BitmapFactory.decodeResource(getResources(), R.drawable.takepicture);
    				mButton2.setImageBitmap(bmps[5]);
//                    v.setBackgroundResource(R.drawable.barcodesearch);
    			}
    			return false;
    			}
    	});
        /* 拍照Button的事件处理 */
        mButton.setOnClickListener(new Button.OnClickListener() 
        { 
          //@Override 
          public void onClick(View arg0) 
          { 
            /* 关闭闪光灯并拍照 */        	  
          	  mButton.setVisibility(View.GONE); 
          	  if(bmps[0] != null && !bmps[0].isRecycled())
          		  bmps[0].recycle();
        	  mCamera.autoFocus(mAutoFocusCallback);
//        	  Notification notification = new Notification(); 
//        	  notification.ledOffMS = 0;
//        	  notification.ledOnMS = 0;
//        	  notification.flags = notification.flags | Notification.FLAG_SHOW_LIGHTS;
//        	  takePicture();
           
          }
        });
        /*搜索按钮的事件处理 */
        mButton1.setOnClickListener(new Button.OnClickListener() 
        { 
          //@Override 
          public void onClick(View arg0) 
          {
//        	  Bitmap newBmp = ImageTool.imageZoom(bmp, 720, 480);
        	  mButton1.setVisibility(View.GONE);
              mButton2.setVisibility(View.GONE);
//              if(bmps[2] != null && !bmps[2].isRecycled())
//            	  bmps[2].recycle();
//              if(bmps[4] != null && !bmps[4].isRecycled())
//            	  bmps[4].recycle();
//              Bitmap newBmp = null;
//              newBmp = bmp;
//        	  Bitmap newBmp = ImageTool.imageZoom(bmp, 960, 640);
//        	  if(!bmp.isRecycled())
//      	  		bmp.recycle();
            /* 保存文件 */
            if(bmp!=null)
            {
            	Log.i("aaaaaaaaaaaaa", "nnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnn");
              /* 检查SDCard是否存在 */ 
              if (!Environment.MEDIA_MOUNTED.equals(Environment.getExternalStorageState())) 
              { 
                /* SD卡不存在，显示Toast信息 */
                Toast.makeText(CameraTest.this,"SD卡不存在!上传失败！",
                Toast.LENGTH_LONG).show();
              }
              else
              {
                try
                {
                  /* 文件不存在就创建 */
                  File f=new File
                  (
                    Environment.getExternalStorageDirectory(),path
                  );
                  
                  if(!f.exists())
                  {
                    f.mkdir();
                  }
                  /* 保存相片文件 */
//                  File n=new File(f,Constant.state + ".jpg");
//                  Bitmap newBmp = ImageTool.imageZoom(bmp, 720, 480);
                  File n=new File(f,"1024_768.jpg");
                  FileOutputStream bos = 
                    new FileOutputStream(n.getAbsolutePath());
                  /* 文件转换 */
                  bmp.compress(Bitmap.CompressFormat.JPEG, 100, bos);
                  /* 调用flush()方法，更新BufferStream */
                  bos.flush();
                  /* 结束OutputStream */
                  bos.close();
                  Toast.makeText(CameraTest.this,cnt+".jpg保存成功!",
                      Toast.LENGTH_LONG).show();
//                  if(!newBmp.isRecycled())
//                	  newBmp.recycle();
//                  Constant.upLoadFile = "/sdcard/MyPhoto/" + Constant.state + ".jpg";
////                  Constant.upLoadFile = "/sdcard/MyPhoto/3E.jpg";
//                  Constant.newFileName = Constant.state + ".jpg";
////                  Constant.newFileName = "3E.jpg";
                  cnt++;              
                }
                catch (Exception e)
                {
                  e.printStackTrace();
                }
              }
            }
            
            if(!bmp.isRecycled())
            	bmp.recycle();
            
            mButton.setVisibility(View.VISIBLE);
            
            /* 重新设定Camera */            
            stopCamera(); 
            initCamera();
          } 
        }); 
        /* 重拍按钮的事件处理 */
        mButton2.setOnClickListener(new Button.OnClickListener() 
        { 
          //@Override 
          public void onClick(View arg0) 
          { 
            mButton.setVisibility(View.VISIBLE);
            mButton1.setVisibility(View.GONE);
            mButton2.setVisibility(View.GONE);
            /* 重新设定Camera */
//            bmp = null;
            if(!bmp.isRecycled())
    	  		bmp.recycle();
            stopCamera(); 
            initCamera();
          } 
        });
    }
    
    public void surfaceCreated(SurfaceHolder surfaceholder) 
    { 
      try
      {
        /* 打开相机 */
        mCamera = mCamera.open();
        mCamera.setPreviewDisplay(holder);
      }
      catch (IOException exception)
      {
        mCamera.release();
        mCamera = null;
      }     
    }
    
    public void surfaceChanged(SurfaceHolder surfaceholder,
            int format,int w,int h) 
	{
		/* 相机初始化 */
		initCamera();
    	count ++;
		Log.i("changed", count + "times");
	} 

//@Override 
	public void surfaceDestroyed(SurfaceHolder surfaceholder) 
	{ 
		stopCamera();
		mCamera.release();
		mCamera = null;
	}
	
	private void takePicture()  
	  { 
	    if (mCamera != null)  
	    { 
	      mCamera.takePicture(shutterCallback, rawCallback,jpegCallback); 
	    } 
	  }

	  private ShutterCallback shutterCallback = new ShutterCallback()  
	  {  
	    public void onShutter()  
	    {  
	      /* 按快门瞬间呼叫这里的程序 */
	    }  
	  };
	  
	  private PictureCallback rawCallback = new PictureCallback()  
	  {  
	    public void onPictureTaken(byte[] _data, Camera _camera)  
	    {  
	      /* 要处理raw data?写?否 */
	    }  
	  };
	  
	  private PictureCallback jpegCallback = new PictureCallback()  
	  { 
	    public void onPictureTaken(byte[] _data, Camera _camera) 
	    { 
	      /* 取得相片 */
	      try 
	      { 
	        /* 设定Button可视性 */
	    	  mButton.setVisibility(View.GONE);
	          mButton1.setVisibility(View.VISIBLE);
	          mButton2.setVisibility(View.VISIBLE);
	        /* 取得相片Bitmap对象 */      
	          bmp = BitmapFactory.decodeByteArray(_data, 0,_data.length);  	          
	      } 
	      catch (Exception e) 
	      { 
	        e.printStackTrace(); 
	      } 
	    } 
	  };
	  	  
	  public final class AutoFocusCallback implements android.hardware.Camera.AutoFocusCallback 
	  { 
	    public void onAutoFocus(boolean focused, Camera camera) 
	    { 
	      /* 对到焦点拍照 */
	      if (focused) 
	      { 
	        takePicture();
	      } 
	      else
	    	  mButton.setVisibility(View.VISIBLE);
	    } 
	  };
	  
	  /* 相机初始化的method */
	  private void initCamera() 
	  { 
	    if (mCamera != null) 
	    {
	      try 
	      {     	  
	        Camera.Parameters parameters = mCamera.getParameters();         
	        parameters.setPictureFormat(PixelFormat.JPEG); 
//	        parameters.setPictureSize(2560, 1920);
	        parameters.setPictureSize(1024, 768);
//	        parameters.setPictureSize(720, 480);

	        mCamera.setParameters(parameters); 
	        mCamera.startPreview();
	      } 
	      catch (Exception e) 
	      { 
	          e.printStackTrace(); 
	      } 
	    } 
	  } 

	  /* 停止相机的method */ 
	  private void stopCamera() 
	  { 
	    if (mCamera != null) 
	    { 
	      try 
	      { 
	        /* 停止预览 */
	        mCamera.stopPreview(); 
	      } 
	      catch(Exception e) 
	      { 
	        e.printStackTrace(); 
	      } 
	    } 
	  }
	  
//	  protected void onDestroy()
//	  {
//		  super.onDestroy();
//		  for(int i = 0; i < 6; i ++)
//		  {
//			  if(bmps[i] != null && !bmps[i].isRecycled())
//				  bmps[i].recycle();
//		  }
//		  Log.i("&&&&&&&&&&", "**************");
//	  }
}

 

package myj.cameratest;

import java.io.File;
import java.io.FileOutputStream;
import java.util.Calendar;
import java.util.Date;

import android.graphics.Bitmap;
import android.graphics.Matrix;
import android.os.Environment;
import android.util.Log;

public class ImageTool {
	//切割图片的一部分
	public static Bitmap imageCut(Bitmap bmp, int left, int top, int right, int bottom)
	{
		Bitmap resultBmp = null;
		int resultWidth = right - left + 1;
		int resultHeight = bottom - top + 1;
		int colors[] = new int[resultWidth * resultHeight];
		bmp.getPixels(colors, 0, resultWidth, left, top, resultWidth, resultHeight);
		if(bmp.isRecycled())
			bmp.recycle();
		resultBmp = Bitmap.createBitmap(colors, resultWidth, resultHeight, Bitmap.Config.ARGB_8888);
		return resultBmp;
	}
	
	//把图片按固定比例缩小
	public static Bitmap imageZoom(Bitmap bmp, int iWidth, int iHeight)
	{
		Bitmap newBmp = null;
		int imageHeight = bmp.getHeight();
		int imageWidth = bmp.getWidth();
		float scaleW = 1;
		float scaleH = 1;
		double scalex = (float)iWidth/imageWidth;
		double scaley = (float)iHeight/imageHeight;
		scaleW = (float)(scaleW * scalex);
		scaleH = (float)(scaleH * scaley);
		Matrix matrix = new Matrix();
		matrix.postScale(scaleW, scaleH);
		newBmp = Bitmap.createBitmap(bmp, 0, 0, imageWidth, imageHeight, matrix, true);
//		if(!bmp.isRecycled())
//			bmp.recycle();
		return newBmp;
	}
	
	//图片合并
	public static Bitmap imageMerge(Bitmap[] bmps)
	{
		Bitmap resultBmp = null;
		//判断bmps中有没有值为null的bmp，有的话将其初始化为一张960*80的空白图片
		int bmp_null[] = new int[960 * 80];
		for(int i = 0; i < 960 * 80; i ++)
			bmp_null[i] = 0xffffffff;
		for(int i = 0; i < bmps.length; i ++)
		{
			if(bmps[i] == null)
			{
				bmps[i] = Bitmap.createBitmap(960, 80, Bitmap.Config.ARGB_8888);
				bmps[i].setPixels(bmp_null, 0, 960, 0, 0, 960, 80);
			}
		}
		int devideLineHeight = 5;
		int resultWidth = 0;   //合并完的图像的宽度；
		int resultHeight = 0;  //合并完的图像的高度；
		for(int i = 0; i < bmps.length; i ++)
		{
			if(i != (bmps.length - 1))
			{
				if(bmps[i].getWidth() > resultWidth)
					resultWidth = bmps[i].getWidth();
				resultHeight = resultHeight + bmps[i].getHeight() + devideLineHeight;  //不同图片之间用一条宽度为5像素的红线隔开
			}
			else
			{
				if(bmps[i].getWidth() > resultWidth)
					resultWidth = bmps[i].getWidth();
				resultHeight = resultHeight + bmps[i].getHeight();
			}
		}
		resultWidth = 960;  //暂时将宽度定义为960
		Log.i("Width & Height", "******* " + resultWidth + " * " + resultHeight + " ********");
		//定义各图片之间分割线的像素数组
		int devideLine[] = new int[resultWidth * devideLineHeight];
		for(int i = 0; i < resultWidth * devideLineHeight; i ++)
			devideLine[i] = 0xffff0000;
		//生成了一张resultWidth*resultHeight的黑色图片
		resultBmp = Bitmap.createBitmap(resultWidth, resultHeight, Bitmap.Config.ARGB_8888); 
		//为了识别方便，将这张黑色图片变为纯白色
		int originalColors[] = new int[resultWidth * resultHeight];
		for(int i = 0; i < resultWidth * resultHeight; i ++)
			originalColors[i] = 0xffffffff;
		resultBmp.setPixels(originalColors, 0, resultWidth, 0, 0, resultWidth, resultHeight); //一张纯白色的图片
		//下面的循环用图片数组中各个图片的像素数组及分割线的像素数组填充最终图片
		int y = 0;
		int len = bmps.length;
		for(int i = 0; i < len; i ++)
		{
			int iWidth = bmps[i].getWidth();
			int iHeight = bmps[i].getHeight();
			int colors[] = new int[iWidth * iHeight];
			bmps[i].getPixels(colors, 0, iWidth, 0, 0, iWidth, iHeight);
			if(i != (len - 1))
			{
				resultBmp.setPixels(colors, 0, iWidth, 0, y, iWidth, iHeight);
				y = y + iHeight;
				resultBmp.setPixels(devideLine, 0, resultWidth, 0, y, resultWidth, devideLineHeight);
				y = y + devideLineHeight;
			}
			else
			{
				resultBmp.setPixels(colors, 0, iWidth, 0, y, iWidth, iHeight);
			}
			if(!bmps[i].isRecycled())
				bmps[i].recycle();
		}
		return resultBmp;
	}
	
	//保存图片
	public static void saveImage(Bitmap bmp, String path, String filename, int quality)
	{
		String time = callTime();
		if (bmp != null) {
			try {
				/* 文件不存在就创建 */
				File f = new File(Environment.getExternalStorageDirectory(),
						path);
				if (!f.exists()) {
					f.mkdir();
				}
				/* 保存相片文件 */
				File n = null;
//				if(path.equals("MyPhoto"))
//				{
//					n = new File(f, filename + Constant.cntOfMyPhoto + ".jpg");
//					Constant.cntOfMyPhoto ++;
//				}
//				else
//				{
//				    n = new File(f, filename + Constant.cntOfTemp + ".jpg");
//				    Constant.cntOfTemp ++;
//				}
//				Constant.fileNameOfTemp = filename + Constant.cntOfTemp;
				n = new File(f, filename + time + ".jpg");
//				Constant.fileNameOfTemp = filename + time;
				FileOutputStream bos = new FileOutputStream(n.getAbsolutePath());
				/* 文件转换 */
				bmp.compress(Bitmap.CompressFormat.JPEG, quality, bos);
				/* 调用flush()方法，更新BufferStream */
				bos.flush();
				/* 结束OutputStream */
				bos.close();
//				Constant.upLoadFile = "/sdcard/MyPhoto/" + filename + sTime + ".jpg";
//				Constant.upLoadFile = "/sdcard/MyPhoto/" + filename + time + ".jpg";
//				Constant.newFileName = filename + time + ".jpg";
			} catch (Exception e) {
				e.printStackTrace();
			}
		}
		if(!bmp.isRecycled())
			bmp.recycle();
	}
	
	//重置选择框的初始位置
	public static void resetRect()
	{
//		Constant.left = 200;
//		Constant.top = 140;
//		Constant.right = 280;
//		Constant.bottom = 170;
	}
	
	//获取系统时间
	public static String callTime() {
        long backTime = new Date().getTime();
        Calendar cal = Calendar.getInstance();
        cal.setTime(new Date(backTime));
        int year = cal.get(Calendar.YEAR);
        int month = cal.get(Calendar.MONTH) + 1;
        int date = cal.get(Calendar.DAY_OF_MONTH);
        int hour = cal.get(Calendar.HOUR_OF_DAY);
        int minute = cal.get(Calendar.MINUTE);
        int second = cal.get(Calendar.SECOND);
        String time = "" + year + month + date + hour + minute + second;
        Log.i("CurrentTime", "^^^^^^^^^^^^^" + time + "^^^^^^^^^^^^^");
        return time;
//        return date + 100 * (month + 1) + 10000 * year;
  }
}

 

<uses-permission android:name="android.permission.CAMERA" /> 
	  <uses-feature android:name="android.hardware.camera" /> 
	  <uses-feature android:name="android.hardware.camera.autofocus" />

 

Android Camera 架构
2401_86391954的博客
09-04 2029
应用开发者调用AOSP提供的接口即可,AOSP的接口即Android提供的相机应用的通用接口,这些接口将通过Binder与Framework层的相机服务进行操作与数据传递;位于,相机Framework服务是承上启下的作用,上与应用交互,下与HAL曾交互。硬件抽象层,Android 定义好了Framework服务与HAL层通信的协议及接口,HAL层如何实现有各个Vendor自己实现,如Qcom的老架构mm-Camera,新架构Camx架构,Mtk的P之后的Hal3架构.
Android Camera系列（一）：SurfaceView+Camera
xiaozhiwz的专栏
09-02 2448
本文介绍了Camera+SurfaceView的基本操作及关键代码，但是你如果看github中代码会发现和文中出入很大。其原因在于文章我想用一种简单的方式让没有做过自定义Camera的人也能明白。而github中的项目我已经进行了多次重构、抽象。其中包括对Camera的抽象，定义ICameraManager接口。对预览的View的重构，定义BaseCameraView接口，以及预览视图的众多超类。
Android硬编码知识点总结
jackzhouyu的专栏
11-25 2058
Android硬编码知识点总结 编码 软编码ffmpeg可以解决众多Android机型适配的问题，但由于软编码会大量消耗CPU资源，反而得不偿失！所以一般会考虑使用Android自身硬编码，不足时用软编码补充！硬编码中的一些特性有时会难以理解，这里记录一下我在编码时的心得总结！ 帧率如何设置？ 一般根据使用场景实际需求来设定，帧率表示每秒输出多少帧画面！一般来说在30帧左右的情况下，人眼是看不出画面有拖影的现象，所以没有特殊要求可以设置30帧；但是帧率也和我们画面的宽高尺寸有关，如果宽高尺寸太大有可能导
android camera详解
a5566255的专栏
03-26 3157
Android Camera原理之编译Android Camera原理之camera provider启动Android Camera原理之cameraserver与cameraprovider是怎样联系的Android Camera原理之camera service与camera provider session会话与capture request轮转Android Camera原理之camera HAL底层数据结构与类总结Android Camera原理之camera service类与接口关系。
Android Camera Metadata
run068的博客
05-24 2631
Android Camera metadata 原理
Android Camera API2架构
最新发布
hirezy
04-14 1249
Camera API 2 （下面用Camera2简称）是最新的 Android 相机框架 API，它取代了已弃用的相机框架库（Camera API 1）。Camera2 为复杂的用例提供深入的控制，但需要用户管理特定于设备的配置。用户可以在相应的参考文档中了解 Camera2 中的特定类和函数。总体上Camera遵循Client-Server架构，通过Binder通讯完成Camera APP -> Camera API2 -> CameraService -> Camera Hal流程。
android camera client、CameraService及camera hal调用流程
kk3087961的博客
02-02 3569
这里的 hardware::camera::provider::V2_4::ICameraProvider 对应 android.hardware.camera.provider@2.4 .so模块，CameraProvider就是与HAL层so的交互。因为 Camera 也继承 ::android::hardware::BnCameraClient 所以可以将 Camera 赋值给 TCamCallbacks（即 TCam为::android::hardware::ICameraClient）
Android Camera app开发
weixin_47225948的博客
09-15 1278
Android Camera app开发
Android Camera压力测试工具
hongyeying的专栏
01-02 1613
背景描述：随着系统的复杂化和业务的积累，日常的功能性测试已不足以满足我们对Android Camera相机系统的测试需求。为了确保Android Camera系统在高负载和多任务情况下的稳定性和性能优化，需要对Android Camera应用进行全面的压测。对于压力测试，之前虽然有接触，但只是使用工具跑测，然后分析日志，解决问题。现在需要自己根据要测试的场景来确定使用什么压测工具-》压测工具怎么使用-》跑一次压测-》一次压测结果-》结果分析，确定问题-》跑一次压测。
Android Camera2 Demo - 实现相机预览、拍照、录制视频功能
06-28
因为工作中要使用 Android Camera2 API 来实现相机功能，但因为Camera2比较复杂，网上资料也比较乱，有一定入门门槛，所以花了几天时间系统研究了下，这个项目就是我研究的成果。 其中包括一个自己写的Camera2的Demo...
Android Camera1 Demo - 实现预览、拍照、录制视频功能
09-15
由于工作中需要用到Camera1，所以花了两天时间研究了以下，使用Android Camera1 API实现了相机预览、拍照和录制视频的功能。 资源中有个MyCamera1Demo.apk可以直接安装运行，MyCamera1Demo.zip是Demo源码。 具体详见...
Android Camera开发入门代码，包含Camera1、Camera2、cameraX和UVC Camera
09-05
专栏主要记录Camera开发相关内容，包含Camera、Camera2、CameraX以及USB（UVC）摄像头。 和大家一起快速入门Camera开发工作，为后期的视频编解码、拍照、录像、推流等打好基础工作。
android Camera2 + zxing进行二维码解码
09-24
网上很多关于zxing的相关资源，但基本都是调用的camera或camerax进行集成的，由于摄像头原因，camera原生api又无法进行对焦，camerax在系统源码中又不是很方便导入到编译脚本，故使用了camera2进行集成。 关键代码...
Android任务栏的图标显示
自我学习 自我整理
04-06 874
package com.Example4; import android.app.Activity; import android.app.Notification; import android.app.NotificationManager; import android.app.PendingIntent; import android.content.Context; im...
Uri转换为File地址
自我学习 自我整理
02-20 594
  Uri uri = data.getData(); String[] proj = { MediaStore.Images.Media.DATA }; Cursor actualimagecursor = managedQuery(uri,proj,null,null,null); int actual_image_column_index = actualimagecur...
Android 控件随意拖动
自我学习 自我整理
04-06 589
package com.oppo.examples; import android.app.Activity; import android.os.Bundle; import android.util.DisplayMetrics; import android.util.Log; import android.view.MotionEvent; import android.v...
Android Camera中参数设置
自我学习 自我整理
01-05 493
  parameter.set("jpeg-quality", 30);     List&lt;Size&gt; psizelist = parameter.getSupportedPictureSizes(); if (null != psizelist &amp;&amp; 0 &lt; psizelist.size()) { int heights[] = new i...
Android实现左右滑动页面
自我学习 自我整理
04-06 490
public class TestHD extends Activity implements OnGestureListener, OnDoubleTapListener   @Override public boolean onFling(MotionEvent e1, MotionEvent e2, float velocityX, float velocityY) ...
Android Camera系统架构解析
"Android Camera系统分析涉及Camera架构、进程间通讯Binder机制、库文件及关键类的介绍。" 在Android系统中，Camera功能的实现是一个复杂而精细的过程，它包括了取景预览和拍照两大核心任务。Android Camera的架构...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值