/*

* 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:  CSysInfoService class implementation

*

*/

#include <AccessoryConnection.h>

#include <AccessoryServer.h>

#include <PtiEngine.h>

#include <centralrepository.h>

#include <SysUtilDomainCRKeys.h>

#include "sysinfo.h"

#include "SysInfoUtils.h"

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

// CSysData::CSysData()

// Constructor

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

//

CSysData::CSysData(TDataType aType):iDataType(aType)

    {

    }

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

// CSysData::~CSysData()

// Destructor

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

//

CSysData::~CSysData()

    {

    }

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

// CSysData::DataType()

// returns type of data this instance holds. @TDataType

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

//

EXPORT_C CSysData::TDataType CSysData::DataType() const

    {

    return iDataType;

    }

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

// CStatus::CStatus()

// Constructor

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

//

CStatus::CStatus(TInt aStatus):CSysData(EStatus),iStatus(aStatus)

    {

    }

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

// CStatus::~CStatus()

// Destructor

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

//

CStatus::~CStatus()

    {

    }

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

// CStatus::CStatus()

// Two-phased constructor

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

//

EXPORT_C CStatus* CStatus::NewL(TInt aStatus)

    {

    CStatus* self = new (ELeave) CStatus(aStatus);

    return self;

    }

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

// CStatus::CStatus()

// returns interger value stored which is used to represent status of

// many SA's.

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

//

EXPORT_C TInt CStatus::Status() const

    {

    return iStatus;

    }

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

// CStringData::CStringData()

// Constructor.

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

//

CStringData::CStringData():CSysData(EStringData)

    {

    }

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

// CStringData::~CStringData()

// Destructor

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

//

CStringData::~CStringData()

    {

    delete iStringData;

    }

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

// CStringData::NewL()

// Two-phased constructor. returns new instance of this class.

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

//

EXPORT_C CStringData* CStringData::NewL(const TDesC& aString)

    {

    CStringData* self = new (ELeave) CStringData();

    CleanupStack::PushL(self);

    self->iStringData = aString.AllocL();

    CleanupStack::Pop(self);

    return self;

    }

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

// CStringData::StringData()

// On return aString contains string data.

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

//

EXPORT_C void CStringData::StringData(TPtrC& aString) const

    {

    aString.Set(*iStringData);

    }

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

// CVersion::CVersion()

// Constructor.

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

//

CVersion::CVersion(TInt aMajor,TInt aMinor):CSysData(EVersion),

                                        iMajorVersion(aMajor),

                                        iMinorVersion(aMinor)

    {

    }

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

// CVersion::~CVersion()

// Destructor

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

//

CVersion::~CVersion()

    {

    }

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

// CVersion::NewL()

// Two-phased constructor. returns new instance of this class.

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

//

CVersion* CVersion::NewL(TInt aMajor,TInt aMinor)

    {

    CVersion* self = new (ELeave) CVersion(aMajor,aMinor);

    return self;

    }

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

// CVersion::MajorVersion()

// returns major version number.

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

//

EXPORT_C TInt CVersion::MajorVersion() const

    {

    return iMajorVersion;

    }

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

// CVersion::MinorVersion()

// returns minor version number.

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

//

EXPORT_C TInt CVersion::MinorVersion() const 

    {

    return iMinorVersion;

    }

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

// CNetworkInfo::CNetworkInfo()

// Constructor.

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

//

CNetworkInfo::CNetworkInfo(RMobilePhone::TMobilePhoneNetworkInfoV1& aNetworkInfo,

                            RMobilePhone::TMobilePhoneLocationAreaV1& aArea)

                            :CSysData(ENetworkInfo),iNetworkInfo(aNetworkInfo),

                            iLAC(aArea)

    {

    }

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

// CNetworkInfo::~CNetworkInfo()

// Destructor

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

//

CNetworkInfo::~CNetworkInfo()

    {

    }

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

// CNetworkInfo::NewL()

// Two-phased constructor. returns new instance of this class.

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

//

CNetworkInfo* CNetworkInfo::NewL(

                        RMobilePhone::TMobilePhoneNetworkInfoV1& aNetworkInfo,

                        RMobilePhone::TMobilePhoneLocationAreaV1& aArea )

    {

    CNetworkInfo* self = new (ELeave) CNetworkInfo(aNetworkInfo,aArea);

    return self;

    }

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

// CNetworkInfo::NetworkName()

// returns network name.

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

//

EXPORT_C TPtrC CNetworkInfo::NetworkName()  const

    {

    return	TPtrC(iNetworkInfo.iLongName);

    }

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

// CNetworkInfo::NetworkMode()

// returns network mode.

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

//

EXPORT_C TInt CNetworkInfo::NetworkMode() const

    {

    return (iNetworkInfo.iMode - 1);

    }

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

// CNetworkInfo::NetworkStatus()

// returns network status.

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

//

EXPORT_C TInt CNetworkInfo::NetworkStatus() const

    {

    return (iNetworkInfo.iStatus -1);

    }

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

// CNetworkInfo::CountryCode()

// returns MCC Mobile Country Code.

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

//

EXPORT_C TPtrC CNetworkInfo::CountryCode() const

    {

    return 	TPtrC(iNetworkInfo.iCountryCode);

    }

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

// CNetworkInfo::NetworkCode()

// returns MNC Mobile Network Code.

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

//

EXPORT_C TPtrC CNetworkInfo::NetworkCode() const

    {

    return 	TPtrC(iNetworkInfo.iNetworkId);

    }	

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

// CNetworkInfo::LocationAreaCode()

// returns LAC Location Area Code.

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

//

EXPORT_C TUint CNetworkInfo::LocationAreaCode() const

    {

    return iLAC.iLocationAreaCode;

    }

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

// CNetworkInfo::CellId()

// returns Cell ID of a region.

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

//

EXPORT_C TUint CNetworkInfo::CellId()  const

    {

    return iLAC.iCellId;

    }

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

// CNetworkInfo::ValidLocationAreaCode()

// returns bool validates LAC and CellID data values.

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

//

EXPORT_C TBool CNetworkInfo::ValidLocationAreaCode()  const

    {

    return iLAC.iAreaKnown;

    }

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

// CAccessoryInfo::CAccessoryInfo()

// Constructor.

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

//

CAccessoryInfo::CAccessoryInfo(TAccessoryState aAccState)

                                :CSysData(EAccessoryInfo),

                                iConnectionState(aAccState)

    {

    }

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

// CAccessoryInfo::~CAccessoryInfo()

// Destructor

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

//

CAccessoryInfo::~CAccessoryInfo()

    {

    }

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

// CAccessoryInfo::NewL()

// Two-phased constructor. returns new instance of this class.

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

//

CAccessoryInfo* CAccessoryInfo::NewL(const TAccPolGenericID& aGenericID, 

                                        TAccessoryState aAccState)

    {

    CAccessoryInfo* self = new (ELeave) CAccessoryInfo(aAccState);

    self->GetAccessoryProperty(aGenericID);

    return self;

    }

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

// CAccessoryInfo::AccessoryType()

// returns type of accessory.

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

//

EXPORT_C TInt CAccessoryInfo::AccessoryType() const

    {

    return iAccessoryType;

    }

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

// CAccessoryInfo::GetAccessoryProperty()

// retrives accessory type information from aGenericID.

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

//

void CAccessoryInfo::GetAccessoryProperty(const TAccPolGenericID& aGenericID)

    {

    TUint32 deviceType = aGenericID.DeviceTypeCaps();

    TUint32 connectionType = aGenericID.PhysicalConnectionCaps();

    if(deviceType == KDTHeadset && (connectionType & KPCWired))

        {

        iAccessoryType = CAccessoryInfo::EHeadSet;

        }

    else if(deviceType == KDTHeadset && (connectionType & KPCBluetooth) )

        {

        iAccessoryType = EBTHeadSet;

        }

    else if(deviceType == KDTCarKit && (connectionType & KPCWired) )

        {

        iAccessoryType = ECarKit;

        }

    else if(deviceType == KDTCarKit && (connectionType == KPCBluetooth) )

        {

        iAccessoryType = EBTCarKit;

        }

    else

        {

        iAccessoryType = EUnknown;

        }

    }

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

// CAccessoryInfo::ConnectionState()

// returns accessory state (Connected,Disconnected).

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

//

EXPORT_C TInt CAccessoryInfo::ConnectionState() const

    {

    return iConnectionState;

    }

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

// CAccList::CAccList()

// Constructor.

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

//

CAccList::CAccList():CSysData(EAccessoryList)

    {

    }

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

// CAccList::~CAccList()

// Destructor

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

//

CAccList::~CAccList()

    {

    }

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

// CAccList::NewL()

// Two-phased constructor. returns new instance of this class.

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

//

CAccList* CAccList::NewL()

    {

    CAccList* self = new (ELeave) CAccList();

    CleanupStack::PushL(self);

    self->ConstructL();

    CleanupStack::Pop(self);

    return self;	

    }

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

// CAccList::ConstructL()

// 2nd phase construtor

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

//

void CAccList::ConstructL()

    {

    RAccessoryServer    		AccSrv;

    RAccessoryConnection    	AccConnection;

    //Connect to accessory server.

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

    //Create a session to it.

    User::LeaveIfError(AccConnection.CreateSubSession(AccSrv));

    //read list of connected accssories at this moment.

    AccConnection.GetAccessoryConnectionStatus(iAccessories);

    iCount = iAccessories.Count();

    //Close subsession.

    AccConnection.CloseSubSession();

    //Disconnect accessory server.

    AccSrv.Disconnect();

    }

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

// CAccList::AtL()

// Reads AccessoryInfo at an index. On return aAccessoryInfo consists 

// of accessory information.

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

//

EXPORT_C TBool CAccList::AtL(TInt aIndex,const CAccessoryInfo*& 

                                            aAccessoryInfo) const

    {

    TAccPolGenericID accessoryid;

    if(0 <= aIndex && aIndex < Count())

        {

        accessoryid = iAccessories.GetGenericIDL(aIndex);

        }

    else

        {

        aAccessoryInfo = NULL;

        return EFalse;

        }

    //Create CAccessoryInfo. client has the ownership.

    aAccessoryInfo = CAccessoryInfo::NewL(accessoryid,

                                            CAccessoryInfo::EConnected);

    return ETrue;

    }

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

// CAccList::[]

// Reads AccessoryInfo at an index. returns CAccessoryInfo 

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

//

EXPORT_C const CAccessoryInfo* CAccList::operator[](TInt aIndex) const

    {

    CAccessoryInfo* accessoryinfo = NULL;

    if(0 <= aIndex && aIndex < iCount)

        {

        TAccPolGenericID accessoryid;

        accessoryid = iAccessories.GetGenericIDL(aIndex);

        //Create CAccessoryInfo. client has the ownership.

        accessoryinfo = CAccessoryInfo::NewL(accessoryid,

                                            CAccessoryInfo::EConnected);

        }

    return accessoryinfo;

    }

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

// CAccList::Count()

// returns number of accessories. 

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

//

EXPORT_C TInt CAccList::Count() const

    {

    return iCount;

    }

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

// CLanguageList::CLanguageList()

// Constructor.

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

//

CLanguageList::CLanguageList():CSysData(ELanguageList)

    {

    }

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

// CLanguageList::~CLanguageList()

// Destructor

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

//

CLanguageList::~CLanguageList()

    {

    iLanguages.Close();

    }

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

// CLanguageList::NewL()

// Two-phased constructor. returns new instance of this class.

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

//

CLanguageList* CLanguageList::NewL()

    {

    CLanguageList* self;

    self = new (ELeave) CLanguageList();

    CleanupStack::PushL(self);

    self->ConstructL();