/*

* Copyright (c) 2006-2007 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:      Capsulating store rule

*

*/

// INCLUDES

#include <e32std.h>

#include <s32mem.h>

#include "cmmediaserver.h"

#include "cmstorerule.h"

#include "msdebug.h"

// CONSTANTS

const TInt KArrayGranularity = 16;

const TInt KArrayGranularityContainer = 8;

// ======== LOCAL FUNCTIONS ========

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

// NewL

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

//

EXPORT_C CCmStoreRule* CCmStoreRule::NewL()

    {    

    CCmStoreRule* self = CCmStoreRule::NewLC();

    CleanupStack::Pop( self ); 

    return self;

    }

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

// NewLC

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

//    

EXPORT_C CCmStoreRule* CCmStoreRule::NewLC()

    {    

    CCmStoreRule* self = new ( ELeave ) CCmStoreRule();

    CleanupStack::PushL( self );

    self->ConstructL(); 

    return self;  

    }    

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

// Destructor

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

//

EXPORT_C CCmStoreRule::~CCmStoreRule()

    {

    delete iName;

    iRuleDefs.Reset();

    iRuleDefs.Close();

    iMediaServers.ResetAndDestroy();

    iMediaServers.Close();

    iExcPlayLists->Reset();

    iExcAlbums->Reset();

    delete iExcPlayLists;

    delete iExcAlbums;      

    }

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

// Add new rule into StoreRule

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

//

EXPORT_C TInt CCmStoreRule::AddStoreRuleL( TCmMediaType aMediaType )

    {    

    iRuleDefs.AppendL( aMediaType );

    TInt index = iRuleDefs.Count() - 1;    

    return index;

    }

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

// Get rule

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

//

EXPORT_C void CCmStoreRule::StoreRule( TInt aIndex, TCmMediaType* aMediaType )

    {

    *aMediaType = (TCmMediaType)iRuleDefs[aIndex];

    }

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

// Add new media server into FillRule

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

//    

EXPORT_C TInt CCmStoreRule::AddMediaServerL( const TDesC8& aUDN )

    {

    CCmMediaServer* server = CCmMediaServer::NewLC();

    server->SetUDNL( aUDN );    

    iMediaServers.Append( server );

    CleanupStack::Pop( server );    

    TInt index = iMediaServers.Count() - 1;    

    return index;        

    }

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

// Delete media server from the store rule

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

//

EXPORT_C void CCmStoreRule::DeleteMediaServer( const TDesC8& aUDN )

    {

    TBool deleted( EFalse );

    for( TInt i = 0; i < iMediaServers.Count() && !deleted; i++ )

        {

        if( KErrNone == iMediaServers[i]->MediaServer().Compare(aUDN) )

            {

            delete iMediaServers[i];

            iMediaServers.Remove(i);

            iMediaServers.Compress();

            deleted = ETrue;

            }

        }

    }

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

// Adds one album into excluded list

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

//

EXPORT_C void CCmStoreRule::AddExcAlbumL( const TDesC& aAlbum )

    {

    TRACE(Print(_L("[COMMON]\t AddExcAlbumL( %S )"), &aAlbum ));

    HBufC* temp = aAlbum.AllocL();

    CleanupStack::PushL( temp );

    iExcAlbums->AppendL( *temp );

    CleanupStack::Pop( temp );

    }

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

// Adds one playlist into excluded list

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

//    

EXPORT_C void CCmStoreRule::AddExcPlayListL( const TDesC& aPlayList )

    {

    HBufC* temp = aPlayList.AllocL();

    CleanupStack::PushL( temp );

    iExcPlayLists->AppendL( *temp );

    CleanupStack::Pop( temp );

    }

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

// Removes one album from the excluded list

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

//

EXPORT_C void CCmStoreRule::RemoveExcAlbum( const TDesC& aAlbum )

    {

    TInt pos( KErrNone );

    TInt err( iExcAlbums->Find( aAlbum, pos, ECmpNormal ) );

    if( err == KErrNone )

        {

        iExcAlbums->Delete( pos );

        iExcAlbums->Compress();

        }

    }

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

// Removes one playlist from the excluded list

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

//    

EXPORT_C void CCmStoreRule::RemoveExcPlayList( const TDesC& aPlayList )

    {

    TInt pos( KErrNone );

    TInt err( iExcPlayLists->Find( aPlayList, pos, ECmpNormal ) );

    if( err == KErrNone )

        {

        iExcPlayLists->Delete( pos );

        iExcPlayLists->Compress();

        }    

    }

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

// Returns excluded albums

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

//

EXPORT_C CDesCArray& CCmStoreRule::ExcAlbums()

    {

    return *iExcAlbums;

    }

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

// Returns excluded playlists

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

//    

EXPORT_C CDesCArray& CCmStoreRule::ExcPlayLists()

    {

    return *iExcPlayLists;

    }

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

// Get media server

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

//    

EXPORT_C const TDesC8& CCmStoreRule::MediaServerL( TInt aIndex )

    {

    // check parameter

    if ( aIndex < 0 || aIndex >= iMediaServers.Count() ) 

        {

        User::Leave( KErrArgument );

        }

    return iMediaServers[aIndex]->MediaServer();

    }

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

// Returns count of rules

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

//

EXPORT_C TInt CCmStoreRule::DefCount() const

    {

    return iRuleDefs.Count();

    }

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

// Returns count of media servers

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

//    

EXPORT_C TInt CCmStoreRule::MediaServerCount() const

    {

    return iMediaServers.Count();

    }    

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

// Sets FillRule name

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

//

EXPORT_C void CCmStoreRule::SetNameL( const TDesC8& aName )

    {

    delete iName;

    iName = NULL;

    iName = aName.AllocL();        

    }

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

// Get Name

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

//

EXPORT_C TDesC8& CCmStoreRule::Name() const

    {

    return *iName;

    }

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

// Sets list id, when storing data into db this values isn't used as a 

// db list id

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

//

EXPORT_C void CCmStoreRule::SetListId( const TUint aId )

    {

    iId = aId;

    }

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

// Get list id

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

//    

EXPORT_C TUint CCmStoreRule::ListId() const

    {

    return iId;

    }

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

// Sets selected state

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

//

EXPORT_C void CCmStoreRule::SetSelected( TCmFillRuleStatus aSelected )

    {

    iSelected = aSelected;

    }

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

// Returns method

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

//

EXPORT_C TCmFillRuleStatus CCmStoreRule::Selected() const

    {

    return iSelected;

    }

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

// Sets rule's status ( e.g ECmToBeRemoved )

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

//

EXPORT_C void CCmStoreRule::SetStatus( TCmListItemStatus aStatus )

    {

    iStatus = aStatus;

    }

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

// Returns status 

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

//

EXPORT_C TCmListItemStatus CCmStoreRule::Status() const

    {

    return iStatus;

    }

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

// CCmStoreRule::ExternalizeL

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

//

void CCmStoreRule::ExternalizeL( RWriteStream& aStream ) const

    {

    aStream.WriteInt32L( iName->Length() );

    if ( iName )

        {

        aStream << *iName;

        }

    else

        {

        aStream << KNullDesC8();

        }      

    aStream.WriteInt16L((TInt)iSelected );    

    aStream.WriteInt16L((TInt)iStatus );

    aStream.WriteInt16L( iRuleDefs.Count() );

    for ( TInt index(0); index < iRuleDefs.Count(); index++ )

        {

        aStream.WriteInt16L((TInt)iRuleDefs[index] );

        }

    aStream.WriteInt16L( iMediaServers.Count() );

    for ( TInt index(0); index < iMediaServers.Count(); index++ )

        {

        iMediaServers[index]->ExternalizeL( aStream );

        }

    TRACE(Print(_L("[COMMON]\t iExcAlbums->Count() = %d"), 

        iExcAlbums->Count() ));    

    aStream.WriteInt16L( iExcAlbums->Count() );

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

        {

        TRACE(Print(_L("[COMMON]\t iExcAlbums[index].Length() = %d"), 

            iExcAlbums->MdcaPoint(index).Length() ));                

        aStream.WriteInt32L( iExcAlbums->MdcaPoint(index).Length() );

        aStream << iExcAlbums->MdcaPoint(index);

        }

    TRACE(Print(_L("[COMMON]\t iExcPlayLists->Count() = %d"), 

        iExcPlayLists->Count() ));         

    aStream.WriteInt16L( iExcPlayLists->Count() );

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

        {

        TRACE(Print(_L("[COMMON]\t iExcPlayLists[index].Length() = %d"), 

            iExcPlayLists->MdcaPoint(index).Length() ));

        aStream.WriteInt32L( iExcPlayLists->MdcaPoint(index).Length() );

        aStream << iExcPlayLists->MdcaPoint(index);

        }

    }

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

// CCmFillRule::InternalizeL

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

//

void CCmStoreRule::InternalizeL( RReadStream& aStream )

    {

    // Content

    if ( iName )

        {

        delete iName;

        iName = NULL;

        }

    TInt bufLength = aStream.ReadInt32L();    

    iName = HBufC8::NewL( aStream, bufLength );

    // cleanup

    iRuleDefs.Reset();

    iSelected = (TCmFillRuleStatus)aStream.ReadInt16L();

    iStatus = (TCmListItemStatus)aStream.ReadInt16L();

    // rule count 

    TInt ruleCount = aStream.ReadInt16L();

    // Then internalize them from the stream one by one

    for (TInt index = 0; index < ruleCount; index++ )

        {

        iRuleDefs.Append((TCmMediaType)aStream.ReadInt16L());   

        }

    // cleanup

    iMediaServers.ResetAndDestroy();

    // media Server count

    TInt mediaServerCount = aStream.ReadInt16L();

    // Then internalize them from the stream one by one

    for (TInt index = 0; index < mediaServerCount; index++ )

        {

        CCmMediaServer* server = CCmMediaServer::NewLC();    

        server->InternalizeL( aStream );

        iMediaServers.Append( server );

        CleanupStack::Pop( server );   

        server = NULL;

        }

    iExcAlbums->Reset();   

    TInt excAlbumsCount( aStream.ReadInt16L() );

    bufLength = KErrNone;

    HBufC* temp;

    TRACE(Print(_L("[COMMON]\t excAlbumsCount = %d"), excAlbumsCount ));    

    for ( TInt index(0); index < excAlbumsCount ; index++ )

        {

        bufLength = aStream.ReadInt32L();

        TRACE(Print(_L("[COMMON]\t bufLength = %d"), bufLength )); 

        temp = HBufC::NewL( aStream, bufLength );

        CleanupStack::PushL( temp );

        iExcAlbums->AppendL( *temp );

        CleanupStack::Pop( temp );

        temp = NULL;

        }         

    iExcPlayLists->Reset();

    TInt excPlayListCount( aStream.ReadInt16L() );

    bufLength = KErrNone;

    TRACE(Print(_L("[COMMON]\t excPlayListCount = %d"), excPlayListCount ));

    for ( TInt index(0); index < excPlayListCount ; index++ )

        {

        bufLength = aStream.ReadInt32L();

        TRACE(Print(_L("[COMMON]\t bufLength = %d"), bufLength ));

        temp = HBufC::NewL( aStream, bufLength );

        CleanupStack::PushL( temp );

        iExcPlayLists->AppendL( *temp );

        CleanupStack::Pop( temp );

        temp = NULL;

        }                 

    }

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

// Default constructor

// C++ default constructor can NOT contain any code, that might leave.

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

//    

CCmStoreRule::CCmStoreRule() : 

    iRuleDefs( KArrayGranularity ), 

    iMediaServers( KArrayGranularity )

    {

    }

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

// ConstructL

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

//    

void CCmStoreRule::ConstructL()

    {

    iExcAlbums = new ( ELeave ) CDesCArrayFlat( KArrayGranularityContainer );

    iExcPlayLists = 

        new ( ELeave ) CDesCArrayFlat( KArrayGranularityContainer );

    }    

// End of file