/*

* Copyright (c) 2005 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:  Central Repository proxy.

*

*/

// INCLUDE FILES

#include    <e32std.h>

#include    <e32def.h>

#include    <e32base.h>

#include    <telinternalcrkeys.h>

#include    <pslninternalcrkeys.h>

#include    <LogsDomainCRKeys.h>

#include    <accessoriescrkeys.h>

#include    <settingsinternalcrkeys.h>

#include    <UiklafInternalCRKeys.h>

#include    <ProfileEngineDomainCRKeys.h>

#include    <DRMHelperServerInternalCRKeys.h>

#include    <btengdomaincrkeys.h> 

#include    <utf.h>

#include    "phoneui.pan"

#include    "cphonecenrepproxy.h"

#include    "mphonecenrepobserver.h"

#include    "cphonecenrepeventhandler.h"

#include    "phoneconstants.h"

#include    "phonelogger.h"

#include    "telprivatecrkeys.h"

#include    "tphonecmdparamappinfo.h"

//CONSTANTS

const TInt KMaxParamLength = 1024;

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

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

// CPhoneCenRepProxy::Instance

// Initializes the singleton object

// (other items were commented in a header).

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

//

EXPORT_C CPhoneCenRepProxy* CPhoneCenRepProxy::Instance()

    {

    CPhoneCenRepProxy* instance = static_cast<CPhoneCenRepProxy*> 

        ( CCoeEnv::Static ( KUidCenRepProxySingleton ) );

    if( !instance )

        {

        TRAPD( err, instance = CPhoneCenRepProxy::NewL() );

        if ( err )

            {

            Panic( EPhoneUtilsCouldNotCreateSingleton );    

            }

        }

    return instance;

    }

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

// CPhoneCenRepProxy::CancelAllNotifies

// Cancel the notification if the singleton still exists.

// (other items were commented in a header).

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

//

EXPORT_C void CPhoneCenRepProxy::CancelAllNotifies( 

    MPhoneCenRepObserver* aObserver )

    {

    CPhoneCenRepProxy* instance = static_cast<CPhoneCenRepProxy*> 

        ( CCoeEnv::Static( KUidCenRepProxySingleton ) );

    // Ignore the call since the singleton has already been destroyed and the

    // notifications removed

    if( instance != NULL )

        {

        instance->CancelAllObserverNotifies( aObserver );

        }

    }

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

// CPhoneCenRepProxy::NewL

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

//

CPhoneCenRepProxy* CPhoneCenRepProxy::NewL()

    {

    CPhoneCenRepProxy* self = 

        new (ELeave) CPhoneCenRepProxy();

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop( self );

    return self;

    }

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

// CPhoneCenRepProxy::~CPhoneCenRepProxy

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

//

EXPORT_C CPhoneCenRepProxy::~CPhoneCenRepProxy()

    {

    // The Cancel should be always called before destroy the object

    CancelAllNotifies();

    delete iCenRepAccessoryEventHandler;

    delete iCenRepNetworkEventHandler;

    delete iCenRepThemesEventHandler;

    delete iCenRepLanguageEventHandler;

    delete iCenRepQwertyEventHandler;

    delete iCenRepKDRMHelperEventHandler;

    delete iObserverArray;

    }

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

// CPhoneCenRepProxy::CPhoneCenRepProxy

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

//

CPhoneCenRepProxy::CPhoneCenRepProxy() :

    CCoeStatic( KUidCenRepProxySingleton, EThread )

    {

    }

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

// CPhoneCenRepProxy::ConstructL

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

//

void CPhoneCenRepProxy::ConstructL()

    {

    iObserverArray = new ( ELeave ) CArrayFixFlat<TCenRepObserverTag>( 

        KPhoneCenRepObserversGranularity );

    iTelephonyVariantReadOnlyValues = KPhoneVariantReadOnlyDefaultValue;

    iPhoneUIVariantReadOnlyValues = KPhoneVariantReadOnlyDefaultValue;

    User::LeaveIfError( GetTelephonyVariantData() );

    User::LeaveIfError( GetPhoneUIVariantData() );

    }

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

// CPhoneCenRepProxy::HandleNotifyL

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

//

void CPhoneCenRepProxy::HandleNotify( 

    const TUid& aUid, 

    const TUint aId )

    {

    TInt index = FindByUidId( aUid, aId, 0 );

    while ( index != KErrNotFound )

        {

        __ASSERT_DEBUG( index < iObserverArray->Count(), 

            Panic( EPhoneUtilsIndexOutOfBounds ) );

        const TCenRepObserverTag& observerTag = iObserverArray->At( index );

        TRAP_IGNORE( observerTag.iObserver->HandleCenRepChangeL( aUid, aId ) );

        index = FindByUidId( aUid, aId, index+1 );

        }

    }

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

// CPhoneCenRepProxy::SetInt

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

//

EXPORT_C TInt CPhoneCenRepProxy::SetInt( 

    const TUid& aUid, 

    const TUint aId,

    const TInt aValue )

    {

    CRepository* repository = NULL;

    TRAPD( err, repository = CRepository::NewL( aUid ) );

    if ( err == KErrNone )

        {

        err = repository->Set( aId, aValue );

        }

    delete repository;

    if ( err != KErrNone )

        {

        __PHONELOG1( 

            EBasic, 

            EPhonePhoneapp, 

            "CPhoneCenRepProxy::SetInt() error: %d", 

            err );

        __ASSERT_DEBUG( EFalse, Panic( EPhoneUtilsInvariant ) );

        }

    return err;

    }

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

// CPhoneCenRepProxy::SetString

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

//

EXPORT_C TInt CPhoneCenRepProxy::SetString( 

    const TUid& aUid, 

    const TUint aId,

    const TDesC& aValue )

    {

    CRepository* repository = NULL;

    TRAPD( err, repository = CRepository::NewL( aUid ) );

    if ( err == KErrNone )

        {

        err = repository->Set( aId, aValue );

        }

    delete repository;

    if ( err != KErrNone )

        {

        __PHONELOG1( 

            EBasic, 

            EPhonePhoneapp, 

            "CPhoneCenRepProxy::SetString() error: %d", 

            err );

        __ASSERT_DEBUG( EFalse, Panic( EPhoneUtilsInvariant ) );

        }

    return err;

    }

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

// CPhoneCenRepProxy::SetReal

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

//

EXPORT_C TInt CPhoneCenRepProxy::SetReal( 

    const TUid& aUid, 

    const TUint aId,

    const TReal aValue )

    {

    CRepository* repository = NULL;

    TRAPD( err, repository = CRepository::NewL( aUid ) );

    if ( err == KErrNone )

        {

        err = repository->Set( aId, aValue );

        }

    delete repository;

    if ( err != KErrNone )

        {

        __PHONELOG1( 

            EBasic, 

            EPhonePhoneapp, 

            "CPhoneCenRepProxy::SetReal() error: %d", 

            err );

        __ASSERT_DEBUG( EFalse, Panic( EPhoneUtilsInvariant ) );

        }

    return err;

    }

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

// CPhoneCenRepProxy::GetInt

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

//

EXPORT_C TInt CPhoneCenRepProxy::GetInt( 

    const TUid& aUid, 

    const TUint aId,

    TInt& aValue ) const

    {

    CRepository* repository = NULL;

    TRAPD( err, repository = CRepository::NewL( aUid ) );

    if ( err == KErrNone )

        {

        err = repository->Get( aId, aValue );

        delete repository;

        }

    if ( err != KErrNone)

        {

        __PHONELOG1( 

            EBasic, 

            EPhonePhoneapp, 

            "CPhoneCenRepProxy::GetInt() error: %d", 

            err );

        __ASSERT_DEBUG( EFalse, Panic( EPhoneUtilsInvariant ) );

        }

    return err;

    }

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

// CPhoneCenRepProxy::GetString

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

//

EXPORT_C TInt CPhoneCenRepProxy::GetString( 

    const TUid& aUid, 

    const TUint aId,

    TDes& aValue ) const

    {

    CRepository* repository = NULL;

    TRAPD( err, repository = CRepository::NewL( aUid ) );

    if ( err == KErrNone )

        {

        err = repository->Get( aId, aValue );

        delete repository;

        }

    if ( err != KErrNone)

        {

        __PHONELOG1( 

            EBasic, 

            EPhonePhoneapp, 

            "CPhoneCenRepProxy::GetString() error: %d", 

            err );

        __ASSERT_DEBUG( EFalse, Panic( EPhoneUtilsInvariant ) );

        }

    return err;

    }

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

// CPhoneCenRepProxy::GetReal

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

//

EXPORT_C TInt CPhoneCenRepProxy::GetReal( 

    const TUid& aUid, 

    const TUint aId,

    TReal& aValue ) const

    {

    CRepository* repository = NULL;

    TRAPD( err, repository = CRepository::NewL( aUid ) );

    if ( err == KErrNone )

        {

        err = repository->Get( aId, aValue );

        delete repository;

        }

    if ( err != KErrNone)

        {

        __PHONELOG1( 

            EBasic, 

            EPhonePhoneapp, 

            "CPhoneCenRepProxy::GetReal() error: %d", 

            err );

        __ASSERT_DEBUG( EFalse, Panic( EPhoneUtilsInvariant ) );

        }

    return err;

    }

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

// CPhoneCenRepProxy::NotifyChangeL

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

//

EXPORT_C void CPhoneCenRepProxy::NotifyChangeL( 

    const TUid& aUid, 

    const TUint aId, 

    MPhoneCenRepObserver* aObserver )

    {

    // Make sure this request hasn't been request by this observer yet

    if ( FindByUidIdObserver( aUid, aId, aObserver ) == KErrNotFound )

        {

        TCenRepObserverTag tag;

        tag.iUid = aUid;

        tag.iId = aId;

        tag.iObserver = aObserver;

        iObserverArray->AppendL( tag );

        }

    }

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

// CPhoneCenRepProxy::CancelNotify

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

//

EXPORT_C void CPhoneCenRepProxy::CancelNotify( 

    MPhoneCenRepObserver* aObserver, 

    const TUint aId )

    {

    TInt index = FindByObserverId( aObserver, aId );

    // This class may be destroyded by CCoeEnv::DestroyEnvironmentStatic() 

    // before CancelNotifys are called.

    if( index == KErrNotFound )

        {

        return;            

        }

    __ASSERT_DEBUG( index < iObserverArray->Count(),

        Panic( EPhoneUtilsIndexOutOfBounds ) );

    TCenRepObserverTag observerTag = iObserverArray->At( index );

    iObserverArray->Delete( index );

    }

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

// CPhoneCenRepProxy::CancelAllObserverNotifies

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

//

void CPhoneCenRepProxy::CancelAllObserverNotifies( 

    MPhoneCenRepObserver* aObserver )

    {

    const TInt count = iObserverArray->Count();

    for ( TInt i = count-1; i >=0; i-- )

        {

        const TCenRepObserverTag& observerTag = iObserverArray->At( i );

        if ( observerTag.iObserver == aObserver )

            {

            iObserverArray->Delete( i );

            }

        }

    }

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

// CPhoneCenRepProxy::CancelAllNotifies

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

//

void CPhoneCenRepProxy::CancelAllNotifies()

    {

    const TInt count = iObserverArray->Count();

    for ( TInt i = count-1; i >=0; i-- )

        {

        iObserverArray->At( i );

        iObserverArray->Delete( i );

        }

    }

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

// CPhoneCenRepProxy::FindByUidId

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

//

TInt CPhoneCenRepProxy::FindByUidId( 

    const TUid& aUid,

    const TUint aId, 

    TInt aFromIndex )

    {

    const TInt count = iObserverArray->Count();

    TInt result = KErrNotFound;

    for ( TInt i = aFromIndex; i < count; i++ )

        {

        const TCenRepObserverTag& observerTag = iObserverArray->At( i );

        if ( observerTag.iUid == aUid  && observerTag.iId == aId ) 

            {

            result = i;

            break;

            }

        }

    return result;

    }

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

// CPhoneCenRepProxy::FindByObserverId

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

//

TInt CPhoneCenRepProxy::FindByObserverId( 

    const MPhoneCenRepObserver* aObserver,

    const TUint aId )

    {

    const TInt count = iObserverArray->Count();

    TInt result = KErrNotFound;

    for ( TInt i = 0; i < count; i++ )

        {

        const TCenRepObserverTag& observerTag = iObserverArray->At( i );

        if ( observerTag.iObserver == aObserver && observerTag.iId == aId ) 

            {

            result = i;

            break;

            }

        }

    return result;

    }

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

// CPhoneCenRepProxy::FindByUidIdObserver

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

//

TInt CPhoneCenRepProxy::FindByUidIdObserver( 

    const TUid& aUid, 

    const TUint aId, 

    MPhoneCenRepObserver* aObserver )

    {

    TInt pos = FindByUidId( aUid, aId, 0 );

    TInt result = KErrNotFound;

    while ( pos != KErrNotFound )

        {

        __ASSERT_DEBUG( pos < iObserverArray->Count(), 

            Panic( EPhoneUtilsIndexOutOfBounds ) );

        const TCenRepObserverTag& observerTag = iObserverArray->At( pos );

        if ( observerTag.iObserver == aObserver )

            {

            result = pos;

            break;

            }

        pos++;

        pos = FindByUidId( aUid, aId, pos );

        }

    return result;

    }   

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

// CPhoneCenRepProxy::IsTelephonyFeatureSupported

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

//

EXPORT_C TBool CPhoneCenRepProxy::IsTelephonyFeatureSupported( 

    const TInt aFeatureId )

    {

    return ( aFeatureId & iTelephonyVariantReadOnlyValues );

    }

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

// CPhoneCenRepProxy::GetTelephonyVariantData

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

//

TInt CPhoneCenRepProxy::GetTelephonyVariantData()

    {

    TInt err = KErrNone;

    // Variation data should be unchangable during run-time, 

    // therefore, if once succesfully read, later reads are

    // not allowed.

    if( iTelephonyVariantReadOnlyValues == KPhoneVariantReadOnlyDefaultValue )

        {

        err = GetInt( 

            KCRUidTelVariation, 

            KTelVariationFlags, 

            iTelephonyVariantReadOnlyValues );

        }

    return err;

    }