--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/convergedconnectionhandler/cchclientapi/src/cchuiapiimpl.cpp Mon Jan 18 20:12:36 2010 +0200
@@ -0,0 +1,1380 @@
+/*
+* Copyright (c) 2008-2009 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: Implementation of class CCchUiApiImpl.
+*
+*/
+
+
+#include "cchuilogger.h"
+#include "cchuiapiimpl.h"
+#include "cchuiobserver.h"
+#include "cchuispshandler.h"
+#include "cchuicchhandler.h"
+#include "cchuinotehandler.h"
+#include "cchuiclientobserver.h"
+#include "cchuiconnectionhandler.h"
+
+const TInt KServiceNameMaxLength = 255;
+
+// ======== MEMBER FUNCTIONS ========
+
+// ---------------------------------------------------------------------------
+// Constructor
+// ---------------------------------------------------------------------------
+//
+CCchUiApiImpl* CCchUiApiImpl::NewL( CCch& aCch )
+ {
+ CCchUiApiImpl* cchUiApiImpl =
+ new ( ELeave ) CCchUiApiImpl();
+ CleanupStack::PushL( cchUiApiImpl );
+ cchUiApiImpl->ConstructL( aCch );
+ CleanupStack::Pop( cchUiApiImpl );
+ return cchUiApiImpl;
+ }
+
+// ---------------------------------------------------------------------------
+// Constructor
+// ---------------------------------------------------------------------------
+//
+CCchUiApiImpl::CCchUiApiImpl():
+ iReEnableService( EFalse ),
+ iRemovableConnection( KErrNone ),
+ iObservedService( 0 )
+ {
+ }
+
+// ---------------------------------------------------------------------------
+// Constructor
+// ---------------------------------------------------------------------------
+//
+void CCchUiApiImpl::ConstructL( CCch& aCch )
+ {
+ iCCHHandler = CCchUiCchHandler::NewL( aCch );
+ iSpsHandler = CCchUiSpsHandler::NewL();
+ iNoteController = CCCHUiNoteHandler::NewL( *this );
+ iConnectionHandler = CCchUiConnectionHandler::NewL(
+ *iCCHHandler, *iSpsHandler );
+ // voip sub service is by default the supported one.
+ // Client can overwrite these
+ iAllowedSubServices.AppendL( ECCHVoIPSub );
+
+ iLastOperationResult =
+ MCchUiObserver::ECchUiClientOperationResultNotSet;
+ }
+
+// ---------------------------------------------------------------------------
+// Destructor
+// ---------------------------------------------------------------------------
+//
+CCchUiApiImpl::~CCchUiApiImpl()
+ {
+ if ( iObservedService && iCCHHandler )
+ {
+ TRAP_IGNORE( iCCHHandler->StopObservingL(
+ iObservedService, *this ) );
+ }
+
+ iAllowedNotes.Close();
+ iAllowedSubServices.Close();
+ iObservervedServices.Close();
+ iObservers.ResetAndDestroy();
+ iObservers.Close();
+ delete iCCHHandler;
+ delete iNoteController;
+ delete iSpsHandler;
+ delete iConnectionHandler;
+ }
+
+// ---------------------------------------------------------------------------
+// AddObserver.
+// ---------------------------------------------------------------------------
+//
+void CCchUiApiImpl::AddObserverL( MCchUiObserver& aObserver )
+ {
+ CCHUIDEBUG( "CCchUiApiImpl::AddObserver - IN");
+
+ // Check if already exists
+ TBool alreadyExists = EFalse;
+ for ( TInt i( 0 ) ; i < iObservers.Count() ; i++ )
+ {
+ if ( &aObserver == &iObservers[ i ]->Observer() )
+ {
+ CCHUIDEBUG( "AddObserver - already exists");
+ alreadyExists = ETrue;
+ }
+ }
+
+ if ( !alreadyExists )
+ {
+ CCHUIDEBUG( "AddObserver - add observer");
+
+ CCchUiClientObserver* capsulatedObs =
+ CCchUiClientObserver::NewLC( aObserver );
+
+ iObservers.AppendL( capsulatedObs );
+ CleanupStack::Pop( capsulatedObs );
+ }
+
+ CCHUIDEBUG( "CCchUiApiImpl::AddObserver - OUT");
+ }
+
+// ---------------------------------------------------------------------------
+// RemoveObserver.
+// ---------------------------------------------------------------------------
+//
+void CCchUiApiImpl::RemoveObserver( MCchUiObserver& aObserver )
+ {
+ for ( TInt i = 0 ; i < iObservers.Count() ; i++ )
+ {
+ if ( &aObserver == &iObservers[ i ]->Observer() )
+ {
+ delete iObservers[ i ];
+ iObservers.Remove( i );
+
+ CCHUIDEBUG( "RemoveObserver - observer removed" );
+ }
+ }
+ iObservers.Compress();
+ }
+
+// ---------------------------------------------------------------------------
+// Show dialog.
+// ---------------------------------------------------------------------------
+//
+void CCchUiApiImpl::ShowDialogL(
+ TUint32 aServiceId,
+ MCchUiObserver::TCchUiDialogType aDialog )
+ {
+ CCHUIDEBUG2( "CCchUiApiImpl::ShowDialogL - aServiceId: %d",
+ aServiceId );
+ CCHUIDEBUG2( "CCchUiApiImpl::ShowDialogL - aDialog: %d",
+ aDialog );
+
+ TInt err( KErrNone );
+
+ // Get current connection iap id
+ TInt iapId( KErrNone );
+ iCCHHandler->GetCurrentConnectionIapIdL(
+ aServiceId, ECCHUnknown, iapId, err );
+
+ // Get current service username
+ RBuf userName;
+ CleanupClosePushL( userName );
+ userName.CreateL( KServiceNameLength );
+ iCCHHandler->GetUsernameL( aServiceId, userName, err );
+
+ if ( KErrNone == err || KErrNotFound == err )
+ {
+ CCHUIDEBUG( "ShowDialogL -Launch note" );
+ iNoteController->LaunchNoteL( aDialog, aServiceId, iapId, userName );
+ }
+ else // leave if error code other that KErrNone or KErrNotFound
+ {
+ CCHUIDEBUG2( "ShowDialogL - leave with err=%d", err );
+ User::Leave( err );
+ }
+
+ CleanupStack::PopAndDestroy( &userName );
+ }
+
+// ---------------------------------------------------------------------------
+// Get currently showing dialog.
+// ---------------------------------------------------------------------------
+//
+void CCchUiApiImpl::ConfigureVisualizationL(
+ RArray<MCchUiObserver::TCchUiDialogType>& aAllowedNotes,
+ RArray<TCCHSubserviceType>& aAllowedSubServices )
+ {
+ CCHUIDEBUG( "CCchUiApiImpl::ConfigureVisualizationL - IN" );
+
+ CCHUIDEBUG2( "ConfigureVisualizationL - aAllowedNotes count=%d",
+ aAllowedNotes.Count() );
+ CCHUIDEBUG2( "ConfigureVisualizationL - aAllowedSubServices count=%d",
+ aAllowedSubServices.Count() );
+
+ TBool subServicesHandled = EFalse;
+ TBool dialogsHandled = EFalse;
+
+ // Reset old data
+ iAllowedNotes.Reset();
+ iAllowedSubServices.Reset();
+
+ if ( KErrNotFound != aAllowedNotes.Find(
+ MCchUiObserver::ECchUiDialogTypeNotSet ) )
+ {
+ CCHUIDEBUG( "ConfigureVisualizationL - all dialogs are supported" );
+ dialogsHandled = ETrue;
+ }
+
+ for ( TInt noteIndex = 0 ;
+ noteIndex < aAllowedNotes.Count() && !dialogsHandled ;
+ noteIndex++ )
+ {
+ CCHUIDEBUG2( "ConfigureVisualizationL - appending allowed note: %d",
+ aAllowedNotes[ noteIndex ] );
+ iAllowedNotes.AppendL( aAllowedNotes[ noteIndex ] );
+ }
+
+ if ( KErrNotFound != aAllowedSubServices.Find( ECCHUnknown ) )
+ {
+ CCHUIDEBUG(
+ "ConfigureVisualizationL - all sub services are supported" );
+ iAllowedSubServices.AppendL( ECCHUnknown );
+ subServicesHandled = ETrue;
+ }
+ for ( TInt servIndex = 0 ;
+ servIndex < aAllowedSubServices.Count() && subServicesHandled ;
+ servIndex++ )
+ {
+ CCHUIDEBUG2(
+ "ConfigureVisualizationL - appending allowed sub service: %d",
+ aAllowedSubServices[ servIndex ] );
+ iAllowedSubServices.AppendL( aAllowedSubServices[ servIndex ] );
+ }
+
+ CCHUIDEBUG( "CCchUiApiImpl::ConfigureVisualizationL - OUT" );
+ }
+
+// ---------------------------------------------------------------------------
+// Cancel notes/dialogs.
+// ---------------------------------------------------------------------------
+//
+void CCchUiApiImpl::CancelNotes()
+ {
+ CCHUIDEBUG( "CCchUiApiImpl::CancelNotes" );
+ iNoteController->CancelOldNotes();
+ }
+
+// ---------------------------------------------------------------------------
+// Manual enable has proceeded
+// ---------------------------------------------------------------------------
+//
+void CCchUiApiImpl::ManualEnableResultL(
+ TUint aServiceId,
+ TInt aEnableResult )
+ {
+ CCHUIDEBUG( "CCchUiApiImpl::ManualEnableResultL - IN" );
+
+ if ( KErrNone == aEnableResult )
+ {
+ CCHUIDEBUG( "ManualEnableStartedL - start observing service" );
+ iCCHHandler->StartObservingL( aServiceId, *this );
+
+ iObservedService = aServiceId;
+
+ // Check if id already exists in observed services
+ TInt err = iObservervedServices.Find( aServiceId );
+
+ // Append id only if it is not found.
+ if ( KErrNotFound == err )
+ {
+ CCHUIDEBUG( "ManualEnableStartedL - add to observerd services" );
+ iObservervedServices.AppendL( aServiceId );
+ }
+ }
+ else
+ {
+ HandleManualEnableErrorL( aServiceId, aEnableResult );
+ }
+
+ CCHUIDEBUG( "CCchUiApiImpl::ManualEnableStartedL - OUT" );
+ }
+
+// ---------------------------------------------------------------------------
+// Manual enable error handling.
+// ---------------------------------------------------------------------------
+//
+void CCchUiApiImpl::HandleManualEnableErrorL(
+ TUint aServiceId,
+ TInt aEnableResult )
+ {
+ CCHUIDEBUG( "CCchUiApiImpl::HandleManualEnableErrorL - IN" );
+ CCHUIDEBUG2( " ---> aEnableResult: %d", aEnableResult );
+
+ MCchUiObserver::TCchUiDialogType dialogType =
+ MCchUiObserver::ECchUiDialogTypeNotSet;
+
+ switch ( aEnableResult )
+ {
+ case KCCHErrorAccessPointNotDefined:
+ {
+ dialogType = MCchUiObserver::ECchUiDialogTypeNoConnectionDefined;
+ }
+ break;
+ case KCCHErrorAuthenticationFailed:
+ {
+ dialogType = MCchUiObserver::ECchUiDialogTypeAuthenticationFailed;
+ }
+ break;
+ case KCCHErrorInvalidSettings:
+ {
+ dialogType = MCchUiObserver::ECchUiDialogTypeDefectiveSettings;
+ }
+ break;
+
+ case KCCHErrorBandwidthInsufficient:
+ {
+ dialogType = MCchUiObserver::ECchUiDialogTypeErrorInConnection;
+ }
+ break;
+ case KCCHErrorInvalidIap:
+ case KCCHErrorNetworkLost:
+ case KCCHErrorServiceNotResponding:
+ {
+ dialogType = MCchUiObserver::ECchUiDialogTypeNoConnectionAvailable;
+ }
+ break;
+ default:
+ break;
+ }
+
+ // show dialog if dialog type set and dialog allowed
+ if ( ( MCchUiObserver::ECchUiDialogTypeNotSet != dialogType ) &&
+ ( DialogIsAllowed( dialogType ) ) )
+ {
+ ShowDialogL( aServiceId, dialogType );
+ }
+
+ CCHUIDEBUG( "CCchUiApiImpl::HandleManualEnableErrorL - OUT" );
+ }
+
+// ---------------------------------------------------------------------------
+// Handle dialog completed situation.
+// ---------------------------------------------------------------------------
+//
+void CCchUiApiImpl::DialogCompletedL(
+ TInt aCompleteCode,
+ TCCHUiNotifierParams aResultParams )
+ {
+ CCHUIDEBUG( "CCchUiApiImpl::DialogCompletedL - IN");
+ CCHUIDEBUG2( "DialogCompletedL - complete code=%d", aCompleteCode );
+ CCHUIDEBUG2( "DialogCompletedL - dialog mode=%d",
+ aResultParams.iDialogMode );
+
+ switch ( aResultParams.iDialogMode )
+ {
+ case MCchUiObserver::ECchUiDialogTypeUsernamePasswordFailed:
+ {
+ // Show username/password query.
+ __ASSERT_ALWAYS( DialogIsAllowed(
+ MCchUiObserver::ECchUiDialogTypeAuthenticationFailed ),
+ User::Leave( KErrNotSupported ) );
+
+ CancelNotes();
+ ShowDialogL(
+ aResultParams.iServiceId,
+ MCchUiObserver::ECchUiDialogTypeAuthenticationFailed );
+ }
+ break;
+ case MCchUiObserver::ECchUiDialogTypeAuthenticationFailed:
+ {
+ DoHandleAuthenticationFailedCompleteL(
+ aCompleteCode, aResultParams );
+ }
+ break;
+ case MCchUiObserver::ECchUiDialogTypeNoConnectionAvailable:
+ case MCchUiObserver::ECchUiDialogTypeNoConnectionDefined:
+ {
+ DoHandleNoConnectionsCompleteL(
+ aCompleteCode, aResultParams );
+ }
+ break;
+
+ case MCchUiObserver::ECchUiDialogTypeDefectiveSettings:
+ {
+ // Defective settings is permanent type of condition.
+ iCCHHandler->DisableL( aResultParams.iServiceId );
+ iLastOperationResult =
+ MCchUiObserver::ECchUiClientOperationResultGeneralFailure;
+ }
+ break;
+ case MCchUiObserver::ECchUiDialogTypeErrorInConnection:
+ {
+ // Show confirm change connection query
+ __ASSERT_ALWAYS( DialogIsAllowed(
+ MCchUiObserver::ECchUiDialogTypeConfirmChangeConnection ),
+ User::Leave( KErrNotSupported ) );
+
+ CancelNotes();
+ ShowDialogL(
+ aResultParams.iServiceId,
+ MCchUiObserver::ECchUiDialogTypeConfirmChangeConnection );
+ }
+ break;
+ case MCchUiObserver::ECchUiDialogTypeConfirmChangeConnection:
+ {
+ DoHandleConfirmChangeConnectionCompleteL(
+ aCompleteCode, aResultParams );
+ }
+ break;
+ case MCchUiObserver::ECchUiDialogTypeChangeConnection:
+ {
+ DoHandleChangeConnectionCompleteL(
+ aCompleteCode, aResultParams );
+ }
+ break;
+ default:
+ CCHUIDEBUG( "DialogCompletedL - default switch case" );
+ break;
+ }
+
+ CCHUIDEBUG( "CCchUiApiImpl::DialogCompletedL - OUT" );
+ }
+
+// ---------------------------------------------------------------------------
+// Checks if specific note is allowed
+// ---------------------------------------------------------------------------
+//
+TBool CCchUiApiImpl::DialogIsAllowed(
+ MCchUiObserver::TCchUiDialogType aDialog )
+ {
+ CCHUIDEBUG( "CCchUiApiImpl::DialogIsAllowed");
+ CCHUIDEBUG2( "CCchUiApiImpl::DialogIsAllowed - allowed notes count=%d",
+ iAllowedNotes.Count() );
+ CCHUIDEBUG2( "CCchUiApiImpl::DialogIsAllowed - aDialog find result=%d",
+ iAllowedNotes.Find( aDialog ) );
+
+ TBool ret = EFalse;
+ if ( !iAllowedNotes.Count() ) return ETrue; // not configured, all allowed
+ else if ( KErrNotFound != iAllowedNotes.Find(
+ MCchUiObserver::ECchUiDialogTypeNotSet ) ) return ETrue;
+ else if ( KErrNotFound != iAllowedNotes.Find( aDialog ) ) return ETrue;
+
+ CCHUIDEBUG2( "DialogIsAllowed - return: %d", ret );
+ return ret;
+ }
+
+// ---------------------------------------------------------------------------
+// Checks if specific sub service is allowed
+// ---------------------------------------------------------------------------
+//
+TBool CCchUiApiImpl::SubServiceIsAllowed( TCCHSubserviceType aSubService )
+ {
+ CCHUIDEBUG( "CCchUiApiImpl::SubServiceIsAllowed");
+
+ CCHUIDEBUG2( "SubServiceIsAllowed - allowed subserv=%d",
+ iAllowedSubServices.Count() );
+ CCHUIDEBUG2( "SubServiceIsAllowed - aSubService find=%d",
+ iAllowedSubServices.Find( aSubService ) );
+ CCHUIDEBUG2( "SubServiceIsAllowed - all supported=%d",
+ iAllowedSubServices.Find( ECCHUnknown ) );
+
+ // If subservice type is ECCHUnknown -> subservice is allowed, other
+ // types are checked from array.
+ TBool allowed = EFalse;
+ TInt result = iAllowedSubServices.Find( aSubService );
+
+ if ( ECCHUnknown == aSubService )
+ {
+ allowed = ETrue;
+ }
+ else if ( KErrNotFound != result )
+ {
+ allowed = ETrue;
+ }
+ else
+ {
+ allowed = EFalse;
+ }
+
+ CCHUIDEBUG2( "SubServiceIsAllowed - return: %d", allowed );
+ return allowed;
+ }
+
+// ---------------------------------------------------------------------------
+// Checks subservice state is allowed for showing dialogs.
+// ---------------------------------------------------------------------------
+//
+TBool CCchUiApiImpl::StateIsAllowed( const TCCHSubserviceState aState )
+ {
+ CCHUIDEBUG( "CCchUiApiImpl::StateIsAllowed");
+
+ TBool allowed( EFalse );
+
+ switch ( aState )
+ {
+ case ECCHUninitialized:
+ case ECCHDisabled:
+ case ECCHDisconnecting:
+ {
+ CCHUIDEBUG( "CCchUiApiImpl::StateIsAllowed: Not allowed");
+ }
+ break;
+ case ECCHConnecting:
+ case ECCHEnabled:
+ {
+ CCHUIDEBUG( "CCchUiApiImpl::StateIsAllowed: Allowed");
+ allowed = ETrue;
+ }
+ break;
+ default:
+ CCHUIDEBUG( "CCchUiApiImpl::StateIsAllowed: DEFAULT case");
+ break;
+ }
+
+ return allowed;
+ }
+
+// ---------------------------------------------------------------------------
+// Handles re-enabling of service.
+// ---------------------------------------------------------------------------
+//
+void CCchUiApiImpl::HandleServiceReEnablingL( TUint aServiceId )
+ {
+ if ( iRemovableConnection )
+ {
+ CCHUIDEBUG(
+ "DoHandleServiceEventL - removing old connection" );
+
+ RBuf serviceName;
+ CleanupClosePushL( serviceName );
+ serviceName.CreateL( KServiceNameMaxLength );
+
+ iSpsHandler->ServiceNameL(
+ aServiceId,
+ serviceName );
+
+ // Remove old connection
+ iConnectionHandler->RemoveConnectionL(
+ serviceName, iRemovableConnection );
+
+ CleanupStack::PopAndDestroy( &serviceName );
+ }
+
+ CCHUIDEBUG( "HandleServiceReEnablingL - Re-Enabling service" );
+
+ iReEnableService = EFalse;
+ iCCHHandler->EnableL( aServiceId );
+ }
+
+// ---------------------------------------------------------------------------
+// Handle authentication failed completed situation.
+// ---------------------------------------------------------------------------
+//
+void CCchUiApiImpl::DoHandleAuthenticationFailedCompleteL(
+ TInt aCompleteCode,
+ TCCHUiNotifierParams aResultParams )
+ {
+ CCHUIDEBUG( "CCchUiApiImpl::DoHandleAuthenticationFailedCompleteL - IN");
+
+ switch ( aCompleteCode )
+ {
+ case KErrNone:
+ {
+ TInt err( KErrNone );
+
+ // Set username
+ iCCHHandler->SetUsernameL( aResultParams, err );
+
+ // If no error set also password
+ if ( !err )
+ {
+ iCCHHandler->SetPasswordL( aResultParams, err );
+ }
+ else
+ {
+ iLastOperationResult =
+ MCchUiObserver::ECchUiClientOperationResultGeneralFailure;
+ }
+
+ // Both username and password set succesfully.
+ if ( !err )
+ {
+ iLastOperationResult =
+ MCchUiObserver::ECchUiClientOperationResultCredentialsChanged;
+ }
+ else
+ {
+ iLastOperationResult =
+ MCchUiObserver::ECchUiClientOperationResultGeneralFailure;
+ }
+
+ aCompleteCode = err;
+ break;
+ }
+ case KErrAlreadyExists:
+ {
+ // dialog active, do nothing
+ break;
+ }
+ case KErrCancel:
+ {
+ iLastOperationResult =
+ MCchUiObserver::ECchUiClientOperationResultUserCancelled;
+ break;
+ }
+ default:
+ {
+ CCHUIDEBUG(
+ "DoHandleAuthenticationFailedCompleteL - switch default case");
+ iLastOperationResult =
+ MCchUiObserver::ECchUiClientOperationResultGeneralFailure;
+ break;
+ }
+ }
+
+ switch ( iLastOperationResult )
+ {
+ case MCchUiObserver::ECchUiClientOperationResultCredentialsChanged:
+ {
+ iCCHHandler->EnableL( aResultParams.iServiceId );
+ break;
+ }
+ default:
+ {
+ iCCHHandler->DisableL( aResultParams.iServiceId );
+ break;
+ }
+ }
+
+ CCHUIDEBUG( "CCchUiApiImpl::DoHandleAuthenticationFailedCompleteL - OUT");
+ }
+
+
+// ---------------------------------------------------------------------------
+// Handle no connections complete situation.
+// ---------------------------------------------------------------------------
+//
+void CCchUiApiImpl::DoHandleNoConnectionsCompleteL(
+ TInt aCompleteCode,
+ TCCHUiNotifierParams aResultParams )
+ {
+ CCHUIDEBUG( "CCchUiApiImpl::DoHandleNoConnectionsCompleteL - IN");
+
+ if ( KErrNone == aCompleteCode )
+ {
+ switch( aResultParams.iOperationCommand )
+ {
+ case ECchUiCommandSearchWlan:
+ {
+ HandleSearchWlanCompleteL(
+ aCompleteCode, aResultParams );
+ break;
+ }
+ case ECchUiCommandCopyGprs:
+ {
+ HandleCopyGprsCompleteL(
+ aCompleteCode, aResultParams );
+ break;
+ }
+ case ECchUiCommandGprsNotFound:
+ {
+ CCHUIDEBUG( " -> GPRS was not found");
+ iLastOperationResult =
+ MCchUiObserver::ECchUiClientOperationResultGeneralFailure;
+ break;
+ }
+ case ECchUiCommandEnableCancelled:
+ {
+ iLastOperationResult =
+ MCchUiObserver::ECchUiClientOperationResultUserCancelled;
+ break;
+ }
+ case ECchUiCommandConnectWhenAvailable:
+ {
+ iLastOperationResult =
+ MCchUiObserver::ECchUiClientOperationResultNotSet;
+ break;
+ }
+ default:
+ {
+ CCHUIDEBUG( " -> !DEFAULT!");
+ iLastOperationResult =
+ MCchUiObserver::ECchUiClientOperationResultGeneralFailure;
+ }
+ break;
+ }
+ }
+ else if ( KErrAlreadyExists == aCompleteCode )
+ {
+ // dialog active, do nothing
+ }
+ else if ( KErrCancel == aCompleteCode )
+ {
+ iLastOperationResult =
+ MCchUiObserver::ECchUiClientOperationResultUserCancelled;
+ }
+ else
+ {
+ iLastOperationResult =
+ MCchUiObserver::ECchUiClientOperationResultGeneralFailure;
+ }
+
+ switch ( iLastOperationResult )
+ {
+ case MCchUiObserver::ECchUiClientOperationResultAccessPointAdded:
+ {
+ // New access point was added --> enable service
+ iCCHHandler->EnableL( aResultParams.iServiceId );
+ break;
+ }
+ case MCchUiObserver::ECchUiClientOperationResultNotSet:
+ {
+ // If no operation result set, do nothing
+ break;
+ }
+ // By default disable service
+ default:
+ {
+ CCHUIDEBUG( " -> !DEFAULT!");
+ CCHUIDEBUG( " -> Disabling service");
+ iCCHHandler->DisableL( aResultParams.iServiceId );
+ break;
+ }
+ }
+
+ CCHUIDEBUG( "CCchUiApiImpl::DoHandleNoConnectionsCompleteL - OUT");
+ }
+
+// ---------------------------------------------------------------------------
+// Handle change connection confirmation note complete situation.
+// ---------------------------------------------------------------------------
+//
+void CCchUiApiImpl::DoHandleConfirmChangeConnectionCompleteL(
+ TInt aCompleteCode,
+ TCCHUiNotifierParams aResultParams )
+ {
+ CCHUIDEBUG(
+ "CCchUiApiImpl::DoHandleConfirmChangeConnectionCompleteL - IN");
+
+ switch( aCompleteCode )
+ {
+ case KErrNone:
+ {
+ // show change connection query
+ __ASSERT_ALWAYS( DialogIsAllowed(
+ MCchUiObserver::ECchUiDialogTypeChangeConnection ),
+ User::Leave( KErrNotSupported ) );
+
+ // Set removable connection which is removed when connection
+ // is changed successfully
+ if ( aResultParams.iRemoveOldConnection )
+ {
+ iRemovableConnection = aResultParams.iCurrentConnectionIapId;
+ }
+
+ CancelNotes();
+ ShowDialogL(
+ aResultParams.iServiceId,
+ MCchUiObserver::ECchUiDialogTypeChangeConnection );
+ break;
+ }
+ case KErrCancel:
+ {
+ iLastOperationResult =
+ MCchUiObserver::ECchUiClientOperationResultUserCancelled;
+ break;
+ }
+ default:
+ {
+ CCHUIDEBUG(
+ "DoHandleConfirmChangeConnectionCompleteL - default switch case");
+
+ iLastOperationResult =
+ MCchUiObserver::ECchUiClientOperationResultGeneralFailure;
+ break;
+ }
+ }
+
+ CCHUIDEBUG(
+ "CCchUiApiImpl::DoHandleConfirmChangeConnectionCompleteL - OUT");
+ }
+
+// ---------------------------------------------------------------------------
+// Handle change connection query complete situation.
+// ---------------------------------------------------------------------------
+//
+void CCchUiApiImpl::DoHandleChangeConnectionCompleteL(
+ TInt aCompleteCode,
+ TCCHUiNotifierParams aResultParams )
+ {
+ CCHUIDEBUG( "CCchUiApiImpl::DoHandleChangeConnectionCompleteL - IN");
+
+ switch( aCompleteCode )
+ {
+ case KErrNone:
+ {
+ HandleChangeConnectionL(
+ aCompleteCode, aResultParams );
+ break;
+ }
+ case KErrCancel:
+ {
+ iLastOperationResult =
+ MCchUiObserver::ECchUiClientOperationResultUserCancelled;
+ break;
+ }
+ default:
+ {
+ CCHUIDEBUG(
+ "DoHandleChangeConnectionCompleteL - default switch case");
+
+ iLastOperationResult =
+ MCchUiObserver::ECchUiClientOperationResultGeneralFailure;
+
+ break;
+ }
+ }
+
+ CCHUIDEBUG( "CCchUiApiImpl::DoHandleChangeConnectionCompleteL - OUT");
+ }
+
+// ---------------------------------------------------------------------------
+// Handles search wlan dialog result.
+// ---------------------------------------------------------------------------
+//
+void CCchUiApiImpl::HandleSearchWlanCompleteL(
+ TInt& aCompleteCode,
+ TCCHUiNotifierParams& aResultParams )
+ {
+ CCHUIDEBUG( "CCchUiApiImpl::HandleSearchWlanCompleteL - IN");
+
+ CCHUIDEBUG( "HandleSearchWlanCompleteL - begin wlan search");
+
+ TInt err( KErrNone );
+ TInt snapId( KErrNone );
+
+ iCCHHandler->GetConnectionSnapIdL(
+ aResultParams.iServiceId, snapId, err );
+
+ if ( !err )
+ {
+ CCHUIDEBUG2(
+ "HandleSearchWlanCompleteL - service snap is: %d", snapId );
+
+ HBufC* serviceName = HBufC::NewLC( KServiceNameMaxLength );
+ TPtr serviceNamePtr( serviceName->Des() );
+
+ CCHUIDEBUG( "HandleSearchWlanCompleteL - get service name");
+
+ iSpsHandler->ServiceNameL(
+ aResultParams.iServiceId, serviceNamePtr );
+
+ CCHUIDEBUG( "HandleSearchWlanCompleteL - proceed to wlan search");
+
+ TRAP( err, iConnectionHandler->SearchAccessPointsL(
+ aResultParams.iServiceId,
+ snapId,
+ serviceNamePtr ) );
+
+ CCHUIDEBUG2( "HandleSearchWlanCompleteL - wlan search err: %d", err );
+
+ CleanupStack::PopAndDestroy( serviceName );
+
+ HandleSearchAccessPointsErrorL(
+ err, aCompleteCode, aResultParams );
+ }
+
+ CCHUIDEBUG( "CCchUiApiImpl::HandleSearchWlanCompleteL - OUT");
+ }
+
+// ---------------------------------------------------------------------------
+// Handles search access points error code.
+// ---------------------------------------------------------------------------
+//
+void CCchUiApiImpl::HandleSearchAccessPointsErrorL(
+ TInt aErr,
+ TInt& aCompleteCode,
+ TCCHUiNotifierParams& /*aResultParams*/ )
+ {
+ CCHUIDEBUG( "CCchUiApiImpl::HandleSearchAccessPointsErrorL - IN" );
+
+ switch ( aErr )
+ {
+ case KErrNone:
+ {
+ CCHUIDEBUG(
+ "HandleSearchAccessPointsErrorL - access point added" );
+ iLastOperationResult =
+ MCchUiObserver::ECchUiClientOperationResultAccessPointAdded;
+ break;
+ }
+ case KErrCancel: // user cancel
+ {
+ CCHUIDEBUG( "HandleSearchAccessPointsErrorL - error, cancelled");
+ iLastOperationResult =
+ MCchUiObserver::ECchUiClientOperationResultUserCancelled;
+ break;
+ }
+ default: // other errors
+ {
+ CCHUIDEBUG(
+ "HandleSearchAccessPointsErrorL - error, set general failure");
+
+ aCompleteCode = aErr;
+ iLastOperationResult =
+ MCchUiObserver::ECchUiClientOperationResultGeneralFailure;
+ }
+ }
+
+ CCHUIDEBUG( "CCchUiApiImpl::HandleSearchAccessPointsErrorL - OUT" );
+ }
+
+// ---------------------------------------------------------------------------
+// Handles search wlan dialog result when use gprs selected.
+// ---------------------------------------------------------------------------
+//
+void CCchUiApiImpl::HandleCopyGprsCompleteL(
+ TInt& /*aCompleteCode*/,
+ TCCHUiNotifierParams& aResultParams )
+ {
+ CCHUIDEBUG( "CCchUiApiImpl::HandleCopyGprsCompleteL - IN" );
+
+ // User selected gprs access point which will now be stored in
+ // service snap
+ TInt snapId( KErrNone );
+
+ HBufC* serviceName = HBufC::NewLC( KServiceNameMaxLength );
+ TPtr serviceNamePtr( serviceName->Des() );
+
+ iSpsHandler->ServiceNameL(
+ aResultParams.iServiceId,
+ serviceNamePtr );
+
+ TInt err( KErrNone );
+ iCCHHandler->GetConnectionSnapIdL(
+ aResultParams.iServiceId,
+ snapId,
+ err );
+
+ if ( !err )
+ {
+ CCHUIDEBUG2(
+ "HandleCopyGprsCompleteL - proceed, target snap is: %d", snapId );
+ CCHUIDEBUG2(
+ "HandleCopyGprsCompleteL - proceed, service id is: %d",
+ aResultParams.iServiceId );
+ CCHUIDEBUG2( "HandleCopyGprsCompleteL - gprs iap id is: %d",
+ aResultParams.iGprsIapId );
+
+ iConnectionHandler->CopyIapToServiceSnapL(
+ aResultParams.iServiceId, serviceNamePtr,
+ aResultParams.iGprsIapId, snapId );
+
+ CCHUIDEBUG( "HandleCopyGprsCompleteL - copy gprs iap done ok");
+
+ CleanupStack::PopAndDestroy( serviceName );
+
+ iLastOperationResult =
+ MCchUiObserver::ECchUiClientOperationResultAccessPointAdded;
+
+ CCHUIDEBUG( " -> copy gprs iap done ok, enable");
+ iCCHHandler->EnableL( aResultParams.iServiceId );
+ }
+ else
+ {
+ iLastOperationResult =
+ MCchUiObserver::ECchUiClientOperationResultGeneralFailure;
+ User::Leave( err );
+ }
+
+ CCHUIDEBUG( "CCchUiApiImpl::HandleCopyGprsCompleteL - OUT" );
+ }
+
+// ---------------------------------------------------------------------------
+// Handles changing to new connection.
+// ---------------------------------------------------------------------------
+//
+void CCchUiApiImpl::HandleChangeConnectionL(
+ TInt& aCompleteCode,
+ TCCHUiNotifierParams& aResultParams )
+ {
+ CCHUIDEBUG( "CCchUiApiImpl::HandleChangeConnectionL - IN" );
+
+ switch ( aResultParams.iOperationCommand )
+ {
+ case ECchUiCommandSearchWlan:
+ {
+ CCHUIDEBUG( "HandleChangeConnectionL - search wlan");
+ HandleSearchWlanCompleteL(
+ aCompleteCode, aResultParams );
+ break;
+ }
+ case ECchUiCommandCopyGprs:
+ {
+ CCHUIDEBUG( "HandleChangeConnectionL - copy gprs");
+ HandleCopyGprsCompleteL(
+ aCompleteCode, aResultParams );
+ break;
+ }
+ default:
+ {
+ CCHUIDEBUG( "HandleChangeConnectionL - default switch case");
+ iLastOperationResult =
+ MCchUiObserver::ECchUiClientOperationResultGeneralFailure;
+ break;
+ }
+ }
+
+ switch ( iLastOperationResult )
+ {
+ case MCchUiObserver::ECchUiClientOperationResultAccessPointAdded:
+ {
+ iLastOperationResult =
+ MCchUiObserver::ECchUiClientOperationResultConnectionChanged;
+
+ CCHUIDEBUG( "HandleChangeConnectionL - re-enable service");
+
+ // Disable service and set iReEnable flag so that after service
+ // has disconnected we can connect with new access point.
+ iCCHHandler->StartObservingL( aResultParams.iServiceId, *this );
+
+ iReEnableService = ETrue;
+
+ iObservedService = aResultParams.iServiceId;
+
+ InformObserversL( aResultParams.iServiceId );
+ iCCHHandler->DisableL( aResultParams.iServiceId );
+
+ // Check if id already exists in observed services
+ TInt error = iObservervedServices.Find(
+ aResultParams.iServiceId );
+
+ // Append id only if it is not found.
+ if ( KErrNotFound == error )
+ {
+ CCHUIDEBUG(
+ "HandleChangeConnectionL add to observerd services" );
+ iObservervedServices.AppendL( aResultParams.iServiceId );
+ }
+ break;
+ }
+ default:
+ break;
+ }
+
+ CCHUIDEBUG( "CCchUiApiImpl::HandleChangeConnectionL - OUT" );
+ }
+
+// ---------------------------------------------------------------------------
+// Observer implementation for service events.
+// ---------------------------------------------------------------------------
+//
+void CCchUiApiImpl::ServiceStatusChanged(
+ TInt aServiceId,
+ TCCHSubserviceType aType,
+ const TCchServiceStatus& aServiceStatus )
+ {
+ CCHUIDEBUG( "CCchUiApiImpl::ServiceStatusChanged - IN");
+
+ CCHUIDEBUG2( "ServiceStatusChanged - aServiceId: %d",
+ aServiceId );
+ CCHUIDEBUG2( "ServiceStatusChanged - aError: %d",
+ aServiceStatus.Error() );
+ CCHUIDEBUG2( "ServiceStatusChanged - aState: %d",
+ aServiceStatus.State() );
+ CCHUIDEBUG2( "ServiceStatusChanged - aType: %d",
+ aType );
+
+ TInt observedPos = iObservervedServices.Find( aServiceId );
+
+ CCHUIDEBUG2( " -> observed position: %d", observedPos );
+
+ if ( KErrNotFound != observedPos )
+ {
+ switch ( aServiceStatus.Error() )
+ {
+ case KErrNone:
+ {
+ TRAP_IGNORE( DoHandleServiceEventL(
+ aServiceId, aType, aServiceStatus ) );
+ break;
+ }
+ default: // all error codes but KErrNone
+ {
+ TRAP_IGNORE( DoHandleServiceErrorL(
+ aServiceId, aType, aServiceStatus ) );
+ break;
+ }
+ }
+ }
+
+ CCHUIDEBUG( "CCchUiApiImpl::ServiceStatusChanged - OUT");
+ }
+
+// ---------------------------------------------------------------------------
+// Observer implementation for service events.
+// ---------------------------------------------------------------------------
+//
+void CCchUiApiImpl::DoHandleServiceErrorL(
+ TInt aServiceId,
+ TCCHSubserviceType aType,
+ const TCchServiceStatus& aServiceStatus )
+ {
+ CCHUIDEBUG( "CCchUiApiImpl::DoHandleServiceErrorL - IN");
+
+ CCHUIDEBUG2( "DoHandleServiceErrorL - aServiceId: %d",
+ aServiceId );
+ CCHUIDEBUG2( "DoHandleServiceErrorL - aError: %d",
+ aServiceStatus.Error() );
+ CCHUIDEBUG2( "DoHandleServiceErrorL - aState: %d",
+ aServiceStatus.State() );
+
+ // Check that sub service is allowed
+ __ASSERT_ALWAYS( SubServiceIsAllowed( aType ),
+ User::Leave( KErrNotSupported ) );
+
+ // Double-check subservice state
+ TInt err( KErrNone );
+ TCCHSubserviceState state = iCCHHandler->GetServiceStateL(
+ aServiceId, aType, err );
+
+ if ( err )
+ {
+ User::Leave( err );
+ }
+
+ // Check that dialog showing is allowed.
+ __ASSERT_ALWAYS( StateIsAllowed( state ) ||
+ KCCHErrorInvalidSettings == aServiceStatus.Error(),
+ User::Leave( KErrNotSupported ) );
+
+ switch ( aServiceStatus.Error() )
+ {
+ case KCCHErrorAuthenticationFailed:
+ {
+ __ASSERT_ALWAYS( DialogIsAllowed(
+ MCchUiObserver::ECchUiDialogTypeUsernamePasswordFailed ),
+ User::Leave( KErrNotSupported ) );
+
+ ShowDialogL(
+ aServiceId,
+ MCchUiObserver::ECchUiDialogTypeUsernamePasswordFailed );
+ }
+ break;
+
+ case KCCHErrorInvalidSettings:
+ {
+ __ASSERT_ALWAYS( DialogIsAllowed(
+ MCchUiObserver::ECchUiDialogTypeDefectiveSettings ),
+ User::Leave( KErrNotSupported ) );
+
+ ShowDialogL(
+ aServiceId,
+ MCchUiObserver::ECchUiDialogTypeDefectiveSettings );
+ }
+ break;
+
+ case KCCHErrorInvalidIap:
+ case KCCHErrorNetworkLost:
+ case KCCHErrorServiceNotResponding:
+ {
+ __ASSERT_ALWAYS( DialogIsAllowed(
+ MCchUiObserver::ECchUiDialogTypeNoConnectionAvailable ),
+ User::Leave( KErrNotSupported ) );
+
+ ShowDialogL(
+ aServiceId,
+ MCchUiObserver::ECchUiDialogTypeNoConnectionAvailable );
+ }
+ break;
+
+ case KCCHErrorAccessPointNotDefined:
+ {
+ __ASSERT_ALWAYS( DialogIsAllowed(
+ MCchUiObserver::ECchUiDialogTypeNoConnectionDefined ),
+ User::Leave( KErrNotSupported ) );
+
+ ShowDialogL(
+ aServiceId,
+ MCchUiObserver::ECchUiDialogTypeNoConnectionDefined );
+ }
+ break;
+ case KCCHErrorBandwidthInsufficient:
+ {
+ __ASSERT_ALWAYS( DialogIsAllowed(
+ MCchUiObserver::ECchUiDialogTypeErrorInConnection ),
+ User::Leave( KErrNotSupported ) );
+
+ ShowDialogL(
+ aServiceId,
+ MCchUiObserver::ECchUiDialogTypeErrorInConnection );
+ }
+ break;
+
+ case KErrCancel:
+ {
+ CCHUIDEBUG( "CCchUiApiImpl::DoHandleServiceErrorL - cancelled");
+ CancelNotes();
+ }
+ break;
+
+ default:
+ break;
+ }
+
+ CCHUIDEBUG( "CCchUiApiImpl::DoHandleServiceErrorL - OUT");
+ }
+
+// ---------------------------------------------------------------------------
+// Observer implementation for service events.
+// ---------------------------------------------------------------------------
+//
+void CCchUiApiImpl::DoHandleServiceEventL(
+ TInt aServiceId,
+ TCCHSubserviceType aType,
+ const TCchServiceStatus& aServiceStatus )
+ {
+ CCHUIDEBUG( "CCchUiApiImpl::DoHandleServiceEventL - IN" );
+
+ CCHUIDEBUG2( "DoHandleServiceEventL - aServiceId: %d",
+ aServiceId );
+ CCHUIDEBUG2( "DoHandleServiceEventL - aError: %d",
+ aServiceStatus.Error() );
+ CCHUIDEBUG2( "DoHandleServiceEventL - aState: %d",
+ aServiceStatus.State() );
+ CCHUIDEBUG2( "DoHandleServiceEventL - aType: %d",
+ aType );
+
+ // Check that sub service is allowed
+ __ASSERT_ALWAYS( SubServiceIsAllowed( aType ),
+ User::Leave( KErrNotSupported ) );
+
+ switch ( aServiceStatus.State() )
+ {
+ case ECCHDisabled:
+ {
+ CCHUIDEBUG( "DoHandleServiceEventL - disabled event" );
+
+ // Check if all subservices are disabled
+ TBool allSubserviceDisabled =
+ iCCHHandler->AllSubservicesInStateL( aServiceId, ECCHDisabled );
+
+ CCHUIDEBUG2( "DoHandleServiceEventL - all disabled=%d",
+ allSubserviceDisabled );
+
+ // If all subservices are disabled stop observing service events.
+ if ( allSubserviceDisabled )
+ {
+ TInt observedPos = iObservervedServices.Find( aServiceId );
+
+ if ( KErrNotFound != observedPos )
+ {
+ CCHUIDEBUG(
+ "DoHandleServiceEventL - removed observed service" );
+ iObservervedServices.Remove( observedPos );
+ }
+
+ CCHUIDEBUG( "DoHandleServiceEventL - stop observing" );
+ iCCHHandler->StopObservingL( aServiceId, *this );
+ iObservedService = 0;
+ }
+
+ if ( iReEnableService )
+ {
+ if ( allSubserviceDisabled )
+ {
+ CCHUIDEBUG( "DoHandleServiceEventL - Re-Enable service" );
+ HandleServiceReEnablingL( aServiceId );
+ }
+ else
+ {
+ // do nothing and wait next disabled event
+ // to see if then all subservices are disabled
+ }
+ }
+ else if ( allSubserviceDisabled && !iReEnableService )
+ {
+ CCHUIDEBUG( "DoHandleServiceEventL - all subservices disabled" );
+
+ // Service is in disabled state. Inform cchui observers.
+ InformObserversL( aServiceId );
+
+ iLastOperationResult =
+ MCchUiObserver::ECchUiClientOperationResultNotSet;
+ }
+ else
+ {
+ CCHUIDEBUG( "DoHandleServiceEventL - all subservices not disabled" );
+ // not all subservices are disable, do nothing
+ }
+ }
+ break;
+
+ case ECCHEnabled:
+ {
+ if ( iReEnableService && iCCHHandler->AllSubservicesInStateL( aServiceId, ECCHEnabled ) )
+ {
+ CCHUIDEBUG( "DoHandleServiceEventL - reset re-enabling" );
+ // Just in case set re-enable flag to EFalse
+ iReEnableService = EFalse;
+ }
+
+ CCHUIDEBUG( "DoHandleServiceEventL - service is enabled" );
+
+ // Cancel notes and stop observing only if no active dialog exists
+ // which needs user action
+ if ( !iNoteController->ActiveDialogExists() && !iReEnableService )
+ {
+ CancelNotes();
+
+ TInt observedPos = iObservervedServices.Find( aServiceId );
+ if ( KErrNotFound != observedPos )
+ {
+ CCHUIDEBUG(
+ "DoHandleServiceEventL - removed observed service" );
+ iObservervedServices.Remove( observedPos );
+ }
+
+ CCHUIDEBUG( "DoHandleServiceEventL - stop observing" );
+ iCCHHandler->StopObservingL( aServiceId, *this );
+ iObservedService = 0;
+
+ // Service is in enabled state. Inform cchui observers.
+ InformObserversL( aServiceId );
+
+ iLastOperationResult =
+ MCchUiObserver::ECchUiClientOperationResultNotSet;
+ }
+
+ if ( iNoteController &&
+ MCchUiObserver::ECchUiDialogTypeNoConnectionAvailable ==
+ iNoteController->CurrentNote() )
+ {
+ CCHUIDEBUG( "DoHandleServiceEventL - cancel notifier" );
+ // Connection enabled again so this notify can be canceled.
+ CancelNotes();
+ }
+ }
+ break;
+ default:
+ CCHUIDEBUG( "DoHandleServiceEventL - default switch case" );
+ break;
+ }
+
+ CCHUIDEBUG( "CCchUiApiImpl::DoHandleServiceEventL - OUT" );
+ }
+
+// ---------------------------------------------------------------------------
+// Informs observers about cch ui results.
+// ---------------------------------------------------------------------------
+//
+void CCchUiApiImpl::InformObserversL( TInt aServiceId )
+ {
+ CCHUIDEBUG( "CCchUiApiImpl::InformObserversL - IN");
+
+ for ( TInt index = 0 ; index < iObservers.Count() ; index++ )
+ {
+ CCHUIDEBUG2( "InformObserversL - aServiceId: %d", aServiceId );
+ CCHUIDEBUG2( "InformObserversL - iLastOperationResult: %d",
+ iLastOperationResult );
+
+ iObservers[index]->Observer().ConnectivityDialogsCompletedL(
+ aServiceId,
+ iLastOperationResult );
+ }
+
+ CCHUIDEBUG( "CCchUiApiImpl::InformObserversL - OUT");
+ }
+