一篇搞定Linux和IOS或Android通讯（usbmuxd、libimobiledevice、libusb、AOA）

已于 2023-03-09 14:43:32 修改
阅读量3.4k 收藏 21
点赞数 2
分类专栏： 协议 文章标签： linux 智能手机 android
于 2023-03-08 14:23:11 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_38165614/article/details/129379448
版权

1、Linux要与苹果手机通讯需要两个组件

1、usbmuxd 是苹果的一个服务，这个服务主要用于在USB协议上实现多路TCP连接，将USB通信抽象为TCP通信。苹果的iTunes、Xcode，都直接或间接地用到了这个服务。
参考链接：https://www.theiphonewiki.com/wiki/Usbmux
2、libimobiledevice是一个跨平台的软件库，用于与iOS设备进行交互。
参考链接：https://www.theiphonewiki.com/wiki/MobileDevice_Library

编译安装上面2个库就直接可以使用socket套接字进行通讯

上代码

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/stat.h>
#include <sys/socket.h>
#include <sys/types.h>
#include <sys/un.h>
#include <errno.h>
#include <stddef.h>
#include <unistd.h>
#include <pthread.h>

#define MAX_CONNECT_NUM 2
#define BUFFER_SIZE 1024
const char *filename = "/var/run/usbmuxd";
static pthread_t th;
static pthread_t th1;

//sudo mv /var/run/usbmuxd /var/run/usbmuxx
// sudo socat -t100 -x -v UNIX-LISTEN:/var/run/usbmuxd,mode=777,reuseaddr,fork UNIX-CONNECT:/var/run/usbmuxx


void *thread_recv(void *ptr)
{
    int fd = *(int *)ptr;
    char buffer[BUFFER_SIZE];
    bzero(buffer, BUFFER_SIZE);

    while (1)
    {
        printf("waiting recv...\n");
        int ret = recv(fd, buffer, BUFFER_SIZE, 0);

        if (ret <= 0)
        {
            printf("recv failed\n");
            close(fd);
            pthread_cancel(th1);
            return NULL;
        }

        printf("%s\n", buffer);

        if (strncmp("end", buffer, 3) == 0)
        {
            close(fd);
            exit(0);
        }
    }
}

void *thread_send(void *ptr)
{
    int fd = *(int *)ptr;
    while(1)
    {
        char buff[128] = {0};
        fgets(buff, 128, stdin);

        int ret = send(fd, buff, 128, 0);
        if (ret <= 0)
        {
            close(fd);
            pthread_cancel(th);
            return NULL;
        }
    }
}

int main()
{
    int fd, new_fd, len, i;
    //struct sockaddr_un结构有两个参数：sun_family、sun_path
    //sun_family只能是AF_LOCAL或AF_UNIX，而sun_path是本地文件的路径。
    struct sockaddr_un un;
    fd = socket(AF_UNIX, SOCK_STREAM, 0);//SOCK_DGRAM是基于UDP的
    //本地套接字的通讯类型应该是SOCK_STREAM或SOCK_DGRAM，协议为默认协议。
    if (fd < 0)
    {
        printf("Request socket failed!\n");
        return -1;
    }
    un.sun_family = AF_UNIX;
    strcpy(un.sun_path, filename);
    if (bind(fd, (struct sockaddr *)&un, sizeof(un)) < 0)
    {
        printf("bind failed!\n");
        return -1;
    }
    if (listen(fd, MAX_CONNECT_NUM) < 0)
    {
        printf("listen failed!\n");
        return -1;
    }
    while (1)
    {
        printf("wait to accept...\n");

        new_fd = accept(fd, NULL, NULL);

        printf("new accept.\n");

        if (new_fd < 0)
        {
            printf("accept failed\n");
            return -1;
        }
        pthread_create(&th, NULL, thread_recv, (void *)(&new_fd));
        pthread_create(&th1, NULL, thread_send, (void *)(&new_fd));

    }
    close(fd);
}

2、Linux要与Android手机通讯只需要一个库

libusb是一个开源的用C实现的，应用程序与用户的USB设备进行通信的库。 链接地址：https://github.com/libusb/libusb
编译安装好上面的库后直接可以使用AOA进行通讯了

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

不是AOA模式
USB会出现一次逻辑拔插过程触发一次拔出事件和一次插入事件手机切换VID和PID为AOA模式
是AOA模式
与Android手机通讯
进入切换到AOA模式流程
1.打开usb设备
2.发送AOA协议报文交互
2.发送AOA协议报文交互
3.关闭usb设备
4.USB已切换为AOA模式
5.获取USB接口信息
6.打开USB设备并声明读写接口建立AOA数据通道
获取USB接口信息
打开USB设备并声明读写接口建立AOA数据通道 
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <pthread.h>
#include <unistd.h>
#include "libusb.h"

/*手机通过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数据通道*/
#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

//PID	模式
//0x2D00	accessory
//0x2D01	accessory + adb
//0x2D02	audio
//0x2D03	audio + adb
//0x2D04	accessory + audio
//0x2D05	accessory + audio + adb

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;
}

//获取USB的信息
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;
}

//LIBUSB_HOTPLUG_EVENT_DEVICE_LEFT 设备拔出事件
int usb_handleHotplugLeft(void)
{
    if (gstUsbMngr.handle)
    {
        libusb_release_interface (gstUsbMngr.handle, gstUsbMngr.bInterfaceNumber);
        libusb_close (gstUsbMngr.handle);
        gstUsbMngr.handle = NULL;
    }

    return 0;
}

//USB 插入回调函数
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)
    {
        //处理事件
        //IBUSB_HOTPLUG_EVENT_DEVICE_ARRIVED设备插入事件
        //LIBUSB_HOTPLUG_EVENT_DEVICE_LEFT 设备拔出事件
        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;//设置为 LIBUSB_HOTPLUG_MATCH_ANY 来匹配所有
    product_id = LIBUSB_HOTPLUG_MATCH_ANY;//设置为 LIBUSB_HOTPLUG_MATCH_ANY 来匹配所有
    class_id = LIBUSB_HOTPLUG_MATCH_ANY;//设置为 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;
    }

    //注册热插拔事件回调
    //配件向 endpoint 0 端口中写入 51 号指令，
    //如果返回值为1 或者 2，则说明Android 设备支持 AOA1.0 或者 AOA2.0，
    //如果小于 1 或者大于 2，则说明连接设备不支持AOA协议或者支持的 AOA 协议版本号不正确。
    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;
}

如果对你有帮助，请给予作者一丝丝奖励
在这里插入图片描述
在这里插入图片描述在这里插入图片描述

道士出山
关注
  • 2
    点赞
  • 踩
  • 21
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
ios命令行调试工具libimobiledevice详解
03-22
libimobiledevice是一个跨平台的库，允许开发者通过命令行与iOS设备进行通信，而无需依赖苹果的私有库或设备越狱。以下是对libimobiledevice中一些常用命令的详细解释： 1. **idevicepair**：这个命令用于建立电脑...
usbmuxd：套接字守护程序，用于多路复用iOS设备之间的连接
02-01
libimobiledevice是一个跨平台的C语言库，允许开发者编写应用程序来控制和管理iOS设备，包括解锁、备份、恢复等操作。 5. 安全性：由于usbmuxd在用户空间运行，而非内核空间，它降低了系统的安全风险。此外，它还...
android平台usbmuxd编译与iphone连接进行数据传输
idlegao的专栏
12-02 3480
一.usbmuxd简介 usbmuxd 是苹果官方的一个服务，这个服务主要用于在USB协议上实现TCP连接，将USB通信转化为TCP通信。苹果的iTunes、Xcode，都直接或间接地用到了这个服务。libimobiledevice集成了usbmuxd的服务。 二.下载libimobiledevice https://github.com/xxDroid/libimobiledevice-a...
探索libusbmuxd：与iOS设备无缝交互的利器
gitblog_00092的博客
05-10 438
探索libusbmuxd：与iOS设备无缝交互的利器 项目地址:https://gitcode.com/libimobiledevice/libusbmuxd 项目介绍 在移动开发领域，与iOS设备进行通信是一个不可或缺的部分。libusbmuxd是一个强大的库，它为应用程序提供了一种处理与iOS设备的usbmux协议连接的方法。这个项目还包括一些命令行工具，如iproxy和inetcat，它们让...
探索开源项目：usbmuxd - iOS设备的USB多路复用守护进程
gitblog_00052的博客
05-09 435
探索开源项目：usbmuxd - iOS设备的USB多路复用守护进程 项目地址:https://gitcode.com/libimobiledevice/usbmuxd 在移动开发的世界中，与iOS设备进行无缝交互是至关重要的。【usbmuxd】是一个强大的开源项目，它提供了一个开放源代码的实现，用于通过USB与iPhone、iPad等iOS设备建立和管理连接。不仅如此，该项目还兼容多种操作系统，...
usbmuxd通过交叉编译移植到Android上（三）之libusb1.0
VendorLinux的博客
12-21 1530
usbmuxd通过交叉编译移植libusb到Android上
Linux设备通过USB线与手机通信(Android、IOS)
sj1085745538的专栏
06-04 4461
背景介绍 通过手机USB连接遥控器，无人机的视频经遥控器实时传到手机预览，手机也可以通过USB发送指令给无人机，或者从无人机下载视频照片到手机。 方案选择 IOS手机使用usbmuxd方式，这样就不需要MFI认证，Android手机使用AOA协议，框图如下： 原理解析 手机通过USB发送rtsp/http/ftp等消息，经过遥控器，遥控器起到了一个数据转发的作用，将接收到手机的消...
usbmuxd通过交叉编译移植到Android(四)-libimobiledevice
VendorLinux的博客
12-27 1590
usbmuxd通过交叉编译移植依赖库-libimobiledevice
android和ios测试环境搭建,iOS自动化测试环境搭建
weixin_35029527的博客
05-26 324
macOS相关库安装* libimobiledevicebrew install libimobiledevice使用本机与iOS设备的服务进行通信的库。* ideviceinstallerbrew install ideviceinstaller获取设备uuid、安装app、卸载app、获取bundleid。* carthagebrew install carthage第三方库管理工具。* io...
iOS和Android从命令行获取log的方式
weixin_43643587的博客
09-21 1430
比较经常的Android要查看某个APP运行时的log,都是使用Android studio的logcat模块，工具也较多，过滤搜索也都很好的支持；iOS程序一般使用xcode，在控制台查看在某些过滤需求比较简单的场景，比如只想过滤某个关键字的log看看，可以在命令行快速输出，那一定是很棒的!
usbmuxd通过交叉编译移植到Android上（一）
VendorLinux的博客
12-20 1981
android平台支持usbmuxd
libimobiledevice：一个跨平台协议库，用于与iOS设备通信
01-28
libimobiledevice是一个跨平台软件库，用于讨论与iOS设备进行交互的协议。 与其他项目不同，它不依赖使用任何现有的专有库，也不需要越狱。 一些关键功能是： 接口：为设备服务实现许多高级接口 实现：面向对象的...
ios-deploy:Phonegap 的 ios-deploy 移植到 Linux（使用 libimobiledevice）
06-20
要求目前仅在 Linux Mint 17.1 上使用新版本的 libimobiledevice、libplist、libusbmuxd 和 usbmuxd 进行测试。建造libimobiledevice-dev（推荐版本 1.2.0） 库列表附加功能ideviceinstaller（可选，用于部署应用...
usbmuxd.rar
03-17
1，压缩包中包括libimobiledevice libplist libusb libusbmuxd usbmuxd 代码 2，使用：解压后将这些文件夹放至android编译目external目录下。 3，使用mmm -B ./external/libusb ...一个一个编译。
linux磁盘可视化分析工具
最新发布
吻等离子的博客
08-02 539
Baobab 是 GNOME 桌面环境中的一款图形化磁盘使用分析工具。它能够扫描文件系统并显示各个文件和目录的磁盘使用情况，以易于理解的树形图或圆环图展示。这种可视化方式使得用户能够快速找到占用空间较大的文件和目录。Baobab 是一款非常实用的磁盘使用可视化工具，特别适合用来分析和管理 Linux 系统中的磁盘空间。通过它的直观界面和强大的功能，用户可以轻松找到占用磁盘空间最多的文件和目录，从而采取相应的措施进行清理或优化。
linux一些基础知识（未完待续）
要把所有那些负面的信息当做对自身行为的评价，而不是对自身价值的评判。
08-02 207
/home/ljg下有多个汉字命名的文件夹，.local不在其中：
linux c 字符串环形buf （二）
yazhiye的专栏
08-02 462
字符串环形buf，支持多线程，通过满和空控制buf读写
Linux初学基本命令
yuan20010401的博客
07-25 1198
1、rm 文件名称 删除多个文件多个目录需要用空格 删除根目录（rm -rf /*）1、touch 文件名字 用于linux创建文件 创建多个目录需要用空格隔开。2、mkdir 目录名称 用于创建文件夹 创建多个嵌套文件夹需要用/隔开。1、cp 当前文件 其他目录名称 拷贝文件夹需要在最后 -r。退出不保存时按Esc+:q!1、ls 查看当前目录下面的文件或者文件夹。2、more 文件名称 查看文件更多内容。1、mv 原文件路径 目标文件路径。退出保存时按Esc + :wq。
libimobiledevice 能够模拟ios设置的usb拔插吗
06-09
是的，libimobiledevice 库可以模拟 iOS 设备的 USB 插拔事件。具体来说，libimobiledevice 库中的工具 `idevicedebug` 可以用于模拟 USB 插拔事件。您可以使用以下命令来模拟 USB 插拔事件： ``` # 模拟设备插入 idevicedebug -u <udid> pair # 模拟设备拔出 idevicedebug -u <udid> unpair ``` 其中，`<udid>` 是 iOS 设备的唯一标识符，可以使用 `idevice_id` 命令获取。例如，要模拟插入 UDID 为 `123456789abcdefg` 的设备，可以使用以下命令： ``` idevicedebug -u 123456789abcdefg pair ``` 注意：在使用 `idevicedebug` 工具之前，需要先使用 `idevicepair` 命令对设备进行配对。具体操作可以参考 libimobiledevice 的官方文档。
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值