| -rw-r--r-- | noncore/net/opietooth/lib/manager.cc | 65 | ||||
| -rw-r--r-- | noncore/net/opietooth/lib/manager.h | 18 |
2 files changed, 83 insertions, 0 deletions
diff --git a/noncore/net/opietooth/lib/manager.cc b/noncore/net/opietooth/lib/manager.cc index 23506b3..2234333 100644 --- a/noncore/net/opietooth/lib/manager.cc +++ b/noncore/net/opietooth/lib/manager.cc @@ -1,226 +1,291 @@ #include <opie/oprocess.h> #include "parser.h" #include "manager.h" using namespace OpieTooth; Manager::Manager( const QString& dev ) : QObject() { qWarning("created"); m_device = dev; m_hcitool = 0; m_sdp = 0; } Manager::Manager( Device* /*dev*/ ) : QObject() { m_hcitool = 0; m_sdp = 0; } Manager::Manager() : QObject() { m_hcitool = 0; m_sdp = 0; } Manager::~Manager(){ delete m_hcitool; delete m_sdp; } void Manager::setDevice( const QString& dev ){ m_device = dev; } void Manager::setDevice( Device* /*dev*/ ){ } void Manager::isAvailable( const QString& device ){ OProcess* l2ping = new OProcess(); l2ping->setName( device.latin1() ); *l2ping << "l2ping" << "-c1" << device; connect(l2ping, SIGNAL(processExited(OProcess* ) ), this, SLOT(slotProcessExited(OProcess*) ) ); if (!l2ping->start() ) { emit available( device, false ); delete l2ping; } } void Manager::isAvailable( Device* /*dev*/ ){ } void Manager::searchDevices( const QString& device ){ qWarning("search devices"); OProcess* hcitool = new OProcess(); hcitool->setName( device.isEmpty() ? "hci0" : device.latin1() ); *hcitool << "hcitool" << "scan"; connect( hcitool, SIGNAL(processExited(OProcess*) ) , this, SLOT(slotHCIExited(OProcess* ) ) ); connect( hcitool, SIGNAL(receivedStdout(OProcess*, char*, int ) ), this, SLOT(slotHCIOut(OProcess*, char*, int ) ) ); if (!hcitool->start(OProcess::NotifyOnExit, OProcess::AllOutput) ) { qWarning("could not start"); RemoteDevice::ValueList list; emit foundDevices( device, list ); delete hcitool; } } void Manager::searchDevices(Device* /*d*/ ){ } void Manager::addService(const QString& name ){ OProcess proc; proc << "sdptool" << "add" << name; bool bo = true; if (!proc.start(OProcess::DontCare ) ) bo = false; emit addedService( name, bo ); } void Manager::addServices(const QStringList& list){ QStringList::ConstIterator it; for (it = list.begin(); it != list.end(); ++it ) addService( (*it) ); } void Manager::removeService( const QString& name ){ OProcess prc; prc << "sdptool" << "del" << name; bool bo = true; if (!prc.start(OProcess::DontCare ) ) bo = false; emit removedService( name, bo ); } void Manager::removeServices( const QStringList& list){ QStringList::ConstIterator it; for (it = list.begin(); it != list.end(); ++it ) removeService( (*it) ); } void Manager::searchServices( const QString& remDevice ){ OProcess *m_sdp =new OProcess(); *m_sdp << "sdptool" << "browse" << remDevice; m_sdp->setName( remDevice.latin1() ); qWarning("search Services for %s", remDevice.latin1() ); connect(m_sdp, SIGNAL(processExited(OProcess*) ), this, SLOT(slotSDPExited(OProcess* ) ) ); connect(m_sdp, SIGNAL(receivedStdout(OProcess*, char*, int ) ), this, SLOT(slotSDPOut(OProcess*, char*, int) ) ); if (!m_sdp->start(OProcess::NotifyOnExit, OProcess::AllOutput) ) { qWarning("could not start sdptool" ); delete m_sdp; Services::ValueList list; emit foundServices( remDevice, list ); } } void Manager::searchServices( const RemoteDevice& dev){ searchServices( dev.mac() ); } QString Manager::toDevice( const QString& /*mac*/ ){ return QString::null; } QString Manager::toMac( const QString &/*device*/ ){ return QString::null; } void Manager::slotProcessExited(OProcess* proc ) { bool conn= false; if (proc->normalExit() && proc->exitStatus() == 0 ) conn = true; QString name = QString::fromLatin1(proc->name() ); emit available( name, conn ); delete proc; } void Manager::slotSDPOut(OProcess* proc, char* ch, int len) { QCString str(ch, len+1 ); qWarning("SDP:%s", str.data() ); QMap<QString, QString>::Iterator it; it = m_out.find(proc->name() ); QString string; if ( it != m_out.end() ) { string = it.data(); } string.append( str ); m_out.replace( proc->name(), string ); } void Manager::slotSDPExited( OProcess* proc) { qWarning("proc name %s", proc->name() ); Services::ValueList list; if (proc->normalExit() ) { QMap<QString, QString>::Iterator it = m_out.find( proc->name() ); if ( it != m_out.end() ) { qWarning("found process" ); list = parseSDPOutput( it.data() ); m_out.remove( it ); } } emit foundServices( proc->name(), list ); delete proc; } Services::ValueList Manager::parseSDPOutput( const QString& out ) { Services::ValueList list; qWarning("parsing output" ); Parser parser( out ); list = parser.services(); return list; } void Manager::slotHCIExited(OProcess* proc ) { qWarning("process exited"); RemoteDevice::ValueList list; if (proc->normalExit() ) { qWarning("normalExit %s", proc->name() ); QMap<QString, QString>::Iterator it = m_devices.find(proc->name() ); if (it != m_devices.end() ) { qWarning("!= end ;)"); list = parseHCIOutput( it.data() ); m_devices.remove( it ); } } emit foundDevices( proc->name(), list ); delete proc; } void Manager::slotHCIOut(OProcess* proc, char* ch, int len) { QCString str( ch, len+1 ); qWarning("hci: %s", str.data() ); QMap<QString, QString>::Iterator it; it = m_devices.find( proc->name() ); qWarning("proc->name %s", proc->name() ); QString string; if (it != m_devices.end() ) { qWarning("slotHCIOut "); string = it.data(); } string.append( str ); m_devices.replace( proc->name(), string ); } RemoteDevice::ValueList Manager::parseHCIOutput(const QString& output ) { qWarning("parseHCI %s", output.latin1() ); RemoteDevice::ValueList list; QStringList strList = QStringList::split('\n', output ); QStringList::Iterator it; QString str; for ( it = strList.begin(); it != strList.end(); ++it ) { str = (*it).stripWhiteSpace(); qWarning("OpieTooth %s", str.latin1() ); int pos = str.findRev(':' ); if ( pos > 0 ) { QString mac = str.left(17 ); str.remove( 0, 17 ); qWarning("mac %s", mac.latin1() ); qWarning("rest:%s", str.latin1() ); RemoteDevice rem( mac , str.stripWhiteSpace() ); list.append( rem ); } } return list; } + +////// hcitool cc and hcitool con + +/** + * Create it on the stack as don't care + * so we don't need to care for it + * cause hcitool gets reparented + */ +void Manager::connectTo( const QString& mac) { + OProcess proc; + proc << "hcitool"; + proc << "cc"; + proc << "mac"; + proc.start(OProcess::DontCare); // the lib does not care at this point +} + + +void Manager::searchConnections() { + qWarning("searching connections?"); + OProcess* proc = new OProcess(); + m_hcitoolCon = QString::null; + + connect(proc, SIGNAL(processExited(OProcess*) ), + this, SLOT(slotConnectionExited( OProcess*) ) ); + connect(proc, SIGNAL(receivedStdout(OProcess*, char*, int) ), + this, SLOT(slotConnectionOutput(OProcess*, char*, int) ) ); + *proc << "hcitool"; + *proc << "con"; + + if (!proc->start(OProcess::NotifyOnExit, OProcess::AllOutput) ) { + Connection::ValueList list; + emit connections( list ); + delete proc; + } +} +void Manager::slotConnectionExited( OProcess* proc ) { + qWarning("exited"); + Connection::ValueList list; + list = parseConnections( m_hcitoolCon ); + emit connections(list ); +} +void Manager::slotConnectionOutput(OProcess* proc, char* cha, int len) { + QCString str(cha, len ); + m_hcitoolCon.append( str ); + delete proc; +} +Connection::ValueList Manager::parseConnections( const QString& out ) { + Connection::ValueList list2; + QStringList list = QStringList::split('\n', out ); + QStringList::Iterator it; + for (it = list.begin(); it != list.end(); ++it ) { + QString row = (*it).stripWhiteSpace(); + QStringList value = QStringList::split(' ', row ); + qWarning("0: %s", value[0].latin1() ); + qWarning("1: %s", value[1].latin1() ); + qWarning("2: %s", value[2].latin1() ); + qWarning("3: %s", value[3].latin1() ); + qWarning("4: %s", value[4].latin1() ); + qWarning("5: %s", value[5].latin1() ); + qWarning("6: %s", value[6].latin1() ); + qWarning("7: %s", value[7].latin1() ); + qWarning("8: %s", value[8].latin1() ); + } + return list2; +} diff --git a/noncore/net/opietooth/lib/manager.h b/noncore/net/opietooth/lib/manager.h index 2589e9b..b32327c 100644 --- a/noncore/net/opietooth/lib/manager.h +++ b/noncore/net/opietooth/lib/manager.h @@ -1,148 +1,166 @@ #ifndef OpieToothManager_H #define OpieToothManager_H #include <qobject.h> #include <qstring.h> #include <qmap.h> #include <qvaluelist.h> +#include "connection.h" #include "remotedevice.h" #include "services.h" class OProcess; namespace OpieTooth { class Device; /** Manager manages a blueZ device (hci0 for example) * without Manager you can control the things you * could do from command line in a OO and asynchronus * way. */ class Manager : public QObject { Q_OBJECT public: /** c'tor whichs create a new Manager * @param device is the device to use. Either a mac or blueZ device name * */ Manager( const QString &device ); /** c'tor * @param dev The Device to be managed * We don't care of Device so you need to delete it */ Manager( Device* dev ); /** * c'tor */ Manager(); ~Manager(); /** Set the manager to control a new device * @param device the new device to control (hci0 ) */ void setDevice( const QString& device ); /** * Convience functions for setting a new device */ void setDevice( Device *dev ); /** * Wether or not a device is connected. The function * is asynchron * If device is empty it will take the currently managed * device and see if it's up * for Remote devices it will ping and see. * @param either mac or hciX */ void isAvailable(const QString& device= QString::null ); /** * same as above */ void isAvailable(Device *dev ); /** this searchs for devices reachable from the * currently managed device * or from device if @param device is not empty */ void searchDevices(const QString& device= QString::null ); /** same as above * */ void searchDevices(Device *d ); /** * This will add the service @param name * to the sdpd daemon * It will start the daemon if necessary */ void addService(const QString &name ); /** * This will add the services @param names * to the sdpd daemon * It will start the daemon if necessary */ void addServices( const QStringList& names ); /** * This removes a service from the sdps */ void removeService(const QString &name ); /** * Removes a list from the sdpd */ void removeServices(const QStringList& ); /** * search for services on a remote device * */ void searchServices( const QString& remDevice ); /** * search for services on a remote device */ void searchServices( const RemoteDevice& ); + + /** + * Starts to connect to the device + * in @param + */ + void connectTo(const QString& ); + + /** + * Searches for active connections + * the result is emitted with the + * connections signal + */ + void searchConnections(); + +//// not implemented yet /*static*/ QString toDevice( const QString& mac ); /*static*/ QString toMac( const QString &device ); +//// not implemented yet over signals: // device either mac or dev name // the first device is the device which you access void available( const QString& device, bool connected ); void addedService( const QString& service, bool added ); void removedService( const QString& service, bool removed ); void foundServices( const QString& device, Services::ValueList ); void foundDevices( const QString& device, RemoteDevice::ValueList ); void connections( Connection::ValueList ); private slots: void slotProcessExited(OProcess* ); void slotSDPExited(OProcess*); void slotSDPOut(OProcess*, char*, int); void slotHCIExited(OProcess* ); void slotHCIOut(OProcess*, char*, int ); void slotConnectionExited(OProcess* ); void slotConnectionOutput(OProcess*, char*, int ); private: Services::ValueList parseSDPOutput( const QString& ); RemoteDevice::ValueList parseHCIOutput( const QString& ); + Connection::ValueList parseConnections( const QString& ); OProcess *m_hcitool; OProcess *m_sdp; // not only one QString m_device; QMap<QString, QString> m_out; QMap<QString, QString> m_devices; QString m_hcitoolCon; }; }; #endif |