/*

* 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:   ECOM plugin .dll for handling MMS related WAP push messages.

*

*/

// INCLUDE FILES

#include <e32std.h>

#include <msvapi.h>

#include <msvids.h>

#include <msvuids.h>

#include <e32math.h>

#include <apparc.h>

#include <push/cpushhandlerbase.h>

#include <ecom/implementationproxy.h>

#include <push/pluginkiller.h>

#include <push/pushmessage.h>

#include <push/pushlog.h>

#include "mmsconst.h"

#include "mmscmds.h"

#include "CMmsPushHandler.h"

#include "mmsgenutils.h"

// EXTERNAL DATA STRUCTURES

// EXTERNAL FUNCTION PROTOTYPES  

// CONSTANTS

const TUint KMinimumNumberOfMessageFields = 6;

// ECOM framework related

const TImplementationProxy ImplementationTable[] = 

    {

    // different definition for new compiler

    IMPLEMENTATION_PROXY_ENTRY(0x101F4692, CMmsPushHandler::NewL)

    };

// MACROS

// LOCAL CONSTANTS AND MACROS

// MODULE DATA STRUCTURES

// LOCAL FUNCTION PROTOTYPES

// FORWARD DECLARATIONS

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

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

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

// CMmsPushHandler::New

// 1st phase constructor

// Returns: <new CMmsPushHandler>:

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

//

CMmsPushHandler* CMmsPushHandler::NewL()

    {

    CMmsPushHandler* self = new( ELeave ) CMmsPushHandler();

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop( self );

    LOGTEXT(_L("***** CMmsPushHandler NewL() *****"));

    return self;

    }

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

// CMmsPushHandler::CMmsPushHandler

// Initialises the object with zero/NULL values.

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

//

CMmsPushHandler::CMmsPushHandler()

    :CPushHandlerBase(),

    iState( EInitial ),

    iServiceId( KMsvNullIndexEntryId ),

    iMsvSession( NULL ),

    iMsvOperation( NULL ),

    iPushMsg( NULL ),

    iBody( NULL ),

    iRetryCount( 0 )

    {

    }

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

// CMmsPushHandler::ConstructL

//

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

//

void CMmsPushHandler::ConstructL()

    {

    // Connect to filesystem

    User::LeaveIfError( iFs.Connect() );

    User::LeaveIfError( iTimer.CreateLocal() );

    // Add plugin to AS

    CActiveScheduler::Add( this );

    }

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

// CMmsPushHandler::~CMmsPushHandler

// Destructor. Calls also baseclass destructor which calls

//  REcomSession::DestroyedImplementation(iDtor_ID_Key)

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

//

CMmsPushHandler::~CMmsPushHandler()

    {

    LOGTEXT(_L("~CMmsPushHandler()"));

    // AO's destructor always calls Cancel()

    Cancel();

    // Delete the necessary instance attributes

    delete iMsvSession;

    delete iMsvOperation;

    delete iPushMsg;

    delete iBody;

    iFs.Close();

    iTimer.Close();

    }

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

// CMmsPushHandler::HandleMessageL

// 

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

//

void CMmsPushHandler::HandleMessageL(

    CPushMessage* aPushMsg,

    TRequestStatus& aStatus )

    {

    LOGTEXT(_L("Asynchronous HandleMessageL() called but not implemented."));

    iPushMsg = aPushMsg;

    SetConfirmationStatus( aStatus );

    SignalConfirmationStatus( KErrNotSupported );

    iPluginKiller->KillPushPlugin();

    }

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

// CMmsPushHandler::HandleMessageL

// 

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

//

void CMmsPushHandler::HandleMessageL( CPushMessage* aPushMsg )

    {

    LOGTEXT( _L("Synchronous HandleMessageL() called.") );

    iPushMsg = aPushMsg;

    //

    // Do sanity checks for the message.

    //

    TInt error = PerformChecks();

    if ( error )

        {

        LOGTEXT2( _L("HandleMessageL(): PerformChecks failed with code %d, returning silently. Notification is lost."), error );

        iPluginKiller->KillPushPlugin();        

        return;

        }

    //

    // Store the messagebody into handler's attribute

    // If memory runs out, tough luck..

    //

    TPtrC8 messageBodyPtr;

    if ( iPushMsg->GetMessageBody( messageBodyPtr ) )

        {

        iBody = messageBodyPtr.Alloc();

        if ( !iBody )

            {

        	LOGTEXT( _L("HandleMessageL(): Out of memory when allocating body buffer") );

        	// Commit suicide - the caller expects it even if we leave

        	iPluginKiller->KillPushPlugin();

        	User::Leave( KErrNoMemory );

            }

        }

    //

    // Setting 'this' active and complete in order to get to RunL

    //

    TRequestStatus* status = &iStatus;

    iStatus = KRequestPending;

    User::RequestComplete( status, KErrNone ); //iStatus = KErrNone

    SetActive();

    }

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

// CMmsPushHandler::CancelHandleMessage

// Cancels the pending asynchronous HandleMessageL.

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

//

void CMmsPushHandler::CancelHandleMessage()

    {

    LOGTEXT( _L("CancelHandleMessage() called, but not supported.") );

    }

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

// CMmsPushHandler::HandleSessionEventL

// 

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

//

void CMmsPushHandler::HandleSessionEventL(

    TMsvSessionEvent aEvent, 

    TAny* /*aArg1*/, 

    TAny* /*aArg2*/, 

    TAny* /*aArg3*/)

    {

    switch (aEvent)

        {

        // If session is closed down, the object will be deleted

        case EMsvCloseSession:

            LOGTEXT(_L("HandleSessionEventL(): Session event EMsvCloseSession"));

            // fall through on purpose

        case EMsvServerTerminated:

            LOGTEXT(_L("HandleSessionEventL(): Session event EMsvServerTerminated"));

            if ( iMsvSession )

                {

                delete iMsvSession;

                iMsvSession = NULL;

                }

            break;

        case EMsvMediaUnavailable:

            LOGTEXT(_L("HandleSessionEventL(): EMsvMediaUnavailable"));

            break;

        default:

            //Nothing

            break;

        }

    }

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

// CMmsPushHandler::DoCancel

// 

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

//

void CMmsPushHandler::DoCancel()

    {

    LOGTEXT( _L("DoCancel()") );

    if( iState == ETransferCommand && iMsvOperation )

        {

        iMsvOperation->Cancel();

        }

    else if( iState == EMsDriveChange && iMsvOperation )

        {

        iMsvOperation->Cancel();

        }

    else if( iState == ETimer )

        {

        iTimer.Cancel();

        }

    else if( iState == EDiskSpaceWait )

        {

        iFs.NotifyDiskSpaceCancel();

        }

    // Finally clean up

    iPluginKiller->KillPushPlugin();

    }

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

// CMmsPushHandler::RunL

// Loops forever if MessageServer/ServerMtm respond correctly

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

//

void CMmsPushHandler::RunL()

    {

    LOGTEXT(_L("RunL(): Starting"));

    // Check for cancel

    if( iStatus == KErrCancel )

        {

        LOGTEXT( _L("RunL(): Operation cancelled.") );

        iPluginKiller->KillPushPlugin();

        return;

        }

    // Checking the retry count, because if something just keeps going wrong

    // there is nothing that can be done

    if( ++iRetryCount > KRetryCount )

        {

        LOGTEXT( _L("RunL(): Retrycount exceeded, quitting. Notification is lost.") );

        iPluginKiller->KillPushPlugin();

        return;

        }

    TInt error = KErrNone;

    //

    // Operation: TransferCommand

    //

    if( iState == ETransferCommand )

        {

        // Clean up

        if( iMsvOperation )

            {

            delete iMsvOperation;

            iMsvOperation = NULL;

            }

        // Go through statuses

        if( iStatus == KErrNone )

            {

            LOGTEXT( _L("RunL(): TransferCommandL() succeeded.") );

            iPluginKiller->KillPushPlugin();

            return;

            }

        else if( iStatus == KErrLocked ) // for a short wait

            {

            LOGTEXT2( _L("RunL(): TransferCommandL failed with code %d, entering short wait."), iStatus.Int() );

            iTimer.After( iStatus, KShortWait );

            iState = ETimer;

            SetActive();

            return;

            }

        else // default is long wait

            {

            LOGTEXT2( _L("RunL(): TransferCommandL failed with code %d, entering long wait."), iStatus.Int() );

            iTimer.After( iStatus, KLongWait );

            iState = ETimer;

            SetActive();

            return;

            }

        }

    //

    // Open session if not open

    // Session is needed to check drive

    //

    if ( !iMsvSession  )

        {

        TRAP( error, OpenSessionL() );

        if( error )

            {

            LOGTEXT2( _L("RunL: OpenSessionL left with code %d, entering long wait."), error );

            iState = ETimer;

            iTimer.After( iStatus, KLongWait );

            SetActive();

            return;

            }

        }

    //

    // Operation: MessageStore Drive Change

    //

    if( iState == EMsDriveChange )

        {

        // Clean up

        if( iMsvOperation )

            {

            delete iMsvOperation;

            iMsvOperation = NULL;

            }

        // Drive should be now on 'C:'

        // Asserting this:

        if( iMsvSession->CurrentDriveL() != EDriveC )

            {

            // if not, giving up without retrying

            LOGTEXT( _L("RunL(): Drive change attempt did not work, returning silently. Notification is lost." ) );

            iPluginKiller->KillPushPlugin();

            return;                        

            }

        LOGTEXT( _L("RunL(): Drive change attempt succeeded." ) );        

        }

    //

    // Find MMS default serviceId if not yet found

    //

    if( iServiceId == 0 )

        {

        TRAP( error, FindServiceL() );

        // If MessageStore is not available and push message is a notification,

        // The message store must be moved to C:

        // (delivery reports are handled on best effort basis)

        if( ( error == KErrCorrupt ||         

              error == KErrNotReady )          

            && (*iBody)[1] == 0x82 )

            { 

            // Try changing MessageStore to C:

            LOGTEXT2( _L("RunL: FindServiceL left with code %d, changing drive."), error );

            TRAP( error, { iMsvOperation = iMsvSession->ChangeDriveL( EDriveC, iStatus ); } );

            if( error == KErrNone )

                {

                iState = EMsDriveChange;

                SetActive();

                return;

                }

            else

                {

                LOGTEXT2( _L("RunL: ChangeDriveL left with code %d."), error );

                // This falls to the next if statement (below) on purpose

                }

            }

        if( error != KErrNone ) // error is something else

            {

            LOGTEXT2( _L("RunL(): FindServiceL left with code %d, returning silently. Notification is lost."), error );

            iPluginKiller->KillPushPlugin();

            return;            

            }

        if( iServiceId == 0 ) // if iService still is 0 (FindServiceL should have found this)

            {

            LOGTEXT( _L("RunL(): FindServiceL didn't find MMS serviceId, returning silently. Notification is lost." ) );        

            iPluginKiller->KillPushPlugin();

            return;            

            }

        }

    //

    // Checking disk space before using it

    //

    TRAP( error, { error = CheckDiskSpaceL(); } );

    if( error == KErrDiskFull )

        {

        // CheckDiskSpaceL has handled the situation, i.e. we should active already

        return;

        }

    else if( error != KErrNone ) // other error

        {

        LOGTEXT2( _L("RunL(): CheckDiskSpaceL left with code %d, entering short wait."), error );

        iTimer.After( iStatus, KShortWait );

        iState = ETimer;

        SetActive();

        return;

        }

    //

    // Transfer the push message to MessageServer side

    //

    TRAP( error, TransferMessageL() );

    if( error == KErrCorrupt     // MMC is not present

        && (*iBody)[1] == 0x82 ) // push message is a notification

        {

        LOGTEXT( _L("RunL: TransferMessageL left with code %d, changing drive.") );

        // Try changing MessageStore to C:

        TRAP( error, { iMsvOperation = iMsvSession->ChangeDriveL( EDriveC, iStatus ); } );

        if( error == KErrNone )

            {

            iState = EMsDriveChange;

            SetActive();

            return;

            }

        else

            {

            LOGTEXT2( _L("RunL: ChangeDriveL left with code %d."), error );

            // This falls to the next if statement (below) on purpose

            }

        }

    if( error != KErrNone ) // other error

        {

        LOGTEXT2( _L("RunL(): TransferMessageL left with code %d, entering short wait."), error );

        iTimer.After( iStatus, KShortWait );

        iState = ETimer;

        SetActive();

        return;

        }

    }

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

// CMmsPushHandler::CPushHandlerBase_Reserved1

// 

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

//

void CMmsPushHandler::CPushHandlerBase_Reserved1()

    {

    User::Panic(

        _L("CPushHandlerBase_Reserved1() not supported."), 

        KErrNotSupported );

    }

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

// CMmsPushHandler::CPushHandlerBase_Reserved2

// 

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

//

void CMmsPushHandler::CPushHandlerBase_Reserved2()

    {

    User::Panic(

        _L("CPushHandlerBase_Reserved2() not supported."),

        KErrNotSupported );

    }

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

// CMmsPushHandler::PerformChecksL

// 

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

//

TInt CMmsPushHandler::PerformChecks()

    {

    // Check that message is not equal to NULL

    if( !iPushMsg )

        {

        LOGTEXT( _L("ERROR: Message == NULL.") );

        return KErrCorrupt;

        }

    // Check that body is not equial to NULL

    TPtrC8 messageBodyPtr;

    TBool bodyPresent = EFalse;

    bodyPresent = iPushMsg->GetMessageBody( messageBodyPtr );

    if( !bodyPresent )

        {

        LOGTEXT( _L("ERROR: Message has NULL body.") );

        return KErrCorrupt;

        }

    // KMinimumNumberOfMessageFields (6) is minimum number of message fields. 

    // This is a very "mild" check but

    // at least it guarantees that there is no empty body in the message

    if( messageBodyPtr.Size() < KMinimumNumberOfMessageFields )

        {

        LOGTEXT( _L("ERROR: Message has too short body.") );

        return KErrCorrupt;

        }

    // Check message-type

    TPtrC contentTypePtr;

    iPushMsg->GetContentType( contentTypePtr );

    _LIT( KMmsContentType, "application/vnd.wap.mms-message" );

    if( contentTypePtr.Compare( KMmsContentType ) != 0 )

        {