#include "hbinputkeymapfactory_p.h"

#include <QDebug>

void removeNonExistingPaths(QStringList &list)

    for (int i = list.count()-1; i >= 0; --i) {

        if (!QFile::exists(list.at(i))) {

            list.removeAt(i);

        }

    }

}

void HbKeymapFactoryPrivate::parseFileNames(const QStringList &files, QList<HbInputLanguage> &languages) const

int HbKeymapFactoryPrivate::keymapVersion(QFile &file) const

    int version = -1;

    if (file.fileName().length() > 0) {

        QChar driveLetter = file.fileName().at(0).toLower();

        // The version on the 'softest' drive is given precedence

        // Paths starting with z, :, or any other character are taken after these

        if (driveLetter >= 'a' && driveLetter <= 'y') {

            version = driveLetter.toAscii() - 'a' + 1;

            version = 0;

    return version;

bool HbKeymapFactoryPrivate::findKeymapFile(const HbInputLanguage &language, const QStringList &searchPaths, QFile &file) const

    QString filename, latestVersionFilename;

    qreal maxVersionNumber = -1;

    foreach(const QString &path, searchPaths) {

            int fileVersion = keymapVersion(file);

            if (fileVersion > maxVersionNumber) {

                latestVersionFilename = filename;

                maxVersionNumber = fileVersion;

    if (latestVersionFilename.isEmpty()) {

            foreach(const HbInputLanguage &availableLanguage, HbKeymapFactory::availableLanguages()) {

                    return findKeymapFile(availableLanguage, searchPaths, file);

        return false;

    } else {

        file.setFileName(latestVersionFilename);

        return true;

}

HbKeymap *HbKeymapFactoryPrivate::parseKeymapDefinition(const HbInputLanguage &language, QTextStream &stream) const

{

    if (keyboard) {

        // The last keyboard definition was not terminated properly, so it needs to be freed at this point

        delete keyboard;

        keyboard = 0;

        qDebug() << "HbInputKeymapFactory: unterminated keyboard definition detected";

    }

    if (!isValid(keymap)) {

        delete keymap;

        keymap = 0;

        qDebug() << "HbInputKeymapFactory: invalid keymap definition detected";

    }

    return keymap;

}

bool HbKeymapFactoryPrivate::isValid(const HbKeymap *keymap) const

{

    if (!keymap) {

        return false;

    }

    // Very basic sanity checking

    // Check that basic keyboards are present and the number of keys make sense

    const HbKeyboardMap* keyboard = keymap->keyboard(HbKeyboardTouchPortrait);

    if (!keyboard || keyboard->keys.count() != 10) {

        return false;

    }

    keyboard = keymap->keyboard(HbKeyboardTouchLandscape);

    if (!keyboard || keyboard->keys.count() < 30 || keyboard->keys.count() > 45) {

        return false;

    }

    keyboard = keymap->keyboard(HbKeyboardSctPortrait);

    if (!keyboard || keyboard->keys.count() < 16) {

        return false;

    }

    keyboard = keymap->keyboard(HbKeyboardSctLandscape);

    if (!keyboard || keyboard->keys.count() < 30) {

        return false;

    }

    return true;

}

HbKeymap *HbKeymapFactoryPrivate::keymap(const HbInputLanguage &language) const

{

    QFile file;

    HbKeymap *keymap = 0;

    QStringList paths = HbInputSettingProxy::keymapPluginPaths();

    removeNonExistingPaths(paths);

    // First try to load the highest priority version of the keymap

    if (findKeymapFile(language, paths, file)) {

        QTextStream stream;

        if (file.open(QIODevice::ReadOnly | QIODevice::Text)) {

            stream.setDevice(&file);

            keymap = parseKeymapDefinition(language, stream);

            file.close();

        }

        // If reading the keymap fails (and it was not in system resources to begin with),

        // try to load a version from system resources

        if (!keymap && file.fileName().left(2) != ":/") {

            if (findKeymapFile(language, paths.filter(":/"), file)) {

                if (file.open(QIODevice::ReadOnly | QIODevice::Text)) {

                    stream.setDevice(&file);

                    keymap = parseKeymapDefinition(language, stream);

                    file.close();

                }

            }

        }

    }

    return keymap;

}

/// @endcond

/*!

@stable

@hbcore

\class HbKeymapFactory

\brief A factory class for accessing keymap data.

Keymap factory constructs HbKeymap objects for given languages based on keymap resource files.

It can also provide a list of available keymap files in the system.

\sa HbKeymap

*/

/*!

\enum HbKeymapFactory::Flag

Flags for controlling keymap loading by the factory.

*/

/*!

\var HbKeymapFactory::Flag HbKeymapFactory::Default

Default functionality, loaded keymaps are cached inside the factory and factory retains ownership of keymap objects.

*/

/*!

\var HbKeymapFactory::Flag HbKeymapFactory::NoCaching

Disabled cache for this function call. Keymaps are read directly from disk and are not stored in cache.

Ownership of the returned keymaps is transferred to the caller.

*/

/*!

Returns reference to singleton instance.

*/

HbKeymapFactory *HbKeymapFactory::instance()

{

    static HbKeymapFactory myInstance;

    return &myInstance;

}

/*!

Constructs the object.

*/

HbKeymapFactory::HbKeymapFactory()

{

    mPrivate = new HbKeymapFactoryPrivate();

}

/*!

Destructs the object.

*/

HbKeymapFactory::~HbKeymapFactory()

{

    delete mPrivate;

}

/*!

Returns a HbKeymap object initialized using keymap resource data in the system. Ownership of the

HbKeymap object remains with HbKeymapFactory.

If no data is found for the given language, 0 is returned.

\param language Language for the keymap

\param country Country for the keymap. If empty or AnyCountry, non-country specific version or a country-specific version will be returned.

\sa HbKeymap

*/

const HbKeymap *HbKeymapFactory::keymap(const QLocale::Language language, const QLocale::Country country)

{

    return keymap(HbInputLanguage(language, country), Default);

}

/*!

Returns a HbKeymap object initialized using keymap resource data in the system. Ownership of the

HbKeymap object remains with HbKeymapFactory.

If no data is found for the given input language, 0 is returned. If the variant of the input language

is AnyCountry, the function can return either a keymap with no variant specified or a keymap with any variant.

\param language HbInputLanguage defining the language-country combination.

\sa HbKeymap

\sa HbInputLanguage

*/

const HbKeymap *HbKeymapFactory::keymap(const HbInputLanguage language)

{

    return keymap(language, Default);

}

/*!

Returns a HbKeymap object initialized using keymap resource data in the system. Ownership of the

HbKeymap object remains with HbKeymapFactory unless otherwise specified with flags.

If no data is found for the given input language, 0 is returned. If the variant of the input language

is AnyCountry, the function can return either a keymap with no variant specified or a keymap with any variant.

\param language HbInputLanguage defining the language-country combination.

\param flags HbKeymapFactory flags for controlling this keymap loading.

\sa HbKeymap

\sa HbInputLanguage

\sa HbKeymapFactory::Flags

*/

const HbKeymap *HbKeymapFactory::keymap(const HbInputLanguage &language, HbKeymapFactory::Flags flags)

{

    if (!flags.testFlag(NoCaching)) {

        foreach(HbKeymap *keymap, mPrivate->mKeymaps) {

            if (keymap->language() == language) {

                return keymap;

            }

        }

    }

    HbKeymap *keymap = mPrivate->keymap(language);

    if (keymap && !flags.testFlag(NoCaching)) {

    QStringList* files = new QStringList();

    QStringList* romFiles = new QStringList();

    QStringList paths = HbInputSettingProxy::keymapPluginPaths();

    removeNonExistingPaths(paths);

    foreach(const QString &path, paths) {

            *romFiles += languagedir.entryList(QStringList(QString("*.txt")), QDir::Files);

            *files += languagedir.entryList(QStringList(QString("*.txt")), QDir::Files);

        instance->mPrivate->parseFileNames(*romFiles, languages);

    instance->mPrivate->parseFileNames(*files, languages);

    delete files;

    delete romFiles;