/*
* Copyright (c) 2002 Nokia Corporation and/or its subsidiary(-ies).
* All rights reserved.
* This component and the accompanying materials are made available
* under the terms of the License "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:
*
*/
// INCLUDE FILES
#include <BrowserTelService.rsg>
#include <coemain.h>
#include <data_caging_path_literals.hrh>
// For phonebook API
#include <CPbkContactItem.h> // Phonebook Contact
#include <CPbkContactEngine.h> // Phonebook Engine
#include <CPbkFieldsInfo.h> // Phonebook field types
#include <RPbkViewResourceFile.h>
#include <CPbkContactEditorDlg.h> // Phonebook editor
// For searching a matching number from contact's db
#include <TPbkContactItemField.h>
#include <CNTFLDST.H>
#include <FeatMgr.h>
//
#include <txtrich.h>
#include <badesca.h>
#include <s32strm.h>
// For email API
#include <sendui.h>
#include <CMessageData.h>
#include <TSendingCapabilities.h>
#include <SenduiMtmUids.h>
// For BaflUtils
#include <bautils.h>
// Stringloader
#include <StringLoader.h>
// TApaTask, TApaTaskList
#include <apgtask.h>
// Connection management
#include <in_sock.h>
#include <es_enum.h>
#include <ApUtils.h>
#include <APDataHandler.h>
#include <ApAccessPointItem.h>
#include <commdb.h>
#include <f32file.h>
// Const file name for make call
#include <mmtsy_names.h>
#include <browseruisdkcrkeys.h>
#include <centralrepository.h>
#include <nwx_status.h>
#include <DialUtils.h>
#include "BrowserTelService.h"
#include "BrowserTelServiceDlgs.h"
#include "TelServiceLogger.h"
#include "BrowserUtilitiesVariant.hrh" // KBrowserUtilitiesMailtoSchemeToMmsEditor
const TInt KParseArrayAllocation = 10;
const TInt KTimerDelay = 2500000;
//constants
const TUid KUidMsgTypeSMTP = {0x10001028}; // 268439592
_LIT( KValidDTMFChars,"w/p*#0123456789ABCDabcd," );
_LIT( KDTMFWaitChars, "/wp,*#" );
#ifdef __BROWSER_TEL_SERVICES_CALLUI__
_LIT( KDTMFInvalidWaitChars, "/," );
_LIT( KDTMFValidPause, "p" );
#endif // __BROWSER_TEL_SERVICES_CALLUI__
// load resource file
_LIT( KResourceFileName, "Z:browsertelservice.RSC" );
// Path of the temp file
_LIT(KTempDrive, "d:");
_LIT( KTempPath, "\\system\\temp\\" );
// The library to be loaded.
_LIT( KDialUtilsLoadLib, "DialUtils.dll" );
const TInt KKimonoBase = 26000;
/*
This is a conversion table from browsertelservice internal
error codes to global and localized error ids.
{local error code, global error id}
Exception is KErrArgument-NW_STAT_WTAI_INVALID_ARGUMENT pair, because
case of wrong dtmf sequence has no WTAI correspondent error code.
*/
const TInt KErrorConvTable[][2] =
{
{KErrInvocationError, NW_STAT_WTAI_INVOCATIONERROR},
{KErrNoCallActive, NW_STAT_WTAI_NOCALLACTIVE},
{KErrUserNoAnswer, NW_STAT_WTAI_NOANSWER},
{KErrNoService, NW_STAT_WTAI_NOSERVICE},
{KErrUserBusy, NW_STAT_WTAI_USERBUSY},
{KErrPBPhoneBookFull, NW_STAT_WTAI_PHONEBOOKFULL},
{KErrPBWriteError, NW_STAT_WTAI_PBWRITEERROR},
{KErrPBNumberTooLong, NW_STAT_WTAI_PBNUMBERTOOLONG},
{KErrPBNameTooLong, NW_STAT_WTAI_PBNAMETOOLONG},
{KErrUnspecified, NW_STAT_WTAI_UNSPECIFIED_ERROR},
{KErrArgument,NW_STAT_WTAI_INVALID_ARGUMENT},
{KErrEtelBusyDetected, NW_STAT_WTAI_USERBUSY},
{KErrEtelNoAnswer, NW_STAT_WTAI_NOANSWER},
{0,0}
};
// ================= MEMBER FUNCTIONS =======================
//-----------------------------------------------------------------------------
// CBrowserTelService::NewLC()
//-----------------------------------------------------------------------------
//
EXPORT_C CBrowserTelService* CBrowserTelService::NewLC(
MBrowserTelServiceObserver* aObserver )
{
CBrowserTelService* self = new( ELeave ) CBrowserTelService;
CleanupStack::PushL( self );
self->ConstructL( aObserver );
return self;
}
//---------------------------------------------------------------------------------------
// CBrowserTelService::NewL()
//---------------------------------------------------------------------------------------
//
EXPORT_C CBrowserTelService* CBrowserTelService::NewL(
MBrowserTelServiceObserver* aObserver )
{
CBrowserTelService* self = CBrowserTelService::NewLC( aObserver );
CleanupStack::Pop();
return self;
}
//---------------------------------------------------------------------------------------
// CBrowserTelService::ConstructL()
//---------------------------------------------------------------------------------------
//
void CBrowserTelService::ConstructL( MBrowserTelServiceObserver* aObserver )
{
TELSERVICE_CREATE;
iServiceHandler = NULL;
SetState( EIdle );
if( aObserver )
{
iObserverList.Append( aObserver );
}
iSynch = EFalse;
iIdle = CIdle::NewL( CActive::EPriorityIdle );
// Prepare telservice logger.
TELSERVICE_CREATE;
// Resouce file loading
TParse* fileParser = new (ELeave) TParse;
CleanupStack::PushL( fileParser );
fileParser->Set( KResourceFileName, &KDC_RESOURCE_FILES_DIR, NULL );
iResourceFileName = fileParser->FullName();
iResourceLoader.OpenL( iResourceFileName );
iResourceOpened = ETrue;
CleanupStack::PopAndDestroy( fileParser ); // fileParser
iErrorUi = CErrorUI::NewL();
#ifdef __BROWSER_TEL_SERVICES_CALLUI__
iDialData = CAiwDialData::NewL();
#endif // __BROWSER_TEL_SERVICES_CALLUI__
CActiveScheduler::Add( this );
}
//---------------------------------------------------------------------------------------
// Default C++ constructor
//---------------------------------------------------------------------------------------
//
CBrowserTelService::CBrowserTelService()
: CActive( EPriorityNormal ),
iResourceFileName( KNullDesC ),
iResourceLoader( *CCoeEnv::Static() ),
iResourceOpened( EFalse )
{
}
//---------------------------------------------------------------------------------------
// Destructor
//---------------------------------------------------------------------------------------
//
EXPORT_C CBrowserTelService::~CBrowserTelService()
{
TELSERVICE_ENTERFN( "~CBrowserTelService()" )
delete iServiceHandler;
iServiceHandler = NULL;
// Cancel all current activity
Cancel();
// Close all open sessions
CloseAllSessions();
#ifdef __BROWSER_TEL_SERVICES_CALLUI__
if (iDialData)
{
delete iDialData;
}
#endif // __BROWSER_TEL_SERVICES_CALLUI__
if( iSendableDTMFNumbers )
{
iSendableDTMFNumbers->ResetAndDestroy();
delete iSendableDTMFNumbers;
}
if( iDlgDTMFNumbers )
{
iDlgDTMFNumbers->ResetAndDestroy();
delete iDlgDTMFNumbers;
}
// Empty the observer list
iObserverList.Reset();
/*
if ( iResourceFileOffset )
{
CCoeEnv::Static()->DeleteResourceFile( iResourceFileOffset );
}
*/
if ( iResourceOpened )
{
iResourceLoader.Close();
iResourceOpened = EFalse;
}
#ifdef __BROWSER_TEL_SERVICES_CALLUI__
if( iDTMFNumber )
{
delete iDTMFNumber;
iDTMFNumber = NULL;
}
#endif // __BROWSER_TEL_SERVICES_CALLUI__
delete iIdle;
delete iErrorUi;
TELSERVICE_LEAVEFN( "~CBrowserTelService()" )
TELSERVICE_DELETE
}
//---------------------------------------------------------------------------------------
// CBrowserTelService::InitializeL()
//---------------------------------------------------------------------------------------
//
EXPORT_C HBufC* CBrowserTelService::ParsePhoneNumberL( TDes* aNumber )
{
TELSERVICE_WRITE( "ParsePhoneNumberL()" )
return FindAndRipDTMFSequenceL( aNumber );
}
//---------------------------------------------------------------------------------------
// CBrowserTelService::MakeCall()
//---------------------------------------------------------------------------------------
//
EXPORT_C TInt CBrowserTelService::MakeCall( TDesC& aNumber,
TBool aSendDTMFAlwaysConfirm )
{
TELSERVICE_ENTERFN( "MakeCall() synchronous" )
TInt retVal( KErrNone );
iRetVal = KErrNone;
// Flag to indicate that synchronous method was called
iSynch = ETrue;
TRAP( retVal, MakeCallL( aNumber, aSendDTMFAlwaysConfirm ) );
if( retVal != KErrNone )
{
ErrorHandler( retVal );
retVal = KErrCancel;
}
iSynch = EFalse;
TELSERVICE_LEAVEFN( "MakeCall() synchronous" )
return retVal;
}
//---------------------------------------------------------------------------------------
// CBrowserTelService::MakeCall()
//---------------------------------------------------------------------------------------
//
EXPORT_C void CBrowserTelService::MakeCall( TRequestStatus& aStatus,
TDesC& aNumber,
TBool aSendDTMFAlwaysConfirm )
{
TELSERVICE_ENTERFN( "MakeCall() asynchronous" )
iRetVal = KErrNone;
aStatus = KRequestPending;
iUserRequestStatus = &aStatus;
iSynch = EFalse;
TRAPD( err, MakeCall( aNumber, aSendDTMFAlwaysConfirm ) );
TELSERVICE_WRITE_FORMAT( "Asynch makecall start: %d", err )
if( err )
{
ErrorHandler( err );
User::RequestComplete( iUserRequestStatus, err );
CleanupBuffers();
}
TELSERVICE_LEAVEFN( "MakeCall() asynchronous" )
}
//---------------------------------------------------------------------------------------
// CBrowserTelService::CancelMakeCall()
//---------------------------------------------------------------------------------------
//
EXPORT_C void CBrowserTelService::CancelMakeCall()
{
TELSERVICE_ENTERFN( "CancelMakeCall()" )
#ifdef __BROWSER_TEL_SERVICES_CALLUI__
// There is no ongoing request
#else // __BROWSER_TEL_SERVICES_CALLUI__
Cancel();
SetStateIdleAndNotifyObservers();
#endif // __BROWSER_TEL_SERVICES_CALLUI__
TELSERVICE_LEAVEFN( "CancelMakeCall()" )
}
//---------------------------------------------------------------------------------------
// CBrowserTelService::MakeCallL()
//---------------------------------------------------------------------------------------
//
void CBrowserTelService::MakeCallL( TDesC& aNumber, TBool aSendDTMFAlwaysConfirm, TBool voipCall )
{
iDTMFAlwaysConfirm = aSendDTMFAlwaysConfirm;
iRetVal = KErrNone;
if( State() != EIdle )
{
return;
}
if( aNumber.Length() == 0 )
{
User::Leave( KErrInvocationError );
}
#ifdef __BROWSER_TEL_SERVICES_CALLUI__
if( aNumber.Length() > AIWDialDataExt::KMaximumPhoneNumberLength )
{
User::Leave( KErrPBNumberTooLong );
}
HBufC* orgNumber = HBufC::NewLC( AIWDialDataExt::KMaximumPhoneNumberLength );
#else // __BROWSER_TEL_SERVICES_CALLUI__
if( aNumber.Length() > RMobilePhone::KMaxMobileTelNumberSize )
{
User::Leave( KErrPBNumberTooLong );
}
HBufC* orgNumber = HBufC::NewLC( RMobilePhone::KMaxMobileTelNumberSize );
#endif // __BROWSER_TEL_SERVICES_CALLUI__
orgNumber->Des().Copy( aNumber );
if( FeatureManager::FeatureSupported( KFeatureIdJapanPrefixChange ) )
{
RLibrary dialUtils;
if( dialUtils.Load( KDialUtilsLoadLib ) == KErrNone )
{
CleanupClosePushL( dialUtils );
// Call function CreateDialUtilsFactoryL()
TInt res = dialUtils.Lookup( 1 )();
CDialUtilsFactory * dialUtilsFactory =
reinterpret_cast< CDialUtilsFactory * >( res );
// This way the library is not needed at the linking time.
// Create Dial Utils (see that the function deletes the factory
// instance):
CDialUtilsApi* dialUtilsApi = dialUtilsFactory->CDialUtilsApiLD();
dialUtilsFactory = NULL;
// Then use the Dial Utils API, for example:
if( dialUtilsApi->CheckNumber( *orgNumber ) == KErrOverflow )
// no we have the converted number
{
User::Leave( KErrPBNumberTooLong );
}
delete dialUtilsApi;
CleanupStack::PopAndDestroy( &dialUtils );
}
}
// Handle postd format
TPtr orgNumberPtr( orgNumber->Des() );
HBufC* postdParm = FindPostdParmL( orgNumberPtr );
if(voipCall)
{
FindAndRipVoipParametersL( orgNumberPtr );
}
// Rip URI parameters from Tel URI, in order to that
// number validation and DTMF works as earlier
// Parameters will be added back in later phase
HBufC* params = FindAndRipURIParametersL( orgNumberPtr );
CleanupStack::PushL( params );
HBufC* number = ValidateNumberL( *orgNumber );
CleanupStack::PushL( number );
TPtr numberPtr = number->Des();
iDTMFNumber= FindAndRipDTMFSequenceL( &numberPtr );
TBool isPostd(EFalse);
if ( ! iDTMFNumber )
{
iDTMFNumber = postdParm;
if ( iDTMFNumber )
{
isPostd = ETrue;
}
}
else
{
delete postdParm;
}
#ifndef __BROWSER_TEL_SERVICES_CALLUI__
iSendableDTMFNumbers = ParseDTMFSequencesL( iDTMFNumber );
iDlgDTMFNumbers = ParseDTMFSequencesForDlgL( iDTMFNumber );
#endif // __BROWSER_TEL_SERVICES_CALLUI__
if( ShowDialogL( *number, EConfirmMakeCall ) )
{
#ifndef __WINS__
DisconnectActiveCSDConnectionL();
#endif
#ifdef __BROWSER_TEL_SERVICES_CALLUI__
HBufC* temp = NULL;
if( iDTMFNumber )
{
// Confirm the user (s)he wants to send the DTMF
if( SendDMFConfQueryL( iDTMFNumber->Des() ) )
{
if ( !isPostd )
{
// Add iDTMFNumber to number
temp = HBufC::NewLC( number->Length() + iDTMFNumber->Length() );
temp->Des().Copy( number->Des() );
temp->Des().Append( iDTMFNumber->Des() );
}
else
{
// Add p+iDTMFNumber to number for postd
temp = HBufC::NewLC( number->Length() + iDTMFNumber->Length() + 1 /*for the 'p' character*/ );
temp->Des().Copy( number->Des() );
temp->Des().Append( 'p' );
temp->Des().Append( iDTMFNumber->Des() );
}
}
else
{
// Call number without dtmf
temp = number->AllocLC();
}
}
else
{
temp = number->AllocLC();
}
temp = temp->ReAllocL( temp->Length() + params->Length() );
CleanupStack::Pop( temp ); // location may have changed, update cleanupstack
CleanupStack::PushL( temp );
temp->Des().Append( *params );
// ... and make the call
DoMakeCallL( *temp, voipCall );
CleanupStack::PopAndDestroy( temp ); // temp
#else // __BROWSER_TEL_SERVICES_CALLUI__
// ... and make the call
DoMakeCallL( *number, voipCall );
#endif // __BROWSER_TEL_SERVICES_CALLUI__
}
else
{
User::Leave( KErrCancel );
}
CleanupStack::PopAndDestroy( 3 ); // orgNumber, params, number
}
#ifdef __BROWSER_TEL_SERVICES_CALLUI__
//---------------------------------------------------------------------------------------
// CBrowserTelService::SendDMFConfQueryL()
//---------------------------------------------------------------------------------------
//
TBool CBrowserTelService::SendDMFConfQueryL( const TDesC& aDTMF )
{
TBool retVal( EFalse );
TELSERVICE_ENTERFN( "SendDMFConfQueryL()" )
if( 0 == aDTMF.Length() )
{
return retVal;
}
CRepository* repository = CRepository::NewL( KCRUidBrowser );
CleanupStack::PushL (repository );
repository->Get( KBrowserConfirmedDTMFOnce, iConfirmedOnce );
TELSERVICE_WRITE( "display send dtmf dialog" )
if( iDTMFAlwaysConfirm )
{
retVal = ShowDialogL( aDTMF, EConfirmSendDTMF );
}
else if( iDTMFAlwaysConfirm == EFalse &&
iConfirmedOnce == EFalse )
{
retVal = ShowDialogL( aDTMF,
EConfirmSendDTMF );
iConfirmedOnce = ETrue;
repository->Set( KBrowserConfirmedDTMFOnce, iConfirmedOnce );
}
CleanupStack::PopAndDestroy( repository );
return retVal;
}
#endif // __BROWSER_TEL_SERVICES_CALLUI__
//---------------------------------------------------------------------------------------
// CBrowserTelService::CleanupBuffs()
//---------------------------------------------------------------------------------------
//
void CBrowserTelService::CleanupBuffers()
{
if( iSendableDTMFNumbers )
{
iSendableDTMFNumbers->ResetAndDestroy();
delete iSendableDTMFNumbers;
iSendableDTMFNumbers = NULL;
}
if( iDlgDTMFNumbers )
{
iDlgDTMFNumbers->ResetAndDestroy();
delete iDlgDTMFNumbers;
iDlgDTMFNumbers = NULL;
}
}
//---------------------------------------------------------------------------------------
// CBrowserTelService::DoMakeCallL()
//---------------------------------------------------------------------------------------
//
void CBrowserTelService::DoMakeCallL( TDesC& aNumber, TBool voipCall )
{
TELSERVICE_ENTERFN( "DoMakeCallL()" )
#ifndef __BROWSER_TEL_SERVICES_CALLUI__
RTelServer::TPhoneInfo info;
RPhone::TLineInfo lineInfo;
// Connect to the telephony server and load the TSY.
User::LeaveIfError( iRTelServer.Connect() );
User::LeaveIfError( iRTelServer.LoadPhoneModule( KMmTsyModuleName ) );
// Get the details for the first (and only) phone.
User::LeaveIfError( iRTelServer.GetPhoneInfo( 0, info ) );
// Open the phone.
User::LeaveIfError( iRPhone.Open( iRTelServer, info.iName ) );
// Get the information for the voice line, line 0.
User::LeaveIfError( iRPhone.GetLineInfo( 0, lineInfo ) );
// Open the line. iName will now be "VoiceLine1".
User::LeaveIfError( iRLine.Open( iRPhone, KMmTsyVoice1LineName ) );
TInt count;
// Gets the number of calls opened from a line.
User::LeaveIfError( iRLine.EnumerateCall( count ) );
if ( count > 2 )
{
HBufC* text = StringLoader::LoadL(
R_TEXT_CALL_NOT_ALLOWED,
CEikonEnv::Static() );
CleanupStack::PushL( text );
TDialerDialogs::ErrorNoteL( *text );
CleanupStack::PopAndDestroy();// text
User::Leave( KErrNone );
}
// Open a new phone call.
User::LeaveIfError( iRCall.OpenNewCall( iRLine ) );
// Initialize state
SetState( EDialing );
// Actually dial the specified number.
iRCall.Dial( iStatus, aNumber );
SetActive();
NotifyObservers();
if( iSynch )
{
TELSERVICE_WRITE( "starting DoMakeCallL wait loop" )
iWait.Start(); // start the wait loop. DoMakeCallL() method won't
// return until iWait->AsyncStop() is called in RunL()
TELSERVICE_WRITE( "DoMakeCallL wait loop stopped" )
if( iRetVal == KErrNone )
{
if( HandleInternalSendDTMFL() )
{
TELSERVICE_WRITE( "starting HandleInternalSendDTMFL wait loop" )
iInternalDTMFWaitStarted = ETrue;
iWait.Start();
iRAdvGsmPhone.Close();
TELSERVICE_WRITE( "HandleInternalSendDTMFL wait loop stopped" )
if( iWaitDlg )
{
iWaitDlg->ProcessFinishedL();
}
iInternalDTMFWaitStarted = EFalse;
}
}
else
{
User::Leave( iRetVal );
}
}
#else // __BROWSER_TEL_SERVICES_CALLUI__
if(!iServiceHandler)
{
iServiceHandler = CAiwServiceHandler::NewL();
}
iServiceHandler->AttachL( R_BROWSERTELSERVICES_MENU_AIW_INTERESTS );
CAiwGenericParamList& paramList = iServiceHandler->InParamListL();
CAiwGenericParamList& output = iServiceHandler->OutParamListL();
TPtrC number = aNumber;
iDialData->SetPhoneNumberL( number );
if( !voipCall )
{
iDialData->SetCallType( CAiwDialData::EAIWVideo );
}
else
{
iDialData->SetCallType( CAiwDialData::EAIWVoiP );
}
iDialData->FillInParamListL( paramList );
iServiceHandler->ExecuteServiceCmdL(
KAiwCmdCall,
paramList,
output,
0, // No options used.
this ); //
if( iSynch )
{
iWait.Start();
}
#endif // __BROWSER_TEL_SERVICES_CALLUI__
TELSERVICE_LEAVEFN( "DoMakeCallL()" )
}
//---------------------------------------------------------------------------------------
// CBrowserTelService::SendDTMFL()
//---------------------------------------------------------------------------------------
//
void CBrowserTelService::SendDTMFL( TDesC& aNumber, TBool aSendDTMFAlwaysConfirm )
{
iDTMFAlwaysConfirm = aSendDTMFAlwaysConfirm;
iRetVal = KErrNone;
CheckIsThereActivateVoiceCallOnL();
if( State() == EConnected )
{
CheckDTMFNumberL( aNumber );
// Set flag to indicate that synchronous method was called
iSynch = ETrue;
delete iSendableDTMFNumbers;
iSendableDTMFNumbers = NULL;
delete iDlgDTMFNumbers;
iDlgDTMFNumbers = NULL;
iSendableDTMFNumbers = ParseDTMFSequencesL( &aNumber );
iDlgDTMFNumbers = ParseDTMFSequencesForDlgL( &aNumber );
if( HandleInternalSendDTMFL() )
{
TELSERVICE_WRITE( "starting HandleInternalSendDTMFL wait loop" )
iInternalDTMFWaitStarted = ETrue;
iWait.Start();
TELSERVICE_WRITE( "HandleInternalSendDTMFL wait loop stopped" )
if( iWaitDlg )
{
iWaitDlg->ProcessFinishedL();
}
iInternalDTMFWaitStarted = EFalse;
}
// Unset flag
iSynch = EFalse;
}
else // no active voice connection
{
User::Leave( KErrNoCallActive );
}
}
//---------------------------------------------------------------------------------------
// CBrowserTelService::SendDTMFL()
//---------------------------------------------------------------------------------------
//
void CBrowserTelService::SendDTMFL( TRequestStatus& aStatus,TDesC& aNumber,
TBool aSendDTMFAlwaysConfirm )
{
iDTMFAlwaysConfirm = aSendDTMFAlwaysConfirm;
aStatus = KRequestPending;
iUserRequestStatus = &aStatus;
CheckIsThereActivateVoiceCallOnL();
if( State() == EConnected )
{
CheckDTMFNumberL( aNumber );
if( iSendableDTMFNumbers )
{
iSendableDTMFNumbers->ResetAndDestroy();
}
delete iSendableDTMFNumbers;
iSendableDTMFNumbers = NULL;
if( iDlgDTMFNumbers )
{
iDlgDTMFNumbers->ResetAndDestroy();
}
delete iDlgDTMFNumbers;
iDlgDTMFNumbers = NULL;
iSendableDTMFNumbers = ParseDTMFSequencesL( &aNumber );
iDlgDTMFNumbers = ParseDTMFSequencesForDlgL( &aNumber );
HandleInternalSendDTMFL();
}
else // no active voice connection
{
User::Leave( KErrNoCallActive );
}
}
//---------------------------------------------------------------------------------------
// CBrowserTelService::DoSendDTMFL()
//---------------------------------------------------------------------------------------
//
void CBrowserTelService::DoSendDTMFL( TDesC& aNumber )
{
TELSERVICE_ENTERFN( "DoSendDTMFL()" )
CheckIsThereActivateVoiceCallOnL();
if( State() == EConnected )
{
// Cancel any outstanding requests
Cancel();
RTelServer::TPhoneInfo info;
User::LeaveIfError( iRTelServer.GetPhoneInfo( 0, info ) );
User::LeaveIfError( iRAdvGsmPhone.Open( iRTelServer, info.iName ) );
// Set state
SetState( EDialingDTMF );
// Notify the observer
NotifyObservers();
// Send DTMF tones
if( aNumber.Length() )
{
iRAdvGsmPhone.SendDTMFTones( iStatus, aNumber );
}
else
{
TRequestStatus* status = &iStatus;
User::RequestComplete( status, KErrNone );
}
SetActive();
if( iSynch )
{
iWait.Start(); // start the wait loop. DoSendDTMFL()
// method won't return
// until iWait->AsyncStop() is called in RunL()
}
}
else
{
User::Leave( KErrCancel );
}
TELSERVICE_LEAVEFN( "DoSendDTMFL()" )
}
//---------------------------------------------------------------------------------------
// CBrowserTelService::ValidateNumberL()
//---------------------------------------------------------------------------------------
//
HBufC* CBrowserTelService::ValidateNumberL( TDesC& aNumber )
{
TELSERVICE_ENTERFN( "ValidateNumberL()" )
HBufC* buf = HBufC::NewLC( aNumber.Length() );
TPtr ptr = buf->Des();
ptr.Copy( aNumber );
for( TInt i = 0; i < ptr.Length(); i++ )
{
TChar currentChar = ptr[i];
if( currentChar.IsSpace() )
{
ptr.Delete( i, 1 );
i--;
}
else if( !currentChar.IsDigit() )
{
if( currentChar == '+' )
{
if( i != 0 )
{
User::Leave( KErrInvocationError );
}
}
else
{
currentChar.UpperCase();
switch( currentChar )
{
case '*':
case '#':
case 'A':
case 'B':
case 'C':
case 'D':
case 'P':
case 'W':
case ',':
case '/':
if( i == 0 )
{
User::Leave( KErrInvocationError );
}
break;
case '.':
case '-':
case '(':
case ')':
{
ptr.Delete( i, 1 );
i--;
}
break;
default:
// invalid character in the phone number
{
User::Leave( KErrInvocationError );
}
break;
}
}
}
}
CleanupStack::Pop( buf ); // buf
TELSERVICE_LEAVEFN( "ValidateNumberL()" )
return buf;
}
//---------------------------------------------------------------------------------------
// CBrowserTelService::FindAndHandlePostdL()
//---------------------------------------------------------------------------------------
//
HBufC* CBrowserTelService::FindPostdParmL( TDes& aNumber )
{
TELSERVICE_ENTERFN( "FindPostdParmL()" )
HBufC* buf = NULL;
_LIT( KPostd, ";postd=" );
TInt ret = aNumber.Find( KPostd );
if ( ret != KErrNotFound )
{
buf = aNumber.Mid( ret + KPostd().Length() ).AllocL();
aNumber.SetLength ( ret );
}
TELSERVICE_LEAVEFN( "FindPostdParmL()" )
return buf;
}
//---------------------------------------------------------------------------------------
// CBrowserTelService::FindAndRipDTMFSequenceL()
//---------------------------------------------------------------------------------------
//
HBufC* CBrowserTelService::FindAndRipDTMFSequenceL( TDes* aNumber )
{
TELSERVICE_ENTERFN( "FindAndRipDTMFSequnceL()" )
HBufC* buf = NULL;
TPtrC waitChars;
waitChars.Set( KDTMFWaitChars );
// Look for the first DTMF-wait char and extract the
// dtmf string from the phonenumber
for( TInt i = 0; i < aNumber->Length(); i++ )
{
if( ( waitChars.Locate( (*aNumber)[i] ) != KErrNotFound ) )
{
#ifdef __BROWSER_TEL_SERVICES_CALLUI__
buf = aNumber->Mid(i).AllocL();
aNumber->Delete( i, buf->Length() );
// Remove all the invalid wait chars from
// the sequence which is not accepted by CallUi
TPtrC invalidWaitChars;
invalidWaitChars.Set( KDTMFInvalidWaitChars );
for( TInt j = 0; j < buf->Length(); j++ )
{
if( ( invalidWaitChars.Locate( (*buf)[j] ) != KErrNotFound ) )
{
TPtr ptr = buf->Des();
ptr.Replace( j, 1,KDTMFValidPause() );
}
}
#else // __BROWSER_TEL_SERVICES_CALLUI__
if( (*aNumber)[i] == '#' ||
(*aNumber)[i] == '*' )
// these chars are parts of the dtms sequence
{
buf = aNumber->Mid(i).AllocL();
aNumber->Delete( i, buf->Length() );
}
else
{
// +1 -> wait char is not part of the dtmf sequence
buf = aNumber->Mid(i+1).AllocL();
aNumber->Delete( i, buf->Length() + 1);
}
#endif // __BROWSER_TEL_SERVICES_CALLUI__
break;
}
}
TELSERVICE_LEAVEFN( "FindAndRipDTMFSequenceL()" )
return buf;
}
//---------------------------------------------------------------------------------------
// CBrowserTelService::FindAndRipURIParametersL()
//---------------------------------------------------------------------------------------
//
HBufC* CBrowserTelService::FindAndRipURIParametersL( TDes& aNumber )
{
TELSERVICE_ENTERFN( "FindAndRipURIParametersL()" )
HBufC* buf = NULL;
TInt offset = aNumber.Locate( TChar( ';' ) );
if( offset > 0 ) // Separator is not allowed to be a first char
{
__ASSERT_DEBUG( offset <= aNumber.Length(), User::Leave( KErrGeneral ) );
buf = aNumber.Mid( offset ).AllocL();
aNumber.SetLength( offset );
}
else
{
buf = HBufC::NewL( 0 );
}
TELSERVICE_LEAVEFN( "FindAndRipURIParametersL()" )
return buf;
}
//---------------------------------------------------------------------------------------
// CBrowserTelService::FindAndRipVoipParametersL()
//---------------------------------------------------------------------------------------
//
void CBrowserTelService::FindAndRipVoipParametersL( TDes& aNumber )
{
TELSERVICE_ENTERFN( "FindAndRipVoipParametersL()" )
HBufC* buf = NULL;
TInt offset = aNumber.Locate( TChar( '@' ) );
if( offset > 0 ) // Separator is not allowed to be a first char
{
__ASSERT_DEBUG( offset <= aNumber.Length(), User::Leave( KErrGeneral ) );
buf = aNumber.Mid( offset ).AllocL();
aNumber.SetLength( offset );
}
else
{
buf = HBufC::NewL( 0 );
}
TELSERVICE_LEAVEFN( "FindAndRipVoipParametersL()" )
}
//---------------------------------------------------------------------------------------
// CBrowserTelService::ValidateDTMFNumberL()
//---------------------------------------------------------------------------------------
//
void CBrowserTelService::ValidateDTMFNumberL( TDes* aNumber )
{
TELSERVICE_ENTERFN( "ValidateDTMFNumberL()" )
TPtrC validDTMFChars;
validDTMFChars.Set( KValidDTMFChars );
if( aNumber )
{
for( TInt i = 0; i < aNumber->Length(); i++ )
{
if( ( validDTMFChars.Locate( (*aNumber)[i] ) == KErrNotFound ) )
{
// Invalid character found, remove it!
aNumber->Delete( i, 1 );
i--;
}
}
}
TELSERVICE_LEAVEFN( "ValidateDTMFNumberL()" )
}
//---------------------------------------------------------------------------------------
// CBrowserTelService::ParseDTMFSequencesForDlg()
//---------------------------------------------------------------------------------------
//
CArrayPtrFlat<HBufC>* CBrowserTelService::ParseDTMFSequencesForDlgL(
const TDesC* aDTMFString )
{
TELSERVICE_ENTERFN( "ParseDTMFSequencesForDlgL()" )
CArrayPtrFlat<HBufC>* parsedArray = NULL;
if( aDTMFString )
{
parsedArray = new ( ELeave ) CArrayPtrFlat<HBufC>( KParseArrayAllocation );
TLex dtmfSequence( *aDTMFString );
TChar previousChar = dtmfSequence.Peek(); // first char
while( !dtmfSequence.Eos() )
{
//
if ( dtmfSequence.Offset() ) // if not at start of line
{
TChar nextChar = dtmfSequence.Peek();
if( nextChar == '/' || nextChar == 'w' || nextChar == 'p' ||
nextChar == ',' )
{
// if the previous wait char was either 'w' or '/' then skip it
// and mark new extraction mark.
if( previousChar == 'w' || previousChar == '/' )
{
dtmfSequence.Mark();
}
else
{
parsedArray->AppendL(
dtmfSequence.RemainderFromMark().Alloc() );
dtmfSequence.Mark();
}
}
previousChar = nextChar;
}
dtmfSequence.Inc();
}
parsedArray->AppendL( dtmfSequence.RemainderFromMark().Alloc() );
}
TELSERVICE_LEAVEFN( "ParseDTMFSequencesForDlgL()" )
return parsedArray;
}
//---------------------------------------------------------------------------------------
// CBrowserTelService::ParseDTMFSequencesForDlg()
//---------------------------------------------------------------------------------------
//
CArrayPtrFlat<HBufC>* CBrowserTelService::ParseDTMFSequencesL(
const TDesC* aDTMFString )
{
TELSERVICE_ENTERFN( "ParseDTFMSequencesL()" )
CArrayPtrFlat<HBufC>* parsedArray = NULL;
if( aDTMFString )
{
parsedArray = new ( ELeave ) CArrayPtrFlat<HBufC>(
KParseArrayAllocation );
CleanupStack::PushL( parsedArray );
TLex dtmfSequence( *aDTMFString );
TChar previousChar = dtmfSequence.Peek(); // first char
while( !dtmfSequence.Eos() )
{
//
if ( dtmfSequence.Offset() ) // if not at start of line
{
TChar nextChar = dtmfSequence.Peek();
if( nextChar == '/' || nextChar == 'w' ||
nextChar == 'p' || nextChar == ',' )
{
// if the previous wait char was either 'w' or '/'
// then skip it
// and mark new extraction mark.
if( previousChar == 'w' || previousChar == '/' )
{
dtmfSequence.Mark();
}
else
{
parsedArray->AppendL(
dtmfSequence.MarkedToken().Alloc() );
dtmfSequence.Mark();
}
}
previousChar = nextChar;
}
dtmfSequence.Inc();
}
parsedArray->AppendL( dtmfSequence.RemainderFromMark().Alloc() );
CleanupStack::Pop( parsedArray );
}
TELSERVICE_LEAVEFN( "ParseDTMFSequencesL()" )
return parsedArray;
}
//---------------------------------------------------------------------------------------
// CBrowserTelService::DisplaySendDTMFDialog()
//---------------------------------------------------------------------------------------
//
TBool CBrowserTelService::DisplaySendDTMFDialog( TDes* aNumber )
{
TELSERVICE_ENTERFN( "DisplaySendDTMFDialog()" )
TBool ret = EFalse;
if( aNumber )
{
TInt length = aNumber->Length();
if( length )
{
TChar waitChar = RipWaitChar( aNumber );
switch( waitChar )
{
case '/':
case 'w':
{
ret = ETrue;
}
break;
case 'p':
case ',':
{
ret = EFalse;
}
break;
default:
{
ret = ((iDTMFAlwaysConfirm) || (!iConfirmedOnce));
}
break;
}
}
}
TELSERVICE_LEAVEFN( "DisplaySendDTMFDialog()" )
return ret;
}
//---------------------------------------------------------------------------------------
// CBrowserTelService::RipWaitChar()
//---------------------------------------------------------------------------------------
//
TChar CBrowserTelService::RipWaitChar( TDes* aNumber )
{
TELSERVICE_ENTERFN( "RipWaitChar()" )
TChar waitChar = NULL;
if( aNumber )
{
TInt length = aNumber->Length();
if( length )
{
TChar tempWaitChar = ( *aNumber )[0];
if( tempWaitChar == 'w' || tempWaitChar == '/' ||
tempWaitChar == 'p' || tempWaitChar == ',')
{
waitChar = tempWaitChar;
aNumber->Delete( 0, 1 );
}
}
}
TELSERVICE_LEAVEFN( "RipWaitChar()" )
return waitChar;
}
//---------------------------------------------------------------------------------------
// CBrowserTelService::SendDTMF()
//---------------------------------------------------------------------------------------
//
EXPORT_C TInt CBrowserTelService::SendDTMF( TDesC& aNumber,
TBool aSendDTMFAlwaysConfirm )
{
TELSERVICE_ENTERFN( "SendDTMF() synchronous" )
iRetVal = KErrNone;
TRAPD( err, SendDTMFL( aNumber, aSendDTMFAlwaysConfirm ) );
if( err )
{
ErrorHandler( err );
iRetVal = KErrCancel;
}
TELSERVICE_LEAVEFN( "SendDTMF() synchronous" )
return iRetVal;
}
//---------------------------------------------------------------------------------------
// CBrowserTelService::SendDTMFL()
//---------------------------------------------------------------------------------------
//
EXPORT_C void CBrowserTelService::SendDTMF( TRequestStatus& aStatus,
TDesC& aNumber,
TBool aSendDTMFAlwaysConfirm )
{
TELSERVICE_ENTERFN( "SendDTMF() asynchronous" )
iRetVal = KErrNone;
TRAPD( err, SendDTMFL( aStatus, aNumber, aSendDTMFAlwaysConfirm ) );
if( err )
{
TELSERVICE_WRITE_FORMAT( "Complete the request: %d", KErrInvocationError )
ErrorHandler( err );
User::RequestComplete( iUserRequestStatus, KErrInvocationError );
}
TELSERVICE_LEAVEFN( "SendDTMF() asynchronous" )
}
//---------------------------------------------------------------------------------------
// CBrowserTelService::CancelSendDTMFL()
//---------------------------------------------------------------------------------------
//
EXPORT_C void CBrowserTelService::CancelSendDTMFL()
{
TELSERVICE_ENTERFN( "CancelSendDTMF()" )
if( State() == EDialingDTMF )
{
RCall::TStatus callStatus;
User::LeaveIfError( iRCall.GetStatus( callStatus ) );
if( callStatus == RCall::EStatusConnected )
{
if( State() == EDialingDTMF )
{
Cancel();
SetState( EConnected );
}
}
}
TELSERVICE_LEAVEFN( "CancelSendDTMF()" )
}
//---------------------------------------------------------------------------------------
// CBrowserTelService::AddPBEntryL()
//---------------------------------------------------------------------------------------
//
EXPORT_C TInt CBrowserTelService::AddPBEntryL(
TDesC& aNumber,
TDesC& aName,
TDesC& aEmail )
{
TELSERVICE_ENTERFN( "AddPBEntryL()" )
CPbkContactEngine* pbkEngine = CPbkContactEngine::NewL();
CleanupStack::PushL( pbkEngine );
// Make sure a resource file is available
RPbkViewResourceFile pbkResourceFile( *CCoeEnv::Static() );
pbkResourceFile.OpenL();
CleanupClosePushL<RPbkViewResourceFile> ( pbkResourceFile );
// Step 1: Search Pb for matches and open existing or create new
TBool newContact;
CPbkContactItem* contactItem = SearchPBItemLC( *pbkEngine
, aNumber
, aEmail
, newContact );
TPtrC lastName;
TPtrC firstName;
TPtrC email;
email.Set( aEmail );
// Step 2: Set values to the correct lines
// default focused dialog line
TInt formIndex = -1;
if( JAPANESE )
// Japanese version only. See Vodafone spec:
// http://developers.vodafone.jp/dp/tool_dl/download.php?docid=120
{
TPtrC lastNameReading;
TInt yomiganaInd = aName.LocateReverse( TChar('-') );
if( yomiganaInd != KErrNotFound )
{
lastNameReading.Set( aName.Right( aName.Length() - yomiganaInd - 1 ) );
lastName.Set( aName.Left( yomiganaInd ) );
}
else
{
lastName.Set( aName );
}
SetPBEntryFieldL( EPbkFieldIdLastName, pbkEngine, contactItem, lastName, formIndex );
SetPBEntryFieldL( EPbkFieldIdLastNameReading, pbkEngine, contactItem, lastNameReading, formIndex );
}
else
{
TInt lastNameInd = aName.LocateReverse( TChar(' ') );
TBool whichtag = EFalse;
if ( lastNameInd == KErrNotFound )
{
_LIT( tag, "%20" );
lastNameInd = aName.Find( tag );
whichtag = ETrue;
}
if( lastNameInd != KErrNotFound )
{
if( lastNameInd )
{
if ( whichtag )
{
lastName.Set( aName.Right( aName.Length() - lastNameInd - 3 ) );
}
else
{
lastName.Set( aName.Right( aName.Length() - lastNameInd - 1 ) );
}
firstName.Set( aName.Left( lastNameInd ) );
}
else
{
lastName.Set( aName );
}
}
else
{
lastName.Set( aName );
}
SetPBEntryFieldL( EPbkFieldIdLastName, pbkEngine, contactItem, lastName, formIndex );
SetPBEntryFieldL( EPbkFieldIdFirstName, pbkEngine, contactItem, firstName, formIndex );
}
// common fields
SetPBEntryFieldL( EPbkFieldIdPhoneNumberStandard, pbkEngine, contactItem, aNumber, formIndex );
SetPBEntryFieldL( EPbkFieldIdEmailAddress, pbkEngine, contactItem, aEmail, formIndex );
// Step 3: Open the editor dialog
CPbkContactEditorDlg* dlg = CPbkContactEditorDlg::NewL(
*pbkEngine, *contactItem, newContact, formIndex, formIndex >= 0 );
// Execute phonebook editor
dlg->ExecuteLD();
CleanupStack::PopAndDestroy( 3 ); // contactItem, pbkResourceFile, pbkEngine
TELSERVICE_LEAVEFN( "AddPBEntryL()" )
return KErrNone;
}
//---------------------------------------------------------------------------------------
// CBrowserTelService::State()
//---------------------------------------------------------------------------------------
//
EXPORT_C TBrowserTelServiceState CBrowserTelService::State() const
{
TELSERVICE_WRITE_FORMAT( "State(): %d", iState )
return iState;
}
//---------------------------------------------------------------------------------------
// CBrowserTelService::SetState()
//---------------------------------------------------------------------------------------
//
void CBrowserTelService::SetState( TBrowserTelServiceState aState )
{
TELSERVICE_WRITE( "SetState()" )
iState = aState;
}
//---------------------------------------------------------------------------------------
// CBrowserTelService::AddObserver()
//---------------------------------------------------------------------------------------
//
EXPORT_C void CBrowserTelService::AddObserver(
MBrowserTelServiceObserver* aObserver )
{
TELSERVICE_ENTERFN( "AddObserver()" )
if( aObserver )
{
iObserverList.Append( aObserver );
}
TELSERVICE_LEAVEFN( "AddObserver()" )
}
//---------------------------------------------------------------------------------------
// CBrowserTelService::RemoveObserver()
//---------------------------------------------------------------------------------------
EXPORT_C void CBrowserTelService::RemoveObserver(
MBrowserTelServiceObserver* aObserver )
{
TELSERVICE_ENTERFN( "RemoveObserver()" )
TInt count = iObserverList.Count();
if( count )
{
TInt index = iObserverList.Find( aObserver );
if( index != KErrNotFound )
{
iObserverList.Remove( index );
iObserverList.GranularCompress();
}
}
TELSERVICE_LEAVEFN( "AddObserver()" )
}
//---------------------------------------------------------------------------------------
// CBrowserTelService::SendEmailMessageL()
//---------------------------------------------------------------------------------------
//
EXPORT_C TInt CBrowserTelService::SendEmailMessageL(
const TDesC& aToRecipients,
const TDesC& aCcRecipients,
const TDesC& aParams,
const TDesC& aBody )
{
return this->SendEmailMessageL( aToRecipients, aCcRecipients,
aParams, aBody, 0 );
}
//---------------------------------------------------------------------------------------
// CBrowserTelService::SendEmailMessageL()
//---------------------------------------------------------------------------------------
//
EXPORT_C TInt CBrowserTelService::SendEmailMessageL(
const TDesC& aToRecipients,
const TDesC& aCcRecipients,
const TDesC& aParams,
const TDesC& aBody,
TBool aLaunchEmbedded )
{
TELSERVICE_ENTERFN( "SendEmailMessageL()" )
///////////////////////////////////////////////////////////////
// Determine if mailto handled via MMS from variation mechanism
TBool sendMms( EFalse );
TInt keyVal( 0 );
CRepository* repository = CRepository::NewL( KCRUidBrowserUiLV );
CleanupStack::PushL( repository );
if(repository->Get( KBrowserMailtoSendingApp, keyVal ) == KErrNone )
{
sendMms = ( keyVal == 1 );
}
CleanupStack::PopAndDestroy( repository );
//Search for @ and .(dot) characters
TInt at = aToRecipients.Locate('@');
TInt dot = aToRecipients.Locate('.');
TInt len = aToRecipients.Length();
if(len > 0 && KErrNotFound == at && KErrNotFound == dot)
{
TELSERVICE_WRITE("CBrowserTelService::SendEmailMessageL chars @ and .(dot) are not present");
sendMms = ETrue;
//Make sure all chars are numbers only except first char '+'
TInt loopCounter = 0;
const TUint16 *ptr = aToRecipients.Ptr();
if(*ptr == '+')
{
ptr = ptr + 1;
loopCounter = 1;
}
for(loopCounter; loopCounter<len; loopCounter++)
{
if( (*ptr >= '0' && *ptr <= '9') || *ptr == ',')
{
TELSERVICE_WRITE_FORMAT("CBrowserTelService::SendEmailMessageL character: %c", *ptr );
ptr = ptr + 1;
continue;
}
else
{
TELSERVICE_WRITE_FORMAT("CBrowserTelService::SendEmailMessageL found invalid character: %c", *ptr );
TELSERVICE_WRITE("CBrowserTelService::SendEmailMessageL chars otherthan numbers are present");
sendMms = EFalse;
break;
}
}
}
if ( sendMms )
{
TELSERVICE_WRITE("CBrowserTelService::SendEmailMessageL Sending MMS message");
return SendMmsMessageL( aToRecipients, aCcRecipients, aParams, aBody, aLaunchEmbedded );
}
/////////////////////////////////
// Email editor is launched.
TInt cleanUpCount = 0;
CParaFormatLayer* paraFormat = CParaFormatLayer::NewL();
CleanupStack::PushL( paraFormat );
++cleanUpCount;
CCharFormatLayer* charFormat = CCharFormatLayer::NewL();
CleanupStack::PushL( charFormat );
++cleanUpCount;
CRichText* body = CRichText::NewL( paraFormat, charFormat );
CleanupStack::PushL( body );
++cleanUpCount;
if( aBody.Length() )
{
body->InsertL( 0, aBody );
}
else
{
body->InsertL( 0, KNullDesC );
}
CPtrC16Array* recipients = ParseRecipientsLC( aToRecipients );
++cleanUpCount;
CPtrC16Array* ccrecipients = ParseRecipientsLC( aCcRecipients );
++cleanUpCount;
CSendUi* sendUi = CSendUi::NewL();
CleanupStack::PushL( sendUi );
++cleanUpCount;
CMessageData* messageData = CMessageData::NewL();
CleanupStack::PushL( messageData );
++cleanUpCount;
messageData->SetSubjectL( &aParams );
messageData->SetBodyTextL( body );
for( TInt i = 0; i < recipients->Count(); i++ )
{
messageData->AppendToAddressL( (*recipients)[i] );
}
for( TInt j = 0; j < ccrecipients->Count(); j++ )
{
messageData->AppendCcAddressL( (*ccrecipients)[j] );
}
// check first that the selected mtm supports bodytext
/*
TSendingCapabilities caps( aBody.Size(),
aBody.Size(),
TSendingCapabilities::ESupportsBodyText );
if( sendUi->ValidateServiceL( KUidMsgTypeSMTP, caps ) )
{
sendUi->CreateAndSendMessageL( KUidMsgTypeSMTP, messageData );
} */
sendUi->CreateAndSendMessageL( KUidMsgTypeSMTP, messageData );
CleanupStack::PopAndDestroy( cleanUpCount );
TELSERVICE_LEAVEFN( "SendEmailMessageL()" )
return KErrNone;
}
//---------------------------------------------------------------------------------------
// CBrowserTelService::SendMmsMessageL()
//---------------------------------------------------------------------------------------
//
TInt CBrowserTelService::SendMmsMessageL(
const TDesC& aToRecipients,
const TDesC& aCcRecipients,
const TDesC& aParams,
const TDesC& aBody,
TBool aLaunchEmbedded )
{
TELSERVICE_ENTERFN( "SendMmsMessageL()" )
TInt cleanUpCount = 0;
// We give NULL body for the SendUi.
CRichText* body = NULL;
// We need to write body to file in order to give as a attachment
// for the SendUi.
CDesCArrayFlat* attachments = NULL;
TFileName fileName;
TFileName tempPath;
CCoeEnv* coeEnv = CCoeEnv::Static();
RFs& fs = coeEnv->FsSession();
attachments = new (ELeave) CDesCArrayFlat(1);
CleanupStack::PushL(attachments);
++cleanUpCount;
if ( aBody.Length() > 0 )
{
// Create plaintext object from body
CPlainText* text = CPlainText::NewL( CEditableText::EFlatStorage );
CleanupStack::PushL( text );
text->InsertL( 0, aBody );
TInt err = KErrNone;
RFileWriteStream writer;
tempPath.Copy(KTempDrive);
tempPath.Append(KTempPath);
err = fs.MkDirAll( tempPath );
if ( err != KErrNone && err != KErrAlreadyExists )
{
User::Leave( err );
}
writer.PushL();
User::LeaveIfError( writer.Temp( fs, tempPath, fileName, EFileWrite ) );
writer.WriteUint16L(CEditableText::EByteOrderMark);
text->ExportTextL( 0, writer,
CPlainText::EOrganiseByParagraph );
CleanupStack::PopAndDestroy( 2 ); // text, writer
attachments->AppendL( fileName );
}
// Create address arrays
CPtrC16Array* recipients = ParseRecipientsLC( aToRecipients );
++cleanUpCount;
CPtrC16Array* ccrecipients = ParseRecipientsLC( aCcRecipients );
++cleanUpCount;
TInt count = ccrecipients->Count();
if ( count > 0 )
{
for (TInt i = 0; i < count; i++)
{
recipients->AppendL( ccrecipients->At(i) );
}
}
CleanupStack::PopAndDestroy(ccrecipients);
--cleanUpCount;
ccrecipients = NULL;
CSendUi* sendUi = CSendUi::NewL();
CleanupStack::PushL( sendUi );
++cleanUpCount;
CMessageData* messageData = CMessageData::NewL();
CleanupStack::PushL( messageData );
++cleanUpCount;
messageData->SetSubjectL( &aParams );
messageData->SetBodyTextL( body );
for( TInt i = 0; i < recipients->Count(); i++ )
{
messageData->AppendToAddressL( (*recipients)[i] );
}
for( TInt j = 0; j < attachments->Count(); j++ )
{
messageData->AppendAttachmentL( (*attachments)[j] );
}
sendUi->CreateAndSendMessageL( KSenduiMtmMmsUid, messageData,
KNullUid, aLaunchEmbedded );
fs.Delete( fileName );
CleanupStack::PopAndDestroy( cleanUpCount );
TELSERVICE_LEAVEFN( "SendMmsMessageL()" )
return KErrNone;
}
//---------------------------------------------------------------------------------------
// CBrowserTelService::DisconnectActiveCSDConnectionL()
//---------------------------------------------------------------------------------------
//
EXPORT_C void CBrowserTelService::DisconnectActiveCSDConnectionL()
{
TELSERVICE_ENTERFN( "DisconnectActiveCSDConnectionL()" )
RSocketServ server;
RConnection connection;
TInt err( KErrNone );
User::LeaveIfError( server.Connect() );
CleanupClosePushL<RSocketServ>( server );
User::LeaveIfError( connection.Open( server, KAfInet ) );
CleanupClosePushL<RConnection>( connection );
TUint conns( 0 );
connection.EnumerateConnections( conns );
if( conns )
// we need to check if there is any (HS)CSD conneciton
{
TPckgBuf<TConnectionInfo> connInfo;
TBool found = EFalse;
TUint index = 1;
for( index = 1; index <= conns; ++index )
{
err = connection.GetConnectionInfo( index, connInfo );
if( err == KErrNone )
{
TApBearerType bearerType = EApBearerTypeGPRS;
// Fixing SLAA-6k52P which only happens in MAGNUM. Since
// we only need to find if there is CSD or HSCSD, we should
// not leave here
TRAP_IGNORE( bearerType = ConnectionTypeL( connInfo().iIapId ) );
if( bearerType == EApBearerTypeCSD ||
bearerType == EApBearerTypeHSCSD )
{
found = ETrue;
}
}
}
if( found )
// there is active (HS)CSD. We need to close it.
{
if( ( err = connection.Attach( connInfo,
RConnection::EAttachTypeNormal ) ) == KErrNone )
{
// disconnect
connection.Stop();
}
TELSERVICE_WRITE( "Found active (HS)CSD connection" )
}
}
CleanupStack::PopAndDestroy( 2 ); // connection, server
TELSERVICE_LEAVEFN( "DisconnectActiveCSDConnectionL()" )
User::LeaveIfError( err );
}
//---------------------------------------------------------------------------------------
// CBrowserTelService::ShowDialogL()
//---------------------------------------------------------------------------------------
//
EXPORT_C TInt CBrowserTelService::ShowDialogL(
const TDesC& aDynamicText,
const TBrowserTelServiceDlgType& aDlgType)
{
TELSERVICE_ENTERFN( "ShowDialogL()" )
TInt retVal = 0;
switch( aDlgType )
{
case EConfirmMakeCall:
{
HBufC* number = NULL;
HBufC* valNumber = NULL;
HBufC* text = NULL;
number = aDynamicText.AllocLC();
valNumber = ValidateNumberL( *number );
CleanupStack::PopAndDestroy( number ); // number;
CleanupStack::PushL( valNumber );
HBufC* name = SearchPbForMatchL( *valNumber );
if( name )
{
CleanupStack::PushL( name );
text = StringLoader::LoadL(
R_QTN_WML_WTAI_CALL_NO, *name );
CleanupStack::PopAndDestroy(); // name
CleanupStack::PushL( text );
}
else
{
text = StringLoader::LoadLC(
R_QTN_WML_WTAI_CALL_NO, *valNumber );
}
retVal = TDialerDialogs::ConfirmationDlgL(
*text, R_CONFIRMATION_DIALOG );
CleanupStack::PopAndDestroy( 2 ); // valNumber, text
}
break;
case EConfirmSendDTMF:
{
HBufC* text = StringLoader::LoadLC(
R_QTN_WML_WTAI_SEND_DTMF, aDynamicText, CEikonEnv::Static() );
retVal = TDialerDialogs::ConfirmationDlgL(
*text, R_CONFIRMATION_DIALOG );
CleanupStack::PopAndDestroy(); // text
}
break;
case EConfirmAddToPb:
{
TInt index = 0;
CAknListQueryDialog* dlg =
new( ELeave ) CAknListQueryDialog( &index );
if ( dlg->ExecuteLD( R_ADD_TO_CONTACTS_DIALOG ) )
{
return index;
}
else
{
User::Leave( KErrCancel );
}
}
break;
case ESendingDTMF:
{
HBufC* text = StringLoader::LoadLC(
R_QTN_DTMF_SENDING_WAIT_NOTE,
aDynamicText, CEikonEnv::Static() );
if( !iWaitDlg )
{
TELSERVICE_WRITE( "Create Sending DTMF wait dialog" )
iWaitDlg = new ( ELeave ) CAknWaitDialog(
reinterpret_cast<CEikDialog**>( &iWaitDlg ), ETrue );
iWaitDlg->SetCallback( this );
iWaitDlg->PrepareLC( R_SENDDTMF_DIALOG );
iWaitDlg->SetTextL( *text );
iWaitDlg->RunLD();
}
else
{
TELSERVICE_WRITE( "Update Sending DTMF wait dialog" )
iWaitDlg->SetTextL( *text ); // Just update the text
}
CleanupStack::PopAndDestroy(); // text
}
break;
default:
break;
}
TELSERVICE_LEAVEFN( "ShowDialogL()" )
return retVal;
}
//---------------------------------------------------------------------------------------
// CBrowserTelService::MakeVOIPCall()
//---------------------------------------------------------------------------------------
//
EXPORT_C TInt CBrowserTelService::MakeVOIPCall( TDesC& aNumber,
TBool aSendDTMFAlwaysConfirm )
{
TELSERVICE_ENTERFN( "MakeVOIPCall() synchronous" )
TInt retVal( KErrNone );
iRetVal = KErrNone;
// Flag to indicate that synchronous method was called
iSynch = ETrue;
TBool voipCall = ETrue;
TRAP( retVal, MakeCallL( aNumber, aSendDTMFAlwaysConfirm, voipCall ) );
if( retVal != KErrNone )
{
ErrorHandler( retVal );
retVal = KErrCancel;
}
iSynch = EFalse;
TELSERVICE_LEAVEFN( "MakeVOIPCall() synchronous" )
return retVal;
}
//---------------------------------------------------------------------------------------
// CBrowserTelService::DoCancel()
//---------------------------------------------------------------------------------------
//
void CBrowserTelService::DoCancel()
{
TELSERVICE_ENTERFN( "DoCancel()" )
switch( State() )
{
case EDialing:
{
iRCall.DialCancel();
}
break;
case EDialingDTMF:
{
iRAdvGsmPhone.StopDTMFTone();
if( iInternalDTMFWaitStarted )
{
// We have to hold on a bit so that the CSendAppUi is
// properly initialized
iIdle->Start( TCallBack( IdleCallback,this ) );
}
}
break;
case EConnected:
{
}
break;
case EIdle:
default:
break;
}
TELSERVICE_LEAVEFN( "DoCancel()" )
}
//---------------------------------------------------------------------------------------
// CBrowserTelService::RunL()
//---------------------------------------------------------------------------------------
//
void CBrowserTelService::RunL()
{
TELSERVICE_ENTERFN( "CBrowserTelService::RunL()" )
RCall::TStatus callStatus;
callStatus = RCall::EStatusUnknown;
iRCall.GetStatus( callStatus );
TInt status = iStatus.Int();
TELSERVICE_WRITE_FORMAT( "status: %d", status );
TELSERVICE_WRITE_FORMAT( "callStatus: %d", callStatus );
if ( status != KErrNone )
{
TELSERVICE_WRITE_FORMAT( "RunL() - iStatus error: %d", status )
HandleError( status );
return;
}
if( status == KErrNone )
{
switch( State() )
{
// the call is now active
case EDialing:
{
TELSERVICE_WRITE( "RunL - KDialing" )
BringBrowserToForeground();
if( callStatus == RCall::EStatusConnected )
{
SetState( EConnected );
// Notify the observer
NotifyObservers();
if( iSynch )
{
iWait.AsyncStop(); // stop the wait loop.
// Now DoMakeCallL will return
}
else
{ // async variant was called
if( HandleInternalSendDTMFL() == EFalse )
{ // nothing to handle anymore
// Complete the request
TELSERVICE_WRITE_FORMAT(
"Complete the request: %d",KErrNone )
User::RequestComplete(
iUserRequestStatus, KErrNone );
}
}
}
}
break;
// the DTMF tones have been sent
case EDialingDTMF:
{
TELSERVICE_WRITE( "RunL - KDialingDTMF" )
iRAdvGsmPhone.Close();
if( HandleInternalSendDTMFL() == EFalse )
{ // nothing to handle anymore
SetState( EConnected );
// Notify the observer
NotifyObservers();
if( iSynch || iInternalDTMFWaitStarted )
{
iWait.AsyncStop(); // stop the wait loop.
//Now SendDTMFL() will return
}
else
{
// Asynchronous method was called.
if( iWaitDlg )
{
iWaitDlg->ProcessFinishedL();
}
// Complete the request
TELSERVICE_WRITE_FORMAT(
"Complete the request: %d",KErrNone )
User::RequestComplete( iUserRequestStatus, KErrNone );
}
}
}
break;
// the call has been active, but
// the caller has hanged up.
case EConnected:
{
TELSERVICE_WRITE( "RunL - EPhoneAnswered,EConnected" )
if( iCallStatus == RCall::EStatusIdle ||
iCallStatus == RCall::EStatusHangingUp )
{
SetStateIdleAndNotifyObservers();
}
}
break;
case EIdle:
default:
{
TELSERVICE_WRITE( "RunL - Default" )
break;
}
}
}
else
{
if ( State() == EDialing )
{
BringBrowserToForeground();
// If there is not activate voice call on
// changes state to EIdle.
CheckIsThereActivateVoiceCallOnL();
// MakeCall must return error code Canceled in this case.
iRetVal = KErrCancel;
if( iSynch )
{
iWait.AsyncStop(); // stop the wait loop.
// Now DoMakeCallL will return
}
else
{ // async variant was called
if( HandleInternalSendDTMFL() == EFalse )
{ // nothing to handle anymore
// Complete the request
TELSERVICE_WRITE_FORMAT(
"Complete the request: %d",KErrNone )
User::RequestComplete(
iUserRequestStatus, KErrNone );
}
}
}
}
TELSERVICE_LEAVEFN("CBrowserTelService::RunL()")
}
//---------------------------------------------------------------------------------------
// CBrowserTelService::CloseAllSessions()
//---------------------------------------------------------------------------------------
//
void CBrowserTelService::CloseAllSessions()
{
TELSERVICE_ENTERFN( "CloseAllSessions()" )
iRCall.Close();
iRLine.Close();
iRPhone.Close();
iRTelServer.Close();
TELSERVICE_LEAVEFN( "CloseAllSessions()" )
}
//---------------------------------------------------------------------------------------
// CBrowserTelService::SetStateIdleAndNotifyObserver()
//---------------------------------------------------------------------------------------
//
void CBrowserTelService::SetStateIdleAndNotifyObservers()
{
TELSERVICE_ENTERFN("SetStateIdleAndNotifyObservers()")
SetState( EIdle );
CloseAllSessions();
// Notify the observers
NotifyObservers();
TELSERVICE_LEAVEFN( "SetStateIdleAndNotifyObservers()" )
}
//---------------------------------------------------------------------------------------
// CBrowserTelService::NotifyObservers()
//---------------------------------------------------------------------------------------
//
void CBrowserTelService::NotifyObservers()
{
TELSERVICE_ENTERFN( "NotifyObservers()" )
TInt count = iObserverList.Count();
for( TInt i = 0; i < count ;i++ )
{
iObserverList[i]->BrowserTelServiceEvent( State() );
}
TELSERVICE_LEAVEFN( "NotifyObservers()" )
}
//---------------------------------------------------------------------------------------
// CBrowserTelService::NotifyObservers()
//---------------------------------------------------------------------------------------
//
void CBrowserTelService::NotifyObservers( TBrowserTelServiceError aError )
{
TELSERVICE_ENTERFN( "NotifyObservers( TBrowserTelServiceError )" )
TInt count = iObserverList.Count();
for( TInt i = 0; i < count; i++)
{
iObserverList[i]->BrowserTelServiceError( aError );
}
TELSERVICE_LEAVEFN( "NotifyObservers(TBrowserTelServiceError)" )
}
//---------------------------------------------------------------------------------------
// CBrowserTelService::HandleError()
//
//---------------------------------------------------------------------------------------
//
void CBrowserTelService::HandleError( TInt aError )
{
TELSERVICE_ENTERFN( "HandleError()" )
switch( State() )
{
case EDialingDTMF:
{
iRAdvGsmPhone.Close(); // close RAdvGsmPhone session.
NotifyObservers( ESendDTMFFailed );
SetState( EConnected );
NotifyObservers();
}
break;
case EDialing:
case EConnected:
{
Cancel();
}
break;
case EIdle:
default:
break;
}
iRetVal = aError;
if( iSynch || iInternalDTMFWaitStarted )
{
iWait.AsyncStop(); // stop the wait loop.
// Now synchronous method will return
}
else
{
// Asynchronous method was called.
// Complete the request
TELSERVICE_WRITE_FORMAT( "Complete the request: %d", aError )
User::RequestComplete( iUserRequestStatus, aError );
}
TELSERVICE_LEAVEFN( "HandleError()" )
}
//---------------------------------------------------------------------------------------
// CBrowserTelService::EtelWatcherEvent()
//---------------------------------------------------------------------------------------
//
void CBrowserTelService::BrowserTelServiceEtelWatcherEvent(
RCall::TStatus& aStatus )
{
TELSERVICE_ENTERFN( "EtelWatcherEvent()" )
if( aStatus == RCall::EStatusIdle )
{
// the call recepient has hung up without answering the call,
// so lets reset our state and notify observers
Cancel();
SetStateIdleAndNotifyObservers();
iRetVal = KErrUserBusy;
if( iSynch )
{
iWait.AsyncStop(); // stop the wait loop.
// Now DoMakeCallL will return
}
else
{
// Asynchronous method was called.
// Complete the request
TELSERVICE_WRITE_FORMAT( "Complete the request: %d", KErrUserBusy )
User::RequestComplete( iUserRequestStatus, KErrUserBusy );
}
}
TELSERVICE_LEAVEFN( "EtelWatcherEvent()" )
}
//---------------------------------------------------------------------------------------
// CBrowserTelService::ConnectionStageAchievedL()
//---------------------------------------------------------------------------------------
//
void CBrowserTelService::ConnectionStageAchievedL()
{
TELSERVICE_ENTERFN( "ConnectionStageAchievedL()" )
iAgentDisconnected = ETrue;
if( iWait.IsStarted() )
{
iWait.AsyncStop();
}
TELSERVICE_LEAVEFN( "ConnectionStageAchievedL()" )
}
//---------------------------------------------------------------------------------------
// CBrowserTelService::SearchPbForMatchL()
//---------------------------------------------------------------------------------------
//
HBufC* CBrowserTelService::SearchPbForMatchL(
const TDesC& aPhoneNumber )
{
TELSERVICE_ENTERFN( "SearchPbForMatchL()" )
HBufC* matchingName = NULL;
// Create phonebook engine
CPbkContactEngine* pbkEngine = CPbkContactEngine::NewL();
CleanupStack::PushL( pbkEngine );
// Make sure a resource file is available
RPbkViewResourceFile pbkResourceFile( *CCoeEnv::Static() );
pbkResourceFile.OpenL();
CleanupClosePushL<RPbkViewResourceFile> ( pbkResourceFile );
CContactIdArray* idArray = SearchPbForMatchLC( *pbkEngine
,aPhoneNumber
,EPhoneNumber
);
if( idArray->Count() )
{
// retrive contact's full matching name
CPbkContactItem* item = pbkEngine->ReadMinimalContactLC( (*idArray)[0] );
matchingName = item->GetContactTitleOrNullL();
CleanupStack::PopAndDestroy( item );
}
CleanupStack::PopAndDestroy( 3 ); // idArray, pbkResourceFile, pbkEngine
TELSERVICE_LEAVEFN("SearchPbForMatchL()")
return matchingName;
}
//---------------------------------------------------------------------------------------
// CBrowserTelService::SearchPbForMatchLC()
//---------------------------------------------------------------------------------------
//
CContactIdArray* CBrowserTelService::SearchPbForMatchLC(
CPbkContactEngine& aPbkEngine,
const TDesC& aToMatch,
const TMatchType& aMatchType )
{
TELSERVICE_ENTERFN( "SearchPbForMatchLC()" )
CContactIdArray* idArray = NULL;
if( aMatchType == EPhoneNumber )
{
idArray = aPbkEngine.MatchPhoneNumberL( aToMatch, aToMatch.Length() );
}
else if( aMatchType == EEmail )
{
CPbkFieldIdArray* findFrom = new( ELeave ) CPbkFieldIdArray;
CleanupStack::PushL( findFrom );
findFrom->AppendL( EPbkFieldIdEmailAddress );
idArray = aPbkEngine.FindLC( aToMatch, findFrom );
CleanupStack::Pop( idArray );
CleanupStack::PopAndDestroy( findFrom );
}
CleanupStack::PushL( idArray );
TELSERVICE_LEAVEFN( "SearchPbForMatchLC()" )
return idArray;
}
//---------------------------------------------------------------------------------------
// CBrowserTelService::IdleCallback()
//---------------------------------------------------------------------------------------
//
TInt CBrowserTelService::IdleCallback( TAny* aTelService )
{
TELSERVICE_ENTERFN( "IdleCallback()" )
( ( CBrowserTelService* ) aTelService )->DoIdleCallback();
TELSERVICE_LEAVEFN( "IdleCallback()" )
return EFalse; // return false since we don't want to run idle again
}
//---------------------------------------------------------------------------------------
// CBrowserTelService::IdleCallback()
//---------------------------------------------------------------------------------------
//
void CBrowserTelService::DoIdleCallback()
{
TELSERVICE_WRITE( "DoIdleCallback()" )
iWait.AsyncStop();
}
// ---------------------------------------------------------
// CBrowserTelService::DialogDismissedL
// ---------------------------------------------------------
//
void CBrowserTelService::DialogDismissedL( TInt aButtonId )
{
TELSERVICE_ENTERFN( "DialogDismissedL()" )
if ( aButtonId == EAknSoftkeyCancel )
{
Cancel();
}
iWaitDlg = NULL; // Dialog will delete itself; prevent DoCancel
// deleting it beforehand.
TELSERVICE_LEAVEFN( "DialogDismissedL()" )
}
// ---------------------------------------------------------
// CBrowserTelService::HandleInternalSendDTMFL
// ---------------------------------------------------------
//
TBool CBrowserTelService::HandleInternalSendDTMFL()
{
TELSERVICE_ENTERFN( "HandleInternalSendDTMFL()" )
iSynch = EFalse; // Reset to EFalse since the HandleInternalSendDTMFL()
// is asynchronous!
if( !(iSendableDTMFNumbers && iDlgDTMFNumbers) )
{
return EFalse;
}
TBool retVal = EFalse;
CRepository* repository = CRepository::NewL( KCRUidBrowser );
CleanupStack::PushL (repository );
repository->Get( KBrowserConfirmedDTMFOnce, iConfirmedOnce );
if( iSendableDTMFNumbers->Count() > 0 && iDlgDTMFNumbers->Count() > 0 )
{
TELSERVICE_WRITE( "we have dtmf numbers to send" )
TInt sendDTMF = 1;
TPtr sendableNumberPtr = iSendableDTMFNumbers->At(0)->Des();
TPtr dlgNumberPtr = iDlgDTMFNumbers->At(0)->Des();
if( DisplaySendDTMFDialog( &dlgNumberPtr ) )
{
if( dlgNumberPtr.Length() > 0 )
{
TELSERVICE_WRITE( "display send dtmf dialog" )
if( iDTMFAlwaysConfirm )
{
sendDTMF = ShowDialogL( dlgNumberPtr,EConfirmSendDTMF );
}
else if( iDTMFAlwaysConfirm == EFalse &&
iConfirmedOnce == EFalse )
{
sendDTMF = ShowDialogL( dlgNumberPtr,
EConfirmSendDTMF );
iConfirmedOnce = ETrue;
repository->Set( KBrowserConfirmedDTMFOnce, iConfirmedOnce );
}
else
{
sendDTMF = 1;
}
}
else
{
TELSERVICE_WRITE("don't display send dtmf dialog dlgNumberPtr.Length() < 0")
sendDTMF = 0;
}
}
else
{
TELSERVICE_WRITE( "don't display send dtmf dialog" )
if( dlgNumberPtr.Length() > 0 )
{
TELSERVICE_WRITE( "start dtmf wait timer" )
RTimer timer;
TRequestStatus timerStatus; // request status
// associated with timer
timer.CreateLocal(); // create for this thread
timer.After( timerStatus, KTimerDelay ); // pause for 2,5
// seconds
User::WaitForRequest( timerStatus );
timer.Close();
}
else
{
sendDTMF = 0;
}
}
if( sendDTMF )
{
TELSERVICE_WRITE( "Send the DTMF" )
RipWaitChar( &sendableNumberPtr );
ValidateDTMFNumberL( &sendableNumberPtr );
// Send DTMF tones
DoSendDTMFL( sendableNumberPtr );
TELSERVICE_WRITE( "DoSendDTMFL() ok!" )
ShowDialogL( dlgNumberPtr, ESendingDTMF );
retVal = ETrue;
}
iSendableDTMFNumbers->Delete(0);
iSendableDTMFNumbers->Compress();
iDlgDTMFNumbers->Delete(0);
iDlgDTMFNumbers->Compress();
}
CleanupStack::PopAndDestroy( repository );
TELSERVICE_LEAVEFN( "HandleInternalSendDTMFL()" )
return retVal;
}
// ---------------------------------------------------------------------------
// CBrowserTelService::BringBrowserToForeground
// ---------------------------------------------------------------------------
//
void CBrowserTelService::BringBrowserToForeground()
{
TELSERVICE_ENTERFN( "BringBrowserToForeground()" )
TApaTaskList taskList( CEikonEnv::Static()->WsSession() );
TUid wapUid = KUidBrowserApplication;
TApaTask task = taskList.FindApp( wapUid );
task.BringToForeground();
TELSERVICE_LEAVEFN( "BringBrowserToForeground()" )
}
// ---------------------------------------------------------------------------
// CBrowserTelService::CheckIsThereActivateVoiceCallOnL
// ---------------------------------------------------------------------------
//
void CBrowserTelService::CheckIsThereActivateVoiceCallOnL()
{
RTelServer::TPhoneInfo info;
RPhone::TLineInfo lineInfo;
RLine::TLineInfo callInfo;
// Connect to the telephony server and load the TSY.
User::LeaveIfError( iRTelServer.Connect() );
User::LeaveIfError( iRTelServer.LoadPhoneModule( KMmTsyModuleName ) );
// Get the details for the first (and only) phone.
User::LeaveIfError( iRTelServer.GetPhoneInfo( 0, info ) );
// Open the phone.
iRPhone.Close();
User::LeaveIfError( iRPhone.Open( iRTelServer, info.iName ) );
// Get the information for the voice line, line 0.
User::LeaveIfError( iRPhone.GetLineInfo( 0, lineInfo ) );
if( lineInfo.iStatus > RCall::EStatusIdle )
{
TELSERVICE_WRITE( "There's an active call" );
// Open the line. iName will now be "VoiceLine1".
iRLine.Close();
User::LeaveIfError( iRLine.Open( iRPhone, KMmTsyVoice1LineName ) );
TInt count;
// Gets the number of calls opened from a line.
User::LeaveIfError( iRLine.EnumerateCall( count ) );
if ( count >= 1 )
{
SetState( EConnected );
User::LeaveIfError( iRLine.GetInfo( callInfo ) );
iRCall.Close();
User::LeaveIfError( iRCall.OpenExistingCall( iRLine,
callInfo.iNameOfLastCallAdded ) );
}
else
{
SetState( EIdle );
}
}
else
{
TELSERVICE_WRITE( "No active call" );
SetState( EIdle );
}
}
// ---------------------------------------------------------------------------
// CBrowserTelService::CheckDTMFNumber
// ---------------------------------------------------------------------------
//
void CBrowserTelService::CheckDTMFNumberL( TDesC& aNumber )
{
TBool multiw = EFalse;
TBool multikeno = EFalse;
for ( TInt i = 0; i < aNumber.Length(); i++ )
{
if( (KValidDTMFChars().Locate( aNumber[i] ) ) == KErrNotFound )
{
User::Leave( KErrArgument );
}
else
{
if( aNumber[i] == 'w' )
{
if( multiw )
{
User::Leave( KErrArgument );
}
multiw = ETrue;
}
else if( aNumber[i] == '/' )
{
if( multikeno )
{
User::Leave( KErrArgument );
}
multikeno = ETrue;
}
}
}
}
// ---------------------------------------------------------------------------
// CBrowserTelService::CheckDTMFNumber
// ---------------------------------------------------------------------------
//
CPbkContactItem* CBrowserTelService::SearchPBItemLC( CPbkContactEngine& aPbkEngine,
TDesC& aNumber,
TDesC& aEmail,
TBool& aNewContact )
{
CPbkContactItem* contactItem = NULL;
CContactIdArray* idArrayPhoneNr = SearchPbForMatchLC( aPbkEngine, aNumber, EPhoneNumber );
CContactIdArray* idArrayEmail = SearchPbForMatchLC( aPbkEngine, aEmail, EEmail );
aNewContact = ETrue;
if( idArrayPhoneNr->Count() && aNumber.Length() )
{
// Open existing
if ( ShowDialogL( aNumber, EConfirmAddToPb ) )
{
contactItem = aPbkEngine.OpenContactL( ( *idArrayPhoneNr )[0] );
aNewContact = EFalse;
}
else
{
// Create a new contact
contactItem = aPbkEngine.CreateEmptyContactL();
}
}
else if( idArrayEmail->Count() && aEmail.Length() )
{
if ( ShowDialogL( aEmail, EConfirmAddToPb ) )
{
// Open existing
contactItem = aPbkEngine.OpenContactL( ( *idArrayEmail )[0] );
aNewContact = EFalse;
}
else
{
// Create a new contact
contactItem = aPbkEngine.CreateEmptyContactL();
}
}
else
{
// Create a new contact
contactItem = aPbkEngine.CreateEmptyContactL();
}
CleanupStack::PopAndDestroy( 2 ); // idArrayEmail,idArrayPhoneNr
CleanupStack::PushL( contactItem );
return contactItem;
}
// ---------------------------------------------------------------------------
// CBrowserTelService::SetPBEntryField()
// ---------------------------------------------------------------------------
//
void CBrowserTelService::SetPBEntryFieldL( TInt aField,
CPbkContactEngine* aPbkEngine,
CPbkContactItem* aContactItem,
const TPtrC& aFieldValue,
TInt& aFormIndex )
{
if( aFieldValue.Length() )
{
TPbkContactItemField *dataField = aContactItem->FindField( aField );
if( !dataField )
{
CPbkFieldInfo* newFieldType = NULL;
for ( TInt i = 0; !newFieldType &&
i < aPbkEngine->FieldsInfo().Count(); ++i )
{
CPbkFieldInfo* fieldInfo = aPbkEngine->FieldsInfo()[i];
if( fieldInfo->FieldId() == aField )
{
// we found the proper field. Yeah!
newFieldType = fieldInfo;
}
}
// add new field
dataField = aContactItem->AddOrReturnUnusedFieldL( *newFieldType );
}
if( dataField )
{
// Put the data to the field
dataField->TextStorage()->SetTextL( aFieldValue );
if( aFormIndex == -1 )
{
aFormIndex = aContactItem->FindFieldIndex( *dataField );
}
}
}
}
// ---------------------------------------------------------------------------
// CBrowserTelService::ParseRecipientsLC
// ---------------------------------------------------------------------------
//
CPtrC16Array* CBrowserTelService::ParseRecipientsLC( const TDesC& aRecipients )
{
CPtrC16Array* recips = new( ELeave ) CPtrC16Array( 2 );
CleanupStack::PushL( recips );
if( aRecipients.Length() )
{
TPtrC tempRec( aRecipients );
do
{
int posComma = tempRec.Find( _L(",") );
if( posComma != KErrNotFound )
{
recips->AppendL( tempRec.Left( posComma ) );
tempRec.Set( tempRec.Right( tempRec.Length() - posComma - 1 ) );
}
else
{
recips->AppendL( tempRec );
tempRec.Set( KNullDesC );
}
}while( tempRec.Length() );
}
return recips;
}
// ---------------------------------------------------------------------------
// CBrowserTelService::ConnectionTypeL
// ---------------------------------------------------------------------------
//
TApBearerType CBrowserTelService::ConnectionTypeL( TUint aApId )
{
CCommsDatabase* commsDb = CCommsDatabase::NewL( EDatabaseTypeIAP );
CleanupStack::PushL( commsDb );
CApDataHandler* apDataHandler = CApDataHandler::NewLC( *commsDb );
TUint32 apId = 0;
CApUtils* apUtils = CApUtils::NewLC( *commsDb );
apId = apUtils->WapIdFromIapIdL( aApId );
CleanupStack::PopAndDestroy(); //apUtils
apUtils = NULL;
CApAccessPointItem* apItem = CApAccessPointItem::NewLC();
apDataHandler->AccessPointDataL( apId, *apItem );
TApBearerType bearerType = apItem->BearerTypeL();
CleanupStack::PopAndDestroy( 3 ); // apItem, apDataHandler, commsDb
return bearerType;
}
//---------------------------------------------------------------------------------------
// CBrowserTelService::ErrorHandler()
//---------------------------------------------------------------------------------------
//
void CBrowserTelService::ErrorHandler( TInt aErrorId )
{
TELSERVICE_WRITE_FORMAT( "Error handler: %d", aErrorId );
if( aErrorId == KErrCancel )
{
return;
}
TInt i;
for( i = 0; KErrorConvTable[i][0] && KErrorConvTable[i][0] != aErrorId; ++i ){};
if( KErrorConvTable[i][0] )
{
// If KErrorConvTable[i][1] is 0 it's already handled by the system
if( KErrorConvTable[i][1] )
{
TRAP_IGNORE( iErrorUi->ShowGlobalErrorNoteL( -(KErrorConvTable[i][1] + KKimonoBase )) );
}
}
else
// global error id is received
{
TRAP_IGNORE( iErrorUi->ShowGlobalErrorNoteL( aErrorId ) );
}
}
#ifdef __BROWSER_TEL_SERVICES_CALLUI__
//---------------------------------------------------------------------------------------
// CBrowserTelService::HandleNotifyL()
//---------------------------------------------------------------------------------------
//
TInt CBrowserTelService::HandleNotifyL( TInt /*aCmdId*/,
TInt /*aEventId*/,
CAiwGenericParamList& /*aEventParamList*/,
const CAiwGenericParamList& /*aInParamList*/ )
{
TELSERVICE_ENTERFN("CBrowserTelService::HandleNotifyL");
if( iSynch && iWait.IsStarted() )
{
iWait.AsyncStop(); // stop the wait loop.
// Now DoMakeCallL will return
}
else
{
// The client is not interested what happened!
iSynch = EFalse; // Just in case not to start iWait after ExecuteServiceCmdL
if( iUserRequestStatus )
{
User::RequestComplete( iUserRequestStatus, KErrNone );
}
}
TELSERVICE_LEAVEFN( "CBrowserTelService::HandleNotifyL" );
return KErrNone;
}
#endif // __BROWSER_TEL_SERVICES_CALLUI__
// ================= OTHER EXPORTED FUNCTIONS ==============