/*

* Copyright (c) 2002-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:   Provides MMS direct upload service.

*

*/

// INCLUDE FILES

#include    <CSendingServiceInfo.h>

#include    <SendUiConsts.h>

#include    <CMessageData.h>

#include    <TSendingCapabilities.h>

#include    <bautils.h>                        // BaflUtils

#include    <AknQueryDialog.h>                 // Query dialog

#include    <FeatMgr.h>

#include    <StringLoader.h>

#include    <MmsDirectUploadUi.rsg>

#include    <Mmserrors.h>

#include    <data_caging_path_literals.hrh>

#include    <Sendnorm.rsg>

#include    <aknnotewrappers.h>                // Error note

#include    <senduisingleton.h>

#include    "CMmsDirectUpload.h"

#include    "MDUSyncCreateAndSend.h"

#include    "SendUiFileRightsEngine.h"

#include    "CSendUiAttachment.h"

// CONSTANTS

const TInt KMmsUploadServiceCount       = 4;

const TInt KMmsDirectUploadService      = 1;

const TInt KMaxServiceAddressLength     = 512;

const TInt KMaxServiceNameLength        = 128;

const TInt KMaxServiceMenuNameLength    = 128;

_LIT( KMmsDirectUploadUiResource, "MmsDirectUploadUi.rsc");

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

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

// CMmsDirectUpload::CMmsDirectUpload

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

// might leave.

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

//

CMmsDirectUpload::CMmsDirectUpload( CCoeEnv& aCoeEnv, CSendUiSingleton& aSingleton ) :

	CSendingService( aCoeEnv, aSingleton ),

    iResourceLoader( iCoeEnv )

    {

    }

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

// CMmsDirectUpload::ConstructL

// Symbian 2nd phase constructor can leave.

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

//

void CMmsDirectUpload::ConstructL()

    {

    ReadServiceDataL();

    // Load UI resource file.

    TFileName resourceFile;

    TParse* fp = new(ELeave) TParse(); 

    fp->Set( KMmsDirectUploadUiResource, &KDC_RESOURCE_FILES_DIR, NULL );

    resourceFile = fp->FullName();

    delete fp;

    fp = NULL;

    iResourceLoader.OpenL( resourceFile );

    }

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

// CMmsDirectUpload::NewL

// Two-phased constructor.

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

//

CMmsDirectUpload* CMmsDirectUpload::NewL( TSendingServiceParams* aParams )

    {

    CMmsDirectUpload* self = new(ELeave) CMmsDirectUpload( aParams->iCoeEnv, aParams->iSingleton ); 

    CleanupStack::PushL(self);

    self->ConstructL();

    CleanupStack::Pop(self);

    return self;

    }

// Destructor

CMmsDirectUpload::~CMmsDirectUpload()

    {

    // Unload UI resource file.

    iResourceLoader.Close();

    iServiceArray.ResetAndDestroy();

    iServiceArray.Close();

    }

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

// CMmsDirectUpload::ServiceProviderId

// Returns the id of the service provider.

// (other items were commented in a header).

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

//

TUid CMmsDirectUpload::ServiceProviderId() const

    {

    return KMmsDirectUpload;

    }

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

// CMmsDirectUpload::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 CMmsDirectUpload::PopulateServicesListL(

    RPointerArray<CSendingServiceInfo>& aList )

    {

    for ( TInt cc = 0; cc < iServiceArray.Count(); cc++ )

        {

        User::LeaveIfError( aList.Append( iServiceArray[cc] ) );         

        }

    }

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

// CMmsDirectUpload::CreateAndSendMessageL

// Creates to outbox as many MMS messages as there are files to be send.

// (other items were commented in a header).

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

//

void CMmsDirectUpload::CreateAndSendMessageL(

    TUid                    aServiceUid,

    const CMessageData*     aMessageData,

    TBool /*aLaunchEditorEmbedded */)

    {

    TInt i = 0;

    if ( !aMessageData || ( iServiceArray.Count() == 0 ) )

        {

        return;

        }

    CArrayPtrFlat<CSendUiAttachment>* attachments;

	TInt cleanupItems = 0;

    // Get attachments

    attachments = CSendUiAttachment::InitAttachmentArrayLCC( 

        aMessageData->AttachmentArray(), 

        aMessageData->AttachmentHandleArray(),

        iCoeEnv.FsSession() );

    cleanupItems += 2;

    if ( !ValidateAttachmentsL( attachments ) )

        { // User canceled sending.

        // Cleanup: attachments, *attachments

        CleanupStack::PopAndDestroy( cleanupItems );

        return;

        }

    const CRichText* bodyText = aMessageData->BodyText();

    if ( bodyText->DocumentLength() > 0 )

        {

        CSendUiAttachment* atta = CSendUiAttachment::NewLC( *bodyText, iCoeEnv.FsSession() );

        attachments->AppendL( atta );

        CleanupStack::Pop( atta );

        }

    TInt attachmentCount = attachments->Count();

    // No valid attachments

    if ( attachmentCount <= 0 )

        {

        CleanupStack::PopAndDestroy( cleanupItems  ); // *attachmemts, attachments

        return;

        }

    // Ask users opinion about sending files in separate messages or canceling

    // the actual sending operation.

    if ( attachmentCount > 1 )

        {

        if ( !ShowConfirmationQueryL( R_MMS_DIRECT_UPLOAD_SEND_MESSAGES_QUERY,

            R_MMS_DIRECT_UPLOAD_SEND_MESSAGES, attachmentCount ) )

            {

            CleanupStack::PopAndDestroy( cleanupItems );

            return;

            }

        }

   // Get service name

    HBufC* serviceName = NULL;

    for ( i = 0; i < iServiceArray.Count(); i++)

        {

        if ( (*iServiceArray[i]).ServiceId() == aServiceUid)

            {

            serviceName = ((*iServiceArray[i]).ServiceName()).AllocLC();

            cleanupItems++;

            if ( serviceName->Length() == 0 )

                {

                User::Leave( KErrNotFound );

                }

            }

        }

    // Get service address

    HBufC*  serviceAddress = NULL;

    for ( i = 0; i < iServiceArray.Count(); i++)

        {

        if ( (*iServiceArray[i]).ServiceId() == aServiceUid)

            {

            serviceAddress = (*iServiceArray[i]).ServiceAddress().AllocLC();

            cleanupItems++;

            if ( serviceAddress->Length() == 0 )

                {

                User::Leave( KErrNotFound );

                }

            }

        }

    // Create and send messages        

    CMDUSyncCreateAndSend* messageSender = CMDUSyncCreateAndSend::NewLC( iCoeEnv, iSingleton );

    cleanupItems++;

    TRAPD( error, messageSender->CreateAndSendL(

        attachments,

        *serviceAddress,

        *serviceName,

        iMaxMsgSize ) );

    // KErrCompletion is received, if for some attachments information note was shown

    if ( !( error == KErrNone || error == KErrCompletion ))

        {

        ErrorHandlerL( error, attachmentCount );

        }

    if( messageSender->Error() )

        {

        ErrorHandlerL( messageSender->Error(), attachmentCount );

        }

    else

        {

        // Get compression results

        TInt compressionOk = 0;

        TInt compressionFail = 0;

        messageSender->CompressionResults( compressionOk, compressionFail );

        if ( compressionFail > 0 )

            {

            ResolveCompressionQueryL(

                attachmentCount, compressionFail );

            }

        }

    // Cleanup: serviceName, serviceAddress, messageSender, attachments, *attachments

    CleanupStack::PopAndDestroy( cleanupItems );

    }

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

// CMmsDirectUpload::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. EFalse is returned if user

// cancels sending, otherwise ETrue is returned.

// (other items were commented in a header).

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

//

TBool CMmsDirectUpload::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, KMmsDirectUpload );

        continueSending =

            fileRightsEngine->ShowDrmAndMmsInfoL( KMmsDirectUpload );

        CleanupStack::PopAndDestroy( fileRightsEngine );

        }

    return continueSending;

    }

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

// CMmsDirectUpload::ReadServiceDataL

// Reads service names from resource file and addresses from shared data or 

// from central repository.

// (other items were commented in a header).

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

//

void CMmsDirectUpload::ReadServiceDataL()

    {

    // Read the maximum MMS message size (bytes).

    CRepository* mmsRepository = CRepository::NewL( KCRUidMmsEngine );

    mmsRepository->Get( KMmsEngineMaximumSendSize, iMaxMsgSize );

    delete mmsRepository;

    CRepository* senduiRepository = CRepository::NewLC( KCRUidSendUi );

    TInt i = 0;

    // Go through services and get settings for direct upload services.

    // There can be 0-4 direct upload services configured.

    for ( i = 0; i < KMmsUploadServiceCount; i++)

        {

        TInt serviceType = 0;

        TInt err = senduiRepository->Get( KSUMmsUploadType1 + i , serviceType );

        // Get settings and store those to service array.

        if ( !err && serviceType == KMmsDirectUploadService )

            {

            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( KMmsDirectUpload );

            serviceInfo->SetServiceFeatures( CSendingServiceInfo::EServiceCanSendDirectly );

            // 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 );

    }

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

// CMmsDirectUpload::ShowConfirmationQueryL

// Shows confirmation query.

// (other items were commented in a header).

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

//

TBool CMmsDirectUpload::ShowConfirmationQueryL(

    const TUint&    aQueryId,

    const TUint&    aQueryTextId,

    TInt            aQueryValue) const

    {

    HBufC* prompt = NULL;

    // Get text to be shown

    if ( aQueryValue )

        {

        prompt = StringLoader::LoadLC( aQueryTextId, aQueryValue );

        }

    else

        {

        prompt = StringLoader::LoadLC( aQueryTextId );

        }

    // Create dialog

    CAknQueryDialog* dlg = CAknQueryDialog::NewL( CAknQueryDialog::ENoTone );

    TInt result = dlg->ExecuteLD( aQueryId, prompt->Des() );

    CleanupStack::PopAndDestroy( prompt ); // prompt

    return ( result == EAknSoftkeyOk );

    }

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

// CMmsDirectUpload::ErrorHandlerL

// Show confirmation query to the user if images have been compressed.

// (other items were commented in a header).

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

//

void CMmsDirectUpload::ErrorHandlerL( TInt aErr, TInt aFileCount ) const

    {

    if ( aErr )

        {

        switch ( aErr )

            {

            case KMmsErrorInvalidSettings:

            case KMmsErrorNoWAPAccessPoint:

            case KMmsErrorNoWapAp1:

                {

                ShowErrorNoteL( aFileCount > 1 ?

                    R_SENDUI_SETTINGS_NOT_OK_MANY : R_SENDUI_SETTINGS_NOT_OK );

                break;

                }

            default:

                {

                ShowConfirmationQueryL( R_MMS_DIRECT_UPLOAD_CONFIRMABLE_INFO,

                    aFileCount > 1 ? 

                    R_MMS_DIRECT_UPLOAD_CREATION_FAILED_ALL:

                    R_MMS_DIRECT_UPLOAD_CREATION_FAILED_ONE);         

                break;

                }

            }

        }

    }

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

// CMmsDirectUpload::ResolveCompressionQueryL

// Show confirmation query to the user if images have been compressed.

// (other items were commented in a header).

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

//

void CMmsDirectUpload::ResolveCompressionQueryL(

    TInt aFileCount,

    TInt aCompressionFail ) const

    {

    // Show confirmation query to the user if images have been compressed.

    if ( aCompressionFail > 0 )

        {

        // Compression has failed for all files

        if ( aFileCount == aCompressionFail )

            {

            ShowConfirmationQueryL( R_MMS_DIRECT_UPLOAD_CONFIRMABLE_INFO,

                aCompressionFail > 1 ? 

                    R_MMS_DIRECT_UPLOAD_CREATION_FAILED_ALL:

                    R_MMS_DIRECT_UPLOAD_CREATION_FAILED_ONE);

            }

        else

            {

            ShowConfirmationQueryL( R_MMS_DIRECT_UPLOAD_CONFIRMABLE_INFO,

                R_MMS_DIRECT_UPLOAD_CREATION_FAILED_SOME );

            }

        }

    }

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

// CMmsDirectUpload::ShowErrorNoteL

// Show error note to the user.

// (other items were commented in a header).

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

//   

void CMmsDirectUpload::ShowErrorNoteL( TInt aResourceId ) const

    {

    HBufC* text = static_cast<CEikonEnv&>( iCoeEnv ).AllocReadResourceLC( aResourceId );

    CAknErrorNote* note = new (ELeave) CAknErrorNote;

    note->ExecuteLD(*text);

    CleanupStack::PopAndDestroy( text ); // text

    }

TUid CMmsDirectUpload::TechnologyTypeId( ) const

{

    return TUid::Uid( KSenduiTechnologyMmsUidValue );

}

//  End of File