/****************************************************************************

**

** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).

** All rights reserved.

** Contact: Nokia Corporation (qt-info@nokia.com)

**

** This file is part of the Qt Mobility Components.

**

** $QT_BEGIN_LICENSE:LGPL$

** No Commercial Usage

** This file contains pre-release code and may not be distributed.

** You may use this file in accordance with the terms and conditions

** contained in the Technology Preview License Agreement accompanying

** this package.

**

** GNU Lesser General Public License Usage

** Alternatively, this file may be used under the terms of the GNU Lesser

** General Public License version 2.1 as published by the Free Software

** Foundation and appearing in the file LICENSE.LGPL included in the

** packaging of this file.  Please review the following information to

** ensure the GNU Lesser General Public License version 2.1 requirements

** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.

**

** In addition, as a special exception, Nokia gives you certain additional

** rights.  These rights are described in the Nokia Qt LGPL Exception

** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.

**

** If you have questions regarding the use of this file, please contact

** Nokia at qt-info@nokia.com.

**

**

**

**

**

**

**

**

** $QT_END_LICENSE$

**

****************************************************************************/

#include "qcorewlanengine_mac_p.h"

#include "qnetworkconfiguration_p.h"

#include <QtCore/qthread.h>

#include <QtCore/qmutex.h>

#include <QtCore/qcoreapplication.h>

#include <QtCore/qstringlist.h>

#include <QtCore/qdebug.h>

#if defined(MAC_SDK_10_6) //not much functionality without this

#include <CoreWLAN/CoreWLAN.h>

#include <CoreWLAN/CWInterface.h>

#include <CoreWLAN/CWNetwork.h>

#include <CoreWLAN/CWNetwork.h>

#endif

#include <Foundation/NSEnumerator.h>

#include <Foundation/NSKeyValueObserving.h>

#include <Foundation/NSAutoreleasePool.h>

#include <SystemConfiguration/SCNetworkConfiguration.h>

QMap <QString, QString> networkInterfaces;

#ifdef MAC_SDK_10_6

@interface QNSListener : NSObject

{

    NSNotificationCenter *center;

    CWInterface * currentInterface;

}

- (void)remove;

@end

@implementation QNSListener

- (id) init

{

    [super init];

    center = [NSNotificationCenter defaultCenter];

    currentInterface = [CWInterface interface];

    [center addObserver:self selector:@selector(notificationHandler:) name:kCWLinkDidChangeNotification object:nil];

    [center addObserver:self selector:@selector(notificationHandler:) name:kCWPowerDidChangeNotification object:nil];

    return self;

}

-(void)dealloc

{

   [center release];

   [currentInterface release];

   [super dealloc];

}

-(void)remove

{

    [center removeObserver:self];

}

{

    QTM_NAMESPACE::QCoreWlanEngine::instance()->requestUpdate();

}

@end

#endif

QTM_BEGIN_NAMESPACE

Q_GLOBAL_STATIC(QCoreWlanEngine, coreWlanEngine)

inline QString cfstringRefToQstring(CFStringRef cfStringRef) {

    QString retVal;

    CFIndex maxLength = 2 * CFStringGetLength(cfStringRef) + 1/*zero term*/; // max UTF8

    char *cstring = new char[maxLength];

    if (CFStringGetCString(CFStringRef(cfStringRef), cstring, maxLength, kCFStringEncodingUTF8)) {

        retVal = QString::fromUtf8(cstring);

    }

    delete[] cstring;

    return retVal;

}

inline CFStringRef qstringToCFStringRef(const QString &string)

{

    return CFStringCreateWithCharacters(0, reinterpret_cast<const UniChar *>(string.unicode()),

                                        string.length());

}

inline NSString *qstringToNSString(const QString &qstr)

{ return [reinterpret_cast<const NSString *>(qstringToCFStringRef(qstr)) autorelease]; }

inline QString nsstringToQString(const NSString *nsstr)

{ return cfstringRefToQstring(reinterpret_cast<const CFStringRef>(nsstr)); }

inline QStringList nsarrayToQStringList(void *nsarray)

{

    QStringList result;

    NSArray *array = static_cast<NSArray *>(nsarray);

    for (NSUInteger i=0; i<[array count]; ++i)

        result << nsstringToQString([array objectAtIndex:i]);

    return result;

}

static QString qGetInterfaceType(const QString &interfaceString)

{

    return networkInterfaces.value(interfaceString, QLatin1String("Unknown"));

}

void networkChangeCallback(SCDynamicStoreRef/* store*/, CFArrayRef changedKeys, void *info)

{

    for ( long i = 0; i < CFArrayGetCount(changedKeys); i++) {

        CFStringRef changed = (CFStringRef)CFArrayGetValueAtIndex(changedKeys, i);

        if( cfstringRefToQstring(changed).contains("/Network/Global/IPv4")) {

            QCoreWlanEngine* wlanEngine = static_cast<QCoreWlanEngine*>(info);

            wlanEngine->requestUpdate();

        }

    }

    return;

}

QCoreWlanEngine::QCoreWlanEngine(QObject *parent)

:   QNetworkSessionEngine(parent)

{

    NSAutoreleasePool *pool = [[NSAutoreleasePool alloc] init];

    getAllScInterfaces();

    startNetworkChangeLoop();

#ifdef MAC_SDK_10_6

#endif

    requestUpdate();

}

QCoreWlanEngine::~QCoreWlanEngine()

{

    QNetworkConfigurationPrivate* cpPriv = 0;

    foundConfigurations.clear();

    while(!foundConfigurations.isEmpty()) {

        cpPriv = foundConfigurations.takeFirst();

        delete cpPriv;

    }

}

QList<QNetworkConfigurationPrivate *> QCoreWlanEngine::getConfigurations(bool *ok)

{

    if (ok)

        *ok = true;

    foundConfigurations.clear();

    uint identifier;

    QMapIterator<QString, QString> i(networkInterfaces);

    QNetworkConfigurationPrivate* cpPriv = 0;

    while (i.hasNext()) {

        i.next();

        if (i.value() == "WLAN") {

            QList<QNetworkConfigurationPrivate *> fetchedConfigurations = scanForSsids(i.key());

            for (int i = 0; i < fetchedConfigurations.count(); ++i) {

                QNetworkConfigurationPrivate *config = new QNetworkConfigurationPrivate();

                cpPriv = fetchedConfigurations.at(i);

                config->name = cpPriv->name;

                config->isValid = cpPriv->isValid;

                config->id = cpPriv->id;

                config->state = cpPriv->state;

                config->type = cpPriv->type;

                config->roamingSupported = cpPriv->roamingSupported;

                config->purpose = cpPriv->purpose;

                config->internet = cpPriv->internet;

                config->serviceInterface = cpPriv->serviceInterface;

                config->bearer = cpPriv->bearer;

                identifier = config->name.toUInt();

                configurationInterface[identifier] =  config->serviceInterface.name();

                foundConfigurations.append(config);

                delete cpPriv;

            }

        }

        QNetworkInterface interface = QNetworkInterface::interfaceFromName(i.key());

        QNetworkConfigurationPrivate *cpPriv = new QNetworkConfigurationPrivate();

        const QString humanReadableName = interface.humanReadableName();

        cpPriv->name = humanReadableName.isEmpty() ? interface.name() : humanReadableName;

        cpPriv->isValid = true;

        if (interface.index())

            identifier = interface.index();

        else

            identifier = qHash(interface.hardwareAddress());

        cpPriv->id = QString::number(identifier);

        cpPriv->type = QNetworkConfiguration::InternetAccessPoint;

        cpPriv->state = QNetworkConfiguration::Undefined;

        if (interface.flags() & QNetworkInterface::IsRunning) {

            cpPriv->state = QNetworkConfiguration::Defined;

            cpPriv->internet = true;

        }

        if ( !interface.addressEntries().isEmpty())  {

            cpPriv->state |= QNetworkConfiguration::Active;

            cpPriv->internet = true;

        }

        configurationInterface[identifier] = interface.name();

        cpPriv->bearer = interface.name().isEmpty()? QLatin1String("Unknown") : qGetInterfaceType(interface.name());

        foundConfigurations.append(cpPriv);

    }

    pollTimer.start();

    return foundConfigurations;

}

QString QCoreWlanEngine::getInterfaceFromId(const QString &id)

{

    return configurationInterface.value(id.toUInt());

}

bool QCoreWlanEngine::hasIdentifier(const QString &id)

{

    return configurationInterface.contains(id.toUInt());

}

void QCoreWlanEngine::connectToId(const QString &id)

{

    QString interfaceString = getInterfaceFromId(id);

    if(networkInterfaces.value(interfaceString) == "WLAN") {

#if defined(MAC_SDK_10_6)

        CWInterface *wifiInterface = [CWInterface interfaceWithName: qstringToNSString(interfaceString)];

                        }

                    }

                }

            }

#endif

    }

    emit connectionError(id, OperationNotSupported);

}

void QCoreWlanEngine::disconnectFromId(const QString &id)

{

    QString interfaceString = getInterfaceFromId(id);

    if(networkInterfaces.value(getInterfaceFromId(id)) == "WLAN") { //wifi only for now

#if defined(MAC_SDK_10_6)

        NSAutoreleasePool *autoreleasepool = [[NSAutoreleasePool alloc] init];

        CWInterface *wifiInterface = [CWInterface interfaceWithName:  qstringToNSString(interfaceString)];

        [wifiInterface disassociate];

        if([[wifiInterface interfaceState]intValue] != kCWInterfaceStateInactive) {

            emit connectionError(id, DisconnectionError);

        }

       [autoreleasepool release];

       return;

#endif

    } else {

    }

    emit connectionError(id, OperationNotSupported);

}

void QCoreWlanEngine::requestUpdate()

{

    getAllScInterfaces();

    emit configurationsChanged();

}

QCoreWlanEngine *QCoreWlanEngine::instance()

{

    return coreWlanEngine();

}

QList<QNetworkConfigurationPrivate *> QCoreWlanEngine::scanForSsids(const QString &interfaceName)

{

    QList<QNetworkConfigurationPrivate *> foundConfigs;

#if defined(MAC_SDK_10_6)

    NSAutoreleasePool *autoreleasepool = [[NSAutoreleasePool alloc] init];

    if([currentInterface power]) {

        NSError *err = nil;

        NSDictionary *parametersDict = nil;

        NSArray* apArray = [currentInterface scanForNetworksWithParameters:parametersDict error:&err];

        CWNetwork *apNetwork;

        if(!err) {

            for(uint row=0; row < [apArray count]; row++ ) {

                QNetworkConfigurationPrivate* cpPriv = new QNetworkConfigurationPrivate();

                cpPriv->name = networkSsid;

                cpPriv->isValid = true;

                cpPriv->id = networkSsid;

                cpPriv->internet = true;

                cpPriv->bearer = QLatin1String("WLAN");

                cpPriv->type = QNetworkConfiguration::InternetAccessPoint;

                cpPriv->serviceInterface = QNetworkInterface::interfaceFromName(interfaceName);

                if( [currentInterface.interfaceState intValue] == kCWInterfaceStateRunning) {

                        cpPriv->state |=  QNetworkConfiguration::Active;

                    }

                }

                if(!cpPriv->state) {

                        cpPriv->state =  QNetworkConfiguration::Discovered;

                    } else {

                    }

                }

                if([[apNetwork securityMode ] intValue]== kCWSecurityModeOpen)

                    cpPriv->purpose = QNetworkConfiguration::PublicPurpose;

                else

                    cpPriv->purpose = QNetworkConfiguration::PrivatePurpose;

                foundConfigs.append(cpPriv);

            }