/*

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

* All rights reserved.

* This component and the accompanying materials are made available

* under the terms of the License "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: 

* SisLauncher - session implementation

*

*/

/**

 @file 

 @released

 @internalComponent

*/

#include <s32mem.h>

#ifdef SYMBIAN_UNIVERSAL_INSTALL_FRAMEWORK

#include <ct/rcpointerarray.h>

#include "swtypereginfoparser.h"

#ifndef SWI_TEXTSHELL_ROM

#include <apgcli.h>

#endif

#endif

#include "sislauncherserver.h"

#include "sislaunchersession.h"

#include "sislauncherclientserver.h"

#include "threadmonitor.h"

#include "securitypolicy.h"

#include "sisregistryfiledescription.h"

#include "sislauncherdefs.h"

#include "arrayutils.h"  // from source/sisregistry/common/ 

#include "log.h"

#include "queueprocessor.h"

#ifdef SYMBIAN_UNIVERSAL_INSTALL_FRAMEWORK

#include "apprscparser.h"

#include "ipcutil.h"

#include <usif/scr/appregentries.h>

#include <usif/scr/screntries_platform.h>

#include "sislauncherclient.h" 

#endif

namespace Swi 

{

template <class T>

void DestroyRPointerArray(TAny* aPtr)

    {

    RPointerArray<T>* self = static_cast<RPointerArray<T>*> (aPtr);

    self->ResetAndDestroy();

    delete self;

    }

template <>

class TTraits<TDesC>

    {

public:

    static TDesC* CopyLC(const TDesC& aOther) { return aOther.AllocLC(); }

    static TDesC* ReadFromStreamLC(RReadStream& aStream) { return HBufC::NewLC(aStream, KMaxTInt); }

    static void WriteToStreamL(const TDesC& aItem, RWriteStream& aStream) { aStream << aItem; }

    };

CSisLauncherSession::CSisLauncherSession()

    {

    }

void CSisLauncherSession::CreateL()

    {

    Server().AddSession();

    }

CSisLauncherSession::~CSisLauncherSession()

    {

    #ifdef SYMBIAN_UNIVERSAL_INSTALL_FRAMEWORK

    delete iCurrentAppRegData;

    #endif

    Server().DropSession();

    }

void CSisLauncherSession::DoRunExecutableL(const RMessage2& aMessage) 

    {

    TFileName filename;

    aMessage.ReadL(0, filename);

    TBool wait;

    TPckg <TBool> waitPckg(wait);

    aMessage.ReadL(1, waitPckg);

    Server().RunExecutableL(filename, wait);

    aMessage.Complete(KErrNone);

    }

void CSisLauncherSession::DoStartDocumentL(const RMessage2& aMessage)

    {

    TFileName filename;

    aMessage.ReadL(0, filename);

    TBool wait;

    TPckg <TBool> waitPckg(wait);

    aMessage.ReadL(1, waitPckg);

    if (Server().BootUpMode() == KTextShell) 

        {

        // emulator tests running in textshell or in textshell ROM (#def SWI_TEXTSHELL_ROM)

        DEBUG_PRINTF2(_L8("Sis Launcher Server - textshell - skipping start document by file handle. wait = %d"), wait);    

        }

    else

        { 

        // emulatore running with GUI

        #ifndef SWI_TEXTSHELL_ROM

            Server().StartDocumentL(filename, wait);

        #endif

        }

    aMessage.Complete(KErrNone);    

    }

void CSisLauncherSession::DoStartDocumentByHandleL(const RMessage2& aMessage)

    {

    RFile file;

    file.AdoptFromClient(aMessage, 0, 1);

    CleanupClosePushL(file);

    TBool wait;

    TPckg <TBool> waitPckg(wait);

    aMessage.ReadL(2, waitPckg);

    if (Server().BootUpMode() == KTextShell)

        {

        // emulator tests running in textshell or in textshell ROM (#def SWI_TEXTSHELL_ROM)

        DEBUG_PRINTF3(_L8("Sis Launcher Server - textshell - skipping start document %S, wait = %d"),

                &file, wait);

        }

    else

        {

        // emulatore running with GUI

#ifndef SWI_TEXTSHELL_ROM

        Server().StartDocumentL(file, wait);

#endif

        }

    CleanupStack::PopAndDestroy(&file);

    aMessage.Complete(KErrNone);

}

void CSisLauncherSession::DoStartByMimeL(const RMessage2& aMessage)

    {

    TFileName filename;

    aMessage.ReadL(0, filename);

    TInt srcLen = aMessage.GetDesLengthL(1);

    HBufC8* mimeType = HBufC8::NewLC(srcLen);

    TPtr8 ptr(mimeType->Des());

    aMessage.ReadL(1, ptr);

    TBool wait;

    TPckg <TBool> waitPckg(wait);

    aMessage.ReadL(2, waitPckg);

    if (Server().BootUpMode() == KTextShell) 

        {

        // emulator tests running in textshell or in textshell ROM (#def SWI_TEXTSHELL_ROM)

        DEBUG_PRINTF3(_L8("Sis Launcher Server - textshell - skipping start document by file handle mimetype %S, wait = %d"),

                mimeType, wait);    

        }

    else

        {

        // emulatore running with GUI

#ifndef SWI_TEXTSHELL_ROM

        Server().StartByMimeL(filename, *mimeType, wait);

#endif

        }       

    CleanupStack::PopAndDestroy(mimeType);

    aMessage.Complete(KErrNone);

    }

void CSisLauncherSession::DoStartByMimeByHandleL(const RMessage2& aMessage)

    {

    RFile file;

    file.AdoptFromClient(aMessage, 0, 1);           

    CleanupClosePushL(file);

    TInt srcLen = aMessage.GetDesLengthL(2);

    HBufC8* mimeType = HBufC8::NewLC(srcLen);

    TPtr8 ptr(mimeType->Des());

    aMessage.ReadL(2, ptr);

    TBool wait;

    TPckg <TBool> waitPckg(wait);

    aMessage.ReadL(3, waitPckg);

    if (Server().BootUpMode() == KTextShell) 

        {

        // emulator tests running in textshell or in textshell ROM (#def SWI_TEXTSHELL_ROM)

        DEBUG_PRINTF4(_L("Sis Launcher Server - textshell - skipping launch of document %S, mimetype %s, wait %d"),

                &file, mimeType, wait);

        }

    else

        {

        // emulatore running with GUI

#ifndef SWI_TEXTSHELL_ROM

        Server().StartByMimeL(file, *mimeType, wait);

#endif

        }       

    CleanupStack::PopAndDestroy(mimeType);

    CleanupStack::PopAndDestroy(&file);

    aMessage.Complete(KErrNone);

    }

void CSisLauncherSession::ServiceL(const RMessage2& aMessage)

    {

    DEBUG_PRINTF2(_L8("Sis Launcher Server - Servicing Message %d"), aMessage.Function());

    switch (aMessage.Function())

        {

        case ERunExecutable:

            DoRunExecutableL(aMessage);

            break;

        case EStartDocument:

            DoStartDocumentL(aMessage);         

            break;

        case EStartDocumentByHandle:

            DoStartDocumentByHandleL(aMessage);

            break;  

        case EStartByMime:

            DoStartByMimeL(aMessage);

            break;

        case EStartByMimeByHandle:

            DoStartByMimeByHandleL(aMessage);

            break;

        case EShutdown:

            {

            TInt srcLen=aMessage.GetDesLengthL(0);

            HBufC8* uidBuffer = HBufC8::NewLC(srcLen);

            TPtr8 uidPtr = uidBuffer->Des();

            aMessage.ReadL(0, uidPtr, 0);

            TUint8* dataPtr=const_cast<TUint8*>(uidPtr.Ptr());

            TUid* tUidPtr=reinterpret_cast<TUid*>(dataPtr);

            TInt8 uidCount=srcLen/sizeof(TUid);

            TInt shutdownTimeout = aMessage.Int1();

            if (Server().BootUpMode() == KTextShell) 

                {

                // emulator tests running in textshell or in textshell ROM (#def SWI_TEXTSHELL_ROM)

                DEBUG_PRINTF(_L8("Sis Launcher Server - textshell - skipping graceful shutdown of GUI applications"));

                }

            else

                {

                // emulatore running with GUI

                #ifndef SWI_TEXTSHELL_ROM

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

                        {

                        // graceful shutdown

                        Server().ShutdownL(tUidPtr[i], shutdownTimeout);    

                        }

                #endif

                }

            // Having tried graceful shutdown, we need to kill any remaining processes

            // matching the SID.  Note that killing a process may re-order the list of

            // remaining processes, so the search must start from the top again.

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

                {

                Server().ForceShutdownL(tUidPtr[i]);

                }           

            CleanupStack::PopAndDestroy(uidBuffer);

            aMessage.Complete(KErrNone);

            break;

            }

        case EShutdownAll:

            {

            if (Server().BootUpMode() == KTextShell) 

                {

                // emulator tests running in textshell or in textshell ROM (#def SWI_TEXTSHELL_ROM)

                DEBUG_PRINTF(_L8("Sis Launcher Server - textshell - skipping shutdown of user applications"));  

                }

            else

                {

                // emulatore running with GUI

                #ifndef SWI_TEXTSHELL_ROM

                Server().ShutdownL();

                #endif

                }

            aMessage.Complete(KErrNone);

            break;  

            }

        case ECheckApplicationInUse:

            {

            TInt srcLen=aMessage.GetDesLengthL(0);

            HBufC8* appInUseBuffer = HBufC8::NewLC(srcLen);

            TPtr8 appInUseBufferPtr = appInUseBuffer->Des();    

            aMessage.ReadL(0, appInUseBufferPtr, 0);

            TAppInUse* appInUsePtr = (TAppInUse*) User::AllocL(srcLen);

            CleanupStack::PushL(appInUsePtr);   

            Mem::Copy(appInUsePtr, appInUseBufferPtr.Ptr(), srcLen);

            TUint appInUseCount=srcLen/sizeof(TAppInUse);

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

                {

                TRAPD(err, CheckApplicationInUseL(appInUsePtr[i].iAppUid));

                if (err==KErrInUse)  

                    {

                    appInUsePtr[i].iInUse=ETrue;

                    }            

                }   

            TUint8* dataPtr=reinterpret_cast<TUint8*>(appInUsePtr);

            const TPtrC8 data(dataPtr, srcLen); 

            //Indicate the client apps in use

            aMessage.WriteL(0, data);                           

            aMessage.Complete(KErrNone);

            CleanupStack::PopAndDestroy(appInUsePtr);

            CleanupStack::PopAndDestroy(appInUseBuffer);    

            break;

            }

        case ENotifyNewApps:

            {

            TInt size = aMessage.GetDesLengthL(0);

            HBufC8* buf = HBufC8::NewLC(size);

            TPtr8 bufPtr = buf->Des();

            aMessage.ReadL(0, bufPtr);

            RDesReadStream stream(*buf);

            RPointerArray<TDesC> files;

            InternalizePointerArrayL(files, stream);

            if (Server().BootUpMode() == KTextShell) 

                {

                // emulator tests running in textshell or in textshell ROM (#def SWI_TEXTSHELL_ROM)

                DEBUG_PRINTF(_L8("Sis Launcher Server - TextShell - skipping notification of new applications (ENotifyNewApps)."));

                }

            else

                {

                // emulatore running with GUI

                #ifndef SWI_TEXTSHELL_ROM

                Server().NotifyNewAppsL(files);

                #endif // SWI_TEXTSHELL_ROM

                }

            files.ResetAndDestroy();

            CleanupStack::PopAndDestroy(buf);

            aMessage.Complete(KErrNone);

            break;

            }

        case EParseSwTypeRegFile:

            #ifndef SWI_TEXTSHELL_ROM

            ParseSwTypeRegFileL(aMessage);

            #endif

            aMessage.Complete(KErrNone);

            break;

        case ERegisterSifLauncherMimeTypes:

            #ifndef SWI_TEXTSHELL_ROM

            RegisterSifLauncherMimeTypesL(aMessage);

            #endif

            aMessage.Complete(KErrNone);

            break;

        case EUnregisterSifLauncherMimeTypes:

            UnregisterSifLauncherMimeTypesL(aMessage);

            #endif

            aMessage.Complete(KErrNone);

            break;

        case EAsyncParseResourceFileSize:

            {

            TRAPD(err,err = AsyncParseResourceFileSizeL(aMessage));            

            aMessage.Complete(err);            

            break;

            }

        case EAsyncParseResourceFileData:

            {

            TRAPD(err,AsyncParseResourceFileDataL(aMessage));

            aMessage.Complete(err);

            break;

            }

        case ENotifyNewAppsData:

            {

            RIpcReadStream readStream;

            readStream.Open(aMessage, 0);

            CleanupClosePushL(readStream);

            RPointerArray<Usif::CApplicationRegistrationData> appRegInfo;

            CleanupClosePushL(appRegInfo);

            const TInt numElems = readStream.ReadInt32L();

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

                {

                Usif::CApplicationRegistrationData* info = Usif::CApplicationRegistrationData::NewL(readStream);

                CleanupStack::PushL(info);

                appRegInfo.AppendL(info);

                CleanupStack::Pop(info);

                }

            if (Server().BootUpMode() == KTextShell) 

                {

                // emulator tests running in textshell or in textshell ROM (#def SWI_TEXTSHELL_ROM)

                DEBUG_PRINTF(_L8("Sis Launcher Server - TextShell - Skipping notification of force registered applications."));

                }

            else

                {

                // emulatore running with GUI

                #ifndef SWI_TEXTSHELL_ROM

                Server().NotifyNewAppsL(appRegInfo);

                #endif // SWI_TEXTSHELL_ROM

                }

            appRegInfo.ResetAndDestroy();

            CleanupStack::PopAndDestroy(2);

            aMessage.Complete(KErrNone);

            break;

            }

        case ENotifyApparcForApps:

            {

            if (Server().BootUpMode() == KTextShell) 

                {

                DEBUG_PRINTF(_L8("Sis Launcher Server - TextShell - Skipping notification of applications (ENotifyApparcForApps)."));

                }

            else

                {

                #ifndef SWI_TEXTSHELL_ROM

                NotifyApparcForAppsL(aMessage);  

                #endif

                }

            aMessage.Complete(KErrNone);

            break;

            }

#endif // SYMBIAN_UNIVERSAL_INSTALL_FRAMEWORK

        case EQueueRunExecutable:

            //fall through

        case EQueueStartDocumentByHandle:

            //fall through

        case EQueueStartByMimeByHandle:

            Server().RunQueue().AddToQueueL(aMessage);

            aMessage.Complete(KErrNone);

            break;

        case EExecuteQueue:

            aMessage.Complete(Server().RunQueue().ExecuteQueue());

            break;

        case EKillQueue:

            Server().RunQueue().ResetQueue();

            aMessage.Complete(KErrNone);

            break;

        default:

            {

            PanicClient(aMessage,EPanicIllegalFunction);

            break;

            }

        }

    }

void CSisLauncherSession::ServiceError(const RMessage2& aMessage,TInt aError)

    {

    DEBUG_PRINTF2(_L8("Sis Launcher Server - ServiceL failed with error code %d."), aError);

    if (aError==KErrBadDescriptor)

        {

        PanicClient(aMessage,EPanicBadDescriptor);

        }

    CSession2::ServiceError(aMessage,aError);

    }

void CSisLauncherSession::CheckApplicationInUseL(TUid aUid)

    {

    TFindProcess findProcess;

    TFullName fullName;

    while(findProcess.Next(fullName) == KErrNone)

        {

        RProcess process;

        User::LeaveIfError(process.Open(findProcess));

        TUid sid(process.SecureId());

        TExitType exitType = process.ExitType();

        process.Close();

        if (sid == aUid && exitType == EExitPending)

                    User::Leave(KErrInUse);