* Copyright (c) 2004-2010 Nokia Corporation and/or its subsidiary(-ies).

#include "cleanuputils.h"

//Temporary error logging solution.

void LogSwiErrorsToFileL(TInt aErrorCode, const TDesC& aAppName);

    {

    InternalCancelHandler(CUissClientHandler& aUissClientHandler);

    void HandleCancel();

    CUissClientHandler& iUissClientHandler;

    };

    CUissClientHandler& aUissClientHandler)

:   iUissClientHandler(aUissClientHandler)

    {

    }

    {

    iUissClientHandler.CancelOperation();

    }

    {

    CUissClientHandler* self=new(ELeave) CUissClientHandler(aUiHandler, aActiveObjectMode);

    CleanupStack::PushL(self);

    self->ConstructL();

    return self;

    }

    {

    CUissClientHandler* self=NewLC(aUiHandler, aActiveObjectMode);

    CleanupStack::Pop(self);

    return self;

    }

          iPtrIntoBuf(0,0),

          iPtrIntoArgsStream(0,0)

          #ifdef SYMBIAN_UNIVERSAL_INSTALL_FRAMEWORK

          ,iCompInfoBufPtr(0,0)

          #endif

    {

        {

        CActiveScheduler::Add(this);

        }

    }

    {   

    if(iSisHelper.Handle() > 0)

        {

        TRequestStatus reqStatus;

        iSisHelper.Logon(reqStatus);

        User::WaitForRequest(reqStatus);

        iSisHelper.Close();

        }       

    }

    {

    //Cancel any outstanding request

    CancelOperation();

    WaitForSisHelperShutdown();

        {

        CActive::Cancel(); // Make sure we are cancelled before deletion

        }

    delete iCancelHandler;

    iUissSession.Close();

    delete iBuf;

    delete iBufLogger;

    #ifdef SYMBIAN_UNIVERSAL_INSTALL_FRAMEWORK

    #endif

    }

    {

    iCancelHandler=new(ELeave) InternalCancelHandler(*this);

    AllocBufL(KBufSize);// Allocate the initial r/c buffer

	//Logger buffer.

	iBufLogger = KNullDesC8().AllocL();

    User::LeaveIfError(StartUiss()); // Start UISS

    User::LeaveIfError(iUissSession.Connect()); // Connect to UISS

    }

    {

    {

    // Reallocate the buffer to the size received in parameter 1

    TInt size=0;

    TPckg<TInt> theSize(size);

    theSize.Copy(iBuf->Left(sizeof(TInt)));

    AllocBufL(size);

    }

    {

    {

    switch (aCommand)

        {

        case CUissSession::KMessageApplicationsInUseDialog:

            return new(ELeave) CApplicationsInUseDialogCmdHandler(iUiHandler);

        case CUissSession::KMessageCannotOverwriteFileDialog:

            return new(ELeave) CCannotOverwriteFileDialogCmdHandler(iUiHandler);

        case CUissSession::KMessageDependencyBreakDialog:

            return new(ELeave) CDependencyBreakDialogCmdHandler(iUiHandler);

        case CUissSession::KMessageDeviceIncompatibility:

            return new(ELeave) CDeviceIncompatibilityDialogCmdHandler(iUiHandler);

        case CUissSession::KMessageMissingDependency:

            return new(ELeave) CMissingDependencyDialogCmdHandler(iUiHandler);

        case CUissSession::KMessageDriveDialog:

            return new(ELeave) CDriveDialogCmdHandler(iUiHandler);

        case CUissSession::KMessageErrorDialog:

            return new(ELeave) CErrorDialogCmdHandler(iUiHandler);

        case CUissSession::KMessageGrantCapabilitiesDialog:

            return new(ELeave) CGrantCapabilitiesDialogCmdHandler(iUiHandler);  

        case CUissSession::KMessageHandleCancellableInstallEvent:

            return new(ELeave) CHandleCancellableInstallEventCmdHandler(iUiHandler, 

                *iCancelHandler);

        case CUissSession::KMessageHandleInstallEvent:

            return new(ELeave) CHandleInstallEventCmdHandler(iUiHandler);

        case CUissSession::KMessageInstallDialog:

            return new(ELeave) CInstallDialogCmdHandler(iUiHandler);

        case CUissSession::KMessageLanguageDialog:

            return new(ELeave) CLanguageDialogCmdHandler(iUiHandler);

        case CUissSession::KMessageOcspResultDialog:

            return new(ELeave) COcspResultDialogCmdHandler(iUiHandler);

        case CUissSession::KMessageOptionsDialog:

            return new(ELeave) COptionsDialogCmdHandler(iUiHandler);

        case CUissSession::KMessageQuestionDialog:

            return new(ELeave) CQuestionDialogCmdHandler(iUiHandler);

        case CUissSession::KMessageSecurityWarningDialog:

            return new(ELeave) CSecurityWarningDialogCmdHandler(iUiHandler);

        case CUissSession::KMessageUninstallDialog:

            return new(ELeave) CUninstallDialogCmdHandler(iUiHandler);

        case CUissSession::KMessageUpgradeDialog:

            return new(ELeave) CUpgradeDialogCmdHandler(iUiHandler);

        case CUissSession::KMessageTextDialog:

            return new(ELeave) CTextDialogCmdHandler(iUiHandler);

        default:

            return NULL;

        }

    }

    {

    // Stream out install parameters. Cannot do this in UISSCLIENT because 

    // the code is in LAUNCHER which depends on UISSCLIENT.

    iArgsStream = CWriteStream::NewL();

    *iArgsStream << aInstallPrefs;

    iPtrIntoArgsStream.Set(iArgsStream->Ptr()); 

    }

    {

    iPtrIntoBuf.Set(iBuf->Des());

    InitializeArgStreamL(aInstallPrefs);

    iArgsStream->Stream().WriteInt32L(aDeviceSupportedLanguages.Count());

    //Streaming set of languages that device supports

    TInt noOfDeviceSupportedLanguages = aDeviceSupportedLanguages.Count();

    for(TInt i=0;i<noOfDeviceSupportedLanguages;i++)

        {

        iArgsStream->Stream().WriteInt32L(aDeviceSupportedLanguages[i]);

        }

    // Save ptr for args (must persist whilst server is processing)

    iPtrIntoArgsStream.Set(iArgsStream->Ptr()); 

        {

        SetActive();

        }

    }

    {    

    InitializeArgStreamL(aInstallPrefs);

    AllocCompInfoBufL(KCompInfoBufferSize); 

    // Save the pointer for component info collection buffer

    iCompInfoBufPtr.Set(iCompInfoBuffer->Des());

    // There is no synchronous API for GetComponentInfo

    __ASSERT_ALWAYS(iActiveObjectMode, User::Invariant());

    SetActive();

    iSisHelper = aServer;   

    }

    {

    iArgsStream = CWriteStream::NewL();

    iPtrIntoArgsStream.Set(iArgsStream->Ptr());

    // Issue initial request

        {

        SetActive();

        }

    }

    {

    if (iState == KUissClientIdle)

        {

        return;

        }

    // User called this so must have an outstanding request with us.

    // First tell the Uiss that we want to cancel the current

    // operation.

    //

    // If we have an outstanding Uiss request, this will complete (with

    // KErrCancel) when the operation has terminated.

    //

    // If we are called inside a dialog callback, then there is no

    // outstanding Uiss request at the moment. When the dialog

    // returns, we will issue a request, which will complete (with

    // KErrCancel) when the operation has terminated.

    (void)iUissSession.Cancel();

    }

    {

    // Keep processing UISS responses and issuing new requests

    // until we update the client status to non-pending.

    while(iClientStatus && *iClientStatus == KRequestPending) 

        {

        User::WaitForRequest(iStatus);

        TRAPD(err,RunL());

        if(err != KErrNone)

            {   

            RunError(err);

            }

        }

    }

    {

    return iState != KUissClientIdle;

    }

    {

    const TInt KUissServerStackSize=0x2000;

    const TInt KUissServerInitHeapSize=0x1000;

    const TInt KUissServerMaxHeapSize=0x1000000;

    TThreadFunction entryPoint=UissThreadFunction;

    //TUiSupportStartParams uiSupportParams(aUiHandler);

    // The owner of the new thread will be the process, otherwise if the 

    // current thread dies, the server thread will die, too.

    RThread server;

    TInt err = KErrNone;

    for (TInt retry=0; retry < 2; ++retry)

        {

        err = server.Create(KUissServerName, entryPoint, 

        KUissServerStackSize, KUissServerInitHeapSize, KUissServerMaxHeapSize,

        NULL, EOwnerThread);

        if (err == KErrAlreadyExists)

            {

            User::After(30000); 

            }

        else

            {

            break;

            }

        }

    if (err==KErrAlreadyExists)

        {

        return KErrServerBusy;

        }

    if (err != KErrNone)

        {

        return err;

        }

    // Synchronise with the process to make sure it hasn't died straight away

    TRequestStatus stat;

    server.Rendezvous(stat);

    if (stat != KRequestPending)

        {

        // logon failed - server is not yet running, so cannot have terminated

        server.Kill(0); // Abort startup

        }

    else

        {

        // logon OK - start the server

        server.Resume();

        }

    // Wait to synchronise with server - if it dies in the meantime, it

    // also gets completed

    User::WaitForRequest(stat); 

    // We can't use the 'exit reason' if the server panicked as this

    // is the panic 'reason' and may be '0' which cannot be distinguished

    // from KErrNone

    TInt r=(server.ExitType()==EExitPanic) ? KErrGeneral : stat.Int();

    server.Close();

    return r;

    }

    {

    __UHEAP_MARK;

    CTrapCleanup* cleanup = CTrapCleanup::New(); // get clean-up stack

    CActiveScheduler* scheduler=new(ELeave) CActiveScheduler;

    CActiveScheduler::Install(scheduler);

    CUissServer* server=NULL;

    TRAPD(err, server=CUissServer::NewL());

    if (err==KErrNone)

        {

        RThread::Rendezvous(KErrNone);

        scheduler->Start();

        }

    delete server;

    CActiveScheduler::Install(NULL);

    delete scheduler;

    delete cleanup; // destroy clean-up stack

    __UHEAP_MARKEND;

    return KErrNone;

    }

    iPtrIntoBuf.Set(iBuf->Des()); // Get ptr to our return buffer

    if(err > 0)

        {

		// For Logging purpose, store the buffer to retrieve 

		// application info later.

        delete iBufLogger;

        iBufLogger = 0;

        iBufLogger = iBuf->AllocL();

        }

#ifdef SYMBIAN_UNIVERSAL_INSTALL_FRAMEWORK  

        && iState != KUissClientGettingCompInfo // We don't support overflow management for component info

        )