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


// INCLUDE FILES
#include <cvoicemailboxentry.h>

#include "vmbxenginebase.h"
#include "vmbxutilities.h"

#include "vmbxlogger.h"
#include "vmbxcenrephandler.h"
#include "vmbxsimhandler.h"
#include "vmbxuiutilities.h"

#include "vmbxcsvoiceengine.h"

// CONSTANTS
_LIT (KVmbxIllegalSimCharacter, "w");

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

// ----------------------------------------------------------------------------
// CVmbxCsVoiceEngine::CVmbxCsVoiceEngine
// C++ default constructor can NOT contain any code, that
// might leave.
// ----------------------------------------------------------------------------
//
CVmbxCsVoiceEngine::CVmbxCsVoiceEngine( MVmbxResourceProvider& aProvider )
                                : CVmbxEngineBase( aProvider )
    {
    VMBLOGSTRING( "VMBX: CVmbxCsVoiceEngine::CVmbxCsVoiceEngine =>" );
    VMBLOGSTRING( "VMBX: CVmbxCsVoiceEngine::CVmbxCsVoiceEngine <=" );
    }

// ----------------------------------------------------------------------------
// CVmbxCsVoiceEngine::~CVmbxCsVoiceEngine
// Destructor.
// ----------------------------------------------------------------------------
//
CVmbxCsVoiceEngine::~CVmbxCsVoiceEngine()
    {
    VMBLOGSTRING( "VMBX: CVmbxCsVoiceEngine::~CVmbxCsVoiceEngine =>" );
    delete iSimHandler;
    VMBLOGSTRING( "VMBX: CVmbxCsVoiceEngine::~CVmbxCsVoiceEngine <=" );
    }

// ----------------------------------------------------------------------------
// CVmbxCsVoiceEngine::NewL
// Two-phased constructor.
// ----------------------------------------------------------------------------
//
CVmbxCsVoiceEngine* CVmbxCsVoiceEngine::NewL( MVmbxResourceProvider& aProvider )
    {
    VMBLOGSTRING( "VMBX: CVmbxCsVoiceEngine::NewL =>" );
    CVmbxCsVoiceEngine* self = 
            new( ELeave ) CVmbxCsVoiceEngine( aProvider );
    CleanupStack::PushL( self );
    self->ConstructL();
    CleanupStack::Pop( self );
    VMBLOGSTRING( "VMBX: CVmbxCsVoiceEngine::NewL <=" );
    return self;
    }

// ----------------------------------------------------------------------------
// CVmbxCsVoiceEngine::ConstructL
// Symbian 2nd phase constructor can leave.
// ----------------------------------------------------------------------------
//
void CVmbxCsVoiceEngine::ConstructL()
    {
    VMBLOGSTRING( "VMBX: CVmbxCsVoiceEngine::ConstructL =>" );
    TVmbxMemoryLocation storeType( EVmbxPhoneMemory );
    storeType = iProvider.VmbxCenRepHandler().StoreType();
    if ( EVmbxSimMemory == storeType )
        {
        // create SimHandler
        TRAPD( err, iSimHandler = CVmbxSimHandler::NewL() );
        // for avoid warning for compiling
        err = err;
        VMBLOGSTRING2( "VMBX: CVmbxCsVoiceEngine::ConstructL:\
                     Create SimHandler %I" , err);
        }
    VMBLOGSTRING( "VMBX: CVmbxCsVoiceEngine::ConstructL <=" );
    }

// ----------------------------------------------------------------------------
// CVmbxCsVoiceEngine::GetL
// Gets voice mailbox number
// ----------------------------------------------------------------------------
//
void CVmbxCsVoiceEngine::GetL( CVoiceMailboxEntry*& aEntry )
    {
    VMBLOGSTRING( "VMBX: CVmbxCsVoiceEngine::GetL =>" );
    TInt result( KErrNotFound );

    CVoiceMailboxEntry* vmbxEntry = CVoiceMailboxEntry::NewLC();
    // get als line info
    vmbxEntry->SetVmbxAlsLineType( VmbxUtilities::AlsLine() );

    vmbxEntry->SetVoiceMailboxType( EVmbxVoice );
    vmbxEntry->SetServiceId( KVmbxServiceVoice );
    // get store type from CenRep 
    TVmbxMemoryLocation storeType = iProvider.VmbxCenRepHandler().StoreType();

    if ( EVmbxSimMemory ==  storeType && iSimHandler )
        {
        // read from sim if it is available and active
        VMBLOGSTRING( "VMBX: CVmbxCsVoiceEngine::GetL:\
                        SIM available and active");
        TRAP( result, iSimHandler->GetL( *vmbxEntry ) );

        VMBLOGSTRING2( "VMBX: CVmbxCsVoiceEngine::GetL :Sim res=%d", result );
        TPtrC vmbxNumber( KNullDesC );
        vmbxEntry->GetVmbxNumber( vmbxNumber );

        // if no number from sim(both MBDN file and VMBX file)
        if ( KErrNone != result || !vmbxNumber.Length() )
            {
            VMBLOGSTRING( "VMBX: CVmbxCsVoiceEngine::GetL:\
                       no number from sim, both MBDN file and VMBX file");
            // Get CS number from phone memory
            result = iProvider.VmbxCenRepHandler().GetVmbxNumber( *vmbxEntry );
            vmbxEntry->SetUsingMemoryLocation( EVmbxPhoneMemory );
            }
        else
            {
            vmbxEntry->SetUsingMemoryLocation( EVmbxSimMemory );
            }
        }
    // EVmbxPhoneMemory or sim not available
    else
        {
        VMBLOGSTRING( "VMBX: CVmbxCsVoiceEngine::GetL:\
                        EVmbxPhoneMemory or sim not available " );
        // Get CS number from phone memory
        result = iProvider.VmbxCenRepHandler().GetVmbxNumber( *vmbxEntry );
        vmbxEntry->SetUsingMemoryLocation( EVmbxPhoneMemory );
        }
    VMBLOGSTRING2( "VMBX: CVmbxCsVoiceEngine::GetL: res=%d", result );

    User::LeaveIfError( result );
    CleanupStack::Pop( vmbxEntry );
    aEntry = vmbxEntry;
    vmbxEntry = NULL;
    VMBLOGSTRING( "VMBX: CVmbxCsVoiceEngine::GetL <=" );
    }

// ----------------------------------------------------------------------------
// CVmbxCsVoiceEngine::SaveL
// Saves voice mailbox number
// ----------------------------------------------------------------------------
//
void CVmbxCsVoiceEngine::SaveL( const CVoiceMailboxEntry& aEntry )
    {
    VMBLOGSTRING( "VMBX: CVmbxCsVoiceEngine::SaveL =>" );

    TPtrC vmbxNumber( KNullDesC );
    aEntry.GetVmbxNumber( vmbxNumber );
    
    if ( vmbxNumber.Length() 
         && ( !VmbxUtilities::IsValidPhoneNumber( vmbxNumber )
         || VmbxUtilities::IsEmergencyNumber( vmbxNumber ) ) )
        {
        VMBLOGSTRING( "VMBX: CVmbxCsVoiceEngine::SaveL: number invalid <=" );
        User::Leave( KErrArgument );
        }

    TVoiceMailboxParams params;
    if ( IsWritable( params ) )
        {
        TVmbxMemoryLocation storeType = 
                        iProvider.VmbxCenRepHandler().StoreType();
        VMBLOGSTRING2( "VMBX: CVmbxCsVoiceEngine::SaveL: storeType=%I",
                        storeType );  
        if ( EVmbxSimMemory == storeType && iSimHandler )
            {
            // Save to sim
            SaveEntryToSimL( aEntry );
            }
        else
            {
            // Save to cenrep
            SaveEntryToPhoneL( aEntry );
            }     
        }
    else
        {
        // sim files not exist, its may need by forcing save, eg, OMA.
        if ( !iSimHandler )
            {
            SaveEntryToPhoneL( aEntry );
            VMBLOGSTRING( "VMBX: CVmbxCsVoiceEngine::SaveL: \
                            sim files not exist then save to phone" );
            }
        else
            {
             VMBLOGSTRING( "VMBX: CVmbxCsVoiceEngine::SaveL: \
                                sim files unwritable<=" );
            User::Leave( KErrNotSupported );
            }
        }

    VMBLOGSTRING( "VMBX: CVmbxCsVoiceEngine::SaveL <=" );
    }

// ----------------------------------------------------------------------------
// CVmbxCsVoiceEngine::SaveProvisionedEntryL
// Saves Provisioned voice mailbox number
// ----------------------------------------------------------------------------
//
void CVmbxCsVoiceEngine::SaveProvisionedEntryL( 
                        const CVoiceMailboxEntry& aEntry )
    {
    VMBLOGSTRING( "VMBX: CVmbxCsVoiceEngine::SaveProvisionedEntryL =>" );
    SaveL( aEntry );
    VMBLOGSTRING( "VMBX: CVmbxCsVoiceEngine::SaveProvisionedEntryL <=" );
    }

// ---------------------------------------------------------------------------
// CVmbxCsVoiceEngine::CheckConfiguration
// 
// ---------------------------------------------------------------------------
//
TBool CVmbxCsVoiceEngine::CheckConfiguration( const TVoiceMailboxParams& aParams,
                             const TInt aFlags )
    {
    VMBLOGSTRING( "VMBX: CVmbxCsVoiceEngine::CheckConfiguration =>" );
    TBool configuration( EFalse );
    // check thr property whether allow user to edit number 
    if ( EVmbxChangeNbrAllowedOnUi & aFlags )
        {
        configuration = iProvider.VmbxCenRepHandler().IsAllowedUserEdit();
        if ( configuration )
            {
            configuration = IsWritable( aParams );
            }
        }
    else
        {
        configuration = CVmbxEngineBase::CheckConfiguration(aParams, aFlags);
        }
    VMBLOGSTRING2( "VMBX: CVmbxCsVoiceEngine::CheckConfiguration: conf%I <=",
                 configuration );
    return configuration;
    }

// ----------------------------------------------------------------------------
// CVmbxCsVoiceEngine::SaveEntryToPhone
// Saves number to storage that user selects from the offered list
// ----------------------------------------------------------------------------
//
void CVmbxCsVoiceEngine::SaveEntryToPhoneL( const CVoiceMailboxEntry& aEntry )
    {
    VMBLOGSTRING( "VMBX: CVmbxCsVoiceEngine::SaveEntryToPhoneL: =>" );
    TInt result( KErrArgument );

    result = iProvider.VmbxCenRepHandler().Save( aEntry );

    if ( KErrNone == result )
        {
        iProvider.VmbxUiUtilities().ShowInformationdNoteL( ESavedToPhoneMemory );
        }
    VMBLOGSTRING2( "VMBX: CVmbxCsVoiceEngine::SaveEntryToPhoneL: result=%I <=",
                             result );
    User::LeaveIfError( result );
    }

// ----------------------------------------------------------------------------
// CVmbxCsVoiceEngine::SaveEntryToSim
// For saving to place that user selects
// ----------------------------------------------------------------------------
//
void CVmbxCsVoiceEngine::SaveEntryToSimL( const CVoiceMailboxEntry& aEntry )
    {
    VMBLOGSTRING( "VMBX: CVmbxCsVoiceEngine::SaveEntryToSimL: =>" );
    TInt result( KErrGeneral );

    // number containing "w"-character is not allowed to save to sim
    TPtrC ptrNumber( KNullDesC );
    TInt numError = aEntry.GetVmbxNumber( ptrNumber );
    if ( KErrNotFound != ptrNumber.Find( KVmbxIllegalSimCharacter ) )
        {
        result = KErrArgument;
        }

    if ( iSimHandler )
        {
        result = iSimHandler->Save( aEntry );
       if ( KErrNone == result )
            {
            iProvider.VmbxUiUtilities().ShowInformationdNoteL( ESavedToSimMemory );
            }
        }

    VMBLOGSTRING2( "VMBX: CVmbxCsVoiceEngine::\
                    SaveEntryToSimL: result=%I <=", result );

    User::LeaveIfError( result );
    }

// ----------------------------------------------------------------------------
// CVmbxCsVoiceEngine::IsSimWritable
// ETrue if Sim is allowed to be writable
// ----------------------------------------------------------------------------
TBool CVmbxCsVoiceEngine::IsSimWritable()
    {
    VMBLOGSTRING( "VMBX: CVmbxCsVoiceEngine::IsSimWritable: =>" );
    TBool result( EFalse );
    if ( !( iProvider.VmbxCenRepHandler().IsSimReadOnly() ) 
        && iSimHandler && iSimHandler->IsWritable() )
        {
        result = ETrue;
        }
    VMBLOGSTRING2( "VMBX: CVmbxCsVoiceEngine::IsSimWritable:\
             result=%I <=", result );
    return result;
    }

// ----------------------------------------------------------------------------
// CVmbxCsVoiceEngine::IsWritable
// ETrue if Sim is allowed to be writable
// ----------------------------------------------------------------------------
TBool CVmbxCsVoiceEngine::IsWritable( const TVoiceMailboxParams& /*aParams*/ )
    {
    VMBLOGSTRING( "VMBX: CVmbxCsVoiceEngine::IsWritable =>" );
    TBool result( EFalse );
    TVmbxMemoryLocation storeType = 
                        iProvider.VmbxCenRepHandler().StoreType();

    if ( EVmbxPhoneMemory == storeType )
        {
        result = ETrue;
        }
    else
        {
        if ( iSimHandler )
            {
            #ifdef __WINS__
                result = ETrue;
            #else
                result = IsSimWritable();
            #endif
            }
        else
            {
            VMBLOGSTRING( "VMBX: CVmbxCsVoiceEngine::IsWritable: \
            sim files not exist then use phone memory" );
            result = ETrue;
            }
        }
    VMBLOGSTRING2( "VMBX: CVmbxCsVoiceEngine::IsWritable:\
             result=%I <=", result );
    return result;
    }

// End of file