diff -r f5050f1da672 -r 04becd199f91 javacommons/utils/src.s60/properties.cpp
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/javacommons/utils/src.s60/properties.cpp	Tue Apr 27 16:30:29 2010 +0300
@@ -0,0 +1,320 @@
+/*
+* Copyright (c) 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:
+*
+*/
+
+
+#include <memory>
+#include <jni.h>
+#include <f32file.h>
+#include <sysversioninfo.h>
+#include <versioninfo.h>
+#include <sysutil.h>
+#include <hal.h>
+
+#ifdef RD_JAVA_UI_QT
+
+#include <QLocale>
+
+#else // RD_JAVA_UI_QT
+
+#include <bautils.h>
+#include <barsc.h>
+#include <avkon.rsg>
+#include <AknUtils.h>
+
+#endif // RD_JAVA_UI_QT
+
+#include "javaenvinfo.h"
+#include "commonproperties.h"
+#include "javacommonutils.h"
+#include "exceptionbase.h"
+#include "logger.h"
+#include "s60commonutils.h"
+
+using namespace java::util;
+
+jstring getS60LocaleL(JNIEnv* env);
+
+#ifndef RD_JAVA_UI_QT
+
+HBufC* getS60LocaleTempImplL();
+
+#endif // RD_JAVA_UI_QT
+
+HBufC* MicroEditionPlatformL();
+TInt getHardwareVersionL(TDes& aHardwareType);
+
+const TUint KBufferSize = 32;
+_LIT(KMicroeditionPlatform,                     "S60");
+_LIT(KMicroeditionPlatformValueDefaultPrefix,   "Series60");
+_LIT(KMicroeditionPlatformName,      "sw_platform=");
+_LIT(KMicroeditionPlatformVersion,   "sw_platform_version=");
+_LIT(KMicroeditionPlatformJavaVersion, "java_build_version=");
+
+jstring java::util::getLocaleImpl(JNIEnv* env)
+{
+    JELOG2(EUtils);
+
+#ifdef RD_JAVA_UI_QT
+
+    QString localeName = QLocale::system().name();
+
+    jstring loc = env->NewString(localeName.utf16(), localeName.size());
+    if (!loc)
+    {
+        std::bad_alloc();
+    }
+    return loc;
+
+#else // RD_JAVA_UI_QT
+    jstring loc = 0;
+    HBufC* buf = 0;
+    bool usingTempSolution = false;
+    TRAPD(err, buf = AknLangUtils::DisplayLanguageTagL());
+    if (buf == 0 && err == KErrNotSupported)
+    {
+        //At the moment DisplayLanguageTagL must be called from
+        //UI thread. Once this is fixed by the Avkon, we must
+        //use temporary solution.
+        usingTempSolution = true;
+        TRAP(err, buf = getS60LocaleTempImplL());
+    }
+    if (buf == 0)
+    {
+        std::string errorStr = "Could not solve locale when using ";
+        if (usingTempSolution)
+        {
+            errorStr.append("temp");
+        }
+        else
+        {
+            errorStr.append("original");
+        }
+        errorStr.append(" solution. Leave code = ");
+        errorStr.append(JavaCommonUtils::intToString(err));
+        throw ExceptionBase(errorStr,
+                            __FILE__,__FUNCTION__,__LINE__);
+    }
+    const jchar* stringPtr = buf->Ptr();
+    const jsize stringLength = buf->Length();
+    loc = env->NewString(stringPtr, stringLength);
+    delete buf;
+    return loc;
+
+#endif // RD_JAVA_UI_QT
+}
+
+jstring java::util::getPlatformImpl(JNIEnv* aEnv)
+{
+    JELOG2(EUtils);
+
+
+    jstring platform = NULL;
+    std::auto_ptr<HBufC> propertyValue(0);
+
+    TRAP_IGNORE(propertyValue.reset(MicroEditionPlatformL()));
+    if (propertyValue.get())
+    {
+        platform = S60CommonUtils::NativeToJavaString(*aEnv,*propertyValue.get());
+    }
+    return platform;
+}
+
+#ifndef RD_JAVA_UI_QT
+
+HBufC* getS60LocaleTempImplL()
+{
+    JELOG2(EUtils);
+    _LIT(KFileName, "z:\\resource\\avkon.rsc");
+    TFileName fileName(KFileName);
+    RFs iRFs;
+    CleanupClosePushL(iRFs);
+    User::LeaveIfError(iRFs.Connect());
+    BaflUtils::NearestLanguageFile(iRFs, fileName);
+    RResourceFile resourceFile;
+    CleanupClosePushL(resourceFile);
+    resourceFile.OpenL(iRFs, fileName);
+    resourceFile.ConfirmSignatureL(0);
+    HBufC8* textBuf8 = resourceFile.AllocReadLC(R_QTN_LANGUAGE_RFC3066_TAG);
+    const TPtrC16 ptrBuf8((TText16*) textBuf8->Ptr(), (textBuf8->Length() + 1) >> 1);
+    HBufC16* tag = ptrBuf8.AllocL();
+    CleanupStack::PopAndDestroy(3);
+    return tag;
+
+}
+
+#endif // RD_JAVA_UI_QT
+
+HBufC* GetPlatformVersionL()
+{
+    VersionInfo::TPlatformVersion platformVersion;
+    User::LeaveIfError(VersionInfo::GetVersion(platformVersion));
+    TBuf<KBufferSize> version;
+
+    version.AppendNum(platformVersion.iMajorVersion);
+    version.Append('.');
+    version.AppendNum(platformVersion.iMinorVersion);
+
+    return version.AllocL();
+}
+
+HBufC* MicroEditionPlatformL()
+{
+    // First try to get the actual device name
+    // If the device name is not found the default value is used: Series60/
+    HBufC *productName= NULL;
+
+    TBuf<KBufferSize> hardwareType(0);
+    int retCode = getHardwareVersionL(hardwareType);
+
+    if (retCode == KErrNone && hardwareType.Length() > 0)
+    {
+        TInt slashAfterManufacturer = hardwareType.Locate('/');
+        TInt spaceAfterManufacturer = hardwareType.Locate(' ');
+        TPtrC productNameShort = hardwareType;
+
+        if ((slashAfterManufacturer != KErrNotFound) ||
+                (spaceAfterManufacturer != KErrNotFound))
+        {
+            if (slashAfterManufacturer == KErrNotFound)
+            {
+                productNameShort.Set(hardwareType.Left(
+                                         spaceAfterManufacturer));
+            }
+            else if (spaceAfterManufacturer == KErrNotFound)
+            {
+                productNameShort.Set(hardwareType.Left(
+                                         slashAfterManufacturer));
+            }
+            else
+            {
+                productNameShort.Set(hardwareType.Left(
+                                         slashAfterManufacturer < spaceAfterManufacturer ?
+                                         slashAfterManufacturer :
+                                         spaceAfterManufacturer));
+            }
+        }
+
+        productName = HBufC::NewL(productNameShort.Length());
+        productName->Des().Copy(productNameShort);
+    }
+
+    if (!productName)
+    {
+        productName = KMicroeditionPlatformValueDefaultPrefix().AllocLC();
+    }
+    else
+    {
+        CleanupStack::PushL(productName);
+    }
+
+    HBufC* platformName = NULL;
+
+    TBuf<KSysUtilVersionTextLength> swVersion;
+    if (SysUtil::GetSWVersion(swVersion) == KErrNone && swVersion.Length()>0)
+    {
+        // Assume syntax V xx.xx\ndd-mm-yy\nNHL-vvv\n(c)Vendor
+        TInt NLloc = swVersion.Locate('\n');
+        TPtrC verPtr = swVersion.Mid(2, NLloc-2); // skip "V " in the beginning
+
+        // Get platform minor and major version numbers
+        HBufC* platformVersionValue = GetPlatformVersionL();
+        CleanupStack::PushL(platformVersionValue);
+
+        // Get platform properties and values
+        HBufC* platformNameProperty = KMicroeditionPlatformName().AllocLC();
+        HBufC* platformNameValue = KMicroeditionPlatform().AllocLC();
+        HBufC* platformVersionProperty = KMicroeditionPlatformVersion().AllocLC();
+        HBufC* platformJavaVersionProperty = KMicroeditionPlatformJavaVersion().AllocLC();
+
+        // Get Java version number
+        TVersion versionInfo = Java::JavaEnvInfo::Version();
+        TVersionName versionName;
+        versionName.AppendNum(versionInfo.iMajor);
+        versionName.Append('.');
+        versionName.AppendNum(versionInfo.iMinor);
+        versionName.Append('.');
+        versionName.AppendNum(versionInfo.iBuild);
+        HBufC* platformJavaVersionValue = versionName.AllocL();
+        CleanupStack::PushL(platformJavaVersionValue);
+
+        // Calculate length of property string
+        TUint propertyLength = productName->Length() + 1 + verPtr.Length() + 1;
+        propertyLength += platformNameProperty->Length();
+        propertyLength += platformNameValue->Length() + 1;
+        propertyLength += platformVersionProperty->Length();
+        propertyLength += platformVersionValue->Length() + 1;
+        propertyLength += platformJavaVersionProperty->Length();
+        propertyLength += platformJavaVersionValue->Length();
+
+        // Concatenate properties
+        platformName = HBufC::NewL(propertyLength);
+        platformName->Des().Append(*productName);
+        platformName->Des().Append('/');
+        platformName->Des().Append(verPtr);
+        platformName->Des().Append('/');
+        platformName->Des().Append(*platformNameProperty);
+        platformName->Des().Append(*platformNameValue);
+        platformName->Des().Append(';');
+        platformName->Des().Append(*platformVersionProperty);
+        platformName->Des().Append(*platformVersionValue);
+        platformName->Des().Append(';');
+        platformName->Des().Append(*platformJavaVersionProperty);
+        platformName->Des().Append(*platformJavaVersionValue);
+
+        CleanupStack::PopAndDestroy(platformJavaVersionValue);
+        CleanupStack::PopAndDestroy(platformJavaVersionProperty);
+        CleanupStack::PopAndDestroy(platformVersionProperty);
+        CleanupStack::PopAndDestroy(platformNameValue);
+        CleanupStack::PopAndDestroy(platformNameProperty);
+        CleanupStack::PopAndDestroy(platformVersionValue);
+    }
+
+    CleanupStack::PopAndDestroy(productName);
+    return platformName;
+}
+
+jint java::util::getFreeMemoryImpl(JNIEnv*)
+{
+    JELOG2(EUtils);
+    int freeMemory = -1;
+    HAL::Get(HAL::EMemoryRAMFree, freeMemory);
+    return freeMemory;
+}
+
+TInt getHardwareVersionL(TDes& aHardwareType)
+{
+    SysVersionInfo::TProductVersion pVersion;
+
+    RFs fs;
+    User::LeaveIfError(fs.Connect());
+    CleanupClosePushL(fs);
+    TInt rc = SysVersionInfo::GetVersionInfo(pVersion, fs);
+
+    if (rc == KErrNone)
+    {
+        aHardwareType.Append(pVersion.iManufacturer);
+        aHardwareType.Append(pVersion.iModel);
+        aHardwareType.Append('/');
+        aHardwareType.Append(pVersion.iProduct);
+        aHardwareType.Append(pVersion.iRevision);
+        aHardwareType.Append(';');
+    }
+
+    CleanupStack::PopAndDestroy(&fs);
+    return rc;
+}
+