activate connections tab

3 files changed, 6 insertions, 4 deletions

diff --git a/noncore/net/opietooth/lib/manager.cc b/noncore/net/opietooth/lib/manager.cc
index 1281116..59ade6d 100644
--- a/noncore/net/opietooth/lib/manager.cc
+++ b/noncore/net/opietooth/lib/manager.cc
@@ -70,230 +70,231 @@ void Manager::searchDevices( const QString& device ){
         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) ) {
         ConnectionState::ValueList list;
         emit connections( list  );
         delete proc;
     }
 }
-void Manager::slotConnectionExited( OProcess* /*proc*/ ) {
-    qWarning("exited");
+void Manager::slotConnectionExited( OProcess* proc ) {
+    qWarning("<<<<<<<<<<<<<<<<<exited");
     ConnectionState::ValueList list;
     list = parseConnections( m_hcitoolCon );
     emit connections(list );
+    delete proc;
 }
 void Manager::slotConnectionOutput(OProcess* proc, char* cha, int len) {
     QCString str(cha, len );
     m_hcitoolCon.append( str );
-    delete proc;
+    //delete proc;
 }
 ConnectionState::ValueList Manager::parseConnections( const QString& out ) {
     ConnectionState::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() );
         ConnectionState con;
         con.setDirection( value[0] == QString::fromLatin1("<") ? Outgoing : Incoming );
         con.setConnectionMode( value[1] );
         con.setMac( value[2] );
         con.setHandle( value[4].toInt() );
         con.setState( value[6].toInt() );
         con.setLinkMode( value[8] == QString::fromLatin1("MASTER") ? Master : Client );
         list2.append( con );
     }
     return list2;
 }
diff --git a/noncore/net/opietooth/manager/bluebase.cpp b/noncore/net/opietooth/manager/bluebase.cpp
index d3abb54..5c5f069 100644
--- a/noncore/net/opietooth/manager/bluebase.cpp
+++ b/noncore/net/opietooth/manager/bluebase.cpp
@@ -229,312 +229,312 @@ QString BlueBase::status()const{
 void BlueBase::applyConfigChanges() {
     m_deviceName =  deviceNameLine->text();
     m_defaultPasskey = passkeyLine->text();
     m_useEncryption = cryptCheckBox->isChecked();
     m_enableAuthentification = authCheckBox->isChecked();
     m_enablePagescan = pagescanCheckBox->isChecked();
     m_enableInquiryscan = inquiryscanCheckBox->isChecked();
 
     writeConfig();
 
     QMessageBox::information( this, tr("Test") , tr("Changes were applied.") );
 }
 
 /**
  * Add fresh found devices from scan dialog to the listing
  *
  */
 void BlueBase::addSearchedDevices( const QValueList<RemoteDevice> &newDevices ) {
     BTDeviceItem * deviceItem;
     QValueList<RemoteDevice>::ConstIterator it;
 
     for( it = newDevices.begin(); it != newDevices.end() ; ++it ) {
 
         if (find( (*it)  )) // is already inserted
             continue;
 
         deviceItem = new BTDeviceItem( ListView2 , (*it) );
         deviceItem->setPixmap( 1, m_findPix );
         deviceItem->setExpandable ( true );
 
         // look if device is avail. atm, async
         deviceActive( (*it) );
 
         // ggf auch hier?
         addServicesToDevice( deviceItem );
     }
 }
 
 
 /**
  * Action that is toggled on entrys on click
  */
 void BlueBase::startServiceActionClicked( QListViewItem */*item*/ ) {
 }
 
 
 /**
  * Action that are toggled on hold (mostly QPopups i guess)
  */
 void BlueBase::startServiceActionHold( QListViewItem * item, const QPoint & point, int /*column*/ ) {
     if (!item )
         return;
 
     QPopupMenu *menu = new QPopupMenu();
     int ret=0;
 
     if ( ((BTListItem*)item)->type() == "device") {
 
         QPopupMenu *groups = new QPopupMenu();
 
         menu->insertItem( ((BTDeviceItem*)item)->name(),0 );
         menu->insertSeparator(1);
         menu->insertItem( tr("rescan sevices"),  2);
         menu->insertItem( tr("to group"), groups , 3);
         menu->insertItem( tr("delete"),  4);
 
         ret = menu->exec( point  , 0);
 
         switch(ret) {
         case -1:
             break;
         case 2:
             addServicesToDevice( (BTDeviceItem*)item );
             break;
 
         case 4:
             // deletes childs too
             delete item;
             break;
         }
         delete groups;
 
     }
 
     /*
      * We got service sensitive PopupMenus in our factory
      * We will create one through the factory and will insert
      * our Separator + ShowInfo into the menu or create a new
      * one if the factory returns 0
      * PopupMenu deletion is kind of weird.
      * If escaped( -1 ) or any of our items were chosen we'll
      * delete the PopupMenu otherwise it's the responsibility of
      * the PopupMenu to delete itself
      *
      */
     else if ( ((BTListItem*)item)->type() == "service") {
         BTServiceItem* service = (BTServiceItem*)item;
         QMap<int, QString> list = service->services().classIdList();
         QMap<int, QString>::Iterator it = list.begin();
         QPopupMenu *popup =0l;
         if ( it != list.end() ) {
 	    qWarning("Searching id %d %s", it.key(), it.data().latin1() );
             popup = m_popHelper.find( it.key() /*1*/,
                                       service->services(),
                                       (BTDeviceItem*)service->parent() );
 	}else {
 	    qWarning("Empty");
 	}
 
         if ( popup == 0l ) {
             qWarning("factory returned 0l");
             popup = new QPopupMenu();
         }
         int test1 = popup->insertItem( tr("Test1:"),  2);
 
         ret = popup->exec( point );
         qWarning("returned from exec() ");
         if ( ret == -1 ) {
             ;
         } else if ( ret == test1 ) {
             ;
         }
         delete popup;
     }
     delete menu;
 }
 
 
 /**
  * Search and display avail. services for a device (on expand from device listing)
  * @param item the service item returned
  */
 void BlueBase::addServicesToDevice( BTDeviceItem * item ) {
     qDebug("addServicesToDevice");
     // row of mac adress text(3)
     RemoteDevice device = item->remoteDevice();
     m_deviceList.insert( item->mac() , item );
     // and some time later I get a signal foundServices( const QString& device, Services::ValueList ); back
     m_localDevice->searchServices( device );
 }
 
 
 /**
  * Overloaded. This one it the one that is connected to the foundServices signal
  * @param device the mac address of the remote device
  * @param servicesList the list with the service the device has.
  */
 void BlueBase::addServicesToDevice( const QString& device, Services::ValueList servicesList ) {
     qDebug("fill services list");
 
     QMap<QString,BTDeviceItem*>::Iterator it;
     BTDeviceItem* deviceItem = 0;
 
     // get the right devices which requested the search
     it = m_deviceList.find( device );
     if( it == m_deviceList.end() )
         return;
     deviceItem = it.data();
 
     QValueList<OpieTooth::Services>::Iterator it2;
     BTServiceItem * serviceItem;
 
     if (!servicesList.isEmpty() ) {
         // add services
         QMap<int, QString> list;
         QMap<int, QString>::Iterator classIt;
         for( it2 = servicesList.begin(); it2 != servicesList.end(); ++it2 ) {
             serviceItem = new BTServiceItem( deviceItem  , (*it2)  );
             list = (*it2).classIdList();
             classIt = list.begin();
             int classId=0;
             if ( classIt != list.end() ) {
                 classId = classIt.key();
             }
 
             serviceItem->setPixmap( 0, m_iconLoader->serviceIcon( classId ) );
         }
     } else {
         Services s1;
         s1.setServiceName( tr("no serives found") );
         serviceItem = new BTServiceItem( deviceItem, s1 );
     }
     // now remove them from the  list
     m_deviceList.remove( it );
 }
 
 
 /**
  * Add the existing connections (pairs) to the connections tab.
  * This one triggers the search
  */
 void BlueBase::addConnectedDevices() {
-    m_localDevice->searchConnections();
+        m_localDevice->searchConnections();
 }
 
 
 /**
  * This adds the found connections to the connection tab.
  * @param connectionList the ValueList with all current connections
  */
 void BlueBase::addConnectedDevices( ConnectionState::ValueList connectionList ) {
 
     // clear the ListView first
     ListView4->clear();
 
     QValueList<OpieTooth::ConnectionState>::Iterator it;
     BTConnectionItem * connectionItem;
 
     if ( !connectionList.isEmpty() ) {
 
         for (it = connectionList.begin(); it != connectionList.end(); ++it) {
             connectionItem = new BTConnectionItem( ListView4 , (*it) );
         }
     } else {
         ConnectionState con;
         con.setMac( tr("No connections found") );
         connectionItem = new BTConnectionItem( ListView4 , con );
     }
 
     //  recall connection search after some time
     QTimer::singleShot( 20000, this, SLOT( addConnectedDevices() ) );
 }
 
 
 /**
  * Find out if a device can  currently be reached
  * @param device
  */
 void BlueBase::deviceActive( const RemoteDevice &device ) {
     // search by mac, async, gets a signal back
     // We should have a BTDeviceItem there or where does it get added to the map -zecke
     m_localDevice->isAvailable( device.mac() );
 }
 
 
 /**
  * The signal catcher. Set the avail. status on device.
  * @param device - the mac address
  * @param connected - if it is avail. or not
  */
 void BlueBase::deviceActive( const QString& device, bool connected  ) {
     qDebug("deviceActive slot");
 
     QMap<QString,BTDeviceItem*>::Iterator it;
 
     it = m_deviceList.find( device );
     if( it == m_deviceList.end() )
         return;
 
     BTDeviceItem* deviceItem = it.data();
 
 
     if ( connected ) {
         deviceItem->setPixmap( 1, m_onPix );
     } else {
         deviceItem->setPixmap( 1, m_offPix );
     }
     m_deviceList.remove( it );
 }
 
 
 /**
  * Open the "scan for devices"  dialog
  */
 void BlueBase::startScan() {
     ScanDialog *scan = new ScanDialog( this, "ScanDialog",
                                        true, WDestructiveClose );
     QObject::connect( scan, SIGNAL( selectedDevices( const QValueList<RemoteDevice>& ) ),
                       this, SLOT( addSearchedDevices( const QValueList<RemoteDevice>& ) ) );
 
     scan->showMaximized();
 }
 
 
 /**
  * Set the informations about the local device in information Tab
  */
 void BlueBase::setInfo() {
     StatusLabel->setText( status() );
 }
 
 
 /**
  * Decontructor
  */
 BlueBase::~BlueBase() {
     writeSavedDevices();
     delete m_iconLoader;
 }
 
 
 /**
  * find searches the ListView for a BTDeviceItem containig
  * the same Device if found return true else false
  * @param dev RemoteDevice to find
  * @return returns true if found
  */
 bool BlueBase::find( const RemoteDevice& rem ) {
     QListViewItemIterator it( ListView2 );
     BTListItem* item;
     BTDeviceItem* device;
     for (; it.current(); ++it ) {
         item = (BTListItem*) it.current();
         if ( item->typeId() != BTListItem::Device )
             continue;
 
         device = (BTDeviceItem*)item;
         if ( rem.equals( device->remoteDevice() ) )
             return true;
     }
     return false; // not found
 }
diff --git a/noncore/net/opietooth/manager/btconnectionitem.cpp b/noncore/net/opietooth/manager/btconnectionitem.cpp
index 6fb9c11..b57d1b3 100644
--- a/noncore/net/opietooth/manager/btconnectionitem.cpp
+++ b/noncore/net/opietooth/manager/btconnectionitem.cpp
@@ -1,23 +1,24 @@
 #include <connection.h>
 #include "btconnectionitem.h"
 
 using namespace OpieTooth;
 
 BTConnectionItem::BTConnectionItem( QListView* parent, const ConnectionState& con )
     : BTListItem( parent ){
     m_con = con;
     setText(0, m_con.mac() );
+    setText(1, m_con.connectionMode() );
 }
 BTConnectionItem::~BTConnectionItem() {
 
 }
 QString BTConnectionItem::type() const {
     return QString::fromLatin1("connection");
 }
 int BTConnectionItem::typeId() const {
     return Connection;
 }
 ConnectionState BTConnectionItem::connection() const {
     return m_con;
 }