/*

* Copyright (c) 2009-2010 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:  Implementation of the CVmbxCenRepHandler class

*

*/

// INCLUDE FILES

#include <centralrepository.h>

#include <cvoicemailboxentry.h>

#include "voicemailboxdomaincrkeys.h"

#include "voicemailboxprivatecrkeys.h"

#include "vmbxlogger.h"

#include "vmbxcenrephandler.h"

// CONSTANTS

const TUint32 KUnknownCenRepKey( 0xffffffff );

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

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

// CVmbxCenRepHandler::CVmbxCenRepHandler

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

// might leave.

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

//

CVmbxCenRepHandler::CVmbxCenRepHandler()

    {

    VMBLOGSTRING( "VMBX: CVmbxCenRepHandler::CVmbxCenRepHandler <=>" );

    }

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

// CVmbxCenRepHandler::ConstructL

// Symbian 2nd phase constructor can leave.

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

//

void CVmbxCenRepHandler::ConstructL()

    {

    VMBLOGSTRING( "VMBX: CVmbxCenRepHandler::ConstructL =>" );

    iCRSession = CRepository::NewL( KCRUidVoiceMailbox );

    VMBLOGSTRING( "VMBX: CVmbxCenRepHandler::ConstructL <=" );

    }

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

// CVmbxCenRepHandler::NewL

// Two-phased constructor.

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

//

CVmbxCenRepHandler* CVmbxCenRepHandler::NewL()

    {

    VMBLOGSTRING( "VMBX: CVmbxCenRepHandler::NewL =>" );

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

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop( self );

    VMBLOGSTRING( "VMBX: CVmbxCenRepHandler::NewL <=" );

    return self;

    }

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

// CVmbxCenRepHandler::~CVmbxCenRepHandler

// Destructor

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

//

CVmbxCenRepHandler::~CVmbxCenRepHandler()

    {

    VMBLOGSTRING( "VMBX: CVmbxCenRepHandler::~CVmbxCenRepHandler =>" );

    delete iCRSession;

    VMBLOGSTRING( "VMBX: CVmbxCenRepHandler::~CVmbxCenRepHandler <=" );

    }

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

// CVmbxCenRepHandler::GetVmbxNumber

// Get saved entry number

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

//

TInt CVmbxCenRepHandler::GetVmbxNumber( CVoiceMailboxEntry& aEntry )

    {

    VMBLOGSTRING( "VMBX: CVmbxCenRepHandler::GetVmbxNumber =>" );

    TInt result( KErrNotFound );

    // get right cenrep key

    TUint32 cenRepKey = ResolveKeyByEntry( aEntry );

    if ( KUnknownCenRepKey != cenRepKey )

        {

        HBufC* cenRepEntry = HBufC::New( KVmbxMaxNumberLength );

        TPtr ptr( cenRepEntry->Des() );

        VMBLOGSTRING( "VMBX: CVmbxCenRepHandler::GetVmbxNumber: CenRep Get" );

        result = iCRSession->Get( cenRepKey, ptr );

        // get cenrep value

        if ( KErrNone == result )

            {

            if ( ptr.Length() )

                {

                result = aEntry.SetVmbxNumber( ptr );

                VMBLOGSTRING( "VMBX: CVmbxCenRepHandler::GetVmbxNumber:\

                 Set Entry" ); 

                }

            else

                {

                result = KErrNotFound;

                }

            }

        delete cenRepEntry;

        cenRepEntry = NULL;

        }

    VMBLOGSTRING2( "VMBX: CVmbxCenRepHandler::GetVmbxNumber: result%d <=",

                                 result );

    return result;

    }

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

// CVmbxCenRepHandler::Save

// Saves the mailbox number

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

//

TInt CVmbxCenRepHandler::Save( const CVoiceMailboxEntry& aEntry )

    {

    VMBLOGSTRING( "VMBX: CVmbxCenRepHandler::Save =>" );

    TInt result( KErrNone );

    // get right cenrep key

    TUint32 cenRepKey = ResolveKeyByEntry( aEntry );

    if ( KUnknownCenRepKey != cenRepKey )

        {

        // set cenrep value

        TPtrC vmbxNumber( KNullDesC );

        aEntry.GetVmbxNumber( vmbxNumber );

        result = iCRSession->Set( cenRepKey, vmbxNumber );

        }

    VMBLOGSTRING2( "VMBX: CVmbxCenRepHandler::Save result=%d <=", result );

    return result;

    }

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

// CVmbxCenRepHandler::ResolveKeyByEntry

// Resolve CenRep key by entry

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

//

TUint32 CVmbxCenRepHandler::ResolveKeyByEntry(

                                       const CVoiceMailboxEntry& aEntry  )

    {

    VMBLOGSTRING( "VMBX: CVmbxCenRepHandler::ResolveKeyByEntry =>" );

    TVmbxAlsLineType alsLine = aEntry.VmbxAlsLineType();

    TVmbxType entryType = aEntry.VoiceMailboxType();

    TUint32 cenRepKey( KUnknownCenRepKey );

    switch ( entryType )

        {

        // Voice mailbox

        case EVmbxVoice:

            {

            cenRepKey = VoiceCenRepKey( alsLine );

            break;

            }

        // Video mailbox

        case EVmbxVideo:

            {

            cenRepKey = VideoCenRepKey( alsLine );

            break;

            }

        default:

            break;

        }

    VMBLOGSTRING( "VMBX: CVmbxCenRepHandler::ResolveKeyByEntry <=" );

    return cenRepKey;

    }

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

// CVmbxCenRepHandler::VoiceCenRepKey

// Voice mailbox cenntral repository key value

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

//

TUint32 CVmbxCenRepHandler::VoiceCenRepKey(

                                       const TVmbxAlsLineType& aLine )

    {

    VMBLOGSTRING( "VMBX: CVmbxCenRepHandler::VoiceCenRepKey =>" );

    TUint32 cenRepKey( KUnknownCenRepKey );

    if ( EVmbxAlsLine2 == aLine )

        {

        cenRepKey = KVmbxNumberLineAlternate;

        VMBLOGSTRING( "VMBX: CVmbxCenRepHandler::VoiceCenRepKey:Line2" );

        }

    else

        {

        cenRepKey = KVmbxNumberLinePrimary;

        VMBLOGSTRING( "VMBX: CVmbxCenRepHandler::VoiceCenRepKey:Line1" );

        }

    VMBLOGSTRING( "VMBX: CVmbxCenRepHandler::VoiceCenRepKey <=" );

    return cenRepKey;

    }

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

// CVmbxCenRepHandler::VideoCenRepKey

// Video mailbox cenntral repository key value

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

//

TUint32 CVmbxCenRepHandler::VideoCenRepKey(

                                       const TVmbxAlsLineType& aLine )

    {

    VMBLOGSTRING( "VMBX: CVmbxCenRepHandler::VideoCenRepKey =>" );

    TUint32 cenRepKey( KUnknownCenRepKey );

    VMBLOGSTRING2( "VMBX: CVmbxCenRepHandler::VideoCenRepKey: aLine = %d",

         aLine );

    if ( EVmbxAlsLine2 == aLine )

        {

        cenRepKey = KVmbxVideoNmbrLineAlternate;

        VMBLOGSTRING( "VMBX: CVmbxCenRepHandler::VideoCenRepKey:Line2" );

        }

    else

        {

        cenRepKey = KVmbxVideoNmbrLinePrimary;

        VMBLOGSTRING( "VMBX: CVmbxCenRepHandler::VideoCenRepKey:Line1" );

        }

    VMBLOGSTRING( "VMBX: CVmbxCenRepHandler::VideoCenRepKey <=" );

    return cenRepKey;

    }

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

// CVmbxCenRepHandler::StoreType

// Fetches active store type

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

//

TVmbxMemoryLocation CVmbxCenRepHandler::StoreType()

    {

    VMBLOGSTRING( "VMBX: CVmbxCenRepHandler::StoreType =>" );

    TVmbxMemoryLocation memoryLocation( EVmbxPhoneMemory );

    TInt location;

    TInt result = iCRSession->Get( KVmbxUsesSimMemory, location );

    VMBLOGSTRING2( "VMBX: CVmbxCenRepHandler::StoreType: result = %d",

             result );

    VMBLOGSTRING2( "VMBX: CVmbxCenRepHandler::StoreType: location = %d<=",

             location );

    if ( KErrNone == result && EVmbxSimMemory == location )

        {

        memoryLocation = EVmbxSimMemory;

        }

#ifdef __WINS__

    memoryLocation = EVmbxPhoneMemory;

#endif

    VMBLOGSTRING2( "VMBX: CVmbxCenRepHandler::StoreType: memory = %d<=",

             memoryLocation );

    return memoryLocation;

    }

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

// CVmbxCenRepHandler::VideoSupported

// Returns ETrue if supported

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

//

TBool CVmbxCenRepHandler::VideoSupported()

    {

    VMBLOGSTRING( "VMBX: CVmbxCenRepHandler::VideoSupported =>" );

    TBool supported( EFalse);

    TInt res = iCRSession->Get( KVmbxVideoMbxSupport, supported );

    if ( KErrNone != res )

        {

        supported = EFalse;

        }

    VMBLOGSTRING2( "VMBX: CVmbxCenRepHandler::VideoSupported: result %d",

         supported );

    VMBLOGSTRING( "VMBX: CVmbxCenRepHandler::VideoSupported <=" );

    return supported;

    }

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

// CVmbxCenRepHandler::IsSimReadOnly

// ETrue if CenRep setting Sim read only

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

//

TBool CVmbxCenRepHandler::IsSimReadOnly()

    {

    VMBLOGSTRING( "VMBX: CVmbxCenRepHandler::IsSimReadOnly =>" );

    TBool result( EFalse );

    TInt  res = iCRSession->Get( KVmbxNoSimWriting, result );

    if ( KErrNone != res )

        {

        result = EFalse;

        }

    VMBLOGSTRING2( "VMBX: CVmbxCenRepHandler::IsSimReadOnly: result %I <=",

         result );

    return result;

    }

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

// CVmbxCenRepHandler::IsAllowedUserEdit

// ETrue if number Allowed to edit

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

//

TBool CVmbxCenRepHandler::IsAllowedUserEdit()

    {

    VMBLOGSTRING( "VMBX: CVmbxCenRepHandler::IsAllowedUserEdit =>" );

    TBool result( EFalse );

    TInt temp( 0 );

    TInt  res = iCRSession->Get( KVmbxUiCaps, temp );

    VMBLOGSTRING2( "VMBX: CVmbxCenRepHandler::IsAllowedUserEdit: res %d",

         res );

    VMBLOGSTRING2( "VMBX: CVmbxCenRepHandler::IsAllowedUserEdit: temp %d",

         temp );

    if ( ( KErrNone == res ) && !( KVmbxUiUserEditNotAllowed & temp ) )

        {

        result = ETrue;

        }

    VMBLOGSTRING2( "VMBX: CVmbxCenRepHandler::IsAllowedUserEdit: result %d <=",

         result );

    return result;

    }

// End of file