/*
* Copyright (c) 2002 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 IMPS related WAP push messages.
*
*/


// INCLUDE FILES
#include <e32std.h>
#include <CPushHandlerBase.h>
#include <ecom/ImplementationProxy.h>
#include <PluginKiller.h>
#include <PushMessage.h>
#include <PushLog.h>
#include "ImpsPushHandler.h"

// CONSTANTS

_LIT8( KWVID, "WVCI*" );

// ECOM framework related
const TImplementationProxy ImplementationTable[] = 
    {
#ifdef __EABI__
    IMPLEMENTATION_PROXY_ENTRY(0x101F4696, CImpsPushHandler::NewL)
#else
    {{0x101F4696}, CImpsPushHandler::NewL}
#endif
    };

// ============================= LOCAL FUNCTIONS ===============================
#ifdef _IMPS_LOGGING_ON_
const TInt KLogBufferLength = 256;
_LIT(KLogDir, "impswatcher");
_LIT(KLogFile, "impspushhandlerplugin.txt");

void CWatcherLogger::Log(TRefByValue<const TDesC> aFmt,...)
    {
    VA_LIST list;
    VA_START(list, aFmt);

    // Print to log file
    TBuf<KLogBufferLength> buf;
    buf.FormatList(aFmt, list);

    // Write to log file
    RFileLogger::Write(KLogDir, KLogFile, EFileLoggingModeAppend, buf);
    }
#endif

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

// -----------------------------------------------------------------------------
// CImpsPushHandler::New
// 1st phase constructor
// Returns: <new CImpsPushHandler>:
// -----------------------------------------------------------------------------
//
CImpsPushHandler* CImpsPushHandler::NewL( )
    {
#ifdef _IMPS_LOGGING_ON_
    CWatcherLogger::Log( KNewL );
#endif
    CImpsPushHandler* self = new( ELeave ) CImpsPushHandler( );
    CleanupStack::PushL( self );
    self->ConstructL( );
    CleanupStack::Pop( self );
    return self;
    }

// -----------------------------------------------------------------------------
// CImpsPushHandler::CImpsPushHandler
// -----------------------------------------------------------------------------
//
CImpsPushHandler::CImpsPushHandler( )
    :CPushHandlerBase()
    {
    }

// -----------------------------------------------------------------------------
// CImpsPushHandler::ConstructL
// Adds the AO to the Active Scheduler.
// -----------------------------------------------------------------------------
//
void CImpsPushHandler::ConstructL( )
    {
    // Add plugin to AS
#ifndef _DOUNITTEST
    CActiveScheduler::Add( this );
#endif
    }

// -----------------------------------------------------------------------------
// CImpsPushHandler::~CImpsPushHandler
// -----------------------------------------------------------------------------
//
CImpsPushHandler::~CImpsPushHandler( )
    {
#ifdef _IMPS_LOGGING_ON_
    CWatcherLogger::Log( KDestructor );
#endif

    // AO's destructor always calls Cancel()
    Cancel( );

    delete iPushMsg;

    }

// -----------------------------------------------------------------------------
// CImpsPushHandler::HandleMessageL
// Starts the message handling procedure asynchronously.
// This is not used in CL messages
// -----------------------------------------------------------------------------
//
void CImpsPushHandler::HandleMessageL(
    CPushMessage* aPushMsg,
    TRequestStatus& aStatus )
    {
#ifdef _IMPS_LOGGING_ON_
    CWatcherLogger::Log( KHandleMessageAsync );
#endif

    // We take ownership of this object and delete it ourself
    iPushMsg = aPushMsg;
    SetConfirmationStatus( aStatus );
    SignalConfirmationStatus( KErrNotSupported );
    iPluginKiller->KillPushPlugin( );
    }

// -----------------------------------------------------------------------------
// CImpsPushHandler::HandleMessageL
// Synchronous version of the HandleMessageL(). See asynchronous version's 
//  description.
// -----------------------------------------------------------------------------
//
void CImpsPushHandler::HandleMessageL( CPushMessage* aPushMsg )
    {
#ifdef _IMPS_LOGGING_ON_
    CWatcherLogger::Log( KHandleMessageSync );
#endif

    // We take ownership of this object and delete it ourself
    iPushMsg = aPushMsg;  

    // Do sanity checks
    if( PerformCheck( ) == KErrNone )
        {
        TransferMessage( );
        }

    // Finish up
    iPluginKiller->KillPushPlugin( );
    }

// -----------------------------------------------------------------------------
// CImpsPushHandler::CancelHandleMessage
// Cancels the pending asynchronous HandleMessageL.
// This is not used in CL messages
// -----------------------------------------------------------------------------
//
void CImpsPushHandler::CancelHandleMessage( )
    {
#ifdef _IMPS_LOGGING_ON_
    CWatcherLogger::Log( KCancelHandleMessage );
#endif
    Cancel( );
    }

// -----------------------------------------------------------------------------
// CImpsPushHandler::DoCancel
// Cancels the operation.
// This is not used in CL messages
// -----------------------------------------------------------------------------
//
void CImpsPushHandler::DoCancel( )
    {
#ifdef _IMPS_LOGGING_ON_
    CWatcherLogger::Log( KDoCancel );
#endif
    }

// -----------------------------------------------------------------------------
// CImpsPushHandler::RunL
// Basically all the work is done from/through this method.
// This is not used in CL messages
// -----------------------------------------------------------------------------
//
void CImpsPushHandler::RunL( )
    {
#ifdef _IMPS_LOGGING_ON_
    CWatcherLogger::Log( KRun );
#endif

    }

// -----------------------------------------------------------------------------
// CImpsPushHandler::RunError
// Called by ActiveScheduler in case RunL leaves. Currently does nothing.
// Returns: <KErrNone>: 
// This is not used in CL messages
// -----------------------------------------------------------------------------
//
TInt CImpsPushHandler::RunError(TInt /*aError*/)
    {
#ifdef _IMPS_LOGGING_ON_
    CWatcherLogger::Log( KRunError );
#endif
    return KErrNone;
    }

// -----------------------------------------------------------------------------
// CImpsPushHandler::CPushHandlerBase_Reserved1
// Reserved for future expansion.
// -----------------------------------------------------------------------------
//
void CImpsPushHandler::CPushHandlerBase_Reserved1( )
    {
#ifndef _DOUNITTEST
    User::Panic( KNotSupported, KErrNotSupported );
#endif
    }

// -----------------------------------------------------------------------------
// CImpsPushHandler::CPushHandlerBase_Reserved2
// Reserved for future expansion.
// -----------------------------------------------------------------------------
//
void CImpsPushHandler::CPushHandlerBase_Reserved2( )
    {
#ifndef _DOUNITTEST
    User::Panic( KNotSupported, KErrNotSupported );
#endif
    }

// -----------------------------------------------------------------------------
// CImpsPushHandler::PerformCheck
// Returns: <errorcode>: KErrCorrupt if the message has invalid format
// -----------------------------------------------------------------------------
//
TInt CImpsPushHandler::PerformCheck( )
    {
    TInt error = KErrNone;

    TPtrC8 messageBodyPtr;
    TBool bodyPresent = EFalse;
    bodyPresent = iPushMsg->GetMessageBody( messageBodyPtr );
    // Check that the message begins with WVCI keyword
    if ( ( !bodyPresent ) || ( messageBodyPtr.Match( KWVID ) == KErrNotFound ) )
        {
#ifdef _IMPS_LOGGING_ON_
        CWatcherLogger::Log( KMessageWasCorrupt );
#endif
        error = KErrCorrupt;
        }

    return error;
    }

// -----------------------------------------------------------------------------
// CImpsPushHandler::TransferMessage
// -----------------------------------------------------------------------------
//
void CImpsPushHandler::TransferMessage( )
    {
#ifdef _IMPS_LOGGING_ON_
    CWatcherLogger::Log( KTransferMessage );
#endif
    TInt serverRunning = iWatchClient.Register( );
    if( serverRunning == KErrNone )
        {
        TPtrC8 messageBodyPtr;
        TBool bodyPresent = iPushMsg->GetMessageBody( messageBodyPtr );
        if( bodyPresent )
            {
            iWatchClient.SendCIR( messageBodyPtr );
            }
        iWatchClient.UnRegister( );
        }
    }

// ========================== OTHER EXPORTED FUNCTIONS =========================

// -----------------------------------------------------------------------------
// ImplementationGroupProxy
// Returns: TImplementationProxy*: Implementation table to the ECOM framework 
// -----------------------------------------------------------------------------
//
EXPORT_C const TImplementationProxy* ImplementationGroupProxy( TInt& aTableCount )
    {
    aTableCount = sizeof( ImplementationTable ) / sizeof( TImplementationProxy );

    return ImplementationTable;
    }


//  End of File