/*

* Copyright (c) 2008 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:  This module contains the implementation of 

*              : CSsServiceHandlerVoip class

*

*/

//  INCLUDE FILES

#include "cssservicehandlervoip.h"

#include "cssconnectionhandler.h"

#include "cssuiutilities.h"

#include "cssserviceutilities.h"

#include "csssettingshandler.h"

#include "cssbshandler.h"

#include "csslogger.h"

#include <serviceselector.rsg>

#include <spdefinitions.h>

#include <spsettingsvoiputils.h>

#include <data_caging_path_literals.hrh>

#include <eikenv.h>

// CONSTANTS

// Selection list array granularity

const TInt KSsArrayGranularity = 2;

// CS service id

const TInt KGSMServiceId = 1;

// List item array size

const TInt KSsLbxItemsArraySize = 3;

// Format of the selection list query.

_LIT( KQueryItemFormat, "%d\t%S" );

// Branding id

const TInt KSsBrandingIdLength = 512;

// Integer length

const TInt KSsIntegerLength = 10;

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

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

// CSsServiceHandlerVoip::CSsServiceHandlerVoip

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

// might leave.

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

//

CSsServiceHandlerVoip::CSsServiceHandlerVoip

        ( 

        // None.

        )

    {

    }

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

// CSsServiceHandlerVoip::ConstructL

// Symbian 2nd phase constructor can leave.

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

//

void CSsServiceHandlerVoip::ConstructL()

    {

    iConnectionHandler = CSsConnectionHandler::NewL();

    iVoipUtils = CSPSettingsVoIPUtils::NewL();

    }

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

// CSsServiceHandlerVoip::NewL

// Two-phased constructor.

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

//

CSsServiceHandlerVoip* CSsServiceHandlerVoip::NewL

        ( 

        // None.

        )

    {

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

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop( self );

    return self;

    }

// Destructor

CSsServiceHandlerVoip::~CSsServiceHandlerVoip

        (

        // None.

        )

    {

    delete iVoipUtils;

    delete iConnectionHandler;

    delete iUiUtils;

    delete iSettings;

    delete iBsHandler;

    }

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

// CSsServiceHandlerVoip::ExecuteServiceSelectionL

// Gets the calling service by current call type and service id.

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

//

void CSsServiceHandlerVoip::ExecuteServiceSelectionL

        ( 

        CConvergedServiceSelector::TSsResult& aResult, 

        CConvergedServiceSelector::TSsCallType /*aCallType*/,

        TUint aServiceId,

        TBool aSendKey,

        const TDesC& aString 

        )

    {

    CSSLOGSTRING("CSSelector::ExecuteVoip");

    if ( 0 != aServiceId && KGSMServiceId != aServiceId )

        {

        // Service id is known, just set correct calltype

        // and registration status.

        GetServiceByServiceId( aResult, aServiceId, aSendKey, aString );

        }

    else

        {

        // Service id is not known or CS service

        // so we have to choce from available voip services.

        GetCallingServiceL( aResult );

        }

    }

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

// CSsServiceHandlerVoip::GetServiceByServiceId

// Gets calling service by known service id.

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

//

void CSsServiceHandlerVoip::GetServiceByServiceId

        ( 

        CConvergedServiceSelector::TSsResult& aResult, 

        TUint aServiceId,

        TBool aSendKey,

        const TDesC& aString

        ) const

    {

    if ( aSendKey && ChangeTypeAsCsVoice( aServiceId, aString ) )

        {

        // Set (CS)voice call parameters

        // CallType, Service id and GSM service is always "enabled"

        SsServiceUtilities::SetServiceResult( 

                aResult,

                CConvergedServiceSelector::ESsVoiceCall,

                KGSMServiceId,

                ETrue ); 

        }

    else

        {

        // Get current registration status for the service.

        // This may be unnecessary at the moment because we don't show  

        // "Register now?" note anymore and currently clients don't use the 

        // registration status for anything.

        TBool registered( iConnectionHandler->IsVoipServiceRegistered( 

                                                            aServiceId ) );

        // Set results    

        SsServiceUtilities::SetServiceResult( 

                aResult,

                CConvergedServiceSelector::ESsVoipCall,

                aServiceId,

                registered );

        }

    }

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

// CSsServiceHandlerVoip::GetCallingServiceL

// Gets calling service without service id.

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

//

void CSsServiceHandlerVoip::GetCallingServiceL

        ( 

        CConvergedServiceSelector::TSsResult& aResult

        )

    {

    TInt error( KErrNone );

    TBool registered( EFalse );

    RArray<TUint> services;

    CleanupClosePushL( services );

    // First try to find registered services to be used if not any available

    // then try to find unregistered services.

    error = SettingsHandlerL().GetRegisteredServices( 

                *iConnectionHandler, services );

    if ( KErrNone != error )

        {

        error = SettingsHandlerL().GetAllServices( services );

        }

    else

        {

        registered = ETrue;

        }

    CSSLOGSTRING2("CSSelector::Service error:%d", error);

    if ( KErrNone != error )

        {

        CSSLOGSTRING("CSSelector::Services not available");

        if ( KErrNoMemory == error )

            {

            User::Leave( error );

            }

        // No voip services available/configured. 

        // Launch information note and leave.

        UiUtilitiesL().ShowInformationNoteL( R_NO_SERVICE_AVAILABLE );

        User::Leave( KErrNotFound );

        }

    // Select service. Show list query

    // if more than one services available.

    SelectServiceL( aResult,

                    services,

                    registered );

    CleanupStack::PopAndDestroy( &services );

    }

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

// CSsServiceHandlerVoip::SelectServiceL

// Makes service selection.

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

//

void CSsServiceHandlerVoip::SelectServiceL

        ( 

        CConvergedServiceSelector::TSsResult& aResult, 

        RArray<TUint>& aServices,

        TBool aRegistered 

        )

    {

    CSSLOGSTRING2("CSSelector::Service count:%d",aServices.Count());

    if ( 0 == aServices.Count() )

        {

        // Empty array, leave

        User::Leave( KErrNotFound );

        }

    TUint serviceId( 0 );

    if ( 1 < aServices.Count() )

        {

        // Because more than one service available we have to

        // make selection list for the user.

        TInt index( KErrNotFound );

        CDesCArrayFlat* lbxItems =

            new (ELeave) CDesCArrayFlat( KSsLbxItemsArraySize );

        CleanupStack::PushL( lbxItems );

        CArrayPtr<CGulIcon>* icons =

            new (ELeave) CAknIconArray( KSsLbxItemsArraySize );

        CleanupStack::PushL( icons );

        GetListBoxItemsAndIconsL( aServices,

                                  lbxItems,

                                  icons );

        // List query takes ownership for icon array

        CleanupStack::Pop( icons );

        // Select service by list query

        TBool ret = UiUtilitiesL().ShowListQueryL( 

                index, R_PHONE_VOIP_CALL_TYPE_QUERY, lbxItems, icons );

        CSSLOGSTRING2("CSSelector::Service list ret:%d", ret);

        CSSLOGSTRING2("CSSelector::Service list index:%d", index);

        // Make sure that the index is on the correct range and user has 

        // not canceled the list query.

        if ( !ret || ( index < 0 || index >= aServices.Count() ) )

            {

            // User cancels the query -> leave

            User::Leave( KErrCancel );

            }

        CleanupStack::PopAndDestroy( lbxItems );

        // Use the selected service.

        serviceId = aServices[index];

        }

    else

        {

        // One service available, use it.

        serviceId = aServices[0];

        }

    // Set results    

    SsServiceUtilities::SetServiceResult( 

            aResult,

            CConvergedServiceSelector::ESsVoipCall,

            serviceId,

            aRegistered );

    }

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

// CSsServiceHandlerVoip::UiUtilitiesL

// Returns uiutilities reference.

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

//

CSsUiUtilities& CSsServiceHandlerVoip::UiUtilitiesL() 

    {

    if ( !iUiUtils )

        {

        // Create uiutils for ui dialogs.

        // UiUtils is created only for the real need.

        iUiUtils = CSsUiUtilities::NewL();

        }

    return *iUiUtils;

    }

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

// CSsServiceHandlerVoip::SettingsHandlerL

// Returns settings handler reference.

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

//

CSsSettingsHandler& CSsServiceHandlerVoip::SettingsHandlerL() 

    {

    if ( !iSettings )

        {

        // Create settings handler

        iSettings = CSsSettingsHandler::NewL();

        }

    return *iSettings;

    }

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

// CSsServiceHandlerVoip::BrandingHandlerL

// Returns settings handler reference.

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

//

CSsBsHandler& CSsServiceHandlerVoip::BrandingHandlerL() 

    {

    if ( !iBsHandler )

        {

        // Create settings handler

        iBsHandler = CSsBsHandler::NewL();

        }

    return *iBsHandler;

    }

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

// CSsServiceHandlerVoip::ChangeTypeAsCsVoice

// Checks should voip call type be changed as cs voice.

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

//

TBool CSsServiceHandlerVoip::ChangeTypeAsCsVoice

        ( 

        TUint aServiceId,

        const TDesC& aString

        ) const

    {

    TBool csCall( EFalse );

    TUint prefService( 0 );

    if ( SsServiceUtilities::IsValidCsNumber( aString ) &&

         iVoipUtils->IsPreferredTelephonyVoIP() &&

         KErrNone == iVoipUtils->GetPreferredService( prefService ) )

        {

        csCall = prefService == aServiceId &&

                 !iConnectionHandler->IsVoipServiceRegistered( aServiceId );

        }

    return csCall;

    }

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

// CSsServiceHandlerVoip::AddBrandIconL

//

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

//

void CSsServiceHandlerVoip::AddBrandIconL

        (

        CArrayPtr<CGulIcon>* aIcons,

        TUint aServiceId,

        TInt& aIconId 

        )

    {

    CFbsBitmap* brandedBitmap = NULL;

    CFbsBitmap* brandedBitmapMask = NULL;

    // Get branded bitmap

    TRAPD( err, GetBrandIconL( aServiceId,

                               brandedBitmap, 

                               brandedBitmapMask ) );

    if ( KErrNone == err )

        {

        // The count of list icons(before adding branding icon to the list)

        // must be the branded icon list id

        aIconId = aIcons->Count();

        // Create new icon and add it to the icon list

        CGulIcon* icon = CGulIcon::NewL( brandedBitmap, brandedBitmapMask );

        CleanupStack::PushL( icon );

        aIcons->AppendL( icon );

        CleanupStack::Pop( icon );

        }

    else

        {

        // Use default icon for this service

        aIconId = 0;

        }

    }

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

// CSsServiceHandlerVoip::GetListBoxItemsAndIconsL

//

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

//

void CSsServiceHandlerVoip::GetListBoxItemsAndIconsL

        (

        RArray<TUint>& aServices,

        CDesCArrayFlat* aLbxItems,

        CArrayPtr<CGulIcon>* aIcons       

        )

    {

    CDesCArray* names = new(ELeave) CDesCArrayFlat( KSsArrayGranularity );

    CleanupStack::PushL( names );

    // Load default listbox icon

    UiUtilitiesL().LoadDefaultIconL( *aIcons );

    // Get service names by service id array

    SettingsHandlerL().GetServiceNamesL( aServices, *names );

    for ( TInt i=0; i< aServices.Count() && 

            names->MdcaCount() == aServices.Count(); i++ )

        {

        RBuf16 buf;

        CleanupClosePushL( buf );

        TInt iconId( KErrNotFound );

        // Add brand icon. Default is used if brand icon not found

        AddBrandIconL( aIcons, aServices[ i ], iconId );

        HBufC* name = HBufC::NewLC( names->MdcaPoint(i).Length() );

        name->Des().Copy( names->MdcaPoint(i) );

        buf.CreateL( names->MdcaPoint(i).Length() +

                     KQueryItemFormat().Length() +

                     KSsIntegerLength );

        // Create final list box item data.

        buf.Format( KQueryItemFormat, iconId, name );

        //Append text to the item array.

        aLbxItems->AppendL( buf );

        CleanupStack::PopAndDestroy( name );

        CleanupStack::PopAndDestroy( &buf );

        }

    CleanupStack::PopAndDestroy( names );

    }

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

// CSsServiceHandlerVoip::GetBrandIconL

//

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

//

void CSsServiceHandlerVoip::GetBrandIconL

        (

        TUint aServiceId,

        CFbsBitmap*& aBrandedBitmap,

        CFbsBitmap*& aBrandedBitmapMask  

        )

    {

    TBuf8<KSsBrandingIdLength> brandId( KNullDesC8 );

    SettingsHandlerL().BrandIdL( aServiceId, brandId );

    // Get branded bitmap

    BrandingHandlerL().GetBrandedIconL( brandId, 

                                        aBrandedBitmap, 

                                        aBrandedBitmapMask );

    }

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

//  End of File