drgreen/android_frameworks_base
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
android_frameworks_base/media/mtp/MtpDatabase.cpp
Mike Lockwood 5bae7f615b More work on PTP host support. 
Change-Id: Ifbd5bd5efa3cdb750ae1a2aae38181457554d34d
Signed-off-by: Mike Lockwood <mike@spruce.(none)>
2010-05-19 12:38:03 -04:00

578 lines
20 KiB
C++
Raw Blame History

/*
* 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.
*/
#include "MtpDatabase.h"
#include "MtpDataPacket.h"
#include "MtpUtils.h"
#include "SqliteDatabase.h"
#include "SqliteStatement.h"
#include <stdio.h>
#include <stdlib.h>
#include <sqlite3.h>
namespace android {
#define FILE_ID_COLUMN 1
#define FILE_PATH_COLUMN 2
#define FILE_FORMAT_COLUMN 3
#define FILE_PARENT_COLUMN 4
#define FILE_STORAGE_COLUMN 5
#define FILE_SIZE_COLUMN 6
#define FILE_MODIFIED_COLUMN 7
#define AUDIO_ID_COLUMN 1
#define AUDIO_TITLE_COLUMN 2
#define AUDIO_ARTIST_COLUMN 3
#define AUDIO_ALBUM_COLUMN 4
#define AUDIO_ALBUM_ARTIST_COLUMN 5
#define AUDIO_GENRE_COLUMN 6
#define AUDIO_COMPOSER_COLUMN 7
#define AUDIO_TRACK_NUMBER_COLUMN 8
#define AUDIO_YEAR_COLUMN 9
#define AUDIO_DURATION_COLUMN 10
#define AUDIO_USE_COUNT_COLUMN 11
#define AUDIO_SAMPLE_RATE_COLUMN 12
#define AUDIO_NUM_CHANNELS_COLUMN 13
#define AUDIO_AUDIO_WAVE_CODEC_COLUMN 14
#define AUDIO_AUDIO_BIT_RATE_COLUMN 15
#define FILE_TABLE_CREATE "CREATE TABLE IF NOT EXISTS files (" \
"_id INTEGER PRIMARY KEY," \
"path TEXT," \
"format INTEGER," \
"parent INTEGER," \
"storage INTEGER," \
"size INTEGER," \
"date_modified INTEGER" \
");"
#define AUDIO_TABLE_CREATE "CREATE TABLE IF NOT EXISTS audio (" \
"id INTEGER PRIMARY KEY," \
"title TEXT," \
"artist TEXT," \
"album TEXT," \
"album_artist TEXT," \
"genre TEXT," \
"composer TEXT," \
"track_number INTEGER," \
"year INTEGER," \
"duration INTEGER," \
"use_count INTEGER," \
"sample_rate INTEGER," \
"num_channels INTEGER," \
"audio_wave_codec TEXT," \
"audio_bit_rate INTEGER" \
");"
#define PATH_INDEX_CREATE "CREATE INDEX IF NOT EXISTS path_index on files(path);"
#define FILE_ID_QUERY "SELECT _id,format FROM files WHERE path = ?;"
#define FILE_PATH_QUERY "SELECT path,size FROM files WHERE _id = ?"
#define GET_OBJECT_INFO_QUERY "SELECT storage,format,parent,path,size,date_modified FROM files WHERE _id = ?;"
#define FILE_INSERT "INSERT INTO files VALUES(?,?,?,?,?,?,?);"
#define FILE_DELETE "DELETE FROM files WHERE _id = ?;"
#define AUDIO_INSERT "INSERT INTO audio VALUES(?,?,?,?,?,?,?,?,?,?,?,?,?,?,?);"
#define AUDIO_DELETE "DELETE FROM audio WHERE id = ?;"
struct PropertyTableEntry {
MtpObjectProperty property;
int type;
const char* columnName;
};
static const PropertyTableEntry kPropertyTable[] = {
{ MTP_PROPERTY_PARENT_OBJECT, MTP_TYPE_UINT32, "parent" },
{ MTP_PROPERTY_STORAGE_ID, MTP_TYPE_UINT32, "storage" },
{ MTP_PROPERTY_OBJECT_FORMAT, MTP_TYPE_UINT32, "format" },
{ MTP_PROPERTY_OBJECT_FILE_NAME, MTP_TYPE_STR, "path" },
{ MTP_PROPERTY_OBJECT_SIZE, MTP_TYPE_UINT64, "size" },
{ MTP_PROPERTY_DATE_MODIFIED, MTP_TYPE_STR, "date_modified" },
};
static bool getPropertyInfo(MtpObjectProperty property, int& type, const char*& columnName) {
int count = sizeof(kPropertyTable) / sizeof(kPropertyTable[0]);
const PropertyTableEntry* entry = kPropertyTable;
for (int i = 0; i < count; i++, entry++) {
if (entry->property == property) {
type = entry->type;
columnName = entry->columnName;
return true;
}
}
return false;
}
MtpDatabase::MtpDatabase()
: mFileIdQuery(NULL),
mObjectInfoQuery(NULL),
mFileInserter(NULL),
mFileDeleter(NULL),
mAudioInserter(NULL),
mAudioDeleter(NULL)
{
}
MtpDatabase::~MtpDatabase() {
}
bool MtpDatabase::open(const char* path, bool create) {
if (!SqliteDatabase::open(path, create))
return false;
// create tables and indices if necessary
if (!exec(FILE_TABLE_CREATE)) {
fprintf(stderr, "could not create file table\n");
return false;
}
if (!exec(PATH_INDEX_CREATE)) {
fprintf(stderr, "could not path index on file table\n");
return false;
}
if (!exec(AUDIO_TABLE_CREATE)) {
fprintf(stderr, "could not create file table\n");
return false;
}
if (!mFileIdQuery) {
mFileIdQuery = new SqliteStatement(this);
if (!mFileIdQuery->prepare(FILE_ID_QUERY)) {
fprintf(stderr, "could not compile FILE_ID_QUERY\n");
exit(-1);
}
}
if (!mFilePathQuery) {
mFilePathQuery = new SqliteStatement(this);
if (!mFilePathQuery->prepare(FILE_PATH_QUERY)) {
fprintf(stderr, "could not compile FILE_PATH_QUERY\n");
exit(-1);
}
}
if (!mObjectInfoQuery) {
mObjectInfoQuery = new SqliteStatement(this);
if (!mObjectInfoQuery->prepare(GET_OBJECT_INFO_QUERY)) {
fprintf(stderr, "could not compile GET_OBJECT_INFO_QUERY\n");
exit(-1);
}
}
if (!mFileInserter) {
mFileInserter = new SqliteStatement(this);
if (!mFileInserter->prepare(FILE_INSERT)) {
fprintf(stderr, "could not compile FILE_INSERT\n");
exit(-1);
}
}
if (!mFileDeleter) {
mFileDeleter = new SqliteStatement(this);
if (!mFileDeleter->prepare(FILE_DELETE)) {
fprintf(stderr, "could not compile FILE_DELETE\n");
exit(-1);
}
}
if (!mAudioInserter) {
mAudioInserter = new SqliteStatement(this);
if (!mAudioInserter->prepare(AUDIO_INSERT)) {
fprintf(stderr, "could not compile AUDIO_INSERT\n");
exit(-1);
}
}
if (!mAudioDeleter) {
mAudioDeleter = new SqliteStatement(this);
if (!mAudioDeleter->prepare(AUDIO_DELETE)) {
fprintf(stderr, "could not compile AUDIO_DELETE\n");
exit(-1);
}
}
return true;
}
uint32_t MtpDatabase::getTableForFile(MtpObjectFormat format) {
switch (format) {
case MTP_FORMAT_AIFF:
case MTP_FORMAT_WAV:
case MTP_FORMAT_MP3:
case MTP_FORMAT_FLAC:
case MTP_FORMAT_UNDEFINED_AUDIO:
case MTP_FORMAT_WMA:
case MTP_FORMAT_OGG:
case MTP_FORMAT_AAC:
case MTP_FORMAT_AUDIBLE:
return kObjectHandleTableAudio;
case MTP_FORMAT_AVI:
case MTP_FORMAT_MPEG:
case MTP_FORMAT_ASF:
case MTP_FORMAT_UNDEFINED_VIDEO:
case MTP_FORMAT_WMV:
case MTP_FORMAT_MP4_CONTAINER:
case MTP_FORMAT_MP2:
case MTP_FORMAT_3GP_CONTAINER:
return kObjectHandleTableVideo;
case MTP_FORMAT_DEFINED:
case MTP_FORMAT_EXIF_JPEG:
case MTP_FORMAT_TIFF_EP:
case MTP_FORMAT_FLASHPIX:
case MTP_FORMAT_BMP:
case MTP_FORMAT_CIFF:
case MTP_FORMAT_GIF:
case MTP_FORMAT_JFIF:
case MTP_FORMAT_CD:
case MTP_FORMAT_PICT:
case MTP_FORMAT_PNG:
case MTP_FORMAT_TIFF:
case MTP_FORMAT_TIFF_IT:
case MTP_FORMAT_JP2:
case MTP_FORMAT_JPX:
case MTP_FORMAT_WINDOWS_IMAGE_FORMAT:
return kObjectHandleTableImage;
case MTP_FORMAT_ABSTRACT_AUDIO_PLAYLIST:
case MTP_FORMAT_ABSTRACT_AV_PLAYLIST:
case MTP_FORMAT_ABSTRACT_VIDEO_PLAYLIST:
case MTP_FORMAT_WPL_PLAYLIST:
case MTP_FORMAT_M3U_PLAYLIST:
case MTP_FORMAT_MPL_PLAYLIST:
case MTP_FORMAT_ASX_PLAYLIST:
case MTP_FORMAT_PLS_PLAYLIST:
return kObjectHandleTablePlaylist;
default:
return kObjectHandleTableFile;
}
}
MtpObjectHandle MtpDatabase::getObjectHandle(const char* path) {
mFileIdQuery->reset();
mFileIdQuery->bind(1, path);
if (mFileIdQuery->step()) {
int row = mFileIdQuery->getColumnInt(0);
if (row > 0) {
MtpObjectFormat format = mFileIdQuery->getColumnInt(1);
row |= getTableForFile(format);
return row;
}
}
return 0;
}
MtpObjectHandle MtpDatabase::addFile(const char* path,
MtpObjectFormat format,
MtpObjectHandle parent,
MtpStorageID storage,
uint64_t size,
time_t modified) {
mFileInserter->bind(FILE_PATH_COLUMN, path);
mFileInserter->bind(FILE_FORMAT_COLUMN, format);
mFileInserter->bind(FILE_PARENT_COLUMN, parent);
mFileInserter->bind(FILE_STORAGE_COLUMN, storage);
mFileInserter->bind(FILE_SIZE_COLUMN, size);
mFileInserter->bind(FILE_MODIFIED_COLUMN, modified);
mFileInserter->step();
mFileInserter->reset();
int result = lastInsertedRow();
return (result <= 0 ? kInvalidObjectHandle : result);
}
MtpObjectHandle MtpDatabase::addAudioFile(MtpObjectHandle handle) {
mAudioInserter->bind(AUDIO_ID_COLUMN, handle);
mAudioInserter->step();
mAudioInserter->reset();
int result = lastInsertedRow();
handle |= kObjectHandleTableAudio;
return (result > 0 ? handle : kInvalidObjectHandle);
}
MtpObjectHandle MtpDatabase::addAudioFile(MtpObjectHandle handle,
const char* title,
const char* artist,
const char* album,
const char* albumArtist,
const char* genre,
const char* composer,
const char* mimeType,
int track,
int year,
int duration) {
mAudioInserter->bind(AUDIO_ID_COLUMN, handle);
if (title) mAudioInserter->bind(AUDIO_TITLE_COLUMN, title);
if (artist) mAudioInserter->bind(AUDIO_ARTIST_COLUMN, artist);
if (album) mAudioInserter->bind(AUDIO_ALBUM_COLUMN, album);
if (albumArtist) mAudioInserter->bind(AUDIO_ALBUM_ARTIST_COLUMN, albumArtist);
if (genre) mAudioInserter->bind(AUDIO_GENRE_COLUMN, genre);
if (composer) mAudioInserter->bind(AUDIO_COMPOSER_COLUMN, composer);
if (track) mAudioInserter->bind(AUDIO_TRACK_NUMBER_COLUMN, track);
if (year) mAudioInserter->bind(AUDIO_YEAR_COLUMN, year);
if (duration) mAudioInserter->bind(AUDIO_DURATION_COLUMN, duration);
mAudioInserter->step();
mAudioInserter->reset();
int result = lastInsertedRow();
if (result <= 0)
return kInvalidObjectHandle;
result |= kObjectHandleTableAudio;
return result;
}
MtpObjectHandleList* MtpDatabase::getObjectList(MtpStorageID storageID,
MtpObjectFormat format,
MtpObjectHandle parent) {
bool whereStorage = (storageID != 0xFFFFFFFF);
bool whereFormat = (format != 0);
bool whereParent = (parent != 0);
char intBuffer[20];
MtpString query("SELECT _id,format FROM files");
if (whereStorage || whereFormat || whereParent)
query += " WHERE";
if (whereStorage) {
snprintf(intBuffer, sizeof(intBuffer), "%d", storageID);
query += " storage = ";
query += intBuffer;
}
if (whereFormat) {
snprintf(intBuffer, sizeof(intBuffer), "%d", format);
if (whereStorage)
query += " AND";
query += " format = ";
query += intBuffer;
}
if (whereParent) {
if (parent != MTP_PARENT_ROOT)
parent &= kObjectHandleIndexMask;
snprintf(intBuffer, sizeof(intBuffer), "%d", parent);
if (whereStorage || whereFormat)
query += " AND";
query += " parent = ";
query += intBuffer;
}
query += ";";
SqliteStatement stmt(this);
printf("%s\n", (const char *)query);
stmt.prepare(query);
MtpObjectHandleList* list = new MtpObjectHandleList();
while (!stmt.isDone()) {
if (stmt.step()) {
int index = stmt.getColumnInt(0);
printf("stmt.getColumnInt returned %d\n", index);
if (index > 0) {
MtpObjectFormat format = stmt.getColumnInt(1);
index |= getTableForFile(format);
list->push(index);
}
}
}
printf("list size: %d\n", list->size());
return list;
}
MtpResponseCode MtpDatabase::getObjectProperty(MtpObjectHandle handle,
MtpObjectProperty property,
MtpDataPacket& packet) {
int type;
const char* columnName;
char intBuffer[20];
if (handle != MTP_PARENT_ROOT)
handle &= kObjectHandleIndexMask;
if (!getPropertyInfo(property, type, columnName))
return MTP_RESPONSE_INVALID_OBJECT_PROP_CODE;
snprintf(intBuffer, sizeof(intBuffer), "%d", handle);
MtpString query("SELECT ");
query += columnName;
query += " FROM files WHERE _id = ";
query += intBuffer;
query += ";";
SqliteStatement stmt(this);
printf("%s\n", (const char *)query);
stmt.prepare(query);
if (!stmt.step())
return MTP_RESPONSE_INVALID_OBJECT_HANDLE;
switch (type) {
case MTP_TYPE_INT8:
packet.putInt8(stmt.getColumnInt(0));
break;
case MTP_TYPE_UINT8:
packet.putUInt8(stmt.getColumnInt(0));
break;
case MTP_TYPE_INT16:
packet.putInt16(stmt.getColumnInt(0));
break;
case MTP_TYPE_UINT16:
packet.putUInt16(stmt.getColumnInt(0));
break;
case MTP_TYPE_INT32:
packet.putInt32(stmt.getColumnInt(0));
break;
case MTP_TYPE_UINT32:
packet.putUInt32(stmt.getColumnInt(0));
break;
case MTP_TYPE_INT64:
packet.putInt64(stmt.getColumnInt64(0));
break;
case MTP_TYPE_UINT64:
packet.putUInt64(stmt.getColumnInt64(0));
break;
case MTP_TYPE_STR:
packet.putString(stmt.getColumnString(0));
break;
default:
fprintf(stderr, "unsupported object type\n");
return MTP_RESPONSE_INVALID_OBJECT_HANDLE;
}
return MTP_RESPONSE_OK;
}
MtpResponseCode MtpDatabase::getObjectInfo(MtpObjectHandle handle,
MtpDataPacket& packet) {
char date[20];
if (handle != MTP_PARENT_ROOT)
handle &= kObjectHandleIndexMask;
mObjectInfoQuery->reset();
mObjectInfoQuery->bind(1, handle);
if (!mObjectInfoQuery->step())
return MTP_RESPONSE_INVALID_OBJECT_HANDLE;
MtpStorageID storageID = mObjectInfoQuery->getColumnInt(0);
MtpObjectFormat format = mObjectInfoQuery->getColumnInt(1);
MtpObjectHandle parent = mObjectInfoQuery->getColumnInt(2);
// extract name from path. do we want a separate database entry for this?
const char* name = mObjectInfoQuery->getColumnString(3);
const char* lastSlash = strrchr(name, '/');
if (lastSlash)
name = lastSlash + 1;
int64_t size = mObjectInfoQuery->getColumnInt64(4);
time_t modified = mObjectInfoQuery->getColumnInt(5);
int associationType = (format == MTP_FORMAT_ASSOCIATION ?
MTP_ASSOCIATION_TYPE_GENERIC_FOLDER :
MTP_ASSOCIATION_TYPE_UNDEFINED);
printf("storageID: %d, format: %d, parent: %d\n", storageID, format, parent);
packet.putUInt32(storageID);
packet.putUInt16(format);
packet.putUInt16(0); // protection status
packet.putUInt32((size > 0xFFFFFFFFLL ? 0xFFFFFFFF : size));
packet.putUInt16(0); // thumb format
packet.putUInt32(0); // thumb compressed size
packet.putUInt32(0); // thumb pix width
packet.putUInt32(0); // thumb pix height
packet.putUInt32(0); // image pix width
packet.putUInt32(0); // image pix height
packet.putUInt32(0); // image bit depth
packet.putUInt32(parent);
packet.putUInt16(associationType);
packet.putUInt32(0); // association desc
packet.putUInt32(0); // sequence number
packet.putString(name); // file name
packet.putEmptyString();
formatDateTime(modified, date, sizeof(date));
packet.putString(date); // date modified
packet.putEmptyString(); // keywords
return MTP_RESPONSE_OK;
}
bool MtpDatabase::getObjectFilePath(MtpObjectHandle handle,
MtpString& filePath,
int64_t& fileLength) {
if (handle != MTP_PARENT_ROOT)
handle &= kObjectHandleIndexMask;
mFilePathQuery->reset();
mFilePathQuery->bind(1, handle);
if (!mFilePathQuery->step())
return false;
const char* path = mFilePathQuery->getColumnString(0);
if (!path)
return false;
filePath = path;
fileLength = mFilePathQuery->getColumnInt64(1);
return true;
}
bool MtpDatabase::deleteFile(MtpObjectHandle handle) {
uint32_t table = handle & kObjectHandleTableMask;
handle &= kObjectHandleIndexMask;
mFileDeleter->bind(1, handle);
mFileDeleter->step();
mFileDeleter->reset();
if (table == kObjectHandleTableAudio) {
mAudioDeleter->bind(1, handle);
mAudioDeleter->step();
mAudioDeleter->reset();
}
return true;
}
MtpObjectHandle* MtpDatabase::getFileList(int& outCount) {
MtpObjectHandle* result = NULL;
int count = 0;
SqliteStatement stmt(this);
stmt.prepare("SELECT count(*) FROM files;");
MtpObjectHandleList* list = new MtpObjectHandleList();
if (stmt.step())
count = stmt.getColumnInt(0);
if (count > 0) {
result = new MtpObjectHandle[count];
memset(result, 0, count * sizeof(*result));
SqliteStatement stmt2(this);
stmt2.prepare("SELECT _id,format FROM files;");
for (int i = 0; i < count; i++) {
if (!stmt2.step()) {
printf("getFileList ended early\n");
count = i;
break;
}
MtpObjectHandle handle = stmt2.getColumnInt(0);
MtpObjectFormat format = stmt2.getColumnInt(1);
handle |= getTableForFile(format);
result[i] = handle;
}
}
outCount = count;
return result;
}
/*
for getObjectPropDesc
packet.putUInt16(property);
packet.putUInt16(dataType);
packet.putUInt8(getSet);
// default value DTS
packet.putUInt32(groupCode);
packet.putUInt8(formFlag);
// form, variable
*/
} // namespace android
Reference in New Issue View Git Blame Copy Permalink