/*

* 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 "irsettings.h"

#include "irqsettings.h"

// ---------------------------------------------------------------------------

// IRQSettings::openInstance()

// Static function to get a singleton instance of IRQSettings

// @return IRQSettings *

// ---------------------------------------------------------------------------

//

EXPORT_C IRQSettings* IRQSettings::openInstance()

{

    // Get singleton instance

    IRQSettings* irqsettings =

                           reinterpret_cast<IRQSettings*>(Dll::Tls());

    if (NULL == irqsettings)

    {

        TRAPD(error, irqsettings = createInstanceL());

        if (KErrNone != error)

        {

            delete irqsettings;

            irqsettings = NULL;

            Dll::SetTls(NULL);

        }

    }

    else

    {

        irqsettings->iSingletonInstances++;

    }

    return irqsettings;

}

// ---------------------------------------------------------------------------

// IRQSettings::closeInstance()

// Close a singleton instance of IRQSettings

// ---------------------------------------------------------------------------

//

EXPORT_C void IRQSettings::closeInstance()

{

    iSingletonInstances--;

    if (0 == iSingletonInstances)

    {

        Dll::SetTls(NULL);

        delete this;

    }

}

// ---------------------------------------------------------------------------

// IRQSettings::isFlagCostWarning()

//

// ---------------------------------------------------------------------------

//

EXPORT_C bool IRQSettings::isFlagCostWarning(bool& aFlag)

{

    TRAPD(error, aFlag = (bool)iSettings->IsFlagCostWarningL());

    if (KErrNone != error)

    {

        return false;

    }

    return true;

}

// ---------------------------------------------------------------------------

// IRQSettings::setFlagCostWarning()

//

// ---------------------------------------------------------------------------

//

EXPORT_C void IRQSettings::setFlagCostWarning()

{

    TRAP_IGNORE(iSettings->SetFlagCostWarningL());

}

// ---------------------------------------------------------------------------

// IRQSettings::reSetFlagCostWarning()

//

// ---------------------------------------------------------------------------

//

EXPORT_C void IRQSettings::reSetFlagCostWarning()

{

    TRAP_IGNORE(iSettings->ReSetFlagCostWarningL());

}

// ---------------------------------------------------------------------------

// IRQSettings::isFlagTermsAndConditions()

//

// ---------------------------------------------------------------------------

//

EXPORT_C bool IRQSettings::isFlagTermsAndConditions(bool& aFlag)

{

    TRAPD(error, aFlag = (bool)iSettings->IsFlagTermsAndConditionsL());

    if (KErrNone != error)

    {

        return false;

    }

    return true;

}

// ---------------------------------------------------------------------------

// IRQSettings::setFlagTermsAndConditions()

//

// ---------------------------------------------------------------------------

//

EXPORT_C void IRQSettings::setFlagTermsAndConditions()

{

    TRAP_IGNORE(iSettings->SetFlagTermsAndConditionsL());

}

// ---------------------------------------------------------------------------

// IRQSettings::reSetFlagTermsAndConditions()

//

// ---------------------------------------------------------------------------

//

EXPORT_C void IRQSettings::reSetFlagTermsAndConditions()

{

    TRAP_IGNORE(iSettings->ReSetFlagTermsAndConditionsL());

}

// ---------------------------------------------------------------------------

// IRQSettings::setIrappVersion()

//

// ---------------------------------------------------------------------------

//

EXPORT_C void IRQSettings::setIrappVersion(const QString& aIRAppVersion)

{

    if (aIRAppVersion.length() > KMaxVersionName)

    {

        return;

    }

    TPtrC irAppVersion(reinterpret_cast<const TUint16*>(aIRAppVersion.utf16()));

    TRAP_IGNORE(iSettings->SetIrappVersionL(irAppVersion));

}

// ---------------------------------------------------------------------------

// IRQSettings::getIrappVersion()

//

// ---------------------------------------------------------------------------

//

EXPORT_C bool IRQSettings::getIrappVersion(QString& aAppVersion)

{

    TVersionName irAppVersion;

    TRAPD(error, irAppVersion = iSettings->GetIrappVersionL());

    if (KErrNone != error)

    {

        return false;

    }

    aAppVersion = QString::fromUtf16(irAppVersion.Ptr(), irAppVersion.Length());

    return true;

}

// ---------------------------------------------------------------------------

// IRQSettings::setIRID()

//

// ---------------------------------------------------------------------------

//

EXPORT_C void IRQSettings::setIRID(const QString& aIrid)

{

    TPtrC irid(reinterpret_cast<const TUint16*>(aIrid.utf16()));

    TRAP_IGNORE(iSettings->SetIRIDL(irid));

}

// ---------------------------------------------------------------------------

// IRQSettings::getIRID()

//

// ---------------------------------------------------------------------------

//

EXPORT_C bool IRQSettings::getIRID(QString& aIRID)

{

    TDeviceInfo irid;

    TRAPD(error, irid = iSettings->GetIRIDL());

    if (KErrNone != error)

    {

        return false;

    }

    aIRID = QString::fromUtf16(irid.Ptr(), irid.Length());

    return true;

}

// ---------------------------------------------------------------------------

// IRQSettings::getISDSBaseUrl()

//

// ---------------------------------------------------------------------------

//

EXPORT_C bool IRQSettings::getISDSBaseUrl(QString& aUrl)

{

    TPath isdsBaseUrl;

    TRAPD(error, isdsBaseUrl = iSettings->GetISDSBaseUrlL());

    if (KErrNone != error)

    {

        return false;

    }

    aUrl = QString::fromUtf16(isdsBaseUrl.Ptr(), isdsBaseUrl.Length());

    return true;

}

// ---------------------------------------------------------------------------

// IRQSettings::setISDSBaseUrl()

//

// ---------------------------------------------------------------------------

//

EXPORT_C void IRQSettings::setISDSBaseUrl(const QString& aIsdsUrl)

{

    TPtrC isdsUrl(reinterpret_cast<const TUint16*>(aIsdsUrl.utf16()));

    TRAP_IGNORE(iSettings->SetISDSBaseUrlL(isdsUrl));

}

// ---------------------------------------------------------------------------

// IRQSettings::getVolumeSetting()

//

// ---------------------------------------------------------------------------

//

EXPORT_C int IRQSettings::getVolumeSetting()

{

    return (int)iSettings->GetVolumeSetting();

}

// ---------------------------------------------------------------------------

// IRQSettings::setVolumeSetting()

//

// ---------------------------------------------------------------------------

//

EXPORT_C void IRQSettings::setVolumeSetting(int aPlayVolume)

{

    TRAP_IGNORE(iSettings->SetVolumeSettingL((TInt)aPlayVolume));

}

// ---------------------------------------------------------------------------

// IRQSettings::getManuallyAddedChId()

//

// ---------------------------------------------------------------------------

//

EXPORT_C int IRQSettings::getManuallyAddedChId()

{

    return (int)iSettings->GetManuallyAddedChId();

}

// ---------------------------------------------------------------------------

// IRQSettings::setManuallyAddedChId()

//

// ---------------------------------------------------------------------------

//

EXPORT_C void IRQSettings::setManuallyAddedChId()

{

    TRAP_IGNORE(iSettings->SetManuallyAddedChIdL());

}

// ---------------------------------------------------------------------------

// IRQSettings::isUpdateAvailable()

//

// ---------------------------------------------------------------------------

//

EXPORT_C bool IRQSettings::isUpdateAvailable(bool& aFlag)

{

    TRAPD(error, aFlag = (bool)iSettings->IsUpdateAvailableL());

    if (KErrNone != error)

    {

        return false;

    }

    return true;

}

// ---------------------------------------------------------------------------

// IRQSettings::setUpdateAvailable()

//

// ---------------------------------------------------------------------------

//

EXPORT_C void IRQSettings::setUpdateAvailable()

{

    TRAP_IGNORE(iSettings->SetUpdateAvailableL());

}

// ---------------------------------------------------------------------------

// IRQSettings::reSetUpdateAvailable()

//

// ---------------------------------------------------------------------------

//

EXPORT_C void IRQSettings::reSetUpdateAvailable()

{

    TRAP_IGNORE(iSettings->ReSetUpdateAvailableL());

}

// ---------------------------------------------------------------------------

// IRQSettings::getLogRunningNo()

//

// ---------------------------------------------------------------------------

//

EXPORT_C int IRQSettings::getLogRunningNo()

{

    return (int)iSettings->GetLogRunningNo();

}

// ---------------------------------------------------------------------------

// IRQSettings::setLogRunningNo()

//

// ---------------------------------------------------------------------------

//

EXPORT_C void IRQSettings::setLogRunningNo()

{

    TRAP_IGNORE(iSettings->SetLogRunningNoL());

}

// ---------------------------------------------------------------------------

// IRQSettings::setTimeOut()

//

// ---------------------------------------------------------------------------

//

EXPORT_C void IRQSettings::setTimeOut(int aTimeOut)

{

    TRAP_IGNORE(iSettings->SetTimeOutL((TInt)aTimeOut));

}

// ---------------------------------------------------------------------------

// IRQSettings::getTimeOut()

//

// ---------------------------------------------------------------------------

//

EXPORT_C int IRQSettings::getTimeOut()

{

    return (int)iSettings->GetTimeOut();

}

// ---------------------------------------------------------------------------

// IRQSettings::setSilencePeriod()

//

// ---------------------------------------------------------------------------

//

EXPORT_C void IRQSettings::setSilencePeriod(unsigned int aSilencePeriod)

{

    TRAP_IGNORE(iSettings->SetSilencePeriodL((TUint)aSilencePeriod));

}

// ---------------------------------------------------------------------------

// IRQSettings::getSilencePeriod()

//

// ---------------------------------------------------------------------------

//

EXPORT_C bool IRQSettings::getSilencePeriod(unsigned int& aPeriod)

{

    TRAPD(error, aPeriod = iSettings->GetSilencePeriodL());

    if (KErrNone != error)

    {

        return false;

    }

    return false;

}

// ---------------------------------------------------------------------------

// IRQSettings::setSilencePeriodStart()

//

// ---------------------------------------------------------------------------

//

EXPORT_C void IRQSettings::setSilencePeriodStart(const QString& aSilencePeriodStart)

{

    if( aSilencePeriodStart.length() > KMaxLengthSilencePeriod )

    { 

        return;

    }

    TPtrC silencePeriodStart(reinterpret_cast<const TUint16*>(aSilencePeriodStart.utf16()));

    TRAP_IGNORE(iSettings->SetSilencePeriodStartL(silencePeriodStart));

}

// ---------------------------------------------------------------------------

// IRQSettings::getSilencePeriodStart()

//

// ---------------------------------------------------------------------------

//

EXPORT_C bool IRQSettings::getSilencePeriodStart(QString& aPeriodStart)

{

    TBuf<KMaxLengthSilencePeriod> silencePeriodStart;

    TRAPD(error, silencePeriodStart = iSettings->GetSilencePeriodStartL());

    if (KErrNone != error)

    {

        return false;

    }

    aPeriodStart = QString::fromUtf16(silencePeriodStart.Ptr(), silencePeriodStart.Length());

    return true;

}

// ---------------------------------------------------------------------------

// IRQSettings::displayAccessPoint()

//

// ---------------------------------------------------------------------------

//

EXPORT_C bool IRQSettings::displayAccessPoint(bool& aFlag)

{

    TRAPD(error, aFlag = (bool)iSettings->DisplayAccessPointL());

    if (KErrNone != error)

    {

        return false;

    }

    return true;

}

// ---------------------------------------------------------------------------

// IRQSettings::setDisplayAccessPoint()

//

// ---------------------------------------------------------------------------

//

EXPORT_C void IRQSettings::setDisplayAccessPoint()

{

    TRAP_IGNORE(iSettings->SetDisplayAccessPointL());

}

// ---------------------------------------------------------------------------

// IRQSettings::reSetDisplayAccessPoint()

//

// ---------------------------------------------------------------------------

//

EXPORT_C void IRQSettings::reSetDisplayAccessPoint()

{

    TRAP_IGNORE(iSettings->ReSetDisplayAccessPointL());

}

// ---------------------------------------------------------------------------

// IRQSettings::setBearerId()

//

// ---------------------------------------------------------------------------

//

EXPORT_C void IRQSettings::setBearerId(unsigned long aBearerId)

{

    TRAP_IGNORE(iSettings->SetBearerIdL((TUint32)aBearerId));

}

// ---------------------------------------------------------------------------

// IRQSettings::getBearerId()

//

// ---------------------------------------------------------------------------

//

EXPORT_C bool IRQSettings::getBearerId(unsigned long& aBearerId)

{

    TRAPD(error, aBearerId = iSettings->GetBearerIdL());

    if (KErrNone != error)

    {

        return false;

    }

    return true;

}

// ---------------------------------------------------------------------------

// IRQSettings::setNetworkId()

//

// ---------------------------------------------------------------------------

//

EXPORT_C void IRQSettings::setNetworkId(unsigned long aBearerId)

{

    TRAP_IGNORE(iSettings->SetNetworkIdL((TUint32)aBearerId));

}

// ---------------------------------------------------------------------------

// IRQSettings::getNetworkId()

//

// ---------------------------------------------------------------------------

//

EXPORT_C bool IRQSettings::getNetworkId(unsigned long& aNetworkId)

{

    TRAPD(error, aNetworkId = iSettings->GetNetworkIdL());

    if (KErrNone != error)

    {

        return false;

    }

    return true;

}

// ---------------------------------------------------------------------------

// IRQSettings::setApId()

//

// ---------------------------------------------------------------------------

//

EXPORT_C void IRQSettings::setApId(unsigned long aBearerId)

{

    TRAP_IGNORE(iSettings->SetApIdL((TUint32)aBearerId));

}

// ---------------------------------------------------------------------------

// IRQSettings::getApId()

//

// ---------------------------------------------------------------------------

//

EXPORT_C bool IRQSettings::getApId(unsigned long& aApId)

{

    TRAPD(error, aApId = iSettings->GetApIdL());

    if (KErrNone != error)

    {

        return false;

    }

    return true;

}

// ---------------------------------------------------------------------------

// IRQSettings::setUserSavedApSettings()

//

// ---------------------------------------------------------------------------

//

EXPORT_C void IRQSettings::setUserSavedApSettings(unsigned long aBearerId,

                               unsigned long aNetworkId,unsigned long aApId)

{

    TRAP_IGNORE(iSettings->SetUserSavedApSettingsL((TUint32)aBearerId,

                (TUint32)aNetworkId, (TUint32)aApId));