/*

* 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:  Implementation of CAppArcBackupUtil

*

*/

#include "apparcbackuputil.h"

#include "javaapparcutil.h"

#include "javasymbianoslayer.h"

#include "javauid.h"

#include "logger.h"

#include "javacommonutils.h"

#include "s60commonutils.h"

#include <apgcli.h>

#include <wchar.h>

#include <s32mem.h>

#include <sysutil.h>

#include <f32file.h>

#include <memory>

#include <string>

#ifndef SYMBIAN_ENABLE_SPLIT_HEADERS

#include <apgicnfl.h>

#else

#include <apgicnflpartner.h>

#endif

using namespace std;

using namespace java::storage;

using namespace java::backup;

const TUid  KMidletApplicationTypeUid = { 0x10210E26 };

_LIT(KDefaultFolder, "");

// ======== MEMBER FUNCTIONS ========

CAppArcBackupUtil::CAppArcBackupUtil()

{

    LOG(EBackup, EInfo, "CAppArcBackupUtil constructor");

}

void CAppArcBackupUtil::ConstructL(RFs& aFs)

{

    LOG(EBackup, EInfo, "CAppArcBackupUtil::ConstructL");

    User::LeaveIfError(iApparcServer.Connect());

    iNumberOfIcons = 0;

    iFs = aFs;

}

CAppArcBackupUtil* CAppArcBackupUtil::NewL(RFs& aFs)

{

    LOG(EBackup, EInfo, "CAppArcBackupUtil::NewL");

    CAppArcBackupUtil* self = new(ELeave) CAppArcBackupUtil();

    CleanupStack::PushL(self);

    self->ConstructL(aFs);

    CleanupStack::Pop();

    return self;

}

CAppArcBackupUtil::~CAppArcBackupUtil()

{

    LOG(EBackup, EInfo, "CAppArcBackupUtil destructor");

    iApparcServer.Close();

}

void CAppArcBackupUtil::RegisterAppL(TPtr8& aRestoreIconPtr, TDriveNumber& aDrive)

{

    LOG(EBackup, EInfo, "CAppArcBackupUtil::RegisterApp");

    RDesReadStream stream(aRestoreIconPtr);

    CleanupClosePushL(stream);

    // Read Uid

    int midletUid = stream.ReadUint32L();

    if (!CheckIfAlreadyRegisteredL(midletUid))

    {

        // Read filename

        TInt32 fileNameSize = stream.ReadInt32L();

        HBufC* fileName = HBufC::NewL(fileNameSize);

        CleanupStack::PushL(fileName);

        TPtr16 fileNamePtr = fileName->Des();

        stream.ReadL(fileNamePtr, fileNameSize / 2);   // half of size

        // Read number of icons

        TInt numberOfIcons = stream.ReadInt32L();

//        numberOfIcons = 1;

        //LOG1(EBackup, EInfo, "Number of Icons = %d", numberOfIcons);

        TInt groupNameSize = stream.ReadInt32L();

        TBuf<KApaMaxAppGroupName> groupName;

        if (groupNameSize != 0)

        {

            stream.ReadL(groupName, groupNameSize / 2);

        }

        // check disk space

        TInt index = sizeof(TUint32)    // midletUid

                     + sizeof(TInt32)                // size of fileNameSize

                     + fileNameSize                  // size of filename

                     + sizeof(TInt32)                // size of numberOfIcons

                     + sizeof(TInt32)                // group name size

                     + groupNameSize;                // groupname

        if (SysUtil::DiskSpaceBelowCriticalLevelL(&iFs, aRestoreIconPtr.Size() - index, aDrive))

        {

            ELOG(EBackup, "Disk space below critical level. Leaving with KErrDiskFull.");

            User::Leave(KErrDiskFull);

        }

        // Make directory if necessary

        iFs.CreatePrivatePath(aDrive);

        // Make full path of temporary icon file

        TPath tempPath;

        TPath tempPrivatePath;

        iFs.PrivatePath(tempPrivatePath);

        TDriveUnit* driveUnit = new(ELeave) TDriveUnit(aDrive);

        CleanupStack::PushL(driveUnit);

        tempPath.Append(driveUnit->Name().Left(1));

        tempPath.Append(KDriveDelimiter);

        tempPath.Append(tempPrivatePath);

        tempPath.Append(fileNamePtr);

        // Set private session path to point same drive where restoring

        iFs.SetSessionToPrivate(aDrive);

        RFile iconFile;

        User::LeaveIfError(iconFile.Create(iFs, fileNamePtr, EFileWrite));

        CleanupStack::PopAndDestroy(fileName);

        CleanupClosePushL(iconFile);

        iconFile.Write(aRestoreIconPtr.Mid(index));

        // Register application

        LOG1(EBackup,EInfo,"Registering app %d", midletUid);

        TUid uid = TUid::Uid(midletUid);

        TBuf<128>   appName;

        CJavaApparcUtil::AppName(uid, appName);

        CApaRegistrationResourceFileWriter* writer =

            CApaRegistrationResourceFileWriter::NewL(uid,

                    appName,

                    TApaAppCapability::ENonNative);

        CleanupStack::PushL(writer);

        const TInt  KOpaqueDataLength = 4;

        TBuf8<KOpaqueDataLength>    opaqueData;

        RDesWriteStream             writeStream(opaqueData);

        CleanupClosePushL(writeStream);

        LOG(EBackup, EInfo, "Getting midlet entry");

        JavaStorageApplicationEntry_t appEntries = StorageEntryL(uid);

        if (appEntries.size() == 0)

        {

            ELOG(EBackup, "No midlet entry found in Java Storage; Mismatch between AppArc and Storage data. Abort backup");

            User::Leave(KErrNotFound);

        }

        JavaStorageEntry attribute;

        attribute.setEntry(NAME, L"");

        // Get Name attribute from read attributes.

        JavaStorageApplicationEntry_t::const_iterator findIterator = appEntries.find(attribute);

        wstring midName;

        if (findIterator != appEntries.end())

        {

            midName = (*findIterator).entryValue();

        }

        else

        {

            User::Leave(KErrBadHandle);

        }

        appEntries.clear();

        HBufC* tempstr = java::util::S60CommonUtils::wstringToDes(midName.c_str());

        TPtrC midletName = tempstr->Des();

        if (groupNameSize != 0)

        {

            writer->SetGroupNameL(groupName);

        }

        else

        {

            writer->SetGroupNameL(KDefaultFolder);

        }

        writeStream.WriteUint32L(midletUid);

        writeStream.CommitL();

        LOG(EBackup, EInfo, "Setting opaque data");

        writer->SetOpaqueDataL(opaqueData);

        CApaLocalisableResourceFileWriter*  lWriter =

            CApaLocalisableResourceFileWriter::NewL(KNullDesC,

                                                    midletName,

                                                    numberOfIcons,

                                                    KNullDesC);

        CleanupStack::PushL(lWriter);

        // Prepare AppArc for deregistration

        LOG(EBackup, EInfo, "PrepareNonNativeApplicationsUpdatesL");

        iApparcServer.PrepareNonNativeApplicationsUpdatesL();

        // Register application

        LOG(EBackup, EInfo, "RegisterNonNativeApplicationL");

        iApparcServer.RegisterNonNativeApplicationL(KMidletApplicationTypeUid,

                aDrive,

                *writer,

                lWriter,

                &iconFile);

        // Commit registration changes

        LOG(EBackup, EInfo, "CommitNonNativeApplicationsUpdatesL");

        iApparcServer.CommitNonNativeApplicationsUpdatesL();

        delete tempstr;

        CleanupStack::PopAndDestroy(lWriter);

        CleanupStack::PopAndDestroy(&writeStream);

        CleanupStack::PopAndDestroy(writer);

        iconFile.Close();

        CleanupStack::PopAndDestroy(&iconFile);

        TInt err = iFs.Delete(tempPath);

        LOG1(EBackup, EInfo, "iFs.Delete err = %d", err);

        CleanupStack::PopAndDestroy(driveUnit);

    }

    CleanupStack::PopAndDestroy(&stream);

}

void CAppArcBackupUtil::DeregisterAppsL(TDriveNumber aDrive)

{

    LOG1(EBackup, EInfo, "CAppArcBackupUtil::DeregisterApps, drive: %d", aDrive);

    // Initialise the process of getting apps

    iApparcServer.GetFilteredApps(TApaAppCapability::ENonNative,

                                  TApaAppCapability::ENonNative);

    // Getting the apps one-by-one

    TApaAppInfo* info = new(ELeave) TApaAppInfo();

    CleanupStack::PushL(info);

    TUid typeUid;

    // Prepare AppArc for deregistration

    LOG(EBackup, EInfo, "PrepareNonNativeApplicationsUpdatesL");

    iApparcServer.PrepareNonNativeApplicationsUpdatesL();

    while (!iApparcServer.GetNextApp((*info)))

    {

        LOG1(EBackup, EInfo, "Getting Next App from AppArc, UID = %d", info->iUid);

        // Getting the type of the application

        iApparcServer.GetAppType(typeUid, info->iUid);

        // If it's a MIDlet, check if it has an entry in Java Registry

        TInt drive = 0;

        GetDriveOfApp(info->iFullName, drive);

        if (typeUid == KMidletApplicationTypeUid && drive == aDrive)

        {

            LOG1(EBackup, EInfo, "Checking registry, midlet id = %d", info->iUid);

            wstring PackageID;

            // If there's no entry on the drive, deregister it from AppArc

            JavaStorageApplicationEntry_t appEntries = StorageEntryL(info->iUid);

            if (appEntries.size() != 0)

            {

                JavaStorageEntry attribute;

                attribute.setEntry(PACKAGE_ID, L"");

                JavaStorageApplicationEntry_t::const_iterator findIterator = appEntries.find(attribute);

                if (findIterator != appEntries.end())

                {

                    PackageID = (*findIterator).entryValue();

                }

                else

                {

                    User::Leave(KErrBadHandle);

                }

                if (GetDrivefromStorageL(PackageID) != aDrive)

                {

                    iApparcServer.DeregisterNonNativeApplicationL(info->iUid);

                    LOG1(EBackup, EInfo, "Deregistering midlet id = %d", info->iUid);

                }

            }

            else

            {

                LOG(EBackup, EInfo, "Midlet entry not found in Java Storage; Deregister the Application");

                iApparcServer.DeregisterNonNativeApplicationL(info->iUid);

                LOG1(EBackup, EInfo, "Deregistering midlet id = %d", info->iUid);

            }

            appEntries.clear();

        }

    }

    // Commit registration changes

    LOG(EBackup, EInfo, "CommitNonNativeApplicationsUpdatesL");

    iApparcServer.CommitNonNativeApplicationsUpdatesL();

    CleanupStack::PopAndDestroy(info);

}

void CAppArcBackupUtil::GetMidletsFromAppArcL(RArray<TUid>& aUidArray, TDriveNumber aDrive)

{

    LOG(EBackup, EInfo, "CAppArcBackupUtil::GetMidletsFromAppArc");

    CleanupClosePushL(aUidArray);

    // Initialise the process of getting apps

    iApparcServer.GetFilteredApps(TApaAppCapability::ENonNative,

                                  TApaAppCapability::ENonNative);

    // Getting the apps one-by-one

    TApaAppInfo* info = new(ELeave) TApaAppInfo();

    CleanupStack::PushL(info);

    TUid typeUid;

    LOG1(EBackup, EInfo, "Drive Number aDrive = %d", aDrive);

    while (!iApparcServer.GetNextApp((*info)))

    {

        // Getting the type of the application

        iApparcServer.GetAppType(typeUid, info->iUid);

        // If it's a MIDlet, check if it's registered to this drive

        if (typeUid == KMidletApplicationTypeUid)

        {

            JavaStorageApplicationEntry_t appEntries = StorageEntryL(info->iUid);

            if (appEntries.size() != 0)

            {

                JavaStorageEntry attribute;

                attribute.setEntry(PACKAGE_ID, L"");

                JavaStorageApplicationEntry_t::const_iterator findIterator = appEntries.find(attribute);

                wstring PackageID;

                if (findIterator != appEntries.end())

                {

                    PackageID = (*findIterator).entryValue();

                }

                else

                {

                    User::Leave(KErrBadHandle);

                }

                appEntries.clear();

                if (GetDrivefromStorageL(PackageID) == aDrive)

                {

                    aUidArray.AppendL(info->iUid);

                    iNumberOfIcons++;

                }

            }

            else

            {

                ELOG(EBackup, "No entries from registry; midlet does not exist");

            }

        }

    }

    CleanupStack::PopAndDestroy(info);

    CleanupStack::Pop();

}

void CAppArcBackupUtil::GetIconFilename(TUid aUid, HBufC*& aFullFileName)

{

    LOG(EBackup, EInfo, "CAppArcBackupUtil::GetIconFilename");

    iApparcServer.GetAppIcon(aUid, aFullFileName);

}

TInt CAppArcBackupUtil::NumberOfIcons()

{

    LOG(EBackup, EInfo, "CAppArcBackupUtil::NumberOfIcons");

    return iNumberOfIcons;

}

void CAppArcBackupUtil::NumberOfOwnDefinedIcons(TUid aUid, TInt& aIconCount)

{

    LOG(EBackup, EInfo, "CAppArcBackupUtil::NumberOfOwnDefinedIcons");

    iApparcServer.NumberOfOwnDefinedIcons(aUid, aIconCount);

}

TBool CAppArcBackupUtil::CheckIfAlreadyRegisteredL(TInt& aUid)

{

    LOG(EBackup, EInfo, "CAppArcBackupUtil::CheckIfAlreadyRegisteredL");

    TApaAppInfo* info = new(ELeave) TApaAppInfo();

    TInt err = iApparcServer.GetAppInfo(*info, TUid::Uid(aUid));

    delete info;

    if (err == KErrNone)

    {

        return ETrue;

    }

    else

    {

        return EFalse;

    }

}

void CAppArcBackupUtil::GetDriveOfApp(TFileName aPath, TInt& aDrive)

{

    LOG(EBackup, EInfo, "CAppArcBackupUtil::DriveOfApp");

    iFs.CharToDrive(aPath[0], aDrive);

}

TApaAppGroupName CAppArcBackupUtil::GetMidletGroupName(TUid aUid)

{

    TApaAppCapabilityBuf cap;

    TInt err = iApparcServer.GetAppCapability(cap, aUid);

    return cap().iGroupName;

}

JavaStorageApplicationEntry_t CAppArcBackupUtil::StorageEntryL(const TUid& aMidletUID)

{

    auto_ptr<JavaStorage> js(JavaStorage::createInstance());

    try

    {

        js->open(JAVA_DATABASE_NAME);

        LOG(EBackup, EInfo, "Java database opened");

    }

    catch (JavaStorageException jse)

    {

        ELOG(EBackup, "Opening database connection failed");

        User::Leave(KErrNotFound);

    }

    JavaStorageApplicationEntry_t entries;

    java::util::Uid appUid;

    TUidToUid(aMidletUID, appUid);

    try

    {

        js->read(APPLICATION_TABLE, appUid, entries);

    }

    catch (JavaStorageException jse)

    {

        ELOG(EBackup, "Read in Java Storage failed");

        js->close();

        User::Leave(KErrGeneral);

    }

    js->close();

    return entries;

}

TDriveNumber CAppArcBackupUtil::GetDrivefromStorageL(wstring& aPackageID)

{

    wchar_t Drive;

    auto_ptr<JavaStorage> js(JavaStorage::createInstance());

    try

    {

        js->open(JAVA_DATABASE_NAME);

    }

    catch (JavaStorageException jse)

    {

        ELOG(EBackup, "Opening database connection failed");

        User::Leave(KErrNotFound);

    }

    JavaStorageApplicationEntry_t entries;

    java::util::Uid PackageID(aPackageID);

    try

    {

        js->read(APPLICATION_PACKAGE_TABLE, PackageID, entries);

    }

    catch (JavaStorageException jse)

    {

        ELOG(EBackup, "Read in Java Storage failed");

        js->close();

        User::Leave(KErrGeneral);

    }

    js->close();

    JavaStorageEntry attribute;