/*

* 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:  The JNI code for Java Installer component

*                ApplicationRegistrator.

*

*/

#include <apaid.h>

#include <f32file.h>

#include <apgcli.h>

#include <utf.h>

#include <s32mem.h>

#include <bautils.h>

#include <w32std.h>

#include <apgtask.h>

#include <apacmdln.h>

#include <centralrepository.h>

#include <AknUtils.h>

#include <hal.h>

#ifndef SYMBIAN_ENABLE_SPLIT_HEADERS

#include <apgicnfl.h>

#else

#include <apgicnflpartner.h>

#endif

// JNI header must be included before iconconverter.h. Latter includes some

// other header file which defines WIN32 macro, causing incorrect definitions

// to be taken from jniport.h when WINSCW compilation is made.

// This error situation can be seen from linker warnings which complain

// about not frozen exports for JNI methods.

#include "com_nokia_mj_impl_installer_applicationregistrator_ApplicationRegistrator.h"

#include "iconconverter.h"

#include "javacommonutils.h"

#include "logger.h"

// NAMESPACE DECLARATION

using namespace java;

/**

 * MIDP Stub SIS file UID. The application type Uid for MIDlets in S60

 */

const TUid KMidletApplicationTypeUid = { 0x10210E26 };

/**

 * Symbian file path separator

 */

_LIT(KPathSeperator, "\\");

/**

 * Postfix for the fake application name generated only to make AppArc happy

 */

_LIT(KAppPostfix, ".fakeapp");

#ifdef RD_JAVA_S60_RELEASE_9_2

const TInt KAppIconCount = 2;

#else

const TInt KAppIconCount = 1;

#endif

// ------------------------

/**

 * Internal wrapper method that is used to make TRAPping the leaves in the

 * native Symbian code easier.

 * Used from JNI method ...1registerApplication()

 * @see Java_com_nokia_mj_impl_installer_applicationregistrator_ApplicationRegistrator__1registerApplication

 */

jint registerApplicationL(JNIEnv *aEnv, jclass aClass, jint aSessionHandle,

                          jint aUid, HBufC16 *aGroupName, HBufC16 *aMIDletName, HBufC16 *aTargetDrive,

                          HBufC16 *aIconFileName, HBufC16 *aJarFileName, jboolean aHidden,

                          jboolean aBackground);

/**

 * Internal helper method for checking whether this code is executing in

 * a device that has correctly working version of

 * RApaLsSession::ForceCommitNonNativeApplicationsUpdatesL()

 *

 * @return ETrue if force commit works well

 */

TBool isForceCommitSupported();

/**

 * Internal helper method for starting menu application

 *

 * @return KErrNone or Symbian error code

 */

TInt startAppShellApplicationL();

// --------------------------

/**

 * Starts native application registration session.

 *

 * @return native session handle or Symbian error code (negative number)

 */

JNIEXPORT jint JNICALL Java_com_nokia_mj_impl_installer_applicationregistrator_ApplicationRegistrator__1startSession

(JNIEnv *, jclass)

{

    TInt err;

    RApaLsSession *pApaSession = new RApaLsSession;

    if (NULL == pApaSession)

    {

        // Could not create session

        return KErrGeneral;

    }

    err = pApaSession->Connect();

    if (KErrNone != err)

    {

        // Cannot connect to AppArc server

        return err;

    }

    // Delete any pending (un)registrations (possible if

    // e.g. device rebooted before commit).

    // This call does nothing if there is no pending registrations.

    // Ignore errors.

    (void)pApaSession->RollbackNonNativeApplicationsUpdates();

    // Prepare for Java application registrations / unregistrations

    TRAP(err, pApaSession->PrepareNonNativeApplicationsUpdatesL());

    if (KErrNone != err)

    {

        // Close session and return error

        pApaSession->Close();

        return err;

    }

    // Return handle to session. Utilize the fact that in Symbian

    // all pointer addresses are MOD 4 so the last 2 bits are 0

    // and can be shifted out. This way the returned handle is

    // always positive whereas Symbian error codes are always negative.

    return reinterpret_cast<TUint>(pApaSession)>>2;

}

/**

 * Registers Java Application to S60 AppArc

 *

 * @param[in] aSessionHandle

 * @param[in] aUid The Uid of the application.

 * @param[in] aGroupName  Max group name len is 16 in AppArc

 * @param[in] aMIDletName

 * @param[in] aTargetDrive Must be "C:", "E:", ..., "J:"

 * @param[in] aIconFileName The name of the icon

 * @param[in] aJarFileName The full path name of the jar file

 * @param[in] aHidden

 * @param[in] aBackground

 * @return 0 if registration succeeded or Symbian error code

 */

JNIEXPORT jint JNICALL Java_com_nokia_mj_impl_installer_applicationregistrator_ApplicationRegistrator__1registerApplication

(JNIEnv */*aEnv*/, jclass /*aClass*/, jint /*aSessionHandle*/, jint /*aUid*/, jstring /*aGroupName*/,

 jstring /*aMIDletName*/, jstring /*aTargetDrive*/, jstring /*aIconFileName*/,

 jstring /*aJarFileName*/, jboolean /*aHidden*/, jboolean /*aBackground*/)

{

    return KErrNone;

}

JNIEXPORT jint JNICALL Java_com_nokia_mj_impl_installer_applicationregistrator_ApplicationRegistrator__1registerApplication

(JNIEnv *aEnv, jclass aClass, jint aSessionHandle, jint aUid, jstring aGroupName,

 jstring aMIDletName, jstring aTargetDrive, jstring aIconFileName,

 jstring aJarFileName, jboolean aHidden, jboolean aBackground)

{

    TInt err(KErrNone);

    TBool fStayInLoop(EFalse);

    HBufC16 *unicodeIconFileName(NULL);

    HBufC16 *unicodeGroupName(NULL);

    HBufC16 *unicodeMIDletName(NULL);

    HBufC16 *unicodeTargetDrive(NULL);

    HBufC16 *unicodeJarFileName(NULL);

    // create loop that is executed only once to make error handling easier

    do

    {

        // Copy the unicode characters in jstrings to Symbian buffers so that

        // they can be used in S60 code

        const jchar *iconFileName = aEnv->GetStringChars(aIconFileName, 0);

        if (NULL == iconFileName)

        {

            ELOG(

                EJavaInstaller,

                "Cannot register application, getting icon file name as unicode failed in JNI");

            err = KErrArgument;

            break;

        }

        unicodeIconFileName = HBufC16::New(aEnv->GetStringLength(aIconFileName) + 1);

        if (NULL == unicodeIconFileName)

        {

            err = KErrNoMemory;

            break;

        }

        *unicodeIconFileName = iconFileName;

        aEnv->ReleaseStringChars(aIconFileName, iconFileName);

        const jchar *groupName = aEnv->GetStringChars(aGroupName, 0);

        if (NULL == groupName)

        {

            ELOG(

                EJavaInstaller,

                "Cannot register application, getting group name as unicode failed in JNI");

            err = KErrArgument;

            break;

        }

        unicodeGroupName = HBufC16::New(aEnv->GetStringLength(aGroupName) + 1);

        if (NULL == unicodeGroupName)

        {

            err = KErrNoMemory;

            break;

        }

        *unicodeGroupName = groupName;

        aEnv->ReleaseStringChars(aGroupName, groupName);

        const jchar *midletName = aEnv->GetStringChars(aMIDletName, 0);

        if (NULL == midletName)

        {

            ELOG(

                EJavaInstaller,

                "Cannot register application, getting midlet name as unicode failed in JNI");

            err = KErrArgument;

            break;

        }

        unicodeMIDletName = HBufC16::New(aEnv->GetStringLength(aMIDletName) + 1);

        if (NULL == unicodeMIDletName)

        {

            err = KErrNoMemory;

            break;

        }

        *unicodeMIDletName = midletName;

        aEnv->ReleaseStringChars(aMIDletName, midletName);

        const jchar *targetDrive = aEnv->GetStringChars(aTargetDrive, 0);

        if (NULL == targetDrive)

        {

            ELOG(

                EJavaInstaller,

                "Cannot register application, getting target drive as unicode failed in JNI");

            err = KErrArgument;

            break;

        }

        unicodeTargetDrive = HBufC16::New(aEnv->GetStringLength(aTargetDrive) + 1);

        if (NULL == unicodeTargetDrive)

        {

            err = KErrNoMemory;

            break;

        }

        *unicodeTargetDrive = targetDrive;

        aEnv->ReleaseStringChars(aTargetDrive, targetDrive);

        const jchar *jarFileName = aEnv->GetStringChars(aJarFileName, 0);

        if (NULL == jarFileName)

        {

            ELOG(

                EJavaInstaller,

                "Cannot register application, getting jar file name as unicode failed in JNI");

            err = KErrArgument;

            break;

        }

        unicodeJarFileName = HBufC16::New(aEnv->GetStringLength(aJarFileName) + 1);

        if (NULL == unicodeTargetDrive)

        {

            err = KErrNoMemory;

            break;

        }

        *unicodeJarFileName = jarFileName;

        aEnv->ReleaseStringChars(aJarFileName, jarFileName);

    }

    while (fStayInLoop);

    if (KErrNone != err)

    {

        delete unicodeIconFileName;

        delete unicodeGroupName;

        delete unicodeMIDletName;

        delete unicodeTargetDrive;

        delete unicodeJarFileName;

        return err;

    }

    // Call the actual register method inside TRAP harness

    TInt ret = KErrNone;

    TRAP(err,

         ret = registerApplicationL(

                   aEnv, aClass, aSessionHandle, aUid, unicodeGroupName,

                   unicodeMIDletName, unicodeTargetDrive, unicodeIconFileName,

                   unicodeJarFileName, aHidden, aBackground));

    LOG1WSTR(

        EJavaInstaller,

        EInfo,

        "Registering application, midlet name (%s)",

        (wchar_t *)(unicodeMIDletName->Des().PtrZ()));

    LOG1WSTR(

        EJavaInstaller,

        EInfo,

        "Registering application, icon file name (%s)",

        (wchar_t *)(unicodeIconFileName->Des().PtrZ()));

    if (KErrNone != err)

    {

        ELOG1(EJavaInstaller,

              "Cannot register application, err code is %d ",

              err);

    }

    if (KErrNone != ret)

    {

        // error even though the code did not leave

        err = ret;

        ELOG1(EJavaInstaller,

              "Cannot register application, non-leaving error %d",

              ret);

    }

    // Free all Symbian buffers containing copies of jstring data

    delete unicodeIconFileName;

    delete unicodeGroupName;

    delete unicodeMIDletName;

    delete unicodeTargetDrive;

    delete unicodeJarFileName;

    return err;

}

/**

 * See JNI method __1registerApplication.

 * This method makes all calls that may leave (the actual registering)

 */

jint registerApplicationL(

    JNIEnv *, jclass, jint aSessionHandle, jint aUid, HBufC16 *aGroupName,

    HBufC16 *aMIDletName, HBufC16 *aTargetDrive, HBufC16 *aIconFileName,

    HBufC16 * /*aJarFileName*/, jboolean aHidden, jboolean aBackground)

{

    RFs         fileServ;

    RFile       appArcIcon;

    TUid        midletUid;

    TInt        err;

    TInt        numberOfIcons = KAppIconCount; // number of icons stored in MBM

    // Also default mbm has one icon.

    midletUid.iUid = aUid;

    // AppArc requires open RFile handle

    err = fileServ.Connect();

    if (KErrNone != err)

    {

        // Will not register application without icon

        ELOG1(EJavaInstaller,

              "Cannot open RFs connection, err code is %d ", err);

        return err;

    }

    CleanupClosePushL(fileServ);

    // The session must be shared so that AppArc can

    // use the same icon file handle

    err = fileServ.ShareProtected();

    if (KErrNone != err)

    {

        ELOG1(EJavaInstaller,

              "Cannot share file server session, err code is %d ", err);

        User::Leave(err);

    }

    // Default icon has been copied from ROM, so the icon may have ReadOnly

    // flag on. Must remove that flag.

    fileServ.SetAtt(*aIconFileName, 0, KEntryAttReadOnly);

    // open the icon

    err = appArcIcon.Open(

              fileServ,

              *aIconFileName,

              (EFileShareReadersOrWriters | EFileWrite));

    if (KErrNone != err)

    {

        ELOG1(EJavaInstaller,

              "registerApplicationL: Cannot open icon, err code is %d ", err);

        User::Leave(err);

    }

    // Now icon is open

    CleanupClosePushL(appArcIcon);

    // Generate the executable name name using the same

    // algorithm as used earlier in S60 platform

    // in case some external S60 application

    // needs to parse the Uid from the executable name.

    TFileName appName;

    appName.Copy(KPathSeperator);

    appName.AppendNum(midletUid.iUid);

    appName.Append(KAppPostfix);

    // Create writer needed for actual registration

    CApaRegistrationResourceFileWriter *writer = NULL;

    writer = CApaRegistrationResourceFileWriter::NewL(

                 midletUid,

                 appName,

                 TApaAppCapability::ENonNative);

    CleanupStack::PushL(writer);

    writer->SetGroupNameL(*aGroupName);

    if (aBackground)

    {

        // By default this is false, so the value needs to be set

        // only if it is true

        writer->SetLaunchInBackgroundL(ETrue);

    }

    if (aHidden)

    {

        // By default this is false, so the value needs to be set

        // only if it is true

        writer->SetAppIsHiddenL(ETrue);

    }

    // write application Uid to opaque data   (needed by MIDlet launcher)

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

    RDesWriteStream  writeStream(opaqueData);

    writeStream.WriteInt32L(midletUid.iUid);

    writeStream.CommitL();

    writer->SetOpaqueDataL(opaqueData);

    CApaLocalisableResourceFileWriter*  lWriter = NULL;

    lWriter =

        CApaLocalisableResourceFileWriter::NewL(

            KNullDesC,  // short caption

            *aMIDletName,  // caption

            numberOfIcons,

            KNullDesC);

    CleanupStack::PushL(lWriter);

    TDriveUnit targetDrive(*aTargetDrive);

    // Convert session handle to pointer.

    RApaLsSession *pApaSession =

        reinterpret_cast<RApaLsSession*>(aSessionHandle<<2);

    // Register application to AppArc

    pApaSession->RegisterNonNativeApplicationL(

        KMidletApplicationTypeUid,

        targetDrive,

        *writer,

        lWriter,

        &appArcIcon);

    CleanupStack::PopAndDestroy(lWriter);

    CleanupStack::PopAndDestroy(writer);

    // close icon file handle

    CleanupStack::PopAndDestroy(&appArcIcon);

    // close file server connection

    CleanupStack::PopAndDestroy(&fileServ);

    return err;

}

/**

 * Unregisters Java Application from S60 AppArc

 *

 * @param[in] aSessionHandle

 * @param[in] aUid The Uid of the application to be unregistered..

 * @return 0 if unregistration succeeded or Symbian error code

 */

JNIEXPORT jint JNICALL Java_com_nokia_mj_impl_installer_applicationregistrator_ApplicationRegistrator__1unregisterApplication

(JNIEnv *, jclass, jint /*aSessionHandle*/, jint /*aUid*/)

{

    return KErrNone;

}

JNIEXPORT jint JNICALL Java_com_nokia_mj_impl_installer_applicationregistrator_ApplicationRegistrator__1unregisterApplication

(JNIEnv *, jclass, jint aSessionHandle, jint aUid)

{

    // Convert session handle to pointer.

    RApaLsSession *pApaSession =

        reinterpret_cast<RApaLsSession*>(aSessionHandle<<2);

    TUid appUid;

    appUid.iUid = aUid;

    TRAPD(err, pApaSession->DeregisterNonNativeApplicationL(appUid));

    return err;

}

/**

 * Commits native application registration session.

 * If commit succeeds the native session is closed.

 *

 * @param[in] aSessionHandle

 * @param[in] aSynchronous if true, makes synchronous commit

 * @return 0 or Symbian error code (negative number)