/*

* Copyright (c) 2002-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 CSWInstSession class 

*                member functions.

*

*/

// INCLUDE FILES

#include <ecom/ecom.h>

#include <w32std.h>

#include <apgtask.h>

#include <s32mem.h> //RDesReadStream 

#include "SWInstSession.h"

#include "SWInstServer.h"

#include "SWInstServerPanic.h"

#include "SWInstInstallRequest.h"

#include "SWInstUninstallRequest.h"

#include "SWInstRequestStore.h"

#include "SWInstPrivateUid.h"

using namespace SwiUI;

// ============================ MEMBER FUNCTIONS ===============================

// -----------------------------------------------------------------------------

// CSWInstSession::CSWInstSession

// C++ default constructor can NOT contain any code, that

// might leave.

// -----------------------------------------------------------------------------

//

CSWInstSession::CSWInstSession()

    {

    }

// Destructor

CSWInstSession::~CSWInstSession()

    {   

    if ( iCanceller )

        {

        iCanceller->Cancel();

        delete iCanceller;

        }    

    delete iRequestStore;    

    // Call final close for ecom    

    REComSession::FinalClose();  

    delete iHeapSourceUrl;   

    }

// -----------------------------------------------------------------------------

// CSWInstSession::PrepareForExit

// Prepare the session for exit.

// (other items were commented in a header).

// -----------------------------------------------------------------------------

//

void CSWInstSession::PrepareForExit( MRequestCallback* aExitCallback )

    {

    iExitCallback = aExitCallback;

    // If we have any pending requests, cancel them all

    if ( iRequestStore )

        {

        iRequestStore->CancelAllRequests();

        }

    if ( iExitCallback )

        {

        iExitCallback->RequestCompleted( KErrNone ); 

        iExitCallback = NULL;        

        }    

    }

// -----------------------------------------------------------------------------

// CSWInstSession::ServiceL

// Handles the received message.

// (other items were commented in a header).

// -----------------------------------------------------------------------------

//

void CSWInstSession::ServiceL( const RMessage2& aMessage )

    {

    // Dispatch the message in trap harness.

    TRAPD( result, HandleRequestL( aMessage ) );

    if ( result == KErrBadDescriptor )

        {

        PanicClient( aMessage, ESWInstPanicBadDescriptor );

        }    

    // In case of leave, we need to complete the client request here

    else if ( result != KErrNone )

        {

        if ( iRequestStore )

            {

            CSWInstRequestObject* req = iRequestStore->GetRequest( aMessage.Function() );

            if ( req && req->IsActive() )

                {

                req->Cancel();                

                }            

            else 

                {

                // No active request found, we must complete the message manually

                aMessage.Complete( result );

                }            

            } 

        else

            {

            aMessage.Complete( result );

            }        

        }

    }

// -----------------------------------------------------------------------------

// CSWInstSession::ServiceError

// Called back by the server framework if this sessions RunL function returns an

// error.

// (other items were commented in a header).

// -----------------------------------------------------------------------------

//

void CSWInstSession::ServiceError( const RMessage2& aMessage, TInt 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, ESWInstPanicBadDescriptor );

        }

    CAknAppServiceBase::ServiceError( aMessage, aError );    

    }

// -----------------------------------------------------------------------------

// CSWInstSession::CreateL

// Completes construction of this server-side client session object.

// (other items were commented in a header).

// -----------------------------------------------------------------------------

//

void CSWInstSession::CreateL()

    {

    iRequestStore = CSWInstRequestStore::NewL();  

    CAknAppServiceBase::CreateL();   

    iAppInForeground = ETrue; 

    }

// -----------------------------------------------------------------------------

// CSWInstSession::RequestCompleted

// Called when request is completed.

// (other items were commented in a header).

// -----------------------------------------------------------------------------

//

void CSWInstSession::RequestCompleted( TInt /*aResult*/ )

    {

    // Delete completed requests

    iRequestStore->Flush();

    TInt pendingRequests = iRequestStore->PendingRequestCount();

    // See if we need to notify this completion

    if( iExitCallback && !pendingRequests )

        {

        iExitCallback->RequestCompleted( KErrNone );

        iExitCallback = NULL;

        }    

    }

// -----------------------------------------------------------------------------

// CSWInstSession::Server

// Returns reference to the server.

// (other items were commented in a header).

// -----------------------------------------------------------------------------

//

CSWInstServer& CSWInstSession::Server()

    {

    return *static_cast<CSWInstServer*>( const_cast<CServer2*>

                                         ( CSession2::Server() ) );

    }

// -----------------------------------------------------------------------------

// CSWInstSession::HandleRequestL

// Handles the request.

// (other items were commented in a header).

// -----------------------------------------------------------------------------

//

void CSWInstSession::HandleRequestL( const RMessage2& aMessage )

    {       

    TServerRequest opCode( ( TServerRequest ) aMessage.Function() );  

    // Send application to background if installation is silent. This way

    // we do not block other apps if installation takes long time.   

    if ( opCode == ERequestSilentInstall && iAppInForeground || 

         opCode == ERequestSilentInstallParams && iAppInForeground ||

         opCode == ERequestSilentInstallHandle && iAppInForeground ||

         opCode == ERequestSilentInstallParamsHandle && iAppInForeground )

        {        

        SendAppToBackgroundL();                                

        }      

    // Handle requests for the session.

    switch ( opCode ) 

        {

        case ERequestCancelRequest:

            {

            // We need to cancel and destroy the corresponding request. 

            TInt functionToCancel( GetInt( aMessage, KRequestIpcSlot ) );            

            CSWInstRequestObject* requestObj = iRequestStore->GetRequest( functionToCancel );

            if ( requestObj && requestObj->IsActive() )

                {

                requestObj->Cancel( aMessage );

                }

            else

                {                

                // If we are cancelling we may have a dialog waiting. We need to 

                // use this special method to cancel dialog before exit.

                // See error TSW ELBA-78SBTS

                TRAP_IGNORE(

                    iCanceller = CommonUI::CCUICancelTimer::NewL( this );

                    iCanceller->StartCancelling();            

                    );

                aMessage.Complete( KErrNotFound );

                }           

            break;                

            }                    

        case ERequestInstall:

        case ERequestInstallParams:

        case ERequestSilentInstall:

        case ERequestSilentInstallParams:

            {          

            // Delete completed requests

            iRequestStore->Flush();

            CSWInstInstallRequest* installRequestObj = CSWInstInstallRequest::NewL( aMessage );

            CleanupStack::PushL( installRequestObj );

            // If store is full, this leaves with KSWInstErrBusy

            iRequestStore->AddRequestL( installRequestObj );  // Ownership transfers to store

            CleanupStack::Pop( installRequestObj );

            TFileName fileName;            

            TInstallReq params;

            // Parse filename

            __ASSERT_ALWAYS( aMessage.GetDesLength( KFileNameIpcSlot ) > 0, 

                             User::Leave( KErrBadDescriptor ) );

            aMessage.ReadL( KFileNameIpcSlot, fileName );                

            if ( opCode == ERequestInstall )

                {                

                installRequestObj->Install( fileName, params );                

                }            

            else if( opCode == ERequestSilentInstall )

                {            

                __ASSERT_ALWAYS( aMessage.GetDesLength( KOptionsIpcSlot ) > 0, 

                                 User::Leave( KErrBadDescriptor ) );

                // Parse install options

                TInstallOptions options;

                TPckg<TInstallOptions> optionsPckg( options );            

                aMessage.ReadL( KOptionsIpcSlot, optionsPckg );

                installRequestObj->SilentInstall( fileName, params, options );

                }

            else if ( opCode == ERequestInstallParams )

                {                              

                //TSW JROL-7B8K6H            

                TPckg<TInstallReq> paramsPckg( params );        

                TInt desLength = aMessage.GetDesLength( KParamsIpcSlot );                 				

                __ASSERT_ALWAYS( desLength > 0, 

                        User::Leave( KErrBadDescriptor ) );                          

                // If length is more then sizeof TInstallReqPckg, input data 

                // is stored to to heap. Read data to descriptor.                                  

                if ( desLength > sizeof( TInstallReq ) )

                    {                       	          	

                    HBufC8* paramDescriptor = HBufC8::NewLC( desLength );

                    TPtr8 paramDesPtr = paramDescriptor->Des();						                	                                                                

                    aMessage.ReadL( KParamsIpcSlot, paramDesPtr );                  	

                    // Get install parameters and store URL to heap. 

                    GetReqParamsL( *paramDescriptor, params );					

                    CleanupStack::PopAndDestroy( paramDescriptor ); 		

                    }

                else

                    {             	

                    aMessage.ReadL( KParamsIpcSlot, paramsPckg );	

                    }	

                installRequestObj->Install( fileName, params );

                }

            else if ( opCode == ERequestSilentInstallParams )

                {                            

                __ASSERT_ALWAYS( aMessage.GetDesLength( KParamsIpcSlot ) > 0 && 

                                 aMessage.GetDesLength( KOptionsIpcSlot ) > 0, 

                                 User::Leave( KErrBadDescriptor ) );

                //TSW JROL-7B8K6H 

                TPckg<TInstallReq> paramsPckg( params );        

                TInt desLength = aMessage.GetDesLength( KParamsIpcSlot );                 

                // If length is more then sizeof TInstallReqPckg, input data 

                // is stored to to heap. Read data to descriptor.                                  

                if ( desLength > sizeof( TInstallReq ) )

                    {                       	          	

                    HBufC8* paramDescriptor = HBufC8::NewLC( desLength );

                    TPtr8 paramDesPtr = paramDescriptor->Des();						                	                                                                

                    aMessage.ReadL( KParamsIpcSlot, paramDesPtr );                  	

                    // Get install parameters and store URL to heap. 

                    GetReqParamsL( *paramDescriptor, params );					

                    CleanupStack::PopAndDestroy( paramDescriptor ); 		

                    } 

                // Read params to pckg if lenght is more then 0.	               

                else

                    {             	

                    aMessage.ReadL( KParamsIpcSlot, paramsPckg );	

                    }	

                // Parse install options

                TInstallOptions options;

                TPckg<TInstallOptions> optionsPckg( options );            

                aMessage.ReadL( KOptionsIpcSlot, optionsPckg );                                 

                installRequestObj->SilentInstall( fileName, params, options );

                }

            break;            

            }

        case ERequestInstallHandle:

        case ERequestInstallParamsHandle:

        case ERequestSilentInstallHandle:

        case ERequestSilentInstallParamsHandle:

            {

            // Delete completed requests

            iRequestStore->Flush();

            CSWInstInstallRequest* installRequestObj = CSWInstInstallRequest::NewL( aMessage );

            CleanupStack::PushL( installRequestObj );

            // If store is full, this leaves with KSWInstErrBusy

            iRequestStore->AddRequestL( installRequestObj );  // Ownership transfers to store

            CleanupStack::Pop( installRequestObj );

            RFile file;            

            TInstallReq params;

            // Get the file handle

            User::LeaveIfError( file.AdoptFromClient( aMessage, KFileHandleIpcSlot, KFileSrvSessionIpcSlot ) );

            CleanupClosePushL( file );            

            if ( opCode == ERequestInstallHandle )

                {                

                installRequestObj->Install( file, params ); // Ownership of file transfers

                CleanupStack::Pop(); // file

                }            

            else if( opCode == ERequestSilentInstallHandle )

                {            

                __ASSERT_ALWAYS( aMessage.GetDesLength( KOptionsIpcSlot ) > 0, 

                                 User::Leave( KErrBadDescriptor ) );

                // Parse install options

                TInstallOptions options;

                TPckg<TInstallOptions> optionsPckg( options );            

                aMessage.ReadL( KOptionsIpcSlot, optionsPckg );

                installRequestObj->SilentInstall( file, params, options ); // Ownership of file transfers

                CleanupStack::Pop(); // file

                }

            else if ( opCode == ERequestInstallParamsHandle )

                {                        

                TPckg<TInstallReq> paramsPckg( params );        

                TInt desLength = aMessage.GetDesLength( KParamsIpcSlot );                 				              

                __ASSERT_ALWAYS( desLength > 0, 

                        User::Leave( KErrBadDescriptor ) );                          

                // If length is more then sizeof TInstallReqPckg, input data 

                // is stored to to heap. Read data to descriptor.                                           

                if ( desLength > sizeof( TInstallReq ) )

                    {                       	          	

                    HBufC8* paramDescriptor = HBufC8::NewLC( desLength );

                    TPtr8 paramDesPtr = paramDescriptor->Des();						                	                                                                

                    aMessage.ReadL( KParamsIpcSlot, paramDesPtr );                  	

                    // Get install parameters and store URL to heap. 

                    GetReqParamsL( *paramDescriptor, params );					

                    CleanupStack::PopAndDestroy( paramDescriptor ); 		

                    }

                else 

                    {             	

                    aMessage.ReadL( KParamsIpcSlot, paramsPckg );	

                    }	

                installRequestObj->Install( file, params ); // Ownership of file transfers

                CleanupStack::Pop(); // file                

                }

            else if ( opCode == ERequestSilentInstallParamsHandle )

                {                          

                __ASSERT_ALWAYS( aMessage.GetDesLength( KParamsIpcSlot ) > 0 && 

                                 aMessage.GetDesLength( KOptionsIpcSlot ) > 0, 

                                 User::Leave( KErrBadDescriptor ) );

                TPckg<TInstallReq> paramsPckg( params );        

                TInt desLength = aMessage.GetDesLength( KParamsIpcSlot );                 

                // If length is more then sizeof TInstallReqPckg, input data 

                // is stored to to heap. Read data to descriptor.                                  

                if ( desLength > sizeof( TInstallReq ) )

                    {                       	          	

                    HBufC8* paramDescriptor = HBufC8::NewLC( desLength );

                    TPtr8 paramDesPtr = paramDescriptor->Des();						                	                                                                

                    aMessage.ReadL( KParamsIpcSlot, paramDesPtr );                  	

                    // Get install parameters and store URL to heap. 

                    GetReqParamsL( *paramDescriptor, params );					

                    CleanupStack::PopAndDestroy( paramDescriptor ); 		

                    }

                else 

                    {             	

                    aMessage.ReadL( KParamsIpcSlot, paramsPckg );	

                    }	

                // Parse install options

                TInstallOptions options;

                TPckg<TInstallOptions> optionsPckg( options );

                aMessage.ReadL( KOptionsIpcSlot, optionsPckg );

                installRequestObj->SilentInstall( file, params, options ); // Ownership of file transfers

                CleanupStack::Pop(); // file

                }

            break;            

            }

        case ERequestUninstall:

        case ERequestSilentUninstall:

            {

            // Delete completed requests

            iRequestStore->Flush();

            CSWInstUninstallRequest* uninstRequestObj = CSWInstUninstallRequest::NewL( aMessage );

            CleanupStack::PushL( uninstRequestObj );                

            // If store is full, this leaves with KSWInstErrBusy

            iRequestStore->AddRequestL( uninstRequestObj );  // Ownership transfers to store

            CleanupStack::Pop( uninstRequestObj );  

            TUid uid;

            HBufC8* mime = NULL;

            if ( opCode == ERequestUninstall )

                {            

                 __ASSERT_ALWAYS( aMessage.GetDesLength( KMimeIpcSlot ) > 0, 

                             User::Leave( KErrBadDescriptor ) );

                // Parse Uid            

                uid.iUid = GetInt( aMessage, KUidIpcSlot );                

                // Parse the mime

                mime = HBufC8::NewLC( aMessage.GetDesLength( KMimeIpcSlot ) );

                TPtr8 ptr( mime->Des() );            

                aMessage.ReadL( KMimeIpcSlot, ptr );

                uninstRequestObj->Uninstall( uid, *mime );

                CleanupStack::PopAndDestroy( mime );            

                }

            else if ( opCode == ERequestSilentUninstall )

                {            

                __ASSERT_ALWAYS( aMessage.GetDesLength( KOptionsIpcSlot ) > 0 && 

                                 aMessage.GetDesLength( KMimeIpcSlot ) > 0, 

                                 User::Leave( KErrBadDescriptor ) );

                // Parse Uid                

                uid.iUid = GetInt( aMessage, KUidIpcSlot );                

                TUninstallOptions options;            

                // Parse uninstall options

                TPckg<TUninstallOptions> optionsPckg( options );

                aMessage.ReadL( KOptionsIpcSlot, optionsPckg );

                // Parse the mime

                mime = HBufC8::NewLC( aMessage.GetDesLength( KMimeIpcSlot ) );

                TPtr8 ptr( mime->Des() );            

                aMessage.ReadL( KMimeIpcSlot, ptr );

                uninstRequestObj->SilentUninstall( uid, *mime, options );

                CleanupStack::PopAndDestroy( mime );

                }

            break;        

            }            

        case ERequestCustomUninstall:

        case ERequestSilentCustomUninstall:

            {

            __ASSERT_ALWAYS( aMessage.GetDesLength( KCommonParamsIpcSlot ) > 0 &&

                             aMessage.GetDesLength( KMimeIpcSlot ) > 0,

                             User::Leave( KErrBadDescriptor ) );

             // Get the operation we need to perform

            TOperation operation = (TOperation) GetInt( aMessage, KOperationIpcSlot );

            // Get the params

            HBufC8* params = HBufC8::NewLC( aMessage.GetDesLength( KCommonParamsIpcSlot ) );

            TPtr8 paramPtr( params->Des() );            

            aMessage.ReadL( KCommonParamsIpcSlot, paramPtr );

            // Parse the mime

            HBufC8* mime = HBufC8::NewLC( aMessage.GetDesLength( KMimeIpcSlot ) );

            TPtr8 mimePtr( mime->Des() );            

            aMessage.ReadL( KMimeIpcSlot, mimePtr );

            // Delete completed requests

            iRequestStore->Flush();