Android MTP 分析

    if (pipe(mtppipe) < 0) {
        LOGE("Error creating MTP pipe\n");
        return false;
    }
    /* To enable MTP debug, use the twrp command line feature to
     * twrp set tw_mtp_debug 1
     */ 
    //DIR* source=opendir("/tmp");
    //DIR* destination=opendir("/data/media/0/backup");
    //copy_folder("/tmp","/data/media/0/backup");
    twrpMtp *mtp = new twrpMtp(0);
    mtppid = mtp->forkserver(mtppipe);
    //property_set("sys.usb.config", "mtp,adb");
    if (mtppid) {
        close(mtppipe[0]); // Host closes read side
        mtp_write_fd = mtppipe[1];
        //DataManager::SetValue("tw_mtp_enabled", 1);
        //Add_All_MTP_Storage();
        Add_Remove_MTP_Storage(MTP_MESSAGE_ADD_STORAGE);
        return true;
    } else {
        close(mtppipe[0]);
        close(mtppipe[1]);
        //gui_err("mtp_fail=Failed to enable MTP");
        return false;
    }

            LOGI("a[] = %s\n",a);
            LOGI("mtp_display = %s\n",mtp_display);
            const char *mtp_test=a;
            mtp_message.message_type = MTP_MESSAGE_ADD_STORAGE;
            mtp_message.storage_id = 1;
            mtp_message.path = "/data/media/0";
            mtp_message.maxFileSize = 0;
            mtp_message.display = PROJECT_NAME;
            LOGI("TEST MTP_DISPLAy\n");
            LOGI("sending message to add %i '%s' '%s'\n", mtp_message.storage_id, mtp_message.path, mtp_message.display);
            if (write(mtp_write_fd, &mtp_message, sizeof(mtp_message)) <= 0) {
                LOGI("error sending message to add storage %i\n", mtp_message.storage_id);
                return false;
            } else {
                LOGI("Message sent, add storage ID: %i\n",mtp_message.storage_id);
                return true;
            }

int twrpMtp::start(void) {
    MTPI("Starting MTP\n");
    twmtp_MtpServer *mtp = new twmtp_MtpServer();
    mtp->set_storages(mtpstorages);
    mtp->set_read_pipe(mtp_read_pipe);
    mtp->start();
    return 0;
}

void twmtp_MtpServer::start()
{
    usePtp =  false;
    MyMtpDatabase* mtpdb = new MyMtpDatabase();
    /* Sleep for a bit before we open the MTP USB device because some
     * devices are not ready due to the kernel not responding to our
     * sysfs requests right away.
     */
    usleep(800000);
#ifdef USB_MTP_DEVICE
#define STRINGIFY(x) #x 
#define EXPAND(x) STRINGIFY(x)
    const char* mtp_device = EXPAND(USB_MTP_DEVICE);
    MTPI("Using '%s' for MTP device.\n", EXPAND(USB_MTP_DEVICE));
#else   
    const char* mtp_device = "/dev/mtp_usb";
#endif
    //fp_mtp =fopen( "/recovery/mtp.log", "a+" );
    int fd = open(mtp_device, O_RDWR);
    if (fd < 0) {
        MTPE("could not open MTP driver, errno: %d\n", errno);
        return;
    } 
    MTPD("fd: %d\n", fd);
    server = new MtpServer(mtpdb, usePtp, 0, 0664, 0775);
    refserver = server;
    MTPI("created new mtpserver object\n");
    add_storage();
    MTPD("Starting add / remove mtppipe monitor thread\n");
    pthread_t thread;
    ThreadPtr mtpptr = &twmtp_MtpServer::mtppipe_thread;
    PThreadPtr p = *(PThreadPtr*)&mtpptr;
    pthread_create(&thread, NULL, p, this);
    // This loop restarts the MTP process if the device is unplugged and replugged in
    while (true) {
        server->run(fd);
        fd = open(mtp_device, O_RDWR);
        usleep(800000);
    }
}

void MtpServer::run(int fd) {
    if (fd < 0)
        return;

    mFD = fd;
    MTPI("MtpServer::run fd: %d\n", fd);

    while (1) {
        MTPD("About to read device...\n");
        int ret = mRequest.read(fd);
        if (ret < 0) {
            if (errno == ECANCELED) {
                // return to top of loop and wait for next command
                MTPD("request read returned %d ECANCELED, starting over\n", ret);
                continue;
            }
            MTPE("request read returned %d, errno: %d, exiting MtpServer::run loop\n", ret, errno);
            break;
        }
        MtpOperationCode operation = mRequest.getOperationCode();
        MtpTransactionID transaction = mRequest.getTransactionID();

        MTPD("operation: %s", MtpDebug::getOperationCodeName(operation));
        mRequest.dump();
    
        // FIXME need to generalize this
        bool dataIn = (operation == MTP_OPERATION_SEND_OBJECT_INFO
                    || operation == MTP_OPERATION_SET_OBJECT_REFERENCES
                    || operation == MTP_OPERATION_SET_OBJECT_PROP_VALUE
                    || operation == MTP_OPERATION_SET_DEVICE_PROP_VALUE);
        if (dataIn) {
            int ret = mData.read(fd);
            if (ret < 0) {
                if (errno == ECANCELED) {
                    // return to top of loop and wait for next command
                    MTPD("data read returned %d ECANCELED, starting over\n", ret);
                    continue;
                }
                MTPD("data read returned %d, errno: %d, exiting MtpServer::run loop\n", ret, errno);
                break;
            }
            MTPD("received data:");
            mData.dump();
        } else {
            mData.reset();
        }
    

            case MTP_OPERATION_SEND_OBJECT_INFO:
                MTPE("about to call doSendObjectInfo()\n");
                //response = MTP_RESPONSE_OBJECT_WRITE_PROTECTED;
                response = doSendObjectInfo();
                break;
            case MTP_OPERATION_SEND_OBJECT:
                MTPE("about to call doSendObject()\n");
                //response = MTP_RESPONSE_OBJECT_WRITE_PROTECTED;
                response = doSendObject();
                break;

/* file operations for /dev/mtp_usb */
static const struct file_operations mtp_fops = {
    .owner = THIS_MODULE,
    .read = mtp_read,
    .write = mtp_write,
    .unlocked_ioctl = mtp_ioctl,
#ifdef CONFIG_COMPAT
    .compat_ioctl = compat_mtp_ioctl,
#endif
    .open = mtp_open,
    .release = mtp_release,
};

static struct miscdevice mtp_device = {
    .minor = MISC_DYNAMIC_MINOR,
    .name = mtp_shortname,
    .fops = &mtp_fops,
};
static int __mtp_setup(struct mtp_instance *fi_mtp)
{
    ...
    ret = misc_register(&mtp_device);
    ...
}