/*

* Copyright (c) 2002 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:   MMF ROP plugin specific settings model.*

*/

// INCLUDE FILES

#include <mmf/common/mmfbase.h>

#include <MMFROPCustomCommandConstants.h>

#include <f32file.h>

#include <bautils.h>

#include <barsc.h>

#include <barsread.h>

#include <f32file.h>

#include <commdb.h>             // CMDBSession

#include <commsdattypesv1_1.h>  // CCDWAPIPBearerRecord

#include <mpsettingsropmodel.rsg>

#include    <data_caging_path_literals.hrh> // KDC_RESOURCE_FILES_DIR

#include    "MPSettingsModelForROP.h"

#include    "MPSettingsRopConfigParser.h"

#include    "MPSettingsROPSettings.hrh"

#include    "MediaPlayerPrivateCRKeys.h"

#include	"MediaPlayerVariant.hrh" 

#include	"mpxlog.h"

// CONSTANTS

// ROP controller UID

const TUid KRopControllerUid = {0x101F8514};

// This should be used only as the granularity for iItems array

const TInt KMPRopItemsArrayGranularity = 8;

// Initial config string length

const TInt KMPRopConfigStringLength = 2048;

// Seconds to milli seconds multiplier

const TInt KMPRopSecondsMultiplier = 1000;

// Unlocalized resource file path

_LIT( KMPSettROPResource, "MPSettingsROPModel.rsc" );

// CLASS DECLARATION

// ============================ MEMBER FUNCTIONS ===============================

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

// CMPSettingsModelForROP::CMPSettingsModelForROP

// C++ default constructor can NOT contain any code, that

// might leave.

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

//

CMPSettingsModelForROP::CMPSettingsModelForROP()

    {

    MPX_DEBUG1(_L("#MS# CMPSettingsModelForROP::CMPSettingsModelForROP()"));

    }

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

// CMPSettingsModelForROP::ConstructL

// Symbian 2nd phase constructor can leave.

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

//

void CMPSettingsModelForROP::ConstructL()

    {

    MPX_DEBUG1(_L("#MS# CMPSettingsModelForROP::ConstructL()"));

    InitializeCentralRepositoryL();

    iItems = new(ELeave) CArrayPtrSeg<CMPRopSettingItem>(KMPRopItemsArrayGranularity);

    // Connect RFs

    RFs fs;

    User::LeaveIfError(fs.Connect());

    CleanupClosePushL(fs);

    // Locate resource file

    TFileName fileName;

    LocateResourceFileL( fileName, fs );

    // Open resource file

    RResourceFile resourceFile;

    resourceFile.OpenL(fs, fileName);

    CleanupClosePushL(resourceFile);

    // Read array from resource file to a buffer

    resourceFile.ConfirmSignatureL(0); // Magic: dummy value

    HBufC8* buf = resourceFile.AllocReadLC(R_MPSETT_ROP_SETTINGS_ARRAY);

    CMPRopSettingItem* item = NULL;

    TInt id = 0;

    HBufC* key = NULL;

    // Set buffer to resource reader

    TResourceReader reader;

    reader.SetBuffer(buf);

    // Read number of items from the resource structure

    TInt count = reader.ReadInt16();

    for (TInt index = 0; index < count; ++index)

        {

        // Read id and key

        id = reader.ReadInt16();

        key = reader.ReadHBufCL();

        CleanupStack::PushL(key);

        // key's ownership is transferred to item

        item = CMPRopSettingItem::NewLC(id, *key);

        iItems->AppendL(item); // Ownership transferred

        CleanupStack::Pop(2); // item & key

        delete key;

        key = NULL;

        }

    CleanupStack::PopAndDestroy(3); // fs, resourceFile & buf

    // Create config parser

    iParser = CMPSettingsRopConfigParser::NewL();

    // Open ROP controller

    TMMFPrioritySettings prioritySettings;

    prioritySettings.iPriority = EMdaPriorityNormal;

    prioritySettings.iPref = EMdaPriorityPreferenceNone;

    prioritySettings.iState = EMMFStateIdle;

    User::LeaveIfError(iMMFController.Open(KRopControllerUid,

                                           prioritySettings));

    }

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

// CMPSettingsModelForROP::NewL

// Two-phased constructor.

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

//

CMPSettingsModelForROP* CMPSettingsModelForROP::NewL()

    {

    MPX_DEBUG1(_L("#MS# CMPSettingsModelForROP::NewL()"));

    CMPSettingsModelForROP* self = new(ELeave) CMPSettingsModelForROP;    

    CleanupStack::PushL(self);

    self->ConstructL();

    CleanupStack::Pop();

    return self;

    }

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

// CMPSettingsModelForROP::~CMPSettingsModelForROP

// Destructor

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

//

CMPSettingsModelForROP::~CMPSettingsModelForROP()

    {  

    MPX_DEBUG1(_L("#MS# CMPSettingsModelForROP::~CMPSettingsModelForROP()"));

	UninitializeCentralRepository();

    if (iItems)

        {

        iItems->ResetAndDestroy();

        delete iItems;

        }

    if (iParser) 

        {

        delete iParser;

        }

    if (iROPSettings) 

        {

        delete iROPSettings;

        }

    if (iROPHeader) 

        {

        delete iROPHeader;

        }

    iMMFController.Close();

    }

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

// CMPSettingsModelForROP::LoadSettingsL

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

//

void CMPSettingsModelForROP::LoadSettingsL(TInt aConfigVersion)

    {

    MPX_DEBUG2(_L("#MS# CMPSettingsModelForROP::LoadSettingsL(%d)"),aConfigVersion);

    // Initialize variables

    TInt configLength(KMPRopConfigStringLength);

    TInt error(KErrOverflow);

    const TMMFMessageDestinationPckg destinationPckg(KUidInterfaceMMFROPController);

    TInt ropConfigVersion;

    switch (aConfigVersion)

        {

        case EConfigDefault:

            ropConfigVersion = KMMFAudioVideoConfigDefault;

            break;

        case EConfigUser:

        default:

            ropConfigVersion = KMMFAudioVideoConfigUser;

            break;

        }

    const TPckgBuf<TInt> verPckg(ropConfigVersion);

    // If iROPSettings is not large enough, increase the length and try again 

    for (TInt i = 0; i < 2 && error == KErrOverflow; ++i)

        {

        delete iROPSettings;

        iROPSettings = NULL;

        iROPSettings = HBufC8::NewL(configLength);

        TPtr8 ptr = iROPSettings->Des();

        error = iMMFController.CustomCommandSync(destinationPckg, EMMFROPControllerGetApplicationConfig,

            verPckg, KNullDesC8, ptr);

        if (error == KErrOverflow)

            {

            // iROPSettings is not large enough => increase length:

            // extract correct length from iROPSettings

            TPckgBuf<TInt> newLength;

            newLength.Copy(ptr);

            configLength = newLength();

            }

        else 

            {

            // Leave if unexpected error occurred

            User::LeaveIfError(error);

            }               

        }

    // Leave if unexpected error occurred

    User::LeaveIfError(error);

    delete iROPHeader;

    iROPHeader = NULL;

    iROPHeader = iParser->ParseConfigStringL(*iROPSettings, iItems);

    delete iROPSettings;

    iROPSettings = NULL;

    }

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

// CMPSettingsModelForROP::StoreSettingsL

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

//

void CMPSettingsModelForROP::StoreSettingsL()

    {

    MPX_DEBUG1(_L("#MS# CMPSettingsModelForROP::StoreSettingsL()"));

    delete iROPSettings;

    iROPSettings = NULL;

    iROPSettings = iParser->CreateConfigStringL(iItems, *iROPHeader);

    if (iROPSettings)

        {

        const TMMFMessageDestinationPckg destinationPckg(KUidInterfaceMMFROPController);

        const TPckgBuf<TBool> savePckg(ETrue);

        User::LeaveIfError(iMMFController.CustomCommandSync(destinationPckg, EMMFROPControllerSetApplicationConfig,

            *iROPSettings, savePckg));

        }

    // Set iValueChanged status to EFalse for all items

    TInt count = iItems->Count();

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

        {

        iItems->At(i)->iValueChanged = EFalse;

        }

    }

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

// CMPSettingsModelForROP::SetVideoContrast

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

//

TInt CMPSettingsModelForROP::SetVideoContrast(TInt aContrast)

    {

    MPX_DEBUG2(_L("#MS# CMPSettingsModelForROP::SetVideoContrast(%d)"),aContrast);

    return SetIntegerValue(EMPRopContrast, aContrast);

    }

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

// CMPSettingsModelForROP::GetVideoContrast

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

//

TInt CMPSettingsModelForROP::GetVideoContrast(TInt& aContrast)

    {

    MPX_DEBUG1(_L("#MS# CMPSettingsModelForROP::GetVideoContrast()"));

    return GetIntegerValue(EMPRopContrast, aContrast);

    }

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

// CMPSettingsModelForROP::SetProxyMode

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

//

TInt CMPSettingsModelForROP::SetProxyMode(TInt aMode)

    {

    MPX_DEBUG2(_L("#MS# CMPSettingsModelForROP::SetProxyMode(%d)"),aMode);

    return SetIntegerValue(EMPRopProxyMode, aMode);

    }

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

// CMPSettingsModelForROP::GetProxyMode

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

//

TInt CMPSettingsModelForROP::GetProxyMode(TInt& aMode)

    {

    MPX_DEBUG1(_L("#MS# CMPSettingsModelForROP::GetProxyMode()"));

    return GetIntegerValue(EMPRopProxyMode, aMode);

    }

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

// CMPSettingsModelForROP::SetProxyHostNameL

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

//

TInt CMPSettingsModelForROP::SetProxyHostNameL(const TDesC& aHostName)

    {

    MPX_DEBUG2(_L("#MS# CMPSettingsModelForROP::SetProxyHostNameL(%S)"),&aHostName);

    CMPRopSettingItem* item = NULL;

    TInt error = GetItem(EMPRopProxyHostName, item);

    if (!error)

        {

        delete item->iStringValue;

        item->iStringValue = NULL;

        item->iStringValue = aHostName.AllocL();

        item->iValueChanged = ETrue;

        item->iError = KErrNone;

        }

    MPX_DEBUG2(_L("#MS# CMPSettingsModelForROP::SetProxyHostNameL() ret %d"),error);

    return error;

    }

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

// CMPSettingsModelForROP::GetProxyHostName

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

//

TInt CMPSettingsModelForROP::GetProxyHostName(TDes& aHostName)

    {

    MPX_DEBUG2(_L("#MS# CMPSettingsModelForROP::GetProxyHostName(%S)"),&aHostName);

    CMPRopSettingItem* item = NULL;

    TInt error = GetItem(EMPRopProxyHostName, item);

    if (!error)

        {

        error = item->iError;

        }

    if (!error)

        {

        // Fail safe: aHostName's length is not exceeded in the copy operation

        aHostName.Copy(item->iStringValue->Left(aHostName.MaxLength()));

        }

    MPX_DEBUG2(_L("#MS# CMPSettingsModelForROP::GetProxyHostName() ret %d"),error);

    return error;

    }

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

// CMPSettingsModelForROP::SetProxyPort

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

//

TInt CMPSettingsModelForROP::SetProxyPort(TInt aPort)

    {

    MPX_DEBUG2(_L("#MS# CMPSettingsModelForROP::SetProxyPort(%d)"),aPort);

    return SetIntegerValue(EMPRopProxyPort, aPort);

    }

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

// CMPSettingsModelForROP::GetProxyPort

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

//

TInt CMPSettingsModelForROP::GetProxyPort(TInt& aPort)

    {

    MPX_DEBUG1(_L("#MS# CMPSettingsModelForROP::GetProxyPort()"));

    return GetIntegerValue(EMPRopProxyPort, aPort);

    }

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

// CMPSettingsModelForROP::SetDefaultAp

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

//

TInt CMPSettingsModelForROP::SetDefaultAp(TUint32 aApId)

    {

    MPX_DEBUG2(_L("#MS# CMPSettingsModelForROP::SetDefaultAp(%d)"),aApId);

    TInt error = KErrNone;

    TUint32 tmp = 0;

    TRAP( error, tmp = IapIdFromWapIdL( aApId ) );

    if ( !error )

        {

        error = SetIntegerValue(EMPRopDefaultAP, tmp );

        }

    MPX_DEBUG2(_L("#MS# CMPSettingsModelForROP::SetDefaultAp() ret %d"),error);

    return error;

    }

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

// CMPSettingsModelForROP::GetDefaultAp

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

//

TInt CMPSettingsModelForROP::GetDefaultAp(TUint32& aApId)

    {

    MPX_DEBUG1(_L("#MS# CMPSettingsModelForROP::GetDefaultAp()"));

    TInt tmp = 0;

	TInt error = GetIntegerValue(EMPRopDefaultAP, tmp);

    MPX_DEBUG2(_L("#MS# CMPSettingsModelForROP::GetDefaultAp - Got iap id %d"),tmp);

	if ( tmp != 0 )

	    {

		TRAP( error, aApId = WapIdFromIapIdL(static_cast<TUint32>(tmp)) );

	    }

	else {

        aApId = 0;

        }

	return error;

    }

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

// CMPSettingsModelForROP::SetBandwidthControlMode

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

//

TInt CMPSettingsModelForROP::SetBandwidthControlMode(TInt /*aMode*/)

    {

    MPX_DEBUG1(_L("#MS# CMPSettingsModelForROP::SetBandwidthControlMode()"));

    return KErrNotSupported;

    }

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

// CMPSettingsModelForROP::GetBandwidthControlMode

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

//

TInt CMPSettingsModelForROP::GetBandwidthControlMode(TInt& /*aMode*/)

    {

    MPX_DEBUG1(_L("#MS# CMPSettingsModelForROP::GetBandwidthControlMode()"));

    return KErrNotSupported;

    }

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

// CMPSettingsModelForROP::SetMaxBandwidth

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

//

TInt CMPSettingsModelForROP::SetMaxBandwidth(TInt aMaxBw, TDataBearer aBearer)

    {

    MPX_DEBUG3(_L("#MS# CMPSettingsModelForROP::SetMaxBandwidth(%d,%d)"),aMaxBw,aBearer);

    TInt error = KErrNone;

    switch (aBearer)

        {

        case EBearerGPRS:

            error = SetIntegerValue(EMPRopGPRSMaxBw, aMaxBw);

            break;

        case EBearerEGPRS:

            error = SetIntegerValue(EMPRopEGPRSMaxBw, aMaxBw);

            break;

        case EBearerWCDMA:

            error = SetIntegerValue(EMPRopWCDMAMaxBw, aMaxBw);

            break;

        case EBearerWLAN:

            error = SetIntegerValue(EMPRopWLANMaxBw, aMaxBw);

            break;

        case EBearerHSDPA:

            error = SetIntegerValue(EMPRopHSDPAMaxBw, aMaxBw);

            break;

        default:

            error = KErrNotSupported;

            break;

        }

    MPX_DEBUG2(_L("#MS# CMPSettingsModelForROP::SetMaxBandwidth() ret %d"),error);

    return error;

    }

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

// CMPSettingsModelForROP::GetMaxBandwidth

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

//

TInt CMPSettingsModelForROP::GetMaxBandwidth(TInt& aMaxBw, TDataBearer aBearer)

    {

    MPX_DEBUG1(_L("#MS# CMPSettingsModelForROP::GetMaxBandwidth()"));

    TInt error = KErrNone;

    switch (aBearer)

        {

        case EBearerGPRS:

            error = GetIntegerValue(EMPRopGPRSMaxBw, aMaxBw);

            break;

        case EBearerEGPRS:

            error = GetIntegerValue(EMPRopEGPRSMaxBw, aMaxBw);

            break;

        case EBearerWCDMA:

            error = GetIntegerValue(EMPRopWCDMAMaxBw, aMaxBw);

            break;

        case EBearerWLAN:

            error = GetIntegerValue(EMPRopWLANMaxBw, aMaxBw);

            break;

        case EBearerHSDPA:

            error = GetIntegerValue(EMPRopHSDPAMaxBw, aMaxBw);

            break;

        default:

            error = KErrNotSupported;

            break;

        }

    MPX_DEBUG2(_L("#MS# CMPSettingsModelForROP::GetMaxBandwidth() ret %d"),error);

    return error;

    }

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

// CMPSettingsModelForROP::SetConnectionTimeout

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