/*
* Copyright (c) 2005-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:  CSConAppInstaller implementation
*
*/


// INCLUDE FILES
#include <s32mem.h> // For RBufWriteStream
#include <utf.h>  // for CnvUtfConverter
//#include <pathinfo.h>
#include <usif/sif/sifcommon.h>

using namespace Usif;

#include "debug.h"
#include "sconinstaller.h"
#include "sconpcdconsts.h"
#include "sconpcdutility.h"


const TInt KSConSeConUidValue = 0x101f99f6;
const TUid KSConSeConUid = {KSConSeConUidValue};

_LIT8(KValSep, "=");
_LIT8(KComma, ",");
_LIT8(KLineEnd, "\r\n");

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

CSConAppInstaller* CSConAppInstaller::NewL( CSConInstallerQueue* aQueue, RFs& aFs )
    {
    CSConAppInstaller* self = new (ELeave) CSConAppInstaller( aQueue, aFs );
    CleanupStack::PushL( self );
    self->ConstructL();
    CleanupStack::Pop( self );
    return self;
    }
// -----------------------------------------------------------------------------
// CSConAppInstaller::CSConAppInstaller( CSConInstallerQueue* aQueue )
// Constructor
// -----------------------------------------------------------------------------
//
CSConAppInstaller::CSConAppInstaller( CSConInstallerQueue* aQueue, RFs& aFs ) :
    CActive( EPriorityStandard ), iQueue( aQueue ), iFs( aFs )
    {
    CActiveScheduler::Add( this );
    }

void CSConAppInstaller::ConstructL()
    {
    iSifOptions = COpaqueNamedParams::NewL();
    iSifResults = COpaqueNamedParams::NewL();
    }

// -----------------------------------------------------------------------------
// CSConAppInstaller::~CSConAppInstaller()
// Destructor
// -----------------------------------------------------------------------------
//
CSConAppInstaller::~CSConAppInstaller()
    {
    TRACE_FUNC;
    Cancel();
    iSwInstaller.Close();
    delete iSifOptions;
    delete iSifResults;
    }

// -----------------------------------------------------------------------------
// CSConAppInstaller::StartInstaller( TInt& aTaskId )
// Starts the installer task
// -----------------------------------------------------------------------------
//
void CSConAppInstaller::StartInstaller( TInt& aTaskId )
    {
    TRACE_FUNC_ENTRY;
    CSConTask* task = NULL;
    TRequestStatus* status = NULL;
    TInt err( KErrNone );
    
    TInt ret = iQueue->GetTask( aTaskId, task );
    
    if( aTaskId > 0 && ret != KErrNotFound )
        {
        if ( IsActive() )
            {
            LOGGER_WRITE("WARNING! SConAppInstaller was not on idle state!");
            iQueue->CompleteTask( aTaskId, KErrInUse );
            TRACE_FUNC_EXIT;
            return;
            }
        
        
        iCurrentTask = aTaskId;
        iQueue->SetTaskProgress( aTaskId, KSConCodeProcessingStarted );
        
        switch( task->GetServiceId() )
            {
            case EInstall :
                iQueue->ChangeQueueProcessStatus();
                err = iSwInstaller.Connect();
                if( err == KErrNone )
                    {
                    TRAP(err, ProcessInstallL( *task->iInstallParams ));
                    if( err != KErrNone )
                        {
                        LOGGER_WRITE_1( "StartInstaller ProcessInstallL err: %d", err );
                        iStatus = KRequestPending;
                        SetActive();
                        status = &iStatus;
                        User::RequestComplete( status, err );
                        }
                    }
                
                break;
            case EUninstall :
                iQueue->ChangeQueueProcessStatus();
                err = iSwInstaller.Connect();
                if( err == KErrNone )
                    {
                    LOGGER_WRITE( "Begin to uninstall.. " );
                    
                    TRAP( err, ProcessUninstallL( *task->iUninstallParams ) );
                    if( err != KErrNone )
                        {
                        LOGGER_WRITE_1( "StartInstaller ProcessUninstallL err: %d", err );
                        iStatus = KRequestPending;
                        SetActive();
                        status = &iStatus;
                        User::RequestComplete( status, err );
                        }
                    }
                
                break;
            case EListInstalledApps :
                iQueue->ChangeQueueProcessStatus();
                iStatus = KRequestPending;
                SetActive();
                TRAP( err, ProcessListInstalledAppsL() );
                status = &iStatus;
                User::RequestComplete( status, err );
                break;
            default :
                break;
            }
        }
    TRACE_FUNC_EXIT;
    }

// -----------------------------------------------------------------------------
// CSConAppInstaller::StopInstaller( TInt& aTaskId )
// Stops the installer task
// -----------------------------------------------------------------------------
//
void CSConAppInstaller::StopInstaller( TInt& aTaskId )
    {
    TRACE_FUNC_ENTRY;
    //If the task is the current task, cancel it first
    if( iCurrentTask == aTaskId )
        {
        Cancel();
        iSwInstaller.Close();
        }
    TRACE_FUNC_EXIT;
    }

// -----------------------------------------------------------------------------
// TBool CSConAppInstaller::InstallerActive()
// returns installer activity status
// -----------------------------------------------------------------------------
//
TBool CSConAppInstaller::InstallerActive() const
    {
    return IsActive();
    }

// -----------------------------------------------------------------------------
// CSConAppInstaller::DoCancel()
// Implementation of CActive::DoCancel()
// -----------------------------------------------------------------------------
//
void CSConAppInstaller::DoCancel()
    {
    TRACE_FUNC_ENTRY;
    
    LOGGER_WRITE("Cancel iSwInstaller");
    iSwInstaller.CancelOperation();
    /*
    // find and complete current task
    CSConTask* task = NULL;
    TInt ret = iQueue->GetTask( iCurrentTask, task );

    if ( iCurrentTask > 0 && ret != KErrNotFound )
        {

        switch( task->GetServiceId() )
            {
            case EInstall :
                iQueue->CompleteTask( iCurrentTask, KErrCancel );
                break;
            case EUninstall :
                iQueue->CompleteTask( iCurrentTask, KErrCancel );
                break;
            default :
                break;
            }
        }
        */
    TRACE_FUNC_EXIT;
    }

// -----------------------------------------------------------------------------
// CSConAppInstaller::RunL()
// Implementation of CActive::RunL()
// -----------------------------------------------------------------------------
//
void CSConAppInstaller::RunL()
    {
    TRACE_FUNC_ENTRY;
    iSwInstaller.Close();
    iQueue->ChangeQueueProcessStatus();
    TInt err( iStatus.Int() );
    LOGGER_WRITE_1( "CSConAppInstaller::RunL() iStatus.Int() : returned %d", err );
    
    CSConTask* task = NULL;
    TInt taskErr = iQueue->GetTask( iCurrentTask, task );
    if( taskErr == KErrNone )
        {
        if ( task->GetServiceId() == EInstall || task->GetServiceId() == EUninstall )
            {
            TRAPD(dataErr, WriteTaskDataL( *task ));
            if (dataErr)
                {
                LOGGER_WRITE_1("WriteTaskDataL err: %d", dataErr);
                }
            }
        
        if( task->GetServiceId() == EInstall && err == KErrNone )
            {
            LOGGER_WRITE( "CSConAppInstaller::RunL() : before DeleteFile" );
            //delete sis after succesfull install
            DeleteFile( task->iInstallParams->iPath );
            }
        }
    
    iQueue->CompleteTask( iCurrentTask, err );
    TRACE_FUNC_EXIT;
    }

// -----------------------------------------------------------------------------
// CSConAppInstaller::WriteTaskDataL()
// Writes data to task
// -----------------------------------------------------------------------------
//
void CSConAppInstaller::WriteTaskDataL( CSConTask& aTask )
    {
    TRACE_FUNC_ENTRY;
    CBufFlat* buffer = CBufFlat::NewL(200);
    CleanupStack::PushL(buffer);
    RBufWriteStream stream( *buffer );
    CleanupClosePushL( stream );
    
    ExternalizeResultArrayIntValL( KSifOutParam_ComponentId , stream);
    ExternalizeResultIntValL( KSifOutParam_ErrCategory , stream);
    ExternalizeResultIntValL( KSifOutParam_ErrCode , stream);
    ExternalizeResultIntValL( KSifOutParam_ExtendedErrCode , stream);
    ExternalizeResultStringValL( KSifOutParam_ErrMessage , stream);
    ExternalizeResultStringValL( KSifOutParam_ErrMessageDetails , stream);
    
    stream.CommitL();
    
    buffer->Compress();
    
    HBufC8* data = HBufC8::NewL( buffer->Size() );
    TPtr8 dataPtr = data->Des();
    buffer->Read( 0, dataPtr, buffer->Size() );
    
    if ( aTask.GetServiceId() == EInstall )
        {
        if ( aTask.iInstallParams->iData )
            {
            delete aTask.iInstallParams->iData;
            aTask.iInstallParams->iData = NULL;
            }
        aTask.iInstallParams->iData = data;
        data = NULL;
        }
    else if ( aTask.GetServiceId() == EUninstall )
        {
        if ( aTask.iUninstallParams->iData )
            {
            delete aTask.iUninstallParams->iData;
            aTask.iUninstallParams->iData = NULL;
            }
        aTask.iUninstallParams->iData = data;
        data = NULL;
        }
    else
        {
        delete data;
        data = NULL;
        }
    
    CleanupStack::PopAndDestroy( &stream );
    CleanupStack::PopAndDestroy( buffer );
    TRACE_FUNC_EXIT;
    }

void CSConAppInstaller::ExternalizeResultArrayIntValL( const TDesC& aName, RWriteStream& aStream )
    {
    TRACE_FUNC_ENTRY;
    RArray<TInt> valueArray;
    TRAPD(err, valueArray = iSifResults->IntArrayByNameL(aName));
    if ( !err && valueArray.Count() > 0 )
        {
        LOGGER_WRITE_1("count: %d", valueArray.Count());
        TBuf8<100> nameBuf;
        err = CnvUtfConverter::ConvertFromUnicodeToUtf8( nameBuf, aName );
        if (!err)
            {
            LOGGER_WRITE("2");
            aStream.WriteL( nameBuf, nameBuf.Length() );
            aStream.WriteL( KValSep, 1 );
            aStream.WriteInt32L( valueArray[0] );
            for (TInt i=1; i<valueArray.Count(); i++)
                {
                aStream.WriteL( KComma, 1 );
                aStream.WriteInt32L( valueArray[i] );
                }
            aStream.WriteL( KLineEnd, 2 );
            }
        }
    TRACE_FUNC_EXIT;
    }
// -----------------------------------------------------------------------------
// CSConAppInstaller::ExternalizeResultIntValL()
// Read integer value and write it to stream
// -----------------------------------------------------------------------------
//
void CSConAppInstaller::ExternalizeResultIntValL( const TDesC& aName, RWriteStream& aStream )
    {
    TRACE_FUNC_ENTRY;
    TInt value;
    TBool found(EFalse);
    found = iSifResults->GetIntByNameL(aName, value);

    if (found)
        {
        TBuf8<100> nameBuf;
        TInt err = CnvUtfConverter::ConvertFromUnicodeToUtf8( nameBuf, aName );
        if (!err)
            {
            aStream.WriteL( nameBuf, nameBuf.Length() );
            aStream.WriteL( KValSep, 1 );
            aStream.WriteInt32L( value );
            aStream.WriteL( KLineEnd, 2 );
            }
        }
    TRACE_FUNC_EXIT;
    }

// -----------------------------------------------------------------------------
// CSConAppInstaller::ExternalizeResultStringValL()
// Read string value and write it to stream
// -----------------------------------------------------------------------------
//
void CSConAppInstaller::ExternalizeResultStringValL( const TDesC& aName, RWriteStream& aStream )
    {
    TRACE_FUNC_ENTRY;
    const TDesC& strValue = iSifResults->StringByNameL( aName );
    if (strValue.Length() > 0)
        {
        TBuf8<100> nameBuf;
        TInt err = CnvUtfConverter::ConvertFromUnicodeToUtf8( nameBuf, aName );
        if (!err)
            {
            HBufC8* nameVal = CnvUtfConverter::ConvertFromUnicodeToUtf8L( strValue );
            CleanupStack::PushL( nameVal );
            aStream.WriteL( nameBuf, nameBuf.Length() );
            aStream.WriteL( KValSep, 1 );
            aStream.WriteL( nameVal->Des(), nameVal->Length() );
            aStream.WriteL( KLineEnd, 2 );
            CleanupStack::PopAndDestroy( nameVal );
            }
        }
    TRACE_FUNC_EXIT;
    }

// -----------------------------------------------------------------------------
// CSConAppInstaller::ProcessInstallL()
// Executes Install task
// -----------------------------------------------------------------------------
//
void CSConAppInstaller::ProcessInstallL( const CSConInstall& aInstallParams )
    {
    TRACE_FUNC_ENTRY;
    iSifOptions->Cleanup();
    iSifResults->Cleanup();
    
    if ( aInstallParams.iMode == ESilentInstall )
        {
        LOGGER_WRITE( "Begin silent installation.. " );
        
        iSifOptions->AddIntL( Usif::KSifInParam_InstallSilently, ETrue );
        iSifOptions->AddIntL( Usif::KSifInParam_PerformOCSP, EFalse );   
        // Note if upgrade is allowed, see NeedsInstallingL function.
        iSifOptions->AddIntL( Usif::KSifInParam_AllowUpgrade, ETrue );
        iSifOptions->AddIntL( Usif::KSifInParam_AllowUntrusted, EFalse );
        iSifOptions->AddIntL( Usif::KSifInParam_GrantCapabilities, EFalse ); 
        // Defined for the install.
        iSifOptions->AddIntL( Usif::KSifInParam_InstallOptionalItems, ETrue );          
        iSifOptions->AddIntL( Usif::KSifInParam_IgnoreOCSPWarnings, ETrue );            
        iSifOptions->AddIntL( Usif::KSifInParam_AllowAppShutdown, ETrue );
        iSifOptions->AddIntL( Usif::KSifInParam_AllowDownload, ETrue );
        iSifOptions->AddIntL( Usif::KSifInParam_AllowOverwrite, ETrue );

        iSwInstaller.Install( aInstallParams.iPath, *iSifOptions,
                *iSifResults, iStatus, ETrue );
        }
    else
        {
        LOGGER_WRITE( "Begin to install.. " );
        
        iSwInstaller.Install( aInstallParams.iPath, *iSifOptions,
                *iSifResults, iStatus, ETrue );
        }
    SetActive();
    TRACE_FUNC_EXIT;
    }

// -----------------------------------------------------------------------------
// CSConAppInstaller::ProcessUninstallL( const CSConUninstall& aUninstallParams )
// Executes UnInstall task
// -----------------------------------------------------------------------------
//
void CSConAppInstaller::ProcessUninstallL( const CSConUninstall& aUninstallParams )
    {
    TRACE_FUNC_ENTRY;
    LOGGER_WRITE_1( "aUid: 0x%08x", aUninstallParams.iUid.iUid );
    LOGGER_WRITE_1( "aName: %S", &aUninstallParams.iName );
    LOGGER_WRITE_1( "aVendor: %S", &aUninstallParams.iVendor );
    LOGGER_WRITE_1( "aType: %d", aUninstallParams.iType );
    LOGGER_WRITE_1( "aMode: %d", aUninstallParams.iMode );
    
    if ( aUninstallParams.iUid == KSConSeConUid )
	    {
	    LOGGER_WRITE("Cannot uninstall itself, leave");
	    // cannot uninstall itself
	    User::Leave( KErrInUse ); //SwiUI::KSWInstErrFileInUse );
	    }
    TComponentId componentId = aUninstallParams.iUid.iUid;
    iSifOptions->Cleanup();
    iSifResults->Cleanup();
    
    if ( aUninstallParams.iMode == ESilentInstall)
        {
        iSifOptions->AddIntL( Usif::KSifInParam_InstallSilently, ETrue );
        iSwInstaller.Uninstall( componentId, *iSifOptions, *iSifResults, iStatus, ETrue );
        }
    else
        {
        iSwInstaller.Uninstall( componentId, *iSifOptions, *iSifResults, iStatus, ETrue );
        }
    SetActive();
    TRACE_FUNC_EXIT;
    }
    
//--------------------------------------------------------------------------------
//void CSConAppInstaller::ProcessListInstalledAppsL()
//--------------------------------------------------------------------------------
//
void CSConAppInstaller::ProcessListInstalledAppsL()
    {
    TRACE_FUNC_ENTRY;
    
    CSConTask* task = NULL;
    User::LeaveIfError( iQueue->GetTask( iCurrentTask, task ) );
    
    SConPcdUtility::ProcessListInstalledAppsL( task );
    
    TRACE_FUNC_EXIT;
    }

// -----------------------------------------------------------------------------
// CSConAppInstaller::DeleteFile( const TDesC& aPath )
// Deletes a file 
// -----------------------------------------------------------------------------
//  
void CSConAppInstaller::DeleteFile( const TDesC& aPath )    
    {
    TRACE_FUNC;
    iFs.Delete( aPath );
    }
// End of file