/*
* 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