/*
* Copyright (c) 2002-2004 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: Provides MMS indirect upload service.
*
*/
// INCLUDE FILES
#include <CSendingServiceInfo.h>
#include <SendUiConsts.h>
#include <CMessageData.h>
#include <senduisingleton.h>
#include <MmsConst.h>
#include <bautils.h> // BaflUtils
#include <barsc.h> // RResourceFile
#include <f32file.h> // TParse
#include <TSendingCapabilities.h>
#include <SenduiMtmUids.h>
#include "CMmsIndirectUpload.h"
#include "SendUiOperationWait.h"
#include "SendUiFileRightsEngine.h"
#include "CSendUiAttachment.h"
#include <data_caging_path_literals.hrh>
// CONSTANTS
const TInt KMaxMmsUploadServiceCount = 4;
const TInt KMmsIndirectUploadService = 2;
const TInt KMaxServiceAddressLength = 512;
const TInt KMaxServiceNameLength = 128;
const TInt KMaxServiceMenuNameLength = 128;
// ============================ MEMBER FUNCTIONS ===============================
// -----------------------------------------------------------------------------
// CMmsIndirectUpload::CMmsIndirectUpload
// C++ default constructor can NOT contain any code, that
// might leave.
// -----------------------------------------------------------------------------
//
CMmsIndirectUpload::CMmsIndirectUpload( CCoeEnv& aCoeEnv, CSendUiSingleton& aSingleton )
: CSendingService( aCoeEnv, aSingleton )
{
}
// -----------------------------------------------------------------------------
// CMmsIndirectUpload::ConstructL
// Symbian 2nd phase constructor can leave.
// -----------------------------------------------------------------------------
//
void CMmsIndirectUpload::ConstructL()
{
ReadServiceDataL();
}
// -----------------------------------------------------------------------------
// CMmsIndirectUpload::NewL
// Two-phased constructor.
// -----------------------------------------------------------------------------
//
CMmsIndirectUpload* CMmsIndirectUpload::NewL( TSendingServiceParams* aParams )
{
CMmsIndirectUpload* self = new(ELeave) CMmsIndirectUpload( aParams->iCoeEnv, aParams->iSingleton );
CleanupStack::PushL(self);
self->ConstructL();
CleanupStack::Pop(self);
return self;
}
// Destructor
CMmsIndirectUpload::~CMmsIndirectUpload()
{
iServiceArray.ResetAndDestroy();
iServiceArray.Close();
}
// ---------------------------------------------------------
// CMmsIndirectUpload::ServiceProviderId
// Returns the id of the service provider.
// (other items were commented in a header).
// ---------------------------------------------------------
//
TUid CMmsIndirectUpload::ServiceProviderId() const
{
return KMmsIndirectUpload;
}
TUid CMmsIndirectUpload::TechnologyTypeId( ) const
{
return TUid::Uid( KSenduiTechnologyMmsUidValue );
}
// -----------------------------------------------------------------------------
// CMmsIndirectUpload::CreateAndSendMessageL
// Creates message to be sent and opens MMS editor.
// (other items were commented in a header).
// -----------------------------------------------------------------------------
//
void CMmsIndirectUpload::CreateAndSendMessageL(
TUid aServiceUid,
const CMessageData* aMessageData,
TBool /*aLaunchEditorEmbedded */)
{
TInt i = 0;
RSendAs sendAsSession;
User::LeaveIfError( sendAsSession.Connect() );
TInt cleanupItems(0);
CleanupClosePushL( sendAsSession );
cleanupItems++;
if ( !CheckMmsServiceAvailabilityL( sendAsSession ) )
{
CleanupStack::PopAndDestroy( &sendAsSession ); // sendAsSession
return;
}
RSendAsMessage sendAsMessage;
CleanupClosePushL( sendAsMessage );
cleanupItems++;
sendAsMessage.CreateL( sendAsSession, KSenduiMtmUniMessageUid );
// BIO type identifies MMS message as upload message.
sendAsMessage.SetBioTypeL( KUidMsgSubTypeMmsUpload );
// Set service address
for ( i=0; i < iServiceArray.Count(); i++)
{
if ( (*iServiceArray[i]).ServiceId() == aServiceUid)
{
TPtrC address = (*iServiceArray[i]).ServiceAddress();
if ( address != KNullDesC )
{
sendAsMessage.AddRecipientL(
address,
(*iServiceArray[i]).ServiceName(),
RSendAsMessage::ESendAsRecipientTo );
}
else
{
User::Leave( KErrNotFound );
}
break;
}
}
CArrayPtrFlat<CSendUiAttachment>* attachments(NULL);
// Get attachments
if ( aMessageData )
{
attachments = CSendUiAttachment::InitAttachmentArrayLCC(
aMessageData->AttachmentArray(),
aMessageData->AttachmentHandleArray(),
iCoeEnv.FsSession() );
cleanupItems += 2;
}
if ( aMessageData )
{
if ( !ValidateAttachmentsL( attachments ) )
{
// attachments, sendAsMessage, sendAsSession
CleanupStack::PopAndDestroy( cleanupItems, &sendAsSession );
return;
}
const CRichText* bodyText = aMessageData->BodyText();
if ( bodyText->DocumentLength() > 0 )
{
CSendUiAttachment* atta = CSendUiAttachment::NewLC( *bodyText, iCoeEnv.FsSession() );
attachments->AppendL( atta );
CleanupStack::Pop( atta );
}
for ( i = 0; i < attachments->Count(); i++ )
{
CSendUiOperationWait* waiter = CSendUiOperationWait::NewLC();
CSendUiAttachment& attachmentPacket = *(attachments->At(i));
if ( attachmentPacket.Type() == CSendUiAttachment::EAttachmentPath )
{
sendAsMessage.AddAttachment(
*(attachmentPacket.Path()),
attachmentPacket.MimeType(),
waiter->iStatus );
}
else
{
RFile attachment;
attachment.Duplicate( *(attachmentPacket.Handle()) );
sendAsMessage.AddAttachment(
attachment,
attachmentPacket.MimeType(),
waiter->iStatus );
}
waiter->Start( (CActive*)NULL );
CleanupStack::PopAndDestroy( waiter );
}
}
TInt attachmentCount( 0 );
if ( attachments )
{
attachmentCount = attachments->Count();
CleanupStack::PopAndDestroy( 2, attachments );
cleanupItems -= 2;
}
if ( attachmentCount > 0 )
{
sendAsMessage.LaunchEditorAndCloseL(); // sendAsMessage is closed
CleanupStack::Pop( &sendAsMessage );
}
else
{
CleanupStack::PopAndDestroy( &sendAsMessage); // sendAsMessage
}
cleanupItems--;
CleanupStack::PopAndDestroy( cleanupItems, &sendAsSession );
}
// -----------------------------------------------------------------------------
// CMmsIndirectUpload::ValidateAttachmentsL
// Validates attachments for sending. DRM protection and MMS validity are
// checked. DRM query and error note is shown if needed. Return value of
// attachment arrays contains valid attachments.
// (other items were commented in a header).
// -----------------------------------------------------------------------------
//
TBool CMmsIndirectUpload::ValidateAttachmentsL( CArrayPtrFlat<CSendUiAttachment>* aAttachments )
{
TBool continueSending( ETrue );
// Validate attachments and show query and error note if needed.
if ( aAttachments->Count() > 0 )
{
CSendUiFileRightsEngine* fileRightsEngine =
CSendUiFileRightsEngine::NewLC( iCoeEnv.FsSession() );
fileRightsEngine->ConfirmDrmFileRightsL( aAttachments );
fileRightsEngine->ConfirmMmsValidityL( aAttachments );
continueSending = fileRightsEngine->ShowDrmAndMmsInfoL( KMmsIndirectUpload );
CleanupStack::PopAndDestroy( fileRightsEngine );
}
return continueSending;
}
// -----------------------------------------------------------------------------
// CMmsIndirectUpload::PopulateServicesListL
// Populates given list with the services provided by this plugin.
// The ownership of the pointed objects remains.
// (other items were commented in a header).
// -----------------------------------------------------------------------------
//
void CMmsIndirectUpload::PopulateServicesListL(
RPointerArray<CSendingServiceInfo>& aList )
{
CleanupClosePushL( aList );
for ( TInt cc = 0; cc < iServiceArray.Count(); cc++ )
{
User::LeaveIfError( aList.Append( iServiceArray[cc] ) );
}
CleanupStack::Pop( &aList );
}
// -----------------------------------------------------------------------------
// CMmsIndirectUpload::ReadServiceDataL
// Reads service names from resource file and addresses from shared data or
// central repository.
// (other items were commented in a header).
// -----------------------------------------------------------------------------
//
void CMmsIndirectUpload::ReadServiceDataL()
{
// Read the maximum MMS message size (bytes).
TInt maxMsgSize = 0;
CRepository* mmsRepository = CRepository::NewL( KCRUidMmsEngine );
mmsRepository->Get( KMmsEngineMaximumSendSize, maxMsgSize );
delete mmsRepository;
CRepository* senduiRepository = CRepository::NewLC( KCRUidSendUi );
TInt i = 0;
// Go through services and get settings for indirect upload services.
// There can be 0-4 indirect upload services configured.
for ( i = 0; i < KMaxMmsUploadServiceCount; i++)
{
TInt serviceType = 0;
TInt err = senduiRepository->Get( KSUMmsUploadType1 + i , serviceType );
// Get settings and store those to service array.
if ( !err && serviceType == KMmsIndirectUploadService )
{
CSendingServiceInfo* serviceInfo = CSendingServiceInfo::NewL();
CleanupStack::PushL( serviceInfo );
HBufC* serviceAddress = HBufC::NewLC( KMaxServiceAddressLength );
TPtr serviceAddressPtr = serviceAddress->Des();
User::LeaveIfError( senduiRepository->Get( KSUMmsUploadAddress1 + i , serviceAddressPtr ) );
serviceInfo->SetServiceAddressL( serviceAddressPtr );
CleanupStack::PopAndDestroy( serviceAddress );
HBufC* serviceName = HBufC::NewLC( KMaxServiceNameLength );
TPtr serviceNamePtr = serviceName->Des();
User::LeaveIfError( senduiRepository->Get( KSUMmsUploadServiceName1 + i , serviceNamePtr ) );
serviceInfo->SetServiceNameL( serviceNamePtr );
CleanupStack::PopAndDestroy( serviceName );
HBufC* serviceMenuName = HBufC::NewLC( KMaxServiceMenuNameLength );
TPtr serviceMenuNamePtr = serviceMenuName->Des();
User::LeaveIfError( senduiRepository->Get( KSUMmsUploadServiceMenuName1 + i , serviceMenuNamePtr ) );
serviceInfo->SetServiceMenuNameL( serviceMenuNamePtr );
CleanupStack::PopAndDestroy( serviceMenuName );
// Set service type.
serviceInfo->SetServiceProviderId( KMmsIndirectUpload );
// Set sending capabilities.
TSendingCapabilities capabilities =
TSendingCapabilities( 0, KMaxTInt,
TSendingCapabilities::ESupportsAttachments );
serviceInfo->SetServiceCapabilities( capabilities );
TUid serviceId = KNullUid;
switch ( i )
{
case 0:
{
serviceId = KMmsUploadService1Id;
break;
}
case 1:
{
serviceId = KMmsUploadService2Id;
break;
}
case 2:
{
serviceId = KMmsUploadService3Id;
break;
}
case 3:
{
serviceId = KMmsUploadService4Id;
break;
}
default:
break;
}
serviceInfo->SetServiceId( serviceId );
iServiceArray.Append( serviceInfo );
CleanupStack::Pop( serviceInfo );
}
}
CleanupStack::PopAndDestroy( senduiRepository );
}
// -----------------------------------------------------------------------------
// CMmsIndirectUpload::CheckMmsServiceAvailabilityL
// Checks MMS service availability.
// (other items were commented in a header).
// -----------------------------------------------------------------------------
//
TBool CMmsIndirectUpload::CheckMmsServiceAvailabilityL(
RSendAs& aSendAsSession )
{
TInt i = 0;
CSendAsMessageTypes* msgTypes = CSendAsMessageTypes::NewL();
CleanupStack::PushL( msgTypes );
aSendAsSession.FilteredMessageTypesL( *msgTypes );
for ( i = 0; i < msgTypes->Count(); i++ )
{
if ( msgTypes->MessageTypeUid( i ) == KSenduiMtmMmsUid )
{
CleanupStack::PopAndDestroy( msgTypes );
return ETrue;
}
}
return EFalse;
}
// End of File