media/mtp/MtpCursor.cpp

/*
 * Copyright (C) 2010 The Android Open Source Project
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

#define LOG_TAG "MtpCursor"

#include "MtpDebug.h"
#include "MtpClient.h"
#include "MtpCursor.h"
#include "MtpDevice.h"
#include "MtpDeviceInfo.h"
#include "MtpObjectInfo.h"
#include "MtpStorageInfo.h"


#include "binder/CursorWindow.h"

namespace android {

/* Device Column IDs */
/* These must match the values in MtpCursor.java */
#define DEVICE_ROW_ID           1
#define DEVICE_MANUFACTURER     2
#define DEVICE_MODEL            3

/* Storage Column IDs */
/* These must match the values in MtpCursor.java */
#define STORAGE_ROW_ID          101
#define STORAGE_IDENTIFIER      102
#define STORAGE_DESCRIPTION     103

/* Object Column IDs */
/* These must match the values in MtpCursor.java */
#define OBJECT_ROW_ID               201
#define OBJECT_STORAGE_ID           202
#define OBJECT_FORMAT               203
#define OBJECT_PROTECTION_STATUS    204
#define OBJECT_SIZE                 205
#define OBJECT_THUMB_FORMAT         206
#define OBJECT_THUMB_SIZE           207
#define OBJECT_THUMB_WIDTH          208
#define OBJECT_THUMB_HEIGHT         209
#define OBJECT_IMAGE_WIDTH          210
#define OBJECT_IMAGE_HEIGHT         211
#define OBJECT_IMAGE_DEPTH          212
#define OBJECT_PARENT               213
#define OBJECT_ASSOCIATION_TYPE     214
#define OBJECT_ASSOCIATION_DESC     215
#define OBJECT_SEQUENCE_NUMBER      216
#define OBJECT_NAME                 217
#define OBJECT_DATE_CREATED         218
#define OBJECT_DATE_MODIFIED        219
#define OBJECT_KEYWORDS             220
#define OBJECT_THUMB                221

MtpCursor::MtpCursor(MtpClient* client, int queryType, int deviceID,
                MtpStorageID storageID, MtpObjectHandle objectID,
                int columnCount, int* columns)
        :   mClient(client),
            mQueryType(queryType),
            mDeviceID(deviceID),
            mStorageID(storageID),
            mQbjectID(objectID),
            mColumnCount(columnCount),
            mColumns(NULL)
{
    if (columns) {
        mColumns = new int[columnCount];
        memcpy(mColumns, columns, columnCount * sizeof(int));
    }
}

MtpCursor::~MtpCursor() {
    delete[] mColumns;
}

int MtpCursor::fillWindow(CursorWindow* window, int startPos) {
    LOGD("MtpCursor::fillWindow mQueryType: %d\n", mQueryType);

    switch (mQueryType) {
        case DEVICE:
            return fillDevices(window, startPos);
        case DEVICE_ID:
            return fillDevice(window, startPos);
        case STORAGE:
            return fillStorages(window, startPos);
        case STORAGE_ID:
            return fillStorage(window, startPos);
        case OBJECT:
            return fillObjects(window, 0, startPos);
        case OBJECT_ID:
            return fillObject(window, startPos);
        case STORAGE_CHILDREN:
            return fillObjects(window, -1, startPos);
        case OBJECT_CHILDREN:
            return fillObjects(window, mQbjectID, startPos);
        default:
            LOGE("MtpCursor::fillWindow: unknown query type %d\n", mQueryType);
            return 0;
    }
}

int MtpCursor::fillDevices(CursorWindow* window, int startPos) {
    int count = 0;
    MtpDeviceList& deviceList = mClient->getDeviceList();
    for (int i = 0; i < deviceList.size(); i++) {
        MtpDevice* device = deviceList[i];
        if (fillDevice(window, device, startPos)) {
            count++;
            startPos++;
        } else {
            break;
        }
    }
    return count;
}

int MtpCursor::fillDevice(CursorWindow* window, int startPos) {
    MtpDevice* device = mClient->getDevice(mDeviceID);
    if (device && fillDevice(window, device, startPos))
        return 1;
    else
        return 0;
}

int MtpCursor::fillStorages(CursorWindow* window, int startPos) {
    int count = 0;
    MtpDevice* device = mClient->getDevice(mDeviceID);
    if (!device)
        return 0;
    MtpStorageIDList* storageIDs = device->getStorageIDs();
    if (!storageIDs)
        return 0;

    for (int i = 0; i < storageIDs->size(); i++) {
        MtpStorageID storageID = (*storageIDs)[i];
        if (fillStorage(window, device, storageID, startPos)) {
            count++;
            startPos++;
        } else {
            break;
        }
    }
    delete storageIDs;
    return count;
}

int MtpCursor::fillStorage(CursorWindow* window, int startPos) {
    MtpDevice* device = mClient->getDevice(mDeviceID);
    if (device && fillStorage(window, device, mStorageID, startPos))
        return 1;
    else
        return 0;
}

int MtpCursor::fillObjects(CursorWindow* window, int parent, int startPos) {
    int count = 0;
    MtpDevice* device = mClient->getDevice(mDeviceID);
    if (!device)
        return 0;
    MtpObjectHandleList* handles = device->getObjectHandles(mStorageID, 0, parent);
    if (!handles)
        return 0;

    for (int i = 0; i < handles->size(); i++) {
        MtpObjectHandle handle = (*handles)[i];
        if (fillObject(window, device, handle, startPos)) {
            count++;
            startPos++;
        } else {
            break;
        }
    }
    delete handles;
    return count;
}

int MtpCursor::fillObject(CursorWindow* window, int startPos) {
    MtpDevice* device = mClient->getDevice(mDeviceID);
    if (device && fillObject(window, device, mQbjectID, startPos))
        return 1;
    else
        return 0;
}

bool MtpCursor::fillDevice(CursorWindow* window, MtpDevice* device, int row) {
    MtpDeviceInfo* deviceInfo = device->getDeviceInfo();
    if (!deviceInfo)
        return false;
    if (!prepareRow(window))
        return false;

    for (int i = 0; i < mColumnCount; i++) {
        switch (mColumns[i]) {
            case DEVICE_ROW_ID:
                if (!putLong(window, device->getID(), row, i))
                    return false;
                 break;
            case DEVICE_MANUFACTURER:
                if (!putString(window, deviceInfo->mManufacturer, row, i))
                    return false;
                 break;
            case DEVICE_MODEL:
                if (!putString(window, deviceInfo->mModel, row, i))
                    return false;
                 break;
            default:
                LOGE("fillDevice: unknown column %d\n", mColumns[i]);
                return false;
        }
    }

    return true;
}

bool MtpCursor::fillStorage(CursorWindow* window, MtpDevice* device,
        MtpStorageID storageID, int row) {

LOGD("fillStorage %d\n", storageID);

    MtpStorageInfo* storageInfo = device->getStorageInfo(storageID);
    if (!storageInfo)
        return false;
    if (!prepareRow(window)) {
        delete storageInfo;
        return false;
    }

    const char* text;
    for (int i = 0; i < mColumnCount; i++) {
        switch (mColumns[i]) {
            case STORAGE_ROW_ID:
                if (!putLong(window, storageID, row, i))
                    goto fail;
                 break;
            case STORAGE_IDENTIFIER:
                text = storageInfo->mVolumeIdentifier;
                if (!text || !text[0])
                    text = "Camera Storage";
                if (!putString(window, text, row, i))
                    goto fail;
                 break;
            case STORAGE_DESCRIPTION:
                text = storageInfo->mStorageDescription;
                if (!text || !text[0])
                    text = "Storage Description";
                if (!putString(window, text, row, i))
                    goto fail;
                 break;
            default:
                LOGE("fillStorage: unknown column %d\n", mColumns[i]);
                goto fail;
        }
    }

    delete storageInfo;
    return true;

fail:
    delete storageInfo;
    return false;
}

bool MtpCursor::fillObject(CursorWindow* window, MtpDevice* device,
        MtpObjectHandle objectID, int row) {

    MtpObjectInfo* objectInfo = device->getObjectInfo(objectID);
    if (!objectInfo)
        return false;
    // objectInfo->print();
    if (!prepareRow(window)) {
        delete objectInfo;
        return false;
    }

    for (int i = 0; i < mColumnCount; i++) {
        switch (mColumns[i]) {
            case OBJECT_ROW_ID:
                if (!putLong(window, objectID, row, i))
                    goto fail;
                 break;
            case OBJECT_STORAGE_ID:
                if (!putLong(window, objectInfo->mStorageID, row, i))
                    goto fail;
                 break;
            case OBJECT_FORMAT:
                if (!putLong(window, objectInfo->mFormat, row, i))
                    goto fail;
                 break;
            case OBJECT_PROTECTION_STATUS:
                if (!putLong(window, objectInfo->mProtectionStatus, row, i))
                    goto fail;
                 break;
            case OBJECT_SIZE:
                if (!putLong(window, objectInfo->mCompressedSize, row, i))
                    goto fail;
                 break;
            case OBJECT_THUMB_FORMAT:
                if (!putLong(window, objectInfo->mThumbFormat, row, i))
                    goto fail;
                 break;
            case OBJECT_THUMB_SIZE:
                if (!putLong(window, objectInfo->mThumbCompressedSize, row, i))
                    goto fail;
                 break;
            case OBJECT_THUMB_WIDTH:
                if (!putLong(window, objectInfo->mThumbPixWidth, row, i))
                    goto fail;
                 break;
            case OBJECT_THUMB_HEIGHT:
                if (!putLong(window, objectInfo->mThumbPixHeight, row, i))
                    goto fail;
                 break;
            case OBJECT_IMAGE_WIDTH:
                if (!putLong(window, objectInfo->mImagePixWidth, row, i))
                    goto fail;
                 break;
            case OBJECT_IMAGE_HEIGHT:
                if (!putLong(window, objectInfo->mImagePixHeight, row, i))
                    goto fail;
                 break;
            case OBJECT_IMAGE_DEPTH:
                if (!putLong(window, objectInfo->mImagePixDepth, row, i))
                    goto fail;
                 break;
            case OBJECT_PARENT:
                if (!putLong(window, objectInfo->mParent, row, i))
                    goto fail;
                 break;
            case OBJECT_ASSOCIATION_TYPE:
                if (!putLong(window, objectInfo->mAssociationType, row, i))
                    goto fail;
                 break;
            case OBJECT_ASSOCIATION_DESC:
                if (!putLong(window, objectInfo->mAssociationDesc, row, i))
                    goto fail;
                 break;
            case OBJECT_SEQUENCE_NUMBER:
                if (!putLong(window, objectInfo->mSequenceNumber, row, i))
                    goto fail;
                 break;
            case OBJECT_NAME:
                if (!putString(window, objectInfo->mName, row, i))
                    goto fail;
                 break;
            case OBJECT_DATE_CREATED:
                if (!putLong(window, objectInfo->mDateCreated, row, i))
                    goto fail;
                 break;
            case OBJECT_DATE_MODIFIED:
                if (!putLong(window, objectInfo->mDateModified, row, i))
                    goto fail;
                 break;
            case OBJECT_KEYWORDS:
                if (!putString(window, objectInfo->mKeywords, row, i))
                    goto fail;
                 break;
            case OBJECT_THUMB:
                if (!putThumbnail(window, objectID, objectInfo->mFormat, row, i))
                    goto fail;
                break;
            default:
                LOGE("fillObject: unknown column %d\n", mColumns[i]);
                goto fail;
        }
    }

    delete objectInfo;
    return true;

fail:
    delete objectInfo;
    return false;
}

bool MtpCursor::prepareRow(CursorWindow* window) {
    if (!window->setNumColumns(mColumnCount)) {
        LOGE("Failed to change column count from %d to %d", window->getNumColumns(), mColumnCount);
        return false;
    }
    field_slot_t * fieldDir = window->allocRow();
    if (!fieldDir) {
        LOGE("Failed allocating fieldDir");
        return false;
    }
    return true;
}


bool MtpCursor::putLong(CursorWindow* window, int64_t value, int row, int column) {
    if (!window->putLong(row, column, value)) {
        window->freeLastRow();
        LOGE("Failed allocating space for a long in column %d", column);
        return false;
    }
    return true;
}

bool MtpCursor::putString(CursorWindow* window, const char* text, int row, int column) {
    int size = strlen(text) + 1;
    int offset = window->alloc(size);
    if (!offset) {
        window->freeLastRow();
        LOGE("Failed allocating %u bytes for text/blob %s", size, text);
        return false;
    }
    window->copyIn(offset, (const uint8_t*)text, size);

    // This must be updated after the call to alloc(), since that
    // may move the field around in the window
    field_slot_t * fieldSlot = window->getFieldSlot(row, column);
    fieldSlot->type = FIELD_TYPE_STRING;
    fieldSlot->data.buffer.offset = offset;
    fieldSlot->data.buffer.size = size;
    return true;
}

bool MtpCursor::putThumbnail(CursorWindow* window, MtpObjectHandle objectID,
                            MtpObjectFormat format, int row, int column) {
    MtpDevice* device = mClient->getDevice(mDeviceID);
    void* thumbnail;
    int size, offset;
    if (format == MTP_FORMAT_ASSOCIATION) {
        thumbnail = NULL;
        size = offset = 0;
    } else {
        thumbnail = device->getThumbnail(objectID, size);

        LOGV("putThumbnail: %p, size: %d\n", thumbnail, size);
        offset = window->alloc(size);
        if (!offset) {
            window->freeLastRow();
            LOGE("Failed allocating %u bytes for thumbnail", size);
            return false;
        }
    }
    if (thumbnail)
        window->copyIn(offset, (const uint8_t*)thumbnail, size);

    // This must be updated after the call to alloc(), since that
    // may move the field around in the window
    field_slot_t * fieldSlot = window->getFieldSlot(row, column);
    fieldSlot->type = FIELD_TYPE_BLOB;
    fieldSlot->data.buffer.offset = offset;
    fieldSlot->data.buffer.size = size;
    return true;
}

} // namespace android