/*

* 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 <QStringList>

#include "irqnetworkcontrollerbody.h"

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

// IRQNetworkControllerBody::~IRQNetworkControllerBody()

// Destructor

//

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

//

IRQNetworkControllerBody::~IRQNetworkControllerBody()

{

    if (iNetworkController)

    {

        iNetworkController->Close();

    }

}

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

// IRQNetworkControllerBody::GetNetworkStatus()

// Returns the variable which indicates if connection is active or not

// @return bool

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

//

bool IRQNetworkControllerBody::getNetworkStatus() const

{

    return (bool)iNetworkController->GetNetworkStatus();

}

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

// IRQNetworkControllerBody::getIAPId()

// Gets the IAP Id of the chosen IAP

// @return IRQError

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

//

IRQError IRQNetworkControllerBody::getIAPId(unsigned long& aIapId) const

{

    IRQError retval = EIRQErrorNone;

    if (KErrNotFound == iNetworkController->GetIAPId(aIapId))

    {

        retval = EIRQErrorNotFound;

    }

    return retval;

}

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

// IRQNetworkControllerBody::getAccessPointList()

// Returns the list of available access points

// @return QStringList &aList specifying the access point names

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

//

void IRQNetworkControllerBody::getAccessPointList(QStringList &aList)

{

    const CDesCArray *apArray = iNetworkController->GetAccessPointList();

    int count = apArray->MdcaCount();

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

    {

        QString str = QString::fromUtf16(apArray->MdcaPoint(i).Ptr(), apArray->MdcaPoint(i).Length());

        aList.append(str);

    }

}

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

// IRQNetworkControllerBody::getApIdList()

// Returns the list of iap ids for available access points

// @return QList<unsigned long> &aList specifying the iap ids

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

//

void IRQNetworkControllerBody::getApIdList(QList<unsigned long> &aList)

{

    const RArray<TUint32>& accessPointIDArray = iNetworkController->GetApList();

    for (int i = 0; i < accessPointIDArray.Count(); ++i)

    {

        aList.append(accessPointIDArray[i]);

    }

}

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

// IRQNetworkControllerBody::getBearerList()

// Returns the list of bearer ids for available access points

// @return QList<unsigned long> &aList specifying the bearer ids

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

//

void IRQNetworkControllerBody::getBearerList(QList<unsigned long> &aList)

{

    const RArray<TUint32>& bearerIDArray = iNetworkController->GetBearerList();

    for (int i = 0; i < bearerIDArray.Count(); ++i)

    {

        aList.append(bearerIDArray[i]);

    }

}

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

// IRQNetworkControllerBody::getNetworkList()

// Returns the list of network ids for available access points

// @return QList<unsigned long> &aList specifying the network ids

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

//

void IRQNetworkControllerBody::getNetworkList(QList<unsigned long> &aList)

{

    const RArray<TUint32>& networkIDArray = iNetworkController->GetNetworkList();

    for (int i = 0; i < networkIDArray.Count(); ++i)

    {

        aList.append(networkIDArray[i]);

    }

}

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

// IRQNetworkControllerBody::chooseAccessPoint()

// Configures the Access Point which is used by all the components for network

// connectivity

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

//

void  IRQNetworkControllerBody::chooseAccessPoint()

{

    TRAPD(error, iNetworkController->ChooseAccessPointL());

    if (KErrNone != error)

    {

        emit errorOccured(EIRQErrorGeneral);

    }

}

/*

 * Cancel configuring access point

 */

void IRQNetworkControllerBody::cancelConnecting()

{

    iNetworkController->CancelConnecting();

}

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

// IRQNetworkControllerBody::isOfflineMode()

// Indicates if the phone is in offline mode

// @return True if the phone is in offline mode else False

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

//

bool IRQNetworkControllerBody::isOfflineMode()

{

    return (bool)iNetworkController->IsOfflineMode();

}

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

// IRQNetworkControllerBody::isWlanSupported()

// Indicates if the phone supports WLan usage

// @return True if the phone supports else False

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

//

bool IRQNetworkControllerBody::isWlanSupported() const

{

    return (bool)iNetworkController->IsWlanSupported();

}

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

// IRQNetworkControllerBody::resetConnectionStatus()

// Resets the connection status to Disconnected state

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

//

void IRQNetworkControllerBody::resetConnectionStatus()

{

    iNetworkController->ResetConnectionStatus();

}

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

// IRQNetworkControllerBody::identifyConnectionType()

// Indicates the type of connection

// @return enum describing the type of connection ( GPRS/3G/WiFi )

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

//

IRQConnectionType IRQNetworkControllerBody::identifyConnectionType() const

{

    return (IRQConnectionType)iNetworkController->IdentifyConnectionType();

}

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

// IRQNetworkControllerBody::notifyActiveNetworkObservers()

// Notifies all observers whose network request is active to reissue the request

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

//

void IRQNetworkControllerBody::notifyActiveNetworkObservers(IRQNetworkEvent aEvent)

{

    TRAPD(error, iNetworkController->NotifyActiveNetworkObserversL((TIRNetworkEvent)aEvent));

    if (KErrNone != error)

    {

        emit errorOccured(EIRQErrorGeneral);

    }

}

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

// IRQNetworkControllerBody::isHandlingOverConnection()

// Indicates if the hand over of network connection has happened

// @return bool

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

//

bool IRQNetworkControllerBody::isHandlingOverConnection()

{

    return (bool)iNetworkController->IsHandingOverConnection();

}

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

// IRQNetworkControllerBody::isConnectRequestIssued()

// Indicates if chooseAccessPoint is called

// @return bool

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

//

bool IRQNetworkControllerBody::isConnectRequestIssued() const

{

    return (bool)iNetworkController->iIsConnectRequestIssued;

}

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

// MIRActiveNetworkObserver::NotifyActiveNetworkObserversL()

// Callback which notifies all observers whose network request is active to reissue the request

// @param aEvent Indicates the type of network event that occurred

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

//

void IRQNetworkControllerBody::NotifyActiveNetworkObserversL(TIRNetworkEvent aEvent)

{

    emit networkRequestNotified((IRQNetworkEvent)aEvent);

}

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

// MIRActiveNetworkObserver::ResetPendingRequests()

// Callback which notifies all observers whose network request is active to

// reset the pending request status

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

//

void IRQNetworkControllerBody::ResetPendingRequests(TBool aValue)

{

    emit pendingRequestsReset((bool)aValue);

}

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

// MIRNetworkController::IRNetworkEventL()

// @param aEvent Indicates the type of network event that occurred

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

//

void IRQNetworkControllerBody::IRNetworkEventL(TIRNetworkEvent aEvent)

{

    emit networkEventNotified((IRQNetworkEvent)aEvent);

}

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

// IRQNetworkControllerBody::initL()

// Create resources

//

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

//

void IRQNetworkControllerBody::initL()

{

    // Get singleton instance

    iNetworkController = CIRNetworkController::OpenL(this);

    iNetworkController->RegisterActiveNetworkObserverL(*this);

}