/*

* Copyright (c) 2002-2010 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:  Contains SAT commands.

*

*/

#include    <f32file.h>

#include    <barsc.h>

#include    <bautils.h>

#include    <SatServer.rsg>

#include    <ecom.h>

#include    <e32property.h>

#include    <data_caging_path_literals.hrh>

#include    <startupdomainpskeys.h>

#include    <satdomainpskeys.h>

#include    "MSatSystemState.h"

#include    "TSatSystemStateFactory.h"

#include    "MSatSystemStateChangeNotifier.h"

#include    "CSatCommandContainer.h"

//lint -e766 Used inside TRAP macro, lint misfunction.

#include    "EnginePanic.h"

#include    "TUSatAPI.h"

#include    "MSatSSessions.h"

#include    "MSatShellController.h"

#include    "SatServer.hrh"

#include    "SatLog.h"

#include    "MSatSUiClientHandler.h"

#include    "CSatClientServiceReq.h"

#include    "CSatEventMonitorContainer.h"

#include    "CSatSAPChangeObserver.h"

#include    "CSatSSimSubscriberId.h"

#include    "CSatBIPUtils.h"

#include    "TSatExtErrorUtils.h"

#include    "MSatUiSession.h"

#include    "csatmediatoreventprovider.h"

#include    "csatprofilechangeobserver.h"

#include    "SATInternalPSKeys.h"

#include    "csatmultimodeapi.h"

#include    "csatsactivewrapper.h"

// Drive letter for resource file

_LIT( KResourceDrive, "Z:" );

// SatServer's resource file

_LIT( KSatServerRsc, "SatServer.rsc" );

const TUid KSatInterfaceDefinitionUid = { 0x1000f001 };

const TInt KSizeOfBuf = 50;

const TInt8 KCreateSatAppNamePop( 2 );

// Important plugins UIDs. These are started on startup

// Implementation UID is from the <plugin>.rss

const TUid KSetUpEventListUid = { 0x10202993 };

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

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

// CleanupPointerArray

// Cleanup RPointerArray objects by using the cleanup stack. Function will be 

// called when application leaves while a RPointerArray object still alive, 

// or when CleanupStack::PopAndDestroy is explicitly called to release a 

// RPointerArray. See CleanupStack::PushL( TCleanupItem ) for more details.

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

//

static void CleanupPointerArray( TAny* aArray )

    {

    LOG2( NORMAL, "SATENGINE: CSatCommandContainer::CleanupPointerArray \

        calling array = 0x%08x", aArray )

    RImplInfoPtrArray* array = reinterpret_cast<RImplInfoPtrArray*>( aArray );

    if ( array )

        {

        array->ResetAndDestroy();

        }

    LOG( NORMAL, "SATENGINE: CSatCommandContainer::CleanupPointerArray \

        exiting" )

    }

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

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

// CSatCommandContainer::NewL

// Two-phased constructor.

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

//

CSatCommandContainer* CSatCommandContainer::NewL(

    MSatSSessions& aSessions,

    TSatEventMediator& aEventMediator,

    MSatSUiClientHandler& aSatUiHandler )

    {

    LOG( NORMAL, "SATENGINE: CSatCommandContainer::NewL calling" )

    CSatCommandContainer* self =

        new ( ELeave ) CSatCommandContainer(

            aSessions,

            aEventMediator,

            aSatUiHandler );

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop( self );

    LOG( NORMAL, "SATENGINE: CSatCommandContainer::NewL exiting" )

    return self;

    }

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

// CSatCommandContainer::~CSatCommandContainer

// Destructor

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

//

CSatCommandContainer::~CSatCommandContainer()

    {

    LOG( NORMAL,

        "SATENGINE: CSatCommandContainer::~CSatCommandContainer calling" )

    // Stop and Delete all command handlers

    StopCommandHandlers();

    if ( iUSatAPI )

        {

        iUSatAPI->Close();

        delete iUSatAPI;

        iUSatAPI = NULL;

        }

    if ( iServiceReqs )

        {

        iServiceReqs->Reset();

        delete iServiceReqs;

        iServiceReqs = NULL;

        }

    delete iSatAppName;

    delete iSystemState;

    delete iBipUtils;

    delete iSatMediatorEvent;    

    delete iMultiModeApi;

    delete iSapObserver;

    delete iProfileObserver;

    delete iSimSubscriberId;

    delete iEventMonitors;

    delete iCmdHandlers;

    delete iStartupChangeObserver;

    LOG( NORMAL,

        "SATENGINE: CSatCommandContainer::~CSatCommandContainer exiting" )

    }

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

// CSatCommandContainer::StartCommandHandlersL

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

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

//

void CSatCommandContainer::StartCommandHandlersL()

    {

    LOG( NORMAL,

        "SATENGINE: CSatCommandContainer::StartCommandHandlersL calling" )

    // If in startup phase, start the rest of the commands

    if ( iStartupPhase )

        {

        LOG( NORMAL, "SATENGINE: CSatCommandContainer::StartCommandHandlersL \

             in startup phase" )

        // Create command handlers.

        RImplInfoPtrArray satCommandImplementations;

        CleanupStack::PushL( 

            TCleanupItem( CleanupPointerArray, &satCommandImplementations ) );

        REComSession::ListImplementationsL( KSatInterfaceDefinitionUid,

            satCommandImplementations );

        // Container for commands

        const TInt cmdCount( satCommandImplementations.Count() );

        LOG2( NORMAL, "SATENGINE: CSatCommandContainer::StartCommandHandlersL \

            Command handler count: %d", cmdCount )

        // Check are there any command implementations

        if ( cmdCount > 0 )

            {

            // Check array. Should not be NULL as it is started earlier

            if ( !iCmdHandlers )

                {

                LOG( NORMAL, "SATENGINE: CSatCommandContainer::\

                StartCommandHandlersL iCmdHandlers false" )

                iCmdHandlers = new ( ELeave )

                    CArrayPtrFlat<CSatCommandHandler>( cmdCount );

                }

            // Add all found command handlers to list

            for ( TInt i = 0; i < cmdCount; i++ )

                {

                const TUid KImplementationUid(

                    satCommandImplementations[i]->ImplementationUid() );

                // Check important command handlers. They are already started

                if ( KImplementationUid != KSetUpEventListUid )

                    {

                    CSatCommandHandler* cmd =

                        CSatCommandHandler::NewL( KImplementationUid, this );

                    cmd->Start();

                    CleanupStack::PushL( cmd );

                    iCmdHandlers->AppendL( cmd );

                    CleanupStack::Pop( cmd );

                    }

                }

            }

        CleanupStack::PopAndDestroy( &satCommandImplementations );

        // Notify TSY about readiness i.e. all nofies are sent

        // Done only once in startup phase

        TInt ret = iUSatAPI->UsatClientReadyIndication();

        LOG2( NORMAL, "SATENGINE: UsatClientReadyIndication() gives %d", ret )

        }

    // Else check that there are no command handlers created and

    // BT SAP is not active

    else if ( !iCmdHandlers && !( SystemState().IsBtSapActive() ) )

        {

        LOG( NORMAL, "SATENGINE: CSatCommandContainer::StartCommandHandlersL \

             no command handlers created and BT SAP is not active" )

        // This is the case when

        // SAP is first enabled and then disabled

        if ( !iUSatAPI->IsRSatConnected() )

            {

            User::LeaveIfError( iUSatAPI->Connect( *iMultiModeApi ) );

            }

        // Create command handlers.

        RImplInfoPtrArray satCommandImplementations;

        CleanupStack::PushL( 

            TCleanupItem( CleanupPointerArray, &satCommandImplementations ) );

        REComSession::ListImplementationsL( KSatInterfaceDefinitionUid,

            satCommandImplementations );

        // Container for commands

        const TInt cmdCount( satCommandImplementations.Count() );

        LOG2( NORMAL, "SATENGINE: CSatCommandContainer::StartCommandHandlersL \

            Command handler count: %d", cmdCount )

        // Check are there any command implementations

        if ( cmdCount > 0 )

            {

            iCmdHandlers =

                new ( ELeave ) CArrayPtrFlat<CSatCommandHandler>( cmdCount );

            // Add all found command handlers to list

            for ( TInt i = 0; i < cmdCount; i++ )

                {

                const TUid KImplementationUid(

                    satCommandImplementations[i]->ImplementationUid() );

                CSatCommandHandler* cmd =

                    CSatCommandHandler::NewL( KImplementationUid, this );

                cmd->Start();

                CleanupStack::PushL( cmd );

                iCmdHandlers->AppendL( cmd );

                CleanupStack::Pop( cmd );

                }

            }

        else

            {

            LOG( NORMAL, "SATENGINE: CSatCommandContainer::\

            StartCommandHandlersL No commands found" )

            // No commands, remove SAT Icon from shell

            iSatUiHandler.ShellController().RemoveSatUiL();

            }

        CleanupStack::PopAndDestroy( &satCommandImplementations );

        }

    else

        {

        LOG( NORMAL, " Not starting any command handlers" )

        }

    // Create SAP State observer.

    if ( !iSapObserver )

        {

        LOG( NORMAL, "SATENGINE: CSatCommandContainer::StartCommandHandlersL \

        iSapObserver false" )

        // Create SAP change observer only if there are command handlers.

        iSapObserver = CSatSAPChangeObserver::NewL( *this );

        }

    // Create Profile change observer.

    if ( !iProfileObserver )

        {

        LOG( NORMAL, "SATENGINE: CSatCommandContainer::StartCommandHandlersL \

        iProfileObserver false" )

        iProfileObserver = CSatProfileChangeObserver::NewL( *this );

        }

    LOG( NORMAL,

        "SATENGINE: CSatCommandContainer::StartCommandHandlersL exiting" )

    }

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

// CSatCommandContainer::StopCommandHandlersL

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

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

//

void CSatCommandContainer::StopCommandHandlers()

    {

    LOG( NORMAL,

        "SATENGINE: CSatCommandContainer::StopCommandHandlers calling" )

    if ( iCmdHandlers )

        {

         // Remove every command handler from event observers

        const TInt count( iCmdHandlers->Count() );

        LOG2( NORMAL, "SATENGINE: CSatCommandContainer::StopCommandHandlers \

              Command handler count: %d", count )

        for ( TInt j = 0; j < count; j++ )

            {

            CSatCommandHandler* cmd = iCmdHandlers->At( j );

            UnregisterEventObserver( cmd );

            }

        // Delete command handlers

        iCmdHandlers->ResetAndDestroy();

        delete iCmdHandlers;

        iCmdHandlers = NULL;

        }

    // This must be called when all ECom Plug-Ins has been deleted. Otherwise

    // there might be memory leaks.

    REComSession::FinalClose();

    // Reset ClientService request handlers since there are no command handlers

    // to handle client responses. If SAT UI / Proactive command is executing

    // while Bluetooth SAP is enabled, SAT UI sends ClientResponse and that must

    // be preveted

    if ( iServiceReqs )

        {

        iServiceReqs->Reset();

        }

    // Close all reserved BIP Data channels

    if ( iBipUtils )

        {

        LOG( NORMAL, "SATENGINE: CSatCommandContainer::StopCommandHandlers \

        iBipUtils true" )

        iBipUtils->CloseAllChannels();

        }

    // Cancel all event monitors

    if ( iEventMonitors )

        {

        LOG( NORMAL, "SATENGINE: CSatCommandContainer::StopCommandHandlers \

        iEventMonitors true" )

        iEventMonitors->CancelAllMonitors();

        }

#ifdef SAT_USE_DUMMY_TSY

    // Close ATSY. This is needed when testin BT SAP in emulator

    if ( iUSatAPI )

        {

        iUSatAPI->Close();

        }

#endif

    LOG( NORMAL,

        "SATENGINE: CSatCommandContainer::StopCommandHandlers exiting" )

    }

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

// CSatCommandContainer::Event

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

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

//

void CSatCommandContainer::Event( TInt aEvent )

    {

    LOG( NORMAL, "SATENGINE: CSatCommandContainer::Event calling" )

    if ( MSatUtils::ECmccSimDetected == aEvent )

        {

        LOG( NORMAL, "SATENGINE:   Event: ECmccSimDetected" )

        iIsCmccSim = ETrue;

        // Update default name read in ConstructL.

        TRAPD( err, CreateSatAppNameL( R_QTN_SAT_CMCC_TITLE ) );

        LOG2( NORMAL, "SATENGINE:   Error: %i", err )

        if ( KErrNone == err )

            {

            // Notify application name update.

            NotifyEvent( EApplNameUpdated );

            }

        }

    else if ( MSatUtils::ESatUiClosed == aEvent )

        {

        LOG( NORMAL, "SATENGINE:   Event: ESatUiClosed" )

        // Reset service requests. If this is not done,

        // Some command may try to send data to UiClient,

        // even if there is no request.

        const TInt reqs( iServiceReqs->Count() );

        LOG2( NORMAL, "SATENGINE: CSatCommandContainer::Event reqs: %i", 

              reqs )

        for ( TInt i = 0; i < reqs; i++ )

            {

            iServiceReqs->At( i )->Reset();

            }

        }

    else

        {

        LOG( NORMAL, "SATENGINE:   Unexpected event" )

        }

    LOG( NORMAL, "SATENGINE: CSatCommandContainer::Event exiting" )

    }

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

// CSatCommandContainer::NotifyUiEvent

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

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

//

void CSatCommandContainer::NotifyUiEvent(

    TInt aEventId, TInt aEventStatus, TInt aEventError )

    {

    LOG( NORMAL, "SATENGINE: CSatCommandContainer::NotifyUiEvent calling" )

    MSatUiSession* session = iSatUiHandler.UiSession();

    if ( session )

        {

        LOG( NORMAL, "SATENGINE: CSatCommandContainer::NotifyUiEvent \

        session" )

        session->UiEventNotification( aEventId, aEventStatus, aEventError );

        session = NULL;

        }

    LOG( NORMAL, "SATENGINE: CSatCommandContainer::NotifyUiEvent exiting" )

    }

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

// CSatCommandContainer::USatAPI

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

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

//

MSatApi& CSatCommandContainer::USatAPI()

    {

    LOG( DETAILED, "SATENGINE: CSatCommandContainer::USatAPI calling" )

    __ASSERT_ALWAYS( iUSatAPI, PanicSatEngine( ESatEngineNullPointer ) );

    LOG( DETAILED, "SATENGINE: CSatCommandContainer::USatAPI exiting" )

    return *iUSatAPI;

    }

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

// CSatCommandContainer::SystemState

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

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

//

MSatSystemState& CSatCommandContainer::SystemState()

    {

    LOG( NORMAL,

        "SATENGINE: CSatCommandContainer::SystemState calling-exiting" )

    return *iSystemState;

    }

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

// CSatCommandContainer::SatUiHandler

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

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

//

MSatSUiClientHandler& CSatCommandContainer::SatUiHandler()

    {

    LOG( NORMAL,

        "SATENGINE: CSatCommandContainer::SatUiHandler calling-exiting" )

    return iSatUiHandler;

    }

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

// CSatCommandContainer::RegisterL

// Forwards the registeration to TSatEventMediator

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

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

//

void CSatCommandContainer::RegisterL(

    MSatEventObserver* aObserver, // Event observer

    TSatEvent aEvent ) // Event which is observerd

    {

    LOG( NORMAL, "SATENGINE: CSatCommandContainer::RegisterL calling" )

    iEventMediator.RegisterL( aObserver, aEvent );

    LOG( NORMAL, "SATENGINE: CSatCommandContainer::RegisterL exiting" )

    }

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

// CSatCommandContainer::NotifyEvent

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

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

//

void CSatCommandContainer::NotifyEvent( TSatEvent aEvent )

    {

    LOG( NORMAL, "SATENGINE: CSatCommandContainer::NotifyEvent calling" )

    iEventMediator.Notify( aEvent );

    LOG( NORMAL, "SATENGINE: CSatCommandContainer::NotifyEvent exiting" )

    }

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

// CSatCommandContainer::UnregisterEvent

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

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

//

void CSatCommandContainer::UnregisterEvent(

    MSatEventObserver* aObserver, // Observer of the event

    TSatEvent aEvent ) // Event

    {