isCOnnected, add and remove Service + first bits of service browsing done

5 files changed, 127 insertions, 48 deletions

diff --git a/noncore/net/opietooth/lib/device.cc b/noncore/net/opietooth/lib/device.cc
index e3d7f3b..5234996 100644
--- a/noncore/net/opietooth/lib/device.cc
+++ b/noncore/net/opietooth/lib/device.cc
@@ -1,16 +1,16 @@
 
 #include <signal.h>
 
-#include "kprocess.h"
+#include <opie/oprocess.h>
 
 #include "device.h"
 
 using namespace OpieTooth;
 
 namespace {
   int parsePid( const QCString& par ){
     int id=0;
     QString string( par );
     QStringList list =  QStringList::split( '\n', string );
     for( QStringList::Iterator it = list.begin(); it != list.end(); ++it ){
       if( !(*it).startsWith("CSR") ){
@@ -31,77 +31,77 @@ Device::Device(const QString &device, const QString &mode )
   m_device = device;
   m_mode = mode;
   attach();
 }
 Device::~Device(){
   detach();
 }
 void Device::attach(){
   qWarning("attaching %s %s", m_device.latin1(), m_mode.latin1() );
   if(m_process == 0 ){
     m_output.resize(0);
     qWarning("new process to create" );
-    m_process = new KProcess();
+    m_process = new OProcess();
     *m_process << "hciattach";
     *m_process << "-p";
     *m_process << m_device << m_mode;
-    connect(m_process, SIGNAL( processExited(KProcess*) ),
-	    this, SLOT( slotExited(KProcess* ) ) );
-    connect(m_process, SIGNAL( receivedStdout(KProcess*, char*, int) ),
-	    this, SLOT(slotStdOut(KProcess*,char*,int ) ) );
-    connect(m_process, SIGNAL(receivedStderr(KProcess*, char*, int ) ),
-	    this, SLOT(slotStdErr(KProcess*,char*,int) ) );
-    if(!m_process->start(KProcess::NotifyOnExit, KProcess::AllOutput ) ){
+    connect(m_process, SIGNAL( processExited(OProcess*) ),
+	    this, SLOT( slotExited(OProcess* ) ) );
+    connect(m_process, SIGNAL( receivedStdout(OProcess*, char*, int) ),
+	    this, SLOT(slotStdOut(OProcess*,char*,int ) ) );
+    connect(m_process, SIGNAL(receivedStderr(OProcess*, char*, int ) ),
+	    this, SLOT(slotStdErr(OProcess*,char*,int) ) );
+    if(!m_process->start(OProcess::NotifyOnExit, OProcess::AllOutput ) ){
       qWarning("Could not start" );
       delete m_process;
       m_process = 0;
     }
   };
 }
 void Device::detach(){
   delete m_hci;
   delete m_process;
   // kill the pid we got
   if(m_attached ){
     //kill the pid
     qWarning( "killing" );
     kill(pid, 9);
   }
   qWarning("detached" );
 }
 bool Device::isLoaded()const{
   return m_attached;
 }
 QString Device::devName()const {
   return QString::fromLatin1("hci0");
 };
-void Device::slotExited( KProcess* proc)
+void Device::slotExited( OProcess* proc)
 {
   qWarning("prcess exited" );
   if(proc== m_process ){
     if( m_process->normalExit() ){ // normal exit
       int ret = m_process->exitStatus();
       if( ret == 0 ){ // attached
 	qWarning("attached" );
 	qWarning("Output: %s", m_output.data() );
 	pid = parsePid( m_output );
 	qWarning("Pid = %d", pid );
 	// now hciconfig hci0 up ( determine hciX FIXME)
 	// and call hciconfig hci0 up
 	// FIXME hardcoded to hci0 now :(
-	m_hci = new KProcess( );
+	m_hci = new OProcess( );
 	*m_hci << "hciconfig";
 	*m_hci << "hci0 up";
-	connect(m_hci, SIGNAL( processExited(KProcess*) ),
-		this, SLOT( slotExited(KProcess* ) ) );
+	connect(m_hci, SIGNAL( processExited(OProcess*) ),
+		this, SLOT( slotExited(OProcess* ) ) );
 	if(!m_hci->start() ){
 	  qWarning("could not start" );
 	  m_attached = false;
 	  emit device("hci0", false );
 	}
       }else{
 	m_attached = false;
 	emit device("hci0", false );
 
       }
     }
     delete m_process;
@@ -116,27 +116,27 @@ void Device::slotExited( KProcess* proc)
 	m_attached = true;
 	emit device("hci0", true );
       }else{
 	qWarning( "failed" );
 	emit device("hci0", false );
 	m_attached = false;
       }
     }// normal exit
     delete m_hci;
     m_hci = 0;
   }
 }
-void Device::slotStdOut(KProcess* proc, char* chars, int len)
+void Device::slotStdOut(OProcess* proc, char* chars, int len)
 {
   qWarning("std out" );
   if( len <1 )
     return; 
   if(proc == m_process ){
     QCString string( chars, len+1 ); // \0 == +1
     qWarning("output: %s", string.data() );
     m_output.append( string.data() );
   }
 }
-void Device::slotStdErr(KProcess*, char*, int )
+void Device::slotStdErr(OProcess*, char*, int )
 {
   qWarning("std err" );
 }
diff --git a/noncore/net/opietooth/lib/device.h b/noncore/net/opietooth/lib/device.h
index 8498b14..c0e2658 100644
--- a/noncore/net/opietooth/lib/device.h
+++ b/noncore/net/opietooth/lib/device.h
@@ -1,23 +1,23 @@
 
 #ifndef OpieToothDevice_H
 #define OpieToothDevice_H
 
 #include <qobject.h>
 #include <qstring.h>
 #include <qvaluelist.h>
 
 #include <sys/types.h>
 
-class KProcess;
+class OProcess;
 namespace OpieTooth {
     /**
      *  Device takes care of attaching serial 
      *  devices to the blueZ stack.
      *  After attaching it hciconfig ups it
      */
     class Device : public QObject {
     Q_OBJECT
 
     public:
 
     /**
@@ -56,30 +56,30 @@ namespace OpieTooth {
          */
         QString devName()const ; // hci0
 
     signals:
 
         /**
          * Signals devicename and up status
          * @return &device QString, Devicename
          * @return up bool, if the device is up or not.
          */
         void device(const QString& device, bool up );
     private slots:
-        virtual void slotExited( KProcess* );
-        virtual void slotStdOut(KProcess*, char*, int );
-	virtual void slotStdErr(KProcess*, char*, int );
+        virtual void slotExited( OProcess* );
+        virtual void slotStdOut(OProcess*, char*, int );
+	virtual void slotStdErr(OProcess*, char*, int );
     private:
 	class Private;
 	Private *d;
 	QString m_device;
 	bool m_attached:1;
-	KProcess* m_hci;
-	KProcess* m_process;
+	OProcess* m_hci;
+	OProcess* m_process;
 	QString m_devId;
 	QString m_mode;
 	pid_t pid;
 	QCString m_output;
     };
 };
 
 #endif
diff --git a/noncore/net/opietooth/lib/lib.pro b/noncore/net/opietooth/lib/lib.pro
index a70c7ab..f2cde06 100644
--- a/noncore/net/opietooth/lib/lib.pro
+++ b/noncore/net/opietooth/lib/lib.pro
@@ -1,8 +1,9 @@
 TEMPLATE        = lib
 CONFIG          += qte warn_on release
-HEADERS 	= kprocctrl.h kprocess.h device.h manager.h remotedevice.h services.h
-SOURCES		= kprocctrl.cpp kprocess.cpp device.cc manager.cc remotedevice.cc services.cc
+HEADERS 	= device.h manager.h remotedevice.h services.h
+SOURCES		= device.cc manager.cc remotedevice.cc services.cc
 TARGET		= opietooth
 INCLUDEPATH += $(OPIEDIR)/include
 DESTDIR         = $(QTDIR)/lib$(PROJMAK)
+LIBS = -lopie
 #VERSION = 0.0.0
diff --git a/noncore/net/opietooth/lib/manager.cc b/noncore/net/opietooth/lib/manager.cc
index 882af81..eeeab19 100644
--- a/noncore/net/opietooth/lib/manager.cc
+++ b/noncore/net/opietooth/lib/manager.cc
@@ -1,69 +1,134 @@
+#include <opie/oprocess.h>
 
 #include "manager.h"
 
 
 using namespace OpieTooth;
 
-Manager::Manager( const QString& )
+Manager::Manager( const QString& dev )
   : QObject()
 {
-
+    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::isConnected( 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 connected( device,  false );
+        delete l2ping;
+    }
 
 }
 void Manager::isConnected( Device* dev ){
 
 
 }
 void Manager::searchDevices( const QString& device ){
 
 }
 
 void Manager::searchDevices(Device* d ){
 
 
 }
 void Manager::addService(const QString& name ){
-
-}
-void Manager::addServices(const QStringList& ){
-
+    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 ){
-
-}
-void Manager::removeServices( const QStringList& ){
-
+    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() );
+    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() ) {
+        delete m_sdp;
+        Services::ValueList list;
+        emit foundServices( remDevice, list );
+    }
+}
+void Manager::searchServices( const RemoteDevices& dev){
+    searchServices( dev.mac() );
+}
+QString Manager::toDevice( const QString& mac ){
 
 }
-void Manager::searchServices( const RemoteDevices& ){
+QString Manager::toMac( const QString &device ){
 
 }
-QString Manager::toDevice( const QString& mac ){
+void Manager::slotProcessExited(OProcess* proc ) {
+    bool conn= false;
+    if (proc->normalExit() && proc->exitStatus() == 0 )
+        conn = true;
 
+    QString name = QString::fromLatin1(proc->name() );
+    emit connected( name, conn );
+    delete proc;
 }
-QString Manager::toMac( const QString &device ){
+void Manager::slotSDPOut(OProcess* proc, char* ch, int len)
+{
+    QCString str(ch,  len+1 );
+    QMap<QString, QString>::Iterator it;
+    it = m_out.find(proc->name() );
+    if ( it != m_out.end() ) {
+        QString string = it.data();
+        string.append( str );
+        m_out.replace( proc->name(), string );
+    }
 
 }
+void Manager::slotSDPExited( OProcess* proc)
+{
+    delete proc;
+}
diff --git a/noncore/net/opietooth/lib/manager.h b/noncore/net/opietooth/lib/manager.h
index 6c5e27f..03375c5 100644
--- a/noncore/net/opietooth/lib/manager.h
+++ b/noncore/net/opietooth/lib/manager.h
@@ -1,72 +1,75 @@
 
 #ifndef OpieToothManager_H
 #define OpieToothManager_H
 
 #include <qobject.h>
 #include <qstring.h>
+#include <qmap.h>
 #include <qvaluelist.h>
 
 #include "remotedevice.h"
 #include "services.h"
 
+class OProcess;
 namespace OpieTooth {
   class Device;
   /** Manager manages a blueZ device (hci0 for example)
    *  with Manager you can control the things you
    *  could do from command line in a OO and asynchronus
-   *  way.   
+   *  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
+     * for Remote devices it will ping and see.
+     * @param either mac or hciX
      */
     void isConnected(const QString& device= QString::null );
     /**
      * same as above
      */
     void isConnected(Device *dev );
 
-    /** this search for devices reachable from the
-     *  currently managed device   
+    /** 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
@@ -80,34 +83,44 @@ Q_OBJECT
     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 RemoteDevices& );
     /*static*/ QString toDevice( const QString& mac );
     /*static*/ QString toMac( const QString &device );
 
   signals:
     // device either mac or dev name
     // the first device is the device which you access
     void connected( const QString& device, bool connected );
-    void addedService( const QString& device, const QString& service, bool added );
-    void removedService( const QString& device, const QString& service, bool removed );
+    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, RemoteDevices::ValueList );
+      void foundNothing( const QString& device );
+private slots:
+    void slotProcessExited(OProcess* );
+    void slotSDPExited(OProcess*);
+    void slotSDPOut(OProcess*, char*, int);
+  private:
+      OProcess *m_hcitool;
+      OProcess *m_sdp; // not only one
+      QString m_device;
+      QMap<QString, QString> m_out;
   };
 };
 
 #endif