/*

* Copyright (c) 2009-2010 Nokia Corporation and/or its subsidiary(-ies).

* All rights reserved.

* This component and the accompanying materials are made available

* under the terms of the License "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: 

* Implements the test steps for component management APIs in the SCR

*

*/

#include "appreginfoapparcsteps.h"

#include "tscrdefs.h"

#include <scs/cleanuputils.h>

#include <barsread.h> 

using namespace Usif;

void CScrGetApplicationRegistrationViewSubsessionStep::PrintPerformanceLog(TTime aTime)

    {

    TDateTime timer = aTime.DateTime();

    INFO_PRINTF6(_L("%S,%d:%d:%d:%d"), &KPerformanceTestInfo(), timer.Hour(), timer.Minute(), timer.Second(), timer.MicroSecond());

    }

void CScrGetApplicationRegistrationViewSubsessionStep::StartTimer()

    {

    iStartTime.HomeTime();

    PrintPerformanceLog(iStartTime);

    }

void CScrGetApplicationRegistrationViewSubsessionStep::StopTimerAndPrintResultL()

    {

    TTime endTime;

    endTime.HomeTime();

    PrintPerformanceLog(endTime);

    TTimeIntervalMicroSeconds duration = endTime.MicroSecondsFrom(iStartTime);

    TInt actualDuration = I64INT(duration.Int64())/1000; // in millisecond

    TInt maxDuration = 0;

    if(!GetIntFromConfig(ConfigSection(), KMaxDurationName, maxDuration))

        {

        ERR_PRINTF2(_L("%S could not be found in configuration."), &KMaxDurationName());

        User::Leave(KErrNotFound);

        }

    else

        {

        INFO_PRINTF3(_L("%S,%d"), &KMaxTestCaseDuration(), maxDuration);

        INFO_PRINTF3(_L("%S,%d"), &KActualTestCaseDuration(), actualDuration);

        }

    if(actualDuration <= maxDuration)

        {

        INFO_PRINTF2(_L("This test meets performance requirement (Duration=%d)."), actualDuration);

        }

    else

        {

        ERR_PRINTF2(_L("This test does not meet performance requirement (Duration=%d)."), actualDuration);

        SetTestStepResult(EFail);

        }

    }

void CScrGetApplicationRegistrationViewSubsessionStep::GenerateIndexedAttributeNameL(TDes& aInitialAttributeName, TInt aIndex)

    {

    const TInt MAX_INT_STR_LEN = 8;

    TBuf<MAX_INT_STR_LEN> integerAppendStr;

    integerAppendStr.Format(_L("%d"), aIndex);

    aInitialAttributeName.Append(integerAppendStr);

    }

void CScrGetApplicationRegistrationViewSubsessionStep::GetAppOwnedFilesL(RPointerArray<HBufC>& aOwnedFileArray,HBufC* aConfigSection)

    {

    TInt ownedFileCount = 0;

    HBufC* configsection;

    if(aConfigSection == NULL)

       configsection = ConfigSection().AllocL();

    else

       configsection = aConfigSection->AllocL();

    GetIntFromConfig(*configsection, _L("OwnedFileCount"), ownedFileCount);

    for (TUint i = 0; i < ownedFileCount; ++i)

        {

        TPtrC tOwnedFileName;

        TBuf<20> fileName;

        fileName = KOwnedFileName;

        GenerateIndexedAttributeNameL(fileName, i);

        GetStringFromConfig(*configsection, fileName, tOwnedFileName);

        HBufC* ownedFileName = tOwnedFileName.AllocLC();

        aOwnedFileArray.AppendL(ownedFileName);

        CleanupStack::Pop(ownedFileName);

        }

    delete configsection;

    }

TBool CScrGetApplicationRegistrationViewSubsessionStep::GetUidFromConfig(const TDesC& aSectName, const TDesC& aKeyName, TUid& aUid)

    {

    TInt val;

    if(GetHexFromConfig(aSectName, aKeyName, val))

        {

        aUid = TUid::Uid(val);

        return ETrue;

        }

    else

        {

        return EFalse;

        }

    }

void CScrGetApplicationRegistrationViewSubsessionStep::PrintErrorL(const TDesC& aMsg, TInt aErrNum,...)

    {

    VA_LIST list;

    VA_START(list, aErrNum);

    RBuf msgBuf;

    msgBuf.CreateL(MAX_SCR_ERROR_MESSAGE_LENGTH);

    msgBuf.CleanupClosePushL();

    msgBuf.AppendFormatList(aMsg, list);

    ERR_PRINTF1(msgBuf);

    SetTestStepResult(EFail);

    CleanupStack::PopAndDestroy(&msgBuf);

    User::Leave(aErrNum);

    }

void CScrGetApplicationRegistrationViewSubsessionStep::GetAppUidL(TUid& aAppUid, HBufC* aConfigSection)

    {    

    HBufC* configsection;

    if(aConfigSection == NULL)

       configsection = ConfigSection().AllocL();

    else

       configsection = aConfigSection->AllocL();

    if (!GetUidFromConfig(*configsection, _L("AppUid"), aAppUid))

        {

        delete configsection;

        PrintErrorL(_L("AppUid was not found!"), KErrNotFound);        

        }    

    INFO_PRINTF2(_L("AppUid is 0x%x"), aAppUid.iUid);

    delete configsection;

    }

void CScrGetApplicationRegistrationViewSubsessionStep::GetAppServiceInfoL(

        RPointerArray<CServiceInfo>& aServiceInfoArray, HBufC* aConfigSection)

    {

    TInt serviceInfoCount = 0;

    TInt totalOpaqueDataCount = 0;

    TInt totalServiceDataTypeCount = 0;

    HBufC* configsection;

    if (aConfigSection == NULL)

        configsection = ConfigSection().AllocL();

    else

        configsection = aConfigSection->AllocL();

    GetIntFromConfig(*configsection, _L("ServiceInfoCount"),

            serviceInfoCount);

    for (TUint i = 0; i < serviceInfoCount; ++i)

        {

        // service Uid

        TBuf<20> uid;

        TUid serviceUid;

        uid = KServiceUid;

        GenerateIndexedAttributeNameL(uid, i);

        GetUidFromConfig(*configsection, uid, serviceUid);

        // service opaque data

        RPointerArray<COpaqueData> serviceOpaqueDataInfoArray;

        TBuf<27> servOpaqueDataCountStr;

        servOpaqueDataCountStr = KServiceOpaqueDataInfoCount;

        GenerateIndexedAttributeNameL(servOpaqueDataCountStr, i);

        TInt serviceOpaqueDataInfoCount = 0;

        GetIntFromConfig(*configsection, servOpaqueDataCountStr, serviceOpaqueDataInfoCount);

        GetServiceOpaqueDataInfoL(serviceOpaqueDataInfoArray, serviceOpaqueDataInfoCount, totalOpaqueDataCount, configsection);

        totalOpaqueDataCount += serviceOpaqueDataInfoCount;

        //GetServiceOpaqueDataInfoL(serviceOpaqueDataInfoArray);

        //CleanupStack::PushL(&serviceOpaqueDataInfoArray);

        // service data type

        TBuf<21> serviceDataTypeCountString;

        serviceDataTypeCountString = KServiceDataTypeCount;

        GenerateIndexedAttributeNameL(serviceDataTypeCountString, i);

        TInt serviceDataTypeCount = 0;

        GetIntFromConfig(*configsection, serviceDataTypeCountString,

                serviceDataTypeCount);

        totalServiceDataTypeCount += serviceDataTypeCount;

        RPointerArray<CDataType> serviceDataTypeArray;

        for (TUint j = 0; j < serviceDataTypeCount; ++j)

            {

            TInt indexToRead = totalServiceDataTypeCount

                    - serviceDataTypeCount + j;

            TInt serviceDataTypePriority;

            TPtrC serviceType;

            TBuf<25> priority, type;

            priority = KServiceDataTypePriority;

            GenerateIndexedAttributeNameL(priority, indexToRead);

            GetIntFromConfig(*configsection, priority,

                    serviceDataTypePriority);

            type = KServiceDataType;

            GenerateIndexedAttributeNameL(type, indexToRead);

            GetStringFromConfig(*configsection, type, serviceType);

            CDataType* serviceDataType = CDataType::NewLC(

                    serviceDataTypePriority, serviceType);

            serviceDataTypeArray.AppendL(serviceDataType);

            CleanupStack::Pop(serviceDataType);

            }

        CServiceInfo* serviceInfo = CServiceInfo::NewLC(serviceUid,

                serviceOpaqueDataInfoArray, serviceDataTypeArray);

        aServiceInfoArray.AppendL(serviceInfo);

        CleanupStack::Pop(serviceInfo);

        }

    delete configsection;

    }

void CScrGetApplicationRegistrationViewSubsessionStep::GetAppLocalizableInfoL(RPointerArray<CLocalizableAppInfo>& aLocalizableAppInfoArray, HBufC* aConfigSection)

    {

    TInt localizableAppInfoCount = 0;

    TInt totalViewDataCount=0;

    HBufC* configsection;

    if(aConfigSection == NULL)

      configsection = ConfigSection().AllocL();

    else

      configsection = aConfigSection->AllocL();

    GetIntFromConfig(*configsection, _L("LocalizableAppInfoCount"), localizableAppInfoCount);

    for (TUint i = 0; i < localizableAppInfoCount; ++i)

        {

        TPtrC locShortCaption;

        TLanguage locLanguage = (TLanguage)0;

        TInt lang;

        TPtrC locGroupName;

        TBuf<20> shortCaption, language, groupName, viewDataCount;

        shortCaption = KLocShortCaption;

        GenerateIndexedAttributeNameL(shortCaption, i);

        GetStringFromConfig(*configsection, shortCaption, locShortCaption);

        language = KLocAppLanguage;

        GenerateIndexedAttributeNameL(language, i);

        GetIntFromConfig(*configsection, language, lang);

        locLanguage = static_cast<TLanguage>(lang);

        groupName = KLocGroupName;

        GenerateIndexedAttributeNameL(groupName, i);

        GetStringFromConfig(*configsection, groupName, locGroupName);

        TPtrC locCaption;

        TPtrC locIconFileName;

        TInt locNoOfAppIcons = 0;

        TBuf<20> caption, iconFileName, noOfAppIcons;

        caption = KLocCaption;

        GenerateIndexedAttributeNameL(caption, i);

        GetStringFromConfig(*configsection, caption, locCaption);

        iconFileName = KLocIconFileName;

        GenerateIndexedAttributeNameL(iconFileName, i);

        GetStringFromConfig(*configsection, iconFileName, locIconFileName);

        noOfAppIcons = KLocNumberOfAppIcons;

        GenerateIndexedAttributeNameL(noOfAppIcons, i);

        GetIntFromConfig(*configsection, noOfAppIcons, locNoOfAppIcons);

        CCaptionAndIconInfo* captionAndIconInfo = NULL;

        if(locCaption.Length() != 0 || locIconFileName.Length() !=0 || locNoOfAppIcons != 0)

          {

           captionAndIconInfo = CCaptionAndIconInfo::NewLC(locCaption,locIconFileName,locNoOfAppIcons);

          }

        else

          CleanupStack::PushL(captionAndIconInfo);

        TInt viewDataCountForLocale = 0;

        viewDataCount=KViewDataCount;

        GenerateIndexedAttributeNameL(viewDataCount, i);

        GetIntFromConfig(*configsection, viewDataCount , viewDataCountForLocale);

        totalViewDataCount+=viewDataCountForLocale;

        RPointerArray<CAppViewData> viewDataArray;

        for (TUint i = 0; i < viewDataCountForLocale; ++i)

            {

            TInt viewScreenMode = 0 ,vUid,indexToRead;

            TBuf<20> uid, screenMode;

            uid = KVwUid;

            indexToRead=totalViewDataCount-viewDataCountForLocale+i;

            GenerateIndexedAttributeNameL(uid, indexToRead);

            GetIntFromConfig(*configsection, uid, vUid);

            TUid viewUid = TUid::Uid(vUid);

            screenMode = KVwScreenMode;

            GenerateIndexedAttributeNameL(screenMode, indexToRead);

            GetIntFromConfig(*configsection, screenMode, viewScreenMode);

            TPtrC viewCaption;

            TPtrC viewIconFileName;

            TInt viewNoOfAppIcons = 0;

            TBuf<20> caption, iconFileName, noOfAppIcons;

            caption = KVwCaption;

            GenerateIndexedAttributeNameL(caption, indexToRead);

            GetStringFromConfig(*configsection, caption, viewCaption);

            iconFileName = KVwIconFileName;

            GenerateIndexedAttributeNameL(iconFileName, indexToRead);

            GetStringFromConfig(*configsection, iconFileName, viewIconFileName);

            noOfAppIcons = KVwNumberOfAppIcons;

            GenerateIndexedAttributeNameL(noOfAppIcons, indexToRead);

            GetIntFromConfig(*configsection, noOfAppIcons, viewNoOfAppIcons);

            CCaptionAndIconInfo* viewCaptionAndIconInfo = NULL;

            if(viewCaption.Length() != 0 || viewIconFileName.Length() !=0 || viewNoOfAppIcons != 0)

              {

               viewCaptionAndIconInfo = CCaptionAndIconInfo::NewLC(viewCaption,viewIconFileName,viewNoOfAppIcons);

              }

            else

              CleanupStack::PushL(viewCaptionAndIconInfo);          

            CAppViewData* viewData = CAppViewData::NewLC(viewUid,viewScreenMode,viewCaptionAndIconInfo);

            viewDataArray.AppendL(viewData);

            CleanupStack::Pop(2, viewCaptionAndIconInfo);

            }

        CLocalizableAppInfo* localizableAppInfo = CLocalizableAppInfo::NewLC(locShortCaption,locLanguage,locGroupName,captionAndIconInfo,viewDataArray);

        aLocalizableAppInfoArray.AppendL(localizableAppInfo);

        CleanupStack::Pop(localizableAppInfo);

        CleanupStack::Pop(captionAndIconInfo);

        }

    delete configsection;

    }

void CScrGetApplicationRegistrationViewSubsessionStep::GetAppOpaqueDataInfoL(RPointerArray<Usif::COpaqueData>& aAppOpaqueDataInfoArray, HBufC* aConfigSection)

    {

    TInt appOpaqueDataInfoCount = 0;

    HBufC* configsection;

    if(aConfigSection == NULL)

      configsection = ConfigSection().AllocL();

    else

      configsection = aConfigSection->AllocL();

    GetIntFromConfig(*configsection, _L("AppOpaqueDataInfoCount"), appOpaqueDataInfoCount);

    for (TUint i = 0; i < appOpaqueDataInfoCount; ++i)

        {

        TBuf<16> localeAttr;

        localeAttr = KAppOpaqueDataLocale;

        TInt locale = 0;

        GenerateIndexedAttributeNameL(localeAttr, i);

        GetIntFromConfig(*configsection, localeAttr, locale);

        TBuf<14> opaqueDataAttr;

        opaqueDataAttr = KAppOpaqueData;

        TPtrC opaqueData;

        GenerateIndexedAttributeNameL(opaqueDataAttr, i);

        GetStringFromConfig(*configsection, opaqueDataAttr, opaqueData);

        TPtrC8 blobOpaqueData((TUint8*)opaqueData.Ptr(), opaqueData.Length()*2);

        COpaqueData* appOpaqueData = COpaqueData::NewLC(blobOpaqueData, (TLanguage) locale);

        aAppOpaqueDataInfoArray.AppendL(appOpaqueData);

        CleanupStack::Pop(1, appOpaqueData);

        }

    delete configsection;

    }

void CScrGetApplicationRegistrationViewSubsessionStep::GetServiceOpaqueDataInfoL(RPointerArray<Usif::COpaqueData>& aServiceOpaqueDataInfoArray, TInt aServiceOpaqueDataInfoCount, TInt aStartingIndex, HBufC* aConfigSection)

    {

    for (TUint i = 0; i < aServiceOpaqueDataInfoCount; ++i)

        {

        TBuf<20> localeAttr;

        localeAttr = KServiceOpaqueLocale;

        TInt locale = 0;

        TInt indexToRead = i + aStartingIndex;

        GenerateIndexedAttributeNameL(localeAttr, indexToRead);

        GetIntFromConfig(*aConfigSection, localeAttr, locale);

        TBuf<18> opaqueDataAttr;

        opaqueDataAttr = KServiceOpaqueData;

        TPtrC opaqueData;

        GenerateIndexedAttributeNameL(opaqueDataAttr, indexToRead);

        GetStringFromConfig(*aConfigSection, opaqueDataAttr, opaqueData);

        TPtrC8 blobOpaqueData((TUint8*)opaqueData.Ptr(), opaqueData.Length()*2);

        COpaqueData* serviceOpaqueData = COpaqueData::NewLC(blobOpaqueData, (TLanguage) locale);

        aServiceOpaqueDataInfoArray.AppendL(serviceOpaqueData);

        CleanupStack::Pop(1, serviceOpaqueData);

        }    

    }

TBool CScrGetApplicationRegistrationViewSubsessionStep::Get64BitIntegerFromConfigL(const TDesC& aConfigKeyName, TInt64& aRetVal,HBufC* aConfigSection)

    {

    TPtrC int64Str;

    HBufC* configsection;

        if(aConfigSection == NULL)

            configsection = ConfigSection().AllocLC();

        else

            configsection = aConfigSection->AllocLC();

    if (!GetStringFromConfig(*configsection, aConfigKeyName, int64Str))

        return EFalse;

    TLex lex(int64Str);

    User::LeaveIfError(lex.Val(aRetVal));

    CleanupStack::PopAndDestroy(configsection);

    return ETrue;

    }

CPropertyEntry* CScrGetApplicationRegistrationViewSubsessionStep::GetPropertyFromConfigLC(TBool aIsSingle, TInt aIndex, TBool aSupportLocalized,HBufC* aConfigSection)

    {

    // This function can be used for getting a single property, which is defined by attributes such as PropertyName etc.

    // or a property in a set - in this case the properties would be PropertyType0, PropertyName0 etc.

    // aIsSingle defines the working mode. aIndex applies only if aIsSingle is false

    // First, we need to generate the property name

    TBuf<MAX_SCR_PARAM_LENGTH> propertyTypeParam, propertyNameParam, propertyValueParam, propertyLocaleParam;

    propertyTypeParam = KPropertyTypeParam;

    propertyNameParam = KPropertyNameParam;

    propertyValueParam = KPropertyValueParam;

    propertyLocaleParam = KPropertyLocaleParam;

    if (!aIsSingle)

        {

        GenerateIndexedAttributeNameL(propertyTypeParam, aIndex);

        GenerateIndexedAttributeNameL(propertyNameParam, aIndex);

        GenerateIndexedAttributeNameL(propertyValueParam, aIndex);

        GenerateIndexedAttributeNameL(propertyLocaleParam, aIndex);

        }

    HBufC* configsection;

    if(aConfigSection == NULL)

        configsection = ConfigSection().AllocLC();

    else

        configsection = aConfigSection->AllocLC();

    TPtrC propertyName;

    if (!GetStringFromConfig(*configsection, propertyNameParam, propertyName))

        {

        ERR_PRINTF2(_L("The property name param %S could not be found in configuration."), &propertyNameParam);

        User::Leave(KErrNotFound);

        }

    TInt propertyTypeInt;

    if (!GetIntFromConfig(*configsection, propertyTypeParam, propertyTypeInt))

        {

        ERR_PRINTF2(_L("The property type param %S could not be found in configuration."), &propertyTypeParam);

        User::Leave(KErrNotFound);

        }

    CPropertyEntry::TPropertyType propertyType = static_cast<CPropertyEntry::TPropertyType>(propertyTypeInt);

    CPropertyEntry* propertyEntry(NULL);

    switch (propertyType)

        {

        case CPropertyEntry::EBinaryProperty:

        case CPropertyEntry::ELocalizedProperty:

            {

            TPtrC propertyStrValue;

            if (!GetStringFromConfig(*configsection, propertyValueParam, propertyStrValue))

                {

                ERR_PRINTF2(_L("The property value param %S could not be found in configuration."), &propertyValueParam);

                User::Leave(KErrNotFound);

                }

            if(!aSupportLocalized || propertyType == CPropertyEntry::EBinaryProperty)

                {

                HBufC8* buffer8Bit = ConvertBufferTo8bitL(propertyStrValue);

                CleanupStack::PushL(buffer8Bit);

                propertyEntry = CBinaryPropertyEntry::NewL(propertyName, *buffer8Bit);

                CleanupStack::PopAndDestroy(buffer8Bit);

                break;

                }

            // Handle ELocalProperty case

            TLanguage locale;

            TInt localeParam;

            if (!GetIntFromConfig(*configsection, propertyLocaleParam, localeParam))

                {

                ERR_PRINTF2(_L("The property locale param %S could not be found in configuration."), &propertyLocaleParam);

                User::Leave(KErrNotFound);  

                }

            locale = static_cast<TLanguage>(localeParam);

            propertyEntry = CLocalizablePropertyEntry::NewL(propertyName, propertyStrValue, locale);

            break;                      

            }

        case CPropertyEntry::EIntProperty:

            {

            TInt64 int64Value;

            if (!Get64BitIntegerFromConfigL(propertyValueParam, int64Value, configsection))

                {

                ERR_PRINTF2(_L("The integer param %S could not be found in configuration."), &propertyValueParam);

                User::Leave(KErrNotFound);

                }

            propertyEntry = CIntPropertyEntry::NewL(propertyName, int64Value);

            break;

            }           

        }

    CleanupStack::PopAndDestroy(configsection);

    CleanupStack::PushL(propertyEntry);

    return propertyEntry;

    }

void CScrGetApplicationRegistrationViewSubsessionStep::GetAppPropertiesL(RPointerArray<CPropertyEntry>& aAppPropertyArray,TBool aSupportLocalized, HBufC* aConfigSection)

    {

    TInt propertiesCount = 0;  

    HBufC* configsection;

    if(aConfigSection == NULL)

      configsection = ConfigSection().AllocLC();

    else

      configsection = aConfigSection->AllocLC();

    if (!GetIntFromConfig(*configsection, KPropertiesCountParamName, propertiesCount))

       {

        INFO_PRINTF1(_L("Properties count was not found!"));

        CleanupStack::PopAndDestroy(configsection);

        return;

        }

    if (propertiesCount < 0)

        {

        INFO_PRINTF1(_L("Properties count was negative !"));

        CleanupStack::PopAndDestroy(configsection);

        return;

        }

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

        {

        CPropertyEntry *propertyEntry = GetPropertyFromConfigLC(EFalse, i, aSupportLocalized,configsection);

        User::LeaveIfError(aAppPropertyArray.Append(propertyEntry));

        CleanupStack::Pop(propertyEntry);

        }

    CleanupStack::PopAndDestroy(configsection);

    }

CApplicationRegistrationData* CScrGetApplicationRegistrationViewSubsessionStep::GetAppRegInfoFromConfigLC(HBufC* aConfigSection )

    {

    TUid appUid;

    HBufC* configsection;

    if(aConfigSection == NULL)

       configsection = ConfigSection().AllocLC();

    else

       configsection = aConfigSection->AllocLC();