/*

* 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:      CM Settings Engine implementation

*

*/

#include <e32base.h>

#include <e32const.h>

#include <bautils.h>

#include <f32file.h>

#include <centralrepository.h>

#ifdef __SERIES60_31__

#include <upnpnetworkaccess.h>

#else

#include "upnpsettingsengine.h"

#endif

#include "cmdriveinfo.h"

#include <driveinfo.h>

#include "msdebug.h"

#include "cmsettingsengine.h"

#include "contentmanagercrkeys.h"

// Constants

const TInt KTimeLength = 64;

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

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

// Default constructor

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

//

CCmSettingsEngine::CCmSettingsEngine()

    {

    }

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

// Two-phase constructor

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

//

void CCmSettingsEngine::ConstructL()

    {

    LOG(_L("[CmSettinsEngine]\t CCmSettingsEngine::ConstructL"));

    iRepository = CRepository::NewL( KCRUidCmContentManager );

    }

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

// Two-phase API constructor

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

//

CCmSettingsEngine* CCmSettingsEngine::NewL()

    {

    LOG(_L("[CmSettinsEngine]\t CCmSettingsEngine::NewL"));

    CCmSettingsEngine* self = CCmSettingsEngine::NewLC();

    CleanupStack::Pop( self );

    return self;

    }

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

// Two-phase API constructor

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

//

CCmSettingsEngine* CCmSettingsEngine::NewLC()

    {

    LOG(_L("[CmSettinsEngine]\t CCmSettingsEngine::NewLC"));

    CCmSettingsEngine* self = new( ELeave ) CCmSettingsEngine;

    CleanupStack::PushL( self );

    self->ConstructL();

    return self;

    }

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

// Destructor

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

//

CCmSettingsEngine::~CCmSettingsEngine()

    {

    LOG(_L("[CmSettinsEngine]\t CCmSettingsEngine::~CCmSettingsEngine"));

    delete iRepository;

    }

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

// Gets Content Manager service's state

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

//

TInt CCmSettingsEngine::GetServiceState(

    const TCmService aService,

    TCmServiceState& aState ) const

    {

    TInt error( KErrNone );

    TInt state( 0 );

    switch ( aService )

        {

        case ECmServiceContentManager:

            {

            error = iRepository->Get( KCmContentManagerState, state ) ;

            break;

            }

        case ECmServiceHarvest:

            {

            error = iRepository->Get( KCmHarvesterState, state ) ;

            break;

            }

        case ECmServiceFill:

            {

            error = iRepository->Get( KCmFillState, state ) ;

            break;

            }

        case ECmServiceStore:

            {

            error = iRepository->Get( KCmStoreState, state ) ;

            break;

            }

        case ECmServiceMemoryManager:

            {

            error = iRepository->Get( KCmMemoryManagerState, state ) ;

            break;

            }

        default:

            {

            LOG(_L("[CmSettinsEngine]\t CCmSettingsEngine::GetServiceState \

            service not found"));

            error = KErrNotFound;

            break;

            }

        }

    if ( !error )

        {

        TRACE(Print(_L("[CmSettinsEngine]\t CCmSettingsEngine::\

        GetServiceState state = %d"), state ));

        // converting the value back

        aState = (TCmServiceState) state;

        }

    return error;

    }

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

// Set Content Manager service state

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

//

TInt CCmSettingsEngine::SetServiceState(

                                const TCmService aService,

                                const TCmServiceState aState )

    {

    LOG(_L("[CmSettinsEngine]\t CCmSettingsEngine::SetServiceState"));

    TInt error( KErrNone );

    switch ( aService )

        {

        case ECmServiceContentManager:

            {

            error = iRepository->Set( KCmContentManagerState, (TInt)aState ) ;

            break;

            }

        case ECmServiceHarvest:

            {

            error = iRepository->Set( KCmHarvesterState, (TInt)aState ) ;

            break;

            }

        case ECmServiceFill:

            {

            error = iRepository->Set( KCmFillState, (TInt)aState ) ;

            break;

            }

        case ECmServiceStore:

            {

            error = iRepository->Set( KCmStoreState, (TInt)aState ) ;

            break;

            }

        case ECmServiceMemoryManager:

            {

            error = iRepository->Set( KCmMemoryManagerState, (TInt)aState ) ;

            break;

            }

        default:

            {

            error = KErrNotFound;

            break;

            }

        }

    return error;

    }

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

// Gets IAP information from Home Network's cenrep key

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

//

TInt CCmSettingsEngine::GetIapL( TInt& aIap ) const

    {

    LOG(_L("[CmSettinsEngine]\t CCmSettingsEngine::GetIapL"));

#ifdef __SERIES60_31__

    CUpnpNetworkAccess* access = CUpnpNetworkAccess::NewL( KCRUidUPnPStack );

    TInt error( access->Get( CUpnpNetworkAccess::KUPnPStackIapId, aIap ) );

    delete access;

#else

    CUPnPSettingsEngine* settings = CUPnPSettingsEngine::NewLC();

    TInt error( settings->GetAccessPoint( aIap ) );

    CleanupStack::PopAndDestroy( settings );

#endif

    return error;

    }

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

// Gets next start time information for specified service

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

//

TInt CCmSettingsEngine::GetNextRuntime( const TCmService aService,

                                                 TTime& aRuntime ) const

    {

    LOG(_L("[CmSettinsEngine]\t CCmSettingsEngine::GetNextRuntime"));

    TBuf<KTimeLength> time;

    TPtrC timePtr( time );

    TInt error( KErrNone );

    if ( aService == ECmServiceStore )

        {

        error = iRepository->Get( KCmNextStoreTime, time );

        }

    else // ECmServiceFill

        {

        error = iRepository->Get( KCmNextFillTime, time );

        }

    if ( !error )

        {

        // convert string to TInt64

        TInt64 timeInt;

        TLex lex( timePtr );

        lex.Val( timeInt );

        aRuntime = timeInt;

        }

    return error;

    }

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

// Sets next start time information for specified service

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

//

TInt CCmSettingsEngine::SetNextRuntime( const TCmService aService,

                                                 const TTime aNextTime )

    {

    LOG(_L("[CmSettinsEngine]\t CCmSettingsEngine::SetNextRuntime"));

    TInt error( KErrNone );

    TBuf<KTimeLength> nextRunTime;

    nextRunTime.AppendNum( aNextTime.Int64() );

    if (aService == ECmServiceStore)

        {

        error = iRepository->Set( KCmNextStoreTime, nextRunTime );

        }

    else // ECmServiceFill

        {

        error = iRepository->Set( KCmNextFillTime, nextRunTime ) ;

        }

    return error;

    }

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

// Gets discovery delay.

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

//

TInt CCmSettingsEngine::GetDiscoveryDelay( TInt& aDelay ) const

    {

    TInt error( KErrNone );

    error = iRepository->Get( KCmDiscoveryDelay, aDelay );

    TRACE(Print(_L("[CmSettinsEngine]\t CCmSettingsEngine::\

    GetDiscoveryDelay delay = %d"), aDelay));

    return error;

    }

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

// Sets discovery delay

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

//

TInt CCmSettingsEngine::SetDiscoveryDelay( const TInt aDelay )

    {

    LOG(_L("[CmSettinsEngine]\t CCmSettingsEngine::SetDiscoveryDelay"));

    return iRepository->Set( KCmDiscoveryDelay, aDelay );

    }

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

//

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

//

TInt CCmSettingsEngine::GetAutoSync( TBool& aAutoSync ) const

    {

    LOG(_L("[CmSettinsEngine]\t CCmSettingsEngine::GetAutoSync"));

    TInt error( KErrNotFound );

    TInt autoSyncInt;

    error = iRepository->Get( KCmAutoSync, autoSyncInt );

    aAutoSync = (TBool) autoSyncInt;

    return error;

    }

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

// Sets synchronization state

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

//

TInt CCmSettingsEngine::SetAutoSync( const TBool aAutoSync )

    {

    LOG(_L("[CmSettinsEngine]\t CCmSettingsEngine::SetAutoSync"));

    return iRepository->Set( KCmAutoSync, (TInt)aAutoSync ) ;

    }

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

// Gets memory manager's status

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

//

TInt CCmSettingsEngine::GetMemoryManagerStatus(

    TBool& aMmStatus ) const

    {

    LOG(_L("[CmSettinsEngine]\t CCmSettingsEngine::GetMemoryManagerStatus"));

    TInt mmInt;

    TInt error = iRepository->Get( KCmMemoryManagerState, mmInt );

    if ( !error )

        {

        aMmStatus = (TBool) mmInt;

        }

    return error;

    }

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

// Sets memory manager's status

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

//

TInt CCmSettingsEngine::SetMemoryManagerStatus(

    const TBool aMmStatus )

    {

    LOG(_L("[CmSettinsEngine]\t CCmSettingsEngine::SetMemoryManagerStatus"));

    return iRepository->Set( KCmMemoryManagerState, (TInt)aMmStatus ) ;

    }

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

// Gets item count for search action

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

//

TInt CCmSettingsEngine::GetSearchCount( TInt& aItemCount ) const

    {

    TInt error( KErrNone );

    error = iRepository->Get( KCmSearchCount, aItemCount );

    TRACE(Print(_L("[CmSettinsEngine]\t CCmSettingsEngine::\

    GetSearchCount count = %d"), aItemCount));

    return error;

    }

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

// Gets item count for database add operation

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

//

TInt CCmSettingsEngine::GetAddCount( TInt& aAddCount ) const

    {

    LOG(_L("[CmSettinsEngine]\t CCmSettingsEngine::GetAddCount"));

    return iRepository->Get( KCmAddCount, aAddCount );

    }

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

// Gets app wizard execution status info.

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

//

TInt CCmSettingsEngine::GetAppWizardInformation(

    TInt& aAppWizardState ) const

    {

    LOG(_L("[CmSettinsEngine]\t CCmSettingsEngine::\

    GetAppWizardInformation"));

    return iRepository->Get( KCmAppWizardState, aAppWizardState );

    }

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

// Sets app wizard execution status info.

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

//

TInt CCmSettingsEngine::SetAppWizardInformation()

    {

    LOG(_L("[CmSettinsEngine]\t CCmSettingsEngine::\

    SetAppWizardInformation"));

    // application wizard run -> set status 1

    return iRepository->Set( KCmAppWizardState, 1 ) ;

    }

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

// Gets information about MCs drives

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

//

void CCmSettingsEngine::DriveListL(

    RFs& aFs,

    RPointerArray<CCmDriveInfo>& aDrives ) const

    {

    LOG(_L("[CmSettinsEngine]\t CCmSettingsEngine::DriveListL"));

    TDriveList list;

    TDriveInfo info;

    aFs.DriveList( list );

    TInt drive( KErrNotFound );                                                         

    TInt error = DriveInfo::GetDefaultDrive( DriveInfo::EDefaultMassStorage,

                                             drive );

    TRACE( Print(_L("[CmSettinsEngine]\t GetDefaultDrive error = %d, drive = %d"),

    error, drive ) );

    for( TInt driveNumber = 0 ; driveNumber <= EDriveZ ; driveNumber++ )

        {

        if( list[driveNumber] ) // is drive available

            {

            TUint drvStatus( 0 );

            aFs.Drive( info, driveNumber );

            TRACE( Print(_L("[CmSettinsEngine]\t drivenumber = %d"),

                      driveNumber ) );

            User::LeaveIfError(DriveInfo::GetDriveStatus( aFs,

                                                          driveNumber,

                                                          drvStatus ) );                                                                      

            TRACE( Print(_L("[CmSettinsEngine]\t removable drive = %d"),

                      drvStatus & DriveInfo::EDriveRemovable ) );

            TInt removableStatus = drvStatus & DriveInfo::EDriveRemovable;

            // Check if drive is internal hard disc or memory card

            if( 

                ((!error && driveNumber == drive ) && !removableStatus ) ||

                ( removableStatus && ( info.iType != EMediaNotPresent ) ) )

                {

                TRACE( Print(_L("[CmSettinsEngine]\t info.iType = %d"),

                       info.iType ) );

                TRACE( Print(_L("[CmSettinsEngine]\t info.iDriveAtt = %d"),

                       info.iDriveAtt ) );                       

                HBufC* memoryCardName = NULL;

                CCmDriveInfo* driveInfo = CCmDriveInfo::NewLC();

                TVolumeInfo volInfo;

                aFs.Volume( volInfo, driveNumber );

                TRACE( Print(_L("[CmSettinsEngine]\t volInfo.iName = %S"),

                       &volInfo.iName ) );

                if ( volInfo.iName.Compare( KNullDesC() ) )

                    {

                    memoryCardName = volInfo.iName.AllocLC();

                    driveInfo->SetDriveNameL( *memoryCardName );

                    }

                else

                    {

                    driveInfo->SetDriveNameL( KNullDesC() );

                    }

                // collect drive information

                driveInfo->SetDriveNumber( driveNumber );

                driveInfo->SetDriveType( removableStatus );

                driveInfo->SetDriveSize( volInfo.iSize );

                driveInfo->SetDriveId( volInfo.iUniqueID );

                if ( memoryCardName )

                    {

                    CleanupStack::PopAndDestroy( memoryCardName );

                    }

                CleanupStack::Pop( driveInfo );

                }

            }

        }

    }

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

// Deletes the object

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