iaupdate/IAD/ui/src/iaupdatesession.cpp
author Dremov Kirill (Nokia-D-MSW/Tampere) <kirill.dremov@nokia.com>
Thu, 17 Dec 2009 08:51:10 +0200
changeset 0 ba25891c3a9e
child 34 741e5bba2bd1
permissions -rw-r--r--
Revision: 200949 Kit: 200951

/*
* Copyright (c) 2007-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:   This module contains the implementation of CIAUpdateSession class 
*                member functions.
*
*/



// INCLUDE FILES
#include <w32std.h>
#include <apgtask.h>
#include <iaupdateparameters.h>
#include <iaupdateresult.h>

#include "iaupdatesession.h"
#include "iaupdateserver.h"

// Parameters are transmitted from the client side to the server
#include "iaupdatetools.h"
#include "iaupdateclientdefines.h"
#include "iaupdateappui.h"
#include "iaupdatelauncheruids.h"
#include "iaupdatedebug.h"

// CONSTANTS
const TSecureId KSIDBackgroundChecker = 0x200211f4;
const TSecureId KSIDLauncher = KIAUpdateLauncherUid;
// ============================ MEMBER FUNCTIONS ===============================

// -----------------------------------------------------------------------------
// CIAUpdateSession::CIAUpdateSession
// C++ default constructor can NOT contain any code, that
// might leave.
// -----------------------------------------------------------------------------
//
CIAUpdateSession::CIAUpdateSession()
    {
    IAUPDATE_TRACE("[IAUPDATE] CIAUpdateSession::CIAUpdateSession()");
    iEikEnv = CEikonEnv::Static();
    }
    
// -----------------------------------------------------------------------------
// CIAUpdateSession::CIAUpdateSession
// C++ default constructor can NOT contain any code, that
// might leave.
// -----------------------------------------------------------------------------
//
CIAUpdateSession::~CIAUpdateSession()
    {
    IAUPDATE_TRACE("[IAUPDATE] CIAUpdateSession::~CIAUpdateSession() begin");    
    CIAUpdateAppUi* appUi = 
        static_cast<CIAUpdateAppUi*>( iEikEnv->EikAppUi() );
    if ( appUi ) 
        {
    	appUi->HandleObserverRemoval();
        }
    delete iMessage;
    IAUPDATE_TRACE("[IAUPDATE] CIAUpdateSession::~CIAUpdateSession() end");  
    }


// -----------------------------------------------------------------------------
// CIAUpdateSession::ServiceL
// Handles the received message.
// (other items were commented in a header).
// -----------------------------------------------------------------------------
//
void CIAUpdateSession::ServiceL( const RMessage2& aMessage )
    {
    IAUPDATE_TRACE("[IAUPDATE] CIAUpdateSession::ServiceL() begin");
    // Dispatch the message in trap harness.
    TRAPD( result, HandleRequestL( aMessage ) );
    // If HandleRequest Left, the message has to be completed
    // here. Otherwise, the RequestCompleted callback will be called
    // when the operations finishes
    if ( result != KErrNone )   
        {
        IAUPDATE_TRACE_1("[IAUPDATE] HandleRequestL leave with error: %d", result );
        aMessage.Complete( result );
        } 
    IAUPDATE_TRACE("[IAUPDATE] CIAUpdateSession::ServiceL() end");
    }

// -----------------------------------------------------------------------------
// CIAUpdateSession::ServiceError
// Called back by the server framework if this sessions RunL function returns an
// error.
// (other items were commented in a header).
// -----------------------------------------------------------------------------
//
void CIAUpdateSession::ServiceError( const RMessage2& aMessage, TInt aError )
    {
    IAUPDATE_TRACE("[IAUPDATE] CIAUpdateSession::ServiceError() begin");
    IAUPDATE_TRACE_1("[IAUPDATE] error code: %d", aError );
    // A bad descriptor error implies a badly programmed client, so panic it;
    // otherwise use the default handling (report the error to the client)
    if ( aError == KErrBadDescriptor )
        {
        //PanicClient( aMessage, ECIAUpdatePanicBadDescriptor );
        }
    CAknAppServiceBase::ServiceError( aMessage, aError );   
    IAUPDATE_TRACE("[IAUPDATE] CIAUpdateSession::ServiceError() end");
    }


// -----------------------------------------------------------------------------
// CIAUpdateSession::CreateL
// Completes construction of this server-side client session object.
// (other items were commented in a header).
// -----------------------------------------------------------------------------
//
void CIAUpdateSession::CreateL()
    {
    IAUPDATE_TRACE("[IAUPDATE] CIAUpdateSession::CreateL() begin");
    CAknAppServiceBase::CreateL();   
    IAUPDATE_TRACE("[IAUPDATE] CIAUpdateSession::CreateL() end");
    }


// -----------------------------------------------------------------------------
// CIAUpdateSession::RequestCompleted
// @see MIAUpdateRequestObserver::RequestCompleted
// -----------------------------------------------------------------------------
//
void CIAUpdateSession::RequestCompleted( CIAUpdateResult* aResult, 
                                         TInt aCountOfAvailableUpdates,  
                                         TBool aUpdateNow, 
                                         TInt aError )
    {
    IAUPDATE_TRACE("[IAUPDATE] CIAUpdateSession::RequestCompleted() begin");
    IAUPDATE_TRACE_1("[IAUPDATE] error code: %d", aError );

    if ( !iMessage ) //be sure that there is still message to complete
        {
        IAUPDATE_TRACE("[IAUPDATE] No message to complete");
        IAUPDATE_TRACE("[IAUPDATE] CIAUpdateSession::RequestCompleted() end");
        return;
        }

    IAUpdateClientDefines::TIAUpdateServerFunctions functionId =
        static_cast<IAUpdateClientDefines::TIAUpdateServerFunctions>( iMessage->Function() );
 
    TInt error( KErrNone );       

    switch( functionId )
        {
        case IAUpdateClientDefines::EIAUpdateServerCheckUpdates:
            {
            TPckg<TInt> availableUpdates( aCountOfAvailableUpdates ); 
            TPtr8 ptr1( availableUpdates );
            TRAP( error, iMessage->WriteL( 1, ptr1 ) );
            break;	
            }
             
        case IAUpdateClientDefines:: EIAUpdateServerShowUpdateQuery:
            {
            TPckg<TInt> updateNow( aUpdateNow ); 
            TPtr8 ptr1( updateNow );
            TRAP( error, iMessage->WriteL( 1, ptr1 ) );
            break;	
            }

        case IAUpdateClientDefines::EIAUpdateServerShowUpdates:
            {
            TPckg<TInt> successCount( aResult->SuccessCount() ); 
            TPtr8 ptr1( successCount ); 
  
            TPckg<TInt> failCount( aResult->FailCount() );
            TPtr8 ptr2( failCount );
         	
            TPckg<TInt> cancelCount( aResult->CancelCount() );
            TPtr8 ptr3( cancelCount );
    
            TRAP( error,
                  iMessage->WriteL( 1, ptr1 );
                  iMessage->WriteL( 2, ptr2 );
                  iMessage->WriteL( 3, ptr3 ); );            
            break;	
            }
        case IAUpdateClientDefines::EIAUpdateServerStartedByLauncher:
            break;    
        default:
            // We should never come here.
            break;
        }            

    if ( error == KErrNone )
        {
        // Writing of the data in to the message went ok.
        // So, nothing to inform about that.
        // Insert possible error code of the update operation.
        error = aError;
        }

    delete aResult;
    aResult = NULL;

    iMessage->Complete( error );
    delete iMessage;
    iMessage = NULL;
                
    IAUPDATE_TRACE("[IAUPDATE] CIAUpdateSession::RequestCompleted() end");
    }


// -----------------------------------------------------------------------------
// CIAUpdateSession::Server
// Returns reference to the server.
// (other items were commented in a header).
// -----------------------------------------------------------------------------
//
CIAUpdateServer& CIAUpdateSession::Server()
    {
    IAUPDATE_TRACE("[IAUPDATE] CIAUpdateSession::Server()");
    return *static_cast<CIAUpdateServer*>( const_cast<CServer2*>
                                         ( CSession2::Server() ) );
    }


// -----------------------------------------------------------------------------
// CIAUpdateSession::HandleRequestL
// Handles the request.
// (other items were commented in a header).
// -----------------------------------------------------------------------------
//
void CIAUpdateSession::HandleRequestL( const RMessage2& aMessage )
    {
    IAUPDATE_TRACE("[IAUPDATE] CIAUpdateSession::HandleRequestL() begin");    
    
    CIAUpdateAppUi* appUi = 
        static_cast<CIAUpdateAppUi*>( iEikEnv->EikAppUi() );     
    // First value is the function number
    IAUpdateClientDefines::TIAUpdateServerFunctions functionId =
        static_cast<IAUpdateClientDefines::TIAUpdateServerFunctions>( aMessage.Function() );
    IAUPDATE_TRACE_1("[IAUPDATE] function id: %d", functionId );
      
    if ( functionId == IAUpdateClientDefines::EIAUpdateServerCancel )  
        {
        appUi->PotentialCancel();
        if ( iMessage ) //complete possible ongoing request
            {
        	iMessage->Complete( KErrCancel );
        	delete iMessage;
        	iMessage = NULL;  
            }
        // Because cancel is sent synchronously from the client side,
        // aMessage is different than the iMessage for other operation
        // that is currently going on asynchronously.
        // So, RequestCompleted above closed that connection.
        // Now, inform the caller of the cancel operation
        // that cancellation was success.
        aMessage.Complete( KErrNone );
        IAUPDATE_TRACE("[IAUPDATE] CIAUpdateSession::HandleRequestL() end");
    	return;
        }
    
    if ( functionId == IAUpdateClientDefines::EIAUpdateServerToForeground )  
        {
        appUi->HandleClientToForegroundL();
        aMessage.Complete( KErrNone );
        IAUPDATE_TRACE("[IAUPDATE] CIAUpdateSession::HandleRequestL() end");
        return;
        }
    
    if ( functionId == IAUpdateClientDefines::EIAUpdateServerSendWgId )  
        {
        TPckgBuf<TInt> wgIdPkg( 0 );
        aMessage.ReadL( 0, wgIdPkg ); 
        TInt wgId = wgIdPkg(); 
        appUi->SetClientWgId( wgId );
        aMessage.Complete( KErrNone );
        IAUPDATE_TRACE("[IAUPDATE] CIAUpdateSession::HandleRequestL() end");
        return;
        }
    
        
    if ( iMessage )
        {
        // This session is used in a wrong way because the
        // old operation has not been completed before new one is
        // started.
        User::Leave( KErrInUse );
        }
        
    iMessage = new( ELeave ) RMessage2( aMessage );
    if ( functionId == IAUpdateClientDefines::EIAUpdateServerStartedByLauncher )
        {
        TPckgBuf<TBool> refreshFromNetworkDeniedPkg( 0 );
        aMessage.ReadL( 0, refreshFromNetworkDeniedPkg ); 
        TBool refreshFromNetworkDenied = refreshFromNetworkDeniedPkg(); 
    	appUi->StartedByLauncherL( *this, refreshFromNetworkDenied );
        }
    else if ( functionId == IAUpdateClientDefines::EIAUpdateServerShowUpdateQuery )  
        {
        // Handle the update query dialog request
        TUint id = aMessage.SecureId().iId;
    	appUi->ShowUpdateQueryRequestL( *this, id ); 
        }
    else
        {
        // Handle update operation related requests.
        HBufC8* data = NULL;
        data = HBufC8::NewLC( aMessage.GetDesLength( 0 ) );
        TPtr8 ptr( data->Des() );            
        aMessage.ReadL( 0, ptr );
    
        CIAUpdateParameters* params( CIAUpdateParameters::NewLC() );
        IAUpdateTools::InternalizeParametersL( *params, *data );
        // Do not destroy, because ownership of params is transferred
        // below.
        CleanupStack::Pop( params );
        CleanupStack::PopAndDestroy( data );
        
        if ( aMessage.SecureId() != KSIDBackgroundChecker )      
            {
            // other processes than backroundchecker are not allowed to cause refresh from network 
            params->SetRefresh( EFalse );
            }
        switch( functionId )
            {
            case IAUpdateClientDefines::EIAUpdateServerCheckUpdates:
                appUi->CheckUpdatesRequestL( *this, params );
                break;

            case IAUpdateClientDefines::EIAUpdateServerShowUpdates:
                appUi->ShowUpdatesRequestL( *this, params );
                break;
                    
            default:
            // We should never come here
                delete params;
                params = NULL;
                break;
            }    
        }
     IAUPDATE_TRACE("[IAUPDATE] CIAUpdateSession::HandleRequestL() end"); 
     }    


// -----------------------------------------------------------------------------
// CIAUpdateSession::SecurityCheckL
// Virtual framework function that is called on receipt of a message from the
// client. This allows the service implementation to define a security policy
// for messages from the client.
// (other items were commented in a header).
// -----------------------------------------------------------------------------
//
CPolicyServer::TCustomResult CIAUpdateSession::SecurityCheckL( const RMessage2& aMsg,
                                                             TInt& /*aAction*/,
                                                             TSecurityInfo& /*aMissing*/ )
    {
    IAUPDATE_TRACE("[IAUPDATE] CIAUpdateSession::SecurityCheckL() begin");
    
    CPolicyServer::TCustomResult result = CPolicyServer::EFail; 
    switch ( aMsg.Function() )
        {
        case IAUpdateClientDefines::EIAUpdateServerStartedByLauncher:
            if ( aMsg.SecureId() == KSIDLauncher )  
                {
                result = CPolicyServer::EPass;
                }
            break;
        case IAUpdateClientDefines::EIAUpdateServerCheckUpdates:
        case IAUpdateClientDefines::EIAUpdateServerShowUpdates:
        // no capability check is needed because SID is checked later
        // that means that only bacgkroundchecker is allowed to initiate network refresh
            
        case IAUpdateClientDefines::EIAUpdateServerShowUpdateQuery:
        case IAUpdateClientDefines::EIAUpdateServerCancel:
        case IAUpdateClientDefines::EIAUpdateServerToForeground:
        case IAUpdateClientDefines::EIAUpdateServerSendWgId:
        // No capabilities needed
            result = CPolicyServer::EPass;
            break;

        default:
            // Not recognized message
            result = CPolicyServer::EFail;
        }
    IAUPDATE_TRACE_1("[IAUPDATE] result: %d", result );
    IAUPDATE_TRACE("[IAUPDATE] CIAUpdateSession::SecurityCheckL() end");
    return result; 
    }


//  End of File