/*

* Copyright (c) 2002-2007 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: mmsclient implementation

*

*/

// INCLUDE FILES

#include    <txtrich.h>

#include    <msvids.h>

#include    <badesca.h>

#include    <msvstore.h>

#include    <mtmuids.h> 

#include    <mtclbase.h>

#include    <mtmdef.h>

#include    <logcli.h>

#include    <msvftext.h>       // CMsvFindText 

#include    <cmsvmimeheaders.h>

#include    <mmsvattachmentmanager.h>

#include    <mmsvattachmentmanagersync.h>

#include    <charconv.h>

#include    <msgtextutils.h>

// mms headers

#include    "mmsheaders.h"

#include    "mmssettings.h"

#include    "mmsclient.h"

#include    "mmsmessageoperation.h"

#include    "mmsgenutils.h"

#include    "mmscmds.h"

#include    "mmsattachmenthandler.h"

#include    "mmssendingchain.h"

#include    "mmsattachmentwaiter.h"

#include    "mmssendmessageoperation.h"

// EXTERNAL DATA STRUCTURES

// EXTERNAL FUNCTION PROTOTYPES  

// CONSTANTS

#ifdef _DEBUG

#undef _NO_MMSC_LOGGING_

#endif

_LIT( K1970, "19700000:000000.000000" );    // 1-Jan 1970 0:00:00

// MACROS

// LOCAL CONSTANTS AND MACROS

const TInt KMmsAttributeArrayGranularity = 8;

// MODULE DATA STRUCTURES

// LOCAL FUNCTION PROTOTYPES

// ==================== LOCAL FUNCTIONS ====================

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

// Factory function.

EXPORT_C CMmsClientMtm* CMmsClientMtm::NewL(

    CRegisteredMtmDll& aRegisteredMtmDll,

    CMsvSession& aSession )

    {

    CMmsClientMtm* self=new( ELeave ) CMmsClientMtm(

        aRegisteredMtmDll, aSession );

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop( self );

    return self;

    }

// Constructor

// Notice that CMmsNotificationClientMtm constructor calls this.

CMmsClientMtm::CMmsClientMtm(

    CRegisteredMtmDll& aRegisteredMtmDll,

    CMsvSession& aSession )

    : CBaseMtm( aRegisteredMtmDll, aSession ),

    iMmsSettings ( NULL ),

    iMmsHeaders ( NULL ),

    iServiceId ( KMsvNullIndexEntryId ),

    iFetchAll( EFalse ),

    iFetchOverride( ETrue ),

    iOwnSession( aSession ),

    iAttaWaiter( NULL )

    {

    }

// Destructor

CMmsClientMtm::~CMmsClientMtm()

    {

    delete iAttaWaiter;

    // We created the settings, it is ours to delete

    delete iMmsSettings;

    delete iMmsHeaders;

    if ( iAttributes != 0 )

        {

        iAttributes->Reset();

        }

    delete iAttributes;

    }

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

// CMmsClientMtm::CreateNewEntryL

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

//

CMsvOperation* CMmsClientMtm::CreateNewEntryL(

            TMsvId aDestination, 

            TRequestStatus& aCompletionStatus)

    {

    return CMmsMessageOperation::CreateNewL(

            aCompletionStatus,

            Session(),

            aDestination,

            iServiceId );

    }

// DEPRECATED - TO BE REMOVED IN THE FUTURE

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

// CMmsClientMtm::CreateServiceL

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

//

void CMmsClientMtm::CreateServiceL()

    {

    TMsvId service = KMsvNullIndexEntryId;

    // load settings in order to be sure the old ones are deleted

    iMmsSettings->LoadSettingsL();

    // creates new service entry + new notification and mmbox folder entries

    iMmsSettings->CreateNewServiceL( Session() );

    // save the new entry ids into cenrep immediatedly

    iMmsSettings->SaveSettingsL();

    // Get the base values to detect changes

    // This function should not be idly called, so this should be safe.

    iHomeMode = iMmsSettings->ReceivingModeHome();

    iRoamingMode = iMmsSettings->ReceivingModeForeign();

    iAccessPointCount = iMmsSettings->AccessPointCount();

    // service id must be returned

    service = iMmsSettings->Service();

    if ( service == KMsvNullIndexEntryId )

        {

        // No new entry created

        User::Leave( KErrNotSupported );

        }

    SwitchCurrentEntryL( service );

    }

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

// CMmsClientMtm::MmsSettings()

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

//

const CMmsSettings& CMmsClientMtm::MmsSettings()

    {

    return *iMmsSettings;

    }

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

// CMmsClientMtm::SetSettingsL

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

//

void CMmsClientMtm::SetSettingsL( const CMmsSettings& aSettings )

    {

    // copy caller's settings to our member

    iMmsSettings->CopyL( aSettings );

    }

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

// CMmsClientMtm::StoreSettingsL()

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

//

void CMmsClientMtm::StoreSettingsL()

    {

    // Check that sufficient disk space available

    if ( iAccessPointCount < iMmsSettings->AccessPointCount() )

        {

        // Disk space checked only if the file size increases.

        // And the file size increases only when access points are added.

        if ( TMmsGenUtils::DiskSpaceBelowCriticalLevelL( 

            &Session().FileSession(), 

            KMmsAccessPointDiskSpaceNeed,

            EDriveC ) )

            {

            // we use standard error code here

            User::Leave( KErrDiskFull );

            }

        }

    iMmsSettings->SaveSettingsL();

    // if one of the receiving modes have changed to automatic,

    // start fetching deferred messages 

    TInt homeMode = iMmsSettings->ReceivingModeHome();

    TInt roamMode = iMmsSettings->ReceivingModeForeign();

    if ( ( homeMode != iHomeMode && homeMode == EMmsReceivingAutomatic ) ||

        ( roamMode != iRoamingMode && roamMode == EMmsReceivingAutomatic ))

        {

        // fetch all, but only if fetching mode allows it.

        iFetchAll = ETrue;

        iFetchOverride = EFalse;

        }

    else

        {

        iFetchAll = EFalse;

        iFetchOverride = ETrue;

        }

    // We don't leave the settings store function just because the automatic

    // fetch operation leaves. Some entry may be locked and cannot be fetched

    // or some other problem may prevent the fetch.

    // Settings are stored anyway.

    TInt error = KErrNone;

    TRAP( error,

        if ( iFetchAll )

            {

            // Implicit fetch of messages, wrap asynch method to make it synch.

            CMsvOperation* myOperation;

            myOperation = NULL;        

            CMsvOperationActiveSchedulerWait* wait = 

               CMsvOperationActiveSchedulerWait::NewLC();

            // FetchAllL only schedules notifications in mms folder

            myOperation = FetchAllL( wait->iStatus, iFetchOverride );

            // temporary.

            CleanupStack::PushL( myOperation );

            wait->Start();

            CleanupStack::PopAndDestroy( myOperation );

            CleanupStack::PopAndDestroy( wait );

            // Then the notifications in inbox

            wait = CMsvOperationActiveSchedulerWait::NewLC();

            wait->iStatus = KRequestPending;

            // FetchAllFromInboxL only schedules notifications in inbox

            myOperation = FetchAllFromInboxL( wait->iStatus, iFetchOverride );

            CleanupStack::PushL( myOperation );

            wait->Start();

            CleanupStack::PopAndDestroy( myOperation );

            CleanupStack::PopAndDestroy( wait );

            iFetchAll = EFalse; // don't do this next time unless needed...

            }

        );

    // Reset the remembered values

    iHomeMode = iMmsSettings->ReceivingModeHome();

    iRoamingMode = iMmsSettings->ReceivingModeForeign();

    iAccessPointCount = iMmsSettings->AccessPointCount();

    }

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

// CMmsClientMtm::RestoreSettingsL()

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

//

void CMmsClientMtm::RestoreSettingsL()

    {

    // The settings may have been changed without us knowing it.

    // We do not reset saved mode values here, because we try to

    // detect if receiving mode has change since we last checked

    // in StoreSettingsL() function.

    iMmsSettings->LoadSettingsL();

    }   

// DEPRECATED - TO BE REMOVED IN THE FUTURE

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

// CMmsClientMtm::RestoreFactorySettingsL

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

//

void CMmsClientMtm::RestoreFactorySettingsL( TMmsFactorySettingsLevel aLevel )

    {

    iMmsSettings->LoadSettingsL();

    iMmsSettings->RestoreFactorySettingsL( Session(), aLevel );

    // StoreSettingsL triggers the fetching of messages if the receiving mode

    // has changed in a way that requires it.

    StoreSettingsL();

    }

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

// MMS HEADER HANDLING METHODS

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

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

// CMmsClientMtm::SetSenderL

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

//

void CMmsClientMtm::SetSenderL( const TDesC& aAlias )

    {

    iMmsHeaders->SetSenderL( aAlias );

    }

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

// CMmsClientMtm::Sender

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

//

const TPtrC CMmsClientMtm::Sender( ) const

    {

    return iMmsHeaders->Sender();

    }

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

// CMmsClientMtm::MessageClass

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

//

void CMmsClientMtm::SetMessageClass( TMmsMessageClass aMessageClass )

    {

    iMmsHeaders->SetMessageClass( aMessageClass );

    }

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

// CMmsClientMtm::MessageClass

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

//

TInt CMmsClientMtm::MessageClass() const

    {

    return iMmsHeaders->MessageClass();

    }

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

// CMmsClientMtm::SetMessagePriority

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

//

void CMmsClientMtm::SetMessagePriority( TMmsMessagePriority aPriority )

    {

    iMmsHeaders->SetMessagePriority(aPriority);

    }

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

// CMmsClientMtm::MessagePriority

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

//

TInt CMmsClientMtm::MessagePriority() const

    {

    return iMmsHeaders->MessagePriority();

    }

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

// CMmsClientMtm::SetSenderVisibility

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

//

void CMmsClientMtm::SetSenderVisibility( TMmsMessageSenderVisibility aVisibility )

    {

    iMmsHeaders->SetSenderVisibility(aVisibility);

    }

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

// CMmsClientMtm::SenderVisibility

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

//

TInt CMmsClientMtm::SenderVisibility() const

    {

    return iMmsHeaders->SenderVisibility();

    }

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

// CMmsClientMtm::SetDeliveryReport

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

//

void CMmsClientMtm::SetDeliveryReport( TMmsMessageDeliveryReport aVisibility )

    {

    iMmsHeaders->SetDeliveryReport(aVisibility);

    }

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

// CMmsClientMtm::DeliveryReport

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

//

TInt CMmsClientMtm::DeliveryReport() const

    {

    return iMmsHeaders->DeliveryReport();

    }

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

// CMmsClientMtm::SetReadReply

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

//

void CMmsClientMtm::SetReadReply( TMmsMessageReadReply aRequest )

    {

    iMmsHeaders->SetReadReply(aRequest);

    }

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

// CMmsClientMtm::ReadReply

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

//

TInt CMmsClientMtm::ReadReply() const

    {

    return iMmsHeaders->ReadReply();

    }

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

// CMmsClientMtm::SetMessageRootL

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

//

void CMmsClientMtm::SetMessageRootL( const TMsvAttachmentId aId )

    {

    // We cannot check if the attachent id is legal because Symbian

    // message server panics if the store is already open.

    // We must just trust the caller.

    iMmsHeaders->SetMessageRoot( aId );

    }

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

// CMmsClientMtm::MessageRootAttachment

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

//

TMsvAttachmentId CMmsClientMtm::MessageRootAttachment() const

    {

    // This function only returns what has been set earlier by the caller.

    // As the caller can manipulate the attachments without calling

    // MMS Client MTM, we cannot keep track of the presence of the root

    // attachment. It is up to the user to handle the case where the root

    // has been deleted.

    return iMmsHeaders->MessageRoot();

    }

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

// CMmsClientMtm::SendingDate

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

//

TTime CMmsClientMtm::SendingDate() const

    {

    TInt64 inSeconds = iMmsHeaders->Date();

    TTime y1970( K1970 );

    // 1970 presented as microseconds after January 1st, 0 AD Gregorian.

    TInt64 ms1970 = y1970.Int64();

    // If not defined in message headers return 0

    if ( inSeconds == 0 )

        {

        return TTime( 0 );

        }

    return TTime( ms1970 + ( inSeconds * KMmsMillion ) );

    }

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

// CMmsClientMtm::SetMaximumImage

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

//

void CMmsClientMtm::SetMaximumImage( TInt aHigh, TInt aWidth )

    {

    iMmsHeaders->SetMaximumImage( aHigh, aWidth );

    }

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

// CMmsClientMtm::GetMaximumImage

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

//

void CMmsClientMtm::GetMaximumImage( TInt& aHeight, TInt& aWidth ) const

    {

    iMmsHeaders->GetMaximumImage( aHeight, aWidth );

    }

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

// CMmsClientMtm::SetExpiryInterval

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

//       

void CMmsClientMtm::SetExpiryInterval( 

    TTimeIntervalSeconds aInterval )

    {

    iMmsHeaders->SetExpiryInterval(aInterval.Int());

    }

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

// CMmsClientMtm::ExpiryInterval

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

//

TTimeIntervalSeconds CMmsClientMtm::ExpiryInterval() const

    {

    TTimeIntervalSeconds seconds(iMmsHeaders->ExpiryInterval());

    return seconds;

    }

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

// CMmsClientMtm::SetExpiryDate

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

//

void CMmsClientMtm::SetExpiryDate( TTime aDate )

    {

    TTime y1970( K1970 );

    TTimeIntervalMicroSeconds interval;

    // we can't use "seconds from" as it only returns a

    // 32 bit signed integer. If fails in 2038.

    // "microseconds from" returns a 64 bit signed integer

    interval = aDate.MicroSecondsFrom( y1970 );

    if ( interval.Int64() > 0 )

        {

        // expiry date in iMmsHeaders() in seconds from 1.1.1970.

        iMmsHeaders->SetExpiryDate( ( interval.Int64() ) / KMmsMillion );

        }

    }

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

// CMmsClientMtm::ExpiryDate

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

//

TTime CMmsClientMtm::ExpiryDate() const

    {

    TTime y1970( K1970 );

    // 1970 presented as microseconds after January 1st, 0 AD Gregorian.

    TInt64 ms1970 = y1970.Int64();