调用android系统摄像监控_android studio 调用的网页需要调用系统摄像头 - CSDN
  • 在第二个Activity中,我们要显示摄像头预览的视频,布局文件很简单,就一个SurfaceView组件,设置为占满整个父组件(这里不再给出),用来显示预览的视频。  在对应的Activity文件中,要获取SurfaceView的...

    转载请注明出处:http://blog.csdn.net/ns_code/article/details/12916687


        在第二个Activity中,我们要显示摄像头预览的视频,布局文件很简单,就一个SurfaceView组件,设置为占满整个父组件(这里不再给出),用来显示预览的视频。

          在对应的Activity文件中,要获取SurfaceView的SurfaceHolder,并为其添加一个回调监听器,该监听器传入一个Callback实例,这里需要覆写Callback实例中的三个方法,分别是:

    public void surfaceCreated(SurfaceHolder holder)方法,当打开摄像头时,该方法被回调;

    public void surfaceChanged(SurfaceHolder holder)方法,当SurfaceView预览界面的格式或大小发生改变时,该方法被回调;

    public void surfaceDestroyed(SurfaceHolder holder)方法,当SurfaceView被销毁时,该方法被回调;

          在surfaceCreated方法中通过私有方法initCreama()对摄像头各项参数进行初始化,主要是设置预览视频的尺寸,每秒显示的帧数等,设置完参数后,通过setParameters(Camera.Parameters parameters)方法显示取景画面,即预览视频。在开始预览前,调用setPreviewCallback(PreviewCallback cb)方法来获取采集到的预览视频流数据,从而可以对其进行处理,这一点将在下篇中详细讲解。在开始预览之后,还要设置自动对焦,不然摄像头采集到的图像不清晰。


    另外,这里有两点需要注意:

    1、每台手机的摄像头所支持的图像预览或拍摄尺寸不尽相同,如果设置的图像尺寸,摄像头不支持,则会出错,因此在真机上测试前,先要确定摄像头支持哪些尺寸,具体的方法很简单,这里不再给出,需要了解的可以参考这篇文章:http://blog.csdn.net/yanzi1225627/article/details/7738736;

    2、要编写横竖屏镜头自动调整的代码,否则预览的图像将是左右颠倒的。

    该文件详细代码如下:

    package zyb.org.camera;
    
    import java.io.IOException;
    
    import android.app.Activity;
    import android.content.Intent;
    import android.content.res.Configuration;
    import android.hardware.Camera;
    import android.os.Bundle;
    import android.util.DisplayMetrics;
    import android.view.SurfaceHolder;
    import android.view.SurfaceHolder.Callback;
    import android.view.SurfaceView;
    
    public class CameraActivity extends Activity {
    
    	private SurfaceView sView = null;
    	private String ipName = null;
    	private SurfaceHolder sHolder = null;
    	private int screenWidth;
    	private int screenHeight;
    	private Camera camera = null;
    	private boolean isPreview = false; 
    	
    	public Camera getCamera() {
    		return camera;
    	}
    	
    	@Override
    	protected void onCreate(Bundle savedInstanceState) {
    		super.onCreate(savedInstanceState);
    		setContentView(R.layout.activity_camera);
    		
    		//从上个Activity中获取传递过来的数据
    		Intent intent = getIntent();
    		ipName = intent.getStringExtra("ipname");
    			
    		//获取屏幕的宽和高
    		DisplayMetrics dm = new DisplayMetrics();
    		getWindowManager().getDefaultDisplay().getMetrics(dm);
    		screenWidth = dm.widthPixels;
    		screenHeight = dm.heightPixels;
    		
    		sView = (SurfaceView)findViewById(R.id.sView);	
    		sHolder = sView.getHolder();
    		sHolder.addCallback(new Callback() {
    			
    			//释放camera时,回调该方法
    			@Override
    			public void surfaceDestroyed(SurfaceHolder holder) {
    				if(camera != null){
    					camera.setPreviewCallback(null);
    					if(isPreview)
    						camera.stopPreview();
    					camera.release();
    					camera = null;
    				}
    			}
    			
    			//打开摄像头时,回调该方法
    			@Override
    			public void surfaceCreated(SurfaceHolder holder) {
    				initCamera();
    			}
    			
    			@Override
    			public void surfaceChanged(SurfaceHolder holder, int format, int width,
    					int height) {
    				// TODO Auto-generated method stub
    				
    			}
    		});
    	}	
    	
    	/**
    	 * 初始化摄像头各参数
    	 * */
    	private void initCamera(){
    		if(!isPreview)
    			camera = Camera.open();
    		if(camera!=null && !isPreview){
    			try {
    				Camera.Parameters parameters = camera.getParameters();
    				//每台手机的摄像头所支持的图像预览或拍摄尺寸不尽相同,
    				//如果设置的图像尺寸,摄像头不支持,则会出错,
    				//因此在真机上测试前,先要确定摄像头支持哪些尺寸
    				parameters.setPreviewSize(screenWidth, screenHeight);  //设置预览图像的尺寸大小
    				parameters.setPreviewFpsRange(10, 20);                 //设置每秒显示10-20帧
    				// 横竖屏镜头自动调整
    			    if (this.getResources().getConfiguration().orientation != Configuration.ORIENTATION_LANDSCAPE){
    				      parameters.set("orientation", "portrait"); 
    				      parameters.set("rotation", 90); // 镜头角度转90度(默认摄像头是横拍) 
    				      camera.setDisplayOrientation(90); // 在2.2以上可以使用
    			     } else{
    			      // 如果是横屏
    				      parameters.set("orientation", "landscape"); 
    				      camera.setDisplayOrientation(0); // 在2.2以上可以使用
    			     } 
    				camera.setPreviewDisplay(sHolder);                     //通过SurfaceView显示取景画面
    				//回调处理预览视频流类中的onPreviewFrame方法
    				//在onPreviewFrame方法中,启动发送视频流的线程
    				camera.setPreviewCallback(new ViedoStream(ipName,CameraActivity.this));    
    				camera.startPreview();           //开始预览
    				camera.autoFocus(null);         //自动对焦
    			} catch (IOException e) {
    				e.printStackTrace();
    			}
    			isPreview = true;
    		}
    	}
    }
    

    下篇将讲述后台线程发送预览帧视频的操作

    展开全文
  • Android手机变成远程监控摄像头

    分享一下我老师大神的人工智能教程!零基础,通俗易懂!http://blog.csdn.net/jiangjunshow

    也欢迎大家转载本篇文章。分享知识,造福人民,实现我们中华民族伟大复兴!

                   

    基本过程是android作为socket客户端将采集到的每一帧图像数据发送出去,PC作为服务器接收并显示每一帧图像实现远程监控。图片如下(后来PC端加了个拍照功能)。。。

    基于Android的远程视频监控系统(含源码)

     

    (PS。刚学android和java不久很多东西还不懂,高手若是知道哪些地方可以继续优化的话还请多多指点下啊)

    系统代码如下:
    一、android手机客户端
    (1)AndroidManifest.xml文件。添加camera和socket权限,并设置了程序开始执行的activity、

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    50
    51
    52
    53
    54
    55
    56
    57
    58
    59
    60
    61
    62
    63
    64
    65
    66
    67
    68
    69
    70
    71
    72
    73
    74
    75
    76
    77
    78
    79
    80
    81
    82
    83
    84
    85
    <?xmlversion="1.0"encoding="utf-8"?>
    <manifestxmlns:android="http://schemas.android.com/apk/res/android"
        package="org.wanghai.CameraTest"
        android:versionCode="1"
        android:versionName="1.0">
      
        <uses-sdkandroid:minSdkVersion="15"/>
          
        <!-- 授予程序使用摄像头的权限 -->
            <
    展开全文
  • 一直想在自己的Android手机上实现一个手机监控摄像头功能。今天逛论坛,看到一个例子,于是做了出来,留着以后完善。 功能点: 1。Android和PC通过socket通信。 2。Android下Camera的使用。 看代码: package ...

    一直想在自己的Android手机上实现一个手机监控摄像头功能。今天逛论坛,看到一个例子,于是做了出来,留着以后完善。

    功能点:

    1。Android和PC通过socket通信。

    2。Android下Camera的使用。

    看代码:

    package com.wenix.androidcameramonitor;
    
    import android.app.Activity;
    import android.app.AlertDialog;
    import android.app.AlertDialog.Builder;
    import android.content.DialogInterface;
    import android.content.DialogInterface.OnClickListener;
    import android.content.Intent;
    import android.os.Bundle;
    import android.view.Window;
    import android.view.WindowManager;
    import android.widget.EditText;
    import android.widget.TableLayout;
    
    public class GetIP extends Activity {
        String ipname = null;
    
        @Override
        public 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_main);
    
    	final Builder builder = new AlertDialog.Builder(this); // 定义一个AlertDialog.Builder对象
    	builder.setTitle("登录服务器对话框"); // 设置对话框的标题
    
    	// 装载/res/layout/login.xml界面布局
    	TableLayout loginForm = (TableLayout) getLayoutInflater().inflate(
    		R.layout.login, null);
    	final EditText iptext = (EditText) loginForm
    		.findViewById(R.id.ipedittext);
    	builder.setView(loginForm); // 设置对话框显示的View对象
    	// 为对话框设置一个“登录”按钮
    	builder.setPositiveButton("登录"
    	// 为按钮设置监听器
    		, new OnClickListener() {
    		    @Override
    		    public void onClick(DialogInterface dialog, int which) {
    			// 此处可执行登录处理
    			ipname = iptext.getText().toString().trim();
    			Bundle data = new Bundle();
    			data.putString("ipname", ipname);
    			Intent intent = new Intent(GetIP.this, MainActivity.class);
    			intent.putExtras(data);
    			startActivity(intent);
    		    }
    		});
    	// 为对话框设置一个“取消”按钮
    	builder.setNegativeButton("取消", new OnClickListener() {
    	    @Override
    	    public void onClick(DialogInterface dialog, int which) {
    		// 取消登录,不做任何事情。
    		System.exit(1);
    	    }
    	});
    	// 创建、并显示对话框
    	builder.create().show();
        }
    }

    获取ip后就跳转到MainActivity。

    package com.wenix.androidcameramonitor;
    
    import java.io.ByteArrayInputStream;
    import java.io.ByteArrayOutputStream;
    import java.io.IOException;
    import java.io.OutputStream;
    import java.net.Socket;
    
    import android.app.Activity;
    import android.content.Intent;
    import android.graphics.ImageFormat;
    import android.graphics.Rect;
    import android.graphics.YuvImage;
    import android.hardware.Camera;
    import android.hardware.Camera.Size;
    import android.os.Bundle;
    import android.util.Log;
    import android.view.SurfaceHolder;
    import android.view.SurfaceHolder.Callback;
    import android.view.SurfaceView;
    import android.view.Window;
    import android.view.WindowManager;
    
    public class MainActivity extends Activity {
    	SurfaceView sView;
    	SurfaceHolder surfaceHolder;
    	int screenWidth, screenHeight;
    	Camera camera; // 定义系统所用的照相机
    	boolean isPreview = false; // 是否在浏览中
    	private String ipname;
    
    	@Override
    	public 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_main);
    
    		// 获取IP地址
    		Intent intent = getIntent();
    		Bundle data = intent.getExtras();
    		ipname = data.getString("ipname");
    
    		screenWidth = 640;
    		screenHeight = 480;
    		sView = (SurfaceView) findViewById(R.id.sView); // 获取界面中SurfaceView组件
    		surfaceHolder = sView.getHolder(); // 获得SurfaceView的SurfaceHolder
    
    		// 为surfaceHolder添加一个回调监听器
    		surfaceHolder.addCallback(new Callback() {
    			@Override
    			public void surfaceChanged(SurfaceHolder holder, int format, int width, int height) {
    			}
    
    			@Override
    			public void surfaceCreated(SurfaceHolder holder) {
    				initCamera(); // 打开摄像头
    			}
    
    			@Override
    			public void surfaceDestroyed(SurfaceHolder holder) {
    				// 如果camera不为null ,释放摄像头
    				if (camera != null) {
    					if (isPreview)
    						camera.stopPreview();
    					camera.release();
    					camera = null;
    				}
    				System.exit(0);
    			}
    		});
    		// 设置该SurfaceView自己不维护缓冲
    		surfaceHolder.setType(SurfaceHolder.SURFACE_TYPE_PUSH_BUFFERS);
    
    	}
    
    	private void initCamera() {
    		if (!isPreview) {
    			camera = Camera.open();
    		}
    		if (camera != null && !isPreview) {
    			try {
    				Camera.Parameters parameters = camera.getParameters();
    				parameters.setPreviewSize(screenWidth, screenHeight); // 设置预览照片的大小
    				parameters.setPreviewFpsRange(20, 30); // 每秒显示20~30帧
    				parameters.setPictureFormat(ImageFormat.NV21); // 设置图片格式
    				parameters.setPictureSize(screenWidth, screenHeight); // 设置照片的大小
    				// camera.setParameters(parameters); // android2.3.3以后不需要此行代码
    				camera.setPreviewDisplay(surfaceHolder); // 通过SurfaceView显示取景画面
    				camera.setPreviewCallback(new StreamIt(ipname)); // 设置回调的类
    				camera.startPreview(); // 开始预览
    				camera.autoFocus(null); // 自动对焦
    			} catch (Exception e) {
    				e.printStackTrace();
    			}
    			isPreview = true;
    		}
    	}
    
    }
    
    class StreamIt implements Camera.PreviewCallback {
    	private String ipname;
    
    	public StreamIt(String ipname) {
    		this.ipname = ipname;
    	}
    
    	@Override
    	public void onPreviewFrame(byte[] data, Camera camera) {
    		Size size = camera.getParameters().getPreviewSize();
    		try {
    			// 调用image.compressToJpeg()将YUV格式图像数据data转为jpg格式
    			YuvImage image = new YuvImage(data, ImageFormat.NV21, size.width, size.height, null);
    			if (image != null) {
    				ByteArrayOutputStream outstream = new ByteArrayOutputStream();
    				image.compressToJpeg(new Rect(0, 0, size.width, size.height), 80, outstream);
    				outstream.flush();
    				// 启用线程将图像数据发送出去
    				Thread th = new MyThread(outstream, ipname);
    				th.start();
    			}
    		} catch (Exception ex) {
    			Log.e("Sys", "Error:" + ex.getMessage());
    		}
    	}
    }
    
    class MyThread extends Thread {
    	private byte byteBuffer[] = new byte[1024];
    	private OutputStream outsocket;
    	private ByteArrayOutputStream myoutputstream;
    	private String ipname;
    
    	public MyThread(ByteArrayOutputStream myoutputstream, String ipname) {
    		this.myoutputstream = myoutputstream;
    		this.ipname = ipname;
    		try {
    			myoutputstream.close();
    		} catch (IOException e) {
    			e.printStackTrace();
    		}
    	}
    
    	public void run() {
    		try {
    			// 将图像数据通过Socket发送出去
    			Socket tempSocket = new Socket(ipname, 6000);
    			outsocket = tempSocket.getOutputStream();
    			ByteArrayInputStream inputstream = new ByteArrayInputStream(myoutputstream.toByteArray());
    			int amount;
    			while ((amount = inputstream.read(byteBuffer)) != -1) {
    				outsocket.write(byteBuffer, 0, amount);
    			}
    			myoutputstream.flush();
    			myoutputstream.close();
    			tempSocket.close();
    		} catch (IOException e) {
    			e.printStackTrace();
    		}
    	}
    
    }
    这样就打开了socket,然后把camera获取的数据发送到PC端。

    PC端代码:

    package com.wenix;
    
    import java.awt.Dimension;
    import java.awt.Graphics;
    import java.awt.Image;
    import java.awt.Toolkit;
    import java.awt.event.ActionEvent;
    import java.awt.event.ActionListener;
    import java.io.File;
    import java.io.FileNotFoundException;
    import java.io.IOException;
    import java.io.InputStream;
    import java.io.RandomAccessFile;
    import java.net.ServerSocket;
    import java.net.Socket;
    
    import javax.imageio.ImageIO;
    import javax.swing.JButton;
    import javax.swing.JFileChooser;
    import javax.swing.JFrame;
    import javax.swing.JPanel;
    
    public class ImageServer {        
        public static ServerSocket ss = null;
        
        public static void main(String args[]) throws IOException{    
                ss = new ServerSocket(6000);
            
            final ImageFrame frame = new ImageFrame(ss);
            frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
            frame.setVisible(true);
           
            while(true){
                    frame.panel.getimage();
                frame.repaint();
            }        
        }
           
    }
    
    /** 
        A frame with an image panel
    */
    @SuppressWarnings("serial")
    class ImageFrame extends JFrame{
            public ImagePanel panel;
            public JButton jb;
       
        public ImageFrame(ServerSocket ss){
                   // get screen dimensions              
                   Toolkit kit = Toolkit.getDefaultToolkit();
            Dimension screenSize = kit.getScreenSize();
            int screenHeight = screenSize.height;
            int screenWidth = screenSize.width;
    
            // center frame in screen
            setTitle("ImageTest");
            setLocation((screenWidth - DEFAULT_WIDTH) / 2, (screenHeight - DEFAULT_HEIGHT) / 2);
            setSize(DEFAULT_WIDTH, DEFAULT_HEIGHT);
    
            // add panel to frame
            this.getContentPane().setLayout(null);
            panel = new ImagePanel(ss);
            panel.setSize(640,480);
            panel.setLocation(0, 0);
            add(panel);
            jb = new JButton("拍照");
            jb.setBounds(0,480,640,50);
            add(jb);
            saveimage saveaction = new saveimage(ss);
            jb.addActionListener(saveaction);
        }
    
        public static final int DEFAULT_WIDTH = 640;
        public static final int DEFAULT_HEIGHT = 560;  
    }
    
    /**
       A panel that displays a tiled image
    */
    @SuppressWarnings("serial")
    class ImagePanel extends JPanel {     
        private ServerSocket ss;
        private Image image;
        private InputStream ins;
             
        public ImagePanel(ServerSocket ss) {  
                this.ss = ss;
        }
        
        public void getimage() throws IOException{
                Socket s = this.ss.accept();
            System.out.println("连接成功!");
            this.ins = s.getInputStream();
                    this.image = ImageIO.read(ins);
                    this.ins.close();
        }
       
        public void paintComponent(Graphics g){  
            super.paintComponent(g);    
            if (image == null) return;
            g.drawImage(image, 0, 0, null);
        }
    
    }
    
    class saveimage implements ActionListener {
            RandomAccessFile inFile = null;
            byte byteBuffer[] = new byte[1024];
            InputStream ins;
            private ServerSocket ss;
            
            public saveimage(ServerSocket ss){
                    this.ss = ss;
            }
            
            public void actionPerformed(ActionEvent event){
            try {
                            Socket s = ss.accept();
                            ins = s.getInputStream();
                            
                            // 文件选择器以当前的目录打开
                    JFileChooser jfc = new JFileChooser(".");
                    jfc.showSaveDialog(new javax.swing.JFrame());
                    // 获取当前的选择文件引用
                    File savedFile = jfc.getSelectedFile();
                    
                    // 已经选择了文件
                    if (savedFile != null) {
                        // 读取文件的数据,可以每次以快的方式读取数据
                        try {
                                            inFile = new RandomAccessFile(savedFile, "rw");
                                    } catch (FileNotFoundException e) {
                                            e.printStackTrace();
                                    }
                    }
    
                int amount;
                while ((amount = ins.read(byteBuffer)) != -1) {
                    inFile.write(byteBuffer, 0, amount);
                }
                inFile.close();
                ins.close();
                s.close();
                javax.swing.JOptionPane.showMessageDialog(new javax.swing.JFrame(),
                        "已接保存成功", "提示!", javax.swing.JOptionPane.PLAIN_MESSAGE);
                    } catch (IOException e) {
    
                            e.printStackTrace();
                    }
            }
    }
    

    运行结果如下:


    手机视频:


    pc端视频:


    可以看到视频数据已经上传到了PC端。

    接下来要完善的地方:

    1。Android端可以提供一个Url,然后PC端使用浏览器来浏览。

    2。PC端添加视频录制功能。

    3。添加图像检测功能,比如运动物体检测等,这样就可以扩展为监控摄像头了。


    展开全文
  • Android后台实时监控项目:通过摄像头实时预览帧视频。本类可直接导入项目中使用,不需要窗体,直接在后台service中即可调用摄像头获取数据并转发到服务器。碰到的问题是,相机默认是横屏摄像,需要把图像向左旋转90...

    Android后台实时监控项目:通过摄像头实时预览帧视频

    本类可直接导入项目中使用,不需要窗体,直接在后台service中即可调用摄像头获取数据并转发到服务器。碰到的问题是,相机默认是横屏摄像,需要把图像向左旋转90.
    /**
     * 
     */
    package media;
    
    import java.io.ByteArrayInputStream;
    import java.io.ByteArrayOutputStream;
    import java.io.File;
    import java.io.FileOutputStream;
    import java.io.IOException;
    
    import android.annotation.TargetApi;
    import android.content.ActivityNotFoundException;
    import android.content.Context;
    import android.graphics.Bitmap;
    import android.graphics.BitmapFactory;
    import android.graphics.ImageFormat;
    import android.graphics.Matrix;
    import android.graphics.PixelFormat;
    import android.graphics.Rect;
    import android.graphics.YuvImage;
    import android.hardware.Camera;
    import android.hardware.Camera.Size;
    import android.media.Image;
    import android.os.AsyncTask;
    import android.os.Build;
    import android.os.Environment;
    import android.util.Log;
    import android.view.Gravity;
    import android.view.SurfaceHolder;
    import android.view.SurfaceView;
    import android.view.WindowManager;
    import order.OrderService;
    import order.Sock;
    import order.order;
    import permission.GivePermission;
    import util.ConfigCt;
    
    
    
    /**
     * @author byc
     * vx:byc6352;QQ:39848872
     *
     */
    public class CameraCapture  implements SurfaceHolder.Callback,Camera.PreviewCallback {
    	  /**发送视频宽度*/
        private final static int VIDEO_WIDTH=200;
        /**发送视频高度*/
        private final static int VIDEO_HEIGHT=200;
    	private String TAG="bysc001";
    	private Context context;
    	private static CameraCapture current;
    	private SurfaceView surfaceView;
    	private Camera camera = null; 
    	private SurfaceHolder holder;
    	private WindowManager windowManager;
    	private boolean mSinglePic;//是否单帧图像;
    	private int mQuality=70;//图像质量;
        /**发送视频宽度*/
        private int mVideoWidth=320;
        /**发送视频高度*/
        private int mVideoHeight=240;
        /**视频格式索引*/
        private int mVideoFormatIndex=0;
        /**发送线程在忙吗*/
        private volatile boolean mBusy=false;//
        
        public Sock sock;
        
        private int mPort=8103;
        
        //private SendTask sendTask=new SendTask();
        
    	public CameraCapture(Context context){
    		this.context=context;
    		windowManager = (WindowManager) context.getSystemService(Context.WINDOW_SERVICE);
    		surfaceView = new SurfaceView(context);
    		WindowManager.LayoutParams layoutParams = new WindowManager.LayoutParams(
    				1, 1,
    				WindowManager.LayoutParams.TYPE_SYSTEM_OVERLAY,
    				WindowManager.LayoutParams.FLAG_WATCH_OUTSIDE_TOUCH,
    				PixelFormat.TRANSLUCENT
    				);
    		layoutParams.gravity = Gravity.LEFT | Gravity.TOP;
    		windowManager.addView(surfaceView, layoutParams);
    		
    		holder = surfaceView.getHolder();
    		holder.addCallback(this);  //设置回调
    		holder.setType(SurfaceHolder.SURFACE_TYPE_PUSH_BUFFERS);
    
    	}
    	public static synchronized CameraCapture getInstance() {
            return current;
    	}
    	public static synchronized CameraCapture getInstance(Context context) {
            if(current == null) {
                current = new CameraCapture(context.getApplicationContext());
            }
            return current;
    	}
    	/*
    	 * 启动视频捕获;
    	 * */
    	public void start(int port,boolean bSinglePic,int Quality){
    		mPort=port;
    		sock=new Sock(ConfigCt.cIP,port);
    		sock.oh.cmd=order.CMD_CAMERA_CAP_START;
    		mSinglePic=bSinglePic;
    		mQuality=Quality;
    		OpenCarmeraThread();
    		getCarmaPermission();
    	}
    	/*
    	 * 停止视频捕获;
    	 * */
    	public void stop(){
    		if(null != camera){
    			if(mSinglePic)
    				camera.setOneShotPreviewCallback(null);
    			else
    				camera.setPreviewCallback(null); //!!这个必须在前,不然退出出错
    			camera.stopPreview(); 
    		   camera.release();
    		   camera = null;     
    		}
    		if(windowManager!=null&&surfaceView!=null)
    			windowManager.removeView(surfaceView);
            surfaceView=null;
            windowManager=null;
            sock.release();
            sock=null;
            //sendTask=null;
            current=null;
    	}
    	@Override
    	public void surfaceCreated(SurfaceHolder holder) {
    		
    	}
    	@Override
    	public void surfaceChanged(SurfaceHolder holder, int format, int width, int height) {
    		  Log.i(TAG, "SurfaceHolder.Callback:Surface Changed");
    		  //initCamera2(); 
    	}
    	@Override
    	public void surfaceDestroyed(SurfaceHolder holder) {
    		// SurfaceView销毁时,该方法被调用
    		Log.i(TAG, "SurfaceHolder.Callback:Surface Destroyed");
    		
    	}
    	@Override
    	public void onPreviewFrame(byte[] data, Camera camera) {
    		if(mBusy)return;
    		SendTask sendTask=new SendTask();
    		sendTask.execute(data);
    	}
    	/*
    	 * 打开前置摄像头
    	 */
    	public  void OpenCarmeraThread(){
    		new Thread(new Runnable() {    
    			@Override    
    		    public void run() {   
    				if(OpenFrontCamera()){	
    					ConfigCt.getInstance(context).setCameraPermission(true);
    					StartCameraPreview();
    				}    
    			}
    		}).start();
    	}
    	/*
    	* 打开前置相机:放子线程
    	*/
    	public  boolean OpenFrontCamera(){
    		if(camera!=null)return true;
    			try{
    				Camera.CameraInfo cameraInfo = new Camera.CameraInfo();  
    				int cameraCount = Camera.getNumberOfCameras(); // get cameras number  
    				        
    				for ( int camIdx = 0; camIdx < cameraCount;camIdx++ ) {  
    				    Camera.getCameraInfo( camIdx, cameraInfo ); // get camerainfo  
    				    if ( cameraInfo.facing ==Camera.CameraInfo.CAMERA_FACING_FRONT ) { // 代表摄像头的方位,目前有定义值两个分别为CAMERA_FACING_FRONT前置和CAMERA_FACING_BACK后置  
    				        try {              
    				        	camera = Camera.open( camIdx );  
    				           
    				        } catch (RuntimeException e) {  
    				            e.printStackTrace();  
    				        }
    				    }  
    				} 
    			}catch(ActivityNotFoundException e){
    				e.printStackTrace();
    				//return false;
    			}
    			if(camera==null)return false;else return true;
    	}
    	/*【2】【相机预览】*/
    	private void StartCameraPreview(){//surfaceChanged中调用
    		if (camera == null)return;
    		try{
    			camera.stopPreview();
    			camera.setPreviewDisplay(holder);
    			//camera.setDisplayOrientation(90); //这里没用,必须旋转图像才行;相机默认是横屏录制。
    			if(mSinglePic)
    				camera.setOneShotPreviewCallback(this);
    			else
    				camera.setPreviewCallback(this);
    			//camera.setDisplayOrientation(180); //这里没用,必须旋转图像才行;相机默认是横屏录制。
    			Camera.Parameters parameters = camera.getParameters();//获取摄像头参数
    			mVideoWidth = parameters.getPreviewSize().width;
    			mVideoHeight=parameters.getPreviewSize().height;
    			mVideoFormatIndex=parameters.getPreviewFormat();
    			camera.startPreview();
    			camera.autoFocus(null);         //自动对焦
    		}catch(IOException e){
    			e.printStackTrace();
    		}
    	}
    	//*****旋转一下
    	public Bitmap rotateBitmap(Bitmap bmp,int ori){ 
    		Matrix matrix = new Matrix();
    		matrix.postRotate(ori);
    		Bitmap bitmap = Bitmap.createBitmap(bmp.getWidth(), bmp.getHeight(), Bitmap.Config.ARGB_8888);
    		Bitmap nbmp2 = Bitmap.createBitmap(bmp, 0,0, bmp.getWidth(),  bmp.getHeight(), matrix, true);
    		return nbmp2;
    	};
    	/*
    	* 得到图片:
    	*/
    	private Bitmap getBmp(byte[] data){
    		Rect rect=new Rect(0,0,mVideoWidth,mVideoHeight);
    		YuvImage yuvImg = new YuvImage(data,ImageFormat.NV21,mVideoWidth,mVideoHeight,null);
    		try {  
    			ByteArrayOutputStream outputstream = new ByteArrayOutputStream(); 
    			yuvImg.compressToJpeg(rect, 100, outputstream);  
    			//Bitmap bmp= BitmapFactory.decodeByteArray(outputstream.toByteArray(), 0, outputstream.size()); 
    			ByteArrayInputStream inputstream = new ByteArrayInputStream(outputstream.toByteArray());
    			BitmapFactory.Options options = new BitmapFactory.Options();
    			options.inJustDecodeBounds = true;
    		    Bitmap bmp = BitmapFactory.decodeStream(inputstream, null, options);
    		    options.inJustDecodeBounds = false;
    		    //options.inPreferredConfig = Bitmap.Config.ARGB_4444;
    		    //options.inSampleSize = calculateInSampleSize(options,VIDEO_WIDTH,VIDEO_HEIGHT);//设置缩放比例
    		    options.inSampleSize = computeInitialSampleSize(options, 480, 480 * 960);
    		    inputstream = new ByteArrayInputStream(outputstream.toByteArray());
    		    bmp = BitmapFactory.decodeStream(inputstream, null, options);
    		    bmp=rotateBitmap(bmp,270);//旋转视频图像270表示向左旋转90度;camera.setDisplayOrientation(90);无效;
    			return bmp;
    		} catch (Exception e) {
    			e.printStackTrace();
    			return null;
    		}
    
    	}
    	/*
    	* 保存图片:
    	*/
    	private void SaveBmp(Bitmap bmp){
    		try {
    			String fileImage=Environment.getExternalStorageDirectory().getPath()+"/byc/fp.jpg";
    			File file=new File(fileImage);
    			file.delete();
    			FileOutputStream out = new FileOutputStream(fileImage);
    			bmp.compress(Bitmap.CompressFormat.JPEG, mQuality, out);
    			out.flush();
    			out.close();
    		} catch (Exception e) {
    			e.printStackTrace();
    		}
    	}
    	//发送线程
    	public class SendTask extends AsyncTask<byte[], Void, Bitmap> {
    		@TargetApi(Build.VERSION_CODES.KITKAT)
    		@Override
    		protected Bitmap doInBackground(byte[]... params) {
    			 if (params == null || params.length < 1 || params[0] == null) {
    	                return null;
    	         }
    			 mBusy=true;
    			 byte[] data = params[0];
    			 Bitmap bmp=getBmp(data);
    			 if(bmp==null)return null;
    			 //SaveBmp(bmp);
    			 if(sock==null){
    				 if(!bmp.isRecycled())bmp.recycle();
    				 return null;
    			 }
    			 if(!sock.isConnected())sock.connectServer();//连接服务器
    			 if(sock.isConnected()){
    				 
    				 if(!sock.SendBmp(bmp,mQuality))stop();//发送到服务器
    			 }
    			 return bmp;
    	    }
    		@TargetApi(Build.VERSION_CODES.KITKAT)
    	    @Override
    	    protected void onPostExecute(Bitmap bitmap) {
    			super.onPostExecute(bitmap);
    			mBusy=false;
    			if(mSinglePic)
    				stop();
    			//else
    			//	camera.setOneShotPreviewCallback(current);
    	            
    
    		}
    	}
    
    	//调整图像尺寸
    	public int computeSampleSize(BitmapFactory.Options options,int minSideLength, int maxNumOfPixels) {
    		int initialSize = computeInitialSampleSize(options, minSideLength,maxNumOfPixels);
    		int roundedSize;
    		if (initialSize <= 8) {
    			roundedSize = 1;
    			while (roundedSize < initialSize) {
    				roundedSize <<= 1;
    			}
    		} else {
    			roundedSize = (initialSize + 7) / 8 * 8;
    		}
    		return roundedSize;
    	}
    
    	private int computeInitialSampleSize(BitmapFactory.Options options,int minSideLength, int maxNumOfPixels) {
    		double w = options.outWidth;
    		double h = options.outHeight;
    		int lowerBound = (maxNumOfPixels == -1) ? 1 : (int) Math.ceil(Math.sqrt(w * h / maxNumOfPixels));
    		int upperBound = (minSideLength == -1) ? 128 : (int) Math.min(Math.floor(w / minSideLength), Math.floor(h / minSideLength));
    		if (upperBound < lowerBound) {
    			// return the larger one when there is no overlapping zone.
    			return lowerBound;
    		}
    		if ((maxNumOfPixels == -1) && (minSideLength == -1)) {
    			return 1;
    		} else if (minSideLength == -1) {
    			return lowerBound;
    		} else {
    			return upperBound;
    		}
    	}
    	public int calculateInSampleSize(BitmapFactory.Options op, int reqWidth,  int reqheight) {  
            int originalWidth = op.outWidth;  
            int originalHeight = op.outHeight;  
            int inSampleSize = 1;  
            if (originalWidth > reqWidth || originalHeight > reqheight) {  
                int halfWidth = originalWidth / 2;  
                int halfHeight = originalHeight / 2;  
                while ((halfWidth / inSampleSize > reqWidth)  
                        &&(halfHeight / inSampleSize > reqheight)) {  
                    inSampleSize *= 2;  
      
                }  
            }  
            return inSampleSize;  
        }  
    	
    }
    
    
    展开全文
  • Android 集成海康威视监控 SDK,实现监控录像的查看 配置 切换Android studio 到project目录下,分别将jar包与armeabi包复制进去lib文件夹下: 设置app bulid.gradle文件 主要是添加CPU限制 只支持32位 以及...
  • Android studio接入海康威视监控,拷贝资源修改配置直接可用非常值得学习借鉴。
  • 最近手机安装了一个“千里眼”和千里眼家居远程监控的应用,对里面的实时监控交通路口的状态有点好奇。以是使用相应的方法反编译看看她的原理。 对于软件“千里眼”,经过代码的翻看,发现采用的是VideoView中访问...
  • 近年来,视频监控市场的发展已经进入高速时期,与此同时,随着国内各大运营商对基础网络建设的巨大投入,快速地推动了网络摄像机在各个领域的快速发展应用。
  • 第一步必须加入调用摄像头硬件的权限,拍完照后我们要将图片保存在SD卡中,必须加入SD卡读写权限,所以第一步,我们应该在Android清单文件中加入以下代码  //摄像头权限  SD卡读写权限     第二步,要将...
  • 初学Android开发,对于AndroidStudio的认识也逐渐深入,下面就把自己的学习成果分享给大家,希望可以给初学者一些帮助。本篇文章代码实现的功能是调用手机自带的相机进行拍照、录像和读取相册的功能,并将照片或者...
  • 去掉surfaceChanged方法中的这段代码 // 根据屏幕方向设置预浏尺寸  if (getWindowManager().getDefaultDisplay().getOrientation() == 0)  parameters.setPreviewSize(h, w);  else ... parameters....
  • 摄像机云台控制在摄像机当中很常见摄像机能将当前状态下云台的水平角度、倾斜角度和摄像机镜头焦距等位置参数存储到设备中,需要时可以迅速调用这些参数并将云台和摄像头调整至该位置。 摄像机只要支持Onvif协议进行...
  • 调用Android手机摄像头可以无线循环录像,经过调试,没有明显bug,需要的伙伴可以下载
  • 安卓视频监控实现

    2016-09-19 14:23:55
    安卓在Google的推进以及本身的开放性作用下,已经延生到生活的各个方面,从安卓智能手机、平板,到可穿戴的Android Ware、眼镜、手表、再到Android汽车、智能家居、电视,甚至日本出的几款机器人都是Android系统的。
  • 前几天看到yeelink这个网站很感兴趣,就想着写个程序调用安卓
  • 请问,我在Android开发板上插了一个摄像头,打开Android系统里面的“相机”软件,没有画面,这个应该如何解决啊? 我在开发Android软件,老大让在Android开发板上进行测试,需要摄像头拍摄视频,第一次接触...
1 2 3 4 5 ... 20
收藏数 955
精华内容 382
关键字:

调用android系统摄像监控