/****************************************************************************

**

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

** All rights reserved.

** Contact: Nokia Corporation (qt-info@nokia.com)

**

** This file is part of the Qt Mobility Components.

**

** $QT_BEGIN_LICENSE:LGPL$

** No Commercial Usage

** This file contains pre-release code and may not be distributed.

** You may use this file in accordance with the terms and conditions

** contained in the Technology Preview License Agreement accompanying

** this package.

**

** GNU Lesser General Public License Usage

** Alternatively, this file may be used under the terms of the GNU Lesser

** General Public License version 2.1 as published by the Free Software

** Foundation and appearing in the file LICENSE.LGPL included in the

** packaging of this file.  Please review the following information to

** ensure the GNU Lesser General Public License version 2.1 requirements

** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.

**

** In addition, as a special exception, Nokia gives you certain additional

** rights.  These rights are described in the Nokia Qt LGPL Exception

** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.

**

** If you have questions regarding the use of this file, please contact

** Nokia at qt-info@nokia.com.

**

**

**

**

**

**

**

**

** $QT_END_LICENSE$

**

****************************************************************************/

#include "qsysteminfo.h"

#include "qsysteminfo_s60_p.h"

#include <QStringList>

#include <QDir>

#include <QRegExp>

#include <QTimer>

#include <QList>

#include <sysutil.h>

#ifdef HB_SUPPORTED

#include <hbinputkeymapfactory.h>

#include <hbinputlanguage.h>

#else

#include <ptiengine.h>

#endif // HB_SUPPORTED

#include <featdiscovery.h>

#ifndef KFeatureIdMmc

#include <featureinfo.h>

#endif

#include <hwrmvibra.h>

#include <AknUtils.h>

#include <w32std.h>

#include <centralrepository.h>

#include <MProEngEngine.h>

#include <ProEngFactory.h>

#include <MProEngNotifyHandler.h>

#include <btserversdkcrkeys.h>

#include <bt_subscribe.h>

#include <bttypes.h>

#include <etel3rdparty.h>

#include <aknkeylock.h>

#define RD_STARTUP_CHANGE

#include <startupdomainpskeys.h>

QTM_BEGIN_NAMESPACE

QSystemInfoPrivate::QSystemInfoPrivate(QObject *parent)

    : QObject(parent)

{

}

QSystemInfoPrivate::~QSystemInfoPrivate()

{

}

QString QSystemInfoPrivate::currentLanguage() const

{

    return TLanguageToISO639_1(User::Language());

}

#ifdef HB_SUPPORTED

QStringList QSystemInfoPrivate::availableLanguages() const

{

    QStringList languages;

    QList<HbInputLanguage> hblanguages = HbKeymapFactory::availableLanguages();

    foreach(HbInputLanguage lang, hblanguages) {       

        QString language = QLocaleToISO639_1(lang.language());

        if (!language.isEmpty()) {

            languages << language;

        }

    }

    languages.removeDuplicates();

    return languages;

}  

#else

QStringList QSystemInfoPrivate::availableLanguages() const

{

    QStringList languages;

    TRAP_IGNORE(

        CPtiEngine *ptiEngine = CPtiEngine::NewL();

        CleanupStack::PushL(ptiEngine);

        RArray<TInt> languageCodes;

        CleanupClosePushL(languageCodes);

        ptiEngine->GetAvailableLanguagesL(languageCodes);

        for (int i = 0; i < languageCodes.Count(); ++i) {

            QString language = TLanguageToISO639_1(TLanguage(languageCodes[i]));

            if (!language.isEmpty()) {

                languages << language;

            }

        }

        CleanupStack::PopAndDestroy(2, ptiEngine);

    )

    languages.removeDuplicates();

    return languages;

}

#endif //HB_SUPPORTED

QString QSystemInfoPrivate::QLocaleToISO639_1(QLocale::Language language) const    

{

       switch(language) {

       case QLocale::English: return "en";

       case QLocale::Lithuanian: return "lt";

       case QLocale::Malay: return "ms";

       case QLocale::Polish: return "pl";

       case QLocale::Portuguese: return "pt";

       case QLocale::Romanian: return "ro";

       case QLocale::Serbian: return "sr";

       case QLocale::Slovak: return "sk";

       case QLocale::Slovenian: return "sl";

       case QLocale::Spanish: return "es";

       case QLocale::Swedish: return "sv";

       case QLocale::Tagalog: return "tl";

       case QLocale::Czech: return "cs";

       case QLocale::Dutch: return "nl";

       case QLocale::Turkish: return "tr";

       case QLocale::Estonian: return "et";

       case QLocale::French: return "fr";

       case QLocale::Greek: return "el";

       case QLocale::Icelandic: return "is";

       case QLocale::Indonesian: return "id";

       case QLocale::Italian: return "it";

       case QLocale::Latvian: return "lv";

       case QLocale::Croatian: return "hr";

       case QLocale::German: return "de";

       case QLocale::Hungarian: return "hu";

       case QLocale::Bulgarian: return "bg";

       case QLocale::Finnish: return "fi";

       case QLocale::Russian: return "ru";

       case QLocale::Danish: return "da";

       case QLocale::Norwegian: return "no";

       case QLocale::Ukrainian: return "uk";

       case QLocale::Arabic: return "ar";

       case QLocale::Hebrew: return "he";

       case QLocale::Thai: return "th";

       case QLocale::Japanese: return "ja";

       case QLocale::Vietnamese: return "vi";

       case QLocale::Persian: return "fa";

       case QLocale::Hindi: return "hi";

       case QLocale::Urdu: return "ur";

       case QLocale::Catalan: return "ca";

       case QLocale::Galician: return "gl";

       case QLocale::Basque: return "eu";

       case QLocale::Marathi: return "mr";

       case QLocale::Korean: return "ko";       

       default:

           break;

       }

    return "";        

}

QString QSystemInfoPrivate::TLanguageToISO639_1(TLanguage language) const

{

    switch (language) {

        case ELangAmerican:

        case ELangCanadianEnglish:

        case ELangInternationalEnglish:

        case ELangSouthAfricanEnglish:

        case ELangAustralian:

        case ELangEnglish: return "en";

        case ELangSwissFrench:

        case ELangInternationalFrench:

        case ELangCanadianFrench:

        case ELangBelgianFrench:

        case ELangFrench: return "fr";

        case ELangSwissGerman:

        case ELangAustrian:

        case ELangGerman: return "de";

        case ELangInternationalSpanish:

        case ELangLatinAmericanSpanish:

        case ELangSpanish: return "es";

        case ELangSwissItalian:

        case ELangItalian: return "it";

        case ELangFinlandSwedish:

        case ELangSwedish: return "sv";

        case ELangDanish: return "da";

        case ELangNorwegian: return "no";

        case ELangFinnish: return "fi";

        case ELangBrazilianPortuguese:

        case ELangPortuguese: return "pt";

        case ELangCyprusTurkish:

        case ELangTurkish: return "tr";

        case ELangIcelandic: return "is";

        case ELangRussian: return "ru";

        case ELangHungarian: return "hu";

        case ELangBelgianFlemish:

        case ELangDutch: return "nl";

        case ELangNewZealand: return "mi";  //Maori

        case ELangCzech: return "cs";

        case ELangSlovak: return "sk";

        case ELangPolish: return "pl";

        case ELangSlovenian: return "sl";

        case ELangTaiwanChinese:

        case ELangHongKongChinese:

        case ELangPrcChinese: return "zh";

        case ELangJapanese: return "ja";

        case ELangThai: return "th";

        case ELangAfrikaans: return "af";

        case ELangAlbanian: return "sq";

        case ELangAmharic: return "am";

        case ELangArabic: return "ar";

        case ELangArmenian: return "hy";

        case ELangTagalog: return "tl";

        case ELangBelarussian: return "be";

        case ELangBengali:  return "bn";

        case ELangBulgarian: return "bg";

        case ELangBurmese: return "my";

        case ELangCatalan: return "ca";

        case ELangCroatian: return "hr";

        case ELangEstonian: return "et";

        case ELangFarsi: return "fa";

        case ELangScotsGaelic: return "gd";

        case ELangGeorgian: return "ka";

        case ELangGreek:

        case ELangCyprusGreek: return "el";

        case ELangGujarati: return "gu";

        case ELangHebrew: return "he";

        case ELangHindi: return "hi";

        case ELangIndonesian: return "id";

        case ELangIrish: return "ga";

        case ELangKannada: return "kn";

        case ELangKazakh: return "kk";

        case ELangKhmer: return "km";

        case ELangKorean: return "ko";

        case ELangLao: return "lo";

        case ELangLatvian: return "lv";

        case ELangLithuanian: return "lt";

        case ELangMacedonian: return "mk";

        case ELangMalay: return "ms";

        case ELangMalayalam: return "ml";

        case ELangMarathi: return "mr";

        case ELangMoldavian: return "ro";

        case ELangMongolian: return "mn";

        case ELangNorwegianNynorsk: return "nn";

        case ELangPunjabi: return "pa";

        case ELangRomanian: return "ro";

        case ELangSerbian: return "sr";

        case ELangSomali: return "so";

        case ELangSwahili: return "sw";

        case ELangTamil: return "ta";

        case ELangTelugu: return "te";

        case ELangTibetan: return "bo";

        case ELangTigrinya: return "ti";

        case ELangTurkmen: return "tk";

        case ELangUkrainian: return "uk";

        case ELangUrdu: return "ur";

        case ELangVietnamese: return "vi";

        case ELangWelsh: return "cy";

        case ELangZulu: return "zu";

        case ELangSinhalese: return "si";

        case ELangTest:

        case ELangReserved1:

        case ELangReserved2:

        case ELangOther:

        case ELangNone:

        default:

            break;

    }

    return "";

}

QString QSystemInfoPrivate::version(QSystemInfo::Version type,  const QString & /*parameter*/)

{

    switch (type) {

        case QSystemInfo::Os:

        {

            return S60Version();

        }

        case QSystemInfo::QtCore:

        {

            return qVersion();

        }

        case QSystemInfo::Firmware:

        {

            QString versionText;

            TBuf<KSysUtilVersionTextLength> versionBuf;

            if (SysUtil::GetSWVersion(versionBuf) == KErrNone) {

                versionText = QString::fromUtf16(versionBuf.Ptr(), versionBuf.Length());

            }

            return versionText.split("\n").at(0);

        }

        default:

            return QString();

    }

}

QString QSystemInfoPrivate::S60Version() const

{

    QDir romInstallDir("z:\\system\\install\\");

    QStringList files = romInstallDir.entryList(QStringList("Series60v*.sis"), QDir::Files, QDir::Name | QDir::Reversed);

    if (files.size() > 0) {

        QRegExp rx("Series60v(.*).sis");

        if (rx.indexIn(files[0]) > -1) {

            return rx.cap(1);

        }

    }

    return QString();

}

QString QSystemInfoPrivate::currentCountryCode() const

{

    return QLocale::system().name().mid(3,2);

}

bool QSystemInfoPrivate::hasFeatureSupported(QSystemInfo::Feature feature)

{

    TInt featureId = 0;

    switch (feature) {

        case QSystemInfo::BluetoothFeature: featureId = KFeatureIdBt; break;

        case QSystemInfo::CameraFeature: featureId = KFeatureIdCamera; break;

        case QSystemInfo::IrFeature: featureId = KFeatureIdIrda; break;

        case QSystemInfo::MemcardFeature: featureId = KFeatureIdMmc; break;

        case QSystemInfo::UsbFeature: featureId = KFeatureIdUsb; break;

        case QSystemInfo::WlanFeature: featureId = KFeatureIdProtocolWlan; break;

        case QSystemInfo::LocationFeature: featureId = KFeatureIdLocationFrameworkCore; break;

        case QSystemInfo::SimFeature:

        {

            return true;    //Always true in S60

        }

        case QSystemInfo::VibFeature:

        {

            TRAPD(err,

                //Leaves with KErrNotSupported if device doesn't support vibration feature.

                CHWRMVibra *vibra = CHWRMVibra::NewLC();

                CleanupStack::PopAndDestroy(vibra);

            )

            return err == KErrNone;

        }

        case QSystemInfo::HapticsFeature:

        {

            if (CCoeEnv::Static()) {

                //TODO: Do something with the AVKON dependency

                return AknLayoutUtils::PenEnabled();

            }

            return false;

        }

        case QSystemInfo::FmradioFeature:   //Not available in public SDK

        case QSystemInfo::LedFeature:

        case QSystemInfo::VideoOutFeature:  //Accessory monitor available from S60 5.x onwards

        default:

            return false;

    }

    bool isFeatureSupported = false;

    TRAP_IGNORE(isFeatureSupported = CFeatureDiscovery::IsFeatureSupportedL(featureId);)

    return isFeatureSupported;

}

QSystemNetworkInfoPrivate::QSystemNetworkInfoPrivate(QObject *parent)

    : QObject(parent)

{

    DeviceInfo::instance()->cellSignalStrenghtInfo()->addObserver(this);

    DeviceInfo::instance()->cellNetworkInfo()->addObserver(this);

    DeviceInfo::instance()->cellNetworkRegistrationInfo()->addObserver(this);

    connect(DeviceInfo::instance()->wlanInfo(), SIGNAL(wlanNetworkNameChanged()),

        this, SLOT(wlanNetworkNameChanged()));

    connect(DeviceInfo::instance()->wlanInfo(), SIGNAL(wlanNetworkSignalStrengthChanged()),

        this, SLOT(wlanNetworkSignalStrengthChanged()));

    connect(DeviceInfo::instance()->wlanInfo(), SIGNAL(wlanNetworkStatusChanged()),

        this, SLOT(wlanNetworkStatusChanged()));

}

QSystemNetworkInfoPrivate::~QSystemNetworkInfoPrivate()

{

    DeviceInfo::instance()->cellSignalStrenghtInfo()->removeObserver(this);

    DeviceInfo::instance()->cellNetworkInfo()->removeObserver(this);

    DeviceInfo::instance()->cellNetworkRegistrationInfo()->removeObserver(this);

}

QSystemNetworkInfo::NetworkStatus QSystemNetworkInfoPrivate::networkStatus(QSystemNetworkInfo::NetworkMode mode)

{

    switch(mode) {

        case QSystemNetworkInfo::GsmMode:

        case QSystemNetworkInfo::CdmaMode:

        case QSystemNetworkInfo::WcdmaMode:

        {

            CTelephony::TRegistrationStatus networkStatus = DeviceInfo::instance()

                ->cellNetworkRegistrationInfo()->cellNetworkStatus();

            CTelephony::TNetworkMode networkMode = DeviceInfo::instance()->cellNetworkInfo()->networkMode();

            if (networkMode == CTelephony::ENetworkModeGsm && mode != QSystemNetworkInfo::GsmMode)

                return QSystemNetworkInfo::NoNetworkAvailable;

            if ((networkMode == CTelephony::ENetworkModeCdma95 || networkMode == CTelephony::ENetworkModeCdma2000) &&

                mode != QSystemNetworkInfo::CdmaMode)

                return QSystemNetworkInfo::NoNetworkAvailable;

            if (networkMode == CTelephony::ENetworkModeWcdma && mode != QSystemNetworkInfo::WcdmaMode)

                return QSystemNetworkInfo::NoNetworkAvailable;

            switch(networkStatus) {

                case CTelephony::ERegistrationUnknown: return QSystemNetworkInfo::UndefinedStatus;

                case CTelephony::ENotRegisteredNoService: return QSystemNetworkInfo::NoNetworkAvailable;

                case CTelephony::ENotRegisteredEmergencyOnly: return QSystemNetworkInfo::EmergencyOnly;

                case CTelephony::ENotRegisteredSearching: return QSystemNetworkInfo::Searching;

                case CTelephony::ERegisteredBusy: return QSystemNetworkInfo::Busy;

                case CTelephony::ERegisteredOnHomeNetwork: return QSystemNetworkInfo::HomeNetwork;

                case CTelephony::ERegistrationDenied: return QSystemNetworkInfo::Denied;

                case CTelephony::ERegisteredRoaming: return QSystemNetworkInfo::Roaming;

                default:

                    break;

            };

        }

        case QSystemNetworkInfo::WlanMode:

        {

            if (DeviceInfo::instance()->wlanInfo()->wlanNetworkConnectionStatus())

                return QSystemNetworkInfo::Connected;

            else

                return QSystemNetworkInfo::NoNetworkAvailable;

        }

        case QSystemNetworkInfo::EthernetMode:

        case QSystemNetworkInfo::BluetoothMode:

        case QSystemNetworkInfo::WimaxMode:

        default:

            break;

    };

    return QSystemNetworkInfo::UndefinedStatus;

}

int QSystemNetworkInfoPrivate::networkSignalStrength(QSystemNetworkInfo::NetworkMode mode)

{

    switch(mode) {

        case QSystemNetworkInfo::GsmMode:

        case QSystemNetworkInfo::CdmaMode:

        case QSystemNetworkInfo::WcdmaMode:

        {

            CTelephony::TNetworkMode networkMode = DeviceInfo::instance()->cellNetworkInfo()->networkMode();

            if (networkMode == CTelephony::ENetworkModeGsm && mode != QSystemNetworkInfo::GsmMode)

                return -1;

            if ((networkMode == CTelephony::ENetworkModeCdma95 || networkMode == CTelephony::ENetworkModeCdma2000) &&

                mode != QSystemNetworkInfo::CdmaMode)

                return -1;

            if (networkMode == CTelephony::ENetworkModeWcdma && mode != QSystemNetworkInfo::WcdmaMode)

                return -1;

            return DeviceInfo::instance()->cellSignalStrenghtInfo()->cellNetworkSignalStrength();

        }

        case QSystemNetworkInfo::WlanMode:

            return DeviceInfo::instance()->wlanInfo()->wlanNetworkSignalStrength();

        case QSystemNetworkInfo::EthernetMode:

        case QSystemNetworkInfo::BluetoothMode:

        case QSystemNetworkInfo::WimaxMode:

        default:

            break;

    };

    return -1;

}

int QSystemNetworkInfoPrivate::cellId()

{

	return DeviceInfo::instance()->cellNetworkInfo()->cellId();

}

int QSystemNetworkInfoPrivate::locationAreaCode()

{

	return DeviceInfo::instance()->cellNetworkInfo()->locationAreaCode();

}

QString QSystemNetworkInfoPrivate::currentMobileCountryCode()

{

	return DeviceInfo::instance()->cellNetworkInfo()->countryCode();

}

QString QSystemNetworkInfoPrivate::currentMobileNetworkCode()

{

	return DeviceInfo::instance()->cellNetworkInfo()->networkCode();

}

QString QSystemNetworkInfoPrivate::homeMobileCountryCode()

{

    QString imsi = DeviceInfo::instance()->subscriberInfo()->imsi();

    if (imsi.length() >= 3) {

        return imsi.left(3);

    }

	return QString();

}

QString QSystemNetworkInfoPrivate::homeMobileNetworkCode()

{

    CTelephony::TRegistrationStatus networkStatus = DeviceInfo::instance()

        ->cellNetworkRegistrationInfo()->cellNetworkStatus();

    if (networkStatus == CTelephony::ERegisteredOnHomeNetwork) {

        return DeviceInfo::instance()->cellNetworkInfo()->networkCode();

    }

    return QString();

}

QString QSystemNetworkInfoPrivate::networkName(QSystemNetworkInfo::NetworkMode mode)

{

    QString name;

    switch(mode) {

        case QSystemNetworkInfo::GsmMode:

        case QSystemNetworkInfo::CdmaMode:

        case QSystemNetworkInfo::WcdmaMode: