jiangdongguo / androidusbcamera

🔥🔥🔥Flexible and useful UVC camera engine on Android platform, supporting multi-road cameras!

androidusbcamera's Issues

AbstractUVCCameraHandler中handleStopRecording方法报错

((CameraViewInterface)this.mWeakCameraView.get()).setVideoEncoder((IVideoEncoder)null);
WeakReference.get()取到的值是null, 建议加上判断

请问能调节分辨率吗

你好，项目非常棒非常感谢。我这边使用时遇到个问题，我是以单反相机作为摄像头的，想请问下如何在软件中设置显示图像的分辨率？

ANR Problem : I/dalvikvm: threadid=3: reacting to signal 3

I copy the sample code to a new empty project and run the app for a while. The USBCamera widget can display the video smoothly but the app will be no response randomly and the logcat will throw ANR message. I am trying to dump the trace.txt log from android and search for threadid=3.

Here is the debug message about threadid=3 :

"Signal Catcher" daemon prio=5 tid=3 RUNNABLE
| group="system" sCount=0 dsCount=0 obj=0x424699b8 self=0x639c08e8
| sysTid=617 nice=0 sched=0/0 cgrp=apps handle=1714186872
| state=R schedstat=( 0 0 0 ) utm=18 stm=29 core=3
at dalvik.system.NativeStart.run(Native Method)

切换了分辨率之后，好像没法立即预览啊，只有重新拔插才行

周期性的录制视频出现闪退

周期性的录制视频出现闪退

android平台电视使用外接usb摄像头也可以用这个库的吧？

gradle4.4 监听器无效

`

import android.app.Activity;
import android.content.Context;
import android.content.ContextWrapper;
import android.hardware.usb.UsbDevice;
import android.view.Surface;
import android.view.View;
import android.widget.Toast;

import com.facebook.react.bridge.ReactContext;
import com.facebook.react.bridge.WritableMap;
import com.facebook.react.uimanager.events.RCTEventEmitter;
import com.jiangdg.usbcamera.UVCCameraHelper;
import com.microscope.util.OpenCVHelper;
import com.serenegiant.usb.CameraDialog;
import com.serenegiant.usb.USBMonitor;
import com.serenegiant.usb.common.AbstractUVCCameraHandler;
import com.serenegiant.usb.widget.CameraViewInterface;
import com.serenegiant.usb.widget.UVCCameraTextureView;

public class USBCameraView extends UVCCameraTextureView implements CameraDialog.CameraDialogParent{
private UVCCameraHelper mCameraHelper;
private OpenCVHelper openCVHelper;
private Context context;

private boolean isRequest;
private boolean isPreview;

public USBCameraView(final Context context) {
    super(context);

    this.init(context);
    this.context = context;

    super.setOnClickListener(new OnClickListener() {
        @Override
        public void onClick(View v) {
            if (context instanceof ReactContext) {
                showShortMsg("mCameraHelper:"+mCameraHelper);
                showShortMsg("isCameraOpened:"+mCameraHelper.isCameraOpened());
                if(mCameraHelper == null || ! mCameraHelper.isCameraOpened()){
                    showShortMsg("抓拍异常，摄像头未开启");
                }
                String picPath = mCameraHelper.ROOT_PATH+System.currentTimeMillis()
                        +mCameraHelper.SUFFIX_JPEG;
                mCameraHelper.capturePicture(picPath, new AbstractUVCCameraHandler.OnCaptureListener() {
                    @Override
                    public void onCaptureResult(String path) {
                        showShortMsg("保存路径："+path);
                        final WritableMap event = openCVHelper.analysis(path);
                        ((ReactContext) context).getJSModule(RCTEventEmitter.class)
                                .receiveEvent(getId(),"onClick", event);
                    }
                });


            }
        }
    });

    this.openCVHelper = new OpenCVHelper();
}


private void init(Context context){
    this.setCallback(new CameraViewInterface.Callback(){
        @Override
        public void onSurfaceCreated(CameraViewInterface view, Surface surface) {
            // must have
            if (!isPreview && mCameraHelper.isCameraOpened()) {
                mCameraHelper.startPreview(view);
                isPreview = true;
            }
        }

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

        }

        @Override
        public void onSurfaceDestroy(CameraViewInterface view, Surface surface) {
            // must have
            if (isPreview && mCameraHelper.isCameraOpened()) {
                mCameraHelper.stopPreview();
                isPreview = false;
            }
        }
    });
    // 初始化引擎

    mCameraHelper = UVCCameraHelper.getInstance();
    mCameraHelper.initUSBMonitor(this.getActivity(context), this, listener);

}

private Activity getActivity(Context context) {
    while (!(context instanceof Activity) && context instanceof ContextWrapper) {
        context = ((ContextWrapper) context).getBaseContext();
    }

    return (Activity) context;
}

private UVCCameraHelper.OnMyDevConnectListener listener = new UVCCameraHelper.OnMyDevConnectListener() {

    @Override
    public void onAttachDev(UsbDevice device) {
        showShortMsg("getUsbDeviceCount:"+mCameraHelper.getUsbDeviceCount());
        if (mCameraHelper == null || mCameraHelper.getUsbDeviceCount() == 0) {
            showShortMsg("check no usb camera");
            return;
        }
        // request open permission
        if (!isRequest) {
            isRequest = true;
            if (mCameraHelper != null) {
                mCameraHelper.requestPermission(0);
            }
        }
    }

    @Override
    public void onDettachDev(UsbDevice device) {
        // close camera
        if (isRequest) {
            isRequest = false;
            mCameraHelper.closeCamera();
            showShortMsg(device.getDeviceName() + " is out");
        }
    }

    @Override
    public void onConnectDev(UsbDevice device, boolean isConnected) {
        if (!isConnected) {
            showShortMsg("fail to connect,please check resolution params");
            isPreview = false;
        } else {
            isPreview = true;
            showShortMsg("connecting");
        }
    }

    @Override
    public void onDisConnectDev(UsbDevice device) {
        showShortMsg("disconnecting");
    }
};


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

@Override
public void onDialogResult(boolean canceled) {
    if(canceled){
        showShortMsg("取消操作");
    }
}

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

}
`

屏幕漆黑一片，无法预览

多个设备冲突

compile 'com.github.jiangdongguo:AndroidUSBCamera:1.3.8'
我的应用一开始只带一个USBCamera时，整个效果是没问题的。后来加上另外一个USB单片机的代码后，此USB单片机能用，但我们的USBCamera设备找不到了。
mUSBManager.getUsbDeviceCount()的数量为0。单独只连接USBCamera，也无法识别。

另一个USB单片机的接口代码如下：
`package cn.wch.ch9326driver;

import java.util.HashMap;
import java.util.Iterator;

import android.app.PendingIntent;
import android.content.BroadcastReceiver;
import android.content.Context;
import android.content.Intent;
import android.content.IntentFilter;
import android.hardware.usb.UsbDevice;
import android.hardware.usb.UsbDeviceConnection;
import android.hardware.usb.UsbEndpoint;
import android.hardware.usb.UsbInterface;
import android.hardware.usb.UsbManager;
import android.util.Log;
import android.widget.Toast;

public class CH9326UARTDriver {

public static final String TAG = "CH9326UARTDriver";
private UsbManager mUsbmanager;
private PendingIntent mPendingIntent;
private UsbDevice mUsbDevice;
private UsbInterface mInterface;
private UsbEndpoint mBulkInPoint;
private UsbEndpoint mBulkOutPoint;
private UsbDeviceConnection mDeviceConnection;
private Context mContext;
private String mString;
private boolean BroadcastFlag = false;
public boolean READ_ENABLE = false;
public read_thread readThread;
private Object WriteLock = new Object();
private Object ReadLock = new Object();

private byte[] readBuffer; /* circular buffer */
private byte[] usbdata;
private int writeIndex;
private int readIndex;
private int readcount;
private int totalBytes;
private int mBulkPacketSize;
final int maxnumbytes = 65536;

public int WriteTimeOutMillis;
public int ReadTimeOutMillis;
private int DEFAULT_TIMEOUT = 300;

public CH9326UARTDriver(UsbManager manager, Context context, String AppName) {
	super();
	readBuffer = new byte[maxnumbytes];
	usbdata = new byte[1024];
	writeIndex = 0;
	readIndex = 0;

	mUsbmanager = manager;
	mContext = context;
	mString = AppName;
	WriteTimeOutMillis = 10000;
	ReadTimeOutMillis = 10000;
}

/**
 * 设置串口的读写超时
 * 
 * @param WriteTimeOut
 *            写超时(单位Ms)
 * @param ReadTimeOut
 *            读超时(单位Ms)
 */
public void SetTimeOut(int WriteTimeOut, int ReadTimeOut) {
	WriteTimeOutMillis = WriteTimeOut;
	ReadTimeOutMillis = ReadTimeOut;
}

private void OpenUsbDevice(UsbDevice mDevice) {
	Object localObject;
	UsbInterface intf;
	if (mDevice == null)
		return;
	intf = getUsbInterface(mDevice);
	if ((mDevice != null) && (intf != null)) {
		localObject = this.mUsbmanager.openDevice(mDevice);
		if (localObject != null) {
			if (((UsbDeviceConnection) localObject).claimInterface(intf,
					true)) {
				this.mUsbDevice = mDevice;
				this.mDeviceConnection = ((UsbDeviceConnection) localObject);
				this.mInterface = intf;
				enumerateEndPoint(intf);
				if (READ_ENABLE == false) {
					READ_ENABLE = true;
					readThread = new read_thread(mBulkInPoint,
							mDeviceConnection);
					readThread.start();
				}
				return;
			}
		}
	}
}

/**
 * 打开CH9326设备
 * 
 * @param mDevice
 *            需要打开的CH9326设备
 */
public void OpenDevice(UsbDevice mDevice) {
	mPendingIntent = PendingIntent.getBroadcast(mContext, 0, new Intent(
			mString), 0);
	if (mUsbmanager.hasPermission(mDevice)) {
		OpenUsbDevice(mDevice);
	} else {
		synchronized (mUsbReceiver) {
			mUsbmanager.requestPermission(mDevice, mPendingIntent);
		}
	}
}

/**
 * 关闭设备
 */
public synchronized void CloseDevice() {
	if (this.mDeviceConnection != null) {
		if (this.mInterface != null) {
			this.mDeviceConnection.releaseInterface(this.mInterface);
			this.mInterface = null;
		}

		this.mDeviceConnection.close();
	}

	if (this.mUsbDevice != null) {
		this.mUsbDevice = null;
	}

	if (this.mUsbmanager != null) {
		this.mUsbmanager = null;
	}

	if (READ_ENABLE == true) {
		READ_ENABLE = false;
	}

	// 注销广播接收器
	if (BroadcastFlag == true) {
		this.mContext.unregisterReceiver(mUsbReceiver);
		BroadcastFlag = false;
	}

}

/**
 * 判断系统是否支持USB HOST功能
 * 
 * @return false:不支持USB HOST模式 ;true:支持UBS HOST模式
 */
public boolean UsbFeatureSupported() {
	boolean bool = this.mContext.getPackageManager().hasSystemFeature(
			"android.hardware.usb.host");
	return bool;
}

/**
 * 枚举并打开CH9326设备
 * 
 * @return 0:表示打开失败; 1:表示打开成功
 */
public synchronized boolean ResumeUsbList() {
	mUsbmanager = (UsbManager) mContext
			.getSystemService(Context.USB_SERVICE);
	HashMap<String, UsbDevice> deviceList = mUsbmanager.getDeviceList();
	if (deviceList.isEmpty()) {
		Toast.makeText(mContext, "No Device Or Device Not Match",
				Toast.LENGTH_LONG).show();
		return false;
	}
	Iterator<UsbDevice> localIterator = deviceList.values().iterator();
	while (localIterator.hasNext()) {
		UsbDevice localUsbDevice = localIterator.next();
		if (localUsbDevice.getVendorId() == 0x1a86
				&& localUsbDevice.getProductId() == 0xe010) {
			Log.d(TAG, "device found");
			IntentFilter filter = new IntentFilter(mString);
			filter.addAction(UsbManager.ACTION_USB_DEVICE_DETACHED);
			mContext.registerReceiver(mUsbReceiver, filter);
			BroadcastFlag = true;
			if (mUsbmanager.hasPermission(localUsbDevice)) {
				OpenUsbDevice(localUsbDevice);
			} else {
				synchronized (mUsbReceiver) {
					mUsbmanager.requestPermission(localUsbDevice,
							mPendingIntent);
				}
			}
			return true;

		}
	}
	return false;
}

/**
 * 枚举CH9326设备
 * 
 * @return 返回枚举到的设备，如果没有设备则返回null
 */
public synchronized UsbDevice EnumerateDevice() {
	mUsbmanager = (UsbManager) mContext
			.getSystemService(Context.USB_SERVICE);
	HashMap<String, UsbDevice> deviceList = mUsbmanager.getDeviceList();
	if (deviceList.isEmpty()) {
		Toast.makeText(mContext, "No Device Or Device Not Match",
				Toast.LENGTH_LONG).show();
		return null;
	}
	Iterator<UsbDevice> localIterator = deviceList.values().iterator();
	while (localIterator.hasNext()) {
		UsbDevice localUsbDevice = localIterator.next();
		if (localUsbDevice.getVendorId() == 0x1a86
				&& localUsbDevice.getProductId() == 0xe010) {
			Log.d(TAG, "device found");
			IntentFilter filter = new IntentFilter(mString);
			filter.addAction(UsbManager.ACTION_USB_DEVICE_DETACHED);
			mContext.registerReceiver(mUsbReceiver, filter);
			BroadcastFlag = true;
			return localUsbDevice;
		}
	}
	return null;
}

/**
 * 设备是否连接
 * 
 * @return true:设备连接正常 ;false:设备未连接
 */
public boolean isConnected() {
	return (this.mUsbDevice != null) && (this.mInterface != null)
			&& (this.mDeviceConnection != null);
}

/**
 * @return 获取到的CH9326设备
 */
protected UsbDevice getUsbDevice() {
	return this.mUsbDevice;
}

/**
 * 设置串口参数
 * 
 * @param baudRate
 *            01 = 300bps, 02 = 600bps, 03 = 1200bps, 04 = 2400bps, 05 =
 *            4800bps, 06 = 9600(default)bps, 07 = 14400bps, 08 = 19200bps,
 *            09 = 28800bps, 10 = 38400bps, 11 = 57600bps, 12 = 76800bps, 13
 *            = 115200bps
 * @param dataBit
 *            01 = 5bit data bit, 02 = 6bit data bit, 03 = 7bit data bit, 04
 *            = 8bit data bit(default)
 * @param stopBit
 *            01 = 1bit stop bit(default) ,02 = 2bit stop bit
 * @param parity
 *            01 = odd, 02 = even, 03 = space, 04 = none(default)
 * @return true:设置成功 false:设置失败
 */
public synchronized boolean SetConfig(int baudRate, int dataBit,
		int stopBit, int parity) {
	byte interval = 0x10;
	byte[] buf = new byte[32];
	byte[] m_str = new byte[5];
	int size, len;
	if (baudRate < 1 || baudRate > 14 || parity < 1 || parity > 4
			|| stopBit < 1 || stopBit > 2 || dataBit < 1 || dataBit > 4) {
		return false;
	}
	if (baudRate == 1) // 300bps
	{
		m_str[2] = (byte) 0x80;
		m_str[3] = (byte) 0xD9;
		m_str[4] = interval;
		m_str[0] |= 0x01;
	} else if (baudRate == 2) // 600bps
	{
		m_str[2] = (byte) 0x81;
		m_str[3] = 0x64;
		m_str[4] = interval;
		m_str[0] |= 0x01;
	} else if (baudRate == 3) // 1200bps
	{
		m_str[2] = (byte) 0x81;
		m_str[3] = (byte) 0xB2;
		m_str[4] = interval;
		m_str[0] |= 0x01;
	} else if (baudRate == 4) // 2400bps
	{
		m_str[2] = (byte) 0x81;
		m_str[3] = (byte) 0xD9;
		m_str[4] = interval;
		m_str[0] |= 0x01;
	} else if (baudRate == 5) // 4800bps
	{
		m_str[2] = (byte) 0x82;
		m_str[3] = 0x64;
		m_str[4] = interval;
		m_str[0] |= 0x01;
	} else if (baudRate == 6) // 9600bps
	{
		m_str[2] = (byte) 0x82;
		m_str[3] = (byte) 0xB2;
		m_str[4] = interval;
		m_str[0] |= 0x01;
	} else if (baudRate == 7) // 14400bps
	{
		m_str[2] = (byte) 0x82;
		m_str[3] = (byte) 0xCC;
		m_str[4] = interval;
		m_str[0] |= 0x01;
	} else if (baudRate == 8) // 19200bps
	{
		m_str[2] = (byte) 0x82;
		m_str[3] = (byte) 0xD9;
		m_str[4] = interval;
		m_str[0] |= 0x01;
	} else if (baudRate == 9) // 28800bps
	{
		m_str[2] = (byte) 0x83;
		m_str[3] = 0x30;
		m_str[4] = interval;
		m_str[0] |= 0x01;
	} else if (baudRate == 10) // 38400bps
	{
		m_str[2] = (byte) 0x83;
		m_str[3] = 0x64;
		m_str[4] = interval;
		m_str[0] |= 0x01;
	} else if (baudRate == 11) // 57600
	{
		m_str[2] = (byte) 0x83;
		m_str[3] = (byte) 0x98;
		m_str[4] = interval;
		m_str[0] |= 0x01;
	} else if (baudRate == 12) // 76800
	{
		m_str[2] = (byte) 0x83;
		m_str[3] = (byte) 0xB2;
		m_str[4] = interval;
		m_str[0] |= 0x01;
	} else if (baudRate == 13) // 115200
	{
		m_str[2] = (byte) 0x83;
		m_str[3] = (byte) 0xCC;
		m_str[4] = interval;
		m_str[0] |= 0x01;
	}

	if (parity == 1) // odd
	{
		m_str[1] &= ~0x30;
		m_str[1] |= 0x08;
	} else if (parity == 2) // even
	{
		m_str[1] &= ~0x10;
		m_str[1] |= 0x18;
	} else if (parity == 3) // space
	{
		m_str[1] |= 0x38;
	} else if (parity == 4) // none
	{
		m_str[1] &= ~0x08;
	}

	if (stopBit == 1) // 1 bit
	{
		m_str[1] |= 0x04;
	} else if (stopBit == 2) // 2 bit
	{
		m_str[1] &= ~0x04;
	}

	if (dataBit == 1) // 5 bit
	{
		m_str[1] &= ~0x3;
	} else if (dataBit == 2) // 6 bit
	{
		m_str[1] &= ~0x3;
		m_str[1] |= 0x1;
	} else if (dataBit == 3) // 7 bit
	{
		m_str[1] &= ~0x3;
		m_str[1] |= 0x2;
	} else if (dataBit == 4) // 8 bit
	{
		m_str[1] |= 0x3;
	}

	m_str[0] = (byte) 0xFF;
	m_str[1] |= 0xC0;
	buf[0] = m_str[0];
	buf[1] = m_str[1];
	buf[2] = m_str[2];
	buf[3] = m_str[3];
	buf[4] = m_str[4];
	size = 32;
	len = mDeviceConnection.controlTransfer(UsbType.USB_TYPE_CLASS
			| UsbType.USB_RECIP_DEVICE | UsbType.USB_DIR_OUT,
			HID_Constants.HID_REPORT_SET, HID_Constants.HID_RT_OUTPUT << 8,
			0x00, buf, size, DEFAULT_TIMEOUT);
	if (len <= 0) {
		return false;
	} else {
		Log.i(TAG, "control transfer len=" + len);
	}
	return true;
}

/**
 * 串口读数据
 * 
 * @param data
 *            接收缓冲区
 * @param length
 *            需要读取的数据长度，每次读取的数据值不超过256
 * @return 返回实际读取的数据长度
 */
public int ReadData(byte[] data, int length) 
{
	int mLen;

	/* should be at least one byte to read */
	if ((length < 1) || (totalBytes == 0)) {
		mLen = 0;
		return mLen;
	}

	if(length>256)
		length=256;//这是为了防止取太多如果取了接近整个环形缓冲区的容量的数组，而此时CPU切换到硬件读数据的线程中去会将为读取的数据给覆盖了
	
	/* check for max limit */
	if (length > totalBytes)
		length = totalBytes;
	
	

	/* update the number of bytes available */
	totalBytes -= length;//就在此时跳转到线程从usb硬件读取数据时，此时totalBytes为0,会将把此时为取走的数据给覆盖掉

	mLen = length;
	/* copy to the user buffer */
	for (int count = 0; count < length; count++) {
		data[count] = readBuffer[readIndex];
		readIndex++;
		/*
		 * shouldnt read more than what is there in the buffer, so no need
		 * to check the overflow
		 */
		readIndex %= maxnumbytes;
	}
	return mLen;
}

/**
 * 串口写数据
 * 
 * @param buf
 *            实际需要写入的字节数组
 * @param length
 *            需要写入的字节长度
 * @return 返回实际写入的字节长度
 */
public int WriteData(byte[] buf, int length) {
	int mLen = 0;
	mLen = WriteData(buf, length, this.WriteTimeOutMillis);
	return mLen;
}

/**
 * 串口写数据
 * 
 * @param buf
 *            需要发送的字符数组
 * @param length
 *            发送的数据长度
 * @param timeoutMillis
 *            发送超时
 * @return 返回实际写出的数据长度
 */
public int WriteData(byte[] buf, int length, int timeoutMillis) {
	int offset = 0;
	int HasWritten = 0;
	int old_len = length;
	if (this.mBulkOutPoint == null)
		return -1;
	synchronized (WriteLock) {
		while (offset < length) {

			int mLen = Math.min(old_len, this.mBulkPacketSize - 1);
			byte[] arrayOfByte = new byte[mLen + 1];
			arrayOfByte[0] = (byte) mLen;
			if (offset == 0) {
				System.arraycopy(buf, 0, arrayOfByte, 1, mLen);
			} else {
				System.arraycopy(buf, offset, arrayOfByte, 1, mLen);
			}
			HasWritten = this.mDeviceConnection.bulkTransfer(
					this.mBulkOutPoint, arrayOfByte, mLen + 1,
					timeoutMillis);
			HasWritten = HasWritten - 1;// 发送的数据长度为实际发送的值-1
			if (HasWritten < 0) {
				return -1;
			} else {
				offset += HasWritten;
				old_len -= HasWritten;
			}

		}
	}
	return offset;
}

private void enumerateEndPoint(UsbInterface sInterface) {
	if (sInterface == null)
		return;
	for (int i = 0; i < sInterface.getEndpointCount(); ++i) {
		UsbEndpoint endPoint = sInterface.getEndpoint(i);
		if (endPoint.getAddress() == 0x82
				&& endPoint.getMaxPacketSize() == 0x20) {
			mBulkInPoint = endPoint;
		} else if (endPoint.getAddress() == 0x02) {
			mBulkOutPoint = endPoint;
		}
		this.mBulkPacketSize = endPoint.getMaxPacketSize();
	}
	return;
}

private UsbInterface getUsbInterface(UsbDevice paramUsbDevice) {
	if (this.mDeviceConnection != null) {
		if (this.mInterface != null) {
			this.mDeviceConnection.releaseInterface(this.mInterface);
			this.mInterface = null;
		}
		this.mDeviceConnection.close();
		this.mUsbDevice = null;
		this.mInterface = null;
	}
	if (paramUsbDevice == null)
		return null;

	for (int i = 0; i < paramUsbDevice.getInterfaceCount(); i++) {
		UsbInterface intf = paramUsbDevice.getInterface(i);
		if (intf.getInterfaceClass() == 0x03
				&& intf.getInterfaceSubclass() == 0x00) {
			return intf;
		}
	}
	return null;
}

private final BroadcastReceiver mUsbReceiver = new BroadcastReceiver() {
	@Override
	public void onReceive(Context context, Intent intent) {
		String action = intent.getAction();
		if (UsbManager.ACTION_USB_DEVICE_ATTACHED.equals(action))
			return;

		if (mString.equals(action)) {
			synchronized (ReadLock) {
				UsbDevice localUsbDevice = (UsbDevice) intent
						.getParcelableExtra("device");
				if (intent.getBooleanExtra(
						UsbManager.EXTRA_PERMISSION_GRANTED, false)) {
					OpenUsbDevice(localUsbDevice);
				} else {
					Toast.makeText(CH9326UARTDriver.this.mContext,
							"Deny USB Permission", Toast.LENGTH_SHORT)
							.show();
					Log.d(TAG, "permission denied");
				}
			}
		} else if (UsbManager.ACTION_USB_DEVICE_DETACHED.equals(action)) {
			Toast.makeText(CH9326UARTDriver.this.mContext, "Disconnect",
					Toast.LENGTH_SHORT).show();
			CloseDevice();
		} else {
			Log.d(TAG, "......");
		}
	}
};

/**
 * 内部的接收数据的线程，将接受到的数据存放在环形缓冲区内
 */
private class read_thread extends Thread {
	UsbEndpoint endpoint;
	UsbDeviceConnection mConn;

	read_thread(UsbEndpoint point, UsbDeviceConnection con) {
		endpoint = point;
		mConn = con;
		this.setPriority(Thread.MAX_PRIORITY);
	}

	public void run() {
		
		while (READ_ENABLE == true) {
			
			synchronized (ReadLock) {
				while (totalBytes > (maxnumbytes - 256)) {//防止接收过快的时候会覆盖缓冲区
					try {
						Thread.sleep(5);
					} catch (InterruptedException e) {
						e.printStackTrace();
					}
				}

				if (endpoint != null) {
					readcount = mConn.bulkTransfer(endpoint, usbdata, 32,
							ReadTimeOutMillis);
					if (readcount > 0) {
						readcount = usbdata[0];// 读到的数据的第一个字节为接收到的数据长度，数组以后的部分才是实际读取到的数据
						for (int count = 1; count <= readcount; count++) {
							readBuffer[writeIndex] = usbdata[count];
							writeIndex++;
							writeIndex %= maxnumbytes;
						}
						if (writeIndex >= readIndex)
							totalBytes = writeIndex - readIndex;
						else
							totalBytes = (maxnumbytes - readIndex)
									+ writeIndex;
					}
				}
			}
		}
	}
}

private final class UsbType {
	public static final int USB_TYPE_CLASS = 0x20;
	public static final int USB_RECIP_DEVICE = 0x00;
	public static final int USB_DIR_OUT = 0x00;
	public static final int USB_DIR_IN = 0x80;
}

private final class HID_Constants {
	public static final int HID_RT_INPUT = 0x01;
	public static final int HID_RT_OUTPUT = 0x02;
	public static final int HID_REPORT_GET = 0x01;
	public static final int HID_REPORT_SET = 0x09;
}

}
`

建议开放startVideoRecord()和stopVideoRecord()

感谢蒋工开放代码！
我现在想跟清新的SDK对接，需要把H.264的视频流推送过去，清新的SDK说明 https://github.com/tsinglink/ECSDK/wiki/ECSDK%E5%BC%80%E5%8F%91%E6%8C%87%E5%BC%95#%E5%A4%96%E9%83%A8%E5%AA%92%E4%BD%93%E6%BA%90 发现好像除了录制别无他法，要么就是自己重写AbstractUVCCameraHandler.java，如果开放了startVideoRecord()和stopVideoRecord()接口，是不是扩展也会好点？问题是录制的话，怕时间太长了空间又会不够用。
还有其他方法么？ 感谢！

反复几次打开摄像头时无预览画面

首先感谢大神的分享. 最近使用您的库时发现, 在反复几次打开摄像头时 Toast提示Connecting后, 无预览画面出现,需要重新插拔USB后才能恢复.希望大神帮忙解答下,谢谢!

可以支持一下RTMP推流吗？

可以支持一下RTMP推流吗？

SurfaceView的回调方法里面的代码并没有执行

作者在readme文档里面写must have这些代码. 但是我在调试的过程中发现 , cameraHelper.isCameraOpened() 一直为false, 不管能不能预览到画面, 里面的逻辑并不会走,
请问这些代码是在什么时候执行的?

``
@OverRide
public void onSurfaceCreated(CameraViewInterface view, Surface surface) {
if (!isPreview && cameraHelper.isCameraOpened()) {
cameraHelper.startPreview(uvcCameraView);
isPreview = true;
}
}

@Override
public void onSurfaceDestroy(CameraViewInterface view, Surface surface) {
    if (isPreview && cameraHelper.isCameraOpened()) {
        cameraHelper.stopPreview();
        isPreview = false;
    }
}

``

下载的demo运行起来黑屏

下载demo正常运行，但是摄像头没打开，显示黑屏，麻烦帮忙看下，453514644，如果方便能加下我qq，这块想请教下，非常感谢

第一次进去正常，退出再进黑屏

1.集成在自己的app 中，第一次进去正常打开。
2.退出当前页面后，再进黑屏。无报错。log 提示：
E/BufferQueueProducer: [SurfaceTexture-1-25464-3](this:0x7dee11a800,id:3,api:2,p:25464,c:-1) dequeueBuffer: BufferQueue has been abandoned
3.杀死 app再进，又可以打开。
4.测试机是 android7.0开发板，MTK6737平台。
怀疑是资源释放问题，但是有调用release的。

多个USB设备无法识别的问题

之前只有一个usbcamera时，工作没有问题。同时在一个hub上加上另一个usb设备后，usbcamera就识别不到了。
另外一个usb设备配置了device_filter.xml 。不知道是不是这样的影响。

同时处理三个UVC的时候会报错，不知道怎么解决

同时处理三个UVC的时候，H264EncodeConsumer它的run方法里面会报错，有解决的办法吗？

拍照不能保存

/libusbcamera/src/main/java/com/serenegiant/usb/common/AbstractUVCCameraHandler.java
第360行，不知道为什么注释掉了

图片与录像保存后在手机上没有

如题，图片与录像保存后在手机上没有，打印路径为/storage/emulated/0/，但该目录下没有对应图片与录像

关于打开app自动适配到最大分辨率

现在打开摄像头默认分辨率为640x480,怎样才能让app打开时就适配到最大分辨率？之后随用户要求自己更改分辨率。现在所有配置都在onResume()之前做好了，把List list = mCameraHelper.getSupportedPreviewSizes();这一句放到onResume()中，获取的list为null。能给点思路吗？这句要放哪里才会获取到摄像头所支持的分辨率呢？最好是在还没预览前。

Error 12291 on opening app sometimes (and always when app is opened through android studio when screen is locked)

java.lang.IllegalArgumentException: java.lang.RuntimeException: createWindowSurface failed error=12291
at com.serenegiant.glutils.EGLBase14.createWindowSurface(EGLBase14.java:466)
at com.serenegiant.glutils.EGLBase14.access$100(EGLBase14.java:44)
at com.serenegiant.glutils.EGLBase14$EglSurface.(EGLBase14.java:90)
at com.serenegiant.glutils.EGLBase14$EglSurface.(EGLBase14.java:79)
at com.serenegiant.glutils.EGLBase14.createFromSurface(EGLBase14.java:192)
at com.serenegiant.glutils.EGLBase14.createFromSurface(EGLBase14.java:43)
at com.serenegiant.usb.widget.UVCCameraTextureView$RenderHandler$RenderThread.init(UVCCameraTextureView.java:564)
at com.serenegiant.usb.widget.UVCCameraTextureView$RenderHandler$RenderThread.run(UVCCameraTextureView.java:543)
Caused by: java.lang.RuntimeException: createWindowSurface failed error=12291
at com.serenegiant.glutils.EGLBase14.createWindowSurface(EGLBase14.java:460)
at com.serenegiant.glutils.EGLBase14.access$100(EGLBase14.java:44) 
at com.serenegiant.glutils.EGLBase14$EglSurface.(EGLBase14.java:90) 
at com.serenegiant.glutils.EGLBase14$EglSurface.(EGLBase14.java:79) 
at com.serenegiant.glutils.EGLBase14.createFromSurface(EGLBase14.java:192) 
at com.serenegiant.glutils.EGLBase14.createFromSurface(EGLBase14.java:43) 
at com.serenegiant.usb.widget.UVCCameraTextureView$RenderHandler$RenderThread.init(UVCCameraTextureView.java:564) 
at com.serenegiant.usb.widget.UVCCameraTextureView$RenderHandler$RenderThread.run(UVCCameraTextureView.java:543) 

调用录像的startRecording会崩溃

调用startRecording会崩溃，录不了像，log：
05-17 19:03:34.425 18976-19021/com.byteflyer.mcamera E/H264EncodeConsumer: couldn't find a good color format for OMX.MTK.VIDEO.ENCODER.AVC / video/avc
Unable to find an appropriate codec for video/avc
05-17 19:03:34.626 18976-19021/com.byteflyer.mcamera E/AndroidRuntime: FATAL EXCEPTION: Thread-1516
Process: com.byteflyer.mcamera, PID: 18976
java.lang.NullPointerException: Attempt to invoke virtual method 'int android.media.MediaCodec.dequeueOutputBuffer(android.media.MediaCodec$BufferInfo, long)' on a null object reference
at com.serenegiant.usb.encoder.biz.H264EncodeConsumer.run(H264EncodeConsumer.java:153)

这是解码器有问题吗？还是要设置解码？根据README的做法来的。

resolve: com.github.jiangdongguo:AndroidUSBCamera:2.0

as3.0 添加依赖 同步后 报错 resolve: com.github.jiangdongguo:AndroidUSBCamera:2.0

[5903*UVCCamera.cpp:178:connect]:could not open camera:err=-50

运行弹出授权提示框之后，打开摄像头的时候报这个错 [5903*UVCCamera.cpp:178:connect]:could not open camera:err=-50 请问是什么情况

Android 4.4.4 上预览出错了，请帮忙看下

03-30 00:39:55.620 3216-3216/com.jiangdg.usbcamera V/USBMonitor: USBMonitor:Constructor
03-30 00:39:55.620 3216-3216/com.jiangdg.usbcamera V/USBMonitor: USBMonitor:mUsbManager=android.hardware.usb.UsbManager@41a6feb0
03-30 00:39:55.630 3216-3216/com.jiangdg.usbcamera V/CameraThread: getHandler:
03-30 00:39:55.630 3216-3216/com.jiangdg.usbcamera I/USBMonitor: register:
03-30 00:39:55.660 3216-3216/com.jiangdg.usbcamera D/dalvikvm: GC_FOR_ALLOC freed 269K, 11% free 3032K/3372K, paused 13ms, total 13ms
03-30 00:39:55.800 3216-3216/com.jiangdg.usbcamera D/OpenGLRenderer: Enabling debug mode 0
03-30 00:39:55.850 3216-3216/com.jiangdg.usbcamera I/UVCCameraTextureView: onSurfaceTextureAvailable:android.graphics.SurfaceTexture@41a35f48
03-30 00:39:55.850 3216-3216/com.jiangdg.usbcamera V/UVCCameraTextureView: RenderThread#getHandler:
03-30 00:39:55.850 3216-3231/com.jiangdg.usbcamera D/UVCCameraTextureView: RenderThread started
03-30 00:39:55.850 3216-3231/com.jiangdg.usbcamera V/UVCCameraTextureView: RenderThread#init:
03-30 00:39:55.860 3216-3231/com.jiangdg.usbcamera D/EGLBase14: EGLContext created, client version 2
03-30 00:39:55.880 3216-3216/com.jiangdg.usbcamera V/UVCCameraTextureView: getSurface:hasSurface=true
03-30 00:39:55.880 3216-3216/com.jiangdg.usbcamera V/UVCCameraTextureView: getPreviewTexture:
03-30 00:39:55.880 3216-3231/com.jiangdg.usbcamera I/UVCCameraTextureView: RenderThread#updatePreviewSurface:
03-30 00:39:55.880 3216-3231/com.jiangdg.usbcamera V/UVCCameraTextureView: updatePreviewSurface:tex_id=70001
03-30 00:39:56.680 3216-3229/com.jiangdg.usbcamera V/USBMonitor: processConnect:device=UsbDevice[mName=/dev/bus/usb/001/005,mVendorId=1423,mProductId=14464,mClass=239,mSubclass=2,mProtocol=1,mInterfaces=[Landroid.os.Parcelable;@41a4ef38]
03-30 00:39:56.690 3216-3229/com.jiangdg.usbcamera I/dalvikvm: Could not find method android.hardware.usb.UsbInterface.getAlternateSetting, referenced from method com.serenegiant.usb.USBMonitor$UsbControlBlock.getInterface
03-30 00:39:56.690 3216-3229/com.jiangdg.usbcamera W/dalvikvm: VFY: unable to resolve virtual method 1003: Landroid/hardware/usb/UsbInterface;.getAlternateSetting ()I
03-30 00:39:56.690 3216-3229/com.jiangdg.usbcamera D/dalvikvm: VFY: replacing opcode 0x6e at 0x0039
03-30 00:39:56.690 3216-3229/com.jiangdg.usbcamera I/USBMonitor: UsbControlBlock:constructor
03-30 00:39:56.710 3216-3229/com.jiangdg.usbcamera D/UsbDeviceConnectionJNI: close
03-30 00:39:56.710 3216-3229/com.jiangdg.usbcamera I/USBMonitor: name=/dev/bus/usb/001/005,desc=66,busnum=1,devnum=5,rawDesc=[B@41a28228
03-30 00:39:56.720 3216-3229/com.jiangdg.usbcamera V/UVCCameraTextureView: getPreviewTexture:
03-30 00:39:56.720 3216-3231/com.jiangdg.usbcamera I/UVCCameraTextureView: RenderThread#updatePreviewSurface:
03-30 00:39:56.720 3216-3231/com.jiangdg.usbcamera D/UVCCameraTextureView: updatePreviewSurface:release mPreviewSurface
03-30 00:39:56.720 3216-3231/com.jiangdg.usbcamera V/UVCCameraTextureView: updatePreviewSurface:tex_id=140002
03-30 00:39:56.750 3216-3230/com.jiangdg.usbcamera V/CameraThread: handleOpen:
03-30 00:39:56.750 3216-3230/com.jiangdg.usbcamera V/CameraThread: handleClose:
03-30 00:39:56.750 3216-3230/com.jiangdg.usbcamera V/UVCCameraTextureView: setVideoEncoder:
03-30 00:39:56.750 3216-3230/com.jiangdg.usbcamera D/dalvikvm: Trying to load lib /data/app-lib/com.jiangdg.usbcamera-2/libjpeg-turbo1500.so 0x41a05420
03-30 00:39:56.750 3216-3231/com.jiangdg.usbcamera V/UVCCameraTextureView: RenderThread#setEncoder:encoder=null
03-30 00:39:56.760 3216-3230/com.jiangdg.usbcamera D/dalvikvm: Added shared lib /data/app-lib/com.jiangdg.usbcamera-2/libjpeg-turbo1500.so 0x41a05420
03-30 00:39:56.760 3216-3230/com.jiangdg.usbcamera D/dalvikvm: No JNI_OnLoad found in /data/app-lib/com.jiangdg.usbcamera-2/libjpeg-turbo1500.so 0x41a05420, skipping init
03-30 00:39:56.770 3216-3230/com.jiangdg.usbcamera D/dalvikvm: Trying to load lib /data/app-lib/com.jiangdg.usbcamera-2/libusb100.so 0x41a05420
03-30 00:39:56.770 3216-3230/com.jiangdg.usbcamera D/dalvikvm: Added shared lib /data/app-lib/com.jiangdg.usbcamera-2/libusb100.so 0x41a05420
03-30 00:39:56.770 3216-3230/com.jiangdg.usbcamera D/dalvikvm: No JNI_OnLoad found in /data/app-lib/com.jiangdg.usbcamera-2/libusb100.so 0x41a05420, skipping init
03-30 00:39:56.770 3216-3230/com.jiangdg.usbcamera D/dalvikvm: Trying to load lib /data/app-lib/com.jiangdg.usbcamera-2/libuvc.so 0x41a05420
03-30 00:39:56.770 3216-3230/com.jiangdg.usbcamera D/dalvikvm: Added shared lib /data/app-lib/com.jiangdg.usbcamera-2/libuvc.so 0x41a05420
03-30 00:39:56.770 3216-3230/com.jiangdg.usbcamera D/dalvikvm: No JNI_OnLoad found in /data/app-lib/com.jiangdg.usbcamera-2/libuvc.so 0x41a05420, skipping init
03-30 00:39:56.780 3216-3230/com.jiangdg.usbcamera D/dalvikvm: Trying to load lib /data/app-lib/com.jiangdg.usbcamera-2/libUVCCamera.so 0x41a05420
03-30 00:39:56.780 3216-3230/com.jiangdg.usbcamera D/dalvikvm: Added shared lib /data/app-lib/com.jiangdg.usbcamera-2/libUVCCamera.so 0x41a05420
03-30 00:39:56.800 3216-3230/com.jiangdg.usbcamera D/UsbDeviceConnectionJNI: close
03-30 00:39:56.800 3216-3230/com.jiangdg.usbcamera I/libusb/core: [3230core.c:2085:libusb_init2]:libusb v1.0.19.10903
03-30 00:39:56.800 3216-3230/com.jiangdg.usbcamera I/libusb/usbfs: [3230android_usbfs.c:504:op_init2]:start up hotplug event handler
03-30 00:39:56.800 3216-3230/com.jiangdg.usbcamera I/libusb/usbfs: [3230android_usbfs.c:512:op_init2]:call android_scan_devices
03-30 00:39:56.800 3216-3230/com.jiangdg.usbcamera I/AbsUVCCameraHandler: supportedSize:{"formats":[{"index":1,"type":4,"default":1,"size":["640x480","352x288","320x240","176x144","160x120"]}]}
03-30 00:39:56.800 3216-3230/com.jiangdg.usbcamera V/CameraThread: handleStartPreview:
03-30 00:39:56.800 3216-3230/com.jiangdg.usbcamera I/libUVCCamera: [3230UVCPreview.cpp:276:callbackPixelFormatChanged]:PIXEL_FORMAT_YUV20SP:
03-30 00:39:56.820 3216-3234/com.jiangdg.usbcamera I/libUVCCamera: [3234UVCPreview.cpp:492:prepare_preview]:frameSize=(640,480)@yuyv
03-30 00:39:56.820 3216-3236/com.jiangdg.usbcamera I/libUVCCamera: [3236UVCPreview.cpp:276:callbackPixelFormatChanged]:PIXEL_FORMAT_YUV20SP:
03-30 00:40:04.080 3216-3233/com.jiangdg.usbcamera A/libc: Fatal signal 11 (SIGSEGV) at 0x6f0e3000 (code=2), thread 3233 (CameraThread)

同步2.0版出问题

Error:(33, 13) Failed to resolve: com.github.jiangdongguo:AndroidUSBCamera:2.0
repositories里面加了maven的

APP处于卡死、无响应状态

第一次进入APP预览出一帧图，然后处于卡死、无响应状态。

怎么推rtmp视频流？

不同App中libusbcamera读取到的设备信息不同

在Demo中，读取到的信息是：

DeviceFilter[mVendorId=-1,mProductId=-1,mClass=239,mSubclass=2,mProtocol=-1,mManufacturerName=null,mProductName=null,mSerialNumber=null,isExclude=false]

但在自己的App中，同样的设备，读到的信息却是：
DeviceFilter[mVendorId=7851,mProductId=6659,mClass=-1,mSubclass=-1,mProtocol=-1,mManufacturerName=null,mProductName=null,mSerialNumber=null,isExclude=false]

这样导致App中无法匹配到对应的摄像头信息，请教下可能是什么原因；

大哥牛逼。

大哥牛逼

设置曝光值无效

public native int nativeSetExposure(final long id_camera, final int exposure);
public native int nativeGetExposure(final long id_camera);

我先get获得值为-3，然后set为0再get，值还是-1

能完善一下rtmp推流吗？

数据格式问题

您好,我想用您的库来直接获取yuv源数据,应该怎么处理呢.

如何SurfaceView做预览显示呢

大神,如何修改能在SurfaceView上显示预览界面,而不用TextureView

支持音频吗

如果摄像头有音频麦克风，可以获取到音频数据吗，打开和关闭麦克风

你好,请教下预览怎么旋转?直接用rotation属性会导致预览2边有空白.

1080P分辨率帧率较低

用1080P分辨率录了一段视频，看了下帧率只有5fps。能优化下吗？

照片跟影片問題

照片的listenListener 點擊takingPhotos後沒有回傳
錄影的有回傳 但是檔案是0kb
uses-permission android:name="android.permission.WRITE_EXTERNAL_STORAGE"
uses-permission android:name="android.permission.RECORD_AUDIO"
這個權限有給 6.0 android的權限也有拿到
gradle-4.1
ndk-r14
使用AndroidUSBCamera下載的demo
手機7.1.1 sony z5
https://imgur.com/a/AwyFdgU
https://imgur.com/bNFiT9a

预览的时候就卡在第一帧不动了

gradle失败，就在刚刚

Resource missing. [HTTP GET: https://jcenter.bintray.com/com/github/jiangdongguo/AndroidUSBCamera/2.1.1/AndroidUSBCamera-2.1.1.pom]
Resource missing. [HTTP HEAD: https://jcenter.bintray.com/com/github/jiangdongguo/AndroidUSBCamera/2.1.1/AndroidUSBCamera-2.1.1.jar]
Resource missing. [HTTP GET: http://raw.github.com/saki4510t/libcommon/master/repository/com/github/jiangdongguo/AndroidUSBCamera/2.1.1/AndroidUSBCamera-2.1.1.pom]
Resource missing. [HTTP HEAD: http://raw.github.com/saki4510t/libcommon/master/repository/com/github/jiangdongguo/AndroidUSBCamera/2.1.1/AndroidUSBCamera-2.1.1.jar]
Resource missing. [HTTP GET: https://jitpack.io/com/github/jiangdongguo/AndroidUSBCamera/2.1.1/AndroidUSBCamera-2.1.1.pom]
Resource missing. [HTTP HEAD: https://jitpack.io/com/github/jiangdongguo/AndroidUSBCamera/2.1.1/AndroidUSBCamera-2.1.1.

• What went wrong:
  A problem occurred configuring project ':app'.

Could not resolve all dependencies for configuration ':app:_debugApkCopy'.
Could not find com.github.jiangdongguo:AndroidUSBCamera:2.1.1.
Required by:
project :app

请确认是不是更新导致？ 谢谢

你好，对此项目很感性趣，想同你一起把他做的更好！

你好，对此项目很感性趣，想同你一起把他做的更好！方便留个联系方式吗？

createWindowSurface failed error=12291 on opening app sometimes. (and always on opening through android studio when screen is locked)

java.lang.IllegalArgumentException: java.lang.RuntimeException: createWindowSurface failed error=12291
at com.serenegiant.glutils.EGLBase14.createWindowSurface(EGLBase14.java:466)
at com.serenegiant.glutils.EGLBase14.access$100(EGLBase14.java:44)
at com.serenegiant.glutils.EGLBase14$EglSurface.(EGLBase14.java:90)
at com.serenegiant.glutils.EGLBase14$EglSurface.(EGLBase14.java:79)
at com.serenegiant.glutils.EGLBase14.createFromSurface(EGLBase14.java:192)
at com.serenegiant.glutils.EGLBase14.createFromSurface(EGLBase14.java:43)
at com.serenegiant.usb.widget.UVCCameraTextureView$RenderHandler$RenderThread.init(UVCCameraTextureView.java:564)
at com.serenegiant.usb.widget.UVCCameraTextureView$RenderHandler$RenderThread.run(UVCCameraTextureView.java:543)
Caused by: java.lang.RuntimeException: createWindowSurface failed error=12291
at com.serenegiant.glutils.EGLBase14.createWindowSurface(EGLBase14.java:460)
at com.serenegiant.glutils.EGLBase14.access$100(EGLBase14.java:44) 
at com.serenegiant.glutils.EGLBase14$EglSurface.(EGLBase14.java:90) 
at com.serenegiant.glutils.EGLBase14$EglSurface.(EGLBase14.java:79) 
at com.serenegiant.glutils.EGLBase14.createFromSurface(EGLBase14.java:192) 
at com.serenegiant.glutils.EGLBase14.createFromSurface(EGLBase14.java:43) 
at com.serenegiant.usb.widget.UVCCameraTextureView$RenderHandler$RenderThread.init(UVCCameraTextureView.java:564) 
at com.serenegiant.usb.widget.UVCCameraTextureView$RenderHandler$RenderThread.run(UVCCameraTextureView.java:543) 

AS 2.3.3 重复包？

com.android.build.api.transform.TransformException: com.android.ide.common.process.ProcessException: java.util.concurrent.ExecutionException: com.android.dex.DexException: Multiple dex files define Lcom/jiangdg/libusbcamera/BuildConfig;

无法预览以及闪退

我是添加依赖到自己app的，测试机为两个平板(买的主板接的屏幕)，一个平板运行可以，另一个Android5.1.1的平板运行，显示连接了，但是无预览画面，过一会就报错退出了。
06-02 10:50:01.415 4859-4962/cn.gxh.face A/libc: Fatal signal 11 (SIGSEGV), code 2, fault addr 0x94594000 in tid 4962 (CameraThread)
另外，打开从相机里看的话，是花屏，一闪一闪，就像以前电视信号不好的那种，根本看不到其他东西。
请问是什么原因呢？希望回复，谢谢。

抓图

您好，我想大概每隔20ms抓一次图，希望得到byte[]，或者bitmap也行，而不是本地文件，请问怎么实现呢？

DEMO预览卡顿反馈

首先感谢大神的无私分享。我下载了你的demo运行起来发现相较于原来的日本人的库，同分辨率下会卡顿闪屏现象。后来发现你的demo中默认用YUYV的格式，我修改成默认的MJPEG就好了一点。

4.4.4平板无法正常使用

使用环境：4.4.4系统的平板
bug描述：clone运行之后，打开app之后首先无法预览，而后过一会就会闪退
报错信息：
12-16 10:52:03.649 4180-4229/com.jiangdg.usbcamera A/libc: Fatal signal 11 (SIGSEGV) at 0x6efdd000 (code=2), thread 4229 (CameraThread)

大佬这库是不是和opencv的库有冲突？

大佬您好，我在单独用您的库后非常顺利，然后整合进我的项目后，就会遇到OpenCV library not found!。接下来不知道该怎么办了。~~~~(>_<)~~~~

setOnPreviewFrameListener设置了后内部回调不走

如何不传入 CameraView 获取 YUV 数据

你好，能不能不要传入 CameraViewInterface ，就获取 YUV 数据。（就是不要预览界面，在Service 里获取 YUV 数据）