/*

* Copyright (c) 2008 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:  Collects metadata based on user selections

*

*/

// INCLUDES

#include <e32std.h>

#include "cmsqlpropertycontainer.h"

#include "cmsqlpropertyitem.h"

#include "cmsqlpropertycollector.h"

#include "msmetadatacollector.h"

#include "msappui.h"

#include "msengine.h"

#include "msdebug.h"

// ---------------------------------------------------------------------------

// NewL

// ---------------------------------------------------------------------------

//

EXPORT_C CMSMetadataCollector* CMSMetadataCollector::NewL(

                                                    CMSAppUi& aMSAppUi,

                                                    TCmMediaType aMediaType,

                                                    RArray<TInt>& aGenreArray,

                                                    RArray<TInt>& aArtistArray,

                                                    RArray<TInt>& aAlbumArray,

                                                    RArray<TInt>& aTrackArray )

    {

    LOG(_L("[MediaServant]\t CMSMetadataCollector::NewL"));

    CMSMetadataCollector* self = CMSMetadataCollector::NewLC(

                                                        aMSAppUi,

                                                        aMediaType,

                                                        aGenreArray,

                                                        aArtistArray,

                                                        aAlbumArray,

                                                        aTrackArray );

    CleanupStack::Pop( self );

    return self;

    }

// ---------------------------------------------------------------------------

// NewLC

// ---------------------------------------------------------------------------

//

EXPORT_C CMSMetadataCollector* CMSMetadataCollector::NewLC(

                                                    CMSAppUi& aAppUi,

                                                    TCmMediaType aMediaType,

                                                    RArray<TInt>& aGenreArray,

                                                    RArray<TInt>& aArtistArray,

                                                    RArray<TInt>& aAlbumArray,

                                                    RArray<TInt>& aTrackArray )

    {

    LOG(_L("[MediaServant]\t CMSMetadataCollector::NewLC"));

    CMSMetadataCollector* self = new ( ELeave ) CMSMetadataCollector(

                                                        aAppUi,

                                                        aMediaType,

                                                        aGenreArray,

                                                        aArtistArray,

                                                        aAlbumArray,

                                                        aTrackArray );

    CleanupStack::PushL( self );

    self->ConstructL();

    return self;

    }

// ---------------------------------------------------------------------------

// Destructor

// ---------------------------------------------------------------------------

//

CMSMetadataCollector::~CMSMetadataCollector()

    {

    LOG(_L("[MediaServant]\t CMSMetadataCollector::~CMSMetadataCollector"));

    delete iMetadataCollector;

    }

// ---------------------------------------------------------------------------

// Default constructor

// ---------------------------------------------------------------------------

//

CMSMetadataCollector::CMSMetadataCollector( CMSAppUi& aMSAppUi,

                                            TCmMediaType aMediaType,

                                            RArray<TInt>& aGenreArray,

                                            RArray<TInt>& aArtistArray,

                                            RArray<TInt>& aAlbumArray,

                                            RArray<TInt>& aTrackArray ) :

    iMSAppUi( &aMSAppUi ),

    iMediaType( aMediaType ),

    iGenreArray( &aGenreArray ),

    iArtistArray( &aArtistArray ),

    iAlbumArray( &aAlbumArray ),

    iTrackArray( &aTrackArray )

    {

    }

// ---------------------------------------------------------------------------

// CMSMetadataCollector::ConstructL

// ---------------------------------------------------------------------------

//

void CMSMetadataCollector::ConstructL()

    {

    LOG(_L("[MediaServant]\t CMSMetadataCollector::ConstructL"));

    iMetadataCollector = CCmSqlPropertyCollector::NewL();

    AddContainersL();

    GetFilteredMetadataL();

    }

// ---------------------------------------------------------------------------

//CMSMetadataCollector::GetFilteredMetadataL

// ---------------------------------------------------------------------------

//

void CMSMetadataCollector::GetFilteredMetadataL()

    {

    LOG(_L("[MediaServant]\t CMSMetadataCollector::GetFilteredMetadataL"));

    DeleteAllItems();

    // TRACKS - this is both video titles and music tracks

    for ( TInt index = 0; index < iTrackArray->Count(); index++ )

        {

        CCmSqlPropertyItem* item = CCmSqlPropertyItem::NewLC();

        item->SetId( (*iTrackArray)[index] );

        CCmSqlPropertyContainer* container =

                        iMetadataCollector->PropertyContainer( ETracks );

        container->AddPropertyItemL( item );

        CleanupStack::Pop( item );

        }

    if ( iMediaType == ECmAudio )

        {

        // ARTISTS

        for ( TInt index = 0; index < iArtistArray->Count(); index++ )

            {

            CCmSqlPropertyItem* item = CCmSqlPropertyItem::NewLC();

            item->SetId( (*iArtistArray)[index] );

            CCmSqlPropertyContainer* container =

                        iMetadataCollector->PropertyContainer( EArtists );

            container->AddPropertyItemL( item );

            CleanupStack::Pop( item );

            }

        // GENRES

        for ( TInt index = 0; index < iGenreArray->Count(); index++ )

            {

            CCmSqlPropertyItem* item = CCmSqlPropertyItem::NewLC();

            item->SetId( (*iGenreArray)[index] );

            CCmSqlPropertyContainer* container =

                        iMetadataCollector->PropertyContainer( EGenres );

            container->AddPropertyItemL( item );

            CleanupStack::Pop( item );

            }

        // ALBUMS

        for ( TInt index = 0; index < iAlbumArray->Count(); index++ )

            {

            CCmSqlPropertyItem* item = CCmSqlPropertyItem::NewLC();

            item->SetId( (*iAlbumArray)[index] );

            CCmSqlPropertyContainer* container =

                        iMetadataCollector->PropertyContainer( EAlbums );

            container->AddPropertyItemL( item );

            CleanupStack::Pop( item );

            }

        }

    // Start asynchronous metadata query.

    // Engine observer's ReadyL will be called when ready

    iMSAppUi->MSEngine()->GetFilteredMetadataL( iMetadataCollector );

    }

// --------------------------------------------------------------------------

//CMSMetadataCollector::DeleteAllItems

// --------------------------------------------------------------------------

//

void CMSMetadataCollector::DeleteAllItems()

    {

    LOG(_L("[MediaServant]\t CMSMetadataCollector::DeleteAllItems"));

    for ( TInt index = 0;

          index < iMetadataCollector->PropertyContainerCount();

          index++ )

        {

        CCmSqlPropertyContainer* container =

                            iMetadataCollector->PropertyContainer( index );

        for ( TInt idx = 0; idx < container->PropertyItemCount(); idx++ )

            {

            container->DeletePropertyItem( idx-- );

            }

        }

    }

// --------------------------------------------------------------------------

//CMSMetadataCollector::AddContainersL

// --------------------------------------------------------------------------

//

void CMSMetadataCollector::AddContainersL()

    {

    LOG(_L("[MediaServant]\t CMSMetadataCollector::AddContainersL"));

    // tracks

    // this container is used both videos and music    

    CCmSqlPropertyContainer* trackContainer =

                                CCmSqlPropertyContainer::NewLC();

    trackContainer->SetType( ECmTitle );

    iMetadataCollector->AddPropertyContainerL( trackContainer );

    CleanupStack::Pop( trackContainer );

    if ( iMediaType == ECmAudio )

        {

        // artists  

        CCmSqlPropertyContainer* artistContainer =

                                CCmSqlPropertyContainer::NewLC();            

        artistContainer->SetType( ECmArtist );

        iMetadataCollector->AddPropertyContainerL( artistContainer );

        CleanupStack::Pop( artistContainer );

        // genres

        CCmSqlPropertyContainer* genreContainer =

                                CCmSqlPropertyContainer::NewLC();

        genreContainer->SetType( ECmGenre );

        iMetadataCollector->AddPropertyContainerL( genreContainer );

        CleanupStack::Pop( genreContainer );

        // albums

        CCmSqlPropertyContainer* albumContainer =

                                CCmSqlPropertyContainer::NewLC();

        albumContainer->SetType( ECmAlbum );

        iMetadataCollector->AddPropertyContainerL( albumContainer );

        CleanupStack::Pop( albumContainer );

        }

    }

// ---------------------------------------------------------------------------

//CMSMetadataCollector::Genres

// ---------------------------------------------------------------------------

//

CCmSqlPropertyContainer* CMSMetadataCollector::Genres()

    {

    return iMetadataCollector->PropertyContainer( EGenres );

    }

// ---------------------------------------------------------------------------

//CMSMetadataCollector::Artists

// ---------------------------------------------------------------------------

//

CCmSqlPropertyContainer* CMSMetadataCollector::Artists()

    {

    return iMetadataCollector->PropertyContainer( EArtists );

    }

// ---------------------------------------------------------------------------

//CMSMetadataCollector::Albums

// ---------------------------------------------------------------------------

//

CCmSqlPropertyContainer* CMSMetadataCollector::Albums()

    {

    return iMetadataCollector->PropertyContainer( EAlbums );

    }

// ---------------------------------------------------------------------------

//CMSMetadataCollector::Tracks

// ---------------------------------------------------------------------------

//

CCmSqlPropertyContainer* CMSMetadataCollector::Tracks()

    {

    return iMetadataCollector->PropertyContainer( ETracks );

    }

// End of file