1、git下载：https://github.com/jiangdongguo/AndroidUSBCamera
 
2、下载后解压，将模块 libusbcamera、libutils集成到自已的项目中，直接拷贝到项目根目录下，相关配置
 
settings.gradle 后添加   , ':libusbcamera', ':libutils'
 
app build.gradle 文件   implementation project(':libusbcamera')
 
project build.gradle 文件   
 
allprojects {
    repositories {
        jcenter()
        google()
        maven { url 'https://jitpack.io' }
        maven { url 'https://raw.githubusercontent.com/saki4510t/libcommon/master/repository/' }

    }
}
 
AndroidManifest.xml 文件开启相关权限
 
    <uses-permission android:name="android.permission.RECORD_AUDIO"/>
    <uses-permission android:name="android.permission.WRITE_EXTERNAL_STORAGE" />
    <uses-permission android:name="android.permission.READ_EXTERNAL_STORAGE" />

    <uses-feature android:name="android.hardware.usb.host"/>
 
项目ndk 要设置上 最后项目async
 
3、MainActivity
 
public class MainActivity extends AppCompatActivity implements CameraViewInterface.Callback {

    private final String TAG = MainActivity.class.getSimpleName();

    public View mTextureView;
    private UVCCameraHelper mCameraHelper;
    private CameraViewInterface mUVCCameraView;

    private boolean isRequest = false;
    private boolean isPreview = false;
    private boolean isRecording = false;
    private UVCCameraHelper.OnMyDevConnectListener listener = new UVCCameraHelper.OnMyDevConnectListener() {

        @Override
        public void onAttachDev(UsbDevice device) {
            // request open permission
            Log.d(TAG, "camera: usb 设备 " + device.getProductName() + " 新连接");
            if (mCameraHelper == null || mCameraHelper.getUsbDeviceCount() == 0) {
                showShortMsg("未检测到USB摄像头设备");
                return;
            }
            List<UsbDevice> devList = mCameraHelper.getUsbDeviceList();
            /*
             * usb连接时，判断是不是这个摄像头，是就打开，实现了热插拔，插拔一次，
             * 设备的id就加一，所以地址就改变，机器重启id初始化,getProductName()获得的是摄像头 
             * 名称 
             * */
            if (!isRequest)
                for (int i = 0; i < devList.size(); i++) {
                    UsbDevice _device = devList.get(i);
                    if (_device.getProductName().indexOf("camera") > -1) {
                        isRequest = true;
                        mCameraHelper.requestPermission(i);//打开usb摄像头
                    }
                }
        }

        @Override
        public void onDettachDev(UsbDevice device) {
            // close camera
            Log.d(TAG, "camera: usb 设备 " + device.getProductName() + " 已拔出");
            if (isRequest) {
                isRequest = false;
                mCameraHelper.closeCamera();
                showShortMsg(device.getProductName() + " 已拨出");
            }
        }

        @Override
        public void onConnectDev(UsbDevice device, boolean isConnected) {
            Log.d(TAG, "camera: usb 设备 " + device.getProductName() + " 连接失败");
            if (!isConnected) {
                showShortMsg("连接失败，请检查分辨率参数是否正确");
                isPreview = false;
            } else {
                isPreview = true;
                showShortMsg("usb 设备正在连接");
                // need to wait UVCCamera initialize over
                Log.d(TAG, "camera is connected");
            }
        }

        @Override
        public void onDisConnectDev(UsbDevice device) {
            Log.d(TAG, "camera: usb disconnecting");
            showShortMsg("usb设备连接断开");
        }
    };

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        mContext = this;
        // step.1 initialize UVCCameraHelper
        mTextureView = findViewById(R.id.camera_view);
        mUVCCameraView = (CameraViewInterface) mTextureView;
        mUVCCameraView.setCallback(this);
        mCameraHelper = UVCCameraHelper.getInstance();
        mCameraHelper.setDefaultFrameFormat(UVCCameraHelper.FRAME_FORMAT_YUYV);
        /*
         * 初始化分辨率，一定是设备支持的分辨率，否则摄像不能正常使用
         * */
        mCameraHelper.setDefaultPreviewSize(640, 480);
        mCameraHelper.initUSBMonitor(this, mUVCCameraView, listener);
        mCameraHelper.setOnPreviewFrameListener(new AbstractUVCCameraHandler.OnPreViewResultListener() {
            int printNum = 0;

            @Override
            public void onPreviewResult(byte[] nv21Yuv) {
                printNum++;
                if (printNum == 300) {
                    printNum = 0;
                    Log.d(TAG, "onPreviewResult: " + nv21Yuv.length + "摄像头预览");
                }

            }
        });
    }

    //录像
    private void cameraRecording(Boolean isStartRecording, String Name) {
        isRecording = isStartRecording;
        if (mCameraHelper == null || !mCameraHelper.isCameraOpened() || !isPreview) {
            showShortMsg("摄像头异常，请重新更换插口并重启app");
            return;
        }
        String OrderRecordStr = prefs.getString(Config.ORDER_RECORDING, "");
        Log.d(TAG, "OrderRecorde1=" + OrderRecordStr);
        if (!mCameraHelper.isPushing() && isStartRecording) {
            //文件地址自已设置
            String videoPath = Config.VIDEO_DIRECTORY + "/ " + Name;
            OrderRecordStr = OrderRecordStr + "&" + Name;
            prefs.edit().putString(Config.ORDER_RECORDING, OrderRecordStr).apply();
            RecordParams params = new RecordParams();
            params.setRecordPath(videoPath);
            params.setRecordDuration(0);                        // auto divide saved,default 0 means not divided
            params.setVoiceClose(true);    // is close voice
            params.setSupportOverlay(true); // overlay only support armeabi-v7a & arm64-v8a
            mCameraHelper.startPusher(params, new AbstractUVCCameraHandler.OnEncodeResultListener() {
                @Override
                public void onEncodeResult(byte[] data, int offset, int length, long timestamp, int type) {
                    // type = 1,h264 video stream
                    if (type == 1) {
                        FileUtils.putFileStream(data, offset, length);
                    }
                    // type = 0,aac audio stream
                    if (type == 0) {

                    }
                }

                @Override
                public void onRecordResult(String videoPath) {
                    if (TextUtils.isEmpty(videoPath)) {
                        return;
                    }
                    new Handler(getMainLooper()).post(() -> Toast.makeText(MainActivity.this, "save videoPath:" + videoPath, Toast.LENGTH_SHORT).show());
                }
            });
            // if you only want to push stream,please call like this
            // mCameraHelper.startPusher(listener);
            showShortMsg("开始录制视频");
        } else if (mCameraHelper.isPushing() && !isStartRecording) {
            FileUtils.releaseFile();
            mCameraHelper.stopPusher();
            showShortMsg("停止录制视频");
            String[] OrderRecordArr = OrderRecordStr.split("&");
            if (OrderRecordArr.length > 5) {
                String order = OrderRecordArr[1];
                String filePath = Config.VIDEO_DIRECTORY + "/ " + order + ".mp4";
                deleteFile(filePath);
                String _OrderRecordStr = "";
                for (int i = 0; i < OrderRecordArr.length; i++) {
                    if (OrderRecordArr[i] != order && OrderRecordArr[i].length() > 0)
                        _OrderRecordStr = _OrderRecordStr + "&" + OrderRecordArr[i];
                }
                prefs.edit().putString(Config.ORDER_RECORDING, _OrderRecordStr).apply();
                Log.d(TAG, "OrderRecorde=" + prefs.getString(Config.ORDER_RECORDING, ""));
            }
        }
    }

    //删除文件
    public boolean deleteFile(String filePath) {
        File file = new File(filePath);
        if (file.isFile() && file.exists()) return file.delete();
        else if (file.isFile() && !file.exists()) return true;
        return false;
    }
    @Override
    public void onResume() {
        super.onResume();
        // 恢复Camera预览
        if (mUVCCameraView != null) mUVCCameraView.onResume();
    }

    @Override
    protected void onStart() {
        super.onStart();
        // step.2 register USB event broadcast
        if (mCameraHelper != null) {
            mCameraHelper.registerUSB();
        }
    }

    @Override
    protected void onStop() {
        super.onStop();
        // step.3 unregister USB event broadcast
        if (mCameraHelper != null) {
            mCameraHelper.unregisterUSB();
        }
    }

    @Override
    protected void onPause() {
        super.onPause();
        
        if (mUVCCameraView != null) mUVCCameraView.onPause();
    }

    private void showShortMsg(String msg) {
        Toast.makeText(this, msg, Toast.LENGTH_SHORT).show();
    }

    @Override
    public USBMonitor getUSBMonitor() {
        return mCameraHelper.getUSBMonitor();
    }

    @Override
    public void onDialogResult(boolean canceled) {

    }

    public boolean isCameraOpened() {
        return mCameraHelper.isCameraOpened();
    }

    @Override
    public void onSurfaceCreated(CameraViewInterface view, Surface surface) {
        isPreview = false;
        new Thread(new Runnable() {
            @Override
            public void run() {
                // wait for camera created
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                Log.d(TAG, "camera: surface start preview " + isPreview + "  " + isCameraOpened());
                if (!isPreview && isCameraOpened()) {
                    mCameraHelper.startPreview(mUVCCameraView);
                    isPreview = true;
                    Log.d(TAG, "camera: surface start preview");
                }
            }
        }).start();
    }

    @Override
    public void onSurfaceChanged(CameraViewInterface view, Surface surface, int width, int height) {

    }

    @Override
    public void onSurfaceDestroy(CameraViewInterface view, Surface surface) {
        if (isPreview && isCameraOpened()) {
            mCameraHelper.stopPreview();
            Log.d(TAG, "surface:" + "is destroy");
        }
        isPreview = false;
    }

    @Override
    protected void onDestroy() {
        super.onDestroy();
        FileUtils.releaseFile();
        // step.4 release uvc camera resources
        if (mCameraHelper != null) {
            mCameraHelper.release();
            Log.d(TAG, "camera is release");
        }
        isPreview = false;
        isRequest = false;
    }

}
 
activity_main.xml      
 
<com.serenegiant.usb.widget.UVCCameraTextureView
    android:id="@+id/camera_view"
    android:layout_width="match_parent"
    android:layout_height="wrap_content"
    android:layout_gravity="center"/>
 
4、需要注意
 
（1）mCameraHelper.requestPermission(int index) 是打开usb设备，有的usb不是摄像头设备，需要对usb设备名称进行过滤，可控制需要打开特定的usb摄像头， 可以热插拔显示
 
（2）app关闭或后台运行  isPreview 需要重置为 false 不然再次进入app 预览无画面因为startPreview 未执行
 
（3）设备重启后第一次打开app, 预览画面可能没有，但实际是可以录制的，重新进入app就可以了

参考资料：http://www.voidcn.com/article/p-ovkdhqsk-yz.html
 
注意：
 
修改launch文件：
 
如果要使用usb相机，则修改value为="/dev/video1"
 
如果要使用笔记本摄像头，则value="/dev/video0"
 
<node name="usb_cam" pkg="usb_cam" type="usb_cam_node" output="screen" >  
    <param name="video_device" value="/dev/video0" />  
 
 

 
Linux下USB Camera的使用
 
查看摄像头usb信息
查看video设备文件
查看camera信息
查看系统能否识别出camera
通过luvcview查看
安装luvcview
查看视频
  
opencv c++读取usb camera数据
参考

 
支持yuv协议的camera通过usb连接上电脑，可进行如下操作：
 
查看摄像头usb信息
 
lsusb
 
Bus 001 Device 007: ID 0c45:130c Microdia
 Bus 001 Device 005: ID 0c45:310a Microdia
 
查看video设备文件
 
进入/dev/下查看是否有video设备文件
 
cd /dev
ls | grep video
 
将会输出类似如下信息：
 video0
 video1
 
查看camera信息
 
udevadm info --query=all --name=/dev/video0
 
将会输出如下信息：
 
 
查看系统能否识别出camera
 
dmesg | grep Cam
dmesg | grep video
 
将会输出如下信息：
 
 
通过luvcview查看
 
安装luvcview
 
从https://launchpad.net/ubuntu/trusty/+package/luvcview下载amd64的luvcview_0.2.6-6_amd64.deb安装包
 
sudo dpkg -i luvcview_0.2.6-6_amd64.deb
 
查看视频
 
luvcview -d /dev/video0 -f yuv -s 640x480
 
opencv c++读取usb camera数据
 
https://github.com/lxuejiao/USBCamera
 
参考
 
https://blog.csdn.net/liwf616/article/details/8784361
 https://launchpad.net/ubuntu/trusty/+package/luvcview

    项目当中要使用ＵＳＢ接口作为系统的图像输入口，即使用ＵＳＢ　ｃａｍｅｒａ进行开发。
 
　首先要介绍的是ＵＶＣ的概念，ｕｖｃ即ＵＳＢ　ｖｉｄｅｏ　ｃｌａｓｓ也即ＵＳＢ　ｖｉｄｅｏ　ｄｅｖｉｃｅ　ｃｌａｓｓ。这个标准的设备是在不需要安装驱动的情况下实现即插即用，包括了摄像头，数字摄影机和模拟视频转换等。在Ｌｉｎｕｘ当中已经对ｕｄｃ　ｃａｍｅｒａ的支持，全志Ｈ３，ｌｉｎｕｘ３．４下，ｕｖｃ相关代码在路径：linux-3.4/drivers/media/video/uvc下，截图：
 

 
 
　然后是简单介绍Ｖ４Ｌ或者Ｖ４Ｌ２的概念，很明显，Ｖ４Ｌ２是前者的改进版本，这是Ｌｉｎｕｘ系统下用于采集图片，音频，视频数据的ＡＰＩ接口，这些ＡＰＩ和对应的视频图像采集设备和对应的驱动程序一起，就能够实现在Ｌｉｎｕｘ平台上面的图像视频等数据的采集。
 
    ＵＳＢ　ｃａｍｅｒａ要能够正常使用就需要上述两个概念的支持，并且要在内核里面做相应的配置工作，在Ｌｉｎｕｘ目录下执行　make menuconfig 进入到内核配置的界面，如下：
 

 
 
　　必要的配置有如下几项，不同的Ｌｉｎｕｘ内核版本，其所在的位置可能不同，要根据选项之间的信息仔细寻找，我之前没有找到，在网络上面参考的又是另外的内核版本，因此找了半天没有发现。从Device Drivers --->Multimedia support 下配置相应选项：
 

 
 
　　然后再进入到Ｖideo capture adapters 下选择ＵＳＢ的相应配置，如图：
 

 
 
　　通过以上配置就能够保证ＵＳＢ　ｃａｍｅｒａ设备的数据能够被处理，重新编译内核，是配置生效。烧录到板子后插入ＵＳＢ　ｃａｍｅｒａ的设备，果然！读取不到数据～～～。板子上面只留出了一个ＵＳＢ接口，也就是ＵＳＢ０口，通过查看官方文档找到ＵＳＢ０口的相应配置文件在路径：/lichee/tools/pack/chips/sun8iw7p1/configs/定方案目录，下面的sys_config.fex，搜索ｕｓｂ０相关配置如下：
 

 
 
    上图为修改过得配置，主要有两个参数要修改，根据官方文档”usb_port_type"值为０则是”device only"，如果是１则是"host only"，如果是２,则是”OTG“，文件当中初始值为２，按理说应该在插入摄像头设备的时候应该能够自动切换到ｈｏｓｔ模式，但现实是没有正确识别ＵＳＢ设备。接着修改的第二个参数是”usb_host_init_state“，这个属性的意思是表示在系统启动后是否要初始化host的驱动（前提条件是上述的参数已经设置设备为host模式了）：０－－－不初始化；１－－－初始化。这个值默认为０，因此显然要修改为１才行。
 
　完成了上述的设置后，保存退出，然后编译内核，编译android，刷机，然后进行测试，USB CAMERA就能够通过系统相机打开了：
 

 
 
　　这次调试相对来说是比较顺利的，虽然中途因为ＵＳＢ　ｈｏｓｔ模式设置不对导致数据没拿到这个小插曲耽误了一些时间，但总的来说都比较顺利，思路也是比较清晰，这要得益于网络上面很多文章的帮助，最主要的有以下这些参考，贴出来希望能够帮到其他人：
 
１，uvc介绍
 
２，Ｖ4L/V4L2介绍
 
３，http://blog.csdn.net/wb4916/article/details/52913954 
 
４，http://blog.csdn.net/wb4916/article/details/53097797
 
５，http://blog.csdn.net/jiangdou88/article/details/24884483
 
６，http://blog.csdn.net/codectq/article/details/44278465
 
７，http://blog.csdn.net/hclydao/article/details/21235919
 
８，http://blog.csdn.net/wb4916/article/details/53161774
 
９，http://blog.csdn.net/zmnqazqaz/article/details/49535531
 
１０，http://blog.csdn.net/it_fish_man/article/details/17395469