/*

* 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: 

*     Alwaysonline manager implementation file

*

*/

#include <ecom/ecom.h>

#include <ecom/resolver.h>

#include <AlwaysOnlineManagerCommon.h>

#include <CoreApplicationUIsSDKCRKeys.h>   // Offline key

#include "AlwaysOnlineManager.h"

#include "AlwaysOnlineManagerServer.h"

#include "HandleServerCommandOperation.h"

#include "AlwaysOnlineManagerLogging.h"

#include "AOCenRepControl.h"

#include "AOCommandParser.h"

const TInt KPluginArrayGranularity = 3;

const TInt KNWOperationsAllowed = 1;

const TInt KManagerOperationsGranularity = 6;

const TInt KDisabledPluginsGranulatiry = 3;

const TUid KAOEmailPluginUid = {0x101F85ED};

_LIT8( KStopPlugin, "1" );

#ifdef _DEBUG

_LIT( KAOManagerParsePanic, "AO parse" );

#endif

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

// CAlwaysOnlineManager()

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

//

CAlwaysOnlineManager::CAlwaysOnlineManager()

    {

    }

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

// NewL()

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

//

CAlwaysOnlineManager* CAlwaysOnlineManager::NewL(

    CAlwaysOnlineManagerServer* aServer )

    {

    CAlwaysOnlineManager* self = new(ELeave) CAlwaysOnlineManager;

    CleanupStack::PushL( self );

    self->ConstructL( aServer );

    CleanupStack::Pop( self );

    return self;

    }

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

// ~CAlwaysOnlineManager()

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

//

CAlwaysOnlineManager::~CAlwaysOnlineManager()

    {

    if ( iOperations )

        {

        iOperations->ResetAndDestroy();

        }

    delete iOperations;

    iRfs.Close();

    iConMon.Close();

    //we shouldn't never come here while phone is switched on

    if ( iPluginArray )

        {

        TInt idx = KErrNotFound;

        while( iPluginArray->Count() )

            {

            idx = iPluginArray->Count() - 1;

            // Delete object

            delete iPluginArray->At( idx );

            // Delete element

            iPluginArray->Delete( idx );

            }

        }

    delete iCenRepControl;

    delete iPluginArray;       

    delete iDisabledPluginUidsArray;

    delete iDiskSpaceObserver;

    delete iSession;

    }

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

// ConstructL()

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

//

void CAlwaysOnlineManager::ConstructL( CAlwaysOnlineManagerServer* aServer )

    {

    // Create operation array to heap

    iOperations = new ( ELeave ) 

        CMsvSingleOpWatcherArray( KManagerOperationsGranularity );

    iCenRepControl = CAOCenRepControl::NewL( *this );

    iSession = CMsvSession::OpenSyncL(*this);

    iServer = aServer;

    iNetworkStatus = KErrNotFound;

    iOffline = ETrue;

    iLastDiskEvent = EAOManagerEmailCommandBase;

    iPluginsLoaded = EFalse;

    iPluginArray = new(ELeave)

        CArrayFixFlat<CAlwaysOnlineEComInterface*>(KPluginArrayGranularity);

    iDisabledPluginUidsArray = new ( ELeave ) 

        CArrayFixFlat<TUid>( KDisabledPluginsGranulatiry );

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

    iConMon.ConnectL();

    }

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

// DoStartL()

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

//

void CAlwaysOnlineManager::DoStartL()

    {

    if( !iPluginsLoaded )

        {

        TRAPD( err, LoadPluginsL() );

        if ( err != KErrNone )

            {

            KAOMANAGER_LOGGER_WRITE_FORMAT("CAlwaysOnlineManager::DoStartL() Errors in LoadPluginsL. Err = %d", err );

            }

        else

            {

            // Nowadays, we don't care about the plugin count, we will start all

            // which are not disabled. At this point iPluginArray contains those

            // plugins which are enabled.

            TRAPD( err, StartPluginsL() );

            if ( err != KErrNone )

                {

                KAOMANAGER_LOGGER_WRITE_FORMAT("CAlwaysOnlineManager::DoStartL() Errors in StartPluginsL. Err = %d", err );

                }

            else

                {

                //don't start observer unless plugins have been started                  

                iDiskSpaceObserver = 

                    CAlwaysOnlineDiskSpaceObserver::NewL( this, *iSession );

                iDiskSpaceObserver->SetLimitAndActivateL();

                //check network status and start observing it

                CheckNetworkStatusAndSetObserverL();

                //get state of KCoreAppUIsNetworkConnectionAllowed key from 

                //CenRep and relay it to plugins

                TInt state = KErrNotFound;

                TInt result = iCenRepControl->GetCenRepKey(

                    KCRUidCoreApplicationUIs,

                    KCoreAppUIsNetworkConnectionAllowed, 

                    state );

                if ( result == KErrNone )

                    {

                    HandleOfflineEventL( state );

                    }

                else

                    {

                    KAOMANAGER_LOGGER_WRITE_FORMAT("CAlwaysOnlineManager::DoStartL() Could not get KCoreAppUIsNetworkConnectionAllowed from CenRep! Result = %d", result );

                    }

                }

            // Send suicide query to all started plugins.

            KAOMANAGER_LOGGER_WRITE("CAlwaysOnlineManager::DoStartL() Sending suicide queries.");

            QuerySuicideL();

            }

        }

    }

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

// PointerArrayCleanup()

//

// An utility function to handle cleanup of RImplInfoPtrArray instances

// @param aArray Pointer to RImpInfoPtrArray to be deleted. 

// 		  Guaranteed not to be NULL.

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

//

static void PointerArrayCleanup( TAny* aArray )

	{

	static_cast< RImplInfoPtrArray* >( aArray )->ResetAndDestroy();

	}

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

// LoadPluginsL()

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

//

void CAlwaysOnlineManager::LoadPluginsL()

    {

	RImplInfoPtrArray pluginArray;

    TCleanupItem arrayCleanup( PointerArrayCleanup, &pluginArray );

    CleanupStack::PushL( arrayCleanup );

    //List all plugins which implement AlwaysOnlineManagerInterface

    REComSession::ListImplementationsL( KCEComInterfaceUid, pluginArray );

    KAOMANAGER_LOGGER_WRITE_FORMAT("CAlwaysOnlineManager::LoadPluginsL() Count of plugins found: %d", pluginArray.Count() );

    // Update list of disabled plugins from cenrep

    iCenRepControl->UpdateDisabledPluginsUids( *iDisabledPluginUidsArray );

    if ( pluginArray.Count() )

        {

        TInt index = -1;

        TKeyArrayFix key( 0, ECmpTInt32 );

        for( TInt i = 0; i < pluginArray.Count(); i++ )

            {

            CImplementationInformation* info = pluginArray[ i ];

            TUid id = info->ImplementationUid();    

            TInt  result( iDisabledPluginUidsArray->Find( id, key, index ) );

            // if id is found from disabled plugins list, then we don't

            // load it.

            if ( result == 0 )

                {

                 KAOMANAGER_LOGGER_WRITE_FORMAT( "CAlwaysOnlineManager::LoadPluginsL() disabled plugin: 0x%x", id );

                }

            else

                {

                CAlwaysOnlineEComInterface* implementation( NULL );

                //be sure that if plugin leaves, manager doesn't. 

                //This applies in every place!

                TRAP_IGNORE( implementation = CAlwaysOnlineEComInterface::NewL( id ) );

                CleanupStack::PushL( implementation );

                if ( implementation )                    

				{                    

				    implementation->SetStatusQueryObject( this );

                    iPluginArray->AppendL( implementation );

                    KAOMANAGER_LOGGER_WRITE_FORMAT("CAlwaysOnlineManager::LoadPluginsL() plugin loaded succesfully: 0x%x", id);

                }

                else

                    {

                    // Just write to debug log, that all the plugins could not be loaded.

                    // Perhaps there should be some nice way to acknoledge the user or the system!

                    KAOMANAGER_LOGGER_WRITE_FORMAT("CAlwaysOnlineManager::LoadPluginsL() plugin load failed: 0x%x", id);

                    }

                CleanupStack::Pop( implementation );

                }

            }//for

        //plugins should be loaded

        iPluginsLoaded = ETrue;

        }//if

    else

        {

        KAOMANAGER_LOGGER_WRITE("CAlwaysOnlineManager::LoadPluginsL() NO PLUGINS FOUND!");

        //no plugins. This shouldn't be, there's something wrong with build.

        //if plugins are not in build, server shouldn't be either!        

        }

	  CleanupStack::PopAndDestroy(); // arrayCleanup

    }

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

// StartPluginsL()

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

//

void CAlwaysOnlineManager::StartPluginsL()

    {

    TInt count = iPluginArray->Count();

    TBuf8<1> dummyParam;

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

        {

        InvokeCommandHandlerL( EAOManagerPluginStart, dummyParam, i );

        }

    KAOMANAGER_LOGGER_WRITE("CAlwaysOnlineManager::StartPluginsL() All plugins ordered to start");

    }

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

// QuerySuicideL()

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

//

void CAlwaysOnlineManager::QuerySuicideL()

    {

    TInt count = iPluginArray->Count();

    TBuf8<1> dummyParam;

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

        {

        InvokeCommandHandlerL( EAOManagerSuicideQuery, dummyParam, i );

        }

    KAOMANAGER_LOGGER_WRITE("CAlwaysOnlineManager::QuerySuicideL() Suicide query made for all plugins");

    }

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

// QueryStatusL()

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

//

TAny* CAlwaysOnlineManager::QueryStatusL( TInt aQuery )

    {

    KAOMANAGER_LOGGER_FN1("CAlwaysOnlineManager::QueryStatusL()");

    KAOMANAGER_LOGGER_WRITE_FORMAT("CAlwaysOnlineManager::QueryStatusL() Query received: %d", aQuery);

    switch( aQuery )

        {

        case EAOManagerStatusQueryRoaming:

            return reinterpret_cast<TAny*>(

                iNetworkStatus == ENetworkRegistrationRoaming );

        case EAOManagerStatusQueryOffline:

            return reinterpret_cast<TAny*>( iOffline );

        case EAOManagerStatusQueryNetwork:

            return reinterpret_cast<TAny*>( iNetworkStatus );

        default:           

            return reinterpret_cast<TAny*>( KErrNotSupported );//unknown query

        }

    }

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

// HandleOfflineEventL()

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

//

void CAlwaysOnlineManager::HandleOfflineEventL( TInt aEvent)

    {

    KAOMANAGER_LOGGER_FN1("CAlwaysOnlineManager::HandleOfflineEventL()");

    KAOMANAGER_LOGGER_WRITE_FORMAT("CAlwaysOnlineManager::HandeOfflineEventL() aEvent: %d", aEvent);

    TInt count = iPluginArray->Count();

    TInt command = KErrNotFound;

    if( aEvent == KNWOperationsAllowed )

        {

        command = EAOManagerNWOpsAllowed;

        iOffline = EFalse;

        }

    else 

        {

        command = EAOManagerNWOpsNotAllowed;

        iOffline = ETrue;

        }

    TBuf8<1> dummyParam;

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

        {

        InvokeCommandHandlerL( 

            static_cast<TManagerServerCommands>(command), dummyParam, i );

        }

    KAOMANAGER_LOGGER_FN2("CAlwaysOnlineManager::HandleOfflineEventL()");

    }

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

// CheckNetworkStatusAndSetObserverL()

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

//

void CAlwaysOnlineManager::CheckNetworkStatusAndSetObserverL()

    {

    KAOMANAGER_LOGGER_FN1("CAlwaysOnlineManager::CheckNetworkStatusAndSetObserverL()");

    TRequestStatus status;

    TInt registrationStatus( 0 );

    //check network status

    iConMon.GetIntAttribute(

        EBearerIdGSM, 0, KNetworkRegistration, 

        registrationStatus, status );

    User::WaitForRequest( status );		// CSI: 94 # This is server side context

    if ( status.Int() == KErrNone )

        {

        HandleRegistrationStatusL( registrationStatus );

        }

    //sets this as an observer for networkstatus

    iConMon.NotifyEventL(*this);

    KAOMANAGER_LOGGER_FN2("CAlwaysOnlineManager::CheckNetworkStatusAndSetObserverL()");

    }

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

// EventL()

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

//

void CAlwaysOnlineManager::EventL( const CConnMonEventBase &aConnMonEvent )

    {

    switch ( aConnMonEvent.EventType() )

		{

        case EConnMonNetworkRegistrationChange:

            {

			CConnMonNetworkRegistrationChange* eventNetworkRegChange;

			eventNetworkRegChange = ( CConnMonNetworkRegistrationChange* ) &aConnMonEvent;

			TInt regStatus = eventNetworkRegChange->RegistrationStatus();

            HandleRegistrationStatusL( regStatus );

            }

			break;

		default:

			break;

		}; 

    }

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

// HandleRegistrationStatusL()

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

//

void CAlwaysOnlineManager::HandleRegistrationStatusL( TInt aStatus )

    {

    KAOMANAGER_LOGGER_FN1("CAlwaysOnlineManager::HandleRegistrationStatusL()");

    TInt command;

    KAOMANAGER_LOGGER_WRITE_FORMAT("CAlwaysOnlineManager::HandleRegistrationStatusL Reporting Network Status to plugins. aStatus: %d", aStatus );

    iNetworkStatus = aStatus;

    if ( aStatus == ENetworkRegistrationHomeNetwork )

        {

        command = EAOManagerStoppedRoaming;

        }

    else if ( aStatus == ENetworkRegistrationRoaming )

        {

        command = EAOManagerStartedRoaming;

        }

    else

        {

        // lets tell plugins we are offline while we don't know network status so that they

        // won't try any connections...

        KAOMANAGER_LOGGER_FN2("CAlwaysOnlineManager::HandleRegistrationStatusL() 2");

        return; //we don't care about other network states than these two

        }

    TInt count = iPluginArray->Count();

    //send changed status to all plugins

    TBuf8<1> dummyParam;

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

        {

        InvokeCommandHandlerL( 

            static_cast<TManagerServerCommands>(command), dummyParam, i );

        }

    KAOMANAGER_LOGGER_FN2("CAlwaysOnlineManager::HandleRegistrationStatusL()");

    }

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

// InvokeCommandHandlerL

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

//

void CAlwaysOnlineManager::InvokeCommandHandlerL(

    const TManagerServerCommands aCommand,

    TDes8& aParameter,

    TInt aIndex )

    {

    KAOMANAGER_LOGGER_FN1("CAlwaysOnlineManager::InvokeCommandHandlerL()");

    KAOMANAGER_LOGGER_WRITE_FORMAT("CAlwaysOnlineManager::InvokeCommandHandlerL() CommandHandler invoked for TManagerServerCommand: %d", aCommand);

    CMsvSingleOpWatcher* watcher = CMsvSingleOpWatcher::NewL(*this);

    CleanupStack::PushL( watcher );

    if ( !iSession )

        {

        KAOMANAGER_LOGGER_WRITE("CAlwaysOnlineManager::InvokeCommandHandlerL() iSession is NULL");

        iSession = CMsvSession::OpenSyncL(*this);

        KAOMANAGER_LOGGER_WRITE_FORMAT("CAlwaysOnlineManager::InvokeCommandHandlerL() iSession created to 0x%x", iSession );

        }

    CAOServerCommandHandler* op = CAOServerCommandHandler::NewL( 

        *iSession,

        watcher->iStatus,

        aCommand,

        aParameter,

        *iPluginArray->At(aIndex) );

    CleanupStack::PushL( op );

    iOperations->AppendL( watcher );

    watcher->SetOperation( op ); // takes immediately ownership

    KAOMANAGER_LOGGER_WRITE_FORMAT("CAlwaysOnlineManager::InvokeCommandHandlerL() Async command invoked. Operation ID: %d ",op->Id()  );

    CleanupStack::Pop( 2, watcher ); // CSI: 47,12 # op, watcher

    KAOMANAGER_LOGGER_FN2("CAlwaysOnlineManager::InvokeCommandHandlerL()");

    }

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

// HandleDiskSpaceEventL()

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

//

void CAlwaysOnlineManager::HandleDiskSpaceEventL( TInt aEvent )

    {

    KAOMANAGER_LOGGER_FN1("CAlwaysOnlineManager::HandleDiskSpaceEventL()");

    KAOMANAGER_LOGGER_WRITE_FORMAT("CAlwaysOnlineManager::HandleDiskSpaceEventL() Got DiskSpace event: %d, Forwarding to plugins", aEvent );

    // Make sure there actually is a reason to send the event

    if ( aEvent == iLastDiskEvent )

        {

        return;

        }

    iLastDiskEvent = aEvent;       

    TInt count = iPluginArray->Count();

    //send event to all plugins

    TBuf8<1> dummyParam;

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

        {

        InvokeCommandHandlerL( 

            static_cast<TManagerServerCommands>(aEvent), dummyParam, i );

        }

    KAOMANAGER_LOGGER_FN2("CAlwaysOnlineManager::HandleDiskSpaceEventL()");

    }