/*
* Copyright (c) 2007-2009 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 CVmSPSHandler class.
*
*/

// INCLUDE FILES
#include <spsettings.h>
#include <spentry.h>
#include <spproperty.h>
#include <spnotifychange.h>
#include <featmgr.h>
#include <vmnumber.h>
#include "vmspshandler.h"
#include "vmblogger.h"

// EXTERNAL DATA STRUCTURES
// None

// EXTERNAL FUNCTION PROTOTYPES
// None

// CONSTANTS
/**  Maximum length of descriptor data */
const TInt KVmbxMaxDesLength = 512;

// MACROS
// None

// LOCAL CONSTANTS AND MACROS
// None

// MODULE DATA STRUCTURES
// None

// LOCAL FUNCTION PROTOTYPES
// None

// FORWARD DECLARATIONS
// None

// ============================= LOCAL FUNCTIONS =============================

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

// ---------------------------------------------------------------------------
// CVmSPSHandler::CVmSPSHandler
// C++ default constructor can NOT contain any code, that might leave.
// ---------------------------------------------------------------------------
//
CVmSPSHandler::CVmSPSHandler()
    {
    // No implementation required
    }

// ---------------------------------------------------------------------------
// CVmSPSHandler::ConstructL
// Symbian 2nd phase constructor can leave.
// ---------------------------------------------------------------------------
//
void CVmSPSHandler::ConstructL()
    {
    iSettings = CSPSettings::NewL();
    iSpsSettingsVoipUtils = CSPSettingsVoIPUtils::NewL();

    iNotifier = CSPNotifyChange::NewL( *this );

    // Subscribe to service change notifies
    // Empty array so that new services will be notified also
    RIdArray array;
    CleanupClosePushL( array );
    //iNotifier->NotifyChangeL( iServiceIds );
    iNotifier->NotifyChangeL( array );
    CleanupStack::PopAndDestroy( &array );
    }

// ---------------------------------------------------------------------------
// CVmSPSHandler::NewL
// Two-phased constructor.
// ---------------------------------------------------------------------------
//
CVmSPSHandler* CVmSPSHandler::NewL( )
    {
    CVmSPSHandler* self = CVmSPSHandler::NewLC();
    CleanupStack::Pop( self );
    return self;
    }

// ---------------------------------------------------------------------------
// CVmSPSHandler::NewLC
// Two-phased constructor.
// ---------------------------------------------------------------------------
//
CVmSPSHandler* CVmSPSHandler::NewLC()
    {
    CVmSPSHandler* self = new (ELeave) CVmSPSHandler();
    CleanupStack::PushL( self );
    self->ConstructL();
    return self;
    }

// Destructor
CVmSPSHandler::~CVmSPSHandler()
    {
    iObserver = NULL;

    if ( iNotifier )
        {
        iNotifier->Cancel();
        delete iNotifier;
        }

    delete iSettings;

    delete iSpsSettingsVoipUtils;
    }

// ---------------------------------------------------------------------------
// CVmSPSHandler::GetServiceIdsL
// (other items were commented in a header).
// ---------------------------------------------------------------------------
//
void CVmSPSHandler::GetServiceIdsL( RArray<TUint>& aServiceIds ) const
    {
    RArray<TUint> serviceIds;
    CleanupClosePushL( serviceIds );
    // Get all service Ids and..
    iSettings->FindServiceIdsL( serviceIds );
    // ..remove service if VMBX is not defined or if VMBX address is empty
    for ( TInt i( 0 ); i <  serviceIds.Count(); i++ )
        {
        if ( IsVbmxSupportedL( serviceIds[ i ] ) )
            {
            aServiceIds.Append( serviceIds[ i ] );
            }
        }

    VMBLOGSTRING2( "VMBX: found %d IP mailbox services", aServiceIds.Count() );
    
    CleanupStack::PopAndDestroy( &serviceIds );
    }

// ---------------------------------------------------------------------------
// CVmSPSHandler::IsVbmxSupportedL
// (other items were commented in a header).
// ---------------------------------------------------------------------------
//
TBool CVmSPSHandler::IsVbmxSupportedL( TUint32 aServiceId ) const
    {
    TBool supported( EFalse );

    // Get entry
    CSPEntry* entry = CSPEntry::NewLC();
    iSettings->FindEntryL( aServiceId, *entry );

    // Get all service properties a.k.a subservices
    RPropertyArray properties;
    properties = entry->GetAllProperties();

    TServicePropertyName propertyName;

    for ( TInt i( 0 ); i < properties.Count() && !supported; i++ )
        {
        propertyName = properties[ i ]->GetName();

        supported = propertyName == EPropertyVMBXSubServicePluginId;

        if ( supported )
            {
            TVmbxServiceInfo serviceInfo;
            TRAPD( found, GetVmAddressL( aServiceId, serviceInfo.iAddress ) );

            supported = KErrNotFound != found;
            }
        }

    CleanupStack::PopAndDestroy( entry );

    VMBLOGSTRING2( "VMBX: CVmSPSHandler::IsVbmxSupportedL: %d", supported );
    return supported;
    }

// ---------------------------------------------------------------------------
// CVmSPSHandler::GetServiceInfo
// (other items were commented in a header).
// ---------------------------------------------------------------------------
TInt CVmSPSHandler::GetServiceInfo( TVmbxServiceInfo& aServiceInfo ) const
    {
    VMBLOGSTRING( "VMBX: CVmSPSHandler::GetServiceInfo: =>" );
    TInt ret( KErrNone );

    TRAP( ret,
        {
        GetServiceNameL( aServiceInfo.iServiceId, aServiceInfo.iName );

        GetVmAddressL( aServiceInfo.iServiceId, aServiceInfo.iAddress );

        TInt snap( 0 );
        GetSNAPIdL( aServiceInfo.iServiceId, snap );
        aServiceInfo.iSnapId = static_cast<TUint32> ( snap );
        } );

    VMBLOGSTRING( "VMBX: CVmSPSHandler::GetServiceInfo: <=" );
    return ret;
    }

// ---------------------------------------------------------------------------
// CVmSPSHandler::GetVmAddressL
// (other items were commented in a header).
// ---------------------------------------------------------------------------
//
void CVmSPSHandler::GetVmAddressL( const TUint32 aServiceId,
    TDes& aAddress ) const
    {
    VMBLOGSTRING( "VMBX: CVmSPSHandler::GetVmAddressL: =>" );
    RBuf buffer;
    CleanupClosePushL( buffer );
    buffer.ReAllocL( KVmbxMaxDesLength );

    CSPEntry* entry = CSPEntry::NewLC();
    const CSPProperty* property = NULL;

    iSettings->FindEntryL( aServiceId, *entry );

    // Find correct subservice
    User::LeaveIfError(
        entry->GetProperty( property, ESubPropertyVMBXListenAddress ) );

    property->GetValue( buffer );
    buffer.Length() > aAddress.MaxLength() ?
        User::Leave( KErrOverflow ) : aAddress.Copy( buffer );

    CleanupStack::PopAndDestroy( entry );
    CleanupStack::PopAndDestroy( &buffer );

    VMBLOGSTRING( "VMBX: CVmSPSHandler::GetVmAddressL: <=" );
    }

// ---------------------------------------------------------------------------
// CVmSPSHandler::GetServiceNameL
// (other items were commented in a header).
// ---------------------------------------------------------------------------
//
void CVmSPSHandler::GetServiceNameL( const TUint32 aServiceId,
    TDes& aName ) const
    {
    VMBLOGSTRING( "VMBX: CVmSPSHandler::GetServiceNameL: =>" );
    RBuf buffer;
    CleanupClosePushL( buffer );
    buffer.ReAllocL( KVmbxMaxDesLength );

    // Get entry
    CSPEntry* entry = CSPEntry::NewLC();

    iSettings->FindEntryL( aServiceId, *entry );
    VMBLOGSTRING( "VMBX: CVmSPSHandler::GetServiceNameL: 1" );
    // Read service id and service name
    buffer.Copy( entry->GetServiceName() );
    VMBLOGSTRING( "VMBX: CVmSPSHandler::GetServiceNameL: 2" );
    buffer.Length() > aName.MaxLength() ?
        User::Leave( KErrOverflow ) : aName.Copy( buffer );

    CleanupStack::PopAndDestroy( entry );
    CleanupStack::PopAndDestroy( &buffer );

    VMBLOGSTRING( "VMBX: CVmSPSHandler::GetServiceNameL: <=" );
    }

// ---------------------------------------------------------------------------
// CVmSPSHandler::GetSNAPIdL
// (other items were commented in a header).
// ---------------------------------------------------------------------------
//
void CVmSPSHandler::GetSNAPIdL( TUint32 aServiceId, TInt& aSNAPId ) const
    {
    VMBLOGSTRING( "VMBX: CVmSPSHandler::GetSNAPIdL: =>" );

    CSPEntry* entry = CSPEntry::NewLC();
    const CSPProperty* property = NULL;

    iSettings->FindEntryL( aServiceId, *entry );

    // Find correct subservice
    TInt error(
        entry->GetProperty( property, ESubPropertyVMBXPreferredSNAPId ) );

    if ( KErrNotFound != error )
        {
        property->GetValue( aSNAPId );
        }

    CleanupStack::PopAndDestroy( entry );

    VMBLOGSTRING( "VMBX: CVmSPSHandler::GetSNAPIdL: <=" );
    }

// ---------------------------------------------------------------------------
// CVmSPSHandler::BrandIdL
// (other items were commented in a header).
// ---------------------------------------------------------------------------
//
void CVmSPSHandler::BrandIdL( TInt aServiceId, TDes8& aBrandId )
    {
    VMBLOGSTRING( "VMBX: CVmSPSHandler::BrandIdL: =>" );

    CSPEntry* entry = CSPEntry::NewLC();
    const CSPProperty* property;
    TBuf<KSPMaxDesLength> brandId( KNullDesC );

    User::LeaveIfError(
        iSettings->FindEntryL( aServiceId, *entry ) );

    User::LeaveIfError(
        entry->GetProperty( property, EPropertyBrandId ) );

    if ( property )
        {
        property->GetValue( brandId );
        }

    if ( brandId.Length() )
        {
        aBrandId.Copy( brandId );
        }

    CleanupStack::PopAndDestroy( entry );

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

// ---------------------------------------------------------------------------
// CVmSPSHandler::IsActivatedL
// (other items were commented in a header).
// ---------------------------------------------------------------------------
//
TBool CVmSPSHandler::IsActivatedL( TInt aServiceId )
    {
    VMBLOGSTRING( "VMBX: CVmSPSHandler::IsActivatedL: =>" );

    TBool enabled( EFalse );

    CSPEntry* entry = CSPEntry::NewLC();
    const CSPProperty* property = NULL;

    iSettings->FindEntryL( aServiceId, *entry );

    // Find correct subservice
    TInt error(
        entry->GetProperty( property, ESubPropertyVMBXEnabled ) );

    if ( KErrNotFound != error )
        {
        TOnOff onOff( EOONotSet );
        property->GetValue( onOff );
        enabled = onOff == EOn;
        }

    CleanupStack::PopAndDestroy( entry );

    VMBLOGSTRING2( "VMBX: CVmSPSHandler::IsActivatedL: %d", enabled );
    VMBLOGSTRING( "VMBX: CVmSPSHandler::IsActivatedL: <=" );

    return enabled;
    }

// ----------------------------------------------------------------------------
// CVmSPSHandler::NotifyServiceChange
// (other items were commented in a header).
// ----------------------------------------------------------------------------
//
void CVmSPSHandler::NotifyServiceChange( MServiceNotifyHandler* aHandler )
    {
    VMBLOGSTRING( "VMBX: CVmSPSHandler::NotifyServiceChange: =>" );

    iObserver = aHandler;

    VMBLOGSTRING( "VMBX: CVmSPSHandler::NotifyServiceChange: <=" );
    }

// ----------------------------------------------------------------------------
// CVmSPSHandler::NotifyServiceChangeCancel
// (other items were commented in a header).
// ----------------------------------------------------------------------------
//
void CVmSPSHandler::NotifyServiceChangeCancel()
    {
    VMBLOGSTRING( "VMBX: CVmSPSHandler::NotifyServiceChangeCancel: =>" );

    iObserver = NULL;

    VMBLOGSTRING( "VMBX: CVmSPSHandler::NotifyServiceChangeCancel: <=" );
    }

// ---------------------------------------------------------------------------
// CVmSPSHandler::HandleNotifyChange
// (other items were commented in a header).
// ---------------------------------------------------------------------------
//
void CVmSPSHandler::HandleNotifyChange( TServiceId /*ServiceId*/ )
    {
    VMBLOGSTRING( "VMBX: CVmSPSHandler::HandleNotifyChange: =>" );
    if ( iObserver )
        {
        TRAP_IGNORE( iObserver->HandleServiceNotifyL() );
        }
    VMBLOGSTRING( "VMBX: CVmSPSHandler::HandleNotifyChange: <=" );
    }

// ---------------------------------------------------------------------------
// CVmSPSHandler::HandleError
// (other items were commented in a header).
// ---------------------------------------------------------------------------
//
void CVmSPSHandler::HandleError( TInt /*aError*/ )
    {
    }

TBool CVmSPSHandler::IsVoIPProfilesFound()
    {
    VMBLOGSTRING( "VMBX: CVmSPSHandler::IsVoIPProfilesFound" );
    
    TBool ret( EFalse );

    if ( FeatureManager::FeatureSupported( KFeatureIdCommonVoip ) )
        {
        TRAP_IGNORE( ret = iSpsSettingsVoipUtils->VoIPProfilesExistL() );
        }

    VMBLOGSTRING2( "VMBX: CVmContainer::IsVoIPProfilesFound: return %I", ret );
    return ret;
    }

// ========================== OTHER EXPORTED FUNCTIONS =======================

//  End of File