/*

 * Copyright (c) 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:  ?Description

 *

 */

#include <HbParameterLengthLimiter>

#include <HbExtendedLocale>

#include <QMetaType>

#include <QScopedPointer>

#include <QStringList>

#include <QDateTime>

#undef SYMBIAN_ENABLE_SPLIT_HEADERS //TODO this is work around

#include <usif/scr/screntries.h>

#include <usif/scr/scr.h>

#include <xqconversions.h>

#include <driveinfo.h>

#include "cauninstallnotifier.h"

#include "cauninstallnotifier_p.h"

#include "casoftwareregistry.h"

#include "casoftwareregistry_p.h"

#include "cadefs.h"

#include "caarraycleanup.inl"

using namespace Usif;

_LIT(KConfirmMessageKey, "MIDlet-Delete-Confirm");

_LIT(KCaScrPropertyDomainCategory, "Domain-Category");

_LIT(KCaScrPropertyMidletDescryption, "MIDlet-Description");

const int maxLogsCount = 20;  // should be 50 - workaround for 

// ou1cimx1#476143 Dialog crash when label contains big amount of lines

/*!

 Constructor

 \param servicePublic Pointer to object of the public class.

 */

CaSoftwareRegistryPrivate::CaSoftwareRegistryPrivate(

        CaSoftwareRegistry *servicePublic):

    m_q(servicePublic)

{

}

/*!

 Destructor.

 */

CaSoftwareRegistryPrivate::~CaSoftwareRegistryPrivate()

{

}

/*!

 Provides details needed for uninstalling process of Java applications.

 \param[in] componentId component id of an application to be uninstalled.

 \param[out] componentName a name of the component.

 \param[out] applicationsUids a list of uids of applications in the package

      of the given component id.

 \param[out] confirmationMessage optional deletion confirmation message,

      null string means the lack of the message.

 \retval true if there is no error.

 */

bool CaSoftwareRegistryPrivate::getUninstallDetails(int componentId,

        QString &componentName,

        QStringList &applicationsUids,

        QString &confirmationMessage)

{

    TRAPD(error, getUninstallDetailsL(componentId,

            componentName,

            applicationsUids,

            confirmationMessage)

             );

    return error == KErrNone;

}

/*!

 Provides a list of uids of applications installed by the given package.

 \param[in] componentId component id of an application to be uninstalled.

 \param[out] applicationsUids a list of uids of applications in the package

      of the given component id.

 \retval true if there is no error.

 */

bool CaSoftwareRegistryPrivate::getApplicationsUids(int componentId,

        QStringList &applicationsUids)

{

    TRAPD(error, getApplicationsUidsL(componentId, applicationsUids));

    return error == KErrNone;

}

/*!

 Provides details needed for uninstalling process of Java applications

   (leaving version).

 \param[in] componentId component id of an application to be uninstalled.

 \param[out] componentName a name of the component.

 \param[out] applicationsUids a list of uids of applications in the package

      of the given component id.

 \param[out] confirmationMessage optional deletion confirmation message,

      null string means the lack of the message.

 */

void CaSoftwareRegistryPrivate::getUninstallDetailsL(int componentId,

        QString &componentName,

        QStringList &appUids,

        QString &confirmationMessage)

{

    componentName.clear();

    appUids.clear();

    confirmationMessage.clear();

    if (componentId >= 1) {

        TComponentId componentIdValue(componentId);

        RArray<TUid> appUidsArray;

        CleanupClosePushL(appUidsArray);

        CLocalizablePropertyEntry *confirmationMessageProperty = NULL;

        RSoftwareComponentRegistry softwareComponentRegistry;

        CleanupClosePushL(softwareComponentRegistry);

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

        CComponentEntry *entry = CComponentEntry::NewLC();

        softwareComponentRegistry.GetComponentL(componentId, *entry);

        softwareComponentRegistry.GetAppUidsForComponentL(

                componentIdValue, appUidsArray);

        CPropertyEntry *confirmationProperty

                = softwareComponentRegistry.GetComponentPropertyL(

                        componentId, KConfirmMessageKey);

        if (confirmationProperty

                && confirmationProperty->PropertyType()

                        == CPropertyEntry::ELocalizedProperty) {

            confirmationMessageProperty

                    = static_cast<CLocalizablePropertyEntry *>(

                            confirmationProperty);

        } else {

            delete confirmationProperty;

            confirmationProperty = NULL;

        }

        QT_TRYCATCH_LEAVING(componentName =

            XQConversions::s60DescToQString(entry->Name());

            for (TInt i = 0; i<appUidsArray.Count(); i++) {

                appUids.append(QString::number(appUidsArray[i].iUid));

            }

            if (confirmationMessageProperty) {

                confirmationMessage = XQConversions::s60DescToQString(

                        confirmationMessageProperty->StrValue());

            }

        );

        CleanupStack::PopAndDestroy(3, &appUidsArray);

    }

}

/*!

 Provides details needed for uninstalling process of Java applications

   (leaving version).

 \param[in] componentId component id of an application to be uninstalled.

 \param[out] applicationsUids a list of uids of applications in the package

      of the given component id.

 */

void CaSoftwareRegistryPrivate::getApplicationsUidsL(int componentId,

    QStringList &appUids)

{

    appUids.clear();

    if (componentId >= 1) {

        TComponentId componentIdValue(componentId);

        RArray<TUid> appUidsArray;

        CleanupClosePushL(appUidsArray);

        RSoftwareComponentRegistry softwareComponentRegistry;

        CleanupClosePushL(softwareComponentRegistry);

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

        softwareComponentRegistry.GetAppUidsForComponentL(

                componentIdValue, appUidsArray);

        QT_TRYCATCH_LEAVING(

            for (TInt i = 0; i<appUidsArray.Count(); i++) {

                appUids.append(QString::number(appUidsArray[i].iUid));

            }

        );

        CleanupStack::PopAndDestroy(2, &appUidsArray);

    }

}

/*!

 \param componentId Component id of the entry which details are requested for.

 \return Map of component details if component id was greater than 0 or

 empty map otherwise.

 */

CaSoftwareRegistryPrivate::DetailMap CaSoftwareRegistryPrivate::entryDetails(

    int componentId) const

{

    CaSoftwareRegistry::DetailMap result;

    TRAP_IGNORE(result=entryDetailsL(componentId));

    return result;

}

/*!

 \param componentId Component id of the entry which details are requested for.

 \return Map of component details if component id was greater than 0 or

 empty map otherwise.

 */

CaSoftwareRegistryPrivate::DetailMap CaSoftwareRegistryPrivate::entryDetailsL(

    int componentId) const

{

    CaSoftwareRegistry::DetailMap result;

    if (componentId >= 1) {

        RSoftwareComponentRegistry scr;

        CleanupClosePushL(scr);

        if (scr.Connect() == KErrNone) {

            CComponentEntry* entry = CComponentEntry::NewLC();

            if (scr.GetComponentL(componentId, *entry)) {

                result = entryDetailsL(*entry);

                if (entry->SoftwareType().Compare(KSoftwareTypeJava) == 0) {

                    CPropertyEntry* domainProperty =

                        scr.GetComponentPropertyL(componentId,

                            KCaScrPropertyDomainCategory);

                    CleanupStack::PushL(domainProperty);

                    if (domainProperty &&

                        domainProperty->PropertyType() ==

                            CPropertyEntry::ELocalizedProperty) {

                        result[CaSoftwareRegistry::componentProtectionDomainKey()] =

                            XQConversions::s60DescToQString(

                                static_cast<CLocalizablePropertyEntry*>(

                                    domainProperty)->StrValue());

                    }

                    CPropertyEntry *midletDescryption =

                        scr.GetComponentPropertyL(componentId,

                            KCaScrPropertyMidletDescryption);

                    CleanupStack::PushL(midletDescryption);

                    if (midletDescryption &&

                        midletDescryption->PropertyType() ==

                            CPropertyEntry::ELocalizedProperty) {

                        result[CaSoftwareRegistry::componentDescriptionKey()] =

                            XQConversions::s60DescToQString(

                                static_cast<CLocalizablePropertyEntry*>(

                                    midletDescryption)->StrValue());

                    }

                    CleanupStack::PopAndDestroy(midletDescryption);

                    CleanupStack::PopAndDestroy(domainProperty);

                }

            }

            CleanupStack::PopAndDestroy(entry);

        }

        CleanupStack::PopAndDestroy(&scr);

    }

    return result;

}

/*!

 \param entry Software registry entry providing details.

 \return Map with details for the component represented by \entry.

 */

CaSoftwareRegistryPrivate::DetailMap CaSoftwareRegistryPrivate::entryDetailsL(

    const CComponentEntry& entry) const

{

    CaSoftwareRegistry::DetailMap detailMap;

    detailMap[CaSoftwareRegistry::componentNameKey()] =

        XQConversions::s60DescToQString(entry.Name());

    detailMap[CaSoftwareRegistry::componentVersionKey()] =

        XQConversions::s60DescToQString(entry.Version());

    detailMap[CaSoftwareRegistry::componentVendorKey()] =

        XQConversions::s60DescToQString(entry.Vendor());

    QString drives;

    QString drv;

    TChar drive;

    const TInt driveListLen(entry.InstalledDrives().Length());

    for (TInt i( 0 ); i < driveListLen; ++i) {

        if (entry.InstalledDrives()[i] != '\0') {

            if (!drives.isEmpty()) {

                drives = drives.append(",");

            }

            drv = QString(QChar('A'+ i)).append(":");

            if(DriveInfo::GetDefaultDrive(

                    DriveInfo::EDefaultPhoneMemory, drive ) == KErrNone

                    && QChar('A'+ i) == QChar(drive)) {

                drives = drives.append(HbParameterLengthLimiter(

                        "txt_applib_dialog_1_device_memory").arg(

                                QString(QChar('A'+ i))));

            } else if(DriveInfo::GetDefaultDrive(

                    DriveInfo::EDefaultMassStorage, drive ) == KErrNone

                    && QChar('A'+ i) == QChar(drive)) {

                drives = drives.append(HbParameterLengthLimiter(

                        "txt_applib_dialog_1_mass_storage").arg(

                                QString(QChar('A'+ i))));

                } else if(DriveInfo::GetDefaultDrive(

                    DriveInfo::EDefaultRemovableMassStorage, drive ) == KErrNone

                    && QChar('A'+ i) == QChar(drive)) {

                RFs fs;

                CleanupClosePushL(fs);

                if (fs.Connect() == KErrNone) {

                    TInt driveNumber;

                    TVolumeInfo tv;

                    DriveInfo::GetDefaultDrive(

                            DriveInfo::EDefaultRemovableMassStorage,

                            driveNumber );

                    User::LeaveIfError(fs.Volume(tv, driveNumber));

                    if(tv.iName.Length()) {

                        drives = drives.append(HbParameterLengthLimiter(

                                "txt_applib_dialog_1_2").arg(

                                        QString(QChar('A'+ i))).arg(

                                                XQConversions::s60DescToQString(

                                                        tv.iName)));

                    } else {

                        drives = drives.append(HbParameterLengthLimiter(

                                "txt_applib_dialog_1_memory_card").arg(

                                        QString(QChar('A'+ i))));

                    }

                }

                CleanupStack::PopAndDestroy(&fs);

            } else {

                drives = drives.append(QChar('A'+ i)).append(":");

            }

        }

    }

    detailMap[CaSoftwareRegistry::componentDriveInfoKey()] = drives;

    static const TInt64 KKilo = 1024;

    static const TInt64 KMega = KKilo * KKilo;

    if(entry.ComponentSize() >= KMega) {

        detailMap[CaSoftwareRegistry::componentSizeKey()]

                  = HbParameterLengthLimiter("txt_applib_dialog_l1_mb").arg(

                          static_cast<double>(entry.ComponentSize() / KMega));

    } else {

        detailMap[CaSoftwareRegistry::componentSizeKey()]

                  = HbParameterLengthLimiter("txt_applib_dialog_l1_kb").arg(

                          static_cast<double>(entry.ComponentSize() / KKilo));

    }

    detailMap[CaSoftwareRegistry::componentTypeKey()] =

        XQConversions::s60DescToQString(entry.SoftwareType());

    return detailMap;

}

/*!

 \param entry Software registry entry providing details.

 \return Map with details for the component represented by \entry.

 */

QList<CaSoftwareRegistryPrivate::DetailMap>

        CaSoftwareRegistryPrivate::retrieveLogEntries() const

{

    QList<CaSoftwareRegistryPrivate::DetailMap> logMap;

    TRAP_IGNORE(logMap = retrieveLogEntriesL());

    return logMap;

}

/*!

 Creating uninstall notifier

 \return CaUninstallNotifier instance

 */

CaUninstallNotifier *CaSoftwareRegistryPrivate::createUninstallNotifier() const

{

    return CaUninstallNotifier::notifier();

}

/*!

 \param entry Software registry entry providing installation log.

 \return List of Maps with installation log.

 */

QList<CaSoftwareRegistryPrivate::DetailMap>

        CaSoftwareRegistryPrivate::retrieveLogEntriesL() const

{

    QList<CaSoftwareRegistryPrivate::DetailMap> logList;

    RSoftwareComponentRegistry scr;

    CleanupClosePushL(scr);

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

    RPointerArray<CScrLogEntry> logEntries;

    CleanupResetAndDestroyPushL(logEntries);

    scr.RetrieveLogEntriesL(logEntries);

    // 50 log items or less - ui spec

    TInt lastLog(0);

    if (logEntries.Count() > maxLogsCount) {

        lastLog = logEntries.Count() - maxLogsCount;

    }

    // iteration through most recent log to the last

    for (TInt i = logEntries.Count() - 1; i >= lastLog; i--) {

        CScrLogEntry* entry = logEntries[i];

        DetailMap logMap;

        logMap[CaSoftwareRegistry::componentNameKey()]

               = XQConversions::s60DescToQString(entry->ComponentName());

        logMap[CaSoftwareRegistry::componentVersionKey()]

               = XQConversions::s60DescToQString(entry->ComponentVersion());

        logMap[CaSoftwareRegistry::componentTimeKey()]

               = operationTime(entry->OperationTime());

        logMap[CaSoftwareRegistry::componentOperationTypeKey()]

               = operationTypeL(entry->OperationType());

        logList.append(logMap);

    }

    CleanupStack::PopAndDestroy(&logEntries);

    CleanupStack::PopAndDestroy(&scr);

    return logList;

}

/*!

 \param operation type.

 \return string representing operation type.

 */

QString CaSoftwareRegistryPrivate::operationTypeL(int operationType) const

{

    QString opType;

    switch (operationType) {

        case EScrCompInstall:

            opType = CaSoftwareRegistry::componentInstallValue();

            break;

        case EScrCompUnInstall:

            opType = CaSoftwareRegistry::componentUninstallValue();

            break;

        case EScrCompUpgrade:

            opType = CaSoftwareRegistry::componentUpgradeValue();

            break;

        case EScrCompHidden:

            opType = CaSoftwareRegistry::componentHiddenValue();

            break;

        default:

            User::Leave(KErrNotSupported);

            break;

    }

    return opType;

}

/*!

 \param operation type.

 \return string representing operation type.

 */

QString CaSoftwareRegistryPrivate::operationTime(TTime time) const

{

    TDateTime dt = time.DateTime();

    QDate date(dt.Year(), dt.Month() + 1, dt.Day() + 1);

    HbExtendedLocale hbLoc;

    return hbLoc.format(date, r_qtn_date_usual_with_zero);

}