qirserver.cpp

Trolltech公司发布的图形界面操作系统。可在qt-embedded-2.3.7平台上编译为嵌入式图形界面操作系统。

    mime_to_send = mimetype;
    transmitDone = FALSE;

    connectCount = 0;
    tryConnecting();
}



void QObexSender::tryConnecting()
{
    connectCount++;

    if ( aborted ) {
	deleteMeLater();
	return;
    }
	
    int retc = IrOBEX_TransportConnect(self, "OBEX");
    
    if ( retc < 0 ) {
	const int maxTry = 20;
	if ( connectCount > maxTry ) {
	    abort();
	    emit error();
	    deleteMeLater();
	} else {
	    QString str = tr("Beam failed (%1/%2). Retrying...","eg. 1/3").arg(connectCount).arg(maxTry);
	    emit statusMsg( str );
	    QTimer::singleShot( 500, this, SLOT(tryConnecting()) );
	}
	return;
    }

    QString str = tr("Sending...");
    emit statusMsg( str );

    connectSocket();

    obex_object_t *object;

    // connecting
    object = OBEX_ObjectNew(self, OBEX_CMD_CONNECT);


    state = QObexSender::Connecting;

    process( object );
}

//-----------------------------------------------------------------------

/*

  QObexServer /  functions

*/

QObexServer::QObexServer( QObject *parent, const char *name )
  :QObexBase( parent, name )
{

    state = Error;
    self = OBEX_Init( OBEX_TRANS_IRDA, qobex_server_callback, 
		      OBEX_FL_KEEPSERVER );
    state = Init;
    OBEX_SetUserData( self, this );

    if(OBEX_ServerRegister(self, "OBEX") < 0) {
	qWarning( "could not register server" );
	state = Error;
    } else {
      connectSocket();
    }
}



QObexServer::~QObexServer()
{
    //cleanup
}

void QObexServer::doPending()
{
    //nothing, it's stateless
}

void QObexServer::spawnReceiver( obex_t *handle )
{
    ASSERT( handle == self );
    
    // we emit this here, as doing in in QObexReceiver could cause race conditions
    emit receiving( TRUE );
    
    QObexReceiver *receiver = new QObexReceiver( handle, this );
    connect( receiver, SIGNAL(receiving(int, const QString&, const QString&)),
	     parent(), SIGNAL(receiving(int, const QString&, const QString&)) );
    connect( receiver, SIGNAL(progress(int)),
	     parent(), SIGNAL(progress(int)) );
    connect( receiver, SIGNAL(received(const QString&, const QString&)),
	     parent(), SIGNAL(received(const QString&, const QString&)) );
    
    connect( receiver, SIGNAL(receiving(bool)), parent(), SLOT(receiving(bool)) );

    connect( parent(), SIGNAL(abort()), receiver, SLOT(abort()) );
    connect(receiver, SIGNAL(error()),
	    parent(), SLOT(mError()) );
    
}



static void qobex_server_callback(obex_t *handle, obex_object_t * /*object*/, gint /*mode*/, gint event, gint /*obex_cmd*/, gint /*obex_rsp*/)
{

    //    qDebug( "qobex_server_callback %p event %x cmd %x rsp %x", object, event, obex_cmd, obex_rsp );

    QObexServer* server = 
	(QObexServer*)OBEX_GetUserData( handle );

    switch (event)        {
    case OBEX_EV_ACCEPTHINT:
	{
	    //qDebug( "#####------ OBEX_EV_ACCEPTHINT ------########" );

	    server->spawnReceiver( handle );
	}
	break;
    default:
	qWarning( " Unexpected event in server" );
	break;
    }

}



/*

  QObexReceiver functions

*/



QObexReceiver::QObexReceiver( obex_t *handle, QObject *parent, const char *name )
  :QObexBase( parent, name )
{

    state = Error; reclen = 0;

    state = Receiving;
    self = OBEX_ServerAccept( handle, qobex_receiver_callback,
			      this );
    connectSocket();

}


QObexReceiver::~QObexReceiver()
{
}



static QString getString( const uchar* bs, int len )
{
    // qDebug( "getString" );
    /*
    for ( int i = 0; i < len; i++ )
	qDebug( "byte %2d : %02x %c", i, bs[i], bs[i] );
    */
    QString s;
    s.setUnicode( (const QChar*)bs, len/2-1 );
    return s;
}

#define HDR_DESCRIPTION 0x05


void QObexReceiver::getHeaders( obex_object_t *object )
{
    uchar hi;
    obex_headerdata_t hv;
    guint32 hv_size;
    while(OBEX_ObjectGetNextHeader(self, object, &hi, &hv, &hv_size))	{

	switch ( hi ) {

	case OBEX_HDR_LENGTH:
#ifdef QTOPIA_DEBUG_OBEX
	    qDebug( "******** Got length %d", hv.bq4 );
#endif
	    reclen = hv.bq4;
	    break;

	case OBEX_HDR_NAME:
	    filename = getString(hv.bs, hv_size);
#ifdef QTOPIA_DEBUG_OBEX
	    qDebug( "******** Got name %s (%d)", 
			getString(hv.bs, hv_size).latin1(), hv_size );
#endif
	    break;


	case HDR_DESCRIPTION:
#ifdef QTOPIA_DEBUG_OBEX
	    qDebug( "******** Got description %s (%d)", 
			getString(hv.bs, hv_size).latin1(), hv_size );
#endif
	    break;



	case OBEX_HDR_TYPE:
	    mimetype = QString::fromLatin1( (const char*)hv.bs, hv_size );
#ifdef QTOPIA_DEBUG_OBEX
	    qDebug( "******** Got type \"%s\"", mimetype.latin1() );
#endif
	    break;


	default:
#ifdef QTOPIA_DEBUG_OBEX
	    if ( hi < 0x40 ) //unicode header
		qDebug( "******** Got header 0x%x %s (%d)", hi, 
			getString(hv.bs, hv_size).latin1(), hv_size );
	    else if ( (hi & 0xc0) == 0xc0 ) // quantity [eg. cf = PalmOS Creator ID]
		qDebug( "******** Got header 0x%x (%d)", hi, hv.bq4 );
	    else
		qDebug( "******** Got header 0x%x (size=%d)", hi, hv_size );
#endif
	    ;
	}
    }
}

void QObexReceiver::readData( obex_object_t *object )
{
    if ( filename.isEmpty() ) {
	getHeaders( object );


	int slash = filename.find( '/', -1 );
	if ( slash > 0 ) {
	    filename = filename.mid( slash+1 );
	}

	if ( mimetype.isNull() ) {
	    MimeType mt(filename);
	    mimetype = mt.id();
	}

	emit receiving( reclen, filename, mimetype );

	mkdir( "/tmp/obex", 0755 );
	system( "rm -rf /tmp/obex/*" );
	
	if ( filename.isEmpty() )
	    filename = "unnamed"; // No tr
	filename = "/tmp/obex/" + filename;
	
	outfile.setName( filename );
	outfile.open( IO_WriteOnly );

    }


    const uchar* buf;
    int len = OBEX_ObjectReadStream( self, object, &buf );

    if ( len > 0 ) {
	outfile.writeBlock( (const char*)buf, len );
    } else if ( len == 0 ) {
	outfile.close();

	emit received( outfile.name(), mimetype );
    } else {
	qWarning( "ERROR reading stream" );
	emit error();
    }
    finished = ( len <= 0 );
}

void QObexReceiver::updateProgress( obex_object_t * /* obj */)
{
    emit progress( outfile.size() );
}


static void qobex_receiver_callback(obex_t *handle, obex_object_t *object, gint /*mode*/, gint event, gint obex_cmd, gint /*obex_rsp*/ )
{
//    qDebug( "qobex_receiver_callback %p event %x cmd %x rsp %x", object, event, obex_cmd, obex_rsp );
    QObexReceiver* receiver = 
	(QObexReceiver*)OBEX_GetUserData( handle );

    switch (event)        {

    case OBEX_EV_STREAMAVAIL:
	receiver->readData( object );
	break;
    case OBEX_EV_PROGRESS:
	receiver->updateProgress( object );
	// report progress
	break;

    case OBEX_EV_REQ:
	/* An incoming request */
	switch(obex_cmd) {
	case OBEX_CMD_CONNECT:
	case OBEX_CMD_DISCONNECT:
	    /* Dont need to do anything here.
	       Response is already set to
	       success by OBEX_EV_REQHINT event */
	    break;
	case OBEX_CMD_PUT:
	    //We do it all in STREAMAVAIL 
	    //receiver->handlePut(object);
	    break;
	}                 
	break;

    case OBEX_EV_ACCEPTHINT:

	//qFatal( " OBEX_EV_ACCEPTHINT in receiver" );
	OBEX_ObjectSetRsp(object, OBEX_RSP_NOT_IMPLEMENTED,
			  OBEX_RSP_NOT_IMPLEMENTED);
	break;

    case OBEX_EV_REQHINT:

	/* A new request is coming in */
	switch(obex_cmd) {
	    /* Accept some commands! */
	case OBEX_CMD_PUT:
	    OBEX_ObjectSetRsp(object, OBEX_RSP_CONTINUE, OBEX_RSP_SUCCESS);
	//turn on streaming...
	    OBEX_ObjectReadStream(handle, object, NULL);
	    break;


	case OBEX_CMD_CONNECT:
	case OBEX_CMD_DISCONNECT:
	    OBEX_ObjectSetRsp(object, OBEX_RSP_CONTINUE, OBEX_RSP_SUCCESS);
	    break;
                
	default:
	    /* Reject any other commands */                       
	    OBEX_ObjectSetRsp(object, OBEX_RSP_NOT_IMPLEMENTED,
			      OBEX_RSP_NOT_IMPLEMENTED);
	    break;
                
	}
	break;

    case OBEX_EV_REQDONE:
	if(obex_cmd == OBEX_CMD_DISCONNECT) {

	    receiver->state = QObexReceiver::Finished;
	    receiver->finished = TRUE;
	    // Disconnect transport:
	    OBEX_TransportDisconnect( handle );
	}
	break;

    case OBEX_EV_LINKERR:
	// just treat is as finished. SOme mobile phones behave this way.
	    receiver->state = QObexReceiver::Finished;
	    receiver->finished = TRUE;
	    // Disconnect transport:
	    OBEX_TransportDisconnect( handle );
	/* Not good */
	break;

    default:
	break;
    }

}

void QObexReceiver::doPending()
{
    if ( state == Finished ) {
	deleteMeLater();
	emit receiving(FALSE);
    }
}


#include "qirserver.moc"

QIrServer::QIrServer( QObject *parent, const char *name )
    :QObject( parent, name )
{
    QObexServer *ob = new QObexServer( this );
    connect(ob, SIGNAL(receiving(bool)), this, SLOT(receiving(bool)) );

    _state = Ready;
}

QIrServer::~QIrServer()
{
}

void QIrServer::beam( const QString& filename, const QString& mimetype )
{
    if ( _state != Ready ) {
	qDebug("QIrServer not ready, beaming disallowed");
	emit beamError();
	return;
    }
//    qDebug("beaming %s", filename.data() );
    _state = Beaming;
    
    QObexSender *sender = new QObexSender( this );

    connect( this, SIGNAL(abort()), sender, SLOT(abort()) );
    
    connect( sender, SIGNAL(done()), this, SLOT(mDone()) );
    connect( sender, SIGNAL(error()), this, SLOT(mError()) );
    connect( sender, SIGNAL(statusMsg(const QString &)), this, SIGNAL(statusMsg(const QString &)) );
    connect( sender, SIGNAL(progress(int)), this, SIGNAL( progress(int) ) );
    
    sender->beam( filename, mimetype );
    
    //fire-and forget, auto-cleanup
}

void QIrServer::receiving(bool b)
{
    State old = _state;
    
    if ( b )
	_state = Receiving;
    else
	_state = Ready;
    
    // no nice way of initializing the first receive call.  avoid sending more than one receiveInit call
    if ( _state != old && _state == Receiving)
	emit receiveInit();
}

void QIrServer::mDone()
{
    _state = Ready;
    emit beamDone();
}

void QIrServer::mError()
{
    State old = _state;
    _state = Ready;
    
    if ( old == Beaming )
        emit beamError();
    else if ( old == Receiving )
	emit receiveError();
    else
	qDebug("QIrServer::got error after we though connection was completed");
}

void QIrServer::cancel()
{
    // internal signal
    emit abort();
    
    //external (this goes to qir)
    mError();
}

void QIrServer::setReceivingEnabled( bool )
{
    //XXX

}