/*
* 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: CMdEManager implementation
*
*/
#include "cmdemanager.h"
#include <mdeconstants.h>
#include <mmf\common\mmfcontrollerpluginresolver.h>
#include "logger.h"
// Warning: #940-D: missing return statement at end of non-void function
#pragma diag_remark 940
CMdEManager::CMdEManager( MMdEManagerObserver& aObserver ) :
iObserver(aObserver)
{
}
CMdEManager* CMdEManager::NewL( MMdEManagerObserver& aObserver )
{
CMdEManager* self = new (ELeave) CMdEManager( aObserver );
CleanupStack::PushL( self );
self->ConstructL();
CleanupStack::Pop( self );
return self;
}
void CMdEManager::ConstructL()
{
TRACE_FUNC;
iMde = CMdESession::NewL( *this );
}
CMdEManager::~CMdEManager()
{
TRACE_FUNC;
Cancel(); // Cancel any request, if outstanding
delete iAlbumQuery;
delete iObjectQuery;
delete iContainmentQuery;
delete iMde;
iAlbumsInProgress.ResetAndDestroy();
iAlbums.ResetAndDestroy();
}
void CMdEManager::GetAlbumsL()
{
TRACE_FUNC_ENTRY;
iAlbumsInProgress.ResetAndDestroy();
iAlbums.ResetAndDestroy();
if ( !iMde )
{
LOGGER_WRITE("Session was not ready!");
iState = EUninitialized;
iMde = CMdESession::NewL( *this );
}
if ( iState == EUninitialized)
{
LOGGER_WRITE("Starting processing albums after session is ready");
iState = EWaitingToEnumerateAlbums;
}
else if ( iState == EIdle )
{
StartProcessingAlbumsL();
}
else
{
LOGGER_WRITE_1("Wrong state: %d", iState);
User::Leave( KErrGeneral );
}
TRACE_FUNC_EXIT;
}
const CPlaylistItem& CMdEManager::AlbumL( TInt aAlbumId ) const
{
for ( TInt i=0; i<iAlbums.Count(); i++ )
{
if ( iAlbums[i]->Id() == aAlbumId )
{
LOGGER_WRITE("Album found");
return *iAlbums[i];
}
}
LOGGER_WRITE_1("CMdEManager::AlbumL - aAlbumId %d does not exist - Leaving KErrNotFound", aAlbumId);
User::Leave( KErrNotFound );
}
void CMdEManager::CreateAlbumL( CPlaylistItem& aAlbum )
{
TRACE_FUNC_ENTRY;
if ( !iMde || iState != EIdle )
{
LOGGER_WRITE("Not ready!");
User::Leave( KErrNotReady );
}
CMdENamespaceDef& defaultNamespaceDef = iMde->GetDefaultNamespaceDefL();
CMdEObjectDef& albumObjDef = defaultNamespaceDef.GetObjectDefL( MdeConstants::Album::KAlbumObject );
CMdEPropertyDef& titlePropDef = albumObjDef.GetPropertyDefL( MdeConstants::Object::KTitleProperty );
// Validate album name
TInt albumLength = aAlbum.Title().Length();
if ( albumLength < titlePropDef.MinTextLengthL() ||
albumLength > titlePropDef.MaxTextLengthL() )
{
LOGGER_WRITE("Album length is not on valid range!");
User::Leave( KErrBadName );
}
CMdEObject* albumObject = iMde->NewObjectLC( albumObjDef, KNullDesC );
CMdEPropertyDef& sizePropDef = albumObjDef.GetPropertyDefL( MdeConstants::Object::KSizeProperty );
albumObject->AddUint32PropertyL(sizePropDef, 0);
CMdEPropertyDef& creationDatePropDef = albumObjDef.GetPropertyDefL( MdeConstants::Object::KCreationDateProperty );
CMdEPropertyDef& lastModifiedDatePropDef = albumObjDef.GetPropertyDefL( MdeConstants::Object::KLastModifiedDateProperty );
TTime timeDate;
timeDate.UniversalTime();
albumObject->AddTimePropertyL( creationDatePropDef, timeDate );
albumObject->AddTimePropertyL( lastModifiedDatePropDef, timeDate );
CMdEPropertyDef& typePropDef = albumObjDef.GetPropertyDefL( MdeConstants::Object::KItemTypeProperty );
albumObject->AddTextPropertyL( typePropDef,MdeConstants::Album::KAlbumItemType );
albumObject->AddTextPropertyL( titlePropDef, aAlbum.Title() );
TItemId newAlbumId = iMde->AddObjectL( *albumObject );
CleanupStack::PopAndDestroy( albumObject );
if ( newAlbumId == KNoId )
{
LOGGER_WRITE("Adding album failed!");
User::Leave( KErrGeneral );
}
LOGGER_WRITE_1("New almbum created, id: %d", newAlbumId);
CMdERelationDef& relationDef = defaultNamespaceDef.GetRelationDefL( MdeConstants::Relations::KContains );
TMdEObject mediaObject;
RPointerArray<CMdEInstanceItem> relations;
CleanupResetAndDestroyPushL( relations);
for ( TInt i=0; i<aAlbum.ItemCount(); i++ )
{
TRAPD(err, iMde->CheckObjectL( mediaObject, aAlbum.ItemAt(i) ));
LOGGER_WRITE_1("url: %S", &aAlbum.ItemAt(i));
LOGGER_WRITE_1("CheckObjectL err: %d", err);
if ( !err )
{
LOGGER_WRITE_1("object def: %S", &mediaObject.DefL().Name());
if ( mediaObject.DefL().Name().Compare( MdeConstants::Image::KImageObject ) == 0
|| mediaObject.DefL().Name().Compare( MdeConstants::Video::KVideoObject ) == 0 )
{
CMdERelation* relation = iMde->NewRelationL( relationDef, newAlbumId, mediaObject.Id() );
relations.AppendL( relation );
}
else
{
LOGGER_WRITE("type not supported");
}
}
}
if ( relations.Count() > 0 )
{
TInt err = iMde->AddItemsL( relations );
LOGGER_WRITE_1("AddItemsL first err: %d", err);
}
CleanupStack::PopAndDestroy( &relations );
aAlbum.SetId( newAlbumId );
TRACE_FUNC_EXIT;
}
void CMdEManager::ReplaceAlbumL( TInt aAlbumId, CPlaylistItem& aAlbum )
{
TRACE_FUNC_ENTRY;
if ( !iMde || iState != EIdle )
{
LOGGER_WRITE("Not ready!");
User::Leave( KErrNotReady );
}
// get old album from local cache and check do we need to change album title
const CPlaylistItem& oldAlbum = AlbumL( aAlbumId );
CMdENamespaceDef& defaultNamespaceDef = iMde->GetDefaultNamespaceDefL();
if ( oldAlbum.Title().Compare( aAlbum.Title() ) != 0 )
{
// Title changed, open item from MdE and update it
CMdEObjectDef& albumObjDef = defaultNamespaceDef.GetObjectDefL( MdeConstants::Album::KAlbumObject );
CMdEPropertyDef& titlePropDef = albumObjDef.GetPropertyDefL(
MdeConstants::Object::KTitleProperty );
// Validate album name
TInt albumLength = aAlbum.Title().Length();
if ( albumLength < titlePropDef.MinTextLengthL() ||
albumLength > titlePropDef.MaxTextLengthL() )
{
LOGGER_WRITE("Album length is not on valid range!");
User::Leave( KErrBadName );
}
CMdEObject* albumObject = iMde->OpenObjectL( aAlbumId, albumObjDef );
CMdEProperty* titleProp = NULL;
TInt index = albumObject->Property( titlePropDef, titleProp );
if ( index == KErrNotFound )
{
LOGGER_WRITE("Cannot find title property");
User::Leave( KErrCorrupt );
}
LOGGER_WRITE("Change title property");
titleProp->SetTextValueL( aAlbum.Title() );
CMdEPropertyDef& lastModDatePropDef = albumObjDef.GetPropertyDefL(
MdeConstants::Object::KLastModifiedDateProperty );
CMdEProperty* lastModDateProp = NULL;
index = albumObject->Property( lastModDatePropDef, lastModDateProp );
if ( index == KErrNotFound )
{
LOGGER_WRITE("Cannot find lastModDateProp property");
User::Leave( KErrCorrupt );
}
TTime now;
now.UniversalTime();
lastModDateProp->SetTimeValueL( now );
iMde->CommitObjectL( *albumObject );
}
// Update album and content relations
// Search added relations
CMdERelationDef& containsRelationDef = defaultNamespaceDef.GetRelationDefL( MdeConstants::Relations::KContains );
TMdEObject mediaObject;
RPointerArray<CMdEInstanceItem> addedRelations;
CleanupResetAndDestroyPushL( addedRelations);
for ( TInt i=0; i< aAlbum.ItemCount(); i++)
{
TInt index(KErrNotFound);
TInt foundRes = oldAlbum.FindItem( aAlbum.ItemAt(i) ,index );
if ( foundRes != 0 )
{
// Item not found for old album -> Added relation
// Find object by uri
TRAPD( err, iMde->CheckObjectL( mediaObject, aAlbum.ItemAt(i) ));
LOGGER_WRITE_1("url: %S", &aAlbum.ItemAt(i));
LOGGER_WRITE_1("CheckObjectL err: %d", err);
if ( !err )
{
LOGGER_WRITE_1("object def: %S", &mediaObject.DefL().Name());
if ( mediaObject.DefL().Name().Compare( MdeConstants::Image::KImageObject ) == 0
|| mediaObject.DefL().Name().Compare( MdeConstants::Video::KVideoObject ) == 0 )
{
CMdERelation* relation = iMde->NewRelationL( containsRelationDef, aAlbumId, mediaObject.Id() );
addedRelations.AppendL( relation );
}
else
{
LOGGER_WRITE("type not supported");
}
}
}
}
if ( addedRelations.Count() > 0 )
{
TInt err = iMde->AddItemsL( addedRelations );
LOGGER_WRITE_1("AddItemsL first err: %d", err);
}
CleanupStack::PopAndDestroy( &addedRelations );
// search removed relations
if ( iContainmentQuery )
{
delete iContainmentQuery;
iContainmentQuery = NULL;
}
iContainmentQuery = iMde->NewRelationQueryL( defaultNamespaceDef, this );
CMdELogicCondition& rootCondition = iContainmentQuery->Conditions();
CMdERelationCondition& relationCondition =
rootCondition.AddRelationConditionL(containsRelationDef,
ERelationConditionSideLeft); // "AND"
CMdELogicCondition& leftCondition = relationCondition.LeftL();
CMdELogicCondition& rightCondition = relationCondition.RightL();
leftCondition.AddObjectConditionL( aAlbumId );
CMdELogicCondition& objectDefLogicCond =
rightCondition.AddLogicConditionL( ELogicConditionOperatorOr);
TBool removingRelationsNeeded( EFalse );
for ( TInt i=0; i< oldAlbum.ItemCount(); i++)
{
TInt index(KErrNotFound);
TInt foundRes = aAlbum.FindItem( oldAlbum.ItemAt(i) ,index );
if ( foundRes != 0 )
{
removingRelationsNeeded = ETrue;
// Item not found from new album -> Removed relation (add uri to search condition)
LOGGER_WRITE_1("relation to be removed, uri: %S", &oldAlbum.ItemAt(i) );
objectDefLogicCond.AddObjectConditionL( EObjectConditionCompareUri, oldAlbum.ItemAt(i) );
}
}
if ( removingRelationsNeeded )
{
// find all removed relation ID:s. HandleRelationQueryCompleted will be called when ready.
iContainmentQuery->SetResultMode( EQueryResultModeId );
iContainmentQuery->FindL();
iState = EReplacingAlbum;
}
else
{
// All done
iState = EIdle;
iObserver.AlbumReplaced( KErrNone );
}
TRACE_FUNC_EXIT;
}
void CMdEManager::DeleteAlbumL( TInt aAlbumId )
{
TRACE_FUNC_ENTRY;
if ( !iMde || iState != EIdle )
{
LOGGER_WRITE("Not ready!");
User::Leave( KErrNotReady );
}
CMdENamespaceDef& defaultNamespaceDef = iMde->GetDefaultNamespaceDefL();
CMdEObjectDef& albumObjDef = defaultNamespaceDef.GetObjectDefL( MdeConstants::Album::KAlbumObject );
CMdEObject* albumObject = iMde->GetObjectL( aAlbumId, albumObjDef );
CMdEPropertyDef& typePropDef = albumObjDef.GetPropertyDefL(
MdeConstants::Album::KTypeProperty );
CMdEProperty* typeProp = NULL;
TInt index = albumObject->Property( typePropDef, typeProp );
if ( index != KErrNotFound )
{
TUint16 typeVal = typeProp->Uint16ValueL();
if ( typeVal == MdeConstants::Album::EAlbumSystemFavourite )
{
LOGGER_WRITE("Item type is EAlbumSystemFavourite, deletion not allowed!");
User::Leave( KErrPermissionDenied );
}
}
TItemId removedId(KNoId);
removedId = iMde->RemoveObjectL( aAlbumId );
if ( removedId == KNoId )
{
LOGGER_WRITE("Deletion failed!");
User::Leave( KErrNotFound );
}
TRACE_FUNC_EXIT;
}
void CMdEManager::StartProcessingAlbumsL()
{
TRACE_FUNC_ENTRY;
CMdENamespaceDef& defaultNamespaceDef = iMde->GetDefaultNamespaceDefL();
CMdEObjectDef& albumObjDef = defaultNamespaceDef.GetObjectDefL( MdeConstants::Album::KAlbumObject );
if ( iAlbumQuery )
{
delete iAlbumQuery;
iAlbumQuery = NULL;
}
// query objects with object definition "Album"
iAlbumQuery = iMde->NewObjectQueryL( defaultNamespaceDef, albumObjDef, this );
// Add order
CMdEObjectDef& objdef = defaultNamespaceDef.GetObjectDefL( MdeConstants::Object::KBaseObject );
CMdEPropertyDef& propDef = objdef.GetPropertyDefL( MdeConstants::Object::KTitleProperty );
TMdEOrderRule rule( propDef, ETrue );
iAlbumQuery->AppendOrderRuleL( rule );
iAlbumQuery->FindL();
iState = EEnumeratingAlbums;
TRACE_FUNC_EXIT;
}
void CMdEManager::FindItemsOnAlbumL( TItemId aAlbumObjectId )
{
TRACE_FUNC_ENTRY;
if ( !iMde )
{
LOGGER_WRITE("Session was not ready!");
User::Leave( KErrNotReady );
}
CMdENamespaceDef& defaultNamespaceDef = iMde->GetDefaultNamespaceDefL();
CMdEObjectDef& objDef = defaultNamespaceDef.GetObjectDefL( MdeConstants::Object::KBaseObject );
CMdEPropertyDef& titlePropDef = objDef.GetPropertyDefL( MdeConstants::Object::KTitleProperty );
if ( iObjectQuery )
{
delete iObjectQuery;
iObjectQuery = NULL;
}
iObjectQuery = iMde->NewObjectQueryL( defaultNamespaceDef, objDef, this );
// get only "Title" property
iObjectQuery->AddPropertyFilterL( &titlePropDef );
CMdEObjectDef& objdef = defaultNamespaceDef.GetObjectDefL( MdeConstants::Object::KBaseObject );
CMdEPropertyDef& propDef = objdef.GetPropertyDefL( MdeConstants::Object::KTitleProperty );
CMdELogicCondition& rootCond = iObjectQuery->Conditions();
CMdERelationDef& containsRelDef = defaultNamespaceDef.GetRelationDefL(
MdeConstants::Relations::KContains );
// query right side objects from relations
CMdERelationCondition& relCond = rootCond.AddRelationConditionL(
containsRelDef, ERelationConditionSideRight );
// left side object of relation must be defined album object
CMdELogicCondition& leftRelCond = relCond.LeftL();
leftRelCond.AddObjectConditionL( aAlbumObjectId );
iObjectQuery->FindL();
TRACE_FUNC_EXIT;
}
/**
* Called to notify the observer that opening the session has been
* completed and, if the opening succeeded, the session is ready for use.
*
* @param aSession session
* @param aError <code>KErrNone</code>, if opening the session succeeded;
* or one of the system-wide error codes, if opening the
* session failed
*/
void CMdEManager::HandleSessionOpened(CMdESession& /*aSession*/, TInt aError)
{
TRACE_FUNC_ENTRY;
if ( !aError )
{
LOGGER_WRITE("Session opened");
if ( iState == EWaitingToEnumerateAlbums )
{
iState = EIdle;
TRAPD(err, StartProcessingAlbumsL());
if ( err )
{
iObserver.AlbumsReaded( err );
}
}
else
{
iState = EIdle;
}
}
else
{
LOGGER_WRITE_1("Error happened on opening session, aError: %d", aError);
if ( iState == EWaitingToEnumerateAlbums )
{
iObserver.AlbumsReaded( aError );
}
iState = EUninitialized;
delete iMde;
iMde = NULL;
}
TRACE_FUNC_EXIT;
}
/**
* Called to notify the observer about errors, which are not a direct
* consequence of the operations initiated by the client but caused by
* some external source (e.g., other clients). The error cannot be
* recovered and all on-going operations initiated by the client have been
* aborted. Any attempts to continue using the session will cause a panic.
* The client should close the session immediately and try to open a new
* session, if it needs to continue using the metadata engine.
*
* @param aSession session
* @param aError one of the system-wide error codes
*/
void CMdEManager::HandleSessionError(CMdESession& /*aSession*/, TInt aError)
{
// Something went wrong. Handle the error and delete the old session.
LOGGER_WRITE_1("CMdEManager::HandleSessionError - aError: %d", aError)
iState = EUninitialized;
delete iMde;
iMde = NULL;
}
/**
* Called to notify the observer that new results have been received
* in the query.
*
* @param aQuery Query instance that received new results.
* @param aFirstNewItemIndex Index of the first new item that was added
* to the result item array.
* @param aNewItemCount Number of items added to the result item
* array.
*/
void CMdEManager::HandleQueryNewResults(CMdEQuery& /*aQuery*/,
TInt /*aFirstNewItemIndex*/,
TInt /*aNewItemCount*/)
{
}
void CMdEManager::ProcessNextAlbumL()
{
TRACE_FUNC_ENTRY;
if ( iAlbumsInProgress.Count() == 0 )
{
LOGGER_WRITE("All ready");
// all ready
return;
}
FindItemsOnAlbumL( iAlbumsInProgress[0]->Id() );
TRACE_FUNC_EXIT;
}
/**
* Called to notify the observer that the query has been completed,
* or that an error has occured.
*
* @param aQuery Query instance.
* @param aError <code>KErrNone</code>, if the query was completed
* successfully. Otherwise one of the system-wide error
* codes.
*/
void CMdEManager::HandleQueryCompleted(CMdEQuery& aQuery, TInt aError)
{
TRACE_FUNC_ENTRY;
TInt err( aError );
if ( iState == EEnumeratingAlbums )
{
CMdEObjectQuery& query = (CMdEObjectQuery&)aQuery;
if ( !err && &aQuery == iAlbumQuery )
{
LOGGER_WRITE("Album query");
TRAP( err, HandleAlbumQueryCompletedL( query ));
}
else if ( !err && &aQuery == iObjectQuery )
{
LOGGER_WRITE("Object query");
TRAP( err, HandleObjectQueryCompletedL( query ));
}
else
{
LOGGER_WRITE("unknown query or error happened");
}
if ( err )
{
LOGGER_WRITE_1("Error happened: %d", err);
iState = EIdle;
iAlbumsInProgress.ResetAndDestroy();
iAlbums.ResetAndDestroy();
iObserver.AlbumsReaded( err );
}
}
else if ( iState == EReplacingAlbum )
{
if ( !err && &aQuery == iContainmentQuery )
{
LOGGER_WRITE("relation query");
CMdERelationQuery& query = (CMdERelationQuery&)aQuery;
TRAP( err, HandleRelationQueryCompletedL( query ));
}
iState = EIdle;
iObserver.AlbumReplaced( err );
}
TRACE_FUNC_EXIT;
}
// -----------------------------------------------------------------------------
// CMdEManager::HandleAlbumQueryCompletedL
// Callback function for find all albums. Save albums to iAlbumsInProgress array
// and start collecting objects on each album.
// -----------------------------------------------------------------------------
void CMdEManager::HandleAlbumQueryCompletedL( CMdEObjectQuery& aQuery )
{
TRACE_FUNC_ENTRY;
// clear old items
iAlbumsInProgress.ResetAndDestroy();
iAlbums.ResetAndDestroy();
for ( TInt i = 0; i < aQuery.Count(); i++ )
{
CPlaylistItem* albumItem = CPlaylistItem::NewLC();
CMdEObject& object = aQuery.Result(i);
LOGGER_WRITE_1("Id: %d", object.Id());
albumItem->SetId( object.Id() );
CMdEPropertyDef& titlePropDef = object.Def().GetPropertyDefL( MdeConstants::Object::KTitleProperty );
CMdEProperty* titleProp = NULL;
TInt index = object.Property( titlePropDef, titleProp );
if ( index != KErrNotFound )
{
const TDesC& title = titleProp->TextValueL();
LOGGER_WRITE_1("Title: %S", &title);
albumItem->SetTitleL( title );
}
else
{
// not found, might be default album
albumItem->SetTitleL( object.Uri() );
}
LOGGER_WRITE("");
iAlbumsInProgress.AppendL( albumItem );
CleanupStack::Pop( albumItem );
}
if ( aQuery.Count() > 0 )
{
// Start processing albums
ProcessNextAlbumL();
}
else
{
// no albums
iObserver.AlbumsReaded( KErrNone );
}
TRACE_FUNC_EXIT;
}
void CMdEManager::HandleObjectQueryCompletedL( CMdEObjectQuery& aQuery )
{
if ( !iAlbumsInProgress.Count() )
{
LOGGER_WRITE("Error! No items on iAlbumsInProgress");
User::Leave( KErrGeneral );
}
for ( TInt i = 0; i < aQuery.Count(); i++ )
{
CMdEObject& object = aQuery.Result(i);
iAlbumsInProgress[0]->AddItemL( object.Uri() );
}
iAlbums.AppendL( iAlbumsInProgress[0] );
iAlbumsInProgress.Remove( 0 );
if ( iAlbumsInProgress.Count() > 0)
{
ProcessNextAlbumL();
}
else
{
// all albums processed
iState = EIdle;
iObserver.AlbumsReaded( KErrNone );
}
}
void CMdEManager::HandleRelationQueryCompletedL( CMdERelationQuery& aQuery )
{
TRACE_FUNC_ENTRY;
const RArray<TItemId>& res = aQuery.ResultIds();
LOGGER_WRITE_1("founded relations count: %d", res.Count())
for (TInt i=0; i<res.Count(); i++ )
{
LOGGER_WRITE_1(" %d", res[i]);
}
LOGGER_WRITE_1("q count: %d", aQuery.Count() );
RArray<TItemId> removed;
CMdENamespaceDef& defaultNameSpace = iMde->GetDefaultNamespaceDefL();
iMde->RemoveRelationsL( aQuery.ResultIds(),removed, &defaultNameSpace);
LOGGER_WRITE_1("Removed relations count: %d", removed.Count())
for (TInt i=0; i<removed.Count(); i++)
{
LOGGER_WRITE_1(" %d", removed[i]);
}
TRACE_FUNC_EXIT;
}
void CMdEManager::Cancel()
{
TRACE_FUNC_ENTRY;
if ( iState == EWaitingToEnumerateAlbums )
{
// Cancel enumeration before it even begins
iState = EUninitialized;
iObserver.AlbumsReaded( KErrCancel );
}
if ( iAlbumQuery )
{
LOGGER_WRITE("iAlbumQuery->Cancel()");
iAlbumQuery->Cancel();
}
if ( iObjectQuery )
{
LOGGER_WRITE("iObjectQuery->Cancel()");
iObjectQuery->Cancel();
}
if ( iContainmentQuery )
{
LOGGER_WRITE("iContainmentQuery->Cancel()");
iContainmentQuery->Cancel();
}
TRACE_FUNC_EXIT;
}