/*
* 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.*
*/
// Version : %version: 9 %
// 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
// -----------------------------------------------------------------------------
//
TInt CMPSettingsModelForROP::SetConnectionTimeout(TInt aTimeout)
{
MPX_DEBUG2(_L("#MS# CMPSettingsModelForROP::SetConnectionTimeout(%d)"),aTimeout);
return SetIntegerValue(EMPRopConnTimeout, aTimeout * KMPRopSecondsMultiplier);
}
// -----------------------------------------------------------------------------
// CMPSettingsModelForROP::GetConnectionTimeout
// -----------------------------------------------------------------------------
//
TInt CMPSettingsModelForROP::GetConnectionTimeout(TInt& aTimeout)
{
MPX_DEBUG1(_L("#MS# CMPSettingsModelForROP::GetConnectionTimeout()"));
TInt error = GetIntegerValue(EMPRopConnTimeout, aTimeout);
if (!error)
{
aTimeout = aTimeout / KMPRopSecondsMultiplier;
}
MPX_DEBUG2(_L("#MS# CMPSettingsModelForROP::GetConnectionTimeout() ret %d"),error);
return error;
}
// -----------------------------------------------------------------------------
// CMPSettingsModelForROP::SetServerTimeout
// -----------------------------------------------------------------------------
//
TInt CMPSettingsModelForROP::SetServerTimeout(TInt aTimeout)
{
MPX_DEBUG2(_L("#MS# CMPSettingsModelForROP::SetServerTimeout(%d)"),aTimeout);
return SetIntegerValue(EMPRopServerTimeout, aTimeout * KMPRopSecondsMultiplier);
}
// -----------------------------------------------------------------------------
// CMPSettingsModelForROP::GetServerTimeout
// -----------------------------------------------------------------------------
//
TInt CMPSettingsModelForROP::GetServerTimeout(TInt& aTimeout)
{
MPX_DEBUG1(_L("#MS# CMPSettingsModelForROP::GetServerTimeout()"));
TInt error = GetIntegerValue(EMPRopServerTimeout, aTimeout);
if (!error)
{
aTimeout = aTimeout / KMPRopSecondsMultiplier;
}
MPX_DEBUG2(_L("#MS# CMPSettingsModelForROP::GetServerTimeout() ret %d"),error);
return error;
}
// -----------------------------------------------------------------------------
// CMPSettingsModelForROP::SetMinUDPPort
// -----------------------------------------------------------------------------
//
TInt CMPSettingsModelForROP::SetMinUDPPort(TInt aPort)
{
MPX_DEBUG2(_L("#MS# CMPSettingsModelForROP::SetMinUDPPort(%d)"),aPort);
return SetIntegerValue(EMPRopMinUDPPort, aPort);
}
// -----------------------------------------------------------------------------
// CMPSettingsModelForROP::GetMinUDPPort
// -----------------------------------------------------------------------------
//
TInt CMPSettingsModelForROP::GetMinUDPPort(TInt& aPort)
{
MPX_DEBUG1(_L("#MS# CMPSettingsModelForROP::GetMinUDPPort()"));
return GetIntegerValue(EMPRopMinUDPPort, aPort);
}
// -----------------------------------------------------------------------------
// CMPSettingsModelForROP::SetMaxUDPPort
// -----------------------------------------------------------------------------
//
TInt CMPSettingsModelForROP::SetMaxUDPPort(TInt aPort)
{
MPX_DEBUG2(_L("#MS# CMPSettingsModelForROP::SetMaxUDPPort(%d)"),aPort);
return SetIntegerValue(EMPRopMaxUDPPort, aPort);
}
// -----------------------------------------------------------------------------
// CMPSettingsModelForROP::GetMaxUDPPort
// -----------------------------------------------------------------------------
//
TInt CMPSettingsModelForROP::GetMaxUDPPort(TInt& aPort)
{
MPX_DEBUG1(_L("#MS# CMPSettingsModelForROP::GetMaxUDPPort()"));
return GetIntegerValue(EMPRopMaxUDPPort, aPort);
}
// -----------------------------------------------------------------------------
// CMPSettingsModelForROP::GetControllerVersionInfo
// -----------------------------------------------------------------------------
//
TInt CMPSettingsModelForROP::GetControllerVersionInfo(TDes& aVersion)
{
MPX_DEBUG2(_L("#MS# CMPSettingsModelForROP::GetControllerVersionInfo(%S)"),&aVersion);
return GetStringValue(EMPRopCntrlVersion, aVersion);
}
// -----------------------------------------------------------------------------
// CMPSettingsModelForROP::GetControllerBuildDate
// -----------------------------------------------------------------------------
//
TInt CMPSettingsModelForROP::GetControllerBuildDate(TDes& aBldDate)
{
MPX_DEBUG2(_L("#MS# CMPSettingsModelForROP::GetControllerBuildDate(%S)"),&aBldDate);
return GetStringValue(EMPRopCntrlBldDate, aBldDate);
}
// -----------------------------------------------------------------------------
// CMPSettingsModelForROP::GetControllerAdditionalInfo
// -----------------------------------------------------------------------------
//
TInt CMPSettingsModelForROP::GetControllerAdditionalInfo(TDes& aAdditionalInfo)
{
MPX_DEBUG2(_L("#MS# CMPSettingsModelForROP::GetControllerAdditionalInfo(%S)"),&aAdditionalInfo);
return GetStringValue(EMPRopCntrlPlatform, aAdditionalInfo);
}
// -----------------------------------------------------------------------------
// CMPSettingsModelForROP::SetDemandBwFactor
// -----------------------------------------------------------------------------
//
TInt CMPSettingsModelForROP::SetDemandBwFactor(TInt aFactor)
{
MPX_DEBUG2(_L("#MS# CMPSettingsModelForROP::SetDemandBwFactor(%d)"),aFactor);
return SetIntegerValue(EMPRopDemandBwFactor, aFactor);
}
// -----------------------------------------------------------------------------
// CMPSettingsModelForROP::GetDemandBwFactor
// -----------------------------------------------------------------------------
//
TInt CMPSettingsModelForROP::GetDemandBwFactor(TInt& aFactor)
{
MPX_DEBUG1(_L("#MS# CMPSettingsModelForROP::GetDemandBwFactor()"));
return GetIntegerValue(EMPRopDemandBwFactor, aFactor);
}
// -----------------------------------------------------------------------------
// CMPSettingsModelForROP::SetSustainBandwidth
// -----------------------------------------------------------------------------
//
TInt CMPSettingsModelForROP::SetSustainBandwidth(TInt aSustainBw, TDataBearer aBearer)
{
MPX_DEBUG3(_L("#MS# CMPSettingsModelForROP::SetSustainBandwidth(%d,%d)"),aSustainBw,aBearer);
TInt error = KErrNone;
switch (aBearer)
{
case EBearerGPRS:
error = SetIntegerValue(EMPRopGPRSSustainBw, aSustainBw);
break;
case EBearerEGPRS:
error = SetIntegerValue(EMPRopEGPRSSustainBw, aSustainBw);
break;
case EBearerWCDMA:
error = SetIntegerValue(EMPRopWCDMASustainBw, aSustainBw);
break;
case EBearerWLAN:
error = SetIntegerValue(EMPRopWLANSustainBw, aSustainBw);
break;
case EBearerHSDPA:
error = SetIntegerValue(EMPRopHSDPASustainBw, aSustainBw);
break;
default:
error = KErrNotSupported;
break;
}
MPX_DEBUG2(_L("#MS# CMPSettingsModelForROP::SetSustainBandwidth() ret %d"),error);
return error;
}
// -----------------------------------------------------------------------------
// CMPSettingsModelForROP::GetSustainBandwidth
// -----------------------------------------------------------------------------
//
TInt CMPSettingsModelForROP::GetSustainBandwidth(TInt& aSustainBw, TDataBearer aBearer)
{
MPX_DEBUG1(_L("#MS# CMPSettingsModelForROP::GetSustainBandwidth()"));
TInt error = KErrNone;
switch (aBearer)
{
case EBearerGPRS:
error = GetIntegerValue(EMPRopGPRSSustainBw, aSustainBw);
break;
case EBearerEGPRS:
error = GetIntegerValue(EMPRopEGPRSSustainBw, aSustainBw);
break;
case EBearerWCDMA:
error = GetIntegerValue(EMPRopWCDMASustainBw, aSustainBw);
break;
case EBearerWLAN:
error = GetIntegerValue(EMPRopWLANSustainBw, aSustainBw);
break;
case EBearerHSDPA:
error = GetIntegerValue(EMPRopHSDPASustainBw, aSustainBw);
break;
default:
error = KErrNotSupported;
break;
}
MPX_DEBUG2(_L("#MS# CMPSettingsModelForROP::GetSustainBandwidth() ret %d"),error);
return error;
}
// -----------------------------------------------------------------------------
// CMPSettingsModelForROP::GetSustainBwPresetsL
// -----------------------------------------------------------------------------
//
TInt CMPSettingsModelForROP::GetSustainBwPresetsL(RArray<TInt>& aBwArray, TDataBearer aBearer)
{
MPX_DEBUG1(_L("#MS# CMPSettingsModelForROP::GetSustainBwPresetsL()"));
TInt error = KErrNone;
switch (aBearer)
{
case EBearerGPRS:
error = GetArrayL(EMPRopGPRSSustainBwPresets, aBwArray);
break;
case EBearerEGPRS:
error = GetArrayL(EMPRopEGPRSSustainBwPresets, aBwArray);
break;
case EBearerWCDMA:
error = GetArrayL(EMPRopWCDMASustainBwPresets, aBwArray);
break;
case EBearerWLAN:
error = GetArrayL(EMPRopWLANSustainBwPresets, aBwArray);
break;
case EBearerHSDPA:
error = GetArrayL(EMPRopHSDPASustainBwPresets, aBwArray);
break;
default:
error = KErrNotSupported;
break;
}
MPX_DEBUG2(_L("#MS# CMPSettingsModelForROP::GetSustainBwPresetsL() ret %d"),error);
return error;
}
// -----------------------------------------------------------------------------
// CMPSettingsModelForROP::GetMaxBwPresetsL
// -----------------------------------------------------------------------------
//
TInt CMPSettingsModelForROP::GetMaxBwPresetsL(RArray<TInt>& aBwArray, TDataBearer aBearer)
{
MPX_DEBUG1(_L("#MS# CMPSettingsModelForROP::GetMaxBwPresetsL()"));
TInt error = KErrNone;
switch (aBearer)
{
case EBearerGPRS:
error = GetArrayL(EMPRopGPRSMaxBwPresets, aBwArray);
break;
case EBearerEGPRS:
error = GetArrayL(EMPRopEGPRSMaxBwPresets, aBwArray);
break;
case EBearerWCDMA:
error = GetArrayL(EMPRopWCDMAMaxBwPresets, aBwArray);
break;
case EBearerWLAN:
error = GetArrayL(EMPRopWLANMaxBwPresets, aBwArray);
break;
case EBearerHSDPA:
error = GetArrayL(EMPRopHSDPAMaxBwPresets, aBwArray);
break;
default:
error = KErrNotSupported;
break;
}
MPX_DEBUG2(_L("#MS# CMPSettingsModelForROP::GetMaxBwPresetsL() ret %d"),error);
return error;
}
// -----------------------------------------------------------------------------
// CMPSettingsModelForROP::SetIntegerValue
// -----------------------------------------------------------------------------
//
TInt CMPSettingsModelForROP::SetIntegerValue(TInt aId, TInt aValue)
{
MPX_DEBUG3(_L("#MS# CMPSettingsModelForROP::SetIntegerValue(%d,%d)"),aId,aValue);
CMPRopSettingItem* item = NULL;
TInt error = GetItem(aId, item);
if (!error)
{
item->iIntValue = aValue;
item->iValueChanged = ETrue;
item->iError = KErrNone;
}
MPX_DEBUG2(_L("#MS# CMPSettingsModelForROP::SetIntegerValue() ret %d"),error);
return error;
}
// -----------------------------------------------------------------------------
// CMPSettingsModelForROP::GetIntegerValue
// -----------------------------------------------------------------------------
//
TInt CMPSettingsModelForROP::GetIntegerValue(TInt aId, TInt& aValue)
{
MPX_DEBUG2(_L("#MS# CMPSettingsModelForROP::GetIntegerValue(%d)"),aId);
CMPRopSettingItem* item = NULL;
TInt error = GetItem(aId, item);
if (!error)
{
error = item->iError;
}
if (!error)
{
if (item->iType == EMPRopConfTypeInteger)
{
aValue = item->iIntValue;
}
else
{
// Setting value's type is not integer
error = KErrNotFound;
}
}
MPX_DEBUG2(_L("#MS# CMPSettingsModelForROP::GetIntegerValue() ret %d"),error);
return error;
}
// -----------------------------------------------------------------------------
// CMPSettingsModelForROP::GetStringValue
// -----------------------------------------------------------------------------
//
TInt CMPSettingsModelForROP::GetStringValue(TInt aId, TDes& aString)
{
MPX_DEBUG3(_L("#MS# CMPSettingsModelForROP::GetStringValue(%d,%S)"),aId,&aString);
CMPRopSettingItem* item = NULL;
TInt error = GetItem(aId, item);
if (!error)
{
error = item->iError;
}
if (!error)
{
if (item->iType == EMPRopConfTypeString)
{
HBufC* string = item->iStringValue;
if (aString.MaxLength() >= string->Length())
{
aString.Copy(*string);
}
else
{
error = KErrOverflow;
}
}
else
{
// Setting value's type is not string
error = KErrNotFound;
}
}
MPX_DEBUG2(_L("#MS# CMPSettingsModelForROP::GetStringValue() ret %d"),error);
return error;
}
// -----------------------------------------------------------------------------
// CMPSettingsModelForROP::GetArrayL
// -----------------------------------------------------------------------------
//
TInt CMPSettingsModelForROP::GetArrayL(TInt aId, RArray<TInt>& aArray)
{
MPX_DEBUG1(_L("#MS# CMPSettingsModelForROP::GetArrayL()"));
CMPRopSettingItem* item = NULL;
TInt error = GetItem(aId, item);
if (!error)
{
error = item->iError;
}
if (!error)
{
if (item->iType == EMPRopConfTypeIntArray)
{
TInt count = item->iIntArray.Count();
aArray.Reset();
for (TInt index = 0; index < count; ++index)
{
User::LeaveIfError(aArray.Append(item->iIntArray[index]));
}
}
else
{
error = KErrNotFound;
}
}
MPX_DEBUG2(_L("#MS# CMPSettingsModelForROP::GetArrayL() ret %d"),error);
return error;
}
// -----------------------------------------------------------------------------
// CMPSettingsModelForROP::GetItem
// -----------------------------------------------------------------------------
//
TInt CMPSettingsModelForROP::GetItem(TInt aId, CMPRopSettingItem*& aItem)
{
MPX_DEBUG2(_L("#MS# CMPSettingsModelForROP::GetItem(%d)"),aId);
CMPRopSettingItem* item = NULL;
TInt count = iItems->Count();
TInt error = KErrNone;
aItem = NULL;
for (TInt index = 0; index < count; ++index)
{
item = iItems->At(index);
if (aId == item->iId)
{
aItem = item;
break;
}
}
if (!aItem)
{
error = KErrNotFound;
}
MPX_DEBUG2(_L("#MS# CMPSettingsModelForROP::GetItem() ret %d"),error);
return error;
}
// -----------------------------------------------------------------------------
// CMPSettingsModelForROP::SetAutoDisconTimeL
// -----------------------------------------------------------------------------
//
void CMPSettingsModelForROP::SetAutoDisconTimeL( const TInt aTime )
{
MPX_DEBUG2(_L("#MS# CMPSettingsModelForROP::SetAutoDisconTimeL(%d)"),aTime);
if ( iClient->Set( KMPAutoDisconnectTime, aTime ) == KErrNotFound )
{
User::LeaveIfError( iClient->Create( KMPAutoDisconnectTime, aTime ) );
}
}
// -----------------------------------------------------------------------------
// CMPSettingsModelForROP::AutoDisconTimeL
// -----------------------------------------------------------------------------
//
TInt CMPSettingsModelForROP::AutoDisconTimeL()
{
MPX_DEBUG1(_L("#MS# CMPSettingsModelForROP::AutoDisconTimeL()"));
TInt time = 0;
User::LeaveIfError( iClient->Get( KMPAutoDisconnectTime, time ) );
MPX_DEBUG2(_L("#MS# CMPSettingsModelForROP::AutoDisconTimeL() ret %d"),time);
return time;
}
// -----------------------------------------------------------------------------
// CMPSettingsModelForROP::SetVideoRepeatL
// -----------------------------------------------------------------------------
//
void CMPSettingsModelForROP::SetVideoRepeatL( TBool aRepeat )
{
MPX_DEBUG2(_L("#MS# CMPSettingsModelForROP::SetVideoRepeatL(%d)"),aRepeat);
iClient->Set( KMPRepeat, aRepeat );
}
// -----------------------------------------------------------------------------
// CMPSettingsModelForROP::IsVideoRepeatOnL
// -----------------------------------------------------------------------------
//
TBool CMPSettingsModelForROP::IsVideoRepeatOnL()
{
MPX_DEBUG1(_L("#MS# CMPSettingsModelForROP::IsVideoRepeatOnL()"));
TInt repeat;
User::LeaveIfError( iClient->Get( KMPRepeat, repeat ) );
MPX_DEBUG2(_L("#MS# CMPSettingsModelForROP::IsVideoRepeatOnL() ret %d"),repeat);
return repeat;
}
// ----------------------------------------------------------------------------
// CMPSettingsModelForROP::InitializeCentralRepositoryL
//
// Creating and setting keys for the Central Repository
// ----------------------------------------------------------------------------
//
void CMPSettingsModelForROP::InitializeCentralRepositoryL()
{
MPX_DEBUG1(_L("#MS# CMPSettingsModelForROP::InitializeCentralRepositoryL()"));
iClient = CRepository::NewL( KCRUidMediaPlayerSettings );
iMediaPlayerClient = CRepository::NewL( KCRUidMediaPlayerFeatures );
}
// ----------------------------------------------------------------------------
// CMPSettingsModelForROP::UninitializeCentralRepositoryL
//
// Removes Central Repository objects
// ----------------------------------------------------------------------------
//
void CMPSettingsModelForROP::UninitializeCentralRepository()
{
MPX_DEBUG1(_L("#MS# CMPSettingsModelForROP::UninitializeCentralRepository()"));
delete iClient;
iClient = NULL;
delete iMediaPlayerClient;
iMediaPlayerClient = NULL;
}
// -----------------------------------------------------------------------------
// CMPSettingsModelForROP::SetDefaultViewL
// -----------------------------------------------------------------------------
//
void CMPSettingsModelForROP::SetDefaultViewL( TBool aView )
{
MPX_DEBUG2(_L("#MS# CMPSettingsModelForROP::SetDefaultViewL(%d)"),aView);
iClient->Set( KMPDefaultView, aView );
}
// -----------------------------------------------------------------------------
// CMPSettingsModelForROP::IsDefaultViewOnL
// -----------------------------------------------------------------------------
//
TBool CMPSettingsModelForROP::IsDefaultViewOnL()
{
MPX_DEBUG1(_L("#MS# CMPSettingsModelForROP::IsDefaultViewOnL()"));
TInt view;
User::LeaveIfError( iClient->Get( KMPDefaultView, view ) );
MPX_DEBUG2(_L("#MS# CMPSettingsModelForROP::IsDefaultViewOnL() ret %d"),view);
return view;
}
// -----------------------------------------------------------------------------
// CMPSettingsModelForROP::SetRockerKeysL
// -----------------------------------------------------------------------------
//
void CMPSettingsModelForROP::SetRockerKeysL( TBool aRockerKeys )
{
iClient->Set( KMPRockerKeys, aRockerKeys );
}
// -----------------------------------------------------------------------------
// CMPSettingsModelForROP::ShowRockerKeysL
// -----------------------------------------------------------------------------
//
TBool CMPSettingsModelForROP::ShowRockerKeysL()
{
if (IsRockerKeysSupportedL())
{
TInt rockerKeys;
User::LeaveIfError( iClient->Get( KMPRockerKeys, rockerKeys ) );
return rockerKeys;
}
else
{
return EFalse;
}
}
// -----------------------------------------------------------------------------
// CMPSettingsModelForROP::IsRockerKeysSupportedL
// -----------------------------------------------------------------------------
//
TBool CMPSettingsModelForROP::IsRockerKeysSupportedL()
{
TBool isRockerKeysSupported( EFalse );
TInt value( 0 );
// Check if feature is enabled. See MediaPlayerVariant.hrh.
if ( !iMediaPlayerClient->Get( KMPLocalVariation, value ) )
{
isRockerKeysSupported = static_cast<TBool> ( value & KMediaPlayerRockerKeys );
}
RDebug::Print(_L("#MP# CMPSettingsModelForROP::CMPSettingsModelForROP(): return %d"),isRockerKeysSupported);
return isRockerKeysSupported;
}
// -----------------------------------------------------------------------------
// CMPSettingsModelForROP::LocateResourceFileL
// -----------------------------------------------------------------------------
//
void CMPSettingsModelForROP::LocateResourceFileL( TFileName& aFileName, RFs& aFs )
{
MPX_DEBUG1(_L("#MS# CMPSettingsModelForROP::LocateResourceFileL()"));
// Get the path & file name with the drive not specified.
TParse parse;
parse.Set( KMPSettROPResource, &KDC_RESOURCE_FILES_DIR, NULL );
TPtrC rscFile = parse.FullName();
// This is done to ensure upgraded file is used first.
TFindFile find( aFs );
TInt err = find.FindByDir( rscFile, KNullDesC );
if ( err )
{
MPX_DEBUG1(_L("#MS# CMPSettingsModelForROP::LocateResourceFileL() LEAVE: KErrNotFound"));
User::Leave( KErrNotFound );
}
else
{
aFileName.Append( find.File() );
}
MPX_DEBUG2(_L("#MS# CMPSettingsModelForROP::LocateResourceFileL(%S)"),&aFileName);
}
// -----------------------------------------------------------------------------
// CVcxConnUtilImpl::WapIdFromIapIdL
// -----------------------------------------------------------------------------
//
TUint32 CMPSettingsModelForROP::WapIdFromIapIdL( TUint32 aIapId )
{
MPX_DEBUG2(_L("#MS# CMPSettingsModelForROP::WapIdFromIapIdL(%d)"),aIapId);
CMDBSession* db = CMDBSession::NewL( CMDBSession::LatestVersion() );
CleanupStack::PushL( db );
// WapIpBearer table contains the mapping between wap and iap id's.
CCDWAPIPBearerRecord* wapBearerRecord =
static_cast<CCDWAPIPBearerRecord*>( CCDRecordBase::RecordFactoryL( KCDTIdWAPIPBearerRecord ) );
CleanupStack::PushL( wapBearerRecord );
wapBearerRecord->iWAPIAP = aIapId;
TBool found = wapBearerRecord->FindL( *db );
if ( !found )
{
User::Leave(KErrNotFound);
}
TUint32 wap = static_cast<TUint32>( wapBearerRecord->iWAPAccessPointId );
CleanupStack::PopAndDestroy( wapBearerRecord );
CleanupStack::PopAndDestroy( db );
MPX_DEBUG2(_L("#MS# CMPSettingsModelForROP::IapIdFromWapIdL() - return wap id: %d "), wap);
return wap;
}
// -----------------------------------------------------------------------------
// CVcxConnUtilImpl::IapIdFromWapIdL
// -----------------------------------------------------------------------------
//
TUint32 CMPSettingsModelForROP::IapIdFromWapIdL( TUint32 aWapId )
{
MPX_DEBUG2(_L("#MS# CMPSettingsModelForROP::IapIdFromWapIdL(%d)"),aWapId);
CMDBSession* db = CMDBSession::NewL( CMDBSession::LatestVersion() );
CleanupStack::PushL( db );
// WapIpBearer table contains the mapping between wap and iap id's.
CCDWAPIPBearerRecord* wapBearerRecord =
static_cast<CCDWAPIPBearerRecord*>( CCDRecordBase::RecordFactoryL( KCDTIdWAPIPBearerRecord ) );
CleanupStack::PushL( wapBearerRecord );
wapBearerRecord->iWAPAccessPointId = aWapId;
TBool found = wapBearerRecord->FindL( *db );
if ( !found )
{
User::Leave(KErrNotFound);
}
TUint32 iap = static_cast<TUint32>( wapBearerRecord->iWAPIAP );
CleanupStack::PopAndDestroy( wapBearerRecord );
CleanupStack::PopAndDestroy( db );
MPX_DEBUG2(_L("#MS# CMPSettingsModelForROP::IapIdFromWapIdL() - return iap id: %d "), iap);
return iap;
}
// End of File