iaupdate/IAD/api/client/src/iaupdatemanager.cpp
changeset 0 ba25891c3a9e
child 29 26b6f0522fd8
child 36 f9033e605ee2
--- /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()
+    {
+    }
+
+
+
+
+
+