avossocket.cpp

爱可视605看PDF程式源代码, 基于APDF

#include <stdlib.h>
#include <unistd.h>
#include <sys/socket.h>
#include <qsocket.h>

#include "avossocket.h"
#include "extapp_msg.h"

using namespace archos;

/*
Usage example:

#include <extapp.h>
#include <avossocket.h>
[...]

QPdfDlg::QPdfDlg() : QWidget(NULL, "mainwidget", QWidget::WStyle_Customize | 
QWidget::WStyle_NoBorder)
        , m_docLoaded(false)
        , m_pages(0)
        , m_doc(0)
{
        avossocket = archos::AvosSocket::getInstance();
        if ( avossocket->start() == -1) {
                qWarning("failed to setup the avossocket");
                qApp->quit();
        }
        connect(avossocket, SIGNAL(packetReady(extapp_msg_t*)), this, 
SLOT(handleMsg(extapp_msg_t*)));
       [...]
}

[...]

void QPdfDlg::handleMsg(extapp_msg_t* msg)
{
        switch ( msg->header.packet_type ) {
                case EXTAPP_PACKET_BATTERY_STATUS:
                        qWarning("new battery status 0x%x\n", *((int*)msg->data));
                        break;
                case EXTAPP_PACKET_LANG_CHANGED:
                        atr_unload();
                        if (atr_load(tr_path) ) {
                                qWarning("failed to load translations!\n");
                        }
                        qApp->setFont(FontChooser::getFont());
                        restartGui();
                        break;
                default:
                        qWarning("apdf: unkown message (%x).\n", msg->header.packet_type);
                        break;
        }
        avossocket->freeMsg(msg);
}
*/

archos::AvosSocket* archos::AvosSocket::getInstance()
{
	if ( instance == 0 ) {
		instance = new AvosSocket();
	}
	return instance;
}

archos::AvosSocket::AvosSocket(void)
	: avosSocket(new QSocket()) { }

archos::AvosSocket::~AvosSocket(void)
{
	delete avosSocket;

}

int archos::AvosSocket::start(void)
{
	if ( (socket_fd = socket(PF_UNIX, SOCK_STREAM, 0)) < 0 ) {
		qWarning("Failed to open comm socket to AVOS\n");
		return -1;
	}

	struct sockaddr addr;
	addr.sa_family = AF_UNIX;
	strcpy(addr.sa_data, "/tmp/easocket");

	if (::connect(socket_fd, &addr, sizeof(addr)) == -1) {
		qWarning("Failed to connect() comm socket to AVOS\n");
		return -2;
	}

	avosSocket->setSocket(socket_fd);
	connect(avosSocket, SIGNAL(readyRead()), this, SLOT(handleMsg()));
	return 0;
}

#define HEADER_LEN	sizeof(extapp_msg_header_t)

void archos::AvosSocket::handleMsg(void)
{
	static char *msg_buf;
	static unsigned int buffer_fill = 0;
	static int header_complete = 0;
	int msg_len;

	while ( 1 ) {
		// try to get a header first
		if ( !header_complete ) {
			if ( msg_buf == 0 ) {
				msg_buf = (char*)calloc(1, sizeof(extapp_msg_t));
				if ( msg_buf == 0 ) {
					qWarning("avossocket: extapp oom!\n");
					break;
				}
			}
			msg_len = avosSocket->readBlock(msg_buf + buffer_fill, HEADER_LEN - buffer_fill);
			if ( msg_len >= 0 ) {
				buffer_fill += msg_len;
			}
			else {
				qWarning("avossocket: error while reading header from the extapp socket.");
				buffer_fill = 0;
				break;
			}
			if ( buffer_fill < sizeof(extapp_msg_header_t) ) {
				qWarning("avossocket: header incomplete.");
				break;
			}
			buffer_fill = 0;
		
			extapp_msg_header_t *header = (extapp_msg_header_t*)msg_buf;
			if ( header->magic != (int)EXTAPP_MAGIC ) {
				qWarning("avossocket: extapp header magic missing!");
				buffer_fill = 0;
				break;
			}
		
			if ( header->data_length > EXTAPP_MSG_MAX_DATA_LENGTH ) {
				qWarning("avossocket: %i is greater than EXTAPP_MSG_MAX_DATA_LENGTH", header->data_length);
				buffer_fill = 0;
				break;
			}
			header_complete = 1;
			buffer_fill = 0;
		}
		
		// a packet with a data portion, go and get it
		extapp_msg_t *msg = (extapp_msg_t*)msg_buf;
		if ( msg->header.data_length > 0 ) {
			if ( msg->data == 0 ) {
				msg->data = (char*)calloc(1, msg->header.data_length);
				if ( msg->data == 0 ) {
					qWarning("avossocket: extapp oom!");
					break;
				}
			}
			msg_len = avosSocket->readBlock((char*)msg->data + buffer_fill, msg->header.data_length - buffer_fill);
			if ( msg_len >= 0 ) {
				buffer_fill += msg_len;
			}
			else {
				qWarning("avossocket: error while reading msg from the extapp socket.");
				buffer_fill = 0;
				header_complete = 0;
				break;
			}
		
			if ( buffer_fill < msg->header.data_length ) {
				qWarning("avossocket: data incomplete.");
				break;
			}
		}
		header_complete = 0;
		buffer_fill = 0;
		
		qWarning("archos::AvosSocket::handleMsg: packet ready (type = 0x%x)", ((extapp_msg_t*)msg_buf)->header.packet_type);
		emit packetReady((extapp_msg_t*)msg_buf);
		msg_buf = 0;
	}
}

// must be called for every packet passed as paramter of the packetReady(extapp_msg_t*) signal.
void archos::AvosSocket::freeMsg(extapp_msg_t* msg)
{
	free(msg->data);
	free(msg);
}

int archos::AvosSocket::sendMsg(extapp_msg_t* msg)
{
qWarning("archos::AvosSocket::sendMsg %x", msg->header.packet_type);

	unsigned int count = 0;
	int err = 0;
	while ( count < sizeof(extapp_msg_header_t) ) {
		err = avosSocket->writeBlock(((char*)&msg->header) + count, sizeof(extapp_msg_header_t) - count );
		if ( err == -1 ) {
			qWarning("avossocket: failed to write extapp msg header\n");
			return -1;
		}
		count += err;
		qWarning("avossocket: %i bytes of the extapp msg header written\n", count);
	}

	count = 0;
	while ( count < msg->header.data_length ) {
		err = avosSocket->writeBlock(((char*)msg->data) + count, msg->header.data_length + count);
		if ( err == -1 ) {
			qWarning("avossocket: failed to write extapp msg\n");
			return -1;
		}
		count += err;
		qWarning("avossocket: %i bytes of the extapp msg written\n", count);
	}
	return 0;
}

archos::AvosSocket *archos::AvosSocket::instance = NULL;