/*

* 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:   Can be used to show "Send" list query and to create and send

*                messages via available sending services. Created messages are

*                sent directly or message editor is opened for editing,

*                depending on the type of the selected service.

*

*/

#include <coemain.h>

#include <Sendnorm.rsg>

#include <aknlistquerydialog.h>

#include <eikmenup.h>

#include <data_caging_path_literals.hrh>

#include <DRMHelper.h>

#include <centralrepository.h>

#include <e32cmn.h> // Uid

#include <e32property.h>

#include <barsread.h>

#include <akninputblock.h>

#include <centralrepository.h>

#include <miutset.h>

#include <MessagingDomainCRKeys.h>

#include <mtclreg.h>

#include <mtudreg.h>

// Features

#include <featmgr.h>    

#include <bldvariant.hrh>

#include <MsgMimeTypes.h>

#include <CSendingServiceInfo.h>

#include <CSendingService.h>

#include <CMessageData.h>

#include <SendUiConsts.h>

#include <senduisingleton.h>

#include "SendUiImpl.h"

#include "senduiserviceclient.h"

#include "SendUiCapabilityCheck.h"

#include "SendUiUtils.h"

#include "senduiserviceslog.h"              // Logging

#include "SendUiPrivateCRKeys.h"

#include "senduiproperty.h"

#include "propertyobserver.h"

#include "senduilauncher.h"

#include "SendUiInternalConsts.h"

const TInt KArrayGranularity = 2;

const TInt KSendUiServiceOrderArrayGranularity = 6;

const TInt KTitleBufLength = 64;

//Mail Tech Uid

const TUid KMailTechnologyTypeUid = { 0x10001671 };

//CMail Tech Uid

#define KUidMsgTypeFsMtmVal     0x2001F406

_LIT( KSendUiResourceFileName,"sendnorm.rsc" );

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

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

// CSendUiImpl::NewL

// Two-phased constructor.

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

//

CSendUiImpl* CSendUiImpl::NewL()

    {

    CSendUiImpl* self = new( ELeave ) CSendUiImpl;

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop( self );

    return self;

    }

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

// Destructor

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

//

CSendUiImpl::~CSendUiImpl()

    {

    iResourceLoader.Close();

    TInt count = iSendingServices.Count();

    while ( count )

        {

        delete iSendingServices[--count];

        }

    iSendingServices.Close();

    delete iSendUiServicesOrderArray;

    delete iServicesToDim;

    delete iPropertyObserver;

    delete iSingleton;

    }

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

// AddTypedMenuItemL

//

// No menu item is added, if services are not found. This can happen if asyncronous

// sending service update is not yet finished.

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

//

void CSendUiImpl::AddTypedMenuItemL(

    CSendUi::TSendUiMenuType    aMenuType,

    CEikMenuPane&               aMenuPane,

    TInt                        aIndex,

    TInt                        aCommandId,

    TSendingCapabilities        aRequiredCapabilities )

    {

    TInt i(0);

    TBool menuItemAdded = EFalse;

    TBuf<KTitleBufLength> menuItemName;

     // Read the resources

    aMenuType == CSendUi::ESendMenu ? 

        i = R_SENDUI_MENUITEM_SEND : 

        i = R_SENDUI_MENUITEM_WRITE; // CSendUi::EWriteMenu

    iCoeEnv->ReadResourceL( menuItemName, i );

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

    {

    TUid serviceUid = iSendingServices[i]->ServiceId();

    if ( QueryCapabilities( i, aRequiredCapabilities ) )

        {

        CEikMenuPaneItem::SData data;

        data.iCascadeId = NULL;

        data.iText = menuItemName;

        data.iCommandId = aCommandId;

        data.iFlags = 0;

        if ( aIndex == aMenuPane.NumberOfItemsInPane() )

            {

            aMenuPane.AddMenuItemL( data );

            }

        else

            {

            aMenuPane.InsertMenuItemL( data, aIndex );

            }

        menuItemAdded = ETrue;

        break;

        }

    }

    // Hide menu item if sending is already in progress.

    if ( menuItemAdded )

        {

        aMenuPane.SetItemDimmed( aCommandId, iIsSending);

        }        

    }

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

// ShowTypedQueryAndSendL

// First shows list query and then creates the message.

// Editor is launched for editing the message or the message is sent

// directly without opening the editor. Functionality depends on the

// type of selected sending service.

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

//

void CSendUiImpl::ShowTypedQueryAndSendL(

    CSendUi::TSendUiMenuType    aMenuType,

    const CMessageData*         aMessageData,

    TSendingCapabilities        aRequiredCapabilities,

    CArrayFix<TUid>*            aServicesToDim,

    TBool                       aLaunchEditorEmbedded,

    const TDesC&                aTitleText )

    {

    TUid serviceId = ShowTypedQueryL(

        aMenuType,

        aMessageData,

        aRequiredCapabilities,

        aServicesToDim,

        aTitleText );

    if ( serviceId != KNullUid )

        {

        // Process user selection.

        CreateAndSendMessageL(

            serviceId,

            aMessageData,

            aLaunchEditorEmbedded);

        }

    }

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

// ShowTypedQueryL

// Shows list query and returns the user selection.

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

//

TUid CSendUiImpl::ShowTypedQueryL(

    CSendUi::TSendUiMenuType    aMenuType,

    const CMessageData*         aMessageData,

    TSendingCapabilities        aRequiredCapabilities,

    CArrayFix<TUid>*            aServicesToDim,

    const TDesC&                aTitleText )

    {

    // Implemented for CR # 401-1806 >>    

    // This section to enable/disable features (supported by feature manager) at run time, is to be revised,

    // once an observer class is available from feature manager side to intimate about feature state

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

    TInt oldFeatures(0);   

    TInt newFeatures(0); 

    TBool updateNeeded( EFalse );   

    if ( repository->Get( KKeySendUiFeatureManagerServices, oldFeatures ) != KErrNone )

    	{

    	updateNeeded = ETrue;

    	}

    FeatureManager::InitializeLibL();

    FeatureStatus( KFeatureIdMmsPostcard, newFeatures, KSendUiPostcard );

    FeatureStatus( KFeatureIdAudioMessaging, newFeatures, KSendUiAudioMessage );

    FeatureStatus( KFeatureIdSenduiMmsUpload, newFeatures, KSendUiMmsUpload );

    FeatureManager::UnInitializeLib();

    if ( newFeatures != oldFeatures )

        {

        repository->Set( KKeySendUiFeatureManagerServices, newFeatures );

        updateNeeded = ETrue;

        }

    CleanupStack::PopAndDestroy( repository );

    RProperty propertyUpdateOperation;

    TRequestStatus status;

    if ( updateNeeded )

        {

        RProperty::Set( 

            KPSUidSendUiProperty, 

            KSendUiUpdateRequest, 

            KSendUiUpdateRequested );

        User::LeaveIfError( propertyUpdateOperation.Attach( KPSUidSendUiProperty, KSendUiUpdateRequest ));

        propertyUpdateOperation.Subscribe( status );	

        User::WaitForRequest(status);

        TInt value = KErrNone;

        if(propertyUpdateOperation.Get( value ) !=KErrNotFound && value == KSendUiUpdated )

            {

            TRAPD( err, GetServicesL() );

            if ( err )

                {

#ifdef _DEBUG

                TBuf<256> buf;

                buf.Format(_L("SendUi err"));

                User::InfoPrint(buf);

#endif

                TUid serviceId( KNullUid );

                return serviceId;

                }

            }

        propertyUpdateOperation.Close();

        }

    // Implemented for CR # 401-1806 <<    

    // List items for list query.

    CDesCArrayFlat* listItems = new (ELeave) CDesCArrayFlat( KArrayGranularity );

    CleanupStack::PushL( listItems);

    // This array is used to map user selection to correct service.

    CArrayFix<TUid>* listItemUids = 

        new ( ELeave ) CArrayFixFlat<TUid>( KArrayGranularity );

    CleanupStack::PushL( listItemUids );

    iServicesToDim->Reset();

    TInt i = 0;

    if ( aServicesToDim )

        {

        for ( i = 0; i < aServicesToDim->Count(); i++  )

            {

            iServicesToDim->AppendL( (*aServicesToDim)[i] );

            }

        }

    // Get and filter ECom based services.

    FilterServicesL(

        *listItems,

        *listItemUids,

        aRequiredCapabilities,

        aMessageData,

        aMenuType );

    TUid serviceId( KNullUid );

    if ( listItems->Count() > 0 )

        {

        // Show list query.

        SortListL( *listItems, *listItemUids );

        serviceId = ShowListQueryL(

            listItems,

            *listItemUids,

            aTitleText,

            aMenuType );

        }

    CleanupStack::PopAndDestroy( 2, listItems );  // listItemUids, listItems

    return serviceId;

    }

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

// SendMessageL

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

TInt CSendUiImpl::SendMessageL(    

    TUid                    aServiceUid,

    const CMessageData*     aMessageData,

    TBool                   aLaunchEditorEmbedded)

    { 

    if ( iIsSending || aServiceUid == KNullUid )

        {

        return KErrNone;

        }

        CAknInputBlock* absorber = CAknInputBlock::NewLC( ); 

        // Ensures proper sending state if leave happens.

        iIsSending = ETrue;

        TInt success( KErrNone );

        CleanupStack::PushL( TCleanupItem( ResetIsSending, (TAny*)&iIsSending ) );

        // Create the requested ECom service.

        TInt i( ResolveServiceIndex( aServiceUid ));

        if ( i != KErrNotFound )

            {

            TRAP( success, 

                CSendingService* sendingService = CSendingService::NewL( 

                    iSendingServices[i]->ServiceProviderId(), *iCoeEnv, *iSingleton );

                CleanupStack::PushL( sendingService );  

                sendingService->CreateAndSendMessageL( aServiceUid, aMessageData, aLaunchEditorEmbedded );

                CleanupStack::PopAndDestroy( sendingService );

                    );

            }

        else

            {

            iIsSending = EFalse;

            }

    CleanupStack::PopAndDestroy( 2, absorber); // TCleanupItem, absorber

    return success;

    }

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

// SendMessageViaServer

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

//

void CSendUiImpl::SendMessageViaServerL( 

    TUid                    aServiceUid,

    const CMessageData*     aMessageData,

    TBool                   aLaunchEditorEmbedded )

    {

    TInt index( ResolveServiceIndex( aServiceUid ));

    TBool capabilitiesOk = ETrue;

    if ( index == KErrNotFound )

    	{

    	return;

    	}

    if ( iSendingServices[index]->ServiceFeatures() & CSendingServiceInfo::EServiceCanSendDirectly )

    	{

	    // Check sending rights

	    RProcess process;

	    TSecurityInfo securityInfo( process );

	    CSendUiCapabilityCheck* capabilityCheck = CSendUiCapabilityCheck::NewLC();

		capabilitiesOk = capabilityCheck->CheckCapabilitiesL( 

		    securityInfo, 

		    iSingleton->MsvSessionL(), 

		    KSenduiMtmMmsUid, 

		    iSendingServices[index]->ServiceName() );

		CleanupStack::PopAndDestroy( capabilityCheck );

	    }

    if ( capabilitiesOk )

    	{

        TUid providerUid = iSendingServices[index]->ServiceProviderId();	

	    RSendUiServiceClient sendUiClient;

	    CleanupClosePushL( sendUiClient );

	    sendUiClient.ConnectChainedAppL( KSendUiLauncherAppUid );

	    // LaunchSendUiL is syncronous operation

	    sendUiClient.LaunchSendUiL( 

	        aServiceUid,

	        providerUid,

	        aLaunchEditorEmbedded, 

	        aMessageData ); 

	    CleanupStack::PopAndDestroy( &sendUiClient);

    	}

    }

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

// CreateAndSendMessageL

// Creates the message and launches the editor for editing the message

// or sends the message directly without opening the editor. 

// Functionality depends on the type of selected sending service.

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

//

void CSendUiImpl::CreateAndSendMessageL(

    TUid                    aServiceUid,

    const CMessageData*     aMessageData,

    TBool                   aLaunchEditorEmbedded )

    {

    LOGTEXT(_L("CSendUiImpl::CreateAndSendMessageL >>"));

    TInt err(0); // initializing this to 0 helps debugging SendMessageViaServerL

    err = SendMessageL( aServiceUid, aMessageData, aLaunchEditorEmbedded );

    if ( !iServerAppLaunch && ( err == KErrPermissionDenied || err == KErrAccessDenied ) )

        {

        SendMessageViaServerL( aServiceUid, aMessageData, aLaunchEditorEmbedded );

        }

    else

       	{

        User::LeaveIfError( err );

       	}

    LOGTEXT(_L("CSendUiImpl::CreateAndSendMessageL <<"));

   }

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

// ServiceCapabilitiesL

// Returns sending capabilities of the sending service.

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

//

TInt CSendUiImpl::ServiceCapabilities(

    TUid                    aServiceUid,

    TSendingCapabilities&   aServiceCapabilities )

    {

    TInt i( ResolveServiceIndex( aServiceUid ));

    if ( i != KErrNotFound )

        {

        aServiceCapabilities = 

            iSendingServices[i]->ServiceCapabilities();

        i = KErrNone;        

        }

    return i;

    }

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

// AvailableServicesL

// Populates given list with the information about services

// provided by specified ECom service provider.

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

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

//

void CSendUiImpl::AvailableServicesL(

    RPointerArray<CSendingServiceInfo>& aServiceList,

    TUid aServiceProvider)

    {

    for ( TInt i(0); i < iSendingServices.Count(); i++ )

        {

        if ( iSendingServices[i]->ServiceProviderId() == aServiceProvider 

            || aServiceProvider == KNullUid )

            {

            CSendingServiceInfo* serviceInfo = iSendingServices[i]->CopyLC();

            aServiceList.AppendL( serviceInfo );

            CleanupStack::Pop( serviceInfo ); // serviceInfo

            }

        }

    }

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

// TechnologyType

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

//

TUid CSendUiImpl::TechnologyType( TUid aServiceUid )

    {

    TInt i = ResolveServiceIndex( aServiceUid );

    if ( i != KErrNotFound )

        {

        return iSendingServices[i]->TechnologyTypeId(); 

        }

    else

        {        

        return TUid::Null();

        }

    }

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

//

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

//

TInt CSendUiImpl::ResolveServiceIndex( TUid aServiceUid )

    {

    TInt index( iSendingServices.Count() );

    while( --index >= 0)

        {

        if ( iSendingServices[index]->ServiceId() == aServiceUid )

            {

            return index;           

            }

        }

    return KErrNotFound;

    }

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

// QueryCapabilities

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

//

TBool CSendUiImpl::QueryCapabilities( 

    TInt index, 

    TSendingCapabilities aRequiredCapabilities )

    {

    if ( index == KErrNotFound )

    	{

    	return EFalse;

    	}

     if ( aRequiredCapabilities.iFlags == TSendingCapabilities::EAllServices )

        { 

        // No capabilities required from service

        return ETrue;

        }

    TSendingCapabilities serviceCap = iSendingServices[ index ]->ServiceCapabilities();

    if ( !(serviceCap.iMessageSize == 0 // no size limit set for the service

    || aRequiredCapabilities.iMessageSize == 0 ) // no size limit asked from the client

    && aRequiredCapabilities.iMessageSize > serviceCap.iMessageSize )

        {

        return EFalse;