/*

* Copyright (c) 2009 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:  This file contains the implementations of the CHTIDispatcher

*                class.

*

*/

#include "HtiDispatcher.h"

#include "HtiMessage.h"

#include "HtiMessageQueue.h"

#include "HtiLogging.h"

#include "HtiCommAdapter.h"

#include "HtiServicePluginInterface.h"

#include "HtiCommPluginInterface.h"

#include "HtiSecurityManager.h"

#include "HtiVersion.h"

#include <e32debug.h>

//active objects priorities

const static TInt KHtiIdlePriority = 2;

const static TInt KDefaultMaxQueueSize = 4 * 1024 * 1024; // 4 MB

//HTI system service commands

enum THtiCommand

    {

    EHtiAuthentication = 0x01,

    EHtiVersion        = 0x02,

    EHtiServiceList    = 0x03,

    EHtiStop           = 0x04,

    EHtiReboot         = 0x05,

    EHtiFormat         = 0x06,

    EHtiReset          = 0x07,

    EHtiShowConsole    = 0x08,

    EHtiHideConsole    = 0x09,

    EHtiInstanceId     = 0x0A,

    EHtiDebugPrint     = 0x0B,

    EHtiError          = 0xFF

    };

//HTI error messages

const static TInt KMaxErrMessageLength = KErrorDescriptionMaxLength + 10;

//error descriptions

_LIT8( KHtiSystemCmdErrDescr, "Unknown HTI command" );

_LIT8( KErrDescrDispatchOut, "Failed to dispatch message" );

_LIT8( KErrDescrWrap, "Failed to wrap message" );

_LIT8( KErrDescrDispatchOutError, "Failed to dispatch error message" );

_LIT8( KErrDescrInvalidParameter, "Invalid command parameter" );

_LIT8( KErrDescrNotInRom, "Command supported only if HTI is running from ROM" );

const static TChar KSpChar = ' ';

const static TChar KNewLineChar = '\n';

const static TInt KHtiServiceNameLength = 124;

const static TInt KHtiServiceListRecordLength = KHtiServiceNameLength + 4;

_LIT( KHtiWatchDogMatchPattern, "HtiWatchDog*" );

_LIT( KHtiDeviceRebootExeOS,    "HtiDeviceRebootOS.exe" );

_LIT( KHtiDeviceRebootExeUI,    "HtiDeviceRebootUI.exe" );

_LIT( KParamNormalRfs, "rfsnormal" );

_LIT( KParamDeepRfs,   "rfsdeep" );

TDesC8* THtiSystemProtocolHelper::ErrorMessageL( TInt aHtiErrorCode,

                                  const TUid aTargetServiceUid )

    {

    HBufC8* msg = HBufC8::NewL( KMaxErrMessageLength );

    msg->Des().Append( EHtiError ); //one byte

    msg->Des().Append( aHtiErrorCode ); //one byte

    msg->Des().AppendFill( 0x00, 4 ); //missed service error code

    //append uid as TInt32 by copying 4 bytes through pointer

    msg->Des().Append( ( TUint8* )( &( aTargetServiceUid.iUid ) ), 4 );

    return msg;

    }

TDesC8* THtiSystemProtocolHelper::ErrorMessageL( TInt aHtiErrorCode,

                                  const TUid aTargetServiceUid,

                                  TInt aErrorCode,

                                  const TDesC8& aErrorDescription )

    {

    HBufC8* msg = HBufC8::NewL( KMaxErrMessageLength );

    msg->Des().Append( EHtiError ); //one byte

    msg->Des().Append( aHtiErrorCode ); //one byte

    msg->Des().Append( ( TUint8* ) ( &aErrorCode ), 4 ); //4 bytes

    //append uid as TInt32 by copying 4 bytes through pointer

    msg->Des().Append( ( TUint8* )( &( aTargetServiceUid.iUid ) ), 4 );

    msg->Des().Append( aErrorDescription );

    return msg;

    }

TDesC8* THtiSystemProtocolHelper::AuthMessageL( const TDesC8& aToken )

    {

    HBufC8* msg = HBufC8::NewL( aToken.Length() + 1 );

    msg->Des().Append( EHtiAuthentication );

    msg->Des().Append( aToken );

    return msg;

    }

/*************************************************************************

*   CHtiDispatcher implementation

*

**************************************************************************/

CHtiDispatcher::CHtiDispatcher( TInt aMaxQueueMemorySize,

        TInt aReconnectDelay, TBool aShowErrorDialogs ):

    iIdleActive( EFalse ),

    iMaxQueueMemorySize( aMaxQueueMemorySize > 0 ?

                         aMaxQueueMemorySize : KDefaultMaxQueueSize ),

    iToReboot( EFalse ),

    iRfsMode( ERfsUnknown ),

    iConsole( NULL ),

    iIdleOverCommAdapter( EFalse ),

    iHtiInstanceId( 0 ),

    iShowErrorDialogs( aShowErrorDialogs ),

    iReconnectDelay(aReconnectDelay),

    iRebootReason(-1)

    {

    HTI_LOG_FORMAT( "MaxQueueMemorySize %d", iMaxQueueMemorySize );

    iQueueSizeLowThresold = ( iMaxQueueMemorySize / 2 ) / 2;

    iQueueSizeHighThresold = ( iMaxQueueMemorySize / 2 ) * 4 / 5;

    HTI_LOG_FORMAT( "QueueSizeThresholds low : %d", iQueueSizeLowThresold );

    HTI_LOG_FORMAT( "QueueSizeThresholds high: %d", iQueueSizeHighThresold );

    }

void CHtiDispatcher::ConstructL( const TDesC8& aCommPlugin,

                                 TInt aMaxMsgSize,

                                 TBool aShowConsole )

    {

    HTI_LOG_FUNC_IN( "CHTIDispatcher::ConstructL()" );

#ifdef __ENABLE_LOGGING__

    DebugListPlugins();

#endif

    if ( aShowConsole )

        {

        // Create the HTI console

        iConsole = Console::NewL( _L( "HtiFramework" ),

                                  TSize( KConsFullScreen, KConsFullScreen ) );

        iConsole->Printf( _L( "HTI Framework\n" ) );

        iConsole->Printf( _L( "=============\n\n" ) );

        iConsole->Printf( _L( "Version %u.%u\n" ),

                KHtiVersionMajor, KHtiVersionMinor );

        iConsole->Printf( _L( "Starting up...\n" ) );

        }

    //create queues

    iIncomingQueue = CHtiMessageQueue::NewL();

    iOutgoingQueue = CHtiMessageQueue::NewL();

    //security manager init

    iSecurityManager = CHtiSecurityManager::NewL();

    //plugins array

    iLoadedServices = new (ELeave)

                        RArray<TServiceItem>( KServiceArrayGranularity );

    iMemoryObservers = new (ELeave)

                        RPointerArray<MHtiMemoryObserver>( KServiceArrayGranularity );

    //try to load default plugin if specified can't be found

    if ( aCommPlugin.Length() == 0 )

        {

        HTI_LOG_TEXT( "load default comm plugin" );

        iCommPlugin = CHTICommPluginInterface::NewL();

        }

    else

        {

        HTI_LOG_TEXT( "load Comm plugin" );

        HTI_LOG_DES( aCommPlugin );

        iCommPlugin = CHTICommPluginInterface::NewL( aCommPlugin );

        }

    if ( iConsole )

        {

        iConsole->Printf( _L( "Communication plugin loaded.\n" ) );

        }

    iListener = CHtiCommAdapter::NewL( iCommPlugin, this, aMaxMsgSize );

    iSender = CHtiCommAdapter::NewL( iCommPlugin, this, aMaxMsgSize );

    //!!!!!!!!!!!!! -=IMPORTANT=- !!!!!!!!!!!!!!!!!!!!!!!!!!!!

    // idle should be created (added to AS) AFTER comm adapters

    //!!!!!!!!!!!!! -=IMPORTANT=- !!!!!!!!!!!!!!!!!!!!!!!!!!!!

    //create CIdle object

    iIdle = CIdle::NewL( KHtiIdlePriority );

    // start listening for incoming messages

    Reset();

    HTI_LOG_FUNC_OUT( "CHTIDispatcher::ConstructL()" );

    }

CHtiDispatcher::~CHtiDispatcher()

    {

    HTI_LOG_FUNC_IN( "CHTIDispatcher::~CHTIDispatcher" );

    if ( iIdle )

    {

        iIdle->Cancel();

        delete iIdle;

    }

    UnloadAllServices();

    if ( iLoadedServices )

        {

        iLoadedServices->Close();

        delete iLoadedServices;

        }

    if ( iMemoryObservers )

    {

        iMemoryObservers->Close();

        delete iMemoryObservers;

    }

    delete iIncomingQueue;

    delete iOutgoingQueue;

    delete iListener;

    delete iSender;

    delete iCommPlugin;

    REComSession::FinalClose();

    delete iSecurityManager;

    if ( iRfsMode == ERfsNormal || iRfsMode == ERfsDeep )

        {

        HTI_LOG_FORMAT( "Activating Restore Factory Settings %d", iRfsMode );

        RestoreFactorySettings();

        }

    if ( iToReboot )

        {

        HTI_LOG_TEXT( "Reboot now" );

        Reboot();

        }

    delete iConsole;

    HTI_LOG_FUNC_OUT( "CHTIDispatcher::~CHTIDispatcher" );

    }

CHtiDispatcher* CHtiDispatcher::NewLC( const TDesC8& aCommPlugin,

                                TInt aMaxMsgSize,

                                TInt aMaxQueueMemory,

                                TInt aReconnectDelay,

                                TBool aShowConsole,

                                TBool aShowErrorDialogs )

    {

    CHtiDispatcher* obj = new (ELeave) CHtiDispatcher(

            aMaxQueueMemory, aReconnectDelay,aShowErrorDialogs );

    CleanupStack::PushL( obj );

    obj->ConstructL( aCommPlugin, aMaxMsgSize, aShowConsole );

    return obj;

    }

CHtiDispatcher* CHtiDispatcher::NewL( const TDesC8& aCommPlugin,

                                TInt aMaxMsgSize,

                                TInt aMaxQueueMemory,

                                TInt aReconnectDelay,

                                TBool aShowConsole,

                                TBool aShowErrorDialogs )

    {

    CHtiDispatcher* obj = NewLC( aCommPlugin, aMaxMsgSize, aMaxQueueMemory,

            aReconnectDelay,aShowConsole, aShowErrorDialogs );

    CleanupStack::Pop();

    return obj;

    }

CConsoleBase* CHtiDispatcher::GetConsole()

    {

    return iConsole;

    }

TBool CHtiDispatcher::GetShowErrorDialogs()

    {

    return iShowErrorDialogs;

    }

void CHtiDispatcher::CheckPriorities()

    {

    // If incoming queue reaches some high limit then lower its priority

    // below idle object priority.

    // Make opposite when incoming queue size reaches some low limit

    if ( iIncomingQueue->QueueSize() > iQueueSizeHighThresold )

        {

        if ( !( iListener->IsActive() || iIdleOverCommAdapter ) )

            {

            HTI_LOG_TEXT( "Set listener priority low" );

            iListener->Deque();

            CActiveScheduler::Add( iListener );

            iIdleOverCommAdapter = ETrue;

            }

        }

    }

void CHtiDispatcher::DispatchIncomingMessage( CHtiMessage* aMessage )

    {

    HTI_LOG_FUNC_IN( "DispatchIncomingMessage" );

    iIncomingQueue->Add( *aMessage );

    //start CIdle if needed

    Start();

    CheckPriorities();

    HTI_LOG_FUNC_OUT( "DispatchIncomingMessage" );

    }

TInt CHtiDispatcher::DispatchOutgoingMessage( TDesC8* aMessage,

                    const TUid aTargetServiceUid,

                    TBool aWrappedFlag,

                    THtiMessagePriority aPriority )

    {

    HTI_LOG_FUNC_IN( "DispatchOutgoingMessage" );

    HTI_LOG_TEXT( "Construct HTI message" );

    //send only if enough memory

    TInt returnErr = KErrNone;

    if ( aMessage->Size() <= GetFreeMemory() )

        {

        //call here wrapping

        CHtiMessage* msg = NULL;

        if ( aWrappedFlag )

            {

            TDesC8* wrapped = NULL;

            TRAP( returnErr, wrapped = iSecurityManager->WrapL( *aMessage ) );

            if ( returnErr == KErrNone )

                {

                TRAP( returnErr,

                      msg = CHtiMessage::NewL( wrapped, aTargetServiceUid,

                            aWrappedFlag, aPriority ) );

                if ( returnErr != KErrNone )

                    {

                    UrgentReboot( returnErr, KErrDescrDispatchOut );

                    }

                //wrapped message is kept, original is deleted

                delete aMessage;

                }

            else

                {

                UrgentReboot( returnErr, KErrDescrWrap );

                }

            }

        else

            {

            TRAP( returnErr, msg = CHtiMessage::NewL( aMessage,

                                aTargetServiceUid, aWrappedFlag, aPriority ) );

            if ( returnErr != KErrNone )

                {

                UrgentReboot( returnErr, KErrDescrDispatchOut );

                }

            }

        // put in a queue

        if ( msg )

            iOutgoingQueue->Add( *msg );

        //start CIdle if needed

        Start();

        }

    else

        {

        returnErr = KErrNoMemory;

        }

    HTI_LOG_FUNC_OUT( "DispatchOutgoingMessage" );

    return returnErr;

    }

TInt CHtiDispatcher::DispatchOutgoingErrorMessage( TInt aErrorCode,

                    const TDesC8& aErrorDescription,

                    const TUid aTargetServiceUid )

    {

    HTI_LOG_FUNC_IN( "DispatchError" );

    if ( aTargetServiceUid == TUid::Null() )

        {

        return KErrArgument;

        }

    HTI_LOG_FORMAT( "ErrorCode %d", aErrorCode );

    TInt err = KErrNone;

    TDesC8* msg = NULL;

    TRAP( err, msg = THtiSystemProtocolHelper::ErrorMessageL(

                        EHtiErrServiceError,

                        aTargetServiceUid,

                        aErrorCode,

                        aErrorDescription ) );

    if ( err != KErrNone )

        {

        UrgentReboot( err, KErrDescrDispatchOutError );

        }

    err = DispatchOutgoingMessage( msg, KHtiSystemServiceUid,

                             EFalse, EHtiPriorityDefault );

    if ( err == KErrNoMemory )

        {

        delete msg;

        }

    HTI_LOG_FUNC_OUT( "DispatchError" );

    return err;

    }

TInt CHtiDispatcher::DispatchOutgoingErrorMessage( THtiError aHtiErroreCode,

                                    TInt aLeaveCode,

                                    const TUid aTargetServiceUid )

    {

    HTI_LOG_FORMAT( "leaveCode %d", aLeaveCode );

    TInt err = KErrNone;

    TDesC8* msg = NULL;

    TRAP( err, msg = THtiSystemProtocolHelper::ErrorMessageL(

                        aHtiErroreCode,

                        aTargetServiceUid,

                        aLeaveCode,

                        KNullDesC8 ) );

    if ( err != KErrNone )

        {

        UrgentReboot( err, KErrDescrDispatchOutError );

        }

    err = DispatchOutgoingMessage( msg, KHtiSystemServiceUid,

                             EFalse, EHtiPriorityDefault );

    if ( err == KErrNoMemory )

        {

        delete msg;

        }

    return err;

    }

TInt CHtiDispatcher::DispatchOutgoingErrorMessage( THtiError aHtiErrorCode,

                                    const TUid aTargetServiceUid )

    {

    HTI_LOG_FORMAT( "HtiErrorCode %d", aHtiErrorCode );

    TInt err = KErrNone;

    TDesC8* msg = NULL;

    TRAP( err, msg = THtiSystemProtocolHelper::ErrorMessageL( aHtiErrorCode,

                                                aTargetServiceUid ) );

    if ( err != KErrNone )

        {

        UrgentReboot( err, KErrDescrDispatchOutError );

        }

    err = DispatchOutgoingMessage( msg, KHtiSystemServiceUid,

                             EFalse, EHtiPriorityDefault );

    if ( err == KErrNoMemory )

        {

        delete msg;

        }

    return err;

    }

TInt CHtiDispatcher::DispatchOutgoingMessage(TDesC8* aMessage,

                    const TUid aTargetServiceUid)

    {

    return DispatchOutgoingMessage( aMessage, aTargetServiceUid,

                             EFalse, EHtiPriorityDefault );

    }

void CHtiDispatcher::AddMemoryObserver( MHtiMemoryObserver* anObserver )

    {

    if ( iMemoryObservers->FindInAddressOrder( anObserver ) == KErrNotFound )

        {

        iMemoryObservers->InsertInAddressOrder( anObserver );

        }

    }

void CHtiDispatcher::RemoveMemoryObserver( MHtiMemoryObserver* anObserver )

    {

    TInt removeIndex = iMemoryObservers->FindInAddressOrder( anObserver );

    if ( removeIndex != KErrNotFound )

        {

        iMemoryObservers->Remove( removeIndex );

        }

    }

void CHtiDispatcher::DoMemoryNotification()

    {

    if ( iMemoryObservers->Count() > 0 )

        {

        TInt memory = GetFreeMemory();

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

            {

            ( *iMemoryObservers )[i]->NotifyMemoryChange( memory );

            }

        }

    }

TInt CHtiDispatcher::GetFreeMemory()

    {

    return iMaxQueueMemorySize

           - iIncomingQueue->QueueSize()

           - iOutgoingQueue->QueueSize();

    }

void CHtiDispatcher::Start()