--- /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 <eikenv.h>
+#include <iaupdateobserver.h>
+#include <iaupdateresult.h>
+
+#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()
+ {
+ }
+
+
+
+
+
+