/*

* Copyright (c) 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:  HtiAppControl implementation

*

*/

// INCLUDE FILES

#include "../../../symbian_version.hrh"

#include <apacmdln.h>

#include <apgtask.h>

#include <apgwgnam.h>

#include <apmstd.h>

#include <badesca.h>

#include <f32file.h>

#include "HtiAppControl.h"

#include <HtiDispatcherInterface.h>

#include <HTILogging.h>

#include <swinstapi.h>

#include <swi/sisregistrysession.h>

#include <swi/sisregistrypackage.h>

#if ( SYMBIAN_VERSION_SUPPORT < SYMBIAN_4 )

    #include <javaregistryincludes.h>

#endif

#include <widgetregistryclient.h>

#if ( SYMBIAN_VERSION_SUPPORT < SYMBIAN_4 )

    using namespace Java;

#endif

// CONSTANTS

const static TUid KAppServiceUid = { 0x1020DEC7 }; //This is Uid of AppServiceOS

//error descriptions

_LIT8( KErrDescrNoMemory, "No memory" );

_LIT8( KErrDescrInvalidCmd, "Invalid command" );

_LIT8( KErrDescrInvalidArguments, "Invalid arguments" );

_LIT8( KErrDescrFailedCreateProcess, "Failed create process" );

_LIT8( KErrDescrNotSupported, "Command not supported" );

_LIT8( KErrDescrFailedStartApp, "Failed start app" );

_LIT8( KErrDescrInvalidUid, "Invalid application uid" );

_LIT8( KErrDescrFailedFindApp, "Failed find app" );

_LIT8( KErrDescrFailedConnectSilentInstaller, "Failed to connect to silent installer" );

_LIT8( KErrDescrFailedInstall, "Failed to install" );

_LIT8( KErrDescrFailedUnInstall, "Failed to uninstall" );

_LIT8( KErrDescrFailedFindPackage, "Failed to find the package" );

_LIT8( KErrDescrFailedListInstApps, "Failed to list installed apps" );

const static TUint8 KUnicodeMask = 0x01;

const static TInt KTerminateReason = 0;

const static TInt KTUintLength = sizeof(TUint);

const static TInt KCloseTaskDelay = 250000; // microseconds

// MACROS

// LOCAL CONSTANTS AND MACROS

// MODULE DATA STRUCTURES

// LOCAL FUNCTION PROTOTYPES

// FORWARD DECLARATIONS

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

CHtiAppControl* CHtiAppControl::NewL()

    {

    CHtiAppControl* self = new ( ELeave ) CHtiAppControl;

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop();

    return self;

    }

// Constructor

CHtiAppControl::CHtiAppControl():iIsAppCmdsSupported( EFalse )

    {

    }

EXPORT_C CHtiAppControl* NewHtiAppControl()

    {

    return CHtiAppControl::NewL();

    }

CHtiAppControl::~CHtiAppControl()

    {

    HTI_LOG_FUNC_IN( "~CHtiAppControl" );

    for ( TInt i = 0; i < iProcessHandleArray.Count(); i++ )

        {

        iProcessHandleArray[i].Close();

        }

    iProcessHandleArray.Close();

    iAppServer.Close();

    iWs.Close();

    if ( iMimeTypes )

        {

        iMimeTypes->Reset();

        delete iMimeTypes;

        }

    iAugmentations.ResetAndDestroy();

    HTI_LOG_FUNC_OUT( "~CHtiAppControl" );

    }

// Second phase construction.

void CHtiAppControl::ConstructL()

    {

    HTI_LOG_FUNC_IN( "CHtiAppControl::ConstructL" );

    iMimeTypes = new (ELeave) CDesC8ArrayFlat( 8 );

    iMimeTypes->AppendL( SwiUI::KSisxMimeType() );

    iMimeTypes->AppendL( SwiUI::KSisMimeType() );

    iMimeTypes->AppendL( SwiUI::KPipMimeType() );

    iMimeTypes->AppendL( SwiUI::KJadMIMEType() );

    iMimeTypes->AppendL( SwiUI::KJarMIMEType() );

    iMimeTypes->AppendL( SwiUI::KJavaMIMEType() );

    iMimeTypes->AppendL( SwiUI::KJarxMIMEType() );

    iMimeTypes->AppendL( KWidgetMime() ); // from widgetregistryconstants.h

    iAugmentationIndex = 0;

    TInt err = iAppServer.Connect();

    if ( err == KErrNone )

        {

        err = iWs.Connect();

        }

    if ( err == KErrNone )

        {

        iIsAppCmdsSupported = ETrue;

        }

    else

        {

        iAppServer.Close();

        }

    HTI_LOG_FUNC_OUT( "CHtiAppControl::ConstructL" );

    }

TInt CHtiAppControl::ParseString( const TDesC8& aRequest,

                                        TInt anOffset,

                                        TBool aUnicode,

                                        TDes& aResult )

    {

    HTI_LOG_FUNC_IN( "CHtiAppControl::ParseString" );

    //validate parameters

    //if offset outside the string return empty string

    if ( anOffset >= aRequest.Size() )

        {

        return anOffset;

        }

    TInt len = aRequest[anOffset];

    HTI_LOG_FORMAT( "length %d", len );

    if ( len > aResult.MaxLength() )

        {

        return KErrBadDescriptor;

        }

    TInt nextOffset = ( aUnicode ? len * 2 : len ) + anOffset + 1;

    HTI_LOG_FORMAT( "nextOffset %d", nextOffset );

    HTI_LOG_FORMAT( "reqSize %d", aRequest.Size() );

    if ( nextOffset > aRequest.Size() )

        {

        return KErrArgument;

        }

    if ( aUnicode )

        {

        const TPtrC8 aFrom( aRequest.Mid( anOffset + 1, len * 2 ) );

        aResult.SetLength( len );

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

            {

            aResult[i] = ( TUint16 ) aFrom[i << 1] +

                ( ( ( TUint16 ) aFrom[( i << 1 ) + 1] ) << 8 );

            }

        }

    else

        {

        aResult.Copy( aRequest.Mid( anOffset + 1, len ) );

        }

    HTI_LOG_FUNC_OUT( "CHtiAppControl::ParseString" );

    return nextOffset;

    }

void CHtiAppControl::ProcessMessageL( const TDesC8& aMessage,

                THtiMessagePriority /*aPriority*/ )

    {

    HTI_LOG_FUNC_IN( "CHtiAppControl::ProcessMessage" );

    if ( aMessage.Length() < 1 )

        {

        // no command

        SendErrorMsg( KErrArgument, KErrDescrInvalidCmd );

        return;

        }

    if ( aMessage.Length() < 2 &&

         aMessage[0] !=  EListInstalledApps &&

         aMessage[0] !=  EListInstalledApps_u)

        {

         // parameter is required with all commands except

         // listing processes or installed applications

        SendErrorMsg( KErrArgument, KErrDescrInvalidCmd );

        return;

        }

    HTI_LOG_FORMAT( "cmd %d", aMessage[0] );

    if ( aMessage[0] > EProcessLastCommand &&

              aMessage[0] < EAppLastCommand)

        {

        if ( iIsAppCmdsSupported )

            {

            HandleAppControlL( aMessage );

            }

        else

            {

            SendErrorMsg( KErrNotSupported, KErrDescrNotSupported );

            }

        }

    else if ( aMessage[0] > EAppLastCommand &&

              aMessage[0] < ESisLastCommand )

        {

        HandleInstallerControlL( aMessage );

        }

    else

        {

        SendErrorMsg( KErrArgument, KErrDescrInvalidCmd );

        }

    HTI_LOG_FUNC_OUT( "CHtiAppControl::ProcessMessage" );

    }

void CHtiAppControl::HandleAppControlL( const TDesC8& aMessage )

    {

    HTI_LOG_FUNC_IN( "CHtiAppControl::HandleAppControl" );

    TBool unicode = aMessage[0] & KUnicodeMask;

    HTI_LOG_FORMAT( "unicode %d", unicode );

    TApaAppInfo appInfo;

    TFileName appName;

    TFileName docName;

    switch ( aMessage[0] )

        {

        case EStartApp_uid:

        case EStartApp_uid_u:

            {

            TPtrC8 parameters = aMessage.Mid( 1 );

            if ( parameters.Length() >= 4 )

                {

                TInt32 uid = Parse32<TInt32>( parameters );

                TInt offset = ParseString( parameters, 4, unicode, docName );

                if ( offset >= 0)

                    {

                    if ( FindAppL( appInfo, uid ) )

                        {

                        HandleStartAppL( appInfo, docName );

                        }

                    }

                else

                    {

                    SendErrorMsg( offset , KErrDescrInvalidArguments );

                    }

                }

            else

                {

                SendErrorMsg( KErrArgument , KErrDescrInvalidUid );

                }

            }

            break;

        case EStartApp:

        case EStartApp_u:

            {

            TInt offset = ParseString( aMessage, 1, unicode, appName );

            if ( offset >= 0 )

                {

                offset = ParseString( aMessage, offset, unicode, docName );

                if ( offset >= 0 )

                    {

                    //find appInfo by app full name

                    if ( FindAppL( appInfo, appName ) )

                        {

                        HTI_LOG_TEXT( "call HandleStartAppL" );

                        HandleStartAppL( appInfo, docName );

                        }

                    }

                }

            if ( offset < 0 )

                {

                SendErrorMsg( offset , KErrDescrInvalidArguments );

                }

            }

            break;

        case EStartDoc:

        case EStartDoc_u:

            {

            TInt offset = ParseString( aMessage, 1, unicode, docName );

            if ( offset >= 0 )

                {

                HandleStartAppL( appInfo, docName ); //appInfo is empty

                }

            else

                {

                SendErrorMsg( offset , KErrDescrInvalidArguments );

                }

            }

            break;

        case EStatusApp_uid:

            {

            TPtrC8 appUid8 = aMessage.Mid( 1 );

            if ( appUid8.Length() == 4 )

                {

                TApaTaskList tl( iWs );

                TInt32 appUid = Parse32<TInt32>( appUid8 );

                TApaTask task = tl.FindApp( TUid::Uid( appUid ) );

                if ( task.Exists() )

                    {

                    SendMessageL( ERunning );

                    }

                else

                    {

                    SendMessageL( ENotFound );

                    }

                }

            else

                {

                SendErrorMsg( KErrArgument, KErrDescrInvalidUid );

                }

            }

            break;

        case EStatusApp:

        case EStatusApp_u:

            {

            TInt offset = ParseString( aMessage, 1, unicode, appName );

            if ( offset >= 0 )

                {

                TApaTaskList tl( iWs );

                TApaTask task = tl.FindApp( appName );

                if ( task.Exists() )

                    {

                    SendMessageL( ERunning );

                    break; // we are done

                    }

                // Maybe the user gave path or filename instead of caption

                if ( FindAppL( appInfo, appName ) )

                    {

                    TApaTask task2 = tl.FindApp( appInfo.iUid );

                    if ( task2.Exists() )

                        {

                        SendMessageL( ERunning );

                        }

                    else

                        {

                        SendMessageL( ENotFound );

                        }

                    }

                // If app was not found by FindAppL method, a response message

                // has already been sent there - no need to send anything here.

                }

            else

                {

                SendErrorMsg( offset , KErrDescrInvalidArguments );

                }

            }

            break;

        case EStatusDoc:

        case EStatusDoc_u:

            {

            TInt offset = ParseString( aMessage, 1, unicode, docName );

            if ( offset >= 0 )

                {

                TApaTaskList tl( iWs );

                TApaTask task = tl.FindDoc( docName );

                if ( task.Exists() )

                    {

                    SendMessageL( ERunning );

                    }

                else

                    {

                    SendMessageL( ENotFound );

                    }

                }

            else

                {

                SendErrorMsg( offset , KErrDescrInvalidArguments );

                }

            }

            break;

        case EStopApp:

        case EStopApp_u:

            {

            TInt offset = ParseString( aMessage, 1, unicode, appName );

            if ( offset >= 0 )

                {

                TApaTaskList tl( iWs );

                TApaTask task = tl.FindApp( appName );

                if ( task.Exists() )

                    {

                    task.EndTask();

                    User::After( KCloseTaskDelay );

                    TApaTask task = tl.FindApp( appName );

                    if ( task.Exists() )

                        {

                        task.KillTask();

                        }

                    SendMessageL( EOk );

                    break; // we are done

                    }

                // Maybe the user gave path or filename instead of caption

                if ( FindAppL( appInfo, appName ) )

                    {

                    TApaTask task2 = tl.FindApp( appInfo.iUid );

                    if ( task2.Exists() )

                        {

                        task2.EndTask();

                        User::After( KCloseTaskDelay );

                        TApaTask task2 = tl.FindApp( appInfo.iUid );

                        if ( task2.Exists() )

                            {

                            task2.KillTask();

                            }

                        SendMessageL( EOk );

                        }

                    else

                        {

                        SendMessageL( ENotFound );

                        }

                    }

                // If app was not found by FindAppL method, a response message

                // has already been sent there - no need to send anything here.

                }

            else

                {

                SendErrorMsg( offset , KErrDescrInvalidArguments );

                }

            }

            break;

        case EStopDoc:

        case EStopDoc_u:

            {

            TInt offset = ParseString( aMessage, 1, unicode, docName );

            if ( offset >= 0 )

                {

                TApaTaskList tl( iWs );

                TApaTask task = tl.FindDoc( docName );

                if ( task.Exists() )

                    {

                    task.EndTask();

                    User::After( KCloseTaskDelay );

                    TApaTask task = tl.FindDoc( docName );

                    if ( task.Exists() )

                        {

                        task.KillTask();

                        }

                    SendMessageL( EOk );

                    }

                else

                    {

                    SendMessageL( ENotFound );

                    }

                }

            else

                {

                SendErrorMsg( offset , KErrDescrInvalidArguments );

                }

            }

            break;

        case EStopApp_uid:

            {

            TPtrC8 appUid8 = aMessage.Mid( 1 );

            if ( appUid8.Length() == 4 )

                {

                TApaTaskList tl( iWs );

                TInt32 appUid = Parse32<TInt32>( appUid8 );

                TApaTask task = tl.FindApp( TUid::Uid( appUid ) );

                if ( task.Exists() )

                    {

                    task.EndTask();

                    User::After(KCloseTaskDelay);

                    TApaTask task = tl.FindApp( TUid::Uid( appUid ) );

                    if ( task.Exists() )

                        {

                        task.KillTask();

                        }

                    SendMessageL( EOk );

                    }

                else

                    {

                    SendMessageL( ENotFound );

                    }

                }

            else

                {

                SendErrorMsg( KErrArgument , KErrDescrInvalidUid );

                }

            }

            break;

        case EListApps:

        case EListApps_u:

            {

            if ( aMessage.Length() != 3 )

                {

                SendErrorMsg( KErrArgument, KErrDescrInvalidArguments );