/*
* Copyright (c) 2009 Nokia Corporation and/or its subsidiary(-ies).
* All rights reserved.
* This component and the accompanying materials are made available
* under the terms of "Eclipse Public License v1.0"
* which accompanies this distribution, and is available
* at the URL "http://www.eclipse.org/legal/epl-v10.html".
*
* Initial Contributors:
* Nokia Corporation - initial contribution.
*
* Contributors:
*
* Description:
*
*/
#include "irsonghistoryinfo.h"
#include "irsonghistorydb.h"
#include "irqsonghistoryinfo.h"
#include "irqisdsdatastructure.h"
#include "irqmetadata.h"
#include "irqsonghistoryengine.h"
// ---------------------------------------------------------------------------
// IRQSongHistoryEngine::openInstance()
// Static function to get a singleton instance of IRQSongHistoryEngine
// @return IRQSongHistoryEngine *
// ---------------------------------------------------------------------------
//
EXPORT_C IRQSongHistoryEngine* IRQSongHistoryEngine::openInstance()
{
// Get singleton instance
IRQSongHistoryEngine* irqSongHistoryEngine =
reinterpret_cast<IRQSongHistoryEngine*>(Dll::Tls());
if (NULL == irqSongHistoryEngine)
{
TRAPD(error, irqSongHistoryEngine = createInstanceL());
if (KErrNone != error)
{
delete irqSongHistoryEngine;
irqSongHistoryEngine = NULL;
Dll::SetTls(NULL);
}
}
else
{
irqSongHistoryEngine->iSingletonInstances++;
}
return irqSongHistoryEngine;
}
// ---------------------------------------------------------------------------
// IRQSongHistoryEngine::closeInstance()
// Close a singleton instance of IRQSongHistoryEngine
// ---------------------------------------------------------------------------
//
EXPORT_C void IRQSongHistoryEngine::closeInstance()
{
iSingletonInstances--;
if (0 == iSingletonInstances)
{
Dll::SetTls(NULL);
delete this;
}
}
// ---------------------------------------------------------------------------
// IRQSongHistoryEngine::createInstanceL()
// Creates IRQSongHistoryEngine instance
// @return IRQSongHistoryEngine*
// ---------------------------------------------------------------------------
//
IRQSongHistoryEngine* IRQSongHistoryEngine::createInstanceL()
{
IRQSongHistoryEngine* irqSongHistoryEngine = new (ELeave) IRQSongHistoryEngine();
irqSongHistoryEngine->constructL();
User::LeaveIfError(Dll::SetTls(irqSongHistoryEngine));
irqSongHistoryEngine->iSingletonInstances = 1;
return irqSongHistoryEngine;
}
// ---------------------------------------------------------------------------
// IRQSongHistoryEngine::constructL()
// Two-Phase Constructor.
// ---------------------------------------------------------------------------
//
void IRQSongHistoryEngine::constructL()
{
iSongHistoryDb = CIRSongHistoryDb::NewL();
}
// ---------------------------------------------------------------------------
// IRQSongHistoryEngine::IRQSongHistoryEngine()
// standard C++ Constructor
// ---------------------------------------------------------------------------
//
IRQSongHistoryEngine::IRQSongHistoryEngine()
{
}
// ---------------------------------------------------------------------------
// IRQSongHistoryEngine::~IRQSongHistoryEngine()
// standard C++ destructor
// ---------------------------------------------------------------------------
//
IRQSongHistoryEngine::~IRQSongHistoryEngine()
{
delete iSongHistoryDb;
iSongHistoryDb = NULL;
}
// ---------------------------------------------------------------------------
// IRQSongHistoryEngine::handleMetaDataReceivedL()
// Invoked when channel name or song & artist name are changed.
// ---------------------------------------------------------------------------
//
EXPORT_C void IRQSongHistoryEngine::handleMetaDataReceived(const IRQMetaData& aMetaData,
const IRQPreset& aPreset)
{
TRAPD(error, handleMetaDataReceivedL(aMetaData, aPreset));
if (KErrNone != error)
{
}
}
EXPORT_C void IRQSongHistoryEngine::handleSongMetaDataReceived(const IRQMetaData& aMetaData,
const IRQPreset& aPreset)
{
TRAPD(error, handleSongMetaDataReceivedL(aMetaData,aPreset));
if (KErrNone != error)
{
}
}
EXPORT_C void IRQSongHistoryEngine::handleSongMetaDataReceivedL(const IRQMetaData& aMetaData,
const IRQPreset& aPreset)
{
TPtrC songName(reinterpret_cast<const TUint16*>(aMetaData.getSongName().utf16()), aMetaData.getSongName().length());
TPtrC artistName(reinterpret_cast<const TUint16*>(aMetaData.getArtistName().utf16()), aMetaData.getArtistName().length());
TPtrC channelName(reinterpret_cast<const TUint16*>(aPreset.name.utf16()), aPreset.name.length());
TPtrC musicFlag(reinterpret_cast<const TUint16*>(aPreset.musicStoreStatus.utf16()), aPreset.musicStoreStatus.length());
TBool bExceededMax = iSongHistoryDb->AddToSongHistoryDb2L(songName,
artistName,
channelName,
musicFlag);
}
// ---------------------------------------------------------------------------
// IRQSongHistoryEngine::handleMetaDataReceivedL()
// ---------------------------------------------------------------------------
//
void IRQSongHistoryEngine::handleMetaDataReceivedL(const IRQMetaData& aMetaData,
const IRQPreset& aPreset)
{
// Read Channel properties
TPtrC songName(reinterpret_cast<const TUint16*>(aMetaData.getSongName().utf16()), aMetaData.getSongName().length());
TPtrC artistName(reinterpret_cast<const TUint16*>(aMetaData.getArtistName().utf16()), aMetaData.getArtistName().length());
TPtrC channelUrl(reinterpret_cast<const TUint16*>(aMetaData.getStreamUrl().utf16()), aMetaData.getStreamUrl().length());
TPtrC channelName(reinterpret_cast<const TUint16*>(aPreset.name.utf16()), aPreset.name.length());
TPtrC channelDesc(reinterpret_cast<const TUint16*>(aPreset.description.utf16()), aPreset.description.length());
TPtrC imageUrl(reinterpret_cast<const TUint16*>(aPreset.imgUrl.utf16()), aPreset.imgUrl.length());
TPtrC genreName(reinterpret_cast<const TUint16*>(aPreset.genreName.utf16()), aPreset.genreName.length()>KMaxColumnLength ? KMaxColumnLength : aPreset.genreName.length());
TPtrC countryName(reinterpret_cast<const TUint16*>(aPreset.countryName.utf16()), aPreset.countryName.length());
TPtrC languageName(reinterpret_cast<const TUint16*>(aPreset.languageName.utf16()), aPreset.languageName.length());
TPtrC musicFlag(reinterpret_cast<const TUint16*>(aPreset.musicStoreStatus.utf16()), aPreset.musicStoreStatus.length());
TUint8 channelType = aPreset.type;
TUint16 channelId = aPreset.presetId;
TUint16 bitrate = aMetaData.getBitrate();
if (channelType == 1)
{
TInt ret = iSongHistoryDb->GetIdPresentInDbL( channelId );
if(ret)
{
TInt modified = iSongHistoryDb->UpdateSongHistoryDbL( channelId ,
channelUrl ,imageUrl ,genreName, countryName, languageName, musicFlag);
// TODO notify uplayer to change layout?
}
}
else if (channelType != 0)
{
// the channel type can only be 1 (isds channel) or 0 (user defined channel)
channelType = 0;
}
iSongHistoryDb->SearchAndDeleteRecordL(channelName, channelUrl, channelType, channelId);
RBuf delSongName;
delSongName.CleanupClosePushL();
RBuf delArtistName;
delArtistName.CleanupClosePushL();
RBuf delChannelName;
delChannelName.CleanupClosePushL();
RBuf delChannelUrl;
delChannelUrl.CleanupClosePushL();
TBool bExceededMax = iSongHistoryDb->AddToSongHistoryDbL(songName,
artistName,
channelName,
channelUrl,
delSongName,
delArtistName,
delChannelName,
delChannelUrl ,
channelType,
channelId,
bitrate,
channelDesc,
imageUrl,
genreName,
countryName,
languageName,
musicFlag);
CleanupStack::PopAndDestroy(4, &delSongName);
}
// ---------------------------------------------------------------------------
// IRQSongHistoryEngine::detectSongHistoryItemChangesL()
// To detect any change in the song history items.
// ---------------------------------------------------------------------------
//
IRQSongHistoryEngine::TSongHistoryItemChange IRQSongHistoryEngine::detectSongHistoryItemChangesL(
const IRQMetaData& aMetaData, const QString& aChannelName)
{
if(aChannelName.length() == 0)
{
return EBLANKENTRIES;
}
RBuf song;
song.CleanupClosePushL();
RBuf artist;
artist.CleanupClosePushL();
RBuf channel;
channel.CleanupClosePushL();
RBuf url;
url.CleanupClosePushL();
iSongHistoryDb->GetLastHistoryItemL(song, artist, channel, url);
TSongHistoryItemChange retval = ENOCHANGE;
QString tmpsong = QString::fromUtf16(song.Ptr(), song.Length());
QString tmpartist = QString::fromUtf16(artist.Ptr(), artist.Length());
QString tmpchannel = QString::fromUtf16(channel.Ptr(), channel.Length());
QString tmpurl = QString::fromUtf16(url.Ptr(), url.Length());
if (tmpsong == aMetaData.getSongName() && tmpartist == aMetaData.getArtistName()
&& tmpchannel == aChannelName && tmpurl == aMetaData.getStreamUrl())
{
retval = ENOCHANGE;
}
else
{
retval = ECHANNELCHANGED;
}
CleanupStack::PopAndDestroy(4, &song);
return retval;
}
// ---------------------------------------------------------------------------
// IRQSongHistoryEngine::getAllHistory
// Invoked when when UI request.
// Getting the data from SongHistoryDb.
// ---------------------------------------------------------------------------
EXPORT_C void IRQSongHistoryEngine::getAllHistory(QList<IRQSongHistoryInfo *>& aSongHistoryArr)
{
TRAP_IGNORE(getAllHistoryL(aSongHistoryArr));
}
EXPORT_C void IRQSongHistoryEngine::getAllSongHistory(QList<IRQSongInfo *>& aSongHistoryArr)
{
TRAP_IGNORE(getAllSongHistoryL(aSongHistoryArr));
}
// ---------------------------------------------------------------------------
// IRQSongHistoryEngine::getAllHistoryL
// Invoked when when UI request.
// Getting the data from SongHistoryDb.
// ---------------------------------------------------------------------------
void IRQSongHistoryEngine::getAllHistoryL(QList<IRQSongHistoryInfo *>& aSongHistoryArr)
{
// clear the array
while (!aSongHistoryArr.isEmpty())
{
delete aSongHistoryArr.takeFirst();
}
int songCount = iSongHistoryDb->CountSongHistoryDb();
if (songCount == 0)
{
return;
}
// get song history list
RPointerArray<CIRSongHistoryInfo> historyDataArr;
for (int arrCount = 0 ; arrCount < songCount ; arrCount++ )
{
CIRSongHistoryInfo *songHistory = CIRSongHistoryInfo::NewL();
CleanupStack::PushL(songHistory);
historyDataArr.AppendL(songHistory);
CleanupStack::Pop(songHistory);
}
iSongHistoryDb->GetAllSongHistoryListL(historyDataArr);
// create IRQSongHistoryInfo array and set
QString songName;
QString artist;
QString streamUrl;
QString channelName;
int channelType;
int channelId;
int bitrate;
QString channelDesc;
QString imageUrl;
QString genreName;
QString countryName;
QString languageName;
QString musicStoreStatus;
for (int arrCount = 0 ; arrCount < songCount ; arrCount++ )
{
songName = QString::fromUtf16(historyDataArr[arrCount]->GetSongInfo().Ptr(),
historyDataArr[arrCount]->GetSongInfo().Length());
artist = QString::fromUtf16(historyDataArr[arrCount]->GetArtistInfo().Ptr(),
historyDataArr[arrCount]->GetArtistInfo().Length());
streamUrl = QString::fromUtf16(historyDataArr[arrCount]->GetStreamUrl().Ptr(),
historyDataArr[arrCount]->GetStreamUrl().Length());
channelName = QString::fromUtf16(historyDataArr[arrCount]->GetChannelName().Ptr(),
historyDataArr[arrCount]->GetChannelName().Length());
channelType = historyDataArr[arrCount]->GetChannelType();
channelId = historyDataArr[arrCount]->GetChannelId();
bitrate = historyDataArr[arrCount]->GetBitrate();
channelDesc = QString::fromUtf16(historyDataArr[arrCount]->GetChannelDesc().Ptr(),
historyDataArr[arrCount]->GetChannelDesc().Length());
imageUrl = QString::fromUtf16(historyDataArr[arrCount]->GetImageUrl().Ptr(),
historyDataArr[arrCount]->GetImageUrl().Length());
genreName = QString::fromUtf16(historyDataArr[arrCount]->GetGenreName().Ptr(),
historyDataArr[arrCount]->GetGenreName().Length());
countryName = QString::fromUtf16(historyDataArr[arrCount]->GetCountryName().Ptr(),
historyDataArr[arrCount]->GetCountryName().Length());
languageName = QString::fromUtf16(historyDataArr[arrCount]->GetLanguageName().Ptr(),
historyDataArr[arrCount]->GetLanguageName().Length());
musicStoreStatus = QString::fromUtf16(historyDataArr[arrCount]->GetChannelMusicStatus().Ptr(),
historyDataArr[arrCount]->GetChannelMusicStatus().Length());
IRQSongHistoryInfo* irqsongHistory = new IRQSongHistoryInfo();
if (NULL == irqsongHistory)
{
break;
}
irqsongHistory->setHistoryInfo(artist, songName, streamUrl, channelName, channelDesc
, imageUrl, genreName, countryName, languageName, musicStoreStatus, channelType, channelId, bitrate);
aSongHistoryArr.append(irqsongHistory);
}
historyDataArr.ResetAndDestroy();
}
// ---------------------------------------------------------------------------
// IRQSongHistoryEngine::getAllHistoryL
// Invoked when when UI request.
// Getting the data from SongHistoryDb.
// ---------------------------------------------------------------------------
void IRQSongHistoryEngine::getAllSongHistoryL(QList<IRQSongInfo *>& aSongHistoryArr)
{
// clear the array
while (!aSongHistoryArr.isEmpty())
{
delete aSongHistoryArr.takeFirst();
}
int songCount = iSongHistoryDb->CountSongHistoryDb2();
if (songCount == 0)
{
return;
}
// get song history list
RPointerArray<CIRSongHistoryInfo> historyDataArr;
for (int arrCount = 0 ; arrCount < songCount ; arrCount++ )
{
CIRSongHistoryInfo *songHistory = CIRSongHistoryInfo::NewL();
CleanupStack::PushL(songHistory);
historyDataArr.AppendL(songHistory);
CleanupStack::Pop(songHistory);
}
iSongHistoryDb->GetAllSongHistoryList2L(historyDataArr);
// create IRQSongHistoryInfo array and set
QString songName;
QString artist;
QString stationName;
QString musicStoreStatus;
for (int arrCount = 0; arrCount < songCount; arrCount++)
{
songName = QString::fromUtf16(
historyDataArr[arrCount]->GetSongInfo().Ptr(),
historyDataArr[arrCount]->GetSongInfo().Length());
artist = QString::fromUtf16(
historyDataArr[arrCount]->GetArtistInfo().Ptr(),
historyDataArr[arrCount]->GetArtistInfo().Length());
stationName = QString::fromUtf16(
historyDataArr[arrCount]->GetChannelName().Ptr(),
historyDataArr[arrCount]->GetChannelName().Length());
musicStoreStatus = QString::fromUtf16(
historyDataArr[arrCount]->GetChannelMusicStatus().Ptr(),
historyDataArr[arrCount]->GetChannelMusicStatus().Length());
IRQSongInfo* irqsong = new IRQSongInfo();
irqsong->setAllInfo(songName, artist, stationName, musicStoreStatus);
aSongHistoryArr.append(irqsong);
}
historyDataArr.ResetAndDestroy();
}
// ---------------------------------------------------------------------------
// IRQSongHistoryEngine::clearAllHistory
// Invoked when when UI request.
// Clears the SongHistoryDb.
// ---------------------------------------------------------------------------
EXPORT_C int IRQSongHistoryEngine::clearAllHistory( )
{
return iSongHistoryDb->ClearAllSongHistoryFromDb();
}
EXPORT_C int IRQSongHistoryEngine::clearAllSongHistory( )
{
return iSongHistoryDb->ClearAllSongHistoryFromDb2();
}
// ---------------------------------------------------------------------------
// IRQSongHistoryEngine::syncHistory
// Invoked when when UI request.
// Synchronises the Song history DB with the new data in the ISDS.
// ---------------------------------------------------------------------------
EXPORT_C void IRQSongHistoryEngine::syncHistory(int aChannelId)
{
TRAPD(err,iSongHistoryDb->SyncSongHistoryDbL(aChannelId));
if (err)
{
}
}
// ---------------------------------------------------------------------------
// IRQSongHistoryEngine::updateSongHistoryDb
// Invoked when when UI request.
// Synchronises the Song history DB with the new data in the ISDS.
// ---------------------------------------------------------------------------
EXPORT_C void IRQSongHistoryEngine::updateSongHistoryDb(int aChannelId,
const QString& aChannelName,
const QString& aChannelUrl,
const QString& aImageUrl,
const QString& aGenreName,
const QString& aCountryName,
const QString& aLanguageName,
const QString& aMusicFlag)
{
TInt ret = KErrNone ;
TUint16 channelId = aChannelId; // prevent data overflow
TRAPD(err,ret = iSongHistoryDb->GetIdPresentInDbL( channelId ));
if (err)
{
return;
}
if (ret)
{
TPtrC channelName(reinterpret_cast<const TUint16*>(aChannelName.utf16()));
TPtrC channelUrl(reinterpret_cast<const TUint16*>(aChannelUrl.utf16()));
TPtrC imageUrl(reinterpret_cast<const TUint16*>(aImageUrl.utf16()));
TPtrC genreName(reinterpret_cast<const TUint16*>(aGenreName.utf16()));
TPtrC countryName(reinterpret_cast<const TUint16*>(aCountryName.utf16()));
TPtrC languageName(reinterpret_cast<const TUint16*>(aLanguageName.utf16()));
TPtrC musicFlag(reinterpret_cast<const TUint16*>(aMusicFlag.utf16()));
TRAP_IGNORE(iSongHistoryDb->UpdateSongHistoryDbL( channelId ,
channelUrl,
imageUrl,
genreName,
countryName,
languageName,
musicFlag));
}
}
EXPORT_C bool IRQSongHistoryEngine::deleteOneItem(int aIndex)
{
int retValue = 0;
retValue = iSongHistoryDb->DeleteOneHistory(aIndex);
if( KErrNone != retValue )
{
return false;
}
return true;
}
EXPORT_C bool IRQSongHistoryEngine::deleteOneSongHistoryItem(int aIndex)
{
int retValue = 0;
retValue = iSongHistoryDb->DeleteOneSongHistory(aIndex);
if( KErrNone != retValue )
{
return false;
}
return true;
}