基于libusb库和AOA协议实现通过USB与安卓设备通信

最新推荐文章于 2024-04-01 17:53:35 发布
最新推荐文章于 2024-04-01 17:53:35 发布
阅读量2.3k 收藏 20
点赞数 2
分类专栏： 笔记 文章标签： linux Powered by 金山文档
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/dongyoubin/article/details/128814778
版权

流程：

手机通过USB连接到设备时，触发一次插入事件，设备通过VID和PID来判断USB是否为AOA模式

不是AOA模式：则进入切换到AOA模式流程

1.打开usb设备

2.发送AOA协议报文交互

3.关闭usb设备

USB会出现一次逻辑拔插过程：触发一次拔出事件和一次插入事件，手机切换VID和PID为AOA模式

4.USB已切换为AOA模式

5.获取USB接口信息

6.打开USB设备并声明读写接口，建立AOA数据通道

是AOA模式：

1.获取USB接口信息

2.打开USB设备并声明读写接口，建立AOA数据通道

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <pthread.h>
#include <unistd.h>
#include "libusb.h"

#define BULK_RECV_EP    0x83
#define BULK_SEND_EP    0x02
#define INT_RECV_EP     0x81
#define INT_SEND_EP     0x01

#define VID_GOOGLE            0x18D1
#define    PID_AOA_ACC            0x2D00
#define    PID_AOA_ACC_ADB        0x2D01
#define    PID_AOA_AU            0x2D02
#define    PID_AOA_AU_ADB        0x2D03
#define    PID_AOA_ACC_AU        0x2D04
#define    PID_AOA_ACC_AU_ADB    0x2D05

static char manufacturer[] = "Lutixia";
static char modelName[] = "Demo";
static char description[] = "Android Aoa Interface"; 
static char version[] = "1.0";
static char uri[] = "https://www.baidu.com/";
static char serialNumber[] = "1234567890";


typedef struct 
{
    unsigned int pid;
    unsigned int vid;
    unsigned char bInEndpointAddress;
    unsigned char bOutEndpointAddress;
    unsigned char bInterfaceNumber;
    libusb_device *dev;
    pthread_mutex_t stLock;
    libusb_device_handle *handle;
    libusb_hotplug_callback_handle hotplugCbh;
    int event;
    int bNumConfigurations;
    //libusb_device **devs;
} usb_dev_mngr_s;

static usb_dev_mngr_s gstUsbMngr;

void usb_error(int code, int line)
{
    fprintf(stdout,"line %d:", line);
    
    switch (code) 
    {
        case LIBUSB_ERROR_IO:
            fprintf(stderr, "LIBUSB_ERROR_IO\n");
            break;
        case LIBUSB_ERROR_INVALID_PARAM:
            fprintf(stderr, "LIBUSB_ERROR_INVALID_PARAM\n");
            break;
        case LIBUSB_ERROR_ACCESS:
            fprintf(stderr, "Error: LIBUSB_ERROR_ACCESS\n");
            break;
        case LIBUSB_ERROR_NO_DEVICE:
            fprintf(stderr,    "LIBUSB_ERROR_NO_DEVICE\n");
            break;
        case LIBUSB_ERROR_NOT_FOUND:
            fprintf(stderr,    "LIBUSB_ERROR_NOT_FOUND\n");
            break;
        case LIBUSB_ERROR_BUSY:
            fprintf(stderr,    "LIBUSB_ERROR_BUSY\n");
            break;
        case LIBUSB_ERROR_TIMEOUT:
            fprintf(stderr,    "LIBUSB_ERROR_TIMEOUT\n");
            break;
        case LIBUSB_ERROR_OVERFLOW:
            fprintf(stderr,    "LIBUSB_ERROR_OVERFLOW\n");
            break;
        case LIBUSB_ERROR_PIPE:
            fprintf(stderr,    "LIBUSB_ERROR_PIPE\n");
            break;
        case LIBUSB_ERROR_INTERRUPTED:
            fprintf(stderr,    "LIBUSB_ERROR_INTERRUPTED\n");
            break;
        case LIBUSB_ERROR_NO_MEM:
            fprintf(stderr,    "LIBUSB_ERROR_NO_MEM\n");
            break;
        case LIBUSB_ERROR_NOT_SUPPORTED:
            fprintf(stderr,    "LIBUSB_ERROR_NOT_SUPPORTED\n");
            break;
        case LIBUSB_ERROR_OTHER:
            fprintf(stderr,    "LIBUSB_ERROR_OTHER\n");
            break;
        default:
            fprintf(stderr,"unkown error\n");
            break;
    }
}

static int usb_getEndpoint(const struct libusb_interface_descriptor * interface, usb_dev_mngr_s* user_device)
{
    int i;
    int ret = 0;
    const struct libusb_endpoint_descriptor *epdesc;
        
    for(i=0; i<interface->bNumEndpoints; i++)
    {
        epdesc = &interface->endpoint[i];
        
        if(epdesc->bmAttributes == LIBUSB_TRANSFER_TYPE_BULK) //transfer type :bulk 
        {
            if(epdesc->bEndpointAddress & LIBUSB_ENDPOINT_IN) // in endpoint
            {  
                printf("EP IN: %02x \n", epdesc->bEndpointAddress);
                   user_device->bInEndpointAddress = epdesc->bEndpointAddress;
            }
            //else if (epdesc->bEndpointAddress & LIBUSB_ENDPOINT_OUT)// out endpoint
            else if (!(epdesc->bEndpointAddress & LIBUSB_ENDPOINT_IN))
            {
                printf("EP OUT: %02x \n", epdesc->bEndpointAddress);
                   user_device->bOutEndpointAddress = epdesc->bEndpointAddress;
            }
        }

        if (user_device->bInEndpointAddress && user_device->bOutEndpointAddress)
        {
            ret = 1;
            break;
        }
    }

    return ret;
}


static int usb_getUSBInfo(usb_dev_mngr_s* user_device)
{
    int rv = -1;
    int i,j,k;
    struct libusb_config_descriptor *conf_desc = NULL;
    const struct libusb_interface *inter;
    const struct libusb_interface_descriptor *interdesc;
    
    for (i = 0; i < user_device->bNumConfigurations; i++)
    {
        if(user_device->dev != NULL)
        {
            if (LIBUSB_SUCCESS != libusb_get_config_descriptor(user_device->dev, i, &conf_desc))
            {
                continue;
            }
        }
        
        for (j = 0; j < conf_desc->bNumInterfaces; j++)
        {
            inter = &conf_desc->interface[j];
            
            for (k=0; k < inter->num_altsetting; k++)
            {
                interdesc = &inter->altsetting[k];
            
                if(interdesc->bInterfaceClass == LIBUSB_CLASS_VENDOR_SPEC && interdesc->bInterfaceSubClass == LIBUSB_CLASS_VENDOR_SPEC)
                {
                    if (user_device->bInEndpointAddress <= 0 || user_device->bOutEndpointAddress <= 0)
                    {
                         if(usb_getEndpoint(interdesc, user_device))
                        {
                            user_device->bInterfaceNumber = interdesc->bInterfaceNumber;
                            rv = 0;
                            break;
                        }
                    }
                }
                else
                {
                    printf("bInterfaceClass:%02x, bInterfaceSubClass:%02x\n", interdesc->bInterfaceClass, interdesc->bInterfaceSubClass);
                }
            }
        }

        libusb_free_config_descriptor(conf_desc);
        conf_desc = NULL;

        if (0 == rv)
        {
            break;
        }
    }

    return rv;
}

//检查安卓设备是否处于Accessory模式
static int usb_checkAccessory(uint16_t idVendor, uint16_t idProduct)
{
    if (idVendor == VID_GOOGLE)
    {
        switch (idProduct)
        {
            case PID_AOA_ACC:
            case PID_AOA_ACC_ADB:
            case PID_AOA_ACC_AU:
            case PID_AOA_ACC_AU_ADB:
                return 1;

            //音频
            case PID_AOA_AU:    
            case PID_AOA_AU_ADB:
                break;
            
            default:
                break;
        }
    }

    return 0;
}

static int usb_sendCtrl(libusb_device_handle *handle, char *buff, int req, int index)
{
    int ret = 0;
    
    if (NULL != buff) 
    {
        ret = libusb_control_transfer(handle, 0x40, req, 0, index, buff, strlen(buff) + 1, 0);
    } 
    else 
    {
        ret = libusb_control_transfer(handle, 0x40, req, 0, index, NULL, 0, 0);
    }

    if (ret < 0) {
        usb_error(ret, __LINE__);
    }

    return ret;
}

static int usb_setupAccessory(libusb_device *dev)
{
    unsigned char ioBuffer[2] = {0};
    int aoaVersion;
    int ret = 0;
    libusb_device_handle *handle = NULL;
    
    ret = libusb_open (dev, &handle);
    if (LIBUSB_SUCCESS != ret) 
    {
        printf("libusb_open failed, ret:%d\n", ret);
        usb_error(ret, __LINE__);
        return -1;
    }

    //如果USB连接到内核驱动则进行 detach
    //libusb_set_auto_detach_kernel_driver(gstUsbMngr.handle, 1);
    if(libusb_kernel_driver_active(handle, 0) > 0)
    {
        printf("kernel driver active, ignoring device");
        if(libusb_detach_kernel_driver(handle, 0) != LIBUSB_SUCCESS) 
        {
            printf("failed to detach kernel driver, ignoring device");
            goto EXIT;;
        }
    }
    
    //发送序号为51的USB报文，获取手机的AOA协议版本，目前为1或2
    ret = libusb_control_transfer(handle, 0xC0, 51, 0, 0, ioBuffer, 2, 1000);
    if (ret < 0) 
    {
        usb_error(ret, __LINE__);
        goto EXIT;
    }

    aoaVersion  = ioBuffer[1] << 8 | ioBuffer[0];
    printf("AOA Verion: %d \n", aoaVersion);
    if (aoaVersion != 1 && aoaVersion != 2)
    {
        goto EXIT;
    }

    ret = -1;
    usleep(1000);

    //发送序号为52的USB报文，涉及制造商、型号、版本、设备描述、序列号、uri
    if (usb_sendCtrl(handle, manufacturer, 52, 0) < 0) {
        goto EXIT;
    }
    if (usb_sendCtrl(handle, modelName, 52, 1) < 0) {
        goto EXIT;
    }
    if (usb_sendCtrl(handle, description, 52, 2) < 0) {
        goto EXIT;
    }
    if (usb_sendCtrl(handle, version, 52, 3) < 0) {
        goto EXIT;
    }
    if (usb_sendCtrl(handle, uri, 52, 4) < 0) {
        goto EXIT;
    }
    if (usb_sendCtrl(handle, serialNumber, 52, 5) < 0) {
        goto EXIT;
    }

    printf("Accessory Identification sent\n");

    //发送序号为53的USB报文，切换USB模式
    if (usb_sendCtrl(handle, NULL, 53, 0) < 0) {
        goto EXIT;
    }

    ret = 0;

EXIT:    
    libusb_close(handle);
    handle = NULL;
    return ret;
}

static int usb_openUSB(void)
{
    int rc = 0;
    
    rc = libusb_open(gstUsbMngr.dev, &gstUsbMngr.handle);
    if (LIBUSB_SUCCESS != rc) 
    {
        return -1;
    }

    //声明读写接口
    rc = libusb_claim_interface(gstUsbMngr.handle, gstUsbMngr.bInterfaceNumber);
    if (LIBUSB_SUCCESS != rc)
    {
        libusb_close(gstUsbMngr.handle);
        gstUsbMngr.handle = NULL;
        return -1;    
    }

    return 0;
}

/*
    不能在usb_hotplugCallback调用usb_handleHotplugArrived和usb_handleHotplugLeft
    否则会出现LIBUSB_ERROR_BUSY
*/
int usb_handleHotplugArrived(void)
{
    int rc = 0;

    printf("===>> usb_handleHotplugArrived \n");
    pthread_mutex_lock(&gstUsbMngr.stLock);

    if (!usb_checkAccessory(gstUsbMngr.vid, gstUsbMngr.pid))//不是AOA模式
    {
        rc = usb_setupAccessory(gstUsbMngr.dev);
        if (rc)
        {
            fprintf (stderr, "usb_setupAccessory Error, rc:%d\n", rc);
            pthread_mutex_unlock(&gstUsbMngr.stLock);
            return -1;
        }
    }
    else    //是AOA模式
    {
        rc = usb_getUSBInfo(&gstUsbMngr);
        if (rc)
        {
            fprintf (stderr, "usb_getUSBInfo Error, rc:%d\n", rc);
            pthread_mutex_unlock(&gstUsbMngr.stLock);
            return -1;
        }

        rc = usb_openUSB();
        if (rc)
        {
            fprintf (stderr, "usb_openUSB Error, rc:%d\n", rc);
            pthread_mutex_unlock(&gstUsbMngr.stLock);
            return -1;
        }
    }
    
    pthread_mutex_unlock(&gstUsbMngr.stLock);
    return 0;
}

int usb_handleHotplugLeft(void)
{    
    if (gstUsbMngr.handle)
    {
        libusb_release_interface (gstUsbMngr.handle, gstUsbMngr.bInterfaceNumber);
        libusb_close (gstUsbMngr.handle);
        gstUsbMngr.handle = NULL;
    }

    return 0;
}

static int LIBUSB_CALL usb_hotplugCallback(libusb_context *ctx, libusb_device *dev, libusb_hotplug_event event, void *user_data)
{
    int rc;
    struct libusb_device_descriptor desc;

    pthread_mutex_lock(&gstUsbMngr.stLock);
    
    rc = libusb_get_device_descriptor(dev, &desc);
    if (LIBUSB_SUCCESS != rc) {
        fprintf (stderr, "Error getting device descriptor\n");
        pthread_mutex_unlock(&gstUsbMngr.stLock);
        return -1;
    }

    if (event == LIBUSB_HOTPLUG_EVENT_DEVICE_ARRIVED)//插入
    {
        if (0x1d6b == desc.idVendor && 0x0002 == desc.idProduct) //过滤设备本身存在的usb设备
        {
            pthread_mutex_unlock(&gstUsbMngr.stLock);
            return 0;
        }
        
        printf ("Device attached: %04x:%04x\n", desc.idVendor, desc.idProduct);

        gstUsbMngr.vid = desc.idVendor;
        gstUsbMngr.pid = desc.idProduct;
        gstUsbMngr.bInEndpointAddress = 0;
        gstUsbMngr.bOutEndpointAddress = 0;
        gstUsbMngr.bNumConfigurations = desc.bNumConfigurations;
        gstUsbMngr.dev = dev;
        gstUsbMngr.event = event;
        
    }
    else if (event == LIBUSB_HOTPLUG_EVENT_DEVICE_LEFT)//拔出
    {
        printf ("Device detached: %04x:%04x\n", desc.idVendor, desc.idProduct);
        gstUsbMngr.event = event;
    }
    else
    {
        printf("event wrong, event: %d \n", event);        
        gstUsbMngr.event = 0;
    }
    
    pthread_mutex_unlock(&gstUsbMngr.stLock);
    return 0;
}

//监听事件
void *usb_eventMonitorProcess(void *args)
{
    int rc = 0;
    
    while(1)
    {
        //处理事件
        if (gstUsbMngr.event == LIBUSB_HOTPLUG_EVENT_DEVICE_ARRIVED)
        {
            usb_handleHotplugArrived();
            gstUsbMngr.event = 0;
        }
        else if (gstUsbMngr.event == LIBUSB_HOTPLUG_EVENT_DEVICE_LEFT)
        {
            usb_handleHotplugLeft();
            gstUsbMngr.event = 0;
        }

        //事件循环（阻塞），读写USB会触发
        rc = libusb_handle_events(NULL);
        if (rc < 0)
        {
            printf("libusb_handle_events() failed: %s\n", libusb_error_name(rc));
        }
    }    
    
    return NULL;
}

int usb_write(char *buf, int bufLen)
{
    int rc  = 0;
    int nActualBytes = 0;
    
    pthread_mutex_lock(&gstUsbMngr.stLock);
    
    if (NULL == gstUsbMngr.handle || 0 != gstUsbMngr.event)
    {
        pthread_mutex_unlock(&gstUsbMngr.stLock);
        return -1;
    }
    
    rc = libusb_bulk_transfer(gstUsbMngr.handle, gstUsbMngr.bOutEndpointAddress, (unsigned char *)buf, bufLen, &nActualBytes, 1000);
    if (rc < 0)
    {
        printf("libusb_bulk_transfer(0x01) write failed:[%s] \n", libusb_strerror(rc));
        pthread_mutex_unlock(&gstUsbMngr.stLock);
        return rc;
    }
    
    pthread_mutex_unlock(&gstUsbMngr.stLock);
    return nActualBytes;
}

int usb_read(char *buf, int bufLen)
{
    int rc  = 0;
    int nActualBytes = 0; 
        
    pthread_mutex_lock(&gstUsbMngr.stLock);
    
    if (NULL == gstUsbMngr.handle || 0 != gstUsbMngr.event)
    {
        pthread_mutex_unlock(&gstUsbMngr.stLock);
        return -1;
    }

    rc = libusb_bulk_transfer(gstUsbMngr.handle, gstUsbMngr.bInEndpointAddress, (unsigned char *)buf, bufLen, &nActualBytes, 1000);
    if (rc < 0)
    {
        //printf("libusb_bulk_transfer(0x81) read failed:[%s] \n", libusb_strerror(rc));
        pthread_mutex_unlock(&gstUsbMngr.stLock);
        return rc;
    }
    
    pthread_mutex_unlock(&gstUsbMngr.stLock);
    return nActualBytes;
}

//测试读写
void *usb_readProcess(void *args)
{
    int rc = 0;
    char readBuf[4*1024] = {0};
    int nActualBytes = 0;
        
    while (1)
    {
        if (NULL == gstUsbMngr.handle)
        {
            usleep(100*1000);
            continue;
        }
        
        rc = usb_read(readBuf, sizeof(readBuf));
        if (rc > 0)
        {
            usb_write(readBuf, rc);
        }    
    }    
}

int usb_init(void)
{
    int product_id, vendor_id, class_id;
    int rc;
    pthread_t tid;
    
    vendor_id = LIBUSB_HOTPLUG_MATCH_ANY;
    product_id = LIBUSB_HOTPLUG_MATCH_ANY;
    class_id = LIBUSB_HOTPLUG_MATCH_ANY;

    memset(&gstUsbMngr, 0x0, sizeof(usb_dev_mngr_s));
    
    rc = pthread_mutex_init(&gstUsbMngr.stLock, NULL);
    if (rc)
    {
        printf("pthread_mutex_init failed \n");
        return EXIT_FAILURE;
    }    

    rc = libusb_init (NULL);
    if (rc < 0)
    {
        printf("failed to initialise libusb: %s\n", libusb_error_name(rc));
        return EXIT_FAILURE;
    }
    
    //获取当前库是否支持热插拔
    if (!libusb_has_capability (LIBUSB_CAP_HAS_HOTPLUG)) {
        printf("Hotplug capabilities are not supported on this platform\n");
        libusb_exit (NULL);
        return EXIT_FAILURE;
    }
    
    //注册热插拔事件回调
    rc = libusb_hotplug_register_callback (NULL, LIBUSB_HOTPLUG_EVENT_DEVICE_ARRIVED | LIBUSB_HOTPLUG_EVENT_DEVICE_LEFT, LIBUSB_HOTPLUG_ENUMERATE, vendor_id,
        product_id, class_id, usb_hotplugCallback, NULL, &gstUsbMngr.hotplugCbh);
    if (LIBUSB_SUCCESS != rc) {
        printf("libusb_hotplug_register_callback failed \n");
        libusb_exit (NULL);
        return EXIT_FAILURE;
    }
    
    //开启事件处理线程
    pthread_create(&tid, NULL, usb_eventMonitorProcess, NULL);
    
    return LIBUSB_SUCCESS;
}

int usb_deinit(void)
{
    if (gstUsbMngr.handle) {
        libusb_release_interface(gstUsbMngr.handle, gstUsbMngr.bInterfaceNumber);
        libusb_close (gstUsbMngr.handle);
        gstUsbMngr.handle = NULL;
    }
    
    if (0 < gstUsbMngr.hotplugCbh) {
        libusb_hotplug_deregister_callback(NULL, gstUsbMngr.hotplugCbh);        
    }
    
    pthread_mutex_destroy(&gstUsbMngr.stLock);  
    libusb_exit (NULL);
    return LIBUSB_SUCCESS;
}

int main(int argc, char *argv[])
{
    int rc;
    pthread_t tid;
        
    rc = usb_init();
    if (LIBUSB_SUCCESS != rc)
    {
        return -1;
    }
    
    pthread_create(&tid, NULL, usb_readProcess, NULL);
    
    while (1)
    {
        sleep(1);
    }    

    usb_deinit();
    return EXIT_SUCCESS;
}

参考：

libusb API说明：

https://www.cnblogs.com/kwinwei/p/14437975.html

libusb 官方API说明：

https://libusb.sourceforge.io/api-1.0/libusb_api.html

AOA协议：

https://www.taodocs.com/p-753985804.html

B!GGer.
关注
  • 2
    点赞
  • 踩
  • 20
    收藏
    觉得还不错? 一键收藏
  • 2
    评论
专栏目录
andromon-android:适用于具有 AOA 协议的 Android 设备的 Android 应用程序，可将其用作显示器、键盘或鼠标
06-20
安卓系统 适用于具有 AOA 协议的 Android 设备的 Android 应用程序，可将其用作显示器、键盘或鼠标。 必须安装名为 andromon-linux 的支持驱动程序
Android USB的AOA协议设备端(主机模式,配件模式)，ADB连接
ShareUs的专栏
12-26 1万+
USB的ADB/AOA协议（一种是ADB模式，一种是AOA模式）。AOA协议是Google公司推出的用于实现Android设备与外围设备之间USB通信的协议。 ADK中与USB配件模式相关的两个类是UsbManager和UsbAccessory。 > USB Android实战技巧之四十九：Usb通信之USB Host- http://blog.csdn.net/lincyang/...
安卓投屏 Scrcpy 在连接设备后闪退报错 LIBUSB_ERROR_ACCESS 解决
最新发布
卡尔特斯
04-01 1046
这可能是因为设备正在被其他进程使用，或者应用程序没有足够的权限去访问设备。项目自动连接了设备，它是自动连接设备，进行调试的，我把这个相关关闭之后，再次执行。5、如果问题依然存在，可能需要检查设备驱动程序是否正确安装，或者更新到最新版本。3、如果是在开发过程中遇到这个问题，确保设备已经正确连接到电脑，并且在。如果以上步骤无法解决问题，可能需要更详细地调查具体的应用程序或系统环境。4、重新启动设备和计算机，有时候这能解决临时的访问问题。设备访问权限，并在获得用户授权后再访问设备。去连接设备，但是我有一个。
Android的USB通信（AOA连接）
分享技术与经验的博客
05-09 7496
USB 主机和配件概览 Android 通过 USB 配件和 USB 主机两种模式支持各种 USB 外围设备和 Android USB 配件（实现 Android 配件协议的硬件）。在 USB 配件模式下，外部 USB 硬件充当 USB 主机。配件示例可能包括机器人控制器、扩展坞、诊断和音乐设备、自助服务终端、读卡器等等。这样，不具备主机功能的 Android 设备就能够与 USB 硬件互动。Android USB 配件必须设计为与 Android 设备兼容，并且必须遵守 Android 配件通信协议。在
基于libUsb库实现Hid USB设备通讯
11-20
OnInitDialog()下添加如下代码： struct usb_bus *busses, *bus; // usb_dev_handle *handle = NULL; //这个需定义为全局变量，在读线程中也许使用 usb_init(); usb_find_busses(); usb_find_devices(); busses = usb_get_busses(); for(bus = busses; bus; bus = bus->next) { struct usb_device *dev;
通过libusb库文件实现的USB通讯源代码
05-28
环境采用vc++6.0，下位机采用圈圈教你玩USB的板子，程序是hid设备，程序中详细写了如何初始化libusb，并通过它写数据和创建读线程读取数据，程序需插入下位机才能运行成功！
Libusb在Android平台上的环境以及原理
hehao13956455的博客
11-27 4748
    一、环境：配置NDK环境 1、下载libusb源码：https://github.com/libusb/libusb/releases，如下图所示 2、删除一些和Android平台无关的文件，删除后的文件如下图所示： 思考问题： Android是怎么获取usb设备？ 如上图所示：连接adb shell，然后cd到/sys/bus/usb/devices/目录，命令ll...
Android libusb库的使用
汽车以太网和SOA
06-16 8004
Android libusb库的使用
USB的ADB/AOA协议
TyearLin的专栏
04-14 1251
至于在之前的Android版本没有直接提供USB通信支持时，我们只能使用ADB的方式来实现Android设备与其他的设备通过USB线进行通信（Android设备只能以从机的方式接入，因为之前的Android设备都不支持OTG），而这也是到目前为止Android设备与PC通过USB线进行通信的唯一方式（常见的案例有豌豆荚、360手机助手等）。AOA协议是Android设备与Android配件之间进行USB通信需遵循的连接协议，该协议规定了Android配件如何检测Android设备并与其建立通信。
基于libusb库、uac协议，获取Audio声音数据
xyzahaha的博客
11-26 3916
android_usbaudio 基于libusb，实现无驱动获取USBAudio 期望实现的功能： 通过libusb获取USBAudio数据，无需SELinux声卡权限 部分摄像头无法获取音频问题解决思路： 无法获取音频的原因：当前传过去的采样率在设备当前选择的Audio Interface中不存在！ 描述：我们打开的设备声卡通道它当前自己有一个固定的采样率，主机这边传过去的采样率和设备当前的端点的采样率不匹配，就会导致拿不到音频数据 如：设备当前采样率为32000，主机传过去的采样率为48000
libusb函数说明
热门推荐
wince_lover的专栏
04-21 2万+
libusb api接口说明
基于USB2.0 libusb开源库的 上位机完整程序
09-09
包括libusb的动态链接库调用，USB热插板处理，从STM32 读取数据，显示文件列表,选择路径存储文件，软件使用说明书，详细步骤；
android libusb 已经成功编译拿去能用
05-09
android libusb 已经成功编译拿去能用用ndk-build编译
usb4java:基于libusb的Java USB库
04-24
usb4java 基于libusb 1.0的Java USB库 版权所有（C）2011 Klaus Reimer， 版权所有（C）2013 Luca Longinotti， 有关许可信息，请参阅LICENSE.md。 该库可用于访问Java中的USB设备。 它基于本地libusb 1.0共享库，并且尽可能完整地反映了此API。 usb4java还实现了javax-usb（JSR80）API。 因此，您可以选择是否要通过低级libusb 1.0 API或高级别javax-usb API访问USB设备。 本机库以预编译的形式包含在32位和64位版本Linux，Windows和Mac OS X中。 库是自动提取并加载的，因此您无需关心它们。 有关更多详细信息，请访问。
基于libusb的Linux平台USB设备管控与审计系统设计.pdf
09-06
基于libusb的Linux平台USB设备管控与审计系统设计.pdf
[资料]安卓 usb开发
二次元怪兽的博客
01-21 252
Android设备的USB通讯——AOA协议 安卓USB开发教程 <五> 安卓 AOA 1.0
build libusb for Android
ARM-Linux
01-10 1220
平台 libusb版本：libusb-1.0.20 Ubuntu： 14.04 NDK：android-ndk-r9d 测试手机：三星S4 开发板：GD32 ================== Building: --------- To build libusb for Android do the following: 1. Download the l...
Libusb库在Android下的使用例程
hubbybob1专栏
02-06 2万+
转载请注明：http://blog.csdn.net/hubbybob1/article/details/54863662 阅读本文前清先了解相关基础内容，操作步骤请阅读博客：libusb1.0在android内的移植和使用方法 在讲解了libusb库在Android下的移植和基本应用后，下面来讲解Libusb的Android工程；其工程步骤： 1.建立带有JNI工程的eclipse工
libusb库做usb通信
06-22
### 回答1： libusb是一款开源的USB设备访问库，用于在用户空间下与USB设备进行通信，它支持设备的（初始化、发送控制传输命令、批量传输、中断传输、异步传输），不仅支持在Linux平台上使用，还支持在Windows、MAC OS X等平台上使用。对于具有以下情况的开发者只能使用libusb进行开发：需要快速开发应用程序；需要具有跨平台的移植性；需要在用户空间与USB设备进行通信；需要使用USB的批量传输、中断传输、异步传输等传输方式；需要控制USB设备的状态信息。 使用libusb库需要先安装libusb-1.0的开发包，在使用库函数前需要先调用libusb_init()函数对库进行初始化，获取设备列表可通过调用libusb_get_device_list()函数，获取设备描述符可通过libusb_get_device_descriptor()函数。对于USB通信可通过libusb_control_transfer()函数进行设备控制传输。同时还有异步传输和同步传输两种方法，可通过回调函数获取传输状态。 libusb库的优点是它是跨平台的，能够支持不同操作系统和编译平台。使用libusb的开发者可以轻松地在不同的操作系统中进行开发和调试。同时，由于使用了libusb库，将不再需要内核模块支持，它可以帮助开发者轻松地实现USB设备的协议规范和必要的数据处理，从而更加高效地进行开发。不过需要注意的是，由于libusb库在进行USB通信时需要进行复杂的数据传输协议和校验，因此其编程难度较大，需要开发者拥有较好的编程基础。 ### 回答2： libusb是一个跨平台的开源用户空间USB库，可用于在Linux、Windows、macOS等不同操作系统中进行USB通信。它提供了丰富的API，可以用于设备的发现、配置、数据传输和控制等方面。 使用libusb库进行USB通信需要首先初始化库，并对设备进行枚举，从而获得正确的设备句柄。之后可以通过读/写数据端点来进行数据传输，还可以进行控制传输，调整设备配置，发送控制命令等操作。在传输数据时，可以设置超时时间以避免阻塞。 与其他USB库相比，libusb库具有跨平台，轻量级，可移植性高等优点。它可以使用自由软件协议开源自由使用，而且易于添加到项目中。在开发USB设备应用程序时，使用libusb库可以大大提高开发效率，并降低开发难度。 总之，libusb库是一个功能强大的USB通信库，适用于各种应用领域，它为软件开发人员提供了接口，使得USB设备与计算机之间的通信变得更加简单和高效，而且易于移植和开发。 ### 回答3： libusb是一个可移植且独立于操作系统的应用程序接口库，主要用于在用户空间进行USB通信。该库支持操作系统如Windows、Linux、Mac OS、FreeBSD等，同时也支持USB设备的各种功能，例如控制传输、批量传输、中断传输和同步传输等。 通过使用这个库，应用程序就能够直接访问USB设备，无需编写复杂的驱动程序，从而简化了开发流程，并提高了应用程序的可移植性和可维护性。 使用libusb库时，我们可以使用其API来设置USB设备的传输方式、检测USB设备的插拔状态、请求和接收数据等操作。 另外，该库还提供了对USB控制请求和端点映射的支持，并允许应用程序与多个USB设备进行通信。 需要注意的是，在使用libusb库时，需要设置USB设备的访问权限，以避免权限访问限制导致的访问失败等问题。同时，在进行数据传输时也需要遵循USB传输协议，如控制传输时需要按照设备描述符、配置描述符等协议进行相关的控制。 总之，使用libusb库做USB通信可以方便地实现对USB设备的控制和数据传输，并且能够跨平台使用，具有良好的可移植性和可维护性。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值