/*

* Copyright (c) 2005-2010 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:  The executable that enables launching OMJ Java

*               applications in S60

*

*/

#include <apacmdln.h>

#include <bacline.h>

#include <e32cmn.h>

#include <s32mem.h>

#include <unistd.h>

#include "commsmessage.h"

#include "commsclientendpoint.h"

#include "exceptionbase.h"

#include "javainifileutils.h"

#include "javaoslayer.h"

#include "javastorage.h"

#include "javastorageentry.h"

#include "javastoragenames.h"

#include "javasymbianoslayer.h"

#include "javauids.h"

#include "logger.h"

#include "rtcmessages.h"

#include "runtimeexception.h"

using namespace java::captain;

using namespace java::storage;

using namespace java::util;

_LIT(KHexValueStart, "0x");

_LIT(KPercentage, "%");

_LIT(KSemiColon, ";");

_LIT(KMidletNameArg, "midlet-name=");

_LIT(KMidletVendorArg, "midlet-vendor=");

_LIT(KMidletNArg, "midlet-n=");

_LIT(KMidletUidArg, "midlet-uid=");

const TInt KExtraLenForLoggingAndPrompting = 22;

const TInt KArgumentValueMaxLen = 1568;  // Support worst case % encoded args of 512 chars

// The Uid of the Web Browser process

#define KBrowserUid 0x10008D39

/**

 * Return the Uid of the application aMidletName in package aPackageId.

 * If aMidletName is empty, return the Uid of the first application in

 * package aPackageId.

 *

 * @param aJs           JavaStorage connection, must be open

 * @param aPackageId    the id of the package

 * @param aMidletId     the numerical id of the desired application in the

 *                      package, can be empty

 * @param aUid          the Uid the found application is returned in this param

 * @return  KErrNone if Uid was found, otherwise one of the Symbian error codes

 * @throws  JavaStorageException if accessing Java Storage fails

 */

static TInt getOneApplicationFromPackage(

    JavaStorage& aJs,

    const std::wstring& aPackageId,

    const std::wstring& aMidletId,

    TInt32 &aUid)

{

    std::wstring midletId = L"MIDlet-";

    if (aMidletId.length() == 0)

    {

        midletId.append(L"1");

    }

    else

    {

        midletId.append(aMidletId);

    }

    JavaStorageEntry attribute;

    JavaStorageApplicationEntry_t findPattern;

    JavaStorageApplicationList_t  foundEntries;

    // PACKAGE_ID and NAME.

    attribute.setEntry(ID, aPackageId);

    findPattern.insert(attribute);

    attribute.setEntry(NAME, midletId);

    findPattern.insert(attribute);

    attribute.setEntry(VALUE, L"");

    findPattern.insert(attribute);

    aJs.search(APPLICATION_PACKAGE_ATTRIBUTES_TABLE, findPattern, foundEntries);

    if (foundEntries.size() < 1)

    {

        return KErrNotFound;

    }

    // main class. Name is the first argument and main class is the last

    // in the comma separated list.

    std::wstring value = foundEntries.front().begin()->entryValue();

    int pos = value.find_first_of(L",");

    std::wstring midletName = value.substr(0, pos);

    pos = value.find_last_of(L",");

    std::wstring className = value.substr(pos+1);

    // Trim white spaces.

    JavaCommonUtils::trimWstring(midletName, L' ');

    JavaCommonUtils::trimWstring(className, L' ');

    findPattern.clear();

    foundEntries.clear();

    // Get ID from APPLICATION_TABLE based on PACKAGE_ID and MAIN_CLASS

    attribute.setEntry(PACKAGE_ID, aPackageId);

    findPattern.insert(attribute);

    attribute.setEntry(NAME, midletName);

    findPattern.insert(attribute);

    attribute.setEntry(MAIN_CLASS, className);

    findPattern.insert(attribute);

    attribute.setEntry(ID, L"");

    findPattern.insert(attribute);

    aJs.search(APPLICATION_TABLE, findPattern, foundEntries);

    if (foundEntries.size() < 1)

    {

        return KErrNotFound;

    }

    std::wstring applicationId = foundEntries.front().begin()->entryValue();

    TUid tmp;

    TInt err = uidToTUid(applicationId, tmp);

    if (KErrNone == err)

    {

        aUid = tmp.iUid;

    }

    return err;

}

/**

 * Decode %XX encoded UTF-8 characters embedded to UCS-2

 *

 * @param aCmdLineBuf  The command line to be decoded.

 */

static void decodeCommandLineL(TPtr &aCmdLineBuf)

{

    TInt ind = aCmdLineBuf.Find(KPercentage);

    if (KErrNotFound == ind)

    {

        // nothing to decode

        return;

    }

    LOG(EJavaCaptain, EInfo,

        "JavaLauncher:decodeCommandLineL convert percent encoded UTF-8 sequences to UTF-16 ");

    try

    {

        std::wstring cmdLine = desToWstring(aCmdLineBuf);

        std::wstring res = JavaCommonUtils::percentDecode(cmdLine);

        LOG1WSTR(EJavaCaptain, EInfo,

                 "JavaLauncher:decodeCommandLineL: decoded command line is %s", res.c_str());

        aCmdLineBuf = (const TUint16 *)res.c_str();

    }

    catch (std::exception& e)

    {

        ELOG1(EJavaCaptain,

              "JavaLauncher:decodeCommandLineL: cannot decode command line: %s", e.what());

        User::Leave(KErrGeneral);

    }

}

/**

 * Return the value of the argument specified by aArgName

 *

 * @param aMidletCmdLine command line to be parsed

 * @param aArgName the name of the argument

 * @return the value of the argument or empty wstring if no such argument

 */

static std::wstring getArgValue(const TPtrC &aMidletCmdLine, const TDesC &aArgName)

{

    TBuf<KArgumentValueMaxLen> valueBuf;

    TInt argPos = aMidletCmdLine.FindF(aArgName);

    if (argPos >= 0)

    {

        TInt semicolonPos = aMidletCmdLine.Mid(argPos).Find(KSemiColon);

        if (KErrNotFound == semicolonPos)

        {

            semicolonPos = aMidletCmdLine.Mid(argPos).Length();

        }

        TInt argLen = semicolonPos - aArgName.Length();

        if (argLen >= KArgumentValueMaxLen)

        {

            // Protect from buffer overflow.

            WLOG2(EJavaCaptain,

                  "javalauncher: argument value len too long (%d), cutting it to %d",

                  argLen, (KArgumentValueMaxLen - 1));

            argLen = KArgumentValueMaxLen - 1;

        }

        valueBuf = aMidletCmdLine.Mid(argPos + aArgName.Length(),  argLen);

    }

    valueBuf.Append('\0');

    std::wstring value = (wchar_t *)&(valueBuf[0]);

    return value;

}

/**

 * Parse the names of the MIDlet suite and MIDlet vendor from aMidletCmdLine

 * parameter and use them to find the MIDlet suite from Java Storage.

 * Then return Uid of the named MIDlet or if 'midlet-app-name' argument is not given

 * in command line, the Uid of the first MIDlet in the suite.

 * Return the uid of the MIDlet in aUid.

 *

 * @param aMidletCmdLine the command line that contains at least midlet-name

 *  and midlet-vendor arguments

 * @param aUid if the MIDlet is found from Java Storage, contains the Uid after return.

 * @return KErrNone if MIDlet was found. KErrPathNotFound if MIDlet is not found.

 *  Standard Symbian error codes in other cases.

 */

static TInt getUidByNames(const TPtrC &aMidletCmdLine, TInt32 &aUid)

{

    TInt err = aMidletCmdLine.FindF(KMidletNameArg);

    if (KErrNotFound == err)

    {

        return KErrArgument;

    }

    err = aMidletCmdLine.FindF(KMidletVendorArg);

    if (KErrNotFound == err)

    {

        return KErrArgument;

    }

    std::wstring suiteName = getArgValue(aMidletCmdLine, KMidletNameArg);

    std::wstring vendorName = getArgValue(aMidletCmdLine, KMidletVendorArg);

    std::wstring midletId = getArgValue(aMidletCmdLine, KMidletNArg);

    if (suiteName.empty() || vendorName.empty())

    {

        return KErrArgument;

    }

    // Find application uid based on names from Java Storage

    JavaStorage *js = JavaStorage::createInstance();

    try

    {

        js->open(JAVA_DATABASE_NAME);

        JavaStorageEntry attribute;

        JavaStorageApplicationEntry_t findPattern;

        JavaStorageApplicationList_t  foundEntries;

        // Search for package ID by PACKAGE_NAME and VENDOR from APPLICATION_PACKAGE_TABLE

        attribute.setEntry(PACKAGE_NAME, suiteName);

        findPattern.insert(attribute);

        attribute.setEntry(VENDOR, vendorName);

        findPattern.insert(attribute);

        attribute.setEntry(ID, L"");

        findPattern.insert(attribute);

        js->search(APPLICATION_PACKAGE_TABLE , findPattern, foundEntries);

        // Is anything found

        if (foundEntries.size() > 0)

        {

            // The application package has been found, get the ID of the package

            std::wstring value = foundEntries.front().begin()->entryValue();

            LOG1WSTR(EJavaCaptain, EInfo,

                     "JavaLauncher: getUidByNamesL: Found suite uid by name. Uid is %s",

                     value.c_str());

            // Now find the Uid of the first or specified application in the package

            err = getOneApplicationFromPackage(*js, value, midletId, aUid);

        }

        else

        {

            err = KErrPathNotFound;

        }

    }

    catch (JavaStorageException& e)

    {

        ELOG1(EJavaCaptain, "Java Storage exception %s", e.what());

        err = KErrGeneral;

    }

    try

    {

        js->close();

    }

    catch (JavaStorageException& e2)

    {

        WLOG1(EJavaCaptain, "Java Storage exception when closing storage %s", e2.what());

    }

    delete js;

    return err;

}

/**

 * Check whether the MIDlet has been installed to device.

 *

 * @param aUid the Uid of the MIDlet to be checked

 * @return KErrNone if the MIDlet has been installed,

 *         KErrNotFound if the MIDlet has not been installed,

 *         general Symbian error codes in case of error

 */

static TInt verifyAppExists(TInt32 aUid)

{

    TInt err = KErrNone;

    if (aUid == 0)

    {

        return KErrNotFound;

    }

    // Find application uid based on names from Java Storage

    JavaStorage *js = JavaStorage::createInstance();

    try

    {

        js->open(JAVA_DATABASE_NAME);

        JavaStorageEntry attribute;

        JavaStorageApplicationEntry_t findPattern;

        JavaStorageApplicationList_t  foundEntries;

        // Search for application NAME by ID from APPLICATION_TABLE

        Uid uid;

        TUid tuid;

        tuid.iUid = aUid;

        TUidToUid(tuid, uid);

        attribute.setEntry(ID, uid.toString());

        findPattern.insert(attribute);

        attribute.setEntry(NAME, L"");

        findPattern.insert(attribute);

        js->search(APPLICATION_TABLE , findPattern, foundEntries);

        // Is anything found

        if (foundEntries.size() > 0)

        {

            err = KErrNone;

        }

        else

        {

            err = KErrNotFound;

        }

    }

    catch (JavaStorageException& e)

    {

        ELOG1(EJavaCaptain, "Java Storage exception %s", e.what());

        err = KErrGeneral;

    }

    try

    {

        js->close();

    }

    catch (JavaStorageException& e2)

    {

        WLOG1(EJavaCaptain, "Java Storage exception when closing storage %s", e2.what());

    }

    delete js;

    return err;

}

/**

 * Either parse the Uid from the value of 'midlet-uid' parameter in

 * command line given in aMidletCmdLine or find the midlet

 * based on the 'midlet-name' and 'midlet-vendor' from

 * Java Storage / AppArc and return the Uid of the midlet.

 *

 * @param aMidletCmdLine  command line to be parsed, the format is

 *  [midlet-name=XXX;midlet-vendor=XXX;|midlet-uid=YYY;]<midlet_args>

 * @param aUid will contain the Uid parsed from command line

 * @return KErrNone if the command line specified Uid

 */

static TInt getUidFromCommandLine(const TPtrC &aMidletCmdLine, TInt32 &aUid)

{

    TInt err(KErrNone);

    TInt argPos = aMidletCmdLine.FindF(KMidletUidArg);

    if (KErrNotFound != argPos)

    {

        TPtrC uidToParse = aMidletCmdLine.Mid(argPos + KMidletUidArg.iTypeLength);

        TLex parseUid(uidToParse);

        if (uidToParse.FindF(KHexValueStart) == 0)

        {

            parseUid.Inc(2); // skip hex prefix

            TUint32 tmpValue;

            err = parseUid.Val(tmpValue, EHex);

            aUid = tmpValue;

        }

        else

        {

            err = parseUid.Val(aUid);

        }

        if (KErrNone != err)

        {

            ELOG1(EJavaCaptain,

                  "javalauncher failed parsing app Uid from cmdline midlet-uid param. Error %d",

                  err);

        }

        err = verifyAppExists(aUid);

    }

    else

    {

        err = getUidByNames(aMidletCmdLine, aUid);

        if (KErrNone != err)

        {

            if (KErrArgument == err)

            {

                // In this case the Uid is not in opaque data and there are

                // no midlet-uid or midlet-name + midlet-vendor parameters in the command line

                ELOG(EJavaCaptain,

                     "javalauncher cannot launch app because there is no info to determine Uid.");

            }

            else

            {

                ELOG1(EJavaCaptain,

                      "javalauncher failed getting app Uid based on cmdline midlet-name and "

                      "midlet-vendor params. Error %d",

                      err);

            }

        }

    }

    return err;

}

/**

 * Parse CApaCommandLine and optional normal process command line.

 * Determine the uid of the Java application to be started

 *

 * @param aCmdLine returns value of midlet-args

 * @param aUid returns Uid of the Java application to be started

 * @param aBackGroundLaunch returns info whether back ground launch is needed

 * @return KErrNone or error code

 */

TInt getCmdLineAndUidL(HBufC **aCmdLine, TInt *aUid, TBool *aBackGroundLaunch)

{

    CApaCommandLine* commandLine;

    // CApaCommandLine command line is used when AppArc is launching Java application.

    // Uid is in opaque data and possible document name is in document name field.

    TInt err = CApaCommandLine::GetCommandLineFromProcessEnvironment(commandLine);

    if (KErrNone != err)

    {

        return err;

    }

    CleanupStack::PushL(commandLine);

    // The following feature is not supported yet.

    // It needs changes also to Java Installer and to

    // Symbian Settings UI

    TInt maxExtraSpaceForDocumentArg = 0;

#ifdef RD_JAVA_SUPPORT_JAVA_APPS_AS_MIME_TYPE_HANDLERS

    _LIT(KDocumentOnlyCmdLine, "document=");

    TFullName documentName;

    documentName = commandLine->DocumentName();

    if (documentName.Length() > 0)

    {

        maxExtraSpaceForDocumentArg =

            documentName.Length() + KDocumentOnlyCmdLine.iTypeLength +

            KSemiColon.iTypeLength;

        LOG1WSTR(EJavaCaptain, EInfo,

                 "JavaLauncher: document to handle is %s",

                 (wchar_t *)(documentName.PtrZ()));

    }

#endif

    // User::CommandLine command line is used when Java application is launched

    // from native application or from javaapp: or localapp:/jam/launch/ scheme

    // handler plugin.

    HBufC *pBufCmdLine =

        HBufC::NewLC(User::CommandLineLength() +

                     maxExtraSpaceForDocumentArg +

                     KExtraLenForLoggingAndPrompting);

    TPtr cmdLineBuf = pBufCmdLine->Des();

    User::CommandLine(cmdLineBuf);

    if (pBufCmdLine->Length() > 0)

    {

        LOG1WSTR(EJavaCaptain, EInfo,

                 "JavaLauncher: command line of this process is %s",

                 (wchar_t *)(cmdLineBuf.PtrZ()));

        // If the commandline contains hex encoded UTF-8 characters %XX decode them to UCS-2 (UTF-16)

        // For example "%C3%80%C3%80nes%C3%80.txt"

        decodeCommandLineL(cmdLineBuf);

    }

    TPtrC8 data = commandLine->OpaqueData();

    TInt32 uid = 0;  // application uid