3 files changed, 36 insertions, 8 deletions

diff --git a/noncore/net/opietooth/applet/bluezapplet.cpp b/noncore/net/opietooth/applet/bluezapplet.cpp
index f7774f0..127b0af 100644
--- a/noncore/net/opietooth/applet/bluezapplet.cpp
+++ b/noncore/net/opietooth/applet/bluezapplet.cpp
@@ -16,194 +16,194 @@
   _.=:.       :    :=>:      PARTICULAR PURPOSE. See the GNU
 ..}^=.=       =       ;      Library General Public License for more
 ++=   -.     .     .:        details.
  :     =  ...= . :.=-
  -.   .:....=;==+<;          You should have received a copy of the GNU
   -_. . .   )=.  =           Library General Public License along with
     --        :-=            this library; see the file COPYING.LIB.
                              If not, write to the Free Software Foundation,
                              Inc., 59 Temple Place - Suite 330,
                              Boston, MA 02111-1307, USA.
 
 */
 
 
 #include "bluezapplet.h"
 
 /* OPIE */
 #include <opie2/otaskbarapplet.h>
 #include <opie2/odevice.h>
 #include <opie2/odebug.h>
 #include <opie2/oresource.h>
 #include <opie2/oprocess.h>
 #include <qpe/version.h>
 #include <qpe/applnk.h>
 #include <qpe/qcopenvelope_qws.h>
 #include <qpe/config.h>
 using namespace Opie::Core;
 
 /* QT */
 #include <qapplication.h>
 #include <qpoint.h>
 #include <qpainter.h>
 #include <qlayout.h>
 #include <qframe.h>
 #include <qpixmap.h>
 #include <qstring.h>
 #include <qtimer.h>
 #include <qpopupmenu.h>
 #include <qmessagebox.h>
 
 /* STD */
 #include <device.h>
 
 namespace OpieTooth {
     BluezApplet::BluezApplet( QWidget *parent, const char *name ) : QWidget( parent, name ) {
         setFixedHeight( AppLnk::smallIconSize() );
         setFixedWidth( AppLnk::smallIconSize() );
 #if OPIE_VERSION < 102010
         bluezOnPixmap = Resource::loadPixmap( "bluetoothapplet/bluezon" );
         bluezOffPixmap = Resource::loadPixmap( "bluetoothapplet/bluezoff" );
         bluezDiscoveryOnPixmap = Resource::loadPixmap( "bluetoothapplet/magglass.png" );
 #else
         bluezOnPixmap = OResource::loadImage( "bluetoothapplet/bluezon", OResource::SmallIcon );
         bluezOffPixmap = OResource::loadImage( "bluetoothapplet/bluezoff", Opie::Core::OResource::SmallIcon );
         bluezDiscoveryOnPixmap = OResource::loadImage( "bluetoothapplet/bluezondiscovery", Opie::Core::OResource::SmallIcon );
 #endif
         startTimer(2000);
         btDevice = 0;
         btManager = 0;
         bluezactive = false;
         bluezDiscoveryActive = false;
         doListDevice = false;
         isScanning = false;
         m_wasOn = false;
+        m_sync = false;
 
         // TODO: determine whether this channel has to be closed at destruction time.
         QCopChannel* chan = new QCopChannel("QPE/Bluetooth", this );
         connect(chan, SIGNAL(received(const QCString&,const QByteArray&) ),
                 this, SLOT(slotMessage(const QCString&,const QByteArray&) ) );
         ::system("/etc/init.d/bluetooth stop >/dev/null 2>/dev/null");
     }
 
     BluezApplet::~BluezApplet() {
         if ( btDevice ) {
+            ::system("/etc/init.d/bluetooth stop >/dev/null 2>/dev/null");
             delete btDevice;
         }
         if ( btManager ) {
             delete btManager;
         }
     }
 
     int BluezApplet::position()
     {
         return 6;
     }
 
 
     bool BluezApplet::checkBluezStatus() {
         if (btDevice) {
             if (btDevice->isLoaded() ) {
                 odebug << "btDevice isLoaded" << oendl;
                 return true;
             } else {
                 odebug << "btDevice is NOT loaded" << oendl;
                 return false;
             }
         } else {
             odebug << "btDevice is ZERO" << oendl;
             return false;
         }
     }
 
     int BluezApplet::setBluezStatus(int c, bool sync) {
 
         if ( c == 1 ) {
             switch ( ODevice::inst()->model() ) {
             case Model_iPAQ_H39xx:
                 btDevice = new Device( "/dev/tts/1", "bcsp", "921600" );
                 break;
 
             case Model_iPAQ_H5xxx:
                 btDevice = new Device( "/dev/tts/1", "any", "921600" );
                 break;
 
-#ifndef OPIE120
+#if OPIE_VERSION >= 102010
             case Model_MyPal_716:
                 btDevice = new Device( "/dev/ttyS1", "bcsp", "921600" );
                 break;
 #endif
 
             default:
                 btDevice = new Device( "/dev/ttySB0", "bcsp", "230400" );
                 break;
             }
-            if (sync) {
-                ::system("/etc/init.d/bluetooth start >/dev/null 2>/dev/null");
-            } else {
-                QCopEnvelope e("QPE/System", "execute(QString)");
-                e << QString("/etc/init.d/bluetooth start");
-            }
+            m_sync = sync;
+            connect(btDevice, SIGNAL(device(const QString&, bool)),
+                this, SLOT(slotDevice(const QString&, bool)));
+            
         } else {
             ::system("/etc/init.d/bluetooth stop >/dev/null 2>/dev/null");
             if ( btManager ) {
                 delete btManager;
                 btManager = 0;
             }
             if ( btDevice ) {
                 delete btDevice;
                 btDevice = 0;
             }
        }
         return 0;
     }
 
     int BluezApplet::checkBluezDiscoveryStatus() {
       return isScanning;
     }
 
     int BluezApplet::setBluezDiscoveryStatus(int d) {
       return bluezDiscoveryActive = d;
     }
 
     // FIXME mbhaynie
     // receiver for QCopChannel("QPE/Bluetooth") messages.
     void BluezApplet::slotMessage( const QCString& str, const QByteArray& )
     {
         if ( str == "enableBluetooth()") {
             m_wasOn = checkBluezStatus();
             if (!m_wasOn) {
                 setBluezStatus(1, true);
                 sleep(2);
             }
         }
         else if ( str == "disableBluetooth()") {
             /*
              * We can down BT only if it was started by qcop. We don't want 
              * to down BT started from menu an break our networking connection
              */
             if (checkBluezStatus() && !m_wasOn)
                 setBluezStatus(0);
             doListDevice = false;
         }
         else if ( str == "listDevices()") {
             if (checkBluezStatus()) {
                 doListDevice = false;
                 timerEvent(0);
                 if (!btManager) {
                     btManager = new Manager("hci0");
                     connect( btManager, 
                         SIGNAL( foundDevices(const QString&, RemoteDevice::ValueList) ),
                         this, SLOT( fillList(const QString&, RemoteDevice::ValueList) ) ) ;
                 }
                 btManager->searchDevices();
                 isScanning = true;
             } else
                 doListDevice = true;
         }
     }
 
     // Once the hcitool scan is complete, report back.
     void BluezApplet::fillList(const QString&, RemoteDevice::ValueList deviceList)
     {
         QCopEnvelope e("QPE/BluetoothBack", "devices(QStringMap)");
 
@@ -275,69 +275,86 @@ namespace OpieTooth {
             break;
             //case 7:
             // With table of currently-detected devices.
         }
 
         delete signal;
         delete menu;
     }
 
 
 /**
  * Launches the bluetooth manager
  */
     void BluezApplet::launchManager() {
         QCopEnvelope e("QPE/System", "execute(QString)");
         e << QString("bluetooth-manager");
     }
 
 /**
  * Refresh timer
  * @param the timer event
  */
     void BluezApplet::timerEvent( QTimerEvent * ) {
         bool oldactive = bluezactive;
         int olddiscovery = bluezDiscoveryActive;
 
         bluezactive = checkBluezStatus();
         bluezDiscoveryActive = checkBluezDiscoveryStatus();
 
         if ((bluezactive != oldactive) || 
             (bluezDiscoveryActive != olddiscovery))
             update();
         if (bluezactive && doListDevice) {
             const QByteArray arr;
             slotMessage("listDevices()", arr);
         }
     }
 
 /**
  * Implementation of the paint event
  * @param the QPaintEvent
  */
     void BluezApplet::paintEvent( QPaintEvent* ) {
         QPainter p(this);
         odebug << "paint bluetooth pixmap" << oendl; 
 
         if (bluezactive) {
 #if OPIE_VERSION < 102010
             p.drawPixmap( 0, -1,  bluezOnPixmap );
 #else
             p.drawPixmap( 0, 0,  bluezOnPixmap );
 #endif
         } else {
 #if OPIE_VERSION < 102010
             p.drawPixmap( 0, -1,  bluezOffPixmap );
 #else
             p.drawPixmap( 0, 0,  bluezOffPixmap );
 #endif
         }
 
         if (bluezDiscoveryActive) {
             p.drawPixmap( 0, 0,  bluezDiscoveryOnPixmap );
         }
     }
+    /**
+    * Reacts on device up
+    * @param name device name
+    * @param up if device was brought up
+    */
+    void BluezApplet::slotDevice(const QString& name, bool up)
+    {
+        if (!up)
+            return;
+        odebug << name << " is up" << oendl;
+        if (m_sync) {
+            ::system("/etc/init.d/bluetooth start >/dev/null 2>/dev/null");
+        } else {
+            QCopEnvelope e("QPE/System", "execute(QString)");
+            e << QString("/etc/init.d/bluetooth start");
+        }
+    }
 };
 
 
 EXPORT_OPIE_APPLET_v1( OpieTooth::BluezApplet )
 
diff --git a/noncore/net/opietooth/applet/bluezapplet.h b/noncore/net/opietooth/applet/bluezapplet.h
index 1937934..b79ed5b 100644
--- a/noncore/net/opietooth/applet/bluezapplet.h
+++ b/noncore/net/opietooth/applet/bluezapplet.h
@@ -9,73 +9,81 @@
  - .   .-<_>     .<>         Foundation; version 2 of the License.
      ._= =}       :
     .%+i>       _;_.
     .i_,=:_.      -<s.       This library is distributed in the hope that
      +  .  -:.       =       it will be useful,  but WITHOUT ANY WARRANTY;
     : ..    .:,     . . .    without even the implied warranty of
     =_        +     =;=|     MERCHANTABILITY or FITNESS FOR A
   _.=:.       :    :=>:      PARTICULAR PURPOSE. See the GNU
 ..}^=.=       =       ;      Library General Public License for more
 ++=   -.     .     .:        details.
  :     =  ...= . :.=-
  -.   .:....=;==+<;          You should have received a copy of the GNU
   -_. . .   )=.  =           Library General Public License along with
     --        :-=            this library; see the file COPYING.LIB.
                              If not, write to the Free Software Foundation,
                              Inc., 59 Temple Place - Suite 330,
                              Boston, MA 02111-1307, USA.
 
 */
 
 #ifndef __BLUEZAPPLET_H__
 #define __BLUEZAPPLET_H__
 
 #include <qwidget.h>
 #include <qpixmap.h>
 #include <qtimer.h>
 #include <manager.h>
 #include <opie2/oprocess.h>
 
 namespace OpieTooth {
     class Device;
 
     class BluezApplet : public QWidget {
         Q_OBJECT
     public:
         BluezApplet( QWidget *parent = 0, const char *name=0 );
         ~BluezApplet();
         static int position();
     protected:
         void timerEvent(QTimerEvent *te );
 
 public slots:
         void fillList( const QString& device, RemoteDevice::ValueList list );
 
     private:
         void mousePressEvent( QMouseEvent * );
         void paintEvent( QPaintEvent* );
         void launchManager();
         bool checkBluezStatus();
         int setBluezStatus(int, bool sync = false);
         int checkBluezDiscoveryStatus();
         int setBluezDiscoveryStatus(int);
 
     private:
         Device* btDevice;
         Manager *btManager;
         QPixmap bluezOnPixmap;
         QPixmap bluezOffPixmap;
         QPixmap bluezDiscoveryOnPixmap;
         bool bluezactive;
         bool bluezDiscoveryActive;
         bool doListDevice; //If I have to list devices after bringing BT up?
         bool isScanning; //If I'm scanning devices
         bool m_wasOn; //If BT was started by menu?
+    protected:
+        bool m_sync; //If we have to bring BT synchronously
 
 private slots:
         void slotMessage( const QCString& , const QByteArray& );
+        /**
+         * Reacts on device up
+         * @param name device name
+         * @param up if device was brought up
+         */
+        void slotDevice(const QString&, bool);
     };
 };
 
 
 #endif
 
diff --git a/noncore/net/opietooth/lib/device.cc b/noncore/net/opietooth/lib/device.cc
index 2f04d46..88d4cf9 100644
--- a/noncore/net/opietooth/lib/device.cc
+++ b/noncore/net/opietooth/lib/device.cc
@@ -65,118 +65,121 @@ Device::~Device(){
 void Device::attach(){
   owarn << "attaching " << m_device.latin1() << " " << m_mode.latin1() << " " << m_speed.latin1() << oendl;
   if(m_process == 0 ){
     m_output.resize(0);
     owarn << "new process to create" << oendl;
     m_process = new OProcess();
     *m_process << "hciattach";
     *m_process << "-p";
 
     // FIXME -- this is a hack for an odd hciattach interface.
     if ( ODevice::inst()->modelString() == "HX4700" )
       *m_process << "-S" << "/etc/bluetooth/TIInit_3.2.26.bts" << "/dev/ttyS1" << "texas";
     else
       *m_process << m_device << m_mode << m_speed;
     connect(m_process, SIGNAL( processExited(Opie::Core::OProcess*) ),
             this, SLOT( slotExited(Opie::Core::OProcess* ) ) );
     connect(m_process, SIGNAL( receivedStdout(Opie::Core::OProcess*, char*, int) ),
             this, SLOT(slotStdOut(Opie::Core::OProcess*,char*,int ) ) );
     connect(m_process, SIGNAL(receivedStderr(Opie::Core::OProcess*, char*, int ) ),
             this, SLOT(slotStdErr(Opie::Core::OProcess*,char*,int) ) );
     if(!m_process->start(OProcess::NotifyOnExit, OProcess::AllOutput ) ){
       owarn << "Could not start" << oendl;
       delete m_process;
       m_process = 0;
     }
   }
 }
 void Device::detach(){
   delete m_hci;
   m_hci = 0;
   delete m_process;
   m_process = 0;
   // kill the pid we got
   if(m_attached ){
     //kill the pid
     owarn << "killing" << oendl;
     ::kill(pid, 9);
   }
   owarn << "detached" << oendl;
 }
 bool Device::isLoaded()const{
   return m_attached;
 }
 QString Device::devName()const {
   return QString::fromLatin1("hci0");
 };
 void Device::slotExited( OProcess* proc)
 {
   owarn << "prcess exited" << oendl;
   if(proc== m_process ){
     owarn << "proc == m_process" << oendl;
     if( m_process->normalExit() ){ // normal exit
       owarn << "normalExit" << oendl;
       int ret = m_process->exitStatus();
       if( ret == 0 ){ // attached
         owarn << "attached" << oendl;
         owarn << "Output: " << m_output.data() << oendl;
         pid = parsePid( m_output );
         owarn << "Pid = " << pid << oendl;
         // now hciconfig hci0 up ( determine hciX FIXME)
         // and call hciconfig hci0 up
         // FIXME hardcoded to hci0 now :(
         m_hci = new OProcess( );
         *m_hci << "hciconfig";
-        *m_hci << "hci0 up";
+        *m_hci << "hci0";
+        *m_hci << "up";
         connect(m_hci, SIGNAL( processExited(Opie::Core::OProcess*) ),
                 this, SLOT( slotExited(Opie::Core::OProcess* ) ) );
         if(!m_hci->start() ){
           owarn << "could not start" << oendl;
           m_attached = false;
           emit device("hci0", false );
         }
       }else{
         owarn << "crass" << oendl;
         m_attached = false;
         emit device("hci0", false );
 
       }
     }
     delete m_process;
     m_process = 0;
   }else if(proc== m_hci ){
     owarn << "M HCI exited" << oendl;
     if( m_hci->normalExit() ){
       owarn << "normal exit" << oendl;
       int ret = m_hci->exitStatus();
       if( ret == 0 ){
         owarn << "attached really really attached" << oendl;
         m_attached = true;
+        //Wait for a device to be brought up
+        ::sleep(1);
         emit device("hci0", true );
       }else{
         owarn << "failed" << oendl;
         emit device("hci0", false );
         m_attached = false;
       }
     }// normal exit
     delete m_hci;
     m_hci = 0;
   }
 }
 void Device::slotStdOut(OProcess* proc, char* chars, int len)
 {
   owarn << "std out" << oendl;
   if( len <1 ){
     owarn << "len < 1 " << oendl;
     return;
   }
   if(proc == m_process ){
     QCString string( chars, len+1 ); // \0 == +1
     owarn << "output: " << string.data() << oendl;
     m_output.append( string.data() );
   }
 }
 void Device::slotStdErr(OProcess* proc, char* chars, int len)
 {
   owarn << "std err" << oendl;
   slotStdOut( proc, chars, len );
 }