Android/frameworks_base
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Merge "MTP: remove separate audio table from prototype MTP database"

Browse Source
This commit is contained in:
Mike Lockwood
2010-07-08 13:09:17 -07:00
committed by Android (Google) Code Review
parent 26be805f42 2d6c9e9c4e
commit 6d9e1e63a4
9 changed files with 42 additions and 426 deletions
Download Patch File Download Diff File Expand all files Collapse all files

5
media/mtp/Android.mk
View File

@@ -20,7 +20,6 @@ include $(CLEAR_VARS)
LOCAL_SRC_FILES:= \
MtpClient.cpp \
MtpCursor.cpp \
MtpDatabase.cpp \
MtpDataPacket.cpp \
MtpDebug.cpp \
MtpDevice.cpp \
@@ -59,7 +58,7 @@ LOCAL_MODULE:= mtptest
LOCAL_CFLAGS := -DMTP_DEVICE
LOCAL_SHARED_LIBRARIES := libutils libsqlite libstagefright libcutils \
LOCAL_SHARED_LIBRARIES := libutils libsqlite libcutils \
libmedia
LOCAL_STATIC_LIBRARIES := libmtp
@@ -76,7 +75,7 @@ LOCAL_SRC_FILES:= \
LOCAL_STATIC_LIBRARIES := libmtp
LOCAL_C_INCLUDES := external/sqlite/dist
LOCAL_SHARED_LIBRARIES := libutils libsqlite libstagefright libmedia
LOCAL_SHARED_LIBRARIES := libutils libsqlite libmedia
LOCAL_CFLAGS := -g
LOCAL_LDFLAGS := -g

81
media/mtp/MtpDatabase.cpp
View File

@@ -1,81 +0,0 @@
/*
* 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 "MtpDatabase"
#include "MtpDebug.h"
#include "MtpDatabase.h"
#include "MtpTypes.h"
#include "mtp.h"
namespace android {
MtpDatabase::~MtpDatabase() {
}
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;
}
}
} // namespace android

18
media/mtp/MtpDatabase.h
View File

@@ -26,9 +26,7 @@ class MtpDataPacket;
class MtpDatabase {
public:
virtual ~MtpDatabase();
static uint32_t getTableForFile(MtpObjectFormat format);
virtual ~MtpDatabase() {}
virtual MtpObjectHandle getObjectHandle(const char* path) = 0;
virtual MtpObjectHandle addFile(const char* path,
@@ -38,20 +36,6 @@ public:
uint64_t size,
time_t modified) = 0;
virtual MtpObjectHandle addAudioFile(MtpObjectHandle id) = 0;
virtual MtpObjectHandle addAudioFile(MtpObjectHandle id,
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) = 0;
virtual MtpObjectHandleList* getObjectList(MtpStorageID storageID,
MtpObjectFormat format,
MtpObjectHandle parent) = 0;

222
media/mtp/MtpMediaScanner.cpp
View File

@@ -31,143 +31,15 @@
#include <stdio.h>
#include <limits.h>
#include <media/mediascanner.h>
#include <media/stagefright/StagefrightMediaScanner.h>
namespace android {
class MtpMediaScannerClient : public MediaScannerClient
{
public:
MtpMediaScannerClient()
{
reset();
}
virtual ~MtpMediaScannerClient()
{
}
// returns true if it succeeded, false if an exception occured in the Java code
virtual bool scanFile(const char* path, long long lastModified, long long fileSize)
{
LOGV("scanFile %s", path);
return true;
}
// returns true if it succeeded, false if an exception occured in the Java code
virtual bool handleStringTag(const char* name, const char* value)
{
int temp;
if (!strcmp(name, "title")) {
mTitle = value;
mHasTitle = true;
} else if (!strcmp(name, "artist")) {
mArtist = value;
mHasArtist = true;
} else if (!strcmp(name, "album")) {
mAlbum = value;
mHasAlbum = true;
} else if (!strcmp(name, "albumartist")) {
mAlbumArtist = value;
mHasAlbumArtist = true;
} else if (!strcmp(name, "genre")) {
// FIXME - handle numeric values here
mGenre = value;
mHasGenre = true;
} else if (!strcmp(name, "composer")) {
mComposer = value;
mHasComposer = true;
} else if (!strcmp(name, "tracknumber")) {
if (sscanf(value, "%d", &temp) == 1)
mTrack = temp;
} else if (!strcmp(name, "discnumber")) {
// currently unused
} else if (!strcmp(name, "year") || !strcmp(name, "date")) {
if (sscanf(value, "%d", &temp) == 1)
mYear = temp;
} else if (!strcmp(name, "duration")) {
if (sscanf(value, "%d", &temp) == 1)
mDuration = temp;
} else {
LOGV("handleStringTag %s : %s", name, value);
}
return true;
}
// returns true if it succeeded, false if an exception occured in the Java code
virtual bool setMimeType(const char* mimeType)
{
mMimeType = mimeType;
mHasMimeType = true;
return true;
}
// returns true if it succeeded, false if an exception occured in the Java code
virtual bool addNoMediaFolder(const char* path)
{
LOGV("addNoMediaFolder %s", path);
return true;
}
void reset()
{
mHasTitle = false;
mHasArtist = false;
mHasAlbum = false;
mHasAlbumArtist = false;
mHasGenre = false;
mHasComposer = false;
mHasMimeType = false;
mTrack = mYear = mDuration = 0;
}
inline const char* getTitle() const { return mHasTitle ? (const char *)mTitle : NULL; }
inline const char* getArtist() const { return mHasArtist ? (const char *)mArtist : NULL; }
inline const char* getAlbum() const { return mHasAlbum ? (const char *)mAlbum : NULL; }
inline const char* getAlbumArtist() const { return mHasAlbumArtist ? (const char *)mAlbumArtist : NULL; }
inline const char* getGenre() const { return mHasGenre ? (const char *)mGenre : NULL; }
inline const char* getComposer() const { return mHasComposer ? (const char *)mComposer : NULL; }
inline const char* getMimeType() const { return mHasMimeType ? (const char *)mMimeType : NULL; }
inline int getTrack() const { return mTrack; }
inline int getYear() const { return mYear; }
inline int getDuration() const { return mDuration; }
private:
MtpString mTitle;
MtpString mArtist;
MtpString mAlbum;
MtpString mAlbumArtist;
MtpString mGenre;
MtpString mComposer;
MtpString mMimeType;
bool mHasTitle;
bool mHasArtist;
bool mHasAlbum;
bool mHasAlbumArtist;
bool mHasGenre;
bool mHasComposer;
bool mHasMimeType;
int mTrack;
int mYear;
int mDuration;
};
MtpMediaScanner::MtpMediaScanner(MtpStorageID id, const char* filePath, MtpDatabase* db)
: mStorageID(id),
mFilePath(filePath),
mDatabase(db),
mMediaScanner(NULL),
mMediaScannerClient(NULL),
mFileList(NULL),
mFileCount(0)
{
mMediaScanner = new StagefrightMediaScanner;
mMediaScannerClient = new MtpMediaScannerClient;
}
MtpMediaScanner::~MtpMediaScanner() {
@@ -199,47 +71,46 @@ static const struct MediaFileTypeEntry
{
const char* extension;
MtpObjectFormat format;
uint32_t table;
} sFileTypes[] =
{
{ "MP3", MTP_FORMAT_MP3, kObjectHandleTableAudio },
{ "M4A", MTP_FORMAT_UNDEFINED_AUDIO, kObjectHandleTableAudio },
{ "WAV", MTP_FORMAT_WAV, kObjectHandleTableAudio },
{ "AMR", MTP_FORMAT_UNDEFINED_AUDIO, kObjectHandleTableAudio },
{ "AWB", MTP_FORMAT_UNDEFINED_AUDIO, kObjectHandleTableAudio },
{ "WMA", MTP_FORMAT_WMA, kObjectHandleTableAudio },
{ "OGG", MTP_FORMAT_OGG, kObjectHandleTableAudio },
{ "OGA", MTP_FORMAT_UNDEFINED_AUDIO, kObjectHandleTableAudio },
{ "AAC", MTP_FORMAT_AAC, kObjectHandleTableAudio },
{ "MID", MTP_FORMAT_UNDEFINED_AUDIO, kObjectHandleTableAudio },
{ "MIDI", MTP_FORMAT_UNDEFINED_AUDIO, kObjectHandleTableAudio },
{ "XMF", MTP_FORMAT_UNDEFINED_AUDIO, kObjectHandleTableAudio },
{ "RTTTL", MTP_FORMAT_UNDEFINED_AUDIO, kObjectHandleTableAudio },
{ "SMF", MTP_FORMAT_UNDEFINED_AUDIO, kObjectHandleTableAudio },
{ "IMY", MTP_FORMAT_UNDEFINED_AUDIO, kObjectHandleTableAudio },
{ "RTX", MTP_FORMAT_UNDEFINED_AUDIO, kObjectHandleTableAudio },
{ "OTA", MTP_FORMAT_UNDEFINED_AUDIO, kObjectHandleTableAudio },
{ "MPEG", MTP_FORMAT_UNDEFINED_VIDEO, kObjectHandleTableVideo },
{ "MP4", MTP_FORMAT_UNDEFINED_VIDEO, kObjectHandleTableVideo },
{ "M4V", MTP_FORMAT_UNDEFINED_VIDEO, kObjectHandleTableVideo },
{ "3GP", MTP_FORMAT_UNDEFINED_VIDEO, kObjectHandleTableVideo },
{ "3GPP", MTP_FORMAT_UNDEFINED_VIDEO, kObjectHandleTableVideo },
{ "3G2", MTP_FORMAT_UNDEFINED_VIDEO, kObjectHandleTableVideo },
{ "3GPP2", MTP_FORMAT_UNDEFINED_VIDEO, kObjectHandleTableVideo },
{ "WMV", MTP_FORMAT_UNDEFINED_VIDEO, kObjectHandleTableVideo },
{ "ASF", MTP_FORMAT_UNDEFINED_VIDEO, kObjectHandleTableVideo },
{ "JPG", MTP_FORMAT_EXIF_JPEG, kObjectHandleTableImage },
{ "JPEG", MTP_FORMAT_EXIF_JPEG, kObjectHandleTableImage },
{ "GIF", MTP_FORMAT_GIF, kObjectHandleTableImage },
{ "PNG", MTP_FORMAT_PNG, kObjectHandleTableImage },
{ "BMP", MTP_FORMAT_BMP, kObjectHandleTableImage },
{ "WBMP", MTP_FORMAT_BMP, kObjectHandleTableImage },
{ "M3U", MTP_FORMAT_M3U_PLAYLIST, kObjectHandleTablePlaylist },
{ "PLS", MTP_FORMAT_PLS_PLAYLIST, kObjectHandleTablePlaylist },
{ "WPL", MTP_FORMAT_WPL_PLAYLIST, kObjectHandleTablePlaylist },
{ "MP3", MTP_FORMAT_MP3, },
{ "M4A", MTP_FORMAT_UNDEFINED_AUDIO, },
{ "WAV", MTP_FORMAT_WAV, },
{ "AMR", MTP_FORMAT_UNDEFINED_AUDIO, },
{ "AWB", MTP_FORMAT_UNDEFINED_AUDIO, },
{ "WMA", MTP_FORMAT_WMA, },
{ "OGG", MTP_FORMAT_OGG, },
{ "OGA", MTP_FORMAT_UNDEFINED_AUDIO, },
{ "AAC", MTP_FORMAT_AAC, },
{ "MID", MTP_FORMAT_UNDEFINED_AUDIO, },
{ "MIDI", MTP_FORMAT_UNDEFINED_AUDIO, },
{ "XMF", MTP_FORMAT_UNDEFINED_AUDIO, },
{ "RTTTL", MTP_FORMAT_UNDEFINED_AUDIO, },
{ "SMF", MTP_FORMAT_UNDEFINED_AUDIO, },
{ "IMY", MTP_FORMAT_UNDEFINED_AUDIO, },
{ "RTX", MTP_FORMAT_UNDEFINED_AUDIO, },
{ "OTA", MTP_FORMAT_UNDEFINED_AUDIO, },
{ "MPEG", MTP_FORMAT_UNDEFINED_VIDEO, },
{ "MP4", MTP_FORMAT_UNDEFINED_VIDEO, },
{ "M4V", MTP_FORMAT_UNDEFINED_VIDEO, },
{ "3GP", MTP_FORMAT_UNDEFINED_VIDEO, },
{ "3GPP", MTP_FORMAT_UNDEFINED_VIDEO, },
{ "3G2", MTP_FORMAT_UNDEFINED_VIDEO, },
{ "3GPP2", MTP_FORMAT_UNDEFINED_VIDEO, },
{ "WMV", MTP_FORMAT_UNDEFINED_VIDEO, },
{ "ASF", MTP_FORMAT_UNDEFINED_VIDEO, },
{ "JPG", MTP_FORMAT_EXIF_JPEG, },
{ "JPEG", MTP_FORMAT_EXIF_JPEG, },
{ "GIF", MTP_FORMAT_GIF, },
{ "PNG", MTP_FORMAT_PNG, },
{ "BMP", MTP_FORMAT_BMP, },
{ "WBMP", MTP_FORMAT_BMP, },
{ "M3U", MTP_FORMAT_M3U_PLAYLIST, },
{ "PLS", MTP_FORMAT_PLS_PLAYLIST, },
{ "WPL", MTP_FORMAT_WPL_PLAYLIST, },
};
MtpObjectFormat MtpMediaScanner::getFileFormat(const char* path, uint32_t& table)
MtpObjectFormat MtpMediaScanner::getFileFormat(const char* path)
{
const char* extension = strrchr(path, '.');
if (!extension)
@@ -248,11 +119,9 @@ MtpObjectFormat MtpMediaScanner::getFileFormat(const char* path, uint32_t& table
for (unsigned i = 0; i < sizeof(sFileTypes) / sizeof(sFileTypes[0]); i++) {
if (!strcasecmp(extension, sFileTypes[i].extension)) {
table = sFileTypes[i].table;
return sFileTypes[i].format;
}
}
table = kObjectHandleTableFile;
return MTP_FORMAT_UNDEFINED;
}
@@ -316,8 +185,7 @@ int MtpMediaScanner::scanDirectory(const char* path, MtpObjectHandle parent)
}
void MtpMediaScanner::scanFile(const char* path, MtpObjectHandle parent, struct stat& statbuf) {
uint32_t table;
MtpObjectFormat format = getFileFormat(path, table);
MtpObjectFormat format = getFileFormat(path);
// don't scan unknown file types
if (format == MTP_FORMAT_UNDEFINED)
return;
@@ -334,22 +202,6 @@ void MtpMediaScanner::scanFile(const char* path, MtpObjectHandle parent, struct
mDatabase->rollbackTransaction();
return;
}
if (table == kObjectHandleTableAudio) {
mMediaScannerClient->reset();
mMediaScanner->processFile(path, NULL, *mMediaScannerClient);
handle = mDatabase->addAudioFile(handle,
mMediaScannerClient->getTitle(),
mMediaScannerClient->getArtist(),
mMediaScannerClient->getAlbum(),
mMediaScannerClient->getAlbumArtist(),
mMediaScannerClient->getGenre(),
mMediaScannerClient->getComposer(),
mMediaScannerClient->getMimeType(),
mMediaScannerClient->getTrack(),
mMediaScannerClient->getYear(),
mMediaScannerClient->getDuration());
}
mDatabase->commitTransaction();
}
}

6
media/mtp/MtpMediaScanner.h
View File

@@ -23,16 +23,12 @@ namespace android {
class MtpDatabase;
class SqliteStatement;
class MediaScanner;
class MtpMediaScannerClient;
class MtpMediaScanner {
private:
MtpStorageID mStorageID;
const char* mFilePath;
MtpDatabase* mDatabase;
MediaScanner* mMediaScanner;
MtpMediaScannerClient* mMediaScannerClient;
// for garbage collecting missing files
MtpObjectHandle* mFileList;
@@ -45,7 +41,7 @@ public:
bool scanFiles();
private:
MtpObjectFormat getFileFormat(const char* path, uint32_t& table);
MtpObjectFormat getFileFormat(const char* path);
int scanDirectory(const char* path, MtpObjectHandle parent);
void scanFile(const char* path, MtpObjectHandle parent, struct stat& statbuf);
void markFile(MtpObjectHandle handle);

3
media/mtp/MtpServer.cpp
View File

@@ -533,9 +533,6 @@ MtpResponseCode MtpServer::doSendObjectInfo() {
mDatabase->rollbackTransaction();
return MTP_RESPONSE_GENERAL_ERROR;
}
uint32_t table = MtpDatabase::getTableForFile(format);
if (table == kObjectHandleTableAudio)
handle = mDatabase->addAudioFile(handle);
mDatabase->commitTransaction();
if (format == MTP_FORMAT_ASSOCIATION) {

112
media/mtp/MtpSqliteDatabase.cpp
View File

@@ -37,22 +37,6 @@ namespace android {
#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," \
@@ -63,24 +47,6 @@ namespace android {
"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 = ?;"
@@ -90,9 +56,6 @@ namespace android {
#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;
@@ -127,9 +90,7 @@ MtpSqliteDatabase::MtpSqliteDatabase()
mFilePathQuery(NULL),
mObjectInfoQuery(NULL),
mFileInserter(NULL),
mFileDeleter(NULL),
mAudioInserter(NULL),
mAudioDeleter(NULL)
mFileDeleter(NULL)
{
}
@@ -140,8 +101,6 @@ MtpSqliteDatabase::~MtpSqliteDatabase() {
delete mObjectInfoQuery;
delete mFileInserter;
delete mFileDeleter;
delete mAudioInserter;
delete mAudioDeleter;
}
bool MtpSqliteDatabase::open(const char* path, bool create) {
@@ -159,10 +118,6 @@ bool MtpSqliteDatabase::open(const char* path, bool create) {
LOGE("could not path index on file table");
goto fail;
}
if (!mDatabase->exec(AUDIO_TABLE_CREATE)) {
LOGE("could not create file table");
goto fail;
}
if (!mFileIdQuery) {
mFileIdQuery = new SqliteStatement(mDatabase);
@@ -199,20 +154,6 @@ bool MtpSqliteDatabase::open(const char* path, bool create) {
goto fail;
}
}
if (!mAudioInserter) {
mAudioInserter = new SqliteStatement(mDatabase);
if (!mAudioInserter->prepare(AUDIO_INSERT)) {
LOGE("could not compile AUDIO_INSERT\n");
goto fail;
}
}
if (!mAudioDeleter) {
mAudioDeleter = new SqliteStatement(mDatabase);
if (!mAudioDeleter->prepare(AUDIO_DELETE)) {
LOGE("could not compile AUDIO_DELETE\n");
goto fail;
}
}
return true;
@@ -223,16 +164,12 @@ fail:
delete mObjectInfoQuery;
delete mFileInserter;
delete mFileDeleter;
delete mAudioInserter;
delete mAudioDeleter;
mDatabase = NULL;
mFileIdQuery = NULL;
mFilePathQuery = NULL;
mObjectInfoQuery = NULL;
mFileInserter = NULL;
mFileDeleter = NULL;
mAudioInserter = NULL;
mAudioDeleter = NULL;
return false;
}
@@ -250,7 +187,6 @@ MtpObjectHandle MtpSqliteDatabase::getObjectHandle(const char* path) {
int row = mFileIdQuery->getColumnInt(0);
if (row > 0) {
MtpObjectFormat format = mFileIdQuery->getColumnInt(1);
row |= getTableForFile(format);
return row;
}
}
@@ -276,45 +212,6 @@ MtpObjectHandle MtpSqliteDatabase::addFile(const char* path,
return (result <= 0 ? kInvalidObjectHandle : result);
}
MtpObjectHandle MtpSqliteDatabase::addAudioFile(MtpObjectHandle handle) {
mAudioInserter->bind(AUDIO_ID_COLUMN, handle);
mAudioInserter->step();
mAudioInserter->reset();
int result = mDatabase->lastInsertedRow();
handle |= kObjectHandleTableAudio;
return (result > 0 ? handle : kInvalidObjectHandle);
}
MtpObjectHandle MtpSqliteDatabase::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 = mDatabase->lastInsertedRow();
if (result <= 0)
return kInvalidObjectHandle;
result |= kObjectHandleTableAudio;
return result;
}
MtpObjectHandleList* MtpSqliteDatabase::getObjectList(MtpStorageID storageID,
MtpObjectFormat format,
MtpObjectHandle parent) {
@@ -360,7 +257,6 @@ MtpObjectHandleList* MtpSqliteDatabase::getObjectList(MtpStorageID storageID,
LOGV("stmt.getColumnInt returned %d", index);
if (index > 0) {
MtpObjectFormat format = stmt.getColumnInt(1);
index |= getTableForFile(format);
list->push(index);
}
}
@@ -508,11 +404,6 @@ bool MtpSqliteDatabase::deleteFile(MtpObjectHandle handle) {
mFileDeleter->bind(1, handle);
mFileDeleter->step();
mFileDeleter->reset();
if (table == kObjectHandleTableAudio) {
mAudioDeleter->bind(1, handle);
mAudioDeleter->step();
mAudioDeleter->reset();
}
return true;
}
@@ -541,7 +432,6 @@ MtpObjectHandle* MtpSqliteDatabase::getFileList(int& outCount) {
}
MtpObjectHandle handle = stmt2.getColumnInt(0);
MtpObjectFormat format = stmt2.getColumnInt(1);
handle |= getTableForFile(format);
result[i] = handle;
}
}

16
media/mtp/MtpSqliteDatabase.h
View File

@@ -35,8 +35,6 @@ private:
SqliteStatement* mObjectInfoQuery;
SqliteStatement* mFileInserter;
SqliteStatement* mFileDeleter;
SqliteStatement* mAudioInserter;
SqliteStatement* mAudioDeleter;
public:
MtpSqliteDatabase();
@@ -53,20 +51,6 @@ public:
uint64_t size,
time_t modified);
virtual MtpObjectHandle addAudioFile(MtpObjectHandle id);
virtual MtpObjectHandle addAudioFile(MtpObjectHandle id,
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);
virtual MtpObjectHandleList* getObjectList(MtpStorageID storageID,
MtpObjectFormat format,
MtpObjectHandle parent);

5
media/mtp/MtpTypes.h
View File

@@ -63,11 +63,6 @@ union MtpPropertyValue {
// MtpObjectHandle bits and masks
#define kObjectHandleMarkBit 0x80000000 // used for mark & sweep by MtpMediaScanner
#define kObjectHandleTableMask 0x70000000 // mask for object table
#define kObjectHandleTableFile 0x00000000 // object is only in the file table
#define kObjectHandleTableAudio 0x10000000 // object is in the audio table
#define kObjectHandleTableVideo 0x20000000 // object is in the video table
#define kObjectHandleTableImage 0x30000000 // object is in the images table
#define kObjectHandleTablePlaylist 0x40000000 // object is in the playlist table
#define kObjectHandleIndexMask 0x0FFFFFFF // mask for object index in file table
class MtpStorage;