/*

* 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: Simple application for testing Sif API

*              (install, uninstall, get component info)

*/

#include <e32std.h>

#include <e32base.h>

#include <f32file.h>

#include <e32property.h>

#include <stdio.h>

#include <s60commonutils.h>

#include <usif/sif/sif.h>

#include "logger.h"

using namespace Usif;

_LIT(KTestMIDlet, "E:\\stopwatch10midp2.jad");

_LIT(KTestMIDlet2, "E:\\stopwatch11midp2.jar");

_LIT(KTestMIDlet3, "E:\\Private\\10281e17\\SimpleRMS.jar");

_LIT(KUserName, "user");

_LIT(KPassWord, "password");

_LIT(KEmptyString, "");

_LIT(KSourceUrl, "\\sourceurl\\foo");

_LIT(KCharSet, "charset");

_LIT(KJadMimeType, "text/vnd.sun.j2me.app-descriptor");

_LIT(KJarMimeType, "application/java-archive");

/**

 * Installs a component by file name

 */

static void sifSimplestInstallL()

{

    LOG(EJavaConverters, EInfo,

        "testsifapi: sifInstallL: Called");

    RSoftwareInstall installer;

    TInt err = installer.Connect();

    if (KErrNone != err)

    {

        ELOG1(EJavaConverters,

              "testsifapi: sifInstallL: Cannot connect to RSoftwareInstall, err %d", err);

        User::Leave(err);

    }

    CleanupClosePushL(installer);

    TRequestStatus status;

    installer.Install(KTestMIDlet, status);

    User::WaitForRequest(status);

    LOG1(EJavaConverters, EInfo,

        "testsifapi: sifInstallL: The return status of install operation was %d", status.Int());

    // free resources before returning

    CleanupStack::PopAndDestroy(1);

}

/**

 * this test case ends.

 *

 *

 * Keep the installer running until 1) installation has failed

 * 2) uninstallation has failed and 3) getComponentInfo had failed

 * because the installer is already running.

 */

static void sifInstallerAlreadyRunningL()

{

    LOG(EJavaConverters, EInfo,

        "testsifapi: sifInstallerAlreadyRunningL: Called");

    RSoftwareInstall installer;

    TInt err = installer.Connect();

    if (KErrNone != err)

    {

        ELOG1(EJavaConverters,

              "testsifapi: sifInstallerAlreadyRunningL: Cannot connect to RSoftwareInstall, err %d", err);

        User::Leave(err);

    }

    CleanupClosePushL(installer);

/*

    LOG(EJavaConverters, EInfo,

        "testsifapi: sifInstallerAlreadyRunningL: Starting the first installer process");

    TRequestStatus status;

    installer.Install(KTestMIDlet, status);

    // wait for second

    User::After(1000000);

*/

    LOG(EJavaConverters, EInfo,

        "testsifapi: sifInstallerAlreadyRunningL: Starting the concurrent installation");

    // Try to start concurrent installation, will fail

    TRequestStatus status2;

    installer.Install(KTestMIDlet2, status2, EFalse);

    User::WaitForRequest(status2);

    LOG1(EJavaConverters, EInfo,

        "testsifapi: sifInstallerAlreadyRunningL: The return status of concurrent install operation was %d", status2.Int());

    LOG(EJavaConverters, EInfo,

        "testsifapi: sifInstallerAlreadyRunningL: Starting the concurrent uninstallation");

    // Try to start concurrent uninstallation, will fail

    TRequestStatus status3;

    installer.Uninstall(15, status3, EFalse);

    User::WaitForRequest(status3);

    LOG1(EJavaConverters, EInfo,

        "testsifapi: sifInstallerAlreadyRunningL: The return status of concurrent uninstall operation was %d", status3.Int());

    LOG(EJavaConverters, EInfo,

        "testsifapi: sifInstallerAlreadyRunningL: Starting the concurrent get component info");

    // Try to start concurrent GetComponentInfo, will fail

    TRequestStatus status4;

    CComponentInfo *info = CComponentInfo::NewL();

    installer.GetComponentInfo(KTestMIDlet, *info, status4);

    User::WaitForRequest(status4);

    delete info;

    LOG1(EJavaConverters, EInfo,

        "testsifapi: sifInstallerAlreadyRunningL: The return status of concurrent GetComponentInfo operation was %d", status4.Int());

/*

    User::WaitForRequest(status);

    LOG1(EJavaConverters, EInfo,

        "testsifapi: sifInstallerAlreadyRunningL: The return status of install operation was %d", status.Int());

*/

    // free resources before returning

    CleanupStack::PopAndDestroy(1);

}

/**

 * Installs a component by file handle using opaque arguments/results

 */

static TInt sifByHandleAndArgsAndResultsInstallL()

{

    // Open file handle to the installation file

    RFs fs;

    TInt err = fs.Connect();

    if (KErrNone != err)

    {

        ELOG1(EJavaConverters,

              "testsifapi: sifByHandleAndArgsAndResultsInstallL: Cannot connect to RFs, err %d", err);

        User::Leave(err);

    }

    CleanupClosePushL(fs);

    // If the file server session is not shared, USIF server crashes with KERN-EXEC 44

    err = fs.ShareProtected();

    if (KErrNone != err)

    {

        ELOG1(EJavaConverters,

              "testsifapi: sifByHandleAndArgsAndResultsInstallL: Cannot share RFs, err %d", err);

        User::Leave(err);

    }

// TEMP TEST

    RFile installFile;

    err = installFile.Open(fs, KTestMIDlet3, EFileShareReadersOnly | EFileRead);

    if (KErrNone != err)

    {

        ELOG1(EJavaConverters,

              "testsifapi: sifByHandleAndArgsAndResultsInstallL: Cannot open "

        User::Leave(err);

    }

    CleanupClosePushL(installFile);

    LOG(EJavaConverters, EInfo,

        "testsifapi: sifByHandleAndArgsAndResultsInstallL: installFile handle opened");

    RSoftwareInstall installer;

    err = installer.Connect();

    if (KErrNone != err)

    {

        ELOG1(EJavaConverters,

              "testsifapi: sifByHandleAndArgsAndResultsInstallL: Cannot connect to RSoftwareInstall, err %d", err);

        User::Leave(err);

    }

    CleanupClosePushL(installer);

    LOG(EJavaConverters, EInfo,

        "testsifapi: sifByHandleAndArgsAndResultsInstallL: RSoftwareInstall connected");

    TRequestStatus status;

    COpaqueNamedParams *arguments = COpaqueNamedParams::NewL();

    CleanupStack::PushL(arguments);

    COpaqueNamedParams *results = COpaqueNamedParams::NewL();

    CleanupStack::PushL(results);

    // Silent installation request

    arguments->AddIntL(KSifInParam_InstallSilently, 1);

    // drive E:

    arguments->AddStringL(KSifInParam_SourceUrl, KSourceUrl);

    arguments->AddIntL(KSifInParam_IAP, 3);

    arguments->AddStringL(KSifInParam_Charset, KEmptyString);

    LOG(EJavaConverters, EInfo,

        "testsifapi: sifByHandleAndArgsAndResultsInstallL: arguments created");

    installer.Install(installFile, *arguments, *results, status);

    User::WaitForRequest(status);

    LOG1(EJavaConverters, EInfo,

        "testsifapi: sifByHandleAndArgsAndResultsInstallL: The return status of install operation was %d", status.Int());

    TInt componentId = 0;

    {

        LOG1(EJavaConverters, EInfo,

            "testsifapi: sifByHandleAndArgsAndResultsInstallL: Component id was %d", componentId);

    }

    else

    {

        LOG(EJavaConverters, EInfo,

            "testsifapi: sifByHandleAndArgsAndResultsInstallL: No component id was returned");

    }

    // free resources before returning

    CleanupStack::PopAndDestroy(5);

    return componentId;

}

/**

 * Installs a component by file handle using other opaque arguments than

 * sifByHandleAndArgsAndResultsInstallL()

 */

static TInt secondSifByFileAndArgsAndResultsInstallL()

{

    RSoftwareInstall installer;

    TInt err = installer.Connect();

    if (KErrNone != err)

    {

        ELOG1(EJavaConverters,

              "testsifapi: secondSifByFileAndArgsAndResultsInstallL: Cannot connect to RSoftwareInstall, err %d", err);

        User::Leave(err);

    }

    CleanupClosePushL(installer);

    LOG(EJavaConverters, EInfo,

        "testsifapi: secondSifByFileAndArgsAndResultsInstallL: RSoftwareInstall connected");

    TRequestStatus status;

    COpaqueNamedParams *arguments = COpaqueNamedParams::NewL();

    CleanupStack::PushL(arguments);

    COpaqueNamedParams *results = COpaqueNamedParams::NewL();

    CleanupStack::PushL(results);

    // Silent installation request

    arguments->AddIntL(KSifInParam_InstallSilently, 1);

    // illegal drive number 33

    arguments->AddStringL(KSifInParam_SourceUrl, KEmptyString);

    arguments->AddIntL(KSifInParam_SNAP, 8);

    arguments->AddStringL(KSifInParam_Charset, KCharSet);

    arguments->AddStringL(KSifInParam_MimeType, KJarMimeType);

    // forcecancel argument value is ignored, forcecancel is set if the value length > 0

    LOG(EJavaConverters, EInfo,

        "testsifapi: secondSifByFileAndArgsAndResultsInstallL: arguments created");

    installer.Install(KTestMIDlet2, *arguments, *results, status);

    User::WaitForRequest(status);

    LOG1(EJavaConverters, EInfo,

        "testsifapi: secondSifByFileAndArgsAndResultsInstallL: The return status of install operation was %d", status.Int());

    TInt componentId = 0;

    {

        LOG1(EJavaConverters, EInfo,

            "testsifapi: secondSifByFileAndArgsAndResultsInstallL: Component id was %d", componentId);

    }

    else

    {

    }

    // free resources before returning

    CleanupStack::PopAndDestroy(3);

    return componentId;

}

static void sifUninstallL(TInt &aComponentId)

{

    LOG1(EJavaConverters, EInfo,

        "testsifapi: sifUninstallL: Uninstall component (id %d)", aComponentId);

    RSoftwareInstall installer;

    TInt err = installer.Connect();

    if (KErrNone != err)

    {

        ELOG1(EJavaConverters,

              "testsifapi: sifUninstallL: Cannot connect to RSoftwareInstall, err %d", err);

        User::Leave(err);

    }

    CleanupClosePushL(installer);

    TRequestStatus status;

    COpaqueNamedParams *arguments = COpaqueNamedParams::NewL();

    CleanupStack::PushL(arguments);

    COpaqueNamedParams *results = COpaqueNamedParams::NewL();

    CleanupStack::PushL(results);

    // Silent uninstallation request

    arguments->AddIntL(KSifInParam_InstallSilently, 1);

    installer.Uninstall(aComponentId, *arguments, *results, status, EFalse);

    User::WaitForRequest(status);

    LOG1(EJavaConverters, EInfo,

        "testsifapi: sifUninstallL: The return status of uinstall operation was %d", status.Int());

    // free resources before returning

    CleanupStack::PopAndDestroy(3);

}

static void logComponentInfoNode(const CComponentInfo::CNode& aNode)

{

    std::wstring buf((wchar_t*) aNode.SoftwareTypeName().Ptr(), aNode.SoftwareTypeName().Length());

    LOG1WSTR(EJavaConverters, EInfo,

        "SoftwareTypeName is %s",

        buf.c_str());

    std::wstring buf2((wchar_t*) aNode.ComponentName().Ptr(), aNode.ComponentName().Length());

    LOG1WSTR(EJavaConverters, EInfo,

        "ComponentName is %s",

        buf2.c_str());

    std::wstring buf3((wchar_t*) aNode.Version().Ptr(), aNode.Version().Length());

    LOG1WSTR(EJavaConverters, EInfo,

        "Version is %s",

        buf3.c_str());

    std::wstring buf4((wchar_t*) aNode.Vendor().Ptr(), aNode.Vendor().Length());

    LOG1WSTR(EJavaConverters, EInfo,

        "Vendor is %s",

        buf4.c_str());

    LOG1(EJavaConverters, EInfo,

        "ScomoState is %d",

        aNode.ScomoState());

    LOG1(EJavaConverters, EInfo,

        "Install status of component is %d",

        aNode.InstallStatus());

    LOG1(EJavaConverters, EInfo,

        "Component id is %d",

        aNode.ComponentId());

    std::wstring buf5((wchar_t*) aNode.GlobalComponentId().Ptr(), aNode.GlobalComponentId().Length());

    LOG1WSTR(EJavaConverters, EInfo,

        "GlobalComponentId is %s",

        buf5.c_str());

    LOG1(EJavaConverters, EInfo,

        "Authenticity is %d",

        aNode.Authenticity());

    LOG1(EJavaConverters, EInfo,

        "MaxInstalledSize is %d",

        aNode.MaxInstalledSize());

}

static void logApplicationInfo(const CComponentInfo::CApplicationInfo& aApplication)

{

    LOG1(EJavaConverters, EInfo, "Application uid is 0x%x", aApplication.AppUid());

    std::wstring buf((wchar_t*) aApplication.Name().Ptr(), aApplication.Name().Length());

    LOG1WSTR(EJavaConverters, EInfo, "Application name is %s", buf.c_str());

}

static void sifGetComponentInfoL()

{

    LOG(EJavaConverters, EInfo,

        "testsifapi: sifGetComponentInfoL: Called");

    RSoftwareInstall installer;

    TInt err = installer.Connect();

    if (KErrNone != err)

    {

        ELOG1(EJavaConverters,

              "testsifapi: sifGetComponentInfoL: Cannot connect to RSoftwareInstall, err %d", err);

        User::Leave(err);

    }

    CleanupClosePushL(installer);

    TRequestStatus status;

    CComponentInfo *info = CComponentInfo::NewL();

    CleanupStack::PushL(info);

    installer.GetComponentInfo(KTestMIDlet, *info, status);

    User::WaitForRequest(status);

    LOG1(EJavaConverters, EInfo,

        "testsifapi: sifGetComponentInfoL: The return status of get "

        "component info operation was %d", status.Int());

    LOG(EJavaConverters, EInfo,

        "testsifapi: sifGetComponentInfoL: Logging root node (suite)");

    logComponentInfoNode(info->RootNodeL());

    LOG(EJavaConverters, EInfo,

        "testsifapi: sifGetComponentInfoL: Logging child nodes (MIDlets)");

    TInt nMIDlets = info->RootNodeL().Children().Count();

    TInt nInd;

    for (nInd = 0; nInd < nMIDlets; nInd++)

    {

        logComponentInfoNode(*(info->RootNodeL().Children()[nInd]));

    }

    nMIDlets = info->RootNodeL().Applications().Count();

    for (nInd = 0; nInd < nMIDlets; nInd++)

    {

        logApplicationInfo(*(info->RootNodeL().Applications()[nInd]));

    }

    CleanupStack::PopAndDestroy(info);

    User::After(1000000);

    // Get component info also from jar

    TRequestStatus status2;

    CComponentInfo *info2 = CComponentInfo::NewL();

    CleanupStack::PushL(info2);

    installer.GetComponentInfo(KTestMIDlet2, *info2, status2);