--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/servicewidget/servicewidgetdatapublisher/src/cservicewidgetcchhandler.cpp Wed Sep 01 12:33:36 2010 +0100
@@ -0,0 +1,530 @@
+/*
+* 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 for cch service handling
+ *
+ *
+*/
+
+#include "cservicewidgetcchhandler.h"
+
+#include "cservicewidgetcontentpublisher.h"
+#include "mservicewidgetobservers.h"
+#include "servicewidgetcpglobals.h"
+#include "swpdebugtrace.h"
+
+#include <spsettings.h>
+#include <spentry.h>
+#include <spproperty.h>
+
+// ---------------------------------------------------------------------------
+// CServiceWidgetCchHandler::CServiceWidgetCchHandler
+// ---------------------------------------------------------------------------
+//
+CServiceWidgetCchHandler::CServiceWidgetCchHandler(TUint32 aServiceId,
+ MServiceWidgetServiceStateObserver& aStateObserver ):
+ iServiceId(aServiceId),
+ iStateObserver( aStateObserver ),
+ iServiceState( ESWSNotRegistered )
+ {
+ TRACE_SWP(TXT("CServiceWidgetCchHandler::CServiceWidgetCchHandler iServiceId %d"),iServiceId );
+ }
+
+// ---------------------------------------------------------------------------
+// CServiceWidgetCchHandler::NewL
+// ---------------------------------------------------------------------------
+//
+CServiceWidgetCchHandler* CServiceWidgetCchHandler::NewL(TUint32 aServiceId,
+ MServiceWidgetServiceStateObserver& aStateObserver )
+ {
+ TRACE_SWP(TXT("CServiceWidgetCchHandler::NewL() start") );
+ CServiceWidgetCchHandler* self = NewLC(aServiceId, aStateObserver);
+ CleanupStack::Pop(self);
+ TRACE_SWP(TXT("CServiceWidgetCchHandler::NewL() end") );
+ return self;
+ }
+
+// ---------------------------------------------------------------------------aOwnStatusKey
+// CServiceWidgetCchHandler::NewLC
+// ---------------------------------------------------------------------------
+//
+CServiceWidgetCchHandler* CServiceWidgetCchHandler::NewLC(TUint32 aServiceId,
+ MServiceWidgetServiceStateObserver& aStateObserver )
+ {
+ TRACE_SWP(TXT("CServiceWidgetCchHandler::NewLC() start") );
+ CServiceWidgetCchHandler* self =
+ new (ELeave) CServiceWidgetCchHandler(aServiceId, aStateObserver);
+ CleanupStack::PushL(self);
+ self->ConstructL( );
+ TRACE_SWP(TXT("CServiceWidgetCchHandler::NewLC() end") );
+ return self;
+ }
+
+// ---------------------------------------------------------------------------
+// CServiceWidgetCchHandler::ConstructL
+// ---------------------------------------------------------------------------
+//
+void CServiceWidgetCchHandler::ConstructL()
+ {
+ TRACE_SWP(TXT("CServiceWidgetCchHandler::ConstructL() start") );
+ iCchClient = CCch::NewL();
+ TRACE_SWP(TXT("CServiceWidgetCchHandler::ConstructL() iCchClient created") );
+ CCchService* service = iCchClient->GetService( iServiceId );
+ if( service )
+ {
+ service->AddObserver( *this );
+ }
+ //Configure CCHUI notes
+ MCchUi& cchui = iCchClient->CchUiApi();
+ // Configure CCHUI API to show all notes/dialogs except connecting note.
+ // Also configure that only VoIP and IM subservices are allowed (notes are
+ // shown only for those).
+ RArray<MCchUiObserver::TCchUiDialogType> allowedNotes;
+ RArray<TCCHSubserviceType> allowedSubServices;
+ CleanupClosePushL( allowedNotes );
+ CleanupClosePushL( allowedSubServices );
+
+ allowedNotes.AppendL( MCchUiObserver::ECchUiDialogTypeUsernamePasswordFailed );
+ allowedNotes.AppendL( MCchUiObserver::ECchUiDialogTypeAuthenticationFailed );
+ allowedNotes.AppendL( MCchUiObserver::ECchUiDialogTypeNoConnectionDefined );
+ allowedNotes.AppendL( MCchUiObserver::ECchUiDialogTypeNoConnectionAvailable );
+ allowedNotes.AppendL( MCchUiObserver::ECchUiDialogTypeConfirmChangeConnection );
+ allowedNotes.AppendL( MCchUiObserver::ECchUiDialogTypeChangeConnection );
+ allowedNotes.AppendL( MCchUiObserver::ECchUiDialogTypeDefectiveSettings );
+ allowedNotes.AppendL( MCchUiObserver::ECchUiDialogTypeErrorInConnection );
+
+ allowedSubServices.AppendL( ECCHVoIPSub );
+ allowedSubServices.AppendL( ECCHIMSub );
+ allowedSubServices.AppendL( ECCHPresenceSub );
+
+ cchui.ConfigureVisualizationL(
+ allowedNotes, allowedSubServices );
+ CleanupStack::PopAndDestroy( &allowedSubServices );
+ CleanupStack::PopAndDestroy( &allowedNotes );
+
+ ReadSupportedSubServices();
+ TRACE_SWP(TXT("CServiceWidgetCchHandler::ConstructL() end") );
+ }
+
+
+// ---------------------------------------------------------------------------
+// CServiceWidgetCchHandler::~CServiceWidgetCchHandler
+// ---------------------------------------------------------------------------
+//
+CServiceWidgetCchHandler::~CServiceWidgetCchHandler()
+ {
+ TRACE_SWP(TXT("CServiceWidgetCchHandler::~CServiceWidgetCchHandler() start") );
+ if(iCchClient)
+ {
+ CCchService* service = iCchClient->GetService( iServiceId );
+ if( service )
+ {
+ service->RemoveObserver(*this);
+ }
+ delete iCchClient;
+ }
+ iSupportedSubServices.Reset();
+
+ delete iServiceName;
+ delete iOwnData;
+ TRACE_SWP(TXT("CServiceWidgetCchHandler::~CServiceWidgetCchHandler() end") );
+ }
+
+// ---------------------------------------------------------------------------
+// CServiceWidgetCchHandler::ReadSupportedSubServices
+// ---------------------------------------------------------------------------
+//
+ void CServiceWidgetCchHandler::ReadSupportedSubServices()
+ {
+ TRACE_SWP(TXT("CServiceWidgetCchHandler::ReadSupportedSubServices() start") );
+ iSupportedSubServices.Reset();
+ TSubServiceState subService;
+ TBool supported = IsServiceSupported( ECCHIMSub );
+ if( supported )
+ {
+ // im sub service supported
+ subService.iSubServiceType = ECCHIMSub;
+ subService.iSubServiceState = GetServiceState( ECCHIMSub );
+ iSupportedSubServices.Append( subService );
+ }
+ supported = IsServiceSupported( ECCHPresenceSub );
+ if( supported )
+ {
+ // presence sub service supported
+ subService.iSubServiceType = ECCHPresenceSub;
+ subService.iSubServiceState = GetServiceState( ECCHPresenceSub );
+ iSupportedSubServices.Append( subService );
+ }
+ supported = IsServiceSupported( ECCHVoIPSub );
+ if( supported )
+ {
+ // voip sub service supported
+ subService.iSubServiceType = ECCHVoIPSub;
+ subService.iSubServiceState = GetServiceState( ECCHVoIPSub );
+ iSupportedSubServices.Append( subService );
+ }
+ TRACE_SWP(TXT("CServiceWidgetCchHandler::ReadSupportedSubServices() end") );
+ }
+
+
+// ---------------------------------------------------------------------------
+// CServiceWidgetCchHandler::ServiceStatusChanged
+// ---------------------------------------------------------------------------
+//
+void CServiceWidgetCchHandler::ServiceStatusChanged(
+ TInt aServiceId,
+ const TCCHSubserviceType aType,
+ const TCchServiceStatus& aServiceStatus )
+ {
+ TRACE_SWP(TXT("CServiceWidgetCchHandler::ServiceStatusChanged() start") );
+ if( aServiceId != iServiceId )
+ {
+ return;
+ }
+ TCCHSubserviceState state = aServiceStatus.State();
+ TInt subServiceCount = iSupportedSubServices.Count();
+ TInt error = aServiceStatus.Error();
+
+ for(TInt i=0; i< subServiceCount; i++)
+ {
+ TSubServiceState subService = iSupportedSubServices[ i ];
+ if( subService.iSubServiceType == aType )
+ {
+ // sub service is matched ,supported
+ // check for ALR state if supported ,service may go to waiting state
+ if( error && (error != KCCHErrorInvalidSettings ) &&
+ ( ECCHConnecting == state ) )
+ {
+ // waiting state
+ iSupportedSubServices[ i ].iSubServiceState = ESWSWaitingForNetwork;
+ }
+ else
+ {
+ TSWSTRegistrationState swState = GetLocalServiceState( state );
+ if( swState == ESWSRegistered && aType == ECCHPresenceSub )
+ {
+ // in case of presence subservice ,need to fetch the contact ,so
+ // move to updating state
+ iSupportedSubServices[ i ].iSubServiceState = ESWSUpdatingContacts;
+ }
+ else
+ {
+ // store the subservice state
+ iSupportedSubServices[ i ].iSubServiceState = swState;
+ }
+ }
+ break; // break the loop if subservice matched
+ }
+ }
+ TSWSTRegistrationState previousState = iServiceState;
+ // get best match state
+ iServiceState = ParseGetServiceState();
+
+ if( iServiceState != previousState )
+ {
+ // inform the observer only if state changed
+ TRACE_SWP(TXT("CServiceWidgetCchHandler::ServiceStatusChanged() state changed") );
+ // some times give the same state call back more than one
+ TRAP_IGNORE( iStateObserver.HandleServiceStatusChangedL( iServiceState ) );
+ }
+ TRACE_SWP(TXT("CServiceWidgetCchHandler::ServiceStatusChanged() end") );
+ }
+
+// ---------------------------------------------------------------------------
+// CServiceWidgetCchHandler::ParseGetServiceState
+// ---------------------------------------------------------------------------
+//
+TSWSTRegistrationState CServiceWidgetCchHandler::ParseGetServiceState()
+ {
+ TRACE_SWP(TXT("CServiceWidgetCchHandler::ParseGetServiceState() start") );
+
+ TInt serviceState = 0;
+ TInt subServiceCount = iSupportedSubServices.Count();
+ //Find the cumulative of the ServiceStates of all subservices
+ // iterate the service array
+ for ( TInt index = 0; index < subServiceCount ; index++ )
+ {
+ serviceState |= iSupportedSubServices[index].iSubServiceState;
+ }
+ TSWSTRegistrationState swState = ESWSNotRegistered;
+ //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 & ESWSNetworkConnecting )
+ {
+ //Connecting
+ swState = ESWSNetworkConnecting;
+ }
+ else if ( serviceState & ESWSWaitingForNetwork )
+ {
+ //Waiting for Connection
+ swState = ESWSWaitingForNetwork;
+ }
+ else if ( serviceState & ESWSUpdatingContacts )
+ {
+ //Waiting for Connection
+ swState = ESWSUpdatingContacts;
+ }
+ else if ( serviceState & ESWSNetworkDisConnecting )
+ {
+ //disconnecting
+ swState = ESWSNetworkDisConnecting;
+ }
+ else if ( serviceState & ESWSRegistered )
+ {
+ //Enabled
+ swState = ESWSRegistered;
+ }
+ TRACE_SWP(TXT("CServiceWidgetCchHandler::ParseGetServiceState() end") );
+ return swState;
+ }
+// ---------------------------------------------------------------------------
+// CServiceWidgetCchHandler::GetServiceState
+// ---------------------------------------------------------------------------
+//
+TSWSTRegistrationState CServiceWidgetCchHandler::GetServiceState( TCCHSubserviceType aServiceType )
+ {
+ TRACE_SWP(TXT("CServiceWidgetCchHandler::GetServiceState() start") );
+ CCchService* service = iCchClient->GetService( iServiceId );
+ TCchServiceStatus status;
+ status.SetState(ECCHUninitialized);
+ if( service )
+ {
+ // Get status from the client
+ service->GetStatus( aServiceType , status );
+ }
+ TRACE_SWP(TXT("CServiceWidgetCchHandler::GetServiceState() end") );
+ return GetLocalServiceState( status.State() );
+ }
+
+// ---------------------------------------------------------------------------
+// CServiceWidgetCchHandler::GetLocalServiceState
+// ---------------------------------------------------------------------------
+//
+TSWSTRegistrationState CServiceWidgetCchHandler::GetLocalServiceState(TCCHSubserviceState aState )
+ {
+ TRACE_SWP(TXT("CServiceWidgetCchHandler::GetLocalServiceState() start") );
+ TSWSTRegistrationState mappedState = ESWSNotRegistered;
+ if( ECCHConnecting == aState )
+ {
+ mappedState = ESWSNetworkConnecting;
+ }
+ else if( ECCHDisconnecting == aState )
+ {
+ mappedState = ESWSNetworkDisConnecting;
+ }
+ else if( ECCHDisabled == aState )
+ {
+ mappedState = ESWSNotRegistered;
+ }
+ else if( ECCHEnabled == aState )
+ {
+ mappedState = ESWSRegistered;
+ }
+ TRACE_SWP(TXT("CServiceWidgetCchHandler::GetLocalServiceState() end") );
+ return mappedState;
+ }
+
+// ---------------------------------------------------------------------------
+// CServiceWidgetCchHandler::OwnUserIdL
+// ---------------------------------------------------------------------------
+//
+const TDesC& CServiceWidgetCchHandler::OwnUserIdL()
+ {
+ TRACE_SWP(TXT("CServiceWidgetCchHandler::OwnUserIdL() start") );
+ if( iOwnData )
+ {
+ delete iOwnData;
+ iOwnData = NULL;
+ }
+
+ // call back can not be modified ignore the error
+ iOwnData = GetConParametersL( ECchUsername );
+ if( iOwnData )
+ {
+ TRACE_SWP(TXT("CServiceWidgetCchHandler::OwnUserIdL() valid") );
+ TRACE_SWP(TXT("CServiceWidgetCchHandler::OwnUserIdL() end") );
+ return *iOwnData;
+ }
+ TRACE_SWP(TXT("CServiceWidgetCchHandler::OwnUserIdL() end") );
+ return KNullDesC ;
+ }
+
+ // ---------------------------------------------------------------------------
+// CServiceWidgetCchHandler::XimpAdaptationUidL()
+// ---------------------------------------------------------------------------
+//
+TInt CServiceWidgetCchHandler::XimpAdaptationUidL()
+ {
+ TRACE_SWP(TXT("CServiceWidgetCchHandler::XimpAdaptationUidL() start") );
+ TInt ret = KErrNotFound;
+ CSPSettings* settings = CSPSettings::NewLC();
+ CSPProperty* property = CSPProperty::NewLC();
+ TInt err = settings->FindPropertyL( iServiceId,
+ EPropertyPCSPluginId,
+ *property );
+ if (KErrNone == err)
+ {
+ TRACE_SWP(TXT("CServiceWidgetCchHandler::XimpAdaptationUidL() uid read") );
+ property->GetValue( ret );
+ }
+ CleanupStack::PopAndDestroy(2);// property ,settings
+ TRACE_SWP(TXT("CServiceWidgetCchHandler::XimpAdaptationUidL() end") );
+ return ret;
+ }
+
+ // ---------------------------------------------------------------------------
+// CServiceWidgetCchHandler::GetConParametersL
+// ---------------------------------------------------------------------------
+//
+HBufC* CServiceWidgetCchHandler::GetConParametersL( TCchConnectionParameter aConnParam )
+ {
+ TRACE_SWP(TXT("CServiceWidgetCchHandler::GetConParametersL() start") );
+ HBufC* temp = NULL;
+ TInt error = KErrNotFound;
+ if(iCchClient)
+ {
+ CCchService* service = iCchClient->GetService( iServiceId );
+ if( service )
+ {
+ RBuf buffer;
+ CleanupClosePushL( buffer );
+ buffer.CreateL(KIMW_MAX_LENGTH);
+ error = service->GetConnectionParameter(ECCHUnknown,aConnParam,buffer);
+ User::LeaveIfError( error);
+ if( buffer.Length() > 0)
+ {
+ TRACE_SWP(TXT("CServiceWidgetCchHandler::GetConParametersL() buffer valid") );
+ //extract only the user id in case
+ // Check for prefix and remove if found
+ TInt prefixLocation = buffer.Locate( ':' );
+ if ( KErrNotFound != prefixLocation && ECchUsername == aConnParam )
+ {
+ temp = buffer.Mid(prefixLocation+1 ).AllocL(); // ownership transferred
+ }
+ else
+ {
+ temp = buffer.AllocL(); // ownership transferred
+ }
+ }
+ CleanupStack::PopAndDestroy( &buffer );
+ }
+ }
+ TRACE_SWP(TXT("CServiceWidgetCchHandler::GetConParametersL() end") );
+ return temp;
+ }
+
+ // ---------------------------------------------------------------------------
+// CServiceWidgetCchHandler::IsServiceSupported
+// ---------------------------------------------------------------------------
+//
+TBool CServiceWidgetCchHandler::IsServiceSupported(TCCHSubserviceType aSubServiceType )
+ {
+ TRACE_SWP(TXT("CServiceWidgetCchHandler::IsServiceSupported() start") );
+ TBool ret = EFalse;
+ if ( iCchClient )
+ {
+ CCchService* service = iCchClient->GetService( iServiceId );
+ if( service )
+ {
+ service->IsSupported(aSubServiceType, ret );
+ }
+ }
+ TRACE_SWP(TXT("CServiceWidgetCchHandler::IsServiceSupported() end") );
+ return ret;
+ }
+
+ // ---------------------------------------------------------------------------
+// CServiceWidgetCchHandler::IsSubServiceSupported
+// ---------------------------------------------------------------------------
+//
+TBool CServiceWidgetCchHandler::IsSubServiceSupported(TCCHSubserviceType aSubServiceType )
+ {
+ TRACE_SWP(TXT("CServiceWidgetCchHandler::IsSubServiceSupported() start") );
+ TBool ret = EFalse;
+ TInt subServiceCount = iSupportedSubServices.Count();
+ //Find the cumulative of the ServiceStates of all subservices
+ // iterate the service array
+ for ( TInt index = 0; index < subServiceCount ; index++ )
+ {
+ if( iSupportedSubServices[index].iSubServiceType == aSubServiceType )
+ {
+ ret = ETrue;
+ break;
+ }
+ }
+ TRACE_SWP(TXT("CServiceWidgetCchHandler::IsSubServiceSupported() end") );
+ return ret;
+ }
+
+
+// ---------------------------------------------------------------------------
+// CServiceWidgetCchHandler::GetServiceViewIdL
+// ---------------------------------------------------------------------------
+//
+TInt CServiceWidgetCchHandler::GetServiceViewIdL( TInt& aTabUid )
+ {
+ TInt serviceviewId = 0 ;
+ if( iServiceId != KErrNotFound)
+ {
+ CSPSettings* spSettings = CSPSettings::NewL();
+ CleanupStack::PushL(spSettings);
+ //get the tabview id from settings
+ CSPProperty* property = CSPProperty::NewLC();
+ spSettings->FindPropertyL( iServiceId,
+ EPropertyContactViewId,
+ *property );
+ property->GetValue(serviceviewId);
+
+ //get the tab uid from settings
+ spSettings->FindPropertyL( iServiceId,
+ EPropertyContactViewPluginId,
+ *property );
+ property->GetValue(aTabUid);
+
+ CleanupStack::PopAndDestroy( property );
+ CleanupStack::PopAndDestroy( spSettings );
+ }
+ return serviceviewId;
+ }
+
+// ---------------------------------------------------------------------------
+// CServiceWidgetCchHandler::EnableServiceL
+//
+// ---------------------------------------------------------------------------
+//
+TInt CServiceWidgetCchHandler::EnableServiceL( )
+ {
+ TRACE_SWP(TXT("CServiceWidgetCchHandler::EnableServiceL() start") );
+ TInt error = KErrNotFound;
+
+ if( iCchClient )
+ {
+ iCchClient->SetConnectivityDialogsAllowed( ETrue );
+ CCchService* service = iCchClient->GetService( iServiceId );
+ if( service )
+ {
+ error = service->Enable( ECCHUnknown );
+ }
+ }
+ return error;
+ }
+ // end of file
+