diff -r 000000000000 -r f0cf47e981f9 mmsharing/mmshavailability/src/musavadefaultimp.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/mmsharing/mmshavailability/src/musavadefaultimp.cpp Thu Dec 17 08:44:37 2009 +0200 @@ -0,0 +1,513 @@ +/* +* Copyright (c) 2005-2007 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 is default implementation class for CMusAvaInterface +* +*/ + + + +#include "musavadefaultimp.h" +#include "musavaavailabilityobserver.h" +#include "musavaobserver.h" +#include "musavasettingsimp.h" +#include "musavasharedobject.h" +#include "muslogger.h" +#include "musavainvitehandler.h" +#include "musavanetworkavailability.h" +#include "musavacontactavailability.h" +#include "musavaconnectionavailability.h" +#include "musavaregisteravailability.h" +#include "musavaoptionhandler.h" +#include "musavadefaultoptionhandler.h" +#include "musavasipprofileavailability.h" +#include "musavasettingavailability.h" + +#include "mussesseioninformationapi.h" + +#include + + +const MMusAvaObserver::TAvailabilityName KMinimumAvailability + = MMusAvaObserver::EMusAvaBearerStatus; + +const MMusAvaObserver::TAvailabilityName KMandatoryAvailability + = MMusAvaObserver::EMusAvaNameRegistration; + +const MMusAvaObserver::TAvailabilityName KExtensionAvailability + = MMusAvaObserver::EMusAvaOptionHandler; + + +// ----------------------------------------------------------------------------- +// Two-phased constructor. +// ----------------------------------------------------------------------------- +// +CMusAvaDefaultImp* CMusAvaDefaultImp::NewL() + { + MUS_LOG( "mus: [MUSAVA] -> CMusAvaDefaultImp::NewL" ) + CMusAvaDefaultImp* self = new (ELeave) CMusAvaDefaultImp(); + CleanupStack::PushL (self); + self->ConstructL(); + CleanupStack::Pop( self ); + MUS_LOG( "mus: [MUSAVA] <- CMusAvaDefaultImp::NewL" ) + return self; + } + + +// ----------------------------------------------------------------------------- +// C++ destructor. +// ----------------------------------------------------------------------------- +// +CMusAvaDefaultImp::~CMusAvaDefaultImp() + { + MUS_LOG( "mus: [MUSAVA] -> CMusAvaDefaultImp::~CMusAvaDefaultImp" ) + this->Stop(); + iAvailabilities.ResetAndDestroy(); + delete iSettings; + iSettings = NULL; + MUS_LOG( "mus: [MUSAVA] <- CMusAvaDefaultImp::~CMusAvaDefaultImp" ) + } + + +// ----------------------------------------------------------------------------- +// Symbian second-phase constructor. +// ----------------------------------------------------------------------------- +// +void CMusAvaDefaultImp::ConstructL() + { + MUS_LOG( "mus: [MUSAVA] -> CMusAvaDefaultImp::ConstructL" ) + iSettings = CMusAvaSettingsImp::NewL(); + CreateAvailabilityModulesL(); + MUS_LOG( "mus: [MUSAVA] <- CMusAvaDefaultImp::ConstructL" ) + } + + +// ----------------------------------------------------------------------------- +// C++ Constructor +// ----------------------------------------------------------------------------- +// +CMusAvaDefaultImp::CMusAvaDefaultImp() + :iObserver( NULL ), + iCurrentAvailability( MMusAvaObserver::EMusAvaNameNotDefined ), + iAvailabilityStatus ( MMusAvaObserver::EMusAvaStatusNotExecuted ), + iStopping( EFalse ), + iExecuteStarted( EFalse ) + { + } + + +// ----------------------------------------------------------------------------- +// Creates concrete factory and all availability objects +// ----------------------------------------------------------------------------- +// +void CMusAvaDefaultImp::CreateAvailabilityModulesL() + { + MUS_LOG( "mus: [MUSAVA] -> CMusAvaDefaultImp::\ + CreateAvailabilityModulesL" ) + + if ( iAvailabilities.Count() ) + { + Stop(); + iAvailabilities.ResetAndDestroy(); + } + + /* We need handlers all the time to respond incoming Invite/Options + So construct this modules first. + */ + ConstuctHandlerAvailabilityModulesL(); + + /* We must check the static availability modules like sipprofile + mus activation settings. if this fails then this + will be fatal and no need to go and construct further. + */ + ConstructStaticAvailabilityModulesL(); + + /* Check the handler and static availability modules are OK . If it is not + * OK then dont need to create further availability modules. + */ + for ( TInt i = 0; i < iAvailabilities.Count(); i++ ) + { + if ( !iAvailabilities[i]->Available()) + { + MUS_LOG1( "mus: [MUSAVA] <- CMusAvaDefaultImp:: \ + CreateAvailabilityModulesL Fails! Module = %d ",i ) + return ; + } + } + + /* This should construct modules in where availability could change + * dynamically such as network,bearer and call status etc. + */ + ConstructDynamicAvailabilityModulesL(); + + MUS_LOG( "mus: [MUSAVA] <- CMusAvaDefaultImp::\ + CreateAvailabilityModulesL" ) + } + +// ----------------------------------------------------------------------------- +// Creates concrete standard availability objects +// ----------------------------------------------------------------------------- +// +void CMusAvaDefaultImp::ConstuctHandlerAvailabilityModulesL() + { + MUS_LOG( "mus: [MUSAVA] -> CMusAvaDefaultImp::\ + ConstuctHandlerAvailabilityModulesL" ) + + CMusAvaInviteHandler* inviteHandler = CMusAvaInviteHandler::NewLC( + *this, *iSettings ) ; + iAvailabilities.AppendL( inviteHandler ); + CleanupStack::Pop( inviteHandler ); + + CMusAvaDefaultOptionHandler* defaultOptionHandler = + CMusAvaDefaultOptionHandler::NewLC( *this, *iSettings ); + iAvailabilities.AppendL( defaultOptionHandler ); + CleanupStack::Pop( defaultOptionHandler ); + + MUS_LOG( "mus: [MUSAVA] <- CMusAvaDefaultImp::\ + ConstuctHandlerAvailabilityModulesL" ) + } + +// ----------------------------------------------------------------------------- +// Creates concrete standard availability objects +// ----------------------------------------------------------------------------- +// +void CMusAvaDefaultImp::ConstructStaticAvailabilityModulesL() + { + MUS_LOG( "mus: [MUSAVA] -> CMusAvaDefaultImp::\ + ConstructStaticAvailabilityModulesL" ) + + /* Mus Activation Settings */ + CMusAvaSettingAvailability* settingAvailability = + CMusAvaSettingAvailability::NewLC( *this ); + iAvailabilities.AppendL( settingAvailability ); + CleanupStack::Pop( settingAvailability ); + + /* Existence of Sip profile */ + CMusAvaSipprofileAvailability* sipprofileExist = + CMusAvaSipprofileAvailability::NewLC( *this ) ; + iAvailabilities.AppendL( sipprofileExist ); + CleanupStack::Pop( sipprofileExist ); + MUS_LOG( "mus: [MUSAVA] <- CMusAvaDefaultImp:: \ + ConstructStaticAvailabilityModulesL" ) + } + +// ----------------------------------------------------------------------------- +// Creates concrete standard availability objects +// ----------------------------------------------------------------------------- +// +void CMusAvaDefaultImp::ConstructDynamicAvailabilityModulesL() + { + MUS_LOG( "mus: [MUSAVA] -> CMusAvaDefaultImp::\ + ConstructDynamicAvailabilityModulesL" ) + // Create network availability + CMusAvaNetworkAvailability* networkAvailability = + CMusAvaNetworkAvailability::NewLC( *this, *iSettings ) ; + iAvailabilities.AppendL( networkAvailability ); + CleanupStack::Pop( networkAvailability ); + + // Contact availability + CMusAvaContactAvailability* contactAvailability = + CMusAvaContactAvailability::NewLC( *this, *iSettings ); + iAvailabilities.AppendL( contactAvailability ); + CleanupStack::Pop( contactAvailability ); + + //Connection monitor + CMusAvaConnectionAvailability* connectionAvailability = + CMusAvaConnectionAvailability::NewLC( *this, *iSettings ); + iAvailabilities.AppendL( connectionAvailability ); + CleanupStack::Pop( connectionAvailability ); + + // Create register availability + CMusAvaRegisterAvailability* registerAvailability = + CMusAvaRegisterAvailability::NewLC( *this, *iSettings ); + iAvailabilities.AppendL( registerAvailability ); + CleanupStack::Pop( registerAvailability ); + + // Extension availabilities -> + + // Create SIP options availability + CMusAvaOptionHandler* optionHandler = + CMusAvaOptionHandler::NewLC( *this, *iSettings ); + iAvailabilities.AppendL( optionHandler ); + CleanupStack::Pop( optionHandler ); + + MUS_LOG( "mus: [MUSAVA] <- CMusAvaDefaultImp::ConstructDynamicAvailabilityModulesL" ) + } + +// ----------------------------------------------------------------------------- +// Create work for executing availability report. +// ----------------------------------------------------------------------------- +// +void CMusAvaDefaultImp::ExecuteAvailablitityModules() + { + MUS_LOG( "mus: [MUSAVA] -> CMusAvaDefaultImp::\ + ExecuteAvailablitityModules" ) + iExecuteStarted = ETrue; + TBool goOn = ETrue; + for ( TInt i = 0; i < iAvailabilities.Count() && goOn; i++ ) + { + if ( !iAvailabilities[i]->Available() && + !iAvailabilities[i]->Executing()) + { + iAvailabilities[i]->Execute(); + if ( iAvailabilities[i]->State() < MMusAvaObserver::EMusAvaStatusInProgress ) + { + goOn = EFalse; + } + } + } + iExecuteStarted = EFalse; + MUS_LOG( "mus: [MUSAVA] <- CMusAvaDefaultImp::\ + ExecuteAvailablitityModules" ) + } + + +// ----------------------------------------------------------------------------- +// Retuns setting interface for the client. +// ----------------------------------------------------------------------------- +// +MMusAvaSettings& CMusAvaDefaultImp::Settings() + { + return *iSettings; + } + + +// ----------------------------------------------------------------------------- +// Set Observer interface for the client. +// ----------------------------------------------------------------------------- +// +void CMusAvaDefaultImp::SetObserver( MMusAvaObserver& aObserver ) + { + iObserver = &aObserver; + } + +// ----------------------------------------------------------------------------- +// Set MMusAvaSettingsObserver interface for the client. +// ----------------------------------------------------------------------------- +// +void CMusAvaDefaultImp::SetSettingsObserver( MMusAvaSettingsObserver& aObserver ) + { + iSettings->SetObserver( aObserver ); + } +// ----------------------------------------------------------------------------- +// Requests the implementation to start to investigate availabilites. +// ----------------------------------------------------------------------------- +// +void CMusAvaDefaultImp::StartL() + { + MUS_LOG( "mus: [MUSAVA] -> CMusAvaDefaultImp::StartL" ) + ExecuteAvailablitityModules(); + MUS_LOG( "mus: [MUSAVA] <- CMusAvaDefaultImp::StartL" ) + } + + +// ----------------------------------------------------------------------------- +// Requests the implementation to stop investigating or monitoring availabilites +// for the client. +// ----------------------------------------------------------------------------- +// +void CMusAvaDefaultImp::Stop() + { + MUS_LOG( "mus: [MUSAVA] -> CMusAvaDefaultImp::Stop" ) + iStopping = ETrue; + for ( TInt i = iAvailabilities.Count() - 1; i >= 0; i-- ) + { + if ( iAvailabilities[i]->State() > MMusAvaObserver::EMusAvaStatusNotExecuted ) + { + iAvailabilities[i]->Stop(); + } + } + CalculateAvailability(); + iStopping = EFalse; + if ( iObserver ) + { + iObserver->AvailabilityChanged( + CurrentAvailability(), + AvailabilityStatus() ); + } + MUS_LOG( "mus: [MUSAVA] <- CMusAvaDefaultImp::Stop" ) + } + + +// ----------------------------------------------------------------------------- +// Availability report. +// ----------------------------------------------------------------------------- +// +void CMusAvaDefaultImp::AvailabilityChanged( + MMusAvaObserver::TAvailabilityName aName, + MMusAvaObserver::TAvailabilityStatus aStatus ) + { + MUS_LOG2( "mus: [MUSAVA] -> CMusAvaDefaultImp::AvailabilityChanged(%d,%d)", + aName, aStatus ) + + CalculateAvailability(); + if ( iObserver ) + { + iObserver->AvailabilityChanged( aName, aStatus ); + } + + if ( !iStopping && aStatus >= MMusAvaObserver::EMusAvaStatusNotExecuted ) + { + if ( !iExecuteStarted ) + { + ExecuteAvailablitityModules(); + } + } + + MUS_LOG( "mus: [MUSAVA] <- CMusAvaDefaultImp::AvailabilityChanged()" ) + } + + +// ----------------------------------------------------------------------------- +// Availability error. +// ----------------------------------------------------------------------------- +// +void CMusAvaDefaultImp::AvailabilityError( + MMusAvaObserver::TAvailabilityName aName, + MMusAvaObserver::TAvailabilityStatus aStatus ) + { + MUS_LOG2( "mus: [MUSAVA] -> CMusAvaDefaultImp::AvailabilityError\ + ( %d, %d)", aName, aStatus ) + + CalculateAvailability(); + if ( iObserver ) + { + iObserver->AvailabilityError( aName, aStatus ); + } + MUS_LOG( "mus: [MUSAVA] <- CMusAvaDefaultImp::AvailabilityError()" ) + } + +// ----------------------------------------------------------------------------- +// Checks if the current availability is at least the same as given as +// parameter +// ----------------------------------------------------------------------------- +// +TBool CMusAvaDefaultImp::Available( + MMusAvaObserver::TAvailabilityName aAvailability ) + { + return iCurrentAvailability > aAvailability + || ( iCurrentAvailability == aAvailability + && MMusAvaObserver::EMusAvaStatusAvailable == iAvailabilityStatus ) + || ( iCurrentAvailability == aAvailability + && ( MMusAvaObserver::EMusAvaStatusOptionsNotSent == iAvailabilityStatus + || MMusAvaObserver::EMusAvaStatusOptionsSent == iAvailabilityStatus) ); + } + +// ----------------------------------------------------------------------------- +// Calculates current availability +// ----------------------------------------------------------------------------- +MMusAvaObserver::TAvailabilityStatus CMusAvaDefaultImp::AvailabilityPluginState() + { + return iAvailabilityStatus; + } +// ----------------------------------------------------------------------------- +// Calculates current availability +// ----------------------------------------------------------------------------- +// +void CMusAvaDefaultImp::CalculateAvailability() + { + MUS_LOG( "mus: [MUSAVA] -> CMusAvaDefaultImp::CalculateAvailability()" ) + iCurrentAvailability = MMusAvaObserver::EMusAvaFullAvailability; + iAvailabilityStatus = MMusAvaObserver::EMusAvaStatusAvailable; + TBool goOn = ETrue; + for ( TInt i = 0; i < iAvailabilities.Count() && goOn; i++ ) + { + if ( !iAvailabilities[i]->Available() ) + { + iCurrentAvailability = iAvailabilities[i]->Name(); + iAvailabilityStatus = iAvailabilities[i]->State(); + goOn = EFalse; + } + } + MUS_LOG2( "mus: [MUSAVA] Avaialability name and status (%d,%d)", + iCurrentAvailability, iAvailabilityStatus ) + MUS_LOG( "mus: [MUSAVA] <- CMusAvaDefaultImp::CalculateAvailability()" ) + } + +// ----------------------------------------------------------------------------- +// Current availability +// ----------------------------------------------------------------------------- +// +MMusAvaObserver::TAvailabilityName CMusAvaDefaultImp::CurrentAvailability() + { + return iCurrentAvailability; + } + + +// ----------------------------------------------------------------------------- +// Current availability status +// ----------------------------------------------------------------------------- +// +MMusAvaObserver::TAvailabilityStatus CMusAvaDefaultImp::AvailabilityStatus() + { + return iAvailabilityStatus; + } + + +// ----------------------------------------------------------------------------- +// Checks if current availability is at least minimum availability +// ----------------------------------------------------------------------------- +// +TBool CMusAvaDefaultImp::MinimumAvailability() + { + return iCurrentAvailability > KMinimumAvailability; + } + + +// ----------------------------------------------------------------------------- +// Checks if current availability is at least mandatory availability +// ----------------------------------------------------------------------------- +// +TBool CMusAvaDefaultImp::MandatoryAvailability() + { + return iCurrentAvailability > KMandatoryAvailability; + } + + +// ----------------------------------------------------------------------------- +// Checks if current availability is extension availability +// ----------------------------------------------------------------------------- +// +TBool CMusAvaDefaultImp::ExtensionAvailability() + { + return iCurrentAvailability > KExtensionAvailability; + } + +// ----------------------------------------------------------------------------- +// Returns the sate of the given availability +// ----------------------------------------------------------------------------- +// +MMusAvaObserver::TAvailabilityStatus CMusAvaDefaultImp::AvailabilityState( + MMusAvaObserver::TAvailabilityName aAvailability ) + { + MUS_LOG1( "mus: [MUSAVA] -> CMusAvaDefaultImp::AvailabilityState(%d)", + aAvailability ) + MMusAvaObserver::TAvailabilityStatus retval = + MMusAvaObserver::EMusAvaStatusNotExecuted; + MMusAvaObserver::TAvailabilityStatus state = + MMusAvaObserver::EMusAvaStatusAvailable; + + for ( TInt i = 0; i < iAvailabilities.Count() + && state > MMusAvaObserver::EMusAvaStatusNotExecuted; i++ ) + { + state = iAvailabilities[i]->State(); + + if ( iAvailabilities[i]->Name() == aAvailability ) + { + retval = iAvailabilities[i]->State(); + } + } + MUS_LOG1( "mus: [MUSAVA] <- CMusAvaDefaultImp::AvailabilityState(%d)", + retval ) + return retval; + }