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