diff -r 000000000000 -r ba25891c3a9e iaupdate/IAD/api/client/src/iaupdatemanager.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/iaupdate/IAD/api/client/src/iaupdatemanager.cpp Thu Dec 17 08:51:10 2009 +0200 @@ -0,0 +1,529 @@ +/* +* Copyright (c) 2007-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: This module contains the implementation of CIAUpdateManager +* class member functions. +* +*/ + + + +// INCLUDES +#include +#include +#include + +#include "iaupdatemanager.h" +#include "iaupdateclient.h" +#include "iaupdatedebug.h" + + +// ----------------------------------------------------------------------------- +// CIAUpdateManager::NewL +// +// ----------------------------------------------------------------------------- +// +CIAUpdateManager* CIAUpdateManager::NewL( MIAUpdateObserver& aObserver ) + { + IAUPDATE_TRACE("[IAUPDATE] CIAUpdateManager::NewL() begin"); + CIAUpdateManager* self = CIAUpdateManager::NewLC( aObserver ); + CleanupStack::Pop( self ); + IAUPDATE_TRACE("[IAUPDATE] CIAUpdateManager::NewL() end"); + return self; + } + +// ----------------------------------------------------------------------------- +// CIAUpdateManager::NewLC +// +// ----------------------------------------------------------------------------- +// +CIAUpdateManager* CIAUpdateManager::NewLC( MIAUpdateObserver& aObserver ) + { + IAUPDATE_TRACE("[IAUPDATE] CIAUpdateManager::NewLC() begin"); + CIAUpdateManager* self = new( ELeave ) CIAUpdateManager( aObserver ); + CleanupStack::PushL( self ); + self->ConstructL(); + IAUPDATE_TRACE("[IAUPDATE] CIAUpdateManager::NewLC() end"); + return self; + } + +// ----------------------------------------------------------------------------- +// CIAUpdateManager::CIAUpdateManager +// +// ----------------------------------------------------------------------------- +// +CIAUpdateManager::CIAUpdateManager( MIAUpdateObserver& aObserver ) +: CActive( CActive::EPriorityStandard ), + iObserver( aObserver ), + iUpdateType( EIAUpdateIdle ) + { + IAUPDATE_TRACE("[IAUPDATE] CIAUpdateManager::CIAUpdateManager()"); + iEikEnv = CEikonEnv::Static(); + } + +// ----------------------------------------------------------------------------- +// CIAUpdateManager::ConstructL() +// +// ----------------------------------------------------------------------------- +// +void CIAUpdateManager::ConstructL() + { + IAUPDATE_TRACE("[IAUPDATE] CIAUpdateManager::ConstructL() begin"); + CActiveScheduler::Add( this ); + if ( iEikEnv ) + { + iEikEnv->AddForegroundObserverL(*this); + } + IAUPDATE_TRACE("[IAUPDATE] CIAUpdateManager::ConstructL() end"); + } + +// ----------------------------------------------------------------------------- +// CIAUpdateManager::~CIAUpdateManager +// +// ----------------------------------------------------------------------------- +// +CIAUpdateManager::~CIAUpdateManager() + { + IAUPDATE_TRACE("[IAUPDATE] CIAUpdateManager::~CIAUpdateManager() begin"); + // If an operation is still active, + // then DoCancel will cancel ongoing request + Cancel(); + UpdateClient().Close(); + if ( iEikEnv ) + { + iEikEnv->RemoveForegroundObserver(*this); + } + IAUPDATE_TRACE("[IAUPDATE] CIAUpdateManager::~CIAUpdateManager() end"); + } + +// ----------------------------------------------------------------------------- +// CIAUpdateManager::CheckUpdates +// +// ----------------------------------------------------------------------------- +// +void CIAUpdateManager::CheckUpdates( const CIAUpdateParameters& aUpdateParameters ) + { + IAUPDATE_TRACE("[IAUPDATE] CIAUpdateManager::CheckUpdates() begin"); + if ( BusyCheck() ) + { + // An operation is already going on. + // Do not continue with this new operation. + // Only, inform the observer with the error code. + // Notice that the callback is called synchronously here + // because there is no better way to do it. Asynchronous way + // would be really cumbersome because this object is already active. + // This error is users fault. Therefore we, could also panic here. + Observer().CheckUpdatesComplete( KErrServerBusy, 0 ); + return; + } + + // Reset result values because we are starting a new operation. + ResetResults(); + + // Set the update type. + // So, we know later in RunL what operation was requested. + SetUpdateType( EIAUpdateCheck ); + + TInt error( UpdateClient().Open( ETrue) ); + if ( error == KErrNone ) + { + error = + UpdateClient().CheckUpdates( aUpdateParameters, + iSuccessCount, + iStatus ); + } + + if ( error == KErrNone ) + { + // Set this object active. + // Because everything went ok, + // the operation will be handled asynchronously + // and the service provider will inform us when the operation + // is finished. + SetActive(); + } + else + { + // Because we are going to activate this active object, + // set the status pending. + iStatus = KRequestPending; + + // An error occurred above. + // Therefore, the operation did not proceed any further. + // Set this object active for asynchronous error handling. + SetActive(); + + // Now, that everything is ready, just inform the active scheduler + // that operation is finished. Pass the error code for the observer. + TRequestStatus* status( &iStatus ); + User::RequestComplete( status, error ); + } + IAUPDATE_TRACE("[IAUPDATE] CIAUpdateManager::CheckUpdates() end"); + } + +// ----------------------------------------------------------------------------- +// CIAUpdateManager::ShowUpdates +// +// ----------------------------------------------------------------------------- +// +void CIAUpdateManager::ShowUpdates( const CIAUpdateParameters& aUpdateParameters ) + { + IAUPDATE_TRACE("[IAUPDATE] CIAUpdateManager::ShowUpdates() begin"); + if ( BusyCheck() ) + { + // An update operation is already going on. + // Do not continue with this new operation. + // Only, inform the observer with the error code. + // Notice that the callback is called synchronously here + // because there is no better way to do it. Asynchronous way + // would be really cumbersome because this object is already active. + // This error is users fault. Therefore we, could also panic here. + Observer().UpdateComplete( KErrServerBusy, NULL ); + return; + } + + // Reset result values because we are starting a new operation. + ResetResults(); + + // Set the update type. + // So, we know later in RunL what operation was requested. + SetUpdateType( EIAUpdateUpdate ); + + TInt error( UpdateClient().Open( EFalse ) ); + if ( error == KErrNone ) + { + error = + UpdateClient().ShowUpdates( aUpdateParameters, + iSuccessCount, + iFailCount, + iCancelCount, + iStatus ); + } + + if ( error == KErrNone ) + { + // Set this object active. + // Because everything went ok, + // the operation will be handled asynchronously + // and the service provider will inform us when the operation + // is finished. + SetActive(); + } + else + { + // Because we are going to activate this active object, + // set the status pending. + iStatus = KRequestPending; + + // An error occurred above. + // Therefore, the operation did not proceed any further. + // Set this object active for asynchronous error handling. + SetActive(); + + // Now, that everything is ready, just inform the active scheduler + // that operation is finished. Pass the error code for the observer. + TRequestStatus* status( &iStatus ); + User::RequestComplete( status, error ); + } + IAUPDATE_TRACE("[IAUPDATE] CIAUpdateManager::ShowUpdates() end"); + } + +// ----------------------------------------------------------------------------- +// CIAUpdateManager::Update +// +// ----------------------------------------------------------------------------- +// +void CIAUpdateManager::Update( const CIAUpdateParameters& /*aUpdateParameters*/ ) + { + IAUPDATE_TRACE("[IAUPDATE] CIAUpdateManager::Update() begin"); + Observer().UpdateComplete( KErrNotSupported, NULL ); + + + IAUPDATE_TRACE("[IAUPDATE] CIAUpdateManager::Update() begin"); + } + +// ----------------------------------------------------------------------------- +// CIAUpdateManager::UpdateQuery +// +// ----------------------------------------------------------------------------- +// +void CIAUpdateManager::UpdateQuery() + { + IAUPDATE_TRACE("[IAUPDATE] CIAUpdateManager::UpdateQuery() begin"); + if ( BusyCheck() ) + { + // An update operation is already going on. + // Do not continue with this new operation. + // Only, inform the observer with the error code. + // Notice that the callback is called synchronously here + // because there is no better way to do it. Asynchronous way + // would be really cumbersome because this object is already active. + // This error is users fault. Therefore we, could also panic here. + Observer().UpdateQueryComplete( KErrServerBusy, EFalse ); + return; + } + + // Reset result values because we are starting a new operation. + ResetResults(); + + // Set the update type. + // So, we know later in RunL what operation was requested. + SetUpdateType( EIAUpdateQuery ); + + TInt error( UpdateClient().Open( EFalse ) ); + if ( error == KErrNone ) + { + error = + UpdateClient().UpdateQuery( iUpdateNow, iStatus ); + } + + if ( error == KErrNone ) + { + // Set this object active. + // Because everything went ok, + // the operation will be handled asynchronously + // and the service provider will inform us when the operation + // is finished. + SetActive(); + } + else + { + // Because we are going to activate this active object, + // set the status pending. + iStatus = KRequestPending; + + // An error occurred above. + // Therefore, the operation did not proceed any further. + // Set this object active for asynchronous error handling. + SetActive(); + + // Now, that everything is ready, just inform the active scheduler + // that operation is finished. Pass the error code for the observer. + TRequestStatus* status( &iStatus ); + User::RequestComplete( status, error ); + } + IAUPDATE_TRACE("[IAUPDATE] CIAUpdateManager::UpdateQuery() end"); + } + +// ----------------------------------------------------------------------------- +// CIAUpdateManager::DoCancel +// +// ----------------------------------------------------------------------------- +// +void CIAUpdateManager::DoCancel() + { + IAUPDATE_TRACE("[IAUPDATE] CIAUpdateManager::DoCancel() begin"); + UpdateClient().CancelAsyncRequest(); + + // Reset result values because we are starting a new operation. + ResetResults(); + IAUPDATE_TRACE("[IAUPDATE] CIAUpdateManager::DoCancel() end"); + } + +// ----------------------------------------------------------------------------- +// CIAUpdateManager::RunL +// +// ----------------------------------------------------------------------------- +// +void CIAUpdateManager::RunL() + { + IAUPDATE_TRACE("[IAUPDATE] CIAUpdateManager::RunL() begin"); + // Update operation error code + TInt errorCode( iStatus.Int() ); + IAUPDATE_TRACE_1("[IAUPDATE] error code: %d", errorCode ); + if ( errorCode == KErrServerTerminated ) + { + // Handle is released if server is terminated + UpdateClient().Close(); + } + + // Variables for operation and result information. + TIAUpdateType updateType( UpdateType() ); + IAUPDATE_TRACE_1("[IAUPDATE] update type: %d", updateType ); + CIAUpdateResult* updateResult( NULL ); + + if ( updateType == EIAUpdateUpdate ) + { + // Update result object is required. + // Notice that the ownership is transferred later. + // So, this function does not need to delete updateResult object. + TRAPD( trapError, updateResult = CIAUpdateResult::NewL() ); + if ( updateResult ) + { + updateResult->SetSuccessCount( iSuccessCount ); + updateResult->SetFailCount( iFailCount ); + updateResult->SetCancelCount( iCancelCount ); + } + else + { + // Something went wrong when creating update result object. + // Update the error code accordingly. + errorCode = trapError; + } + // Let's assume that connection is not needed anymore + UpdateClient().Close(); + } + + + // Inform that no operation is going on anymore. + // This is required for busy check. + SetUpdateType( EIAUpdateIdle ); + + // Use the update type of the ongoing operation to check what callback + // function to call. + switch ( updateType ) + { + case EIAUpdateCheck: + if ( iSuccessCount == 0 ) + { + // Let's assume that connection is not needed anymore + UpdateClient().Close(); + } + IAUPDATE_TRACE_1("[IAUPDATE] success count: %d", iSuccessCount ); + Observer().CheckUpdatesComplete( errorCode, iSuccessCount ); + break; + + case EIAUpdateUpdate: + // Notice that ownership of result object is transferred here. + IAUPDATE_TRACE_3("[IAUPDATE] success count: %d failed count: %d cancelled count: %d", iSuccessCount, iFailCount, iCancelCount ); + Observer().UpdateComplete( errorCode, updateResult ); + break; + + case EIAUpdateQuery: + if ( !iUpdateNow ) + { + // Let's assume that connection is not needed anymore + UpdateClient().Close(); + } + IAUPDATE_TRACE_1("[IAUPDATE] update now: %d", iUpdateNow ); + Observer().UpdateQueryComplete( errorCode, iUpdateNow ); + break; + + default: + // Should not ever come here. + break; + } + + // Do not anything else than return after callback function is called because + // this instance can be deleted by a client in a callback function + // + IAUPDATE_TRACE("[IAUPDATE] CIAUpdateManager::RunL() end"); + } + +// ----------------------------------------------------------------------------- +// CIAUpdateManager::ResetResults +// +// ----------------------------------------------------------------------------- +// +void CIAUpdateManager::ResetResults() + { + IAUPDATE_TRACE("[IAUPDATE] CIAUpdateManager::ResetResults() begin"); + // Set the member variables to their default values. + iSuccessCount = 0; + iFailCount = 0; + iCancelCount = 0; + iUpdateNow = EFalse; + IAUPDATE_TRACE("[IAUPDATE] CIAUpdateManager::ResetResults() end"); + } + +// ----------------------------------------------------------------------------- +// CIAUpdateManager::BusyCheck +// +// ----------------------------------------------------------------------------- +// +TBool CIAUpdateManager::BusyCheck() const + { + IAUPDATE_TRACE("[IAUPDATE] CIAUpdateManager::BusyCheck()"); + if ( UpdateType() == EIAUpdateIdle ) + { + return EFalse; + } + else + { + return ETrue; + } + } + +// ----------------------------------------------------------------------------- +// CIAUpdateManager::UpdateClient +// +// ----------------------------------------------------------------------------- +// +RIAUpdateClient& CIAUpdateManager::UpdateClient() + { + IAUPDATE_TRACE("[IAUPDATE] CIAUpdateManager::UpdateClient()"); + return iUpdateClient; + } + +// ----------------------------------------------------------------------------- +// CIAUpdateManager::Observer +// +// ----------------------------------------------------------------------------- +// +MIAUpdateObserver& CIAUpdateManager::Observer() const + { + IAUPDATE_TRACE("[IAUPDATE] CIAUpdateManager::Observer()"); + return iObserver; + } + +// ----------------------------------------------------------------------------- +// CIAUpdateManager::UpdateType +// +// ----------------------------------------------------------------------------- +// +CIAUpdateManager::TIAUpdateType CIAUpdateManager::UpdateType() const + { + IAUPDATE_TRACE("[IAUPDATE] CIAUpdateManager::UpdateType()"); + return iUpdateType; + } + + +// ----------------------------------------------------------------------------- +// CIAUpdateManager::SetUpdateType +// +// ----------------------------------------------------------------------------- +// +void CIAUpdateManager::SetUpdateType( CIAUpdateManager::TIAUpdateType aUpdateType ) + { + IAUPDATE_TRACE("[IAUPDATE] CIAUpdateManager::SetUpdateType() begin"); + IAUPDATE_TRACE_1("[IAUPDATE] update type: %d", aUpdateType ); + iUpdateType = aUpdateType; + IAUPDATE_TRACE("[IAUPDATE] CIAUpdateManager::SetUpdateType() end"); + } + +// ----------------------------------------------------------------------------- +// CIAUpdateManager::HandleGainingForeground +// iaupdate.exe is brought to foreground if visible request is ongoing +// ----------------------------------------------------------------------------- +// +void CIAUpdateManager::HandleGainingForeground() + { + IAUPDATE_TRACE("[IAUPDATE] CIAUpdateManager::HandleGainingForeground() begin"); + iUpdateClient.BroughtToForeground(); + IAUPDATE_TRACE("[IAUPDATE] CIAUpdateManager::HandleGainingForeground() end"); + } + +// ----------------------------------------------------------------------------- +// CIAUpdateManager::HandleLosingForeground +// +// ----------------------------------------------------------------------------- +// +void CIAUpdateManager::HandleLosingForeground() + { + } + + + + + +