/*
* Copyright (c) 2004-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:  Skin store.
*
*/


// INCLUDE FILES

// Psln specific.
#include "PslnSkinStore.h"
#include "PslnModel.h"
#include "PslnSkinEntry.h"
#include "PslnDebug.h"

// Repository
#include <centralrepository.h>
#include <AknSkinsInternalCRKeys.h>
#include <AknsSkinUID.h>

#ifdef RD_MULTIPLE_DRIVE
#include <driveinfo.h>
#endif //RD_MULTIPLE_DRIVE

void CleanupDeleteArray( TAny* aArray )
    {
    static_cast<RPointerArray<CPslnSkinNameEntry>*>
        (aArray)->ResetAndDestroy();
    delete aArray;
    aArray = NULL;
    }

// ============================ MEMBER FUNCTIONS ===============================

// -----------------------------------------------------------------------------
// C++ default constructor can NOT contain any code, that
// might leave.
// -----------------------------------------------------------------------------
//
CPslnSkinStore::CPslnSkinStore()
    {
    }

// -----------------------------------------------------------------------------
// Symbian 2nd phase constructor can leave.
// -----------------------------------------------------------------------------
//
void CPslnSkinStore::ConstructL( CPslnModel* aModel )
    {
    iModel = aModel;

    CRepository* repository = CRepository::NewLC( KCRUidPersonalisation );
    TInt value = KAknsNullPkgID.iNumber;
    iDefaultSkinPID.Set( KAknsPIDS60DefaultSkin );
    TBuf<32> buf;
    TAknsPkgID defaultSkin = KAknsNullPkgID;

    TInt err = repository->Get( KPslnDefaultSkinUID, buf );
    if ( err != KErrNone || buf.Length() == 0 )
        {
        err = repository->Get( KPslnDefaultSkinID, value );
        if( err == KErrNone )
            {
            defaultSkin.Set( TUid::Uid( value ) );
            }
        }
    else
        {
        TInt bufLength = buf.Length();
        // If its 8 characters long, its UID.
        // PIDs are 16 characters (8 ID + 8 timestamp)
        if ( bufLength == 8 )
            {
            // Let's try to set it directly as Hex.
            TLex hexLex( buf );
            TUint pid;
            err = hexLex.Val( pid, EHex );
            if (!err)
                {
                // UIDs have no timestamp.
                defaultSkin.Set( 0, pid );
                }
            }
        else
            {
            // The skin PID is set in CenRep in format <PID1><PID2> and
            // values are in hex.
            TLex lex ( buf.Left( 8 ) );
            TLex lex2 ( buf.Right( 8 ) );
            TUint pid;
            TUint timeStamp;
            err = lex.Val( pid, EHex );
            if ( !err )
                {
                err = lex2.Val( timeStamp, EHex );
                }
            if ( !err )
                {
                defaultSkin.Set( timeStamp, pid );
                }
            }
        }
    iDefaultSkinPID = defaultSkin;
    CleanupStack::PopAndDestroy( repository );
    }

// -----------------------------------------------------------------------------
// Two-phased constructor.
// -----------------------------------------------------------------------------
//
CPslnSkinStore* CPslnSkinStore::NewL( CPslnModel* aModel )
    {
    PSLN_TRACE_DEBUG("CPslnSkinStore::NewL");

    CPslnSkinStore* self = new( ELeave ) CPslnSkinStore;
    CleanupStack::PushL( self );
    self->ConstructL( aModel );
    CleanupStack::Pop( self );
    return self;
    }

// -----------------------------------------------------------------------------
// Destructor.
// -----------------------------------------------------------------------------
//
CPslnSkinStore::~CPslnSkinStore()
    {
    iSkinArray.ResetAndDestroy();
    }

// -----------------------------------------------------------------------------
// CPslnSkinStore::UpdateAllSkinsL
// -----------------------------------------------------------------------------
//
void CPslnSkinStore::UpdateAllSkinsL( RFs& aFsSession )
    {
    PSLN_TRACE_DEBUG("CPslnSkinStore::UpdateAllSkinsL");

    TInt i = KErrNone;

    // Mark all the existing skins
    for( ; i < iSkinArray.Count(); i++ )
        {
        CPslnSkinEntry* entry = iSkinArray[i];
        entry->SetDeleteFlag( ETrue );
        }
    UpdateAllSkinsL( EAknsSrvAll, aFsSession );

    // Remove any skins that haven't existed (they no longer exist)
    TInt skinCount = iSkinArray.Count() - 1;
    for( i = skinCount; i >= 0; i-- )
        {
        CPslnSkinEntry* entry = iSkinArray[i];
        if( entry && entry->IsDeleteFlag() )
            {
            delete entry;
            iSkinArray.Remove( i );
            }
        }

    // Then sort the array
    iSkinArray.Sort( CPslnSkinEntry::LinearOrder );

    // Finally, move default skin as first item in the array.
    i = KErrNotFound;
    skinCount = iSkinArray.Count() - 1;
    CPslnSkinEntry* entry = NULL;
    for( i = skinCount; i >= 0; i-- )
        {
        entry = iSkinArray[i];
        // move default theme first, if it is not already there.
        if ( ( entry->PkgID() == iDefaultSkinPID ) && ( i != 0 ) )
            {
            // Default skin found.
            iSkinArray.Remove( i );
            iSkinArray.Insert( entry, 0 );
            entry = NULL; // this is not owned by us.
            break;
            }
        }
    }

// -----------------------------------------------------------------------------
// CPslnSkinStore::Find
// -----------------------------------------------------------------------------
//
CPslnSkinEntry* CPslnSkinStore::Find( const TAknsPkgID& aPID, 
    TAknSkinSrvSkinPackageLocation aLocation )
    {
    PSLN_TRACE_DEBUG("CPslnSkinStore::Find");
    TBool allLocations = ( aLocation == EAknsSrvAll );
    CPslnSkinEntry* entry = NULL;

    for( TInt i = 0; i < iSkinArray.Count(); i++ )
        {
        entry = iSkinArray[i];

        // If PID matches AND
        // location mathes (or is looking from all locations).
        if( ( entry && entry->PkgID() == aPID ) &&
              ( ( allLocations ) ||
              ( entry->Location() == aLocation ) ) )
            {
            // this entry is the one we are looking for.
            break;
            }
        else
            {
            entry = NULL;
            }
        }

    return entry;
    }

// -----------------------------------------------------------------------------
// CPslnSkinStore::UpdateOrAddL
// -----------------------------------------------------------------------------
//
CPslnSkinEntry* CPslnSkinStore::UpdateOrAddL( 
    CAknsSrvSkinInformationPkg* aInfo, RFs& aFsSession )
    {
    PSLN_TRACE_DEBUG("CPslnSkinStore::UpdateOrAddL");

    if( !aInfo )
        {
        User::Leave( KErrArgument );
        }
    CleanupStack::PushL( aInfo );

    CPslnSkinEntry* entry = Find( aInfo->PID(),
        CPslnSkinEntry::LocationFromPath( aInfo->IniFileDirectory() ) );

#ifdef RD_MULTIPLE_DRIVE
    TInt drive = EDriveC;
    TUint driveStatus = 0;
    TFileName fileName;
#endif // RD_MULTIPLE_DRIVE

    if( entry )
        {
#ifdef RD_MULTIPLE_DRIVE
        entry->GetSkinPath( fileName );
        User::LeaveIfError( RFs::CharToDrive( fileName[0], drive ) );
        User::LeaveIfError( DriveInfo::GetDriveStatus( 
            aFsSession, drive, driveStatus ) );
        if ( driveStatus & DriveInfo::EDriveExternallyMountable &&
             driveStatus & DriveInfo::EDriveRemovable )
            {
            entry->SetMemoryCardFlag( ETrue );
            }
        else if ( driveStatus & DriveInfo::EDriveExternallyMountable )
            {
            entry->SetMassDriveFlag( ETrue );
            }
#endif // RD_MULTIPLE_DRIVE

        entry->SetProtection( aInfo->ProtectionType() );
        CleanupStack::PopAndDestroy( aInfo );
        }
    else
        {
        // Ownership of aInfo is transferred to CPslnSkinEntry.
        entry = CPslnSkinEntry::NewL( aInfo );
        CleanupStack::Pop( aInfo );
        CleanupStack::PushL( entry );

#ifdef RD_MULTIPLE_DRIVE
        entry->GetSkinPath( fileName );
        User::LeaveIfError( RFs::CharToDrive( fileName[0], drive ) );
        User::LeaveIfError( DriveInfo::GetDriveStatus( 
            aFsSession, drive, driveStatus ) );
        if ( driveStatus & DriveInfo::EDriveExternallyMountable &&
             driveStatus & DriveInfo::EDriveRemovable )
            {
            entry->SetMemoryCardFlag( ETrue );
            }
        else if ( driveStatus & DriveInfo::EDriveExternallyMountable )
            {
            entry->SetMassDriveFlag( ETrue );
            }
#endif // RD_MULTIPLE_DRIVE

        // Using Append instead of InsertInOrderAllowRepeats, since localized
        // names are not fetched yet for all the items.
        User::LeaveIfError( iSkinArray.Append( entry ) );
        CleanupStack::Pop( entry );
        }

    return entry;
    }

// -----------------------------------------------------------------------------
// CPslnSkinStore::CreateNameArray
// -----------------------------------------------------------------------------
//
RPointerArray<CPslnSkinNameEntry>* CPslnSkinStore::CreateNameArrayL()
    {
    PSLN_TRACE_DEBUG("CPslnSkinStore::CreateNameArray");
    RPointerArray<CPslnSkinNameEntry>* array =
        new RPointerArray<CPslnSkinNameEntry>();

    CleanupStack::PushL( TCleanupItem( CleanupDeleteArray, array ) );

    for( TInt i = 0; i < iSkinArray.Count(); i++ )
        {
        AppendEntryL( *array, i );
        }
    CleanupStack::Pop(); // TCleanupItem

    return array;
    }

// -----------------------------------------------------------------------------
// CPslnSkinStore::UpdateAllSkinsL
// -----------------------------------------------------------------------------
//    
void CPslnSkinStore::UpdateAllSkinsL(
    TAknSkinSrvSkinPackageLocation aLocation, RFs& aFsSession )
    {
    PSLN_TRACE_DEBUG("CPslnSkinStore::UpdateAllSkinsL");
    CArrayPtr<CAknsSrvSkinInformationPkg>* srvArray =
        iModel->SkinSrvSession().EnumerateSkinPackagesL( aLocation );

    while( srvArray && srvArray->Count() )
        {
        CAknsSrvSkinInformationPkg* info = srvArray->At( 0 );
        TRAP_IGNORE( UpdateOrAddL( info, aFsSession )->SetDeleteFlag( EFalse ) );
        srvArray->Delete( 0 );
        }

    if ( srvArray )
        {
        srvArray->ResetAndDestroy();
        }
    delete srvArray;
    }

// -----------------------------------------------------------------------------
// Appends entry to array.
// -----------------------------------------------------------------------------
// 
void CPslnSkinStore::AppendEntryL(
    RPointerArray<CPslnSkinNameEntry>& aArray, const TInt aIndex )
    {
    PSLN_TRACE_DEBUG("CPslnSkinStore::AppendEntryL");
    // Get entry.
    CPslnSkinEntry* entry = iSkinArray[aIndex];

    // Get name entry.
    CPslnSkinNameEntry* nameEntry = NULL;
    nameEntry = CPslnSkinNameEntry::NewL();
    nameEntry->SetPkgID( entry->PkgID() );
    nameEntry->SetLocation( entry->Location() );
    PSLN_TRACE_DEBUG("CPslnSkinStore::AppendEntryL.2");

    // Get name for the entry.
    HBufC* skinName = HBufC::NewLC( KMaxName );
    TPtr skinNamePtr = skinName->Des();
    entry->GetName( skinNamePtr );
    nameEntry->SetNameL( skinNamePtr );
    CleanupStack::PopAndDestroy( skinName );

    if( aArray.Append( nameEntry ) )
        {
        User::Leave( KErrGeneral );
        }
    }

//  End of File