diff -r 3104fc151679 -r 9a48e301e94b uiservicetab/vimpstengine/src/cvimpstengine.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/uiservicetab/vimpstengine/src/cvimpstengine.cpp Wed Sep 01 12:33:36 2010 +0100 @@ -0,0 +1,1445 @@ +/* +* Copyright (c) 2008 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: Class that capsulates single service data members +* +*/ + + +// INCLUDES +#include "cvimpstengine.h" + +#include "cvimpstengineservicetablefetcher.h" +#include +#include +#include +#include +#include + +#include "tvimpstconsts.h" +#include "cvimpstenginevoipsubservice.h" +#include "cvimpstengineimsubservice.h" +#include "cvimpstenginepresencesubservice.h" +#include "cvimpstenginecchhandler.h" +//storage +#include "cvimpststoragemanagerfactory.h" +#include "cvimpstenginesessioncntxtobserver.h" +#include "mvimpststorageserviceview.h" +#include "mvimpststoragevpbkstorehandler.h" + +#include "tvimpstenums.h" + +#include "mvimpstengineextentionfeatures.h" +#include "mvimpstengineservicestateeventobserver.h" + +//extention features +#include "cvimpstenginesearchmgrextention.h" +#include "cvimpstenginecontactmgmtextention.h" +#include "cvimpstblockedlistmanager.h" + +#include "mvimpststoragecontactlist.h" +#include + +#include "uiservicetabtracer.h" + +// Constants +_LIT( KListNameAllBuddy ,"buddylist" ); + +// ================= MEMBER FUNCTIONS ======================= +// --------------------------------------------------------- +// CVIMPSTEngine::NewL +// +// --------------------------------------------------------- +CVIMPSTEngine* CVIMPSTEngine::NewL( + TUint32 aServiceId, + CVIMPSTEngineServiceTableFetcher& aTableFetcher ) + { + TRACER_AUTO; + TRACE("ServiceId: %d", aServiceId); + + + CVIMPSTEngine* self = CVIMPSTEngine::NewLC( aServiceId, + aTableFetcher ); + CleanupStack::Pop( self ); + + return self; + } + + +// --------------------------------------------------------- +// CVIMPSTEngine::NewLC +// +// --------------------------------------------------------- + +CVIMPSTEngine* CVIMPSTEngine::NewLC( + TUint32 aServiceId, + CVIMPSTEngineServiceTableFetcher& aTableFetcher ) + { + TRACER_AUTO; + TRACE( "ServiceId: %d", aServiceId ); + + CVIMPSTEngine* self = new (ELeave) CVIMPSTEngine( + aServiceId, + aTableFetcher ); + CleanupStack::PushL( self ); + self->ConstructL( aServiceId ); + + return self; + } + +// --------------------------------------------------------- +// CVIMPSTEngine::~CVIMPSTEngine +// +// --------------------------------------------------------- + +CVIMPSTEngine::~CVIMPSTEngine() + { + TRACER_AUTO; + + iObserverArray.Reset(); + iObserverArray.Close(); + + iSubService.ResetAndDestroy(); + iSubService.Close(); + // Delete this after sub services, those might use it in destructor! + delete iSessionCntxtObserver; + delete iServiceName; + + iExtentionFeatures.ResetAndDestroy(); + iExtentionFeatures.Close(); + + delete iCchHandler; + iCchHandler = NULL; + + + } + + +// --------------------------------------------------------- +// CVIMPSTEngine::ConstructL +// +// --------------------------------------------------------- + +void CVIMPSTEngine::ConstructL( TUint32 aServiceId ) + { + TRACER_AUTO; + TRACE( "ServiceId: %d", aServiceId ); + + iServiceName = HBufC::NewL( KVIMPSTUISPSMaxPropertyLength ); + + // construct the service state by passing the array of subservices. + iCchHandler = CVIMPSTEngineCchHandler::NewL(iServiceId,*this); + + //construct eventobserver only if there are any adaptations. + TInt ximpAdapterUid = iTableFetcher.XimpAdapterUidL(aServiceId); + + + TBool requireXimp = EFalse; + TBool presenceSupported = IsSubServiceSupportedInternal(TVIMPSTEnums::EPresence); + TBool imSupported = IsSubServiceSupportedInternal(TVIMPSTEnums::EIM); + + requireXimp |= presenceSupported; + requireXimp |= imSupported; + + TPtr serviceIdPtr(iServiceName->Des()); + iTableFetcher.GetServiceNameL(aServiceId, serviceIdPtr); + + //if either of Presence/IM Subservice supported then we need + //to bind to XIMP context. + if ( KErrNotFound != ximpAdapterUid && requireXimp ) + { + TRAPD( err, (iSessionCntxtObserver = CVIMPSTEngineSessionCntxtObserver::NewL(aServiceId))); + TRACE( "1st Creating session context observer: %d", err ); + if (KErrNotFound == err) + { + TRACE( "Ximp impl not found. Calling Logout" ); + iUnInstall = ETrue; + LogoutL(); + TRACE( "Logout Called on account of uninstall" ); + return; + } + } + + // iterate the service array + for ( TInt index = TVIMPSTEnums::EVoip; index < TVIMPSTEnums::ELast ; index++ ) + { + //create the subservice + switch(index) + { + case TVIMPSTEnums::EVoip: + { + if(IsSubServiceSupportedInternal(TVIMPSTEnums::EVoip)) + { + CVIMPSTEngineVOIPSubService* item = + CVIMPSTEngineVOIPSubService::NewL(aServiceId, *iCchHandler, + iTableFetcher, *this); + iSubService.Append(item); + } + break; + } + case TVIMPSTEnums::EPresence: + { + if(presenceSupported) + { + if (iSessionCntxtObserver) + { + CVIMPSTEnginePresenceSubService* item = CVIMPSTEnginePresenceSubService::NewL( + aServiceId,*iCchHandler,iTableFetcher, + *iSessionCntxtObserver,*this + ); + iSubService.Append(item); + iSessionCntxtObserver->RegisterObserver(item); + } + } + break; + } + case TVIMPSTEnums::EIM: + { + if(imSupported) + { + CVIMPSTEngineIMSubService* item = + CVIMPSTEngineIMSubService::NewL(aServiceId, *iCchHandler, + iTableFetcher,*this); + iSubService.Append(item); + } + break; + } + default: + { + break; + } + + } + } + + //Create the required extention mgrs + CreateExtentionFeaturesL(); + iState = ParseGetServiceState(); + //if cch is already logged in, and the callback's servicestatuschanged() stopped + RetriveContextIfCChEnabledL(); + } + + +// --------------------------------------------------------- +// CVIMPSTEngine::CVIMPSTEngine +// +// --------------------------------------------------------- + +CVIMPSTEngine::CVIMPSTEngine( TUint32 aServiceId, + CVIMPSTEngineServiceTableFetcher& aTableFetcher ) : +iServiceId(aServiceId), +iTableFetcher(aTableFetcher) + { + iUnInstall = EFalse; + } + +// --------------------------------------------------------- +// CVIMPSTEngine::RetriveContextIfCChEnabledL +// +// --------------------------------------------------------- +void CVIMPSTEngine::RetriveContextIfCChEnabledL() + { + TRACER_AUTO; + if ( (iSessionCntxtObserver) && + (TVIMPSTEnums::ESVCEUpdatingContacts == iState || TVIMPSTEnums::ESVCERegistered == iState ) + && ( TVIMPSTEnums::EVIMPSTBindNotDone == iSessionCntxtObserver->ContextBindStatus() ) ) + { + TInt ximpAdapterUid = iTableFetcher.XimpAdapterUidL(iServiceId); + TInt err = iSessionCntxtObserver->ServerBindL(TUid::Uid( ximpAdapterUid )); + if(KErrNone != err) + { + //should never reache here; + iCchHandler->DisableService(); + User::LeaveIfError(err); + } + SetExtentionFeaturesSupportedL(); + } + + } + +// --------------------------------------------------------- +// CVIMPSTEngine::LoginL +// +// --------------------------------------------------------- +TInt CVIMPSTEngine::Login() + { + TRACER_AUTO; + TRACE( "ServiceId: %d", iServiceId ); + + TInt error = KErrNotFound; + if(iCchHandler) + { + TRACE( "EnableService Called"); + error = iCchHandler->EnableService(); + } + + TRACE( "error: %d", error ); + + return error; + } + + +// --------------------------------------------------------- +// CVIMPSTEngine::Logout +// +// --------------------------------------------------------- +void CVIMPSTEngine::LogoutL() + { + TRACER_AUTO; + TRACE( "ServiceId: %d", iServiceId ); + + if(iCchHandler) + { + MVIMPSTEngineSubService* subService = SubService(TVIMPSTEnums::EPresence); + if (subService) + { + //Get Presence SubService + MVIMPSTEnginePresenceSubService& presenceSubService = + MVIMPSTEnginePresenceSubService::Cast(*subService); + if (TVIMPSTEnums::ESVCERegistered == subService->SubServiceState() || + TVIMPSTEnums::ESVCEUpdatingContacts == subService->SubServiceState() ) + { + // Unsubscribe all lists here to get whole list contents when doing a new bind. + // Trap here to avoid unbind not being done if list operations should leave + TRAP_IGNORE( presenceSubService.UnsubscribeListsL() ); + } + } + //if either of Presence/IM Subservice supported then we need + //to unbind to XIMP context. + if( iSessionCntxtObserver ) + { + TRACE( "ServerUnBindL Called"); + iSessionCntxtObserver->ServerUnBindL(ETrue); + } + TRACE(" DisableService Called"); + iCchHandler->DisableService(); + } + + } + + +// --------------------------------------------------------- +// CVIMPSTEngine::ServiceId +// +// --------------------------------------------------------- +TUint32 CVIMPSTEngine::ServiceId() const + { + TRACER_AUTO; + TRACE( "ServiceId: %d", iServiceId ); + return iServiceId; + } + + +// --------------------------------------------------------- +// CVIMPSTEngine::ServiceName +// +// --------------------------------------------------------- +const TDesC& CVIMPSTEngine::ServiceName() const + { + TRACER_AUTO; + TPtr serviceNamePtr = iServiceName->Des(); + TRACE( "ServiceName: '%S'", &serviceNamePtr ); + return *iServiceName; + } + +// --------------------------------------------------------- +// CVIMPSTEngine::ServiceState +// +// --------------------------------------------------------- +TVIMPSTEnums::TVIMPSTRegistrationState CVIMPSTEngine::ServiceState() const + { + TRACER_AUTO; + TRACE( "ServiceState: %d", iState ); + return iState; + } + + +// --------------------------------------------------------- +// CVIMPSTEngine::GetBrandInfo +// +// --------------------------------------------------------- +TInt CVIMPSTEngine::GetBrandInfoL(TLanguage& aBrandLanguage, + TInt &aBrandVersion, TDes8& aBrandId) const + + { + TRACER_AUTO; + TRACE("ServiceId: %d", iServiceId ); + + iTableFetcher.GetBrandIdL(iServiceId, aBrandId); + aBrandLanguage = iTableFetcher.PropertyBrandLanguageL(iServiceId); + aBrandVersion = iTableFetcher.PropertyBrandVersionL(iServiceId); + return KErrNone; + } + + +// --------------------------------------------------------- +// CVIMPSTEngine::IsSubServiceSupportedL +// +// --------------------------------------------------------- +TBool CVIMPSTEngine::IsSubServiceSupportedL(TVIMPSTEnums::SubServiceType aType) const + { + TRACER_AUTO; + TRACE("ServiceId: %d", iServiceId); + TRACE("SubServiceType: %d", aType); + + TBool support = EFalse; + + MVIMPSTEngineSubService* subService = SubService(aType); + if (subService) + { + support = ETrue; + } + + TRACE( "support: %d", support ); + return support; + + } + + +// --------------------------------------------------------- +// CVIMPSTEngine::IsSubServiceEnabled +// +// --------------------------------------------------------- +TBool CVIMPSTEngine::IsSubServiceEnabled(TVIMPSTEnums::SubServiceType aType) const + { + + + TRACER_AUTO; + TRACE( "ServiceId: %d", iServiceId ); + TRACE( "SubServiceType: %d", aType ); + + MVIMPSTEngineSubService* subService = SubService(aType); + TBool enabled = EFalse; + + if (subService) + { + if ( TVIMPSTEnums::ESVCERegistered == subService->SubServiceState() ) + { + enabled = ETrue; + } + } + TRACE( "enabled: %d", enabled ); + return enabled; + } + +// --------------------------------------------------------- +// CVIMPSTEngine::GetContactStoreIdL +// +// --------------------------------------------------------- +void CVIMPSTEngine::ContactStoreIdL (TDes& aContactStoreId ) const + { + TRACER_AUTO; + TRACE("ServiceId: %d", iServiceId ); + iTableFetcher.GetContactStoreIdL(iServiceId, aContactStoreId); + + } + +// --------------------------------------------------------------------------- +// CVIMPSTEngine::RegisterServiceSessionObserver() +// --------------------------------------------------------------------------- +// +void CVIMPSTEngine::RegisterServiceSessionObserverL + (MVIMPSTEngineServiceStateEventObserver* aObserver) + { + TRACER_AUTO; + __ASSERT_ALWAYS(aObserver,User::Leave(KErrArgument)); + TInt index = iObserverArray.Find(aObserver); + if( index == KErrNotFound ) + { + iObserverArray.Append( aObserver ); + } + + } + +// --------------------------------------------------------------------------- +// CVIMPSTEngine::UnRegisterServiceSessionObserver() +// --------------------------------------------------------------------------- +// +void CVIMPSTEngine::UnRegisterServiceSessionObserver + (MVIMPSTEngineServiceStateEventObserver* aObserver) + { + + TRACER_AUTO; + if(aObserver) + { + TInt index = iObserverArray.Find(aObserver); + if( index >=0 ) + { + iObserverArray.Remove( index ); + iObserverArray.Compress(); + } + } + + } +// --------------------------------------------------------- +// CVIMPSTEngine::IntializeStorage +// +// --------------------------------------------------------- +void CVIMPSTEngine::IntializeStorageL() + { + TRACER_AUTO; + TRACE( "ServiceId: %d", iServiceId ); + iContactInterface = CVIMPSTStorageManagerFactory::ContactListInterfaceL(iServiceId); + if(iContactInterface) + { + iContactInterface->AddObserverL( this ); + MVIMPSTSettingsStore* store = CVIMPSTSettingsStore::NewLC(); + RBuf lastUserName; + lastUserName.CreateL( KPropertyMaxLength ); + CleanupClosePushL( lastUserName ); + store->GetL( iServiceId, EServiceLastUserName, lastUserName ); + if( lastUserName.Length() == 0 ) + { + HBufC* userId = GetOwnUserIdFromCChOrStorageL(); + CleanupStack::PushL( userId ); + store->SetL(iServiceId, EServiceLastUserName,*userId); + iContactInterface->SetOwnUserIdL(*userId ); + CleanupStack::PopAndDestroy(); //userId + } + else + { + iContactInterface->SetOwnUserIdL(lastUserName ); + } + CleanupStack::PopAndDestroy(&lastUserName); //lastUserName + CleanupStack::PopAndDestroy(); //store + } + + } +// --------------------------------------------------------- +// CVIMPSTEngine::UnIntializeStorage +// +// --------------------------------------------------------- +void CVIMPSTEngine::UnIntializeStorage() + { + TRACER_AUTO; + TRACE( "ServiceId: %d", iServiceId ); + if(iContactInterface) + { + iContactInterface->RemoveObserver( this ); + } + + } + +//----------------------------------------------------------------------------- +// CVIMPSTEngine::SetOwnUserIdIfChangedL +// ( Other items commented in header ) +//----------------------------------------------------------------------------- +void CVIMPSTEngine::SetOwnUserIdIfChangedL(const TDesC& aUserId) + { + + TRACER_AUTO; + MVIMPSTSettingsStore* store = CVIMPSTSettingsStore::NewLC(); + RBuf lastUserName; + lastUserName.CreateL( KPropertyMaxLength ); + CleanupClosePushL( lastUserName ); + store->GetL( iServiceId, EServiceLastUserName, lastUserName ); + //first time when cenrep is not set with any value. set current as lastusername + if( lastUserName.Compare( aUserId ) != 0 ) + { + store->SetL(iServiceId, EServiceLastUserName,aUserId); + iContactInterface->SetOwnUserIdL(aUserId ); + } + CleanupStack::PopAndDestroy(&lastUserName); //lastUserName + CleanupStack::PopAndDestroy(); //store + + } + +//----------------------------------------------------------------------------- +// CVIMPSTEngine::GetOwnUserIdFromCChOrStorageL +// ( Other items commented in header ) +//----------------------------------------------------------------------------- +HBufC* CVIMPSTEngine::GetOwnUserIdFromCChOrStorageL() const + { + + TRACER_AUTO; + TRACE( "ServiceId: %d", iServiceId ); + HBufC* buffer = NULL; + if(iCchHandler) + { + // Set userid + buffer = iCchHandler->GetConParametersL(ECchUsername); + CleanupStack::PushL( buffer ); + } + if (!buffer) + { + buffer = KNullDesC().AllocLC(); + } + CleanupStack::Pop();//buffer + return buffer; + } + +//----------------------------------------------------------------------------- +// CVIMPSTEngine::SubService +// ( Other items commented in header ) +//----------------------------------------------------------------------------- +MVIMPSTEngineSubService* CVIMPSTEngine::SubService(TVIMPSTEnums::SubServiceType aType) const + { + TRACER_AUTO; + TRACE("ServiceId: %d", iServiceId ); + TRACE( "SubServiceType: %d", aType ); + TInt subServiceCount = iSubService.Count(); + MVIMPSTEngineSubService* subService = NULL; + + // iterate the service array + for ( TInt index = 0; index < subServiceCount ; index++ ) + { + + if (aType == iSubService[index]->Type()) + { + subService = iSubService[index]; + TRACE("SubService Found"); + break; + } + } + + + + return subService; + } + + +//----------------------------------------------------------------------------- +// CVIMPSTEngine::ExtentionFeatures +// ( Other items commented in header ) +//----------------------------------------------------------------------------- +MVIMPSTEngineExtentionFeatures* CVIMPSTEngine::ExtentionFeatures(TVIMPSTEnums::ExtentionType aType) const + { + TRACER_AUTO; + TRACE("ServiceId: %d", iServiceId); + TRACE("ExtentionType: %d", aType); + TInt fetaureCount = iExtentionFeatures.Count(); + MVIMPSTEngineExtentionFeatures* feature = NULL; + + // iterate the service array + for ( TInt index = 0; index < fetaureCount ; index++ ) + { + + if (aType == iExtentionFeatures[index]->Type()) + { + feature = iExtentionFeatures[index]; + TRACE("ExtentionFeatures Found"); + break; + } + } + + + return feature; + } + + + +//----------------------------------------------------------------------------- +// CVIMPSTEngine::AddExtentionFeaturesL +// ( Other items commented in header ) +//----------------------------------------------------------------------------- +void CVIMPSTEngine::AddExtentionFeaturesL(MVIMPSTEngineExtentionFeatures* aFeature) + { + __ASSERT_ALWAYS(aFeature,User::Leave(KErrArgument)); + + TRACER_AUTO; + TRACE( "ServiceId: %d", iServiceId ); + if (aFeature) + { + TRACE( "ExtentionType: %d", aFeature->Type() ); + iExtentionFeatures.Append(aFeature); + TRACE( "Append Done" ); + } + + + + } + + +//----------------------------------------------------------------------------- +// CVIMPSTEngine::RemoveExtentionFeatures +// ( Other items commented in header ) +//----------------------------------------------------------------------------- +void CVIMPSTEngine::RemoveExtentionFeatures(TVIMPSTEnums::ExtentionType aType) + { + TRACER_AUTO; + + TRACE( "ServiceId: %d", iServiceId ); + TInt fetaureCount = iExtentionFeatures.Count(); + + // iterate the service array + for ( TInt index = 0; index < fetaureCount ; index++ ) + { + + if (aType == iExtentionFeatures[index]->Type()) + { + TRACE( "ExtentionType: %d", aType ); + iExtentionFeatures.Remove(index); + iExtentionFeatures.Compress(); + TRACE( "Remove Done" ); + break; + } + } + + + + } + + + +//----------------------------------------------------------------------------- +// CVIMPSTEngine::HandleServceConnectionEventL +// ( Other items commented in header ) +//----------------------------------------------------------------------------- +void CVIMPSTEngine::HandleServceConnectionEventL() + { + TRACER_AUTO; + TRACE( "ServiceId: %d", iServiceId ); + + TVIMPSTEnums::TVIMPSTRegistrationState previousState = iState; + iState = ParseGetServiceState(); + + if(TVIMPSTEnums::ESVCENotRegistered == iState) + { + CVIMPSTEnginePresenceSubService* presSubService = + dynamic_cast + (SubService(TVIMPSTEnums::EPresence)); + if(presSubService) + { + presSubService->ResetBlockedListManagerL(); + } + } + TRACE( "PreviousState: %d, CurrentState:%d", previousState, iState ); + //Only send observer notifications if there is any change in the Service State + //Otherwise not required + if (previousState != iState) + { + //Presence Service needs to Register for the XIMP Events once when + //the context gets binded + //Get Presence SubService + CVIMPSTEnginePresenceSubService* presSubService = + dynamic_cast(SubService(TVIMPSTEnums::EPresence)); + // in case of roaming(moving from one network to another) + // servicetab goes from registered to connecting state, hence the unbind is done here. + if ( presSubService && TVIMPSTEnums::ESVCERegistered == previousState && + TVIMPSTEnums::ESVCENetworkConnecting == iState ) + { + TRACE( "UnsubscribeLists" ); + + TRAPD( err, presSubService->UnsubscribeListsL() ); + + TRACE( "UnsubscribeLists -err: %d" , err ); + + if ( iSessionCntxtObserver ) + { + iSessionCntxtObserver->ServerUnBindL( ETrue ); + } + } + TInt count = iObserverArray.Count(); + for (TInt index=0; indexHandleServiceEventL(iState, KErrNone); + } + TInt ximpAdapterUid = iTableFetcher.XimpAdapterUidL(iServiceId); + if ( (iSessionCntxtObserver) && (KErrNotFound != ximpAdapterUid ) ) + { + + if ( ( TVIMPSTEnums::ESVCEUpdatingContacts == iState || + TVIMPSTEnums::ESVCERegistered == iState ) && + TVIMPSTEnums::EVIMPSTBindNotDone == iSessionCntxtObserver->ContextBindStatus() ) + { + TInt error = iSessionCntxtObserver->ServerBindL(TUid::Uid( ximpAdapterUid )); + if(KErrNone != error) + { + //should never reache here; + iCchHandler->DisableService(); + User::LeaveIfError(error); + } + SetExtentionFeaturesSupportedL(); + } + else if (TVIMPSTEnums::ESVCENotRegistered == iState ) + { + MVIMPSTStorageServiceView* storage = CVIMPSTStorageManagerFactory::ContactListInterfaceL(iServiceId); + if( storage ) + { + MVIMPSTStorageContact& ownContact = storage->OwnContactL(); + TPtrC ownUserId = ownContact.UserId(); + if( ownUserId.Length() && presSubService ) + { + presSubService->UnSubscribePresenceOfSingleContactL( ownUserId ); + } + MVIMPSTStorageContactList* list = storage->FindContactList(KIMContactListId) ; + if ( list ) + { + TInt count = list->Count(); + for(TInt i = 0;i < count; i++) + { + MVIMPSTStorageContact* contact = &(list->operator[](i)); + if(contact) + { + if(presSubService) + { + if( contact->UserId().Length() ) + { + TRAP_IGNORE( presSubService->UnSubscribePresenceOfSingleContactL( contact->UserId() ) ); + } + if(!(contact->UserId().Length())) // if no XspId + { + contact->SetOnlineStatus(TVIMPSTEnums::EUnknown); + } + else if(TVIMPSTEnums::EPending != contact->OnlineStatus()) + { + contact->SetOnlineStatus(TVIMPSTEnums::EOffline); + }// end of if + }// end of for + } // end of if(contact) + }// end of for + storage->Sort(KIMContactListId); + // Inform service state changes to UI service tab + // and further to update the buddy list after sort. + TInt obsvrArrayCount = iObserverArray.Count(); + for (TInt index=0; indexHandleServiceEventL(iState, KErrNone); + } + } + } + ReSetExtentionFeaturesSupportedL(); + } //end of else if + }// end of isessioncontextobserver and ximpadapteruid. + }// end of if(previousstate != iState) + + } + +//----------------------------------------------------------------------------- +// CVIMPSTEngine::ParseGetServiceState +// ( Other items commented in header ) +//----------------------------------------------------------------------------- +TVIMPSTEnums::TVIMPSTRegistrationState CVIMPSTEngine::ParseGetServiceState() + { + TRACER_AUTO; + TInt subServiceCount = iSubService.Count(); + TInt serviceState = 0; + + //Find the cumulative of the ServiceStates of all subservices + // iterate the service array + for ( TInt index = 0; index < subServiceCount ; index++ ) + { + serviceState |= iSubService[index]->SubServiceState(); + } + + //ServiceState + TVIMPSTEnums::TVIMPSTRegistrationState state = TVIMPSTEnums::ESVCENotRegistered; + + //The logic below is that, if any one subservice not enabled for us the service is not enabled + //So to do this we assign priority for each service state + //Connecting gets the High Priority, when copmared to Waiting for Connection, + //Disconnecting, Registered, UnRegistered. + //By this way the Sevice Tab will be more usable and atleast we can perform operations + //related to the the logged in subservice + //its upto the connection handlers to do the job properly, whether to provide connectivity to all + //sub services or not.. + + //Start parsing and decide the state of the ServiceTab + if ( serviceState & TVIMPSTEnums::ESVCENetworkConnecting ) + { + //Connecting + state = TVIMPSTEnums::ESVCENetworkConnecting; + } + else if ( serviceState & TVIMPSTEnums::ESVCEWaitingForNetwork ) + { + //Waiting for Connection + state = TVIMPSTEnums::ESVCEWaitingForNetwork; + } + else if ( serviceState & TVIMPSTEnums::ESVCEUpdatingContacts ) + { + //Waiting for Connection + state = TVIMPSTEnums::ESVCEUpdatingContacts; + } + else if ( serviceState & TVIMPSTEnums::ESVCENetworkDisConnecting ) + { + //disconnecting + state = TVIMPSTEnums::ESVCENetworkDisConnecting; + } + else if ( serviceState & TVIMPSTEnums::ESVCERegistered ) + { + //Enabled + state = TVIMPSTEnums::ESVCERegistered; + } + + return state; + } + +//----------------------------------------------------------------------------- +// CVIMPSTEngine::HandleContactFetchedL +// ( Other items commented in header ) +//----------------------------------------------------------------------------- +void CVIMPSTEngine::HandleContactFetchedL() + { + + TRACER_AUTO; + + if (TVIMPSTEnums::ESVCERegistered == iState || + TVIMPSTEnums::ESVCEUpdatingContacts == iState ) + { + MVIMPSTEngineSubService* subService = SubService(TVIMPSTEnums::EPresence); + if (subService) + { + //Get Presence SubService + MVIMPSTEnginePresenceSubService& presenceSubService = + MVIMPSTEnginePresenceSubService::Cast(*subService); + + if (TVIMPSTEnums::ESVCERegistered == subService->SubServiceState() || + TVIMPSTEnums::ESVCEUpdatingContacts == subService->SubServiceState() ) + { + presenceSubService.FetchPresenceFromCache(); + } + presenceSubService.UpdatePresenceStateL(); + } + // this is added here as for xmpp subscribeforsearchkeys needs to be done only + // after the contactts are fetched from the server, + // SetExtensionFeaturesSupported is moved to immediately after login. + // as for sip case it would never come to this line if there are not contacts in it. + MVIMPSTEngineExtentionFeatures* feature = ExtentionFeatures( + TVIMPSTEnums::ESearch); + if (feature) + { + MVIMPSTEngineSearchMgrExtention& searchFeature = + MVIMPSTEngineSearchMgrExtention::Cast(*feature); + //subscribe for search keys, since this is a server feature + if(TVIMPSTEnums::ESupportUnKnown == searchFeature.IsSupported()) + { + searchFeature.SubscribeForSearchKeysL(); + } + } + } + + } + +// -------------------------------------------------------------------------- +// CVIMPSTEngine::HandleStorageChangeL +// -------------------------------------------------------------------------- +// +void CVIMPSTEngine::HandleStorageChangeL( TVIMPSTEnums::TVIMPSTStorgaeEventType aEventType, + MVIMPSTStorageContactList* /*aList*/, + MVIMPSTStorageContact* aContact, + TInt /*aContactIndex*/ ) + { + + TRACER_AUTO; + TRACE(" iState = %d", iState); + if (TVIMPSTEnums::ESVCERegistered == iState || TVIMPSTEnums::ESVCEUpdatingContacts == iState ) + { + TRACE( "Inside IF"); + TRACE( "aEventType : %d", aEventType); + switch( aEventType ) + { + case TVIMPSTEnums::EStorageContactReadComplete: + case TVIMPSTEnums::EStorageContactFetchComplete: + { + TRACE( "aEventType EStorageContactFetchComplete"); + MVIMPSTEngineSubService* subService = SubService(TVIMPSTEnums::EPresence); + if( subService ) + { + + TRACE( "Inside IF subService"); + MVIMPSTEnginePresenceSubService& presenceSubService = MVIMPSTEnginePresenceSubService::Cast(*subService); + + MVIMPSTStorageServiceView* storage = CVIMPSTStorageManagerFactory::ContactListInterfaceL(iServiceId); + if( storage ) + { + MVIMPSTStorageContact& ownContact = storage->OwnContactL(); + TPtrC ownUserId = ownContact.UserId(); + if( ownUserId.Length() ) + { + presenceSubService.SubscribePresenceOfSingleContactL( ownUserId ); + } + + TRACE( "inside if storage"); + MVIMPSTStorageContactList* list = storage->FindContactList(KIMContactListId) ; + if ( list ) + { + + TRACE( "inside if list"); + TInt count = list->Count(); + TRACE( "inside count = %d", count); + for(TInt i = 0;i < count; i++) + { + MVIMPSTStorageContact* contact = &(list->operator[](i)); + if(contact) + { + if( contact->UserId().Length() ) + { + TPtrC userId = contact->UserId(); + TRACE("inside userId = %S", &userId); + presenceSubService.SubscribePresenceOfSingleContactL( contact->UserId() ); + } + } // end of if(contact) + }// end of for + } + } + + } + HandleContactFetchedL(); + + break; + } + case TVIMPSTEnums::EStorageEventOwnUserChanged: + case TVIMPSTEnums::EStorageEventContactAddition: + case TVIMPSTEnums::EStorageContactSynchronizing: + case TVIMPSTEnums::EStorageContactReading: + case TVIMPSTEnums::EStorageContactFetchExistInStore: + { + TRACE( "aEventType : %d", aEventType); + MVIMPSTEngineSubService* subService = SubService(TVIMPSTEnums::EPresence); + if( subService && aContact && + aContact->UserId().Length() && + TVIMPSTEnums::ESVCERegistered == iState ) + { + MVIMPSTEnginePresenceSubService& presenceSubService = MVIMPSTEnginePresenceSubService::Cast(*subService); + presenceSubService.SubscribePresenceOfSingleContactL( aContact->UserId() ); + presenceSubService.FetchPresenceOfSingleContactL(aContact->UserId()); + } + break; + } + case TVIMPSTEnums::EStorageEventUserIdPreChange: + case TVIMPSTEnums::EStorageEventDeleteFromPbk: + { + + TRACE("EStorageEventUserIdPreChange/EStorageEventDeleteFromPbk"); + if( aContact && aContact->UserId().Length() ) + { + TPtrC userId = aContact->UserId(); + MVIMPSTEngineSubService* subService = SubService(TVIMPSTEnums::EPresence); + // incase of delete from phonebook delete from server and close conversation if exist + // mostly applicable for local store cases + if( subService ) + { + MVIMPSTEnginePresenceSubService& presenceSubService = MVIMPSTEnginePresenceSubService::Cast(*subService); + presenceSubService.UnSubscribePresenceOfSingleContactL( userId ) ; + } + MVIMPSTEngineExtentionFeatures* feature = ExtentionFeatures(TVIMPSTEnums::EContactManagement); + if (feature ) + { + MVIMPSTEngineContactMgmtExtention& contactMgr = MVIMPSTEngineContactMgmtExtention::Cast(*feature); + contactMgr.DeleteServerContactL(KNullDesC,userId) ; + } + MVIMPSTEngineSubService* imService = SubService(TVIMPSTEnums::EIM) ; + if(imService) + { + MVIMPSTEngineIMSubService& imSubService = MVIMPSTEngineIMSubService::Cast (*imService); + imSubService.CloseConversationL( userId ); + } + } + break; + } + case TVIMPSTEnums::EStorageEventUserIdPostChange: + { + + TRACE("EStorageEventUserIdPostChange"); + if( aContact && aContact->UserId().Length() ) + { + TPtrC userId = aContact->UserId(); + // incase of delete from phonebook delete from server and close conversation if exist + // mostly applicable for local store cases + MVIMPSTEngineSubService* subService = SubService(TVIMPSTEnums::EPresence); + if( subService ) + { + MVIMPSTEnginePresenceSubService& presenceSubService = MVIMPSTEnginePresenceSubService::Cast(*subService); + presenceSubService.SubscribePresenceOfSingleContactL( userId ); + } + MVIMPSTEngineExtentionFeatures* feature = ExtentionFeatures(TVIMPSTEnums::EContactManagement); + if (feature ) + { + MVIMPSTEngineContactMgmtExtention& contactMgr = MVIMPSTEngineContactMgmtExtention::Cast(*feature); + contactMgr.AddServerContactL(KListNameAllBuddy,userId, aContact->Name(), EFalse ); + } + } + break; + } + default: + { + break; + } + } + } + } + +//----------------------------------------------------------------------------- +// CVIMPSTEngine::CreateExtentionFeaturesL +// ( Other items commented in header ) +//----------------------------------------------------------------------------- +void CVIMPSTEngine::CreateExtentionFeaturesL() + { + TRACER_AUTO; + if (!iSessionCntxtObserver) + { + return; + } + + //create all the features + //first find whether we have the extention already created + //in the extention manager list + + //first find whether we have the extention already created + //in the extention manager list + MVIMPSTEngineExtentionFeatures* contactMgtFeature = ExtentionFeatures( + TVIMPSTEnums::EContactManagement); + + if (!contactMgtFeature) + { + CVIMPSTEngineContactMgmtExtention* contactItem = + CVIMPSTEngineContactMgmtExtention::NewL( + iSessionCntxtObserver->XimpPresenceContextL(), + iSessionCntxtObserver->XimpPresentityGroupsL(), + *iSessionCntxtObserver->GetRequestMapper()); + + AddExtentionFeaturesL(contactItem); + //Unregister is done by session context when the presence context gets + //unbinded + iSessionCntxtObserver->RegisterObserver(contactItem); + } + + + //first find whether we have the extention already created + //in the extention manager list + MVIMPSTEngineExtentionFeatures* searchFeature = ExtentionFeatures( + TVIMPSTEnums::ESearch); + if (!searchFeature) + { + CVIMPSTEngineSearchMgrExtention* searchitem = + CVIMPSTEngineSearchMgrExtention::NewL( + iSessionCntxtObserver->XimpPresenceContextL(), + *iSessionCntxtObserver->GetRequestMapper()); + + AddExtentionFeaturesL(searchitem); + + //Unregister is done by session context when the presence context gets + //unbinded + iSessionCntxtObserver->RegisterObserver(searchitem); + } + + } + +//----------------------------------------------------------------------------- +// CVIMPSTEngine::SetExtentionFeaturesSupportedL +// ( Other items commented in header ) +//----------------------------------------------------------------------------- +void CVIMPSTEngine::SetExtentionFeaturesSupportedL() + { + TRACER_AUTO; + if (!iSessionCntxtObserver) + { + return; + } + + //We would have got the supported features + //iterate and create the required extentionmgr + TInt supportedFeatures = iSessionCntxtObserver->GetSupportedFeatures(); + + if ( !(EVIMPSTFeatureSearch & supportedFeatures) ) + { + //first find whether we have the extention already created + //in the extention manager list + MVIMPSTEngineExtentionFeatures* feature = ExtentionFeatures( + TVIMPSTEnums::ESearch); + if (feature) + { + MVIMPSTEngineSearchMgrExtention& searchFeature = + MVIMPSTEngineSearchMgrExtention::Cast(*feature); + searchFeature.SetSupported(TVIMPSTEnums::ENotSupported); + //subscribe for search keys is done once the contacts are fetched from the server. + //check HandleContactFetchCOmpletedL(). + } + } + + if (( EVIMPSTFeatureAddContact & supportedFeatures ) || + ( EVIMPSTFeatureDeleteContact & supportedFeatures )) + { + //first find whether we have the extention already created + //in the extention manager list + MVIMPSTEngineExtentionFeatures* feature = ExtentionFeatures( + TVIMPSTEnums::EContactManagement); + if (feature) + { + MVIMPSTEngineContactMgmtExtention& contactMgmtFeature = + CVIMPSTEngineContactMgmtExtention::Cast(*feature); + contactMgmtFeature.SetSupported(TVIMPSTEnums::ESupported); + } + + } + + if ( EVIMPSTFeatureAvatar & supportedFeatures ) + { + //first find whether we have the extention already created + //in the extention manager list + MVIMPSTEngineSubService* subService = SubService( + TVIMPSTEnums::EPresence); + if (subService) + { + MVIMPSTEnginePresenceSubService& avatarFeature = + CVIMPSTEnginePresenceSubService::Cast(*subService); + avatarFeature.SetAvatarSupported(ETrue); + } + } + } + + +//----------------------------------------------------------------------------- +// CVIMPSTEngine::ReSetExtentionFeaturesSupportedL +// ( Other items commented in header ) +//----------------------------------------------------------------------------- +void CVIMPSTEngine::ReSetExtentionFeaturesSupportedL() + { + TRACER_AUTO; + //first find whether we have the extention already created + //in the extention manager list + MVIMPSTEngineExtentionFeatures* feature = ExtentionFeatures( + TVIMPSTEnums::ESearch); + if (feature) + { + MVIMPSTEngineSearchMgrExtention& searchFeature = + MVIMPSTEngineSearchMgrExtention::Cast(*feature); + searchFeature.SetSupported(TVIMPSTEnums::ESupportUnKnown); + } + + //first find whether we have the extention already created + //in the extention manager list + MVIMPSTEngineExtentionFeatures* feature1 = ExtentionFeatures( + TVIMPSTEnums::EContactManagement); + if (feature1) + { + MVIMPSTEngineContactMgmtExtention& contactMgmtFeature = + CVIMPSTEngineContactMgmtExtention::Cast(*feature1); + contactMgmtFeature.SetSupported(TVIMPSTEnums::ESupportUnKnown); + } + + //first find whether we have the extention already created + //in the extention manager list + MVIMPSTEngineSubService* subService = SubService( + TVIMPSTEnums::EPresence ); + if (subService) + { + MVIMPSTEnginePresenceSubService& avatarFeature = + CVIMPSTEnginePresenceSubService::Cast(*subService); + avatarFeature.SetAvatarSupported(EFalse); + } + + } + + +// --------------------------------------------------------- +// CVIMPSTEngine::DefaultDomainNameL +// +// --------------------------------------------------------- +void CVIMPSTEngine::DefaultDomainNameL( TDes& aDefaultDomainName ) const + { + TRACER_AUTO; + TRACE( "ServiceId: %d", iServiceId ); + iTableFetcher.GetDefaultDomainNameL(iServiceId, aDefaultDomainName); + + } + + +// --------------------------------------------------------- +// CVIMPSTEngine::IsSubServiceSupportedInternal +// +// --------------------------------------------------------- +TBool CVIMPSTEngine::IsSubServiceSupportedInternal(TVIMPSTEnums::SubServiceType aType) const + { + TRACER_AUTO; + TRACE( "ServiceId: %d", iServiceId ); + TRACE( "SubServiceType: %d", aType ); + TInt err = KErrNotFound; + TBool support = EFalse; + TCCHSubserviceState aCCHState(ECCHUninitialized); + + switch(aType) + { + case TVIMPSTEnums::EVoip: + { + err = iCchHandler->GetServiceState(iServiceId, ECCHVoIPSub, aCCHState); + break; + } + case TVIMPSTEnums::EPresence: + { + err = iCchHandler->GetServiceState(iServiceId, ECCHPresenceSub, aCCHState); + break; + } + case TVIMPSTEnums::EIM: + { + err = iCchHandler->GetServiceState(iServiceId, ECCHIMSub, aCCHState); + break; + } + default: + { + break; + } + + } + + if (KErrNone == err) + { + support = ETrue; + } + + + TRACE("support: %d", support ); + return support; + } + + +// --------------------------------------------------------- +// CVIMPSTEngine::ChangeConnectionL +// +// --------------------------------------------------------- +TInt CVIMPSTEngine::ChangeConnectionL() + { + TRACER_AUTO; + TRACE( "ServiceId: %d", iServiceId ); + TInt error = KErrNotFound; + if(iCchHandler) + { + + TRACE( "ChangeConnectionL() Called" ); + error = iCchHandler->ChangeConnectionL(); + } + + + TRACE("error: %d", error ); + + return error; + } + +// --------------------------------------------------------- +// CVIMPSTEngine::IsBlockSupportedL +// +// --------------------------------------------------------- + +TBool CVIMPSTEngine::IsBlockSupportedL() + { + TRACER_AUTO; + TBool isBlockSupported = EFalse; + //We would have got the supported features + if(iSessionCntxtObserver && (TVIMPSTEnums::ESVCERegistered == ParseGetServiceState())) + { + TInt supportedFeatures = iSessionCntxtObserver->GetSupportedFeatures(); + if ( (EVIMPSTFeatureBlock & supportedFeatures) && (EVIMPSTFeatureUnBlock & supportedFeatures) ) + { + isBlockSupported = ETrue; + } + } + return isBlockSupported; + } + +// --------------------------------------------------------- +// CVIMPSTEngine::IsPasswordAvailable +// returns True if password is present in the settings else returns false +// --------------------------------------------------------- +TBool CVIMPSTEngine::IsPasswordAvailableL() + { + TRACER_AUTO; + + return(iCchHandler->IsPasswordAvailable(ECchPasswordSet)); + } + +// --------------------------------------------------------- +// CVIMPSTEngine::DeleteDataBase +// --------------------------------------------------------- +void CVIMPSTEngine::DeleteDataBaseL() + { + TRACER_AUTO; + MVIMPSTStorageServiceView* storage = + CVIMPSTStorageManagerFactory::ContactListInterfaceL(iServiceId); + if( storage ) + { + //delete cdb file. + storage->DeleteDatabaseL(); + } + } + +// --------------------------------------------------------------------------- +// CVIMPSTEnginePresenceSubService::GetPreseceSubService +// --------------------------------------------------------------------------- +// +MVIMPSTEnginePresenceSubService* CVIMPSTEngine::GetPreseceSubService() + { + TRACER_AUTO; + MVIMPSTEngineSubService* subService = SubService(TVIMPSTEnums::EPresence); + if (subService) + { + //Get Presence SubService + MVIMPSTEnginePresenceSubService& presenceSubService = + MVIMPSTEnginePresenceSubService::Cast(*subService); + return &presenceSubService ; + } + return NULL; + } + +// --------------------------------------------------------------------------- +// CVIMPSTEngine::FetchBlockedList +// --------------------------------------------------------------------------- +// +void CVIMPSTEngine::FetchBlockedListL() + { + MVIMPSTEnginePresenceSubService* subService = GetPreseceSubService(); + if( subService ) + { + //fetch the blocked list from server + subService->FetchBlockedListFromServerL(iBlockListObs); + } + } + +// --------------------------------------------------------------------------- +// CVIMPSTEngine::RegisterBlockedListObserver +// --------------------------------------------------------------------------- +// +void CVIMPSTEngine::RegisterBlockedListObserver( + MVIMPSTEngineBlockedListFetchEventObserver* aOb) + { + iBlockListObs = aOb; + } + +// --------------------------------------------------------------------------- +// CVIMPSTEngine::HandleChangeConnectionEventL +// --------------------------------------------------------------------------- +// +void CVIMPSTEngine::HandleChangeConnectionEventL() + { + TRACER_AUTO; + MVIMPSTEngineSubService* subService = SubService(TVIMPSTEnums::EPresence); + if (subService) + { + //Get Presence SubService + MVIMPSTEnginePresenceSubService& presenceSubService = + MVIMPSTEnginePresenceSubService::Cast(*subService); + if (TVIMPSTEnums::ESVCERegistered == subService->SubServiceState() || + TVIMPSTEnums::ESVCEUpdatingContacts == subService->SubServiceState() ) + { + // Unsubscribe all lists here to get whole list contents when doing a new bind. + // Trap here to avoid unbind not being done if list operations should leave + TRAP_IGNORE( presenceSubService.UnsubscribeListsL() ); + } + } + + if( iSessionCntxtObserver ) + { + iSessionCntxtObserver->ServerUnBindL(ETrue); + } + } + +// ------------------------------------------------------- +// CVIMPSTEngine :: IsUnInstalled +// For Description see MVIMPSTEngine +// ------------------------------------------------------- +// +TBool CVIMPSTEngine::IsUnInstalled( ) + { + return iUnInstall; + } +// End of File