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

// INCLUDE FILES
#include <fbs.h>
#include <cvoicemailboxentry.h>

#include "vmbxenginebase.h"
#include "vmbxlogger.h"
#include "vmbxuiutilities.h"
#include "vmbxutilities.h"
#include "vmspshandler.h"
#include "vmbshandler.h"
#include "voicemailboxdefsinternal.h"
#include "vmbxvoipengine.h"

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

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

// ---------------------------------------------------------------------------
// CVmbxVoIpEngine::~CVmbxVoIpEngine
// Destructor.
// ---------------------------------------------------------------------------
//
CVmbxVoIpEngine::~CVmbxVoIpEngine()
    {
    VMBLOGSTRING( "VMBX: CVmbxVoIpEngine::~CVmbxVoIpEngine =>" );
    delete iVmSpsHandler;
    delete iVmBsHandler;
    VMBLOGSTRING( "VMBX: CVmbxVoIpEngine::~CVmbxVoIpEngine <=" );
    }

// ---------------------------------------------------------------------------
// CVmbxVoIpEngine::NewL
// Two-phased constructor.
// ---------------------------------------------------------------------------
//
CVmbxVoIpEngine* CVmbxVoIpEngine::NewL( MVmbxResourceProvider& aProvider)
    {
    VMBLOGSTRING( "VMBX: CVmbxVoIpEngine::NewL =>" );
    if ( !VmbxUtilities::VoIPSupported() )
        {
        User::Leave( KErrNotSupported );
        }

    CVmbxVoIpEngine* self = new( ELeave ) CVmbxVoIpEngine( aProvider );
    CleanupStack::PushL( self );
    self->ConstructL();
    CleanupStack::Pop( self );
    VMBLOGSTRING( "VMBX: CVmbxVoIpEngine::NewL <=" );
    return self;
    }

// ---------------------------------------------------------------------------
// CVmbxVoIpEngine::ConstructL
// Symbian 2nd phase constructor can leave.
// ---------------------------------------------------------------------------
//
void CVmbxVoIpEngine::ConstructL()
    {
    VMBLOGSTRING( "VMBX: CVmbxVoIpEngine::ConstructL =>" );
    if ( VmbxUtilities::VoIPSupported() )
        {
        iVmSpsHandler = CVmSPSHandler::NewL();
        }

    iVmBsHandler = CVmBSHandler::NewL();
    VMBLOGSTRING( "VMBX: CVmbxVoIpEngine::ConstructL <=" );
    }

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

    vmbxEntry->SetVoiceMailboxType( EVmbxVoip );
    vmbxEntry->SetServiceId( iVmbxServiceId );

    HBufC8* brandId = HBufC8::NewLC( KSPMaxDesLength );
    TPtr8 ptr( brandId->Des() );
    BrandIdL( iVmbxServiceId, ptr );
    // set brand id
    result = vmbxEntry->SetBrandId( ptr );
    CleanupStack::PopAndDestroy( brandId );
    if ( KErrNone == result )
        {
        TVmbxServiceInfo serviceInfo;
        serviceInfo.iServiceId = iVmbxServiceId;
        result = GetServiceInfo( serviceInfo );
        if ( KErrNone == result )
            {
            // set voip name
            result = vmbxEntry->SetVmbxName( serviceInfo.iName );
            if ( KErrNone == result )
                {
                // set voip address
                result = vmbxEntry->SetVmbxNumber( serviceInfo.iAddress );
                }
            }
        }
    VMBLOGSTRING2( "VMBX: CVmbxVoIpEngine::GetL: result=%I", result );
    User::LeaveIfError( result );
    CleanupStack::Pop( vmbxEntry );
    aEntry = vmbxEntry;
    vmbxEntry = NULL;
    VMBLOGSTRING( "VMBX: CVmbxVoIpEngine::GetL <=" );
    }

// ---------------------------------------------------------------------------
// CVmbxVoIpEngine::SaveL
// Saves voice mailbox number
// ---------------------------------------------------------------------------
//
void CVmbxVoIpEngine::SaveL( const CVoiceMailboxEntry& /*aEntry*/,
                             TBool /*aShowNotesAllowed*/ )
    {
    VMBLOGSTRING( "VMBX: CVmbxVoIpEngine::SaveL <=>" );
    User::Leave( KErrNotSupported );
    }

// ---------------------------------------------------------------------------
// CVmbxVoIpEngine::SaveProvisionedEntryL
// Saves Provisioned voice mailbox number
// ---------------------------------------------------------------------------
//
void CVmbxVoIpEngine::SaveProvisionedEntryL( 
                                const CVoiceMailboxEntry& /*aEntry*/ )
    {
    VMBLOGSTRING( "VMBX: CVmbxVoIpEngine::SaveProvisionedEntryL <=>" );
    User::Leave( KErrNotSupported );
    }

// ----------------------------------------------------------------------------
//  CVmbxVoIpEngine::CheckConfiguration()
// ----------------------------------------------------------------------------
//
TBool CVmbxVoIpEngine::CheckConfiguration( 
        const TVoiceMailboxParams& aParams, const TInt aFlags )
    {
    VMBLOGSTRING( "VMBX: CVmbxVoIpEngine::CheckConfiguration: =>" );
    TBool result( EFalse );
    result = CVmbxEngineBase::CheckConfiguration(aParams, aFlags);
    VMBLOGSTRING2( "VMBX: CVmbxVoIpEngine::CheckConfiguration: result%I <=",
     result );
    return result;
    }

// ---------------------------------------------------------------------------
// CVmbxVoIpEngine::QueryDefineNumberL
//
// ---------------------------------------------------------------------------
//
void CVmbxVoIpEngine::QueryDefineNumberL( CVoiceMailboxEntry& /*aEntry*/ )
    {
    VMBLOGSTRING( "VMBX: CVmbxVoIpEngine::QueryDefineNumberL <=>" );
    User::Leave( KErrNotSupported );
    }

// ----------------------------------------------------------------------------
// CVmbxEngineBase::QueryChangeNumberL
//
// ----------------------------------------------------------------------------
//
void CVmbxVoIpEngine::QueryChangeNumberL( CVoiceMailboxEntry& /*aEntry*/ )
    {
    VMBLOGSTRING( "VMBX: CVmbxVoIpEngine::QueryChangeNumberL <=>" );
    User::Leave( KErrNotSupported );        
    }

// Commented out because branding is not supported yet.
// ---------------------------------------------------------------------------
// CVmbxVoIpEngine::GetVmbxImageL
// 
// ---------------------------------------------------------------------------
//
/* CGulIcon* CVmbxVoIpEngine::GetVmbxImageL( const TVoiceMailboxParams& aParams )
    {
    VMBLOGSTRING( "VMBX: CVmbxVoIpEngine::GetVmbxImageL =>" );
    CGulIcon* guiIcon( NULL );
    if ( IsVoIPProfilesFound() )
        {
        TBuf8<KSPMaxDesLength> brandId( KNullDesC8 );
        BrandIdL(aParams.iServiceId, brandId );

        CFbsBitmap* brandedBitmap( NULL );
        CFbsBitmap* brandedBitmapMask( NULL );  
        TRAPD( err, GetBrandedIconL( 
                        brandId, brandedBitmap, brandedBitmapMask ) );

        if ( KErrNotFound == err )
            {
            VMBLOGSTRING( "VMBX: CVmbxVoIpEngine::GetVmbxImageL: \
                                                 no found profiles<= " );
            guiIcon = iProvider.VmbxUiUtilities().GetVmbxImageL( aParams );
            }
        else if ( KErrNone == err )
            {
            guiIcon = 
                       CGulIcon::NewL( brandedBitmap, brandedBitmapMask );
            VMBLOGSTRING( "VMBX: CVmbxVoIpEngine::GetVmbxImageL: \
                            found profiles" );
            }
        }
    else
        {
        VMBLOGSTRING( "VMBX: CVmbxVoIpEngine::GetVmbxImageL: use default " );
        guiIcon = iProvider.VmbxUiUtilities().GetVmbxImageL( aParams );
        }
    VMBLOGSTRING( "VMBX: CVmbxVoIpEngine::GetVmbxImageL <=" );
    return guiIcon; 
    } */

// ---------------------------------------------------------------------------
// CVmbxVoIpEngine::IsVoIPProfilesFound
// 
// ---------------------------------------------------------------------------
//
TBool CVmbxVoIpEngine::IsVoIPProfilesFound()
    {
    VMBLOGSTRING( "VMBX: CVmbxVoIpEngine::IsVoIPProfilesFound <=>" );
    return iVmSpsHandler->IsVoIPProfilesFound();
    }

// ---------------------------------------------------------------------------
// CVmbxVoIpEngine::GetServiceIds
// 
// ---------------------------------------------------------------------------
//
void CVmbxVoIpEngine::GetServiceIdsL( RIdArray& aProfileIds )
    {
    VMBLOGSTRING( "VMBX: CVmbxVoIpEngine::GetServiceIds: =>" );
    if ( VmbxUtilities::VoIPSupported() && IsVoIPProfilesFound() )
        {
        iVmSpsHandler->GetServiceIdsL( aProfileIds );
        }
    else
        {
        User::Leave( KErrNotFound );
        }
    VMBLOGSTRING( "VMBX: CVmbxVoIpEngine::GetServiceIds: <=" );
    }

// ---------------------------------------------------------------------------
// CVmbxVoIpEngine::GetBrandedIconL
// 
// ---------------------------------------------------------------------------
//
/* void CVmbxVoIpEngine::GetBrandedIconL( const TDesC8& aBrandingId,
    CFbsBitmap*& aBrandedBitmap, CFbsBitmap*& aBrandedBitmapMask )
    {
    VMBLOGSTRING( "VMBX: CVmbxVoIpEngine::GetBrandedIconL: =>" );

    iVmBsHandler->GetBrandedIconL( 
                aBrandingId, aBrandedBitmap, aBrandedBitmapMask );
    
    VMBLOGSTRING( "VMBX: CVmbxVoIpEngine::GetBrandedIconL: <=" );
    }
 */
// ---------------------------------------------------------------------------
// CVmbxVoIpEngine::BrandIdL
// 
// ---------------------------------------------------------------------------
//
void CVmbxVoIpEngine::BrandIdL( TInt aServiceId, TDes8& aBrandId )
    {
    VMBLOGSTRING( "VMBX: CVmbxVoIpEngine::BrandIdL: =>" );

    if ( VmbxUtilities::VoIPSupported() )
        {
        iVmSpsHandler->BrandIdL( aServiceId, aBrandId );
        }

    VMBLOGSTRING( "VMBX: CVmbxVoIpEngine::BrandIdL: <=" );
    }

// ---------------------------------------------------------------------------
// CVmbxVoIpEngine::GetServiceInfo
// 
// ---------------------------------------------------------------------------
//
TInt CVmbxVoIpEngine::GetServiceInfo( TVmbxServiceInfo& aServiceInfo )
    {
    VMBLOGSTRING( "VMBX: CVmbxVoIpEngine::GetServiceInfo: =>" );
    TInt ret( KErrNotFound );
    if ( VmbxUtilities::VoIPSupported() )
        {
        ret = iVmSpsHandler->GetServiceInfo( aServiceInfo );
        }
    VMBLOGSTRING( "VMBX: CVmbxVoIpEngine::GetServiceInfo: <=" );
    return ret;
    }

// End of file