Stop receiving when wanting to send

3 files changed, 71 insertions, 5 deletions

diff --git a/core/applets/obex/obex.cc b/core/applets/obex/obex.cc
index 683964b..2218dbc 100644
--- a/core/applets/obex/obex.cc
+++ b/core/applets/obex/obex.cc
@@ -1,128 +1,184 @@
 
 #include <qapplication.h>
 #include <qmessagebox.h>
 #include <qpe/qcopenvelope_qws.h>
 #include <opie/oprocess.h>
 #include "obex.h"
 
 using namespace  OpieObex;
 
 Obex::Obex( QObject *parent, const char* name )
   : QObject(parent, name )
 {
   m_rec = 0;
   m_send=0;
   m_count = 0;
+    m_receive = false;
+    connect( this, SIGNAL(error(int) ), // for recovering to receive
+             SLOT(slotError() ) );
+    connect( this, SIGNAL(sent() ),
+             SLOT(slotError() ) );
 };
 Obex::~Obex() {
   delete m_rec;
   delete m_send;
 }
 void Obex::receive()  {
+    m_receive = true;
   qWarning("Receive" );
    m_rec = new OProcess();
    *m_rec << "irobex_palm3";
    // connect to the necessary slots
    connect(m_rec,  SIGNAL(processExited(OProcess*) ),
 	   this,  SLOT(slotExited(OProcess*) ) );
 
    connect(m_rec,  SIGNAL(receivedStdout(OProcess*, char*,  int ) ),
 	   this,  SLOT(slotStdOut(OProcess*, char*, int) ) );
 
    if(!m_rec->start(OProcess::NotifyOnExit, OProcess::AllOutput) ) {
      qWarning("could not start :(");
      emit done( false );
+        delete m_rec;
+        m_rec = 0;
    }
-   emit currentTry(m_count );
+//    emit currentTry(m_count );
 
 }
-void Obex::send( const QString& fileName) {
+void Obex::send( const QString& fileName) { // if currently receiving stop it send receive
   m_count = 0;
   m_file = fileName;
+    qWarning("send");
+    if (m_rec != 0 ) {
+        qWarning("running");
+        if (m_rec->isRunning() ) {
+            emit error(-1 );
+            qWarning("is running");
+            delete m_rec;
+            m_rec = 0;
+
+        }else{
+            qWarning("is not running");
+            emit error( -1 ); // we did not delete yet but it's not running slotExited is pending
+            return;
+        }
+    }
   sendNow();
 }
 void Obex::sendNow(){
+    qWarning("sendNow");
   if ( m_count >= 25 ) { // could not send
     emit error(-1 );
     return;
   }
   // OProcess inititialisation
   m_send = new OProcess();
   *m_send << "irobex_palm3";
   *m_send << m_file;
 
   // connect to slots Exited and and StdOut
   connect(m_send,  SIGNAL(processExited(OProcess*) ),
 	  this, SLOT(slotExited(OProcess*)) );
   connect(m_send,  SIGNAL(receivedStdout(OProcess*, char*,  int )),
 	  this, SLOT(slotStdOut(OProcess*, char*, int) ) );
+
   // now start it
   if (!m_send->start(/*OProcess::NotifyOnExit,  OProcess::AllOutput*/ ) ) {
     qWarning("could not send" );
     m_count = 25;
     emit error(-1 );
+        delete m_send;
+        m_send=0;
   }
   // end
   m_count++;
   emit currentTry( m_count );
 }
 
 void Obex::slotExited(OProcess* proc ){
    if (proc == m_rec ) { // recieve process
         recieved();
     }else if ( proc == m_send ) {
         sendEnd();
     }
 }
 void Obex::slotStdOut(OProcess* proc, char* buf, int len){
   if ( proc == m_rec ) { // only recieve
     QCString cstring( buf,  len );
     m_outp.append( cstring.data() );
   }
 }
 
 void Obex::recieved() {
   if (m_rec->normalExit() ) {
     if ( m_rec->exitStatus() == 0 ) { // we got one
       QString filename = parseOut();
       emit receivedFile( filename );
     }
   }else{
-    emit error(-1);
+      emit done(false);
   };
   delete m_rec;
+  m_rec = 0;
+  receive();
 }
 
 void Obex::sendEnd() {
   if (m_send->normalExit() ) {
     if ( m_send->exitStatus() == 0 ) {
       delete m_send;
       m_send=0;
       qWarning("done" );
       emit sent();
     }else if (m_send->exitStatus() == 255 ) { // it failed maybe the other side wasn't ready
       // let's try it again
       delete m_send;
       m_send = 0;
       qWarning("try sending again" );
       sendNow();
     }
   }else {
     emit error( -1 );
     delete m_send;
     m_send = 0;
   }
 }
 QString Obex::parseOut(     ){
   QString path;
   QStringList list = QStringList::split("\n",  m_outp);
   QStringList::Iterator it;
   for (it = list.begin(); it != list.end(); ++it ) {
     if ( (*it).startsWith("Wrote"  ) ) {
       QStringList pathes = QStringList::split(' ', (*it) );
       path = pathes[1];
       qWarning("path %s", path.latin1() );
     }
   }
   return path;
 }
+/**
+ * when sent is done slotError is called we  will start receive again
+ */
+void Obex::slotError() {
+    qWarning("slotError");
+    if ( m_receive )
+        receive();
+};
+void Obex::setReceiveEnabled( bool receive ) {
+    if ( !receive ) { //
+        m_receive = false;
+        shutDownReceive();
+    }
+}
+
+void Obex::shutDownReceive() {
+    if (m_rec != 0 ) {
+        qWarning("running");
+        if (m_rec->isRunning() ) {
+            emit error(-1 );
+            qWarning("is running");
+            delete m_rec;
+            m_rec = 0;
+        }
+    }
+
+}
diff --git a/core/applets/obex/obex.h b/core/applets/obex/obex.h
index 4e78015..2ce44f2 100644
--- a/core/applets/obex/obex.h
+++ b/core/applets/obex/obex.h
@@ -5,77 +5,81 @@
 
 #include <qobject.h>
 
 class OProcess;
 class QCopChannel;
 namespace OpieObex {
   class Obex : public QObject {
     Q_OBJECT
   public:
     /**
      * Obex c'tor look 
      */
     Obex( QObject *parent, const char* name);
     /**
      * d'tor
      */
     ~Obex();
 
     /**
      *  Starting listening to irda after enabled by the applet
      * a  signal gets emitted when recieved a file
      */
     void receive();
     void send( const QString& );
+      void setReceiveEnabled( bool = false );
   signals:
 
     /**
      * a signal 
      * @param path The path to the recieved file
      */
     void receivedFile( const QString& path);
     /**
      * error signal if the program couldn't be started or the 
      * the connection timed out
      */
     void error( int );
     /**
      *  The current try to receive data
      */
     void currentTry(unsigned int);
     /**
      * signal sent The file got beamed to the remote location
      */
     void sent();
       // private slots
     void done(bool);
 
   private:
     uint m_count;
     QString m_file;
     QString m_outp;
     OProcess *m_send;
     OProcess *m_rec;
+      bool m_receive : 1;
+      void shutDownReceive();
   
   private slots:
 
     /**
      * send over palm obex
      */
 
     //void send(const QString&);
    
    // the process exited
    void slotExited(OProcess* proc) ;
    void slotStdOut(OProcess*, char*, int);
+      void slotError();
   
   private:
    void sendNow();
    QString parseOut();
    void recieved();
    void sendEnd();
    
   };
 };
 
 
 #endif
diff --git a/core/applets/obex/obeximpl.cc b/core/applets/obex/obeximpl.cc
index 856f100..0c137af 100644
--- a/core/applets/obex/obeximpl.cc
+++ b/core/applets/obex/obeximpl.cc
@@ -28,73 +28,79 @@ ObexImpl::~ObexImpl() {
   delete m_chan;
   delete m_sendgui;
 }
 QRESULT ObexImpl::queryInterface( const QUuid &uuid, QUnknownInterface **iface ) {
   *iface = 0;
   if( uuid  ==  IID_QUnknown )
     *iface = this;
   else if( uuid == IID_ObexInterface )
     *iface = this;
 
   qWarning("query" );
   if(*iface )
     (*iface)->addRef();
   return QS_OK;
 
 }
 void ObexImpl::slotMessage( const QCString& msg, const QByteArray&data ) {
   QDataStream stream( data, IO_ReadOnly );
   qWarning("Message %s", msg.data() );
   if(msg == "send(QString,QString,QString)" ) {
     QString desc;
     stream >> desc;
     QString filename;
     stream >> filename;
+    m_sendgui->raise(); // should be on top
     m_sendgui->showMaximized();
     m_sendgui->lblPath->setText(filename);
     connect( (QObject*)m_sendgui->PushButton2, SIGNAL(clicked()),
              this, SLOT(slotCancelSend()));
     m_obex->send(filename );
     connect( (QObject*)m_obex, SIGNAL( sent() ), this,
              SLOT( slotSent() ) );
-  }else if(msg == "receive(bool)" ) { // open a GUI
+  }else if(msg == "receive(int)" ) { // open a GUI
       m_recvgui->showMaximized();
+      int receiveD = 0;
+      stream >> receiveD;
+      if ( receiveD == 1)
       m_obex->receive();
+      else
+          m_obex->setReceiveEnabled( false );
 
   } else if (msg =="done(QString)") {
       QString text;
       stream >> text;
       m_sendgui->lblPath->setText(tr("Done transfering " + text));
 
   }
 }
 
 void ObexImpl::slotCancelSend() {
     // cancel sync process too
     //m_obex->cancel(); // not ready yet
     m_sendgui->hide();
 }
 
 void ObexImpl::slotDone(bool) {
     QCopEnvelope e ("QPE/Obex", "done(QString)" ); //but this into a slot
     e << "Done!";
 }
 
 void ObexImpl::slotSent() {
     m_sendgui->lblPath->setText("Done!");
     m_sendgui->hide();
 }
 
 void ObexImpl::slotError( int errorCode) {
 
     QString errorString = "";
-    if (errorCode = -1) {
+    if (errorCode == -1) {
         errorString = "test";
     }
     qDebug("Error: " + errorString);
     m_sendgui->hide();
 }
 
 Q_EXPORT_INTERFACE()
 {
     Q_CREATE_INSTANCE( ObexImpl )
 }