/*

* Copyright (c) 2008 - 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: Java platform 2.0 javaappconverter process

*

*/

#include <e32base.h>

#include <apgcli.h>

#include <pathinfo.h>

#include <driveinfo.h>

#include "silentmidletconvert.h"

#include "javauids.h"

#include "javacommonutils.h"

#include "logger.h"

#include "javaprocessconstants.h"

#include "javasymbianoslayer.h"

using namespace java::util;

_LIT(KJarFileNameSuffix, ".jar");

_LIT(KJadFileNameSuffix, ".jad");

_LIT(KFLJarFileNameSuffix, ".dm");

_LIT(KSDJarFileNameSuffix, ".dcf");

_LIT(KSMCBackSplash, "\\");

// The directory where the java applications to be converted are searched from

_LIT(KMidletSuiteInstallBasePath, ":\\Private\\102033E6\\MIDlets\\");

/**

 * To create new instance of this class.

 *

 * @param aFs - A reference to the file server.

 * @return Reference to the object of this class.

 * @exception If construction fails.

 *

 */

CSilentMIDletConvert* CSilentMIDletConvert::NewLC(RFs& aFs)

{

    CSilentMIDletConvert* self = new(ELeave) CSilentMIDletConvert(aFs);

    CleanupStack::PushL(self);

    self->ConstructL();

    return self;

}

/**

 * To do 1st phase construction for this object.

 *

 * Adds this active object to the scheduler.

 *

 * @param aFs - A reference to the file server.

 */

CSilentMIDletConvert::CSilentMIDletConvert(RFs& aFs) :

        CActive(EPriorityStandard), iFs(aFs), iNumberOfAppsToInstall(0),

        iDefaultTargetInstallationDrive(-1)

{

    CActiveScheduler::Add(this);

}

/**

 * To do 2nd phase construction for this object.

 *

 * @exception If the method is not able to allocate necessary buffers.

 */

void CSilentMIDletConvert::ConstructL()

{

    JELOG2(EJavaConverters);

    iConvertServer = new(ELeave) ConvertServer();

}

/**

 * Deletes this object.

 * All allocated resources are released.

 */

CSilentMIDletConvert::~CSilentMIDletConvert()

{

    JELOG2(EJavaConverters);

    Cancel();

    iInstallFiles.ResetAndDestroy();

    iInstallFiles.Close();

    iDirs.ResetAndDestroy();

    iDirs.Close();

    delete iConvertServer;

    iConvertServer = NULL;

}

/**

 * To start silent installation.

 */

void CSilentMIDletConvert::Start()

{

    JELOG2(EJavaConverters);

    iState = EFindOutDeviceDrives;

    CompleteRequest();

}

/**

 * To stop whole preinstaller.

 * Stops the active scheduler.

 */

void CSilentMIDletConvert::Exit()

{

    Deque();

    CActiveScheduler::Stop();

}

/**

 * To complete the request for this object.

 *

 * @Postconditions The following conditions are true immediately after

 * returning from this method.

 * - iStatus == KErrNone

 * - IsActive() == ETrue

 */

void CSilentMIDletConvert::CompleteRequest()

{

    JELOG2(EJavaConverters);

    TRequestStatus *status = &iStatus;

    User::RequestComplete(status, KErrNone);

    if (!IsActive())

    {

        SetActive();

    }

}

/**

 * To run this active object.

 *

 * The state logic is:

 *

 * EFindOutDeviceDrives: find out all non-remote drives in the device

 *    - mark externally mountable drives (removable drives)

 *    - mark read only drives (ROM)

 *

 * EFindOutDrivesToBeScannedNow: make list of drives to be scanned

 *    - start with all mounted drives

 *

 * EAppsInInstalledDirectories: go through all directories in iDirs one by one

 *  and find all java applications in the subdirectories of the directory

 *    - if only .jar/.dcf/.dm file is found it is added to iInstallFiles

 *    - if .jad file is found, it is added to iInstallFiles

 *

 * ECheckWhichAppsShouldBeConverted: for each java application check from

 *  AppArc whether it should be converted

 *    - if the application has been installed, convert it

 *

 * EExecuteConvertServer: give list of install files to preinstall server,

 *  start Java Installer in poll mode, start convert server in another thread,

 *  convert server will give the names of the .jad or .jar/.dcf/.dm files to Java Installer

 *  when it polls them,  convert server will log whether each installation

 *  succeeded. After all install files have been polled, convert server will ask

 *  Java Installer to exit. After that this active object moves to next state.

 *

 * EMarkConversionDone: remove 'uids' data file created by javaapppreconverter

 *

 * EExit: free resources and exit

 *

 */

void CSilentMIDletConvert::RunL()

{

    JELOG2(EJavaConverters);

    switch (iState)

    {

    case EFindOutDeviceDrives:

    {

        LOG(EJavaConverters, EInfo,

            "CSilentMIDletConvert::RunL EFindOutDeviceDrives");

        GetAllDeviceDrivesL();

        iState = EFindOutDrivesToBeScannedNow;

        CompleteRequest();

    }

    break;

    case EFindOutDrivesToBeScannedNow:

    {

        LOG(EJavaConverters, EInfo,

            "CSilentMIDletConvert::RunL EFindOutDrivesToBeScannedNow");

        TChar driveChar = 'C';

        // forget old search directories

        iDirs.ResetAndDestroy();

        for (TInt drive = 0; drive < KMaxDrives; drive++)

        {

            // All present drives will be scanned for

            // java applications to be converted

            if (iDriveStatuses[drive] & DriveInfo::EDrivePresent)

            {

                (void)iFs.DriveToChar(drive, driveChar);

                // The base Java application install directory in this

                // drive must be scanned.

                // Reserve memory also for drive letter and terminating zero

                // for logging.

                HBufC *baseInstallDir = HBufC::NewLC(KMidletSuiteInstallBasePath().Length() + 2);

                TPtr dirPtr(baseInstallDir->Des());

                dirPtr.Append(driveChar);

                dirPtr.Append(KMidletSuiteInstallBasePath());

                // Add new search directory

                iDirs.AppendL(baseInstallDir);

                CleanupStack::Pop(baseInstallDir);

            }

        }

        iState = EAppsInInstalledDirectories;

        CompleteRequest();

    }

    break;

    case EAppsInInstalledDirectories:

    {

        LOG(EJavaConverters, EInfo,

            "CSilentMIDletConvert::RunL EAppsInInstalledDirectories");

        GetInstallFilesL(iDirs);

        iState = ECheckWhichAppsShouldBeConverted;

        CompleteRequest();

    }

    break;

    case ECheckWhichAppsShouldBeConverted:

    {

        LOG(EJavaConverters, EInfo,

            "CSilentMIDletConvert::RunL ECheckWhichAppsShouldBeConverted");

        // Check all Jad / Jar files in iInstallFiles and remove those

        // that need not be converted (those that cannot be found from

        // AppArc). Updates also iNumberOfAppsToInstall

        CheckNeedToInstall();

        iState = EExecuteConvertServer;

        CompleteRequest();

    }

    break;

    case EExecuteConvertServer:

    {

        LOG(EJavaConverters, EInfo,

            "CSilentMIDletConvert::RunL EExecuteConvertServer");

        if (iNumberOfAppsToInstall > 0)

        {

            // Install all MIDlet Suites still in iInstallFiles.

            // Pass iInstallFiles to ConvertServer

            iConvertServer->setInstallFiles(iInstallFiles);

            // Start the server

            int err = iConvertServer->start();

            if (0 != err)

            {

                // server cannot be started

                ELOG1(EJavaConverters,

                      "Cannot start convert server, err %d", err);

            }

            // Starts Java Installer, waits until Java Installer exits

            RunJavaInstallerL();

            iState = EMarkConversionDone;

        }

        else

        {

            iState = EMarkConversionDone;

            CompleteRequest();

        }

    }

    break;

    case EMarkConversionDone:

    {

        // If this line is executed, converting old midlets succeeded.

        // Remove the 'uids' data file so that conversion will not be

        // done again if OMJ sis package is installed again to the same device.

        RemoveDataFile();

        iState = EExit;

        CompleteRequest();

    }

    break;

    case EExit:

    {

        LOG(EJavaConverters, EInfo, "CSilentMIDletConvert::RunL EExit");

        // Stops the server if it is running

        iConvertServer->stop();

        FullCleanup();

        // The whole javaappconverter process is stopped.

        Exit();

    }

    break;

    }

}

/**

 * To handle leave from RunL.

 * This method exits this active object using normal state machine

 * After calling this method this active object will exit.

 *

 * @param aError - A reason of error.

 * @return KErrNone.

 */

TInt CSilentMIDletConvert::RunError(TInt aError)

{

    ELOG2(EJavaConverters,

          "CSilentMIDletConvert::RunError(%d) from state %d", aError, iState);

    Cancel();

    iState = EExit;

    CompleteRequest();

    return KErrNone;

}

/**

 * To do cancelling for this object.

 *

 */

void CSilentMIDletConvert::DoCancel()

{

    ELOG1(EJavaConverters,

          "CSilentMIDletConvert::DoCancel from state %d", iState);

    // Check whether convert server must be stopped

    if (iState == EExecuteConvertServer)

    {

        // Stops the server if it is running

        iConvertServer->stop();

    }

}

/**

 * Add .jad files in the directories specified in aDirs to iInstallFiles.

 * If a directory does not contain a .jad file but it contains a .jar/.dcf/.dm file,

 * add that file to iInstallFiles

 *

 * @param aDirs - An array of directories to be scanned.

 * @exception Unable to alloc memory for the internal buffers.

 * @exception Unable to get directory's contents.

 */

void CSilentMIDletConvert::GetInstallFilesL(RPointerArray<HBufC>& aDirs)

{

    JELOG2(EJavaConverters);

    // Number of MIDlet installation base directories to scan,

    // one directory per local drive

    const TInt nBaseDirs = aDirs.Count();

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

    {

        TFileName suitePath;

        // Form base directory path, MIDlets have been installed

        // to subdirectories of this directory

        const TPtrC& dir = ((HBufC *)(aDirs[i]))->Des();

        TFileName baseSuitePath = dir;

        CDir *entryList;

        CDir *dirList;

        TInt err = iFs.GetDir(baseSuitePath, KEntryAttMatchMask, ESortNone, entryList, dirList);

        if (KErrNone != err)

        {

            WLOG1WSTR(EJavaConverters,

                      "CSilentMIDletConvert::GetInstallFilesL Cannot list directory %s",

                      (wchar_t *)(baseSuitePath.PtrZ()));

            // If no S60 Java application has been installed to the drive,

            // the directory does not exist but it is OK

            if (KErrPathNotFound != err)

            {

                User::Leave(err);

            }

            continue;

        }

        // Only midlet installation directory entries are meaningfull,

        // discard other possible entries

        delete entryList;

        TInt   nCount = dirList->Count();

        TEntry dirEntry;

        for (TInt nInd = 0; nInd < nCount; nInd++)

        {

            dirEntry = (*dirList)[nInd];

            // Just to make sure this really is subdirectory

            if (dirEntry.IsDir())

            {

                // Is this midlet suite subdir?

                // Midlet suite subdirs look like this "[102b567B]"

                // Must parse the value of the Uid as unsigned int to avoid

                // overflow

                TUint32 nUid;

                TLex   lexer(dirEntry.iName);

                lexer.Inc();

                err = lexer.Val(nUid, EHex);

                if (KErrNone != err)

                {

                    // Not midlet suite subdir, skip it

                    continue;

                }

                // Does the subdirectory contain any Jar files?

                suitePath = baseSuitePath;

                suitePath.Append(dirEntry.iName);

                suitePath.Append(KSMCBackSplash);

                CDir *suiteDirEntryList;

                err = iFs.GetDir(suitePath, KEntryAttMatchMask, ESortNone, suiteDirEntryList);

                if (KErrNone != err)

                {

                    ELOG1WSTR(EJavaConverters,

                              "CSilentMIDletConvert::GetInstallFilesL Cannot list content of suite dir %s",

                              (wchar_t *)(suitePath.PtrZ()));

                    User::Leave(err);

                    return;

                }

                // If there is .jad or Jar file in suiteDirEntryList, adds

                // it to iInstallFiles.

                // Recognizes also DRM protected Jar files (.dm, .dcf)

                AddJadJarToInstallFilesL(suitePath, suiteDirEntryList);

                delete suiteDirEntryList;

            }

        } // for - loop all directory entries in a base installation directories

        delete dirList;

    } // for - loop all base installation directories

    if (iInstallFiles.Count() == 0)

    {

        WLOG(EJavaConverters,

             "CSilentMIDletConvert::GetInstallFilesL No MIDlets to convert");

    }

}

/**

 * Check all Jad / Jar files in iInstallFiles and remove those

 * that need not be converted. Updates also iNumberOfAppsToInstall.

 */

void CSilentMIDletConvert::CheckNeedToInstall()

{

    // It is too late to check from AppArc whether the application is a

    // valid java application or no. The Java registry dll:s have been eclipsed and

    // old apps are now invalid.

    // javaapppreconverter has stored the Uids of the valid midlets to 'uids' file

    // in to the data subdirectory of this process.

    // ReadMidletUids() can be used to read the uids of the valid midlets to array.

    // If uid is in the array, it is valid.

    TFileName uidsDataFilePathName(KUidsImportDataFilePathName);

    RArray<TUid> validUids = ReadMidletUids(uidsDataFilePathName);

    // loop through iInstallFiles one be one

    TInt   nNumberOfAppsToInstall = 0;

    TInt   err;

    TInt   nFiles = iInstallFiles.Count();

    TParse fp;

    for (TInt nInd = 0; nInd < nFiles; nInd++)

    {

        // get the directory path of the current iInstallFiles[nInd]

        err = fp.Set(*(iInstallFiles[nInd]), NULL, NULL);

        if (KErrNone != err)

        {

            WLOG1(EJavaConverters,

                  "CSilentMIDletConvert::CheckNeedToInstall Cannot parse install file name %s",

                  iInstallFiles[nInd]);

            continue;

        }

        TPtrC installDir = fp.DriveAndPath();

        // read Java applications uid(s) from 'uids' file in the directory

        RArray<TUid> appUids = ReadMidletUids(installDir);

        // For each app uid, check whether it is uid of an valid java  application.

        // If yes, make conversion installation for the .jad/Jar file

        // in this directory.

        TInt nIndUids;

        TInt nCountUids = appUids.Count();

        for (nIndUids = 0; nIndUids < nCountUids; nIndUids++)

        {

            err = validUids.Find(appUids[nIndUids]);

            if (KErrNotFound == err)

            {

                LOG1(EJavaConverters, EInfo,

                     "CSilentMIDletConvert::CheckNeedToInstall Midlet with Uid %x "

                     "was not registered to AppArc",

                     appUids[nIndUids].iUid);

                // Do not convert any app in this Midlet suite

                delete iInstallFiles[nInd];

                iInstallFiles[nInd] = NULL;

                break;

            }

            else

            {

                // The application is valid, so it should be converted

                nNumberOfAppsToInstall++;

            }

        }

        appUids.Close();