/*

* Copyright (c) 2008 - 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: prototyping starting midlet from native applications

*/

#include <e32std.h>

#include <e32base.h>

#include <f32file.h>

#include <apgcli.h> // for RApaLsSession

#include <e32property.h>

#include <swinstallerinternalpskeys.h>

#include <apacmdln.h> //CApaCommandLine

#include <s32mem.h>   // RDesWriteStream

#include <stdio.h>

#include <s60commonutils.h>

#include "javauids.h"

#include "logger.h"

_LIT(KJavaLauncherExe, "javalauncher.exe");

/**

 *

 */

static void startByJavaLauncherSimpleL()

{

    LOG(EJavaConverters, EInfo,

        "testmidletstart: startByJavaLauncherSimple: Going to start midlet from 'testmidletstart.txt'");

    // Read the content of test data file

    RFs fs;

    TInt err = fs.Connect();

    if (KErrNone != err)

    {

        ELOG1(EJavaConverters,

              "testmidletstart: startByJavaLauncherSimple: Cannot connect to RFs, err %d", err);

        User::Leave(err);

    }

    CleanupClosePushL(fs);

    RFile testData;

    err = testData.Open(fs, _L("E:\\testmidletstart.txt"), EFileRead);

    if (KErrNotFound == err)

    {

        err = testData.Open(fs, _L("C:\\testmidletstart.txt"), EFileRead);

    }

    if (KErrNone != err)

    {

        ELOG1(EJavaConverters,

              "testmidletstart: startByJavaLauncherSimple: Cannot open E: "

              "or C:\\testmidletstart.txt, err %d", err);

        User::Leave(err);

    }

    CleanupClosePushL(testData);

    TInt testDataSize = 0;

    err = testData.Size(testDataSize);

    if (KErrNone != err)

    {

        ELOG1(EJavaConverters,

              "testmidletstart: startByJavaLauncherSimple: Cannot get size of "

              "testmidletstart.txt, err %d", err);

        User::Leave(err);

    }

    HBufC8 *pBuf = HBufC8::NewLC(testDataSize + 8);

    TPtr8 buf = pBuf->Des();

    err = testData.Read(buf);

    if (KErrNone != err)

    {

        ELOG1(EJavaConverters,

              "testmidletstart: startByJavaLauncherSimple: Reading "

              "testmidletstart.txt failed, err %d", err);

        User::Leave(err);

    }

    printf("File content was %s", (const char *)(buf.PtrZ()));

    TInt pos = 0;

    // Find LF

    TInt end = buf.Locate(0x0A);

    if (KErrNotFound == end)

    {

        end = buf.Length();

    }

    else if (buf.Locate(0x0D) == (end - 1))

    {

        // If there is CR before LF, it does not belong to cmd line

        --end;

    }

    // Read one line from buffer, convert it to 16 bit

    TPtrC8 oneLine = buf.Mid(pos, end - pos);

    TDesC *pCmdLine = NULL;

    TInt res = java::util::S60CommonUtils::ConvertNarrowToWiderL(oneLine, pCmdLine);

    // Create one process using this command line

    RProcess rProcess;

    // start

//    TInt err = rProcess.Create(KJavaLauncherExe, _L("midlet-uid=0x1014e720;startMode=startFromCmdLine;sound=ON;landscapeMode=true;"));  // OK

//    TInt err = rProcess.Create(KJavaLauncherExe, _L("midlet-name=%E6%98%9F%E5%A4%A2%E7%BE%8E%E5%B0%91%E5%A5%B3%E7%A0%8C%E5%9C%96"));

//    TInt err = rProcess.Create(KJavaLauncherExe, _L("midlet-name=%C3%80%C3%80NEST%C3%80.EXE"));

//    err = rProcess.Create(KJavaLauncherExe, _L("midlet-name=SPtesti;mode=nativestart;sounds=ON;difficulty=medium;wizard_mode"));

    err = rProcess.Create(KJavaLauncherExe, *pCmdLine);

    if (KErrNone == err)

    {

        LOG(EJavaConverters, EInfo, "testmidletstart: startByJavaLauncherSimple calling Rendezvous");

        // This call will wait until midlet exits (or panics)

        TRequestStatus status;

        rProcess.Logon(status);

        LOG(EJavaConverters, EInfo, "testmidletstart: startByJavaLauncherSimple calling Resume");

        rProcess.Resume();

        // now wait until javalauncher exits

        User::WaitForRequest(status);

        if (status.Int() != KErrNone)

        {

            ELOG1(EJavaConverters,

                  "testmidletstart: startByJavaLauncherSimple javalauncher exited with error %d",

                  status.Int());

        }

    }

    else

    {

        ELOG1(EJavaConverters,

              "testmidletstart: startByJavaLauncherSimple Cannot start midlet, error %d", err);

    }

    LOG(EJavaConverters, EInfo, "testmidletstart: startByJavaLauncherSimple calling RProcess::Close");

    delete pCmdLine;

    rProcess.Close();

    // free resources before returning

    CleanupStack::PopAndDestroy(3);

}

/**

 *

 */

static void startByAppArcL()

{

    RApaLsSession apaSession;

    TInt err = apaSession.Connect();

    if (KErrNone != err)

    {

        ELOG1(EJavaConverters,

              "testmidletstart::startByAppArcL RApaLsSession Connect error %d", err);

        User::Leave(err);

    }

    CleanupClosePushL(apaSession);

    CApaCommandLine* cmdLine = CApaCommandLine::NewLC();

    // Drive letter must be correct

    cmdLine->SetExecutableNameL(_L("C:\\269712461.fakeapp"));

    cmdLine->SetCommandL(EApaCommandRun);

    cmdLine->SetTailEndL(_L8(" midletparam1 -param2 -param3=no"));

    LOG(EJavaConverters, EInfo, "testmidletstart: startByAppArcL: Going to start midlet SystemProperties");

    err = apaSession.StartApp(*cmdLine);

    if (KErrNone != err)

    {

        ELOG1(EJavaConverters,

              "testmidletstart::startByAppArcL StartApp error %d", err);

    }

    CleanupStack::PopAndDestroy(cmdLine);

    CleanupStack::PopAndDestroy(); // apaSession

}

/**

 * Start javalauncher.exe that will start midlet

 */

static void startByJavaLauncherL()

{

    LOG(EJavaConverters, EInfo, "testmidletstart: startByJavaLauncherL: Going to start midlet SystemProperties");

    RProcess rProcess;

    // Build command line used to pass all necessary info

    CApaCommandLine* cmdLine = CApaCommandLine::NewLC();

    cmdLine->SetExecutableNameL(KJavaLauncherExe);

    cmdLine->SetCommandL(EApaCommandRun);

    cmdLine->SetDocumentNameL(_L("C:/data/my_own_doc.kwi"));

    // The midlet to be started can be specified by using opaque data like here or

    // by specifying midlet name and vendor in command line

    TBuf8<4>         opaqueData;     // opaque data will contain one signed 32-bit int

    RDesWriteStream  writeStream(opaqueData);

    writeStream.WriteInt32L(0x10137c4d);   // midlet application Uid

    writeStream.CommitL();

    cmdLine->SetOpaqueDataL(opaqueData);

    LOG(EJavaConverters, EInfo, "testmidletstart: startByJavaLauncherL: Create process");

    // start

    TInt err = rProcess.Create(KJavaLauncherExe, _L("midlet-uid=0x10137c4d;startMode=strangeStart"));

    if (KErrNone == err)

    {

        LOG(EJavaConverters, EInfo, "testmidletstart: startByJavaLauncherL: Set process commandline");

        cmdLine->SetProcessEnvironmentL(rProcess);

        LOG(EJavaConverters, EInfo, "testmidletstart: startByJavaLauncherL calling Logon");

        // This call will wait until javalauncher exits (or panics)

        TRequestStatus status;

        rProcess.Logon(status);

        LOG(EJavaConverters, EInfo, "testmidletstart: startByJavaLauncherL calling Resume");

        rProcess.Resume();

        // now wait until javalauncher exits

        User::WaitForRequest(status);

        if (status.Int() != KErrNone)

        {

            ELOG1(EJavaConverters,

                  "testmidletstart: startByJavaLauncherL javalauncher exited with error %d",

                  status.Int());

        }

    }

    else

    {

        ELOG1(EJavaConverters,

              "testmidletstart: startByJavaLauncherL Cannot start midlet, error %d", err);

    }

    LOG(EJavaConverters, EInfo, "testmidletstart: startByJavaLauncherL calling RProcess::Close");

    // free resources before returning

    CleanupStack::PopAndDestroy(cmdLine);

    rProcess.Close();

}

/**

 * Read all midlets from AppArc.

 * Log midlet Uid, Midlet name, installation drive,

 * group name and icon file path name

 */

static void readMidletsFromAppArcL()

{

    TInt   retryCounter = 10;

    TUid   appTypeUid;

    TApaAppInfo   info;

    RApaLsSession apaSession;

    TBuf8<512> midletDesc;

    TInt err = apaSession.Connect();

    if (KErrNone != err)

    {

        ELOG1(EJavaConverters,

              "testmidletstart::readMidletsFromAppArcL RApaLsSession Connect error %d", err);

        User::Leave(err);

    }

    CleanupClosePushL(apaSession);

    // Get the process of getting the list of all non native applications

    // (mostly java applications)

    err =

        apaSession.GetFilteredApps(

            TApaAppCapability::ENonNative, TApaAppCapability::ENonNative);

    TFullName logBuf;

    do

    {

        err = apaSession.GetNextApp(info);

        if (RApaLsSession::EAppListInvalid == err)

        {

            // Application list has not yet been populated,

            // try again after a short delay

            retryCounter--;

            if (retryCounter > 0)

            {

                User::After(500000);

                continue;

            }

            else

            {

                ELOG(EJavaConverters,

                     "testmidletstart::readMidletsFromAppArcL RApaLsSession "

                     "GetNext returned EAppListInvalid for 10 times, error");

                User::Leave(err);

            }

        }

        else if (KErrNone == err)

        {

            // Info contains valid app info. Now check whether it is java app

            err = apaSession.GetAppType(appTypeUid, info.iUid);

            if (KErrNone != err)

            {

                ELOG1(EJavaConverters,

                      "testmidletstart::readMidletsFromAppArcL RApaLsSession "

                      "GetAppType returned error %d", err);

                User::Leave(err);

            }

            if (appTypeUid.iUid == KMidletApplicationTypeUid)

            {

                // This is java application. Log info

                LOG1(EJavaConverters, EInfo, "testmidletstart: readMidletsFromAppArcL: midlet uid %x", info.iUid);

                logBuf = info.iCaption;

                LOG1WSTR(EJavaConverters, EInfo, "testmidletstart: readMidletsFromAppArcL: midlet name %s",

                         (wchar_t *)(logBuf.PtrZ()));

                logBuf = info.iFullName;

                LOG1WSTR(EJavaConverters, EInfo, "testmidletstart: readMidletsFromAppArcL: midlet path %s",

                         (wchar_t *)(logBuf.PtrZ()));

            }

        }

    }

    while (KErrNone == err);

    if (RApaLsSession::ENoMoreAppsInList != err)

    {

        ELOG1(EJavaConverters,

              "testmidletstart:readMidletsFromAppArcL: RApaLsSession GetNext returned error %d", err);

        User::Leave(err);

    }

    CleanupStack::PopAndDestroy(); // apaSession

}

/**

 *

 */

static void registerAsMimeHandlerL()

{

    TInt   retryCounter = 10;

    TUid   appTypeUid;

    TApaAppInfo   info;

    RApaLsSession apaSession;

    TInt err = apaSession.Connect();

    if (KErrNone != err)

    {

        ELOG1(EJavaConverters,

              "testmidletstart::registerAsMimeHandlerL RApaLsSession Connect error %d", err);

        User::Leave(err);

    }

    CleanupClosePushL(apaSession);

    // Get current handler for file e:\tif.tif

    TUid      handlerUid;

    TDataType mimeType;

    err = apaSession.AppForDocument(_L("e:\\tif.tif"), handlerUid, mimeType);

    if (KErrNone != err)

    {

        ELOG1(EJavaConverters,

              "testmidletstart::registerAsMimeHandlerL AppForDocument error %d", err);

        User::Leave(err);

    }

    TBuf8<256> mimeTypeName;

    mimeTypeName = mimeType.Des8();

    mimeTypeName.Append('\0');

    LOG1(EJavaConverters, EInfo,

         "testmidletstart::registerAsMimeHandlerL file MIME type is %s", &(mimeTypeName[0]));

    LOG1(EJavaConverters, EInfo,

         "testmidletstart::registerAsMimeHandlerL handler for it is %x", handlerUid.iUid);

    TUid midletUid;

    midletUid.iUid = 0x10137c4d;

    TDataTypePriority priority(100);

    err = apaSession.InsertDataMapping(mimeType, priority, midletUid);

    if (KErrNone != err)

    {

        ELOG1(EJavaConverters,

              "testmidletstart::registerAsMimeHandlerL InsertDataMapping error %d", err);

        User::Leave(err);

    }

    TUid  newHandlerUid;

    err = apaSession.AppForDocument(_L("e:\\tif.tif"), newHandlerUid, mimeType);

    if (KErrNone != err)

    {

        ELOG1(EJavaConverters,

              "testmidletstart::registerAsMimeHandlerL AppForDocument2 error %d", err);

        User::Leave(err);

    }

    LOG1(EJavaConverters, EInfo,

         "testmidletstart::registerAsMimeHandlerL NOW handler is %x", newHandlerUid.iUid);

    // Restore old handler

    TDataTypePriority oldHandlerPriority(300);

    TUid originalHandlerUid;

    originalHandlerUid.iUid = 0x1000599d;

    err = apaSession.InsertDataMapping(mimeType, oldHandlerPriority, originalHandlerUid);

    if (KErrNone != err)

    {

        ELOG1(EJavaConverters,

              "testmidletstart::registerAsMimeHandlerL InsertDataMapping (restore old handler) error %d", err);

        User::Leave(err);

    }

    /*

        // Restore old handler

        TDataTypePriority oldHandlerPriority(300);

        TUid originalHandlerUid;

        originalHandlerUid.iUid = 0x101f4d90;

        err = apaSession.InsertDataMapping(mimeType, oldHandlerPriority, originalHandlerUid);

        if (KErrNone != err)

        {

            ELOG1(EJavaConverters,

                "testmidletstart::registerAsMimeHandlerL InsertDataMapping (restore old handler) error %d", err);

            User::Leave(err);

        }

    */

    CleanupStack::PopAndDestroy(); // apaSession

}

/**

 * Create cleanup stack and run the cleaner code inside TRAP harness

 * to log unexpected leaves.

 */

TInt E32Main()

{

//    __UHEAP_MARK;

    CTrapCleanup* cleanupStack = CTrapCleanup::New();

    TRAPD(err, readMidletsFromAppArcL());

    if (KErrNone != err)

    {

        ELOG1(EJavaConverters, "testmidletstart: readMidletsFromAppArcL leaved with err %d", err);

    }

    // Wait for a moment

    User::After(500000);

    TRAP(err, startByJavaLauncherSimpleL());

    if (KErrNone != err)

    {

        ELOG1(EJavaConverters, "testmidletstart: startByJavaLauncherSimple leaved with err %d", err);

    }

    // Wait for a moment

    User::After(500000);

    /*

        TRAP(err, startByAppArcL());

        if (KErrNone != err)

        {

            ELOG1(EJavaConverters, "testmidletstart: startByAppArcL leaved with err %d", err);

        }

        // Wait for a moment

        User::After(500000);

        TRAP(err, startByJavaLauncherL());

        if (KErrNone != err)

        {

            ELOG1(EJavaConverters, "testmidletstart: startByJavaLauncherL leaved with err %d", err);

        }

        // Wait for a moment

        User::After(500000);

        TRAP(err, registerAsMimeHandlerL());

        if (KErrNone != err)

        {

            ELOG1(EJavaConverters, "testmidletstart: registerAsMimeHandlerL leaved with err %d", err);

        }

    */

    delete cleanupStack;

//    __UHEAP_MARKEND;

    return KErrNone;

}

// eof