diff -r 000000000000 -r 8e480a14352b messagingfw/alwaysonline/AlwaysOnlineManager/src/AlwaysOnlineManager.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/messagingfw/alwaysonline/AlwaysOnlineManager/src/AlwaysOnlineManager.cpp Mon Jan 18 20:36:02 2010 +0200 @@ -0,0 +1,1041 @@ +/* +* 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 +#include +#include +#include // 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(KPluginArrayGranularity); + iDisabledPluginUidsArray = new ( ELeave ) + CArrayFixFlat( 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(); + } + } + } + +// ---------------------------------------------------------------------------- +// LoadPluginsL() +// ---------------------------------------------------------------------------- +// +void CAlwaysOnlineManager::LoadPluginsL() + { + RImplInfoPtrArray pluginArray; + + //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 ); + TInt result = KErrNotFound; + + for( TInt i = 0; i < pluginArray.Count(); i++ ) + { + CImplementationInformation* info = pluginArray[ i ]; + + TUid id = info->ImplementationUid(); + delete info; + info = NULL; + + 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! + TRAPD( err, implementation = + CAlwaysOnlineEComInterface::NewL( id ) ); + + if ( err == KErrNone ) + { + 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); + } + } + }//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! + } + } + +// ---------------------------------------------------------------------------- +// 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( + iNetworkStatus == ENetworkRegistrationRoaming ); + + case EAOManagerStatusQueryOffline: + return reinterpret_cast( iOffline ); + + case EAOManagerStatusQueryNetwork: + return reinterpret_cast( iNetworkStatus ); + + default: + return reinterpret_cast( 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(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(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(aEvent), dummyParam, i ); + } + KAOMANAGER_LOGGER_FN2("CAlwaysOnlineManager::HandleDiskSpaceEventL()"); + } + + +// ---------------------------------------------------------------------------- +// CAlwaysOnlineManager::HandleSessionEventL +// ---------------------------------------------------------------------------- +// +void CAlwaysOnlineManager::HandleSessionEventL( + TMsvSessionEvent aEvent, + TAny* /*aArg1*/, + TAny* /*aArg2*/, + TAny* /*aArg3*/) + { + KAOMANAGER_LOGGER_FN1("CAlwaysOnlineManager::HandleSessionEventL"); + KAOMANAGER_LOGGER_WRITE_FORMAT("CAlwaysOnlineManager::HandleSessionEventL() aEvent %d", aEvent); + switch( aEvent ) + { + case EMsvMediaUnavailable: + //delete diskspace observer + if( iDiskSpaceObserver ) + { + iDiskSpaceObserver->Cancel(); + delete iDiskSpaceObserver; + iDiskSpaceObserver = NULL; + } + break; + case EMsvMediaAvailable: + //restart diskspace observer + if( !iDiskSpaceObserver ) + { + iDiskSpaceObserver = + CAlwaysOnlineDiskSpaceObserver::NewL( this, *iSession ); + iDiskSpaceObserver->SetLimitAndActivateL(); + } + break; + case EMsvMediaChanged: + //if media changed, old observer is obsolete, delete and restart. + if( iDiskSpaceObserver ) + { + iDiskSpaceObserver->Cancel(); + delete iDiskSpaceObserver; + iDiskSpaceObserver = NULL; + + iDiskSpaceObserver = + CAlwaysOnlineDiskSpaceObserver::NewL( this, *iSession ); + iDiskSpaceObserver->SetLimitAndActivateL(); + } + break; + + case EMsvCloseSession: + case EMsvServerTerminated: + iOperations->ResetAndDestroy(); + delete iSession; + iSession = NULL; + break; + + + default: + break; + } + + KAOMANAGER_LOGGER_FN2("CAlwaysOnlineManager::HandleSessionEventL"); + } + +// ---------------------------------------------------------------------------- +// CAlwaysOnlineManager::BroadcastClientCommandL +// ---------------------------------------------------------------------------- +// +void CAlwaysOnlineManager::BroadcastClientCommandL( + TAlwaysOnlineServerAPICommands aCommand, + TDes8& aParameter ) + { + KAOMANAGER_LOGGER_FN1("CAlwaysOnlineManager::BroadcastClientCommandL()"); + KAOMANAGER_LOGGER_WRITE_FORMAT("CAlwaysOnlineManager::BroadcastClientCommandL() aCommand: %d", aCommand); + // Translate TAlwaysOnlineServerAPICommands to TManagerServerCommands + TManagerServerCommands command = (TManagerServerCommands)KErrNotFound; + TBool invoke = ETrue; + + switch( aCommand ) + { + + // Start a plugin + case EServerAPIBaseCommandStart: + HandleStartPluginL( aParameter ); + command = EAOManagerPluginStart; + invoke = EFalse; + break; + + // Stop a plugin + case EServerAPIBaseCommandStop: + HandleStopPluginL( aParameter ); + command = EAOManagerPluginStop; + invoke = EFalse; + break; + + case EServerAPIBaseCommandAoSchedulerError: + KAOMANAGER_LOGGER_WRITE("CAlwaysOnlineManager::BroadcastClientCommandL() AOScheduler ERROR!" ); + command = EAOManagerAOSchdulerError; + break; + + // Suspend email agent + case EServerAPIEmailTurnOff: + command = EAOManagerMailboxAgentSuspend; + break; + + // Turn the email agent back on + case EServerAPIEmailTurnOn: + command = EAOManagerMailboxAgentResume; + break; + + case EServerAPIBaseAllowNWOperations: + invoke = EFalse; + break; + case EServerAPIBaseSuspendNWOperations: + invoke = EFalse; + break; + // Remove the agent completely + case EServerAPIEmailAgentRemove: + command = EAOManagerMailboxAgentRemove; + break; + + // Handle the OMA Email Notification + case EServerAPIEmailEMNReceived: + command = EAOManagerEMNReceived; + break; + + // Start temporary agent for manual IMAP4 connection + case EServerAPIEmailUpdateMailWhileConnected: + command = EAOManagerMailboxAgentUpdateMailWhileConnected; + break; + case EServerAPIEmailQueryState: + command = EAOManagerQueryState; + invoke = EFalse; + BroadcastCommandDirectL( command, aParameter ); + break; + case EServerAPIEmailCancelAllAndDisconnect: + command = EAOManagerCancelAllAndDisconnect; + break; + case EServerAPIEmailCancelAllAndDoNotDisconnect: + command = EAOManagerCancelAllAndDoNotDisconnect; + break; + case EServerAPIEmailSuspend: + command = EAOManagerSuspend; + break; + case EServerAPIEmailContinue: + command = EAOManagerContinue; + break; + case EServerAPIEmailDoNotDisconnect: + command = EAOManagerDoNotDisconnect; + break; + case EServerAPIEmailSessionClosed: + command = EAOManagerSessionClosed; + invoke = EFalse; + BroadcastCommandDirectL( command, aParameter ); + break; + case EServerAPIEmailDisableAOEmailPlugin: + // Remove UID from plugin array and delete the instance + // of the email plugin + iCenRepControl->SetPluginStatus( KAOEmailPluginUid, ETrue ); + for( TInt i = 0; i < iPluginArray->Count(); i++ ) + { + if( KAOEmailPluginUid == iPluginArray->At(i)->InstanceUid() ) + { + delete iPluginArray->At( i ); + // Delete element + iPluginArray->Delete( i ); + } + } + break; + case EServerAPIEmailEnableAOEmailPlugin: + iCenRepControl->SetPluginStatus( KAOEmailPluginUid, EFalse ); + break; + + // Ignore unrecognized command + default: + invoke = EFalse; + }; + + // EServerAPIBaseCommandStart and EServerAPIBaseCommandStop is only + // sent to one plugin and at this point, it is already handled in + // their own cases. + if ( invoke ) + { + TInt count = iPluginArray->Count(); + + // Send event to all plugins + for( TInt i = 0; i(command), aParameter, i ); + } + } + KAOMANAGER_LOGGER_FN2("CAlwaysOnlineManager::BroadcastClientCommandL()"); + } + +// ---------------------------------------------------------------------------- +// ---------------------------------------------------------------------------- +// +void CAlwaysOnlineManager::BroadcastCommandDirectL( + TManagerServerCommands aCommand, + TDes8& aParameter ) + { + TInt count = iPluginArray->Count(); + TInt ret = KErrNone; + // Send event to all plugins + for( TInt i = 0; iAt(i); + TAny* result = plugin->HandleServerCommandL( aCommand, &aParameter ); + ret = reinterpret_cast(result); + } + + if ( ret != KErrNone ) + { + User::Leave( ret ); + } + + } + +// ---------------------------------------------------------------------------- +// CAlwaysOnlineManager::OpCompleted +// ---------------------------------------------------------------------------- +// +void CAlwaysOnlineManager::OpCompleted( + CMsvSingleOpWatcher& aOpWatcher, + TInt /*aCompletionCode*/ ) + { + TMsvOp opId = aOpWatcher.Operation().Id(); + const TInt count = iOperations->Count(); + + for ( TInt i=0; i < count; i++ ) + { + CMsvOperation& op = (*iOperations)[i]->Operation(); + + if ( op.Id() == opId ) + { + KAOMANAGER_LOGGER_WRITE_FORMAT("CAlwaysOnlineManager::OpCompleted() Async operation %d completed ", opId ); + CMsvSingleOpWatcher* operation = (*iOperations)[i]; + + // Attempt to handle operation + TRAPD( err, HandleOpCompletionL( op.FinalProgress() ) ); + if ( err != KErrNone ) + { + KAOMANAGER_LOGGER_WRITE_FORMAT("CAlwaysOnlineManager::OpCompleted() failed err:%d", err ); + } + + delete operation; + iOperations->Delete(i); + KAOMANAGER_LOGGER_WRITE_FORMAT("CAlwaysOnlineManager::OpCompleted() Operations remaining: %d ", iOperations->Count() ); + break; + } + } + } + +// ---------------------------------------------------------------------------- +// CAlwaysOnlineManager::HandleOpCompletionL +// ---------------------------------------------------------------------------- +// +void CAlwaysOnlineManager::HandleOpCompletionL( const TDesC8& aProgress ) + { + KAOMANAGER_LOGGER_FN1("CAlwaysOnlineManager::HandleOpCompletionL"); + + TUid id; + TInt command; + TBuf8 result; + + if ( ParseProgressL( aProgress, id, command, result ) ) + { + KAOMANAGER_LOGGER_WRITE_FORMAT("CAlwaysOnlineManager::HandleOpCompletionL() : plugin: 0x%x", id); + KAOMANAGER_LOGGER_WRITE_FORMAT("CAlwaysOnlineManager::HandleOpCompletionL() : command: %d", command); + KAOMANAGER_LOGGER_WRITE_FORMAT8("CAlwaysOnlineManager::HandleOpCompletionL() : result: %S", &result); + + switch ( static_cast( command ) ) + { + case EAOManagerSuicideQuery: + if ( result.Match( KStopPlugin ) > KErrNotFound ) + { + StopPluginL( id ); + } + break; + case EAOManagerPluginStop: + DisablePlugin( id ); + break; + default: + // Currently, there is no other commands for plugins, which + // returns something useful to server. + break; + } + } + KAOMANAGER_LOGGER_FN2("CAlwaysOnlineManager::HandleOpCompletionL"); + } + +// ---------------------------------------------------------------------------- +// CAlwaysOnlineManager::ParseProgressL +// ---------------------------------------------------------------------------- +// +TBool CAlwaysOnlineManager::ParseProgressL( + const TDesC8& aProgress, + TUid& aUid, + TInt& aCommand, + TDes8& aResult ) + { + KAOMANAGER_LOGGER_FN1("CAlwaysOnlineManager::ParseProgressL"); + TBool parseOk = EFalse; + + // Parse final progress, received from CAOServerCommandHandler::FinalProgress() + CAOCommandParser* parser = NULL; + TRAPD( err, parser = CAOCommandParser::NewL( aProgress ) ); + + if ( err == KErrNone ) + { + CleanupStack::PushL( parser ); + + TInt error = parser->Parse(); + + __ASSERT_DEBUG( error != KErrNotFound, User::Panic( KAOManagerParsePanic, error ) ); + + if ( error != KErrNotFound ) + { + aUid = parser->Uid(); + aCommand = parser->Command(); + aResult = parser->Result().Left( aResult.MaxLength() ); + parseOk = ETrue; + } + + CleanupStack::PopAndDestroy( parser ); + } + + KAOMANAGER_LOGGER_FN2("CAlwaysOnlineManager::ParseProgressL"); + + return parseOk; + } + +// ---------------------------------------------------------------------------- +// CAlwaysOnlineManager::HandleStartPluginL +// ---------------------------------------------------------------------------- +// +void CAlwaysOnlineManager::HandleStartPluginL( const TDes8& aParameter ) + { + KAOMANAGER_LOGGER_FN1("CAlwaysOnlineManager::HandleStartPluginL"); + + TPckgBuf paramPack; + TUid pluginId; + TInt error = KErrNone; + + // Make sure that the parameter length matches Id length + if ( aParameter.Length() == sizeof( TUid ) ) + { + paramPack.Copy( aParameter ); + + // Get the mailbox id from the packet + pluginId = paramPack(); + error = KErrNone; + } + else + { + error = KErrNotFound; + } + + // Check if plugin already loaded. + for ( TInt i = 0; i < iPluginArray->Count(); i++ ) + { + if ( pluginId == iPluginArray->At( i )->InstanceUid() ) + { + KAOMANAGER_LOGGER_WRITE_FORMAT("CAlwaysOnlineManager::HandleStartPluginL() plugin already loaded: 0x%x", pluginId); + // No need to load a plugin again. + error = KErrAlreadyExists; + break; + } + } + + // Load the plugin and call start for it. + CAlwaysOnlineEComInterface* implementation = NULL; + + if ( error == KErrNone ) + { + TRAPD( err, implementation = + CAlwaysOnlineEComInterface::NewL( pluginId ) ); + + if ( err == KErrNone ) + { + implementation->SetStatusQueryObject( this ); + iPluginArray->AppendL( implementation ); + + // Set the loaded plugin to be enabled (== delete UID from cenrep). + iCenRepControl->SetPluginStatus( pluginId, EFalse ); + + // Refresh the list of disabled plugins UIDs. + iCenRepControl->UpdateDisabledPluginsUids( + *iDisabledPluginUidsArray ); + + TBuf8<1> dummyParam; + // AppendL puts object to the end of the array, + // so we can start the last plugin + TInt idx = iPluginArray->Count() - 1; + InvokeCommandHandlerL( EAOManagerPluginStart, dummyParam, idx ); + + KAOMANAGER_LOGGER_WRITE_FORMAT("CAlwaysOnlineManager::HandleStartPluginL() plugin loaded succesfully: 0x%x", pluginId); + } + else + { + KAOMANAGER_LOGGER_WRITE_FORMAT("CAlwaysOnlineManager::HandleStartPluginL() plugin load failed: 0x%x", pluginId); + } + } + KAOMANAGER_LOGGER_FN2("CAlwaysOnlineManager::HandleStartPluginL"); + } + +// ---------------------------------------------------------------------------- +// CAlwaysOnlineManager::HandleStopPluginL +// ---------------------------------------------------------------------------- +// +void CAlwaysOnlineManager::HandleStopPluginL( const TDes8& aParameter ) + { + KAOMANAGER_LOGGER_FN1("CAlwaysOnlineManager::HandleStopPluginL"); + + TPckgBuf paramPack; + TUid pluginId; + + // Make sure that the parameter length matches Id length + if ( aParameter.Length() == sizeof( TUid ) ) + { + paramPack.Copy( aParameter ); + + // Get the mailbox id from the packet + pluginId = paramPack(); + StopPluginL( pluginId ); + } + + KAOMANAGER_LOGGER_FN2("CAlwaysOnlineManager::HandleStopPluginL"); + } + +// ---------------------------------------------------------------------------- +// CAlwaysOnlineManager::StopPluginL +// ---------------------------------------------------------------------------- +// +void CAlwaysOnlineManager::StopPluginL( + const TUid& aPlugin ) + { + KAOMANAGER_LOGGER_FN1("CAlwaysOnlineManager::StopPluginL"); + + // Find the plugin and send stop command. + if ( iPluginArray->Count() ) + { + // Get correct plugin from + for ( TInt i = 0; i < iPluginArray->Count(); i++ ) + { + TUid id = ( iPluginArray->At( i ) )->InstanceUid(); + + // Is it this plugin? + if ( id == aPlugin ) + { + KAOMANAGER_LOGGER_WRITE_FORMAT("CAlwaysOnlineManager::StopPluginL() Calling stop to plugin: 0x%x", aPlugin); + TBuf8<1> dummyParam; + InvokeCommandHandlerL( + static_cast( EAOManagerPluginStop ), + dummyParam, + i ); + } + } + } + + KAOMANAGER_LOGGER_FN2("CAlwaysOnlineManager::StopPluginL"); + } + +// ---------------------------------------------------------------------------- +// CAlwaysOnlineManager::DisablePlugin +// ---------------------------------------------------------------------------- +// +void CAlwaysOnlineManager::DisablePlugin( const TUid& aPlugin ) + { + KAOMANAGER_LOGGER_FN1("CAlwaysOnlineManager::DisablePlugin"); + + // Delete the plugin and mark it disabled. + if ( iPluginArray->Count() ) + { + // Get correct plugin from + for ( TInt i = 0; i < iPluginArray->Count(); i++ ) + { + TUid id = ( iPluginArray->At( i ) )->InstanceUid(); + + // Is it this plugin? + if ( id == aPlugin ) + { + KAOMANAGER_LOGGER_WRITE_FORMAT("CAlwaysOnlineManager::DisablePlugin() Deleting plugin from array: 0x%x", aPlugin); + // Delete object + delete iPluginArray->At( i ); + // Delete element + iPluginArray->Delete( i ); + } + } + // Set this plugin as disabled. + iCenRepControl->SetPluginStatus( aPlugin, ETrue ); + + // Refresh the list of disabled plugins UIDs. + iCenRepControl->UpdateDisabledPluginsUids( + *iDisabledPluginUidsArray ); + } + + KAOMANAGER_LOGGER_FN2("CAlwaysOnlineManager::DisablePlugin"); + } + +// ---------------------------------------------------------------------------- +// CAlwaysOnlineManager::HandleNotifyInt +// ---------------------------------------------------------------------------- +// +void CAlwaysOnlineManager::HandleNotifyInt( + TUint32 /* aId */, + TInt aNewValue ) + { + TRAPD( err, HandleOfflineEventL( aNewValue ) ); + if( err != KErrNone ) + { + KAOMANAGER_LOGGER_WRITE_FORMAT("CAlwaysOnlineManager::HandleNotifyInt() failed err:%d", err ); + } + } + +// ---------------------------------------------------------------------------- +// CAlwaysOnlineManager::HandleNotifyError +// ---------------------------------------------------------------------------- +// +void CAlwaysOnlineManager::HandleNotifyError( + TUint32 /* aId */, + TInt /* aError */, + CCenRepNotifyHandler* /* aHandler */ ) + { + TRAPD( err, iCenRepControl->ReCreateCoreAppUiCenRepSessionL() ); + if( err != KErrNone ) + { + KAOMANAGER_LOGGER_WRITE_FORMAT("CAlwaysOnlineManager::HandleNotifyError() failed err:%d", err ); + } + } + +//EOF