Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit 1441e769 authored by San Mehat's avatar San Mehat
Browse files

nexus: Implement wifi scanner and fix a lot of bugs 



Signed-off-by: default avatarSan Mehat <san@google.com>
parent b3779558

nexus/Android.mk

+1 −0
Original line number Diff line number Diff line
@@ -19,6 +19,7 @@ LOCAL_SRC_FILES:= \ 
                  SupplicantListener.cpp   \

                  VpnController.cpp        \

                  ScanResult.cpp           \

                  WifiScanner.cpp          \



LOCAL_MODULE:= nexus

nexus/CommandListener.cpp

+64 −33
Original line number Diff line number Diff line
@@ -19,60 +19,64 @@ 
#define LOG_TAG "CommandListener"

#include <cutils/log.h>



#include <sysutils/SocketClient.h>



#include "CommandListener.h"

#include "Controller.h"

#include "NetworkManager.h"

#include "WifiController.h"



CommandListener::CommandListener(NetworkManager *netman) :

CommandListener::CommandListener() :

                 FrameworkListener("nexus") {

    mNetman = netman;



    registerCmd(new WifiEnableCmd(netman));

    registerCmd(new WifiDisableCmd(netman));

    registerCmd(new WifiScanCmd(netman));

    registerCmd(new WifiEnableCmd());

    registerCmd(new WifiDisableCmd());

    registerCmd(new WifiScanCmd());

    registerCmd(new WifiScanResultsCmd());



    registerCmd(new VpnEnableCmd(netman));

    registerCmd(new VpnDisableCmd(netman));

    registerCmd(new VpnEnableCmd());

    registerCmd(new VpnDisableCmd());

}

 

/* -------------

 * Wifi Commands

 * ------------ */



CommandListener::WifiEnableCmd::WifiEnableCmd(NetworkManager *netman) :

                 NexusCommand("wifi_enable", netman) {

CommandListener::WifiEnableCmd::WifiEnableCmd() :

                 NexusCommand("wifi_enable") {

} 

               

int CommandListener::WifiEnableCmd::runCommand(char *data) {

    Controller *c = mNetman->findController("WIFI");

int CommandListener::WifiEnableCmd::runCommand(SocketClient *cli, char *data) {

    Controller *c = NetworkManager::Instance()->findController("WIFI");

    char buffer[32];



    sprintf(buffer, "WIFI_ENABLE:%d", (c->enable() ? errno : 0));

    mNetman->getFrameworkManager()->sendMsg(buffer);



    cli->sendMsg(buffer);

    return 0;

}



CommandListener::WifiDisableCmd::WifiDisableCmd(NetworkManager *netman) :

                 NexusCommand("wifi_disable", netman) {

CommandListener::WifiDisableCmd::WifiDisableCmd() :

                 NexusCommand("wifi_disable") {

} 

               

int CommandListener::WifiDisableCmd::runCommand(char *data) {

    Controller *c = mNetman->findController("WIFI");

int CommandListener::WifiDisableCmd::runCommand(SocketClient *cli, char *data) {

    Controller *c = NetworkManager::Instance()->findController("WIFI");

    char buffer[32];



    sprintf(buffer, "WIFI_DISABLE:%d", (c->disable() ? errno : 0));

    mNetman->getFrameworkManager()->sendMsg(buffer);

    cli->sendMsg(buffer);

    return 0;

}



CommandListener::WifiScanCmd::WifiScanCmd(NetworkManager *netman) :

                 NexusCommand("wifi_scan", netman) {

CommandListener::WifiScanCmd::WifiScanCmd() :

                 NexusCommand("wifi_scan") {

} 



int CommandListener::WifiScanCmd::runCommand(char *data) {

int CommandListener::WifiScanCmd::runCommand(SocketClient *cli, char *data) {

    LOGD("WifiScanCmd(%s)", data);

    WifiController *wc = (WifiController *) mNetman->findController("WIFI");



    WifiController *wc = (WifiController *) NetworkManager::Instance()->findController("WIFI");



    char buffer[32];

    int mode = 0;

    char *bword, *last;
@@ -90,35 +94,62 @@ int CommandListener::WifiScanCmd::runCommand(char *data) { 
    mode = atoi(bword);



    sprintf(buffer, "WIFI_SCAN:%d", (wc->setScanMode(mode) ? errno : 0));

    mNetman->getFrameworkManager()->sendMsg(buffer);

    cli->sendMsg(buffer);

    return 0;

}



CommandListener::WifiScanResultsCmd::WifiScanResultsCmd() :

                 NexusCommand("wifi_scan_results") {

} 



int CommandListener::WifiScanResultsCmd::runCommand(SocketClient *cli, char *data) {

    NetworkManager *nm = NetworkManager::Instance();



    WifiController *wc = (WifiController *) nm->findController("WIFI");



    ScanResultCollection *src = wc->createScanResults();

    ScanResultCollection::iterator it;

    char buffer[256];

    

    for(it = src->begin(); it != src->end(); ++it) {

        sprintf(buffer, "WIFI_SCAN_RESULT:%s:%u:%d:%s:%s",

                (*it)->getBssid(), (*it)->getFreq(), (*it)->getLevel(),

                (*it)->getFlags(), (*it)->getSsid());

        cli->sendMsg(buffer);

        delete (*it);

        it = src->erase(it);

    }



    delete src;

    cli->sendMsg("WIFI_SCAN_RESULT:0");

    return 0;

}



/* ------------

 * Vpn Commands

 * ------------ */

CommandListener::VpnEnableCmd::VpnEnableCmd(NetworkManager *netman) :

                 NexusCommand("vpn_enable", netman) {

CommandListener::VpnEnableCmd::VpnEnableCmd() :

                 NexusCommand("vpn_enable") {

} 

               

int CommandListener::VpnEnableCmd::runCommand(char *data) {

    Controller *c = mNetman->findController("VPN");

int CommandListener::VpnEnableCmd::runCommand(SocketClient *cli, char *data) {

    Controller *c = NetworkManager::Instance()->findController("VPN");

    char buffer[32];



    sprintf(buffer, "VPN_ENABLE:%d", (c->enable() ? errno : 0));

    mNetman->getFrameworkManager()->sendMsg(buffer);

    cli->sendMsg(buffer);

    return 0;

}



CommandListener::VpnDisableCmd::VpnDisableCmd(NetworkManager *netman) :

                 NexusCommand("vpn_disable", netman) {

CommandListener::VpnDisableCmd::VpnDisableCmd() :

                 NexusCommand("vpn_disable") {

} 

               

int CommandListener::VpnDisableCmd::runCommand(char *data) {

    Controller *c = mNetman->findController("VPN");

int CommandListener::VpnDisableCmd::runCommand(SocketClient *cli, char *data) {

    Controller *c = NetworkManager::Instance()->findController("VPN");

    char buffer[32];



    sprintf(buffer, "VPN_DISABLE:%d", (c->disable() ? errno : 0));

    mNetman->getFrameworkManager()->sendMsg(buffer);

    cli->sendMsg(buffer);

    return 0;

}

nexus/CommandListener.h

+18 −16
Original line number Diff line number Diff line
@@ -19,50 +19,52 @@ 
#include <sysutils/FrameworkListener.h>

#include "NexusCommand.h"



class NetworkManager;



class CommandListener : public FrameworkListener {

protected:

    NetworkManager *mNetman;



public:

    CommandListener(NetworkManager *netman);

    CommandListener();

    virtual ~CommandListener() {}



private:

    class WifiEnableCmd : public NexusCommand {

    public:

        WifiEnableCmd(NetworkManager *);

        WifiEnableCmd();

        virtual ~WifiEnableCmd() {}

        int runCommand(char *data);

        int runCommand(SocketClient *c, char *data);

    };



    class WifiDisableCmd : public NexusCommand {

    public:

        WifiDisableCmd(NetworkManager *);

        WifiDisableCmd();

        virtual ~WifiDisableCmd() {}

        int runCommand(char *data);

        int runCommand(SocketClient *c, char *data);

    };



    class WifiScanCmd : public NexusCommand {

    public:

        WifiScanCmd(NetworkManager *);

        WifiScanCmd();

        virtual ~WifiScanCmd() {}

        int runCommand(char *data);

        int runCommand(SocketClient *c, char *data);

    };



    class WifiScanResultsCmd : public NexusCommand {

    public:

        WifiScanResultsCmd();

        virtual ~WifiScanResultsCmd() {}

        int runCommand(SocketClient *c, char *data);

    };



    class VpnEnableCmd : public NexusCommand {

    public:

        VpnEnableCmd(NetworkManager *);

        VpnEnableCmd();

        virtual ~VpnEnableCmd() {}

        int runCommand(char *data);

        int runCommand(SocketClient *c, char *data);

    };



    class VpnDisableCmd : public NexusCommand {

    public:

        VpnDisableCmd(NetworkManager *);

        VpnDisableCmd();

        virtual ~VpnDisableCmd() {}

        int runCommand(char *data);

        int runCommand(SocketClient *c, char *data);

    };



};

nexus/NetworkManager.cpp

+10 −16
Original line number Diff line number Diff line
@@ -21,36 +21,30 @@ 
#include <cutils/log.h>



#include "NetworkManager.h"

#include "CommandListener.h"

#include "LoopController.h"

#include "VpnController.h"



#include "TiwlanWifiController.h"

NetworkManager *NetworkManager::sInstance = NULL;



NetworkManager *NetworkManager::Instance() {

    if (!sInstance)

        sInstance = new NetworkManager();

    return sInstance;

}



NetworkManager::NetworkManager() {

    mListener = new CommandListener(this);

    mFm = new FrameworkManager(mListener);

    mBroadcaster = NULL;

    mControllers = new ControllerCollection();

}



int NetworkManager::run() {

    LOGD("NetworkManager::start()");



    // XXX: Factory needed

    addController(new LoopController());

    addController(new TiwlanWifiController("/system/lib/modules/wlan.ko", "wlan", ""));

    addController(new VpnController());

    //addController(new GenericController("rmnet0"));



    if (startControllers()) {

        LOGW("Unable to start all controllers (%s)", strerror(errno));

    }

    mFm->run();

    return 0;

}



void NetworkManager::addController(Controller *c) {

int NetworkManager::attachController(Controller *c) {

    mControllers->push_back(c);

    return 0;

}



int NetworkManager::startControllers() {

nexus/NetworkManager.h

+16 −11
Original line number Diff line number Diff line
@@ -16,31 +16,36 @@ 
#ifndef _NETWORKMANAGER_H

#define _NETWORKMANAGER_H



#include "Controller.h"

#include <sysutils/SocketListener.h>



#include <sysutils/FrameworkManager.h>

#include "Controller.h"



class NetworkManager {

private:

    FrameworkListener    *mListener;

    FrameworkManager     *mFm;

    static NetworkManager *sInstance;



private:

    ControllerCollection *mControllers;

    SocketListener       *mBroadcaster;



public:

    NetworkManager();

    virtual ~NetworkManager() {}



    int run();



    int attachController(Controller *controller);



    Controller *findController(const char *name);



    void setBroadcaster(SocketListener *sl) { mBroadcaster = sl; }

    SocketListener *getBroadcaster() { return mBroadcaster; }



    static NetworkManager *Instance();



private:

    void addController(Controller *c);

    int startControllers();

    int stopControllers();



public:

    Controller *findController(const char *name);

    ControllerCollection *getControllers() { return mControllers; }

    FrameworkManager *getFrameworkManager() { return mFm; }

    NetworkManager();



public:

// XXX: Extract these into an interface