diff -r ebe688cedc25 -r 7fdbb852d323 messagingappbase/sendui/genericmtmplugin/src/genericmtmplugin.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/messagingappbase/sendui/genericmtmplugin/src/genericmtmplugin.cpp Wed Sep 01 12:31:54 2010 +0100 @@ -0,0 +1,1536 @@ +/* +* Copyright (c) 2006 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: SendUI sending service provider that manages all MTM based +* sending services. +* +*/ + + + +#include +#include // CClientMtmRegistry +#include +#include +#include +#include // CBaseMtmUi +#include +#include // MTM UI registery +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include // CAknWaitDialog +#include +#include +#include +#include +#include +#include +#include +#include // KMsgBioUidVCard, KMsgBioUidVCalendar +#include +#include // EMtudCommandSendAs +#include // Feature Manager +#include +#include + +#include +#include +#include +#include +#include +#include +#include +#include "SendUiOperationWait.h" +#include "SendUiLog.h" // Logging +#include "genericmtmplugin.h" +#include "SendUiFileRightsEngine.h" +#include "SendUiDummyMtm.h" +#include "CSendUiAttachment.h" +#include "GenericMtmPluginUids.hrh" + +const TInt KSendUiProgressStringSize = 256; +const TInt KSendUiRichTextStoreGranularity = 512; +// For address information separation (start) +const TUint KSendUiMsgAddressStartChar ('<'); +// For address information separation (end) +const TUint KSendUiMsgAddressEndChar ('>'); + +const TUint KSendUiFeatureSFI = 0x2; +const TUint KSendUiFeatureMMS = 0x4; +const TUint KSendUiFeatureSelectableEmail = 0x8; + +const TUint KSeconds = 1000000; +const TUid KMailTechnologyTypeUid = { 0x10001671 }; +const TUid KUidMsgTypeCmailMtmVal = { 0x2001f406 }; //CMail mtmuid + +// ======== LOCAL FUNCTIONS ======== + +// ----------------------------------------------------------------------------- +// Two-phased constructor. +// ----------------------------------------------------------------------------- +// +CGenericMtmPlugin* CGenericMtmPlugin::NewL( TSendingServiceParams* aParams ) + { + CGenericMtmPlugin* self = new(ELeave) CGenericMtmPlugin( aParams->iCoeEnv, aParams->iSingleton ); + + CleanupStack::PushL(self); + self->ConstructL(); + CleanupStack::Pop(self); + + return self; + } + +// ----------------------------------------------------------------------------- +// Destructor +// ----------------------------------------------------------------------------- +// +CGenericMtmPlugin::~CGenericMtmPlugin() + { + iServiceArray.ResetAndDestroy(); + iServiceArray.Close(); + + delete iMtmUi; + delete iClientMtm; + delete iStore; + } + + +// --------------------------------------------------------- +// CGenericMtmPlugin::InitializeSendingL +// --------------------------------------------------------- +// +TBool CGenericMtmPlugin::InitializeSendingL( ) + { + LOGTEXT(_L8("CGenericMtmPlugin::InitializeSendingL >>")); + + if ( iIsSending ) + { + LOGTEXT(_L8("CGenericMtmPlugin::Sending canceled, previous sending in progress.")); + return EFalse; + } + + // Check if MMC mounted or switched to another MMC + TDriveUnit currentDrive = iSingleton.MsvSessionL().CurrentDriveL(); + + if ( currentDrive != EDriveC ) + { + TBool storeOnMMC( EFalse ); + TRAPD ( error, storeOnMMC = iSingleton.MsvSessionL().MessageStoreDrivePresentL( ) ); + if ( !iSingleton.MsvSessionL().DriveContainsStoreL( currentDrive ) || !storeOnMMC || error ) + { + //Change message store to phones internal memory(EDriveC) + MsvUiServiceUtilitiesInternal::ChangeMessageStoreToPhoneL( iSingleton.MsvSessionL() ); + } + } + + LOGTEXT(_L8("CGenericMtmPlugin::InitializeSendingL <<")); + + return ETrue; + } + +// ----------------------------------------------------------------------------- +// Populates given list with the services provided by this plugin. +// The ownership of the pointed objects remains. +// ----------------------------------------------------------------------------- +// +void CGenericMtmPlugin::PopulateServicesListL( + RPointerArray& aList ) + { + ScanMtmsL( iServiceArray ); + + TInt i = iServiceArray.Count(); + while( i-- ) + { + aList.Append( iServiceArray[i]); + } + } + +// --------------------------------------------------------- +// CGenericMtmPlugin::CreateAndSendMessageL +// --------------------------------------------------------- +// +void CGenericMtmPlugin::CreateAndSendMessageL( + TUid aMtmUid, + const CMessageData* aMessageData, + TBool aLaunchEditorEmbedded ) + { + LOGTEXT(_L8("CGenericMtmPlugin::CreateAndSendMessageL >>")); + + if ( aMtmUid != KSenduiMtmBtUid && + MsvUiServiceUtilities::DiskSpaceBelowCriticalLevelL( + iSingleton.MsvSessionL(), 0 ) ) + { + User::Leave(KErrDiskFull); + } + + TUid tempUid( KNullUid ); + if ( aMtmUid == KSenduiMtmSmsUid || + aMtmUid == KSenduiMtmMmsUid ) + { + tempUid = aMtmUid; + aMtmUid = KSenduiMtmUniMessageUid; + // TODO: Use original MTM for checking attachments? + // TODO: Use original MTM for "InitializeSending" (does some + // SmartMessaging checks)? + } + TMsvId service= KMsvUnkownServiceIndexEntryIdValue; + TBool onlineSharing = EFalse; + TBool doContinue = EFalse; + + iClientMtm = iSingleton.ClientMtmRegistryL().NewMtmL( aMtmUid ); + iMtmUi = iSingleton.MtmUiRegistryL().NewMtmUiL( *iClientMtm ); + + if ( IsSupported( KSendUiFeatureSelectableEmail ) ) + { + // from OnlineMtm.rss, mtm_type_uid + onlineSharing = ( aMtmUid == KSenduiMtmOnlineAlbumUid) ? + ETrue : EFalse; + service = GetAndValidateServiceL( aMtmUid, aLaunchEditorEmbedded, + doContinue ); + if( service == KMsvUnkownServiceIndexEntryIdValue && + !onlineSharing ) + { + // cancel pressed on "selecta email account" query + // OR SMTP UID is provided, + // but no cmail mailbox is not configured, shonw note to user to + // configured mailbox and return from here. + return; + } + } + TInt cleanupItems(0); + + if ( !InitializeSendingL( ) ) + { + return; + } + + CArrayPtrFlat* attachments = NULL; + // Get attachments + if ( aMessageData ) + { + attachments = CSendUiAttachment::InitAttachmentArrayLCC( + aMessageData->AttachmentArray(), + aMessageData->AttachmentHandleArray(), + iCoeEnv.FsSession() ); + cleanupItems += 2; + } + + // Ensures proper sending state if leave happens. + iIsSending = ETrue; + CleanupStack::PushL(TCleanupItem(ResetIsSending, (TAny*)&iIsSending)); + cleanupItems++; + + //iClientMtm = iSingleton.ClientMtmRegistryL().NewMtmL( aMtmUid ); + //iMtmUi = iSingleton.MtmUiRegistryL().NewMtmUiL( *iClientMtm ); + + CBaseMtmUiData* mtmUiData = iSingleton.MtmUiDataRegistryL().NewMtmUiDataLayerL( aMtmUid ); + CleanupStack::PushL( mtmUiData ); + cleanupItems++; + + if ( aMessageData && + !ValidateAttachmentsL( + aMtmUid, + *mtmUiData, + attachments )) + { + // User canceled sending. + CleanupStack::PopAndDestroy( cleanupItems ); // TCleanupItem + return; + } + + // Show wait note if needed + TBool showWaitNote = EFalse; + if ( aMessageData ) + { + showWaitNote = + IsWaitNoteNeededL( aMtmUid, *aMessageData, attachments->Count() ); + + if ( showWaitNote ) + { + ShowWaitNoteLC(); + cleanupItems++; + } + } + TBool success = EFalse; + if ( IsSupported( KSendUiFeatureSelectableEmail ) ) + { + if ( !onlineSharing ) + { + if ( doContinue ) + { + CreateMessageL( aMtmUid, service ); + //If doContinue, service already validated to be launched + //embedded + success = ETrue; + } + } + else + { + success = CreateMessageL( aMtmUid, aLaunchEditorEmbedded ); + } + } + else + { + success = CreateMessageL( aMtmUid, aLaunchEditorEmbedded ); + } + + if ( success && tempUid != KNullUid ) + { + TMsvEntry entry = iClientMtm->Entry().Entry(); + TUniMsvEntry::SetCurrentMessageType( + entry, + tempUid == KSenduiMtmSmsUid + ? EUniMessageCurrentTypeSms + : EUniMessageCurrentTypeMms ); + TUniMsvEntry::SetMessageTypeLocked( entry, ETrue ); + iClientMtm->Entry().ChangeL( entry ); + } + + // Set message data + if ( aMessageData && success) + { + SetRecipientsL( aMtmUid, *aMessageData ); + SetBodyL( *mtmUiData, *aMessageData, attachments ); + + if ( attachments->Count() > 0 ) + { + if ( aMtmUid == KSenduiMtmBtUid ) + { + // Bluetooth sending over AIW + SendBtMessageL( attachments ); + CleanupStack::PopAndDestroy( cleanupItems ); // TCleanupItem + return; + } + else + { + success = AddAttachmentsL( *mtmUiData, attachments ); + } + } + + if ( success && ( aMtmUid == KSenduiMtmSmtpUid || + aMtmUid == KSenduiMtmMmsUid || + aMtmUid == KSenduiMtmUniMessageUid || + aMtmUid == KUidMsgTypeCmailMtmVal )) + { + HBufC* subject = aMessageData->Subject().AllocLC(); + cleanupItems++; + iClientMtm->SetSubjectL( *subject ); + } + } + if ( aMtmUid == KSenduiMtmBtUid ) + { + success = EFalse; // bluetooth can launch editor only from SendBtMessageL + } + if ( success ) + { + TInt attachmentsCount = attachments ? attachments->Count(): 0; + LaunchEditorL( attachmentsCount, aLaunchEditorEmbedded ); + } + + CleanupStack::PopAndDestroy( cleanupItems ); // TCleanupItem, attachments + LOGTEXT(_L8("CGenericMtmPlugin::CreateAndSendMessageL <<")); + } + +// --------------------------------------------------------- +// CGenericMtmPlugin::ServiceProviderId +// Returns the id of the service provider. +// (other items were commented in a header). +// --------------------------------------------------------- +// +TUid CGenericMtmPlugin::ServiceProviderId() const + { + return KGenericMtmPlugin; + } + +// ----------------------------------------------------------------------------- +// C++ default constructor can NOT contain any code, that +// might leave. +// ----------------------------------------------------------------------------- +// +CGenericMtmPlugin::CGenericMtmPlugin( CCoeEnv& aCoeEnv, CSendUiSingleton& aSingleton ) : + CSendingService( aCoeEnv, aSingleton ), + iSendUiFeatureFlags(0) + { + } + +// ----------------------------------------------------------------------------- +// ConstructL +// Symbian 2nd phase constructor can leave. +// ----------------------------------------------------------------------------- +// +void CGenericMtmPlugin::ConstructL() + { + iStore = CBufStore::NewL(KSendUiRichTextStoreGranularity); + + FeatureManager::InitializeLibL(); + if ( FeatureManager::FeatureSupported( KFeatureIdSendFileInCall ) ) + { + iSendUiFeatureFlags |= KSendUiFeatureSFI; + } + if ( FeatureManager::FeatureSupported( KFeatureIdMMS ) ) + { + iSendUiFeatureFlags |= KSendUiFeatureMMS; + } + if ( FeatureManager::FeatureSupported( KFeatureIdSelectableEmail ) ) + { + iSendUiFeatureFlags |= KSendUiFeatureSelectableEmail; + } + FeatureManager::UnInitializeLib(); + + } + +// --------------------------------------------------------- +// Start asyncronous MTM scanning +// --------------------------------------------------------- +// +void CGenericMtmPlugin::ScanMtmsL( RPointerArray& aList ) + { + TInt regMtmIndex = 0; + TInt err; + TInt count( iSingleton.MtmUiDataRegistryL().NumRegisteredMtmDlls() ); + while ( regMtmIndex < count ) + { + TUid mtmUid = iSingleton.MtmUiDataRegistryL().MtmTypeUid(regMtmIndex); + LOGTEXT3(_L("Loading MTM index %d, id %d"), regMtmIndex, mtmUid ); + TRAP( err, LoadMtmL( iSingleton.MtmUiDataRegistryL().MtmTypeUid(regMtmIndex), aList ) ); + LOGTEXT2( _L("Loading MTM done, code %d"), err ); + regMtmIndex++; + } + } + + +// --------------------------------------------------------- +// ValidateAttachmentsL +// --------------------------------------------------------- +// +TBool CGenericMtmPlugin::ValidateAttachmentsL( + TUid aMtmUid, + CBaseMtmUiData& aMtmUiData, + CArrayPtrFlat* aAttachments ) + { + LOGTEXT(_L8("CGenericMtmPlugin::ValidateAttachmentsL >>")); + TBool continueSending = ETrue; + + // Validate attachments and show query and error note if needed. + if ( aAttachments->Count() > 0 ) + { + CSendUiFileRightsEngine* fileRightsEngine = + CSendUiFileRightsEngine::NewLC( iCoeEnv.FsSession() ); + if ( aMtmUid == KSenduiMtmPostcardUid && + IsPostcardContactLink( aAttachments ) ) + { + // Postcard special case. ConfirmDrmFileRightsL() fails for contact + // link file sent from Phonebook to Postcard. Therefore the check + // is bypassed. Postcard treats the special file as a contact link. + // Therefore bypassing drm check in this case is not a + // vulnerability. + } + else + { + fileRightsEngine->ConfirmDrmFileRightsL( aAttachments ); + } + // Confirm and filter away non-MMS files, if sending via MMS. + if ( aMtmUid == KSenduiMtmMmsUid || + aMtmUid == KSenduiMtmAudioMessageUid || + ( aMtmUid == KSenduiMtmUniMessageUid && + IsSupported( KSendUiFeatureMMS ) ) ) + { + fileRightsEngine->ConfirmMmsValidityL( aAttachments ); + } + + continueSending = fileRightsEngine->ShowDrmAndMmsInfoL(); + + if ( aAttachments->Count() <= 0 ) + { + continueSending = EFalse; // No files to send after filtering. + } + + if ( continueSending ) + { + TInt messageSize = 0; + + TUid uidQuery = { KUidMsvMtmQuerySupportLinks }; + TInt supportsLinks = 0; + aMtmUiData.QueryCapability( uidQuery, supportsLinks ); + + messageSize = fileRightsEngine->CalculateTotalSizeOfFiles( + aAttachments, + supportsLinks ); + + if ( aMtmUid != KSenduiMtmBtUid && + MsvUiServiceUtilities::DiskSpaceBelowCriticalLevelL( + iSingleton.MsvSessionL(), messageSize ) ) + { + User::Leave(KErrDiskFull); + } + } + CleanupStack::PopAndDestroy( fileRightsEngine ); + } + LOGTEXT(_L8("CGenericMtmPlugin::ValidateAttachmentsL <<")); + return continueSending; + } + +// --------------------------------------------------------- +// IsWaitNoteNeededL +// --------------------------------------------------------- +// +TBool CGenericMtmPlugin::IsWaitNoteNeededL( + TUid aMtmUid, + const CMessageData& aMessageData, + TInt aAttachmentCount ) + { + LOGTEXT(_L8("CGenericMtmPlugin::IsWaitNoteNeededL >>")); + + + const CRichText* bodyText = aMessageData.BodyText(); + const CMessageAddressArray& toAddresses = aMessageData.ToAddressArray(); + + if ( aAttachmentCount > 0 || + ( bodyText && bodyText->DocumentLength() ) ) + { + LOGTEXT(_L8("CGenericMtmPlugin::IsWaitNoteNeededL <<")); + return ETrue; + } + + LOGTEXT(_L8("CGenericMtmPlugin::IsWaitNoteNeededL <<")); + + return EFalse; + } + +// --------------------------------------------------------- +// CGenericMtmPlugin::ShowWaitNoteLC +// +// (other items were commented in a header). +// --------------------------------------------------------- +// +void CGenericMtmPlugin::ShowWaitNoteLC() + { + LOGTEXT(_L8("CGenericMtmPlugin::ShowWaitNoteLC >>")); + + delete iWaitDialog; + iWaitDialog = NULL; + + iWaitDialog = new (ELeave) CAknWaitDialog( + reinterpret_cast(&iWaitDialog), ETrue ); + + CleanupStack::PushL(TCleanupItem(CleanupWaitDialog, (TAny**)&iWaitDialog)); + + iWaitDialog->ExecuteLD( R_SENDUI_WAIT_NOTE ); + LOGTEXT(_L8("CGenericMtmPlugin::ShowWaitNoteLC <<")); + } + +// --------------------------------------------------------- +// ResetIsSending +// --------------------------------------------------------- +// +void CGenericMtmPlugin::ResetIsSending(TAny* aAny) + { + *((TBool*)aAny) = EFalse; + } + +// --------------------------------------------------------- +// CGenericMtmPlugin::CleanupWaitDialog +// --------------------------------------------------------- +// +void CGenericMtmPlugin::CleanupWaitDialog(TAny* aAny) + { + CAknWaitDialog** dialog = (CAknWaitDialog**) aAny; + if (dialog && *dialog) + { + delete *dialog; + *dialog = NULL; + } + } + +// --------------------------------------------------------- +// +// --------------------------------------------------------- +// +void CGenericMtmPlugin::CreateMessageL( + TUid& aMtmUid, + TMsvId aService + ) + { + + LOGTEXT(_L8("CGenericMtmPlugin::CreateMessageL >>")); + + CMsvEntry* draftEntry = iSingleton.MsvSessionL().GetEntryL( KMsvDraftEntryId ); + CleanupStack::PushL( draftEntry ); + iClientMtm->SetCurrentEntryL( draftEntry ); // mtm takes ownership + CleanupStack::Pop( draftEntry ); + + iClientMtm->CreateMessageL( aService ); + + if ( aMtmUid == KSenduiMtmSmtpUid ) + { + // For mail message: this loads signature. + iClientMtm->LoadMessageL(); + } + + LOGTEXT(_L8("CGenericMtmPlugin::CreateMessageL <<")); + + } +TBool CGenericMtmPlugin::CreateMessageL( + TUid& aMtmUid, + TBool& aLaunchEmbedded ) + { + LOGTEXT(_L8("CGenericMtmPlugin::CreateMessageL >>")); + TBool doContinue; + TMsvId service = GetAndValidateServiceL( aMtmUid, aLaunchEmbedded, doContinue ); + + if ( doContinue ) + { + CMsvEntry* draftEntry = iSingleton.MsvSessionL().GetEntryL( KMsvDraftEntryId ); + CleanupStack::PushL( draftEntry ); + iClientMtm->SetCurrentEntryL( draftEntry ); // mtm takes ownership + CleanupStack::Pop( draftEntry ); + iClientMtm->CreateMessageL( service ); + + if ( aMtmUid == KSenduiMtmSmtpUid ) + { + // For emails, this loads signature. + iClientMtm->LoadMessageL(); + } + } + LOGTEXT(_L8("CGenericMtmPlugin::CreateMessageL <<")); + return doContinue; + } + +// ----------------------------------------------------------------------------- +// SetRecipientsL +// ----------------------------------------------------------------------------- +// +void CGenericMtmPlugin::SetRecipientsL( + TUid aMtmUid, + const CMessageData& aMessageData ) + { + LOGTEXT(_L8("CGenericMtmPlugin::SetRecipientsL >>")); + + // Send file in call + TPhCltTelephoneNumber callerNumber; + TPhCltNameBuffer callerName; + // Add "To"-recipients addressees + if ( aMessageData.ToAddressArray().Count() > 0 ) + { + AddAddresseesL( EMsvRecipientTo, aMessageData.ToAddressArray() ); + } + else if( IsCallOngoing( callerNumber, callerName ) && // Incall situation + ( aMtmUid == KSenduiMtmMmsUid || aMtmUid == KSenduiMtmUniMessageUid ) ) + { + if ( callerName != KNullDesC16) + { + iClientMtm->AddAddresseeL( callerNumber, callerName ); + } + else + { + iClientMtm->AddAddresseeL( callerNumber ); + } + } + + // Add "CC"-recipients addressees + if ( aMessageData.CcAddressArray().Count() > 0 ) + { + AddAddresseesL( EMsvRecipientCc, aMessageData.CcAddressArray() ); + } + + // Add "BCC"-recipients addressees + if ( aMessageData.BccAddressArray().Count() > 0 ) + { + AddAddresseesL( EMsvRecipientBcc, aMessageData.BccAddressArray() ); + } + + LOGTEXT(_L8("CGenericMtmPlugin::SetRecipientsL <<")); + } + +// ----------------------------------------------------------------------------- +// Add addressees. +// ----------------------------------------------------------------------------- +// +void CGenericMtmPlugin::AddAddresseesL( + TMsvRecipientType aRecipientType, + const CMessageAddressArray& aAddressees ) + { + LOGTEXT(_L8("CGenericMtmPlugin::AddAddresseesL >>")); + + for( TInt i(0) ; i < aAddressees.Count(); i++ ) + { + if( aAddressees[i]->Address().Length() > 0 ) + { + // If address has an alias, process it + if( aAddressees[i]->Alias().Length() > 0 ) + { + TPtrC alias = aAddressees[i]->Alias(); + + // Check if alias contains illegal characters. If it does + // remove them. + if( ( alias.Locate( KSendUiMsgAddressStartChar ) != KErrNotFound ) || + ( alias.Locate( KSendUiMsgAddressEndChar ) != KErrNotFound ) ) + { + HBufC* aliasNew = alias.AllocLC(); + TPtr aliasPtr = aliasNew->Des(); + RemoveIllegalChars( aliasPtr ); + iClientMtm->AddAddresseeL( + aRecipientType, aAddressees[i]->Address(), *aliasNew ); + + CleanupStack::PopAndDestroy( aliasNew ); + } + else + { + iClientMtm->AddAddresseeL( + aRecipientType, aAddressees[i]->Address(), alias ); + } + } + else + { + // Address entry didn't have alias + iClientMtm->AddAddresseeL( + aRecipientType, aAddressees[i]->Address() ); + } + } + // Done setting one addressee + } + + LOGTEXT(_L8("CGenericMtmPlugin::AddAddresseesL <<")); + } + +// ----------------------------------------------------------------------------- +// Add attachments to message. +// (other items were commented in a header). +// ----------------------------------------------------------------------------- +// +TBool CGenericMtmPlugin::AddAttachmentsL( CBaseMtmUiData& aMtmUiData, + CArrayPtrFlat* aAttachments ) + { + LOGTEXT(_L8("CGenericMtmPlugin::AddAttachmentsL >>")); + + TInt supportsLinks = 0; + aMtmUiData.QueryCapability( TUid::Uid(KUidMsvMtmQuerySupportLinks), supportsLinks ); + + TBool success(ETrue); + // Set linked attachments. (Attachments given as file paths) + TInt attachmentCount = aAttachments->Count(); + TInt i; + for ( i = 0; i < attachmentCount && success ; i++ ) + { + CSendUiAttachment& attachment = *(aAttachments->At(i )); + success = AddAttachmentL( &attachment, supportsLinks ); + } + + LOGTEXT(_L8("CGenericMtmPlugin::AddAttachmentsL <<")); + return success; + } + +// ----------------------------------------------------------------------------- +// CGenericMtmPlugin::AddAttachmentL +// Add attachment to message. +// (other items were commented in a header). +// ----------------------------------------------------------------------------- +// +TBool CGenericMtmPlugin::AddAttachmentL( CSendUiAttachment* aAttachment, TInt aSupportsLinks ) + { + CSendUiOperationWait* waiter = CSendUiOperationWait::NewLC(); + // File paths + if ( aSupportsLinks && aAttachment->Type() == CSendUiAttachment::EAttachmentPath ) + { + iClientMtm->AddLinkedAttachmentL( + *(aAttachment->Path() ), + aAttachment->MimeType(), + 0, + waiter->iStatus ); + } + else + { + RFile attachmentFile; + User::LeaveIfError( attachmentFile.Duplicate( *(aAttachment->Handle() ) )); + CleanupClosePushL( attachmentFile ); + + // File handle ownership transferred. + iClientMtm->AddAttachmentL( + attachmentFile, + aAttachment->MimeType(), + 0, + waiter->iStatus ); + CleanupStack::Pop( &attachmentFile ); + } + + TBool success = waiter->Start( iClientMtm ); + + CleanupStack::PopAndDestroy( waiter ); + return success; + } + +// --------------------------------------------------------- +// SetBodyL +// --------------------------------------------------------- +// +void CGenericMtmPlugin::SetBodyL( + const CBaseMtmUiData& aMtmUiData, + const CMessageData& aMessageData, + CArrayPtrFlat* aAttachments ) + { + LOGTEXT(_L8("CGenericMtmPlugin::SetBodyL >>")); + __ASSERT_DEBUG( iStore, User::LeaveIfError(KErrNoMemory) ); + + const CRichText* bodyText = aMessageData.BodyText(); + LOGTEXT2( _L("CMessageData bodytext length %d" ), bodyText->DocumentLength() ); + + if ( !bodyText || !bodyText->DocumentLength() ) + { // No body text + return; + } + + TInt response; + if ( aMtmUiData.QueryCapability( KUidMtmQuerySupportedBody, response ) == KErrNotSupported ) + { + CSendUiAttachment* atta = CSendUiAttachment::NewLC( *bodyText, iCoeEnv.FsSession() ); + aAttachments->AppendL( atta ); + CleanupStack::Pop( atta ); + return; + } + + CRichText& mtmBody = iClientMtm->Body(); + LOGTEXT2( _L("mtm body length %d" ), mtmBody.DocumentLength() ); + // Set the picture factory + if ( bodyText->PictureFactory() ) + { + mtmBody.SetPictureFactory( bodyText->PictureFactory(), this ); + } + + // read aMtmBody and add to aSentMessageBody so that possible signature is added. + if ( aMtmUiData.Type() == KSenduiMtmSmtpUid && mtmBody.DocumentLength() ) + { + CRichText* text = CRichText::NewL( + static_cast( iCoeEnv ).SystemParaFormatLayerL(), + static_cast( iCoeEnv ).SystemCharFormatLayerL() ); + CleanupStack::PushL( text ); + + TInt len1 = bodyText->DocumentLength(); + TInt len2 = mtmBody.DocumentLength(); + + HBufC* buf = HBufC::NewLC( len1 ); + TPtr ptr = buf->Des(); + bodyText->Extract( ptr, 0 ); + text->InsertL( 0, *buf ); + CleanupStack::PopAndDestroy( buf ); + + len1 = text->DocumentLength(); + text->InsertL (len1, CEditableText::EParagraphDelimiter ); + len1 = text->DocumentLength(); + text->InsertL( len1, mtmBody.Read( 0, len2 ) ); + + // Save and restore the rich text + TStreamId id = text->StoreL( *iStore ); + mtmBody.RestoreL( *iStore, id ); + + CleanupStack::PopAndDestroy( text ); + } + else + { + // Save and restore the rich text + TStreamId id = bodyText->StoreL( *iStore ); + mtmBody.RestoreL( *iStore, id ); + + LOGTEXT(_L8("CGenericMtmPlugin::mtm body restored")); + } + + LOGTEXT2( _L("Final Mtm body length %d" ), mtmBody.DocumentLength() ); + // Get access to protected data + CSendUiDummyMtm* mtm = ( CSendUiDummyMtm* )iClientMtm; + + mtm->SetCharFormatL( *bodyText->GlobalCharFormatLayer() ); + mtm->SetParaFormatL( *bodyText->GlobalParaFormatLayer() ); + LOGTEXT(_L8("CGenericMtmPlugin::SetBodyL <<")); + } + +// ----------------------------------------------------------------------------- +// CGenericMtmPlugin::LaunchEditorL +// +// (other items were commented in a header). +// ----------------------------------------------------------------------------- +// +void CGenericMtmPlugin::LaunchEditorL( + TInt aAttachmentCount, + TBool aLaunchEditorEmbedded ) + { + LOGTEXT(_L8("CGenericMtmPlugin::LaunchEditorL >>")); + // save message. + iClientMtm->SaveMessageL(); + // set the time and make invisible. + iIndexEntry = iClientMtm->Entry().Entry(); + iIndexEntry.iDate.UniversalTime(); + iIndexEntry.SetVisible( EFalse ); + iIndexEntry.SetInPreparation( ETrue ); + + if ( aAttachmentCount > 0 ) + { + iIndexEntry.SetAttachment( ETrue ); + } + else + { + iIndexEntry.SetAttachment( EFalse ); + } + + iClientMtm->Entry().ChangeL( iIndexEntry ); + + CSendUiOperationWait* waiter = + CSendUiOperationWait::NewLC( EActivePriorityWsEvents+10 ); + + iClientMtm->SwitchCurrentEntryL( iIndexEntry.Id() ); + + // Set preferences. + + TUint preferences = iMtmUi->Preferences(); + if ( aLaunchEditorEmbedded ) + { + preferences |= EMtmUiFlagEditorPreferEmbedded; + } + else + { + preferences &= ~EMtmUiFlagEditorPreferEmbedded; + preferences |= EMtmUiFlagEditorNoWaitForExit; + } + + iMtmUi->SetPreferences( preferences ); + + // Remove wait dialog before calling EditL. + // Otherwise possible (e.g. settings) dialogs opened by UI MTM may get dimmed. + delete iWaitDialog; + iWaitDialog = NULL; + + RProperty integerProperty; + + TInt err = integerProperty.Attach(KPSUidMsgEditor,KMuiuStandAloneOpenMsgEditors); + TInt openeditorcount = 0; + err = integerProperty.Get(KPSUidMsgEditor, KMuiuStandAloneOpenMsgEditors, openeditorcount); + switch ( err ) + { + case KErrPermissionDenied: + case KErrArgument: + { + User::Leave( err ); + } + break; + case KErrNotFound: // shoudl be executed only once for every boot cycle + { + User::LeaveIfError ( + RProperty::Define( + KPSUidMsgEditor, + KMuiuStandAloneOpenMsgEditors, + RProperty::EInt, + ECapabilityReadDeviceData, + ECapabilityWriteDeviceData, + 0 ) ); + } + break; + case KErrNone: + default: + break; + } + + if (!aLaunchEditorEmbedded && openeditorcount ) + { + RProperty property; + + User::LeaveIfError( property.Attach( KPSUidMuiu,KMuiuSysOpenMsgEditors ) ); + TInt openEditors; + TInt err = property.Get( openEditors ); + CleanupClosePushL( property ); + + openeditorcount++; + integerProperty.Set(KPSUidMsgEditor, KMuiuStandAloneOpenMsgEditors, openeditorcount); + property.Set( KPSUidMuiu, KMuiuSysOpenMsgEditors, openEditors ); + + // wait a second + User::After( KSeconds ); + CleanupStack::PopAndDestroy( &property ); + } + else + { + openeditorcount = 1; + integerProperty.Set(KPSUidMsgEditor, KMuiuStandAloneOpenMsgEditors, openeditorcount); + } + integerProperty.Close(); + // Edit the message. + CMsvOperation* op = iMtmUi->EditL( waiter->iStatus ); + CleanupStack::PushL( op ); + TBool success = waiter->Start( op ); + if ( success ) + { + TBuf8 progressBuf = op->ProgressL(); + iMtmUi->DisplayProgressSummary( progressBuf ); + } + CleanupStack::PopAndDestroy( op ); //op + CleanupStack::PopAndDestroy(waiter); // waiter + + LOGTEXT(_L8("CGenericMtmPlugin::LaunchEditorL <<")); + } + +// --------------------------------------------------------- +// StreamStoreL +// --------------------------------------------------------- +// +const CStreamStore& CGenericMtmPlugin::StreamStoreL(TInt) const + { + return *iStore; + } + +// --------------------------------------------------------- +// CGenericMtmPlugin::EmailDefaultServiceL +// --------------------------------------------------------- +// +TMsvId CGenericMtmPlugin::EmailDefaultServiceL() + { + TMsvId service = MsvUiServiceUtilitiesInternal::DefaultServiceForMTML( + iSingleton.MsvSessionL(), KSenduiMtmSmtpUid, ETrue); + + if (service == KMsvUnknownServiceIndexEntryId) + { + // Hide wait-note. Email-settings dialog (wizard) status + // pane is dimmed if wait-note is left visible behind settings. + if ( iWaitDialog ) + { + iWaitDialog->MakeVisible( EFalse ); + } + + CAknQueryDialog* dlg = CAknQueryDialog::NewL(CAknQueryDialog::ENoTone); + + if (dlg->ExecuteLD(R_SENDUI_CREATE_MAILBOX_CONFIRMATION_QUERY)) + { + CEikStatusPane* sp = static_cast( iCoeEnv ).AppUiFactory()->StatusPane(); + CAknContextPane* cp = (CAknContextPane *) + sp->ControlL(TUid::Uid(EEikStatusPaneUidContext)); + + // switch layout (e.g. from phone idle layout is different). + TInt current = sp->CurrentLayoutResId(); + if (current != R_AVKON_STATUS_PANE_LAYOUT_USUAL) + { + sp->SwitchLayoutL(R_AVKON_STATUS_PANE_LAYOUT_USUAL); + sp->MakeVisible(ETrue); + } + + iIndexEntry = TMsvEntry(); + iIndexEntry.iMtm = KSenduiMtmSmtpUid; + iIndexEntry.iType.iUid = KUidMsvServiceEntryValue; + iIndexEntry.iDate.UniversalTime(); + + CMsvEntry* centry = iSingleton.MsvSessionL().GetEntryL(KMsvRootIndexEntryId); + CleanupStack::PushL(centry); + + CSendUiOperationWait* waiter = CSendUiOperationWait::NewLC(); + + CMsvOperation* op = + iMtmUi->CreateL( iIndexEntry, *centry, waiter->iStatus ); + CleanupStack::PushL(op); + + waiter->Start( op ); + + CleanupStack::PopAndDestroy( 3, centry ) ; // op, waiter, centry + service = MsvUiServiceUtilitiesInternal::DefaultServiceForMTML( + iSingleton.MsvSessionL(), KSenduiMtmSmtpUid, ETrue); + + if (current != R_AVKON_STATUS_PANE_LAYOUT_USUAL) + { + sp->SwitchLayoutL(current); + sp->MakeVisible(ETrue); + } + + // Display wait note while editor starts + if ( iWaitDialog ) + { + iWaitDialog->MakeVisible( ETrue ); + } + } + } + + if (service == KMsvUnknownServiceIndexEntryId) + { + // User canceled creating mailbox. + // Leaving now pops cleanupstack filled earlier. + User::Leave(KLeaveWithoutAlert); + } + + return service; + } + +// --------------------------------------------------------- +// RemoveIllegalChars < and > characters +// --------------------------------------------------------- +// +void CGenericMtmPlugin::RemoveIllegalChars( TPtr& aCheckedString) + { + TInt stringLength = aCheckedString.Length(); + + while(stringLength--) + { + if ( aCheckedString[stringLength] == KSendUiMsgAddressStartChar || + aCheckedString[stringLength] == KSendUiMsgAddressEndChar) + { + aCheckedString[stringLength] = CEditableText::ESpace; + } + } + aCheckedString.TrimAll(); + } + +// --------------------------------------------------------- +// Checks if the given feature is supported +// --------------------------------------------------------- +// +TBool CGenericMtmPlugin::IsSupported( const TUint& aFeature ) + { + return iSendUiFeatureFlags & aFeature; + } + +// --------------------------------------------------------- +// IsCallOngoing +// --------------------------------------------------------- +// +TBool CGenericMtmPlugin::IsCallOngoing( + TDes& aPhoneNumberString, + TDes& aName ) + { + LOGTEXT(_L8("CGenericMtmPlugin::IsCallOngoing >>")); + + TBool phoneNumberStringFound( EFalse ); + TInt error(KErrNone); + if( IsSupported( KSendUiFeatureSFI ) ) + { + error = RProperty::Get( + KPSUidTelRemotePartyInformation, + KTelCLINumber, + aPhoneNumberString ); + + if( error == KErrNone && aPhoneNumberString != KNullDesC16 ) + { + phoneNumberStringFound = ETrue; + error = RProperty::Get( + KPSUidTelRemotePartyInformation, + KTelCLIName, + aName ); + } + } + LOGTEXT(_L8("CGenericMtmPlugin::IsCallOngoing <<")); + return phoneNumberStringFound; + } + +// --------------------------------------------------------- +// Sends Bluetooth message using AIW +// --------------------------------------------------------- +// +void CGenericMtmPlugin::SendBtMessageL( CArrayPtrFlat* aAttachments ) + { + LOGTEXT(_L8("CGenericMtmPlugin::SendBtMessageL >>")); + + TInt i = 0; + + CAiwGenericParamList* paramList = CAiwGenericParamList::NewLC(); + + // Go through attachments + TInt attaCount = aAttachments->Count(); + + while ( i < attaCount ) + { + CSendUiAttachment& attachment = *(aAttachments->At(i)); + + if ( attachment.Type() == CSendUiAttachment::EAttachmentPath ) + { + TAiwGenericParam filePath( EGenericParamFile, *attachment.Path() ); + paramList->AppendL( filePath ); + } + else + { + TAiwGenericParam fileHandle( EGenericParamFile, *attachment.Handle() ); + paramList->AppendL( fileHandle ); + } + i++; + } + CAiwServiceHandler* serviceHandler = CAiwServiceHandler::NewLC(); + serviceHandler->AttachL( R_SENDUI_BASEINTEREST ); + iWaitDialog->MakeVisible(EFalse); + // Give file list to Service Handler + serviceHandler->ExecuteServiceCmdL( + KAiwCmdSend, + *paramList , + serviceHandler->OutParamListL()); + + CleanupStack::PopAndDestroy( 2, paramList ); // serviceHandler, paramList + + LOGTEXT(_L8("CGenericMtmPlugin::SendBtMessageL <<")); + } + +// --------------------------------------------------------- +// Calls MTM UI validate service function +// (other items were commented in a header). +// --------------------------------------------------------- +// +TBool CGenericMtmPlugin::IsValidServiceL() + { + TPckgBuf paramPack( ETrue ); + + // This is not actually used. + CMsvEntrySelection* dummySelection = new ( ELeave ) CMsvEntrySelection; + CleanupStack::PushL( dummySelection ); + + iMtmUi->InvokeSyncFunctionL( KMtmUiFunctionValidateService, + *dummySelection, + paramPack ); + + CleanupStack::PopAndDestroy( dummySelection ); + + return ( KErrNone == paramPack() ); + } + + +// --------------------------------------------------------- +// ValidateMtmL +// +// Returns +// +// ETrue, if service supports validate service and service is valid +// ETrue, if service does not support validate service +// EFalse, if service supports validate service, but service is not valid +// --------------------------------------------------------- +// +TBool CGenericMtmPlugin::ValidateMtmL() + { + TBool serviceOk = ETrue; + TInt supportsValidateService = 0; + + const TUid uidQuery = { KUidMsvMtmQuerySupportValidateService }; + + TInt supported = ( KErrNone == iMtmUi->QueryCapability( + uidQuery, supportsValidateService ) ); + + if ( supported && supportsValidateService ) + { + serviceOk = IsValidServiceL(); + } + return serviceOk; + } + +// --------------------------------------------------------- +// GetAndValidateServiceL +// --------------------------------------------------------- +// +TMsvId CGenericMtmPlugin::GetAndValidateServiceL( + TUid& aMtmUid, + TBool aLaunchEmbedded, + TBool& aContinue ) + { + LOGTEXT(_L8("CGenericMtmPlugin::GetAndvalidateServiceL >>")); + aContinue = ETrue; + TMsvId service = KMsvUnknownServiceIndexEntryId; + TUid previousMtmUid( aMtmUid ); + + if (aLaunchEmbedded) + { + if (aMtmUid == KSenduiMtmSmtpUid) + { + if( IsSupported( KSendUiFeatureSelectableEmail ) && + !CMceSettingsEmailSel::ShowSelectEmailDlgL( service, + aMtmUid, iRequiredCapabilities ) ) + { + return KMsvUnknownServiceIndexEntryId; + } + + if ( previousMtmUid != aMtmUid ) + { + delete iMtmUi; iMtmUi = NULL; + delete iClientMtm; iClientMtm = NULL; + + iClientMtm = iSingleton.ClientMtmRegistryL().NewMtmL( aMtmUid ); + iMtmUi = iSingleton.MtmUiRegistryL().NewMtmUiL( *iClientMtm ); + } + + if( service == KMsvUnknownServiceIndexEntryId ) + { + //donot launch wizard + // show info note to user to configured + //mailbox from mail app. + CAknGlobalNote* note = CAknGlobalNote::NewL(); + CleanupStack::PushL( note ); + HBufC* text = NULL; + text = StringLoader::LoadLC( R_SENDUI_SETTINGS_EMAIL_NOT_OK, &iCoeEnv ); + note->ShowNoteL( EAknGlobalErrorNote, *text ); + CleanupStack::PopAndDestroy( 2, note ); // note, stringLoader + aContinue = EFalse; + return KMsvUnknownServiceIndexEntryId; + } + } + else + { + service = MsvUiServiceUtilitiesInternal::DefaultServiceForMTML( + iSingleton.MsvSessionL(), aMtmUid, ETrue); + } + } + else + { + if( IsSupported( KSendUiFeatureSelectableEmail ) && + aMtmUid == KSenduiMtmSmtpUid ) + { + if ( !CMceSettingsEmailSel::ShowSelectEmailDlgL( service, + aMtmUid, iRequiredCapabilities ) ) + { + return KMsvUnknownServiceIndexEntryId; + } + + if ( previousMtmUid != aMtmUid ) + { + delete iMtmUi; iMtmUi = NULL; + delete iClientMtm; iClientMtm = NULL; + + iClientMtm = iSingleton.ClientMtmRegistryL().NewMtmL( aMtmUid ); + iMtmUi = iSingleton.MtmUiRegistryL().NewMtmUiL( *iClientMtm ); + } + + } + else + { + service = MsvUiServiceUtilitiesInternal::DefaultServiceForMTML( + iSingleton.MsvSessionL(), aMtmUid, ETrue); + } + // If stand-alone launch requested and service is not OK, show error note. + // This is mainly for phone idle "New message" function which does not + // like possible settings dialogs hanging around... + if ( !ValidateMtmL() ) + { + CAknGlobalNote* note = CAknGlobalNote::NewL(); + CleanupStack::PushL( note ); + + HBufC* text = NULL; + if( iSingleton.ClientMtmRegistryL().TechnologyTypeUid( aMtmUid ) == KMailTechnologyTypeUid ) + text = StringLoader::LoadLC( R_SENDUI_SETTINGS_EMAIL_NOT_OK, &iCoeEnv ); + else + text = StringLoader::LoadLC( R_SENDUI_SETTINGS_NOT_OK, &iCoeEnv ); + note->ShowNoteL( EAknGlobalErrorNote, *text ); + CleanupStack::PopAndDestroy( 2, note ); // note, stringLoader + aContinue = EFalse; + } + } + LOGTEXT(_L8("CGenericMtmPlugin::GetAndvalidateServiceL <<")); + return service; + } + +// --------------------------------------------------------- +// GetMtmSendingCapabilitiesL +// --------------------------------------------------------- +// +void CGenericMtmPlugin::GetMtmSendingCapabilitiesL( + CBaseMtmUiData& mtmUiData, + TSendingCapabilities& cap ) + { + cap.iFlags = 0; // reset flags.body and message size resets themselves. + TInt response; + // Query capabilities + mtmUiData.QueryCapability( KUidMtmQueryMaxBodySize, cap.iBodySize ); + mtmUiData.QueryCapability( KUidMtmQueryMaxTotalMsgSize, cap.iMessageSize ); + + if ( mtmUiData.QueryCapability( KUidMtmQuerySupportAttachments, response ) == KErrNone ) + { + cap.iFlags |= TSendingCapabilities::ESupportsAttachments; + } + if ( mtmUiData.QueryCapability( KUidMtmQuerySupportedBody, response ) == KErrNone ) + { + cap.iFlags |= TSendingCapabilities::ESupportsBodyText; + } + if ( mtmUiData.QueryCapability( KUidMsvQuerySupportsBioMsg, response ) == KErrNone ) + { + cap.iFlags |= TSendingCapabilities::ESupportsBioSending; + } + if ( mtmUiData.QueryCapability( TUid::Uid( KUidMsvMtmQuerySupportEditor ), response ) == KErrNone ) + { + cap.iFlags |= TSendingCapabilities::ESupportsEditor; + } + } + +// --------------------------------------------------------- +// IsPostcardContactLink +// --------------------------------------------------------- +// +TBool CGenericMtmPlugin::IsPostcardContactLink( const CArrayPtrFlat* aAttachments ) + { + _LIT(KFileName, "X-Nokia-PhonebookId_temp"); + + // Check if attachment is a file containing serialized contact + // link. Such attachment is sent by Phonebook to Postcard. The + // special file is recognized by name. + if ( aAttachments->Count() == 0 ) + { + return EFalse; + } + CSendUiAttachment& attachment = *(aAttachments->At(0)); + return attachment.Type() == CSendUiAttachment::EAttachmentPath + && ( attachment.Path()->Right( KFileName().Length() ).Compare( KFileName ) == 0 ); + + } + +// --------------------------------------------------------- +// ValidateAccountL +// --------------------------------------------------------- +// +TBool CGenericMtmPlugin::ValidateAccountL( CBaseMtmUiData& aMtmUiData, TUid aMtmUid ) + { + LOGTEXT2(_L("ValidateAccountL: %d"), aMtmUid.iUid ); + TInt response = 0; + + // Check to see that accounts (if required) have been set up + TMsvId id; + User::LeaveIfError( + iSingleton.MsvSessionL().GetEntry( KMsvRootIndexEntryId, id, iIndexEntry ) ); + + TInt validAccounts = ETrue; + TMsvEntry serviceEntry; + serviceEntry.iType.iUid = KUidMsvServiceEntryValue; + serviceEntry.iMtm = aMtmUid; + + if ( aMtmUiData.CanCreateEntryL( iIndexEntry, serviceEntry, response ) ) + { + CMsvEntrySelection* accounts = + MsvUiServiceUtilities::GetListOfAccountsWithMTML( + iSingleton.MsvSessionL(), aMtmUid, ETrue ); + + if ( accounts->Count() == 0 ) + { + validAccounts = EFalse; + } + + delete accounts; + accounts = NULL; + } + LOGTEXT2(_L("ValidateAccountL result: %d"), validAccounts ); + + return validAccounts; + } + +// --------------------------------------------------------- +// CGenericMtmPlugin::LoadMtmL +// --------------------------------------------------------- +// +void CGenericMtmPlugin::LoadMtmL( + TUid aMtmType, + RPointerArray& aList ) + { + // these mtm's are not needed, because they don't support sending + if (aMtmType == KSenduiMtmImap4Uid || + aMtmType == KSenduiMtmPop3Uid || + aMtmType == KSenduiMtmPushMtm1Uid || + aMtmType == KSenduiMtmPushMtm2Uid || + aMtmType == KSenduiMtmPushMtm3Uid || + aMtmType == KSenduiMtmPushMtmUid || + aMtmType == KSenduiMtmBioUid || + aMtmType == KSenduiMMSNotificationUid || + aMtmType == KSenduiMtmRoUid + ) + { + return ; + } + + TInt err(KErrNone); + + CBaseMtmUiData* uiData = iSingleton.MtmUiDataRegistryL().NewMtmUiDataLayerL( aMtmType ); + CleanupStack::PushL( uiData ); + TInt response = 0; + + err = uiData->QueryCapability(KUidMtmQueryCanSendMsg, response); + + if ( err ) + { + CleanupStack::PopAndDestroy( uiData ); + if ( err == KErrNotSupported ) + { + return; + } + User::Leave( err ); + } + + CSendingServiceInfo* serviceInfo = CSendingServiceInfo::NewLC(); + serviceInfo->SetServiceId( aMtmType ); + + // the MTM can send messages + const CArrayFix& funcs = + uiData->MtmSpecificFunctions(); + + TInt i = funcs.Count(); + TBool usingPriorityName( EFalse ); + while (i--) + { + CBaseMtmUiData::TMtmUiFunction func(funcs.At(i)); + if ( func.iFunctionId == KMtmUiFunctionSendAs /*func.iFlags & EMtudCommandSendAs */) + { + serviceInfo->SetServiceMenuNameL( func.iCaption ); + } + else if ( func.iFunctionId == KMtmUiMceWriteMessagePopup ) + { + serviceInfo->SetServiceNameL( func.iCaption ); + usingPriorityName = ETrue; + } + else if ( !usingPriorityName && func.iFlags & EMtudCommandTransferSend ) + { + serviceInfo->SetServiceNameL( func.iCaption ); + } + } + + if ( serviceInfo->ServiceMenuName() == KNullDesC ) + { + // no info available for caption - use the human readable name + serviceInfo->SetServiceMenuNameL( iSingleton.MtmUiDataRegistryL().RegisteredMtmDllInfo( aMtmType ).HumanReadableName() ); + } + + if ( serviceInfo->ServiceName() == KNullDesC ) + { + // no info available for caption - use the human readable name + serviceInfo->SetServiceNameL( + iSingleton.MtmUiDataRegistryL().RegisteredMtmDllInfo( aMtmType ).HumanReadableName() ); + } + + TSendingCapabilities cap; + TInt featureFlags; + + serviceInfo->SetServiceProviderId( KGenericMtmPlugin ); + serviceInfo->SetTechnologyTypeId( iSingleton.ClientMtmRegistryL().TechnologyTypeUid( aMtmType ) ); + + GetMtmSendingCapabilitiesL( *uiData, cap ); + + TBool validAccount = ValidateAccountL( *uiData, aMtmType ); + + serviceInfo->SetServiceCapabilities( cap ); + + featureFlags = 0; + if ( !validAccount ) + { + featureFlags |= CSendingServiceInfo::EServiceInValid; + } + + if ( aMtmType == KSenduiMtmSmsUid || aMtmType == KSenduiMtmMmsUid ) + { + featureFlags |= CSendingServiceInfo::EServiceHidden; + } + + + serviceInfo->SetServiceFeatures( featureFlags ); + + aList.Append( serviceInfo ); + CleanupStack::Pop( serviceInfo); + CleanupStack::PopAndDestroy( uiData ); + LOGTEXT2(_L("Service flags: %d"), featureFlags ); + + } +// end of file