+#include "socket_mmi.h"
+
+#include <unistd.h>
+#include <fcntl.h>
+#include <sys/ioctl.h>
+
+#include <lib/base/ebase.h>
+#include <lib/base/init.h>
+#include <lib/base/init_num.h>
+#include <lib/base/eerror.h>
+#include <lib/base/estring.h>
+#include <lib/dvb_ci/dvbci_session.h>
+
+#define MAX_LENGTH_BYTES 4
+#define MIN_LENGTH_BYTES 1
+//#define MMIDEBUG
+
+eSocket_UI *eSocket_UI::instance;
+
+eSocket_UI::eSocket_UI()
+ :eMMI_UI(1)
+{
+ ASSERT(!instance);
+ instance = this;
+ CONNECT(handler.mmi_progress, eMMI_UI::processMMIData);
+}
+
+eSocket_UI *eSocket_UI::getInstance()
+{
+ return instance;
+}
+
+void eSocket_UI::setInit(int)
+{
+ //NYI
+}
+
+void eSocket_UI::setReset(int)
+{
+ //NYI
+}
+
+int eSocket_UI::startMMI(int)
+{
+ unsigned char buf[]={0x9F,0x80,0x22,0x00}; // ENTER MMI
+ if (handler.send_to_mmisock( buf, 4 ))
+ {
+ eDebug("eSocket_UI::startMMI failed");
+ return -1;
+ }
+ return 0;
+}
+
+int eSocket_UI::stopMMI(int)
+{
+ unsigned char buf[]={0x9F,0x88,0x00,0x00}; // CLOSE MMI
+ if (handler.send_to_mmisock( buf, 4 ))
+ {
+ eDebug("eSocket_UI::stopMMI failed");
+ return -1;
+ }
+ return 0;
+}
+
+int eSocket_UI::answerMenu(int, int answer)
+{
+ unsigned char data[]={0x9f,0x88,0x0B,0x01,0x00};
+ data[4] = answer & 0xff;
+ if (handler.send_to_mmisock( data, 5 ))
+ {
+ eDebug("eSocket_UI::answerMenu failed");
+ return -1;
+ }
+ return 0;
+}
+
+int eSocket_UI::answerEnq(int, char *answer)
+{
+ unsigned int len = strlen(answer);
+ unsigned char data[4+len+MAX_LENGTH_BYTES];
+ data[0] = 0x9f;
+ data[1] = 0x88;
+ data[2] = 0x08;
+ int LengthBytes=eDVBCISession::buildLengthField(data+3, len+1);
+ data[3+LengthBytes] = 0x01;
+ memcpy(data+4+LengthBytes, answer, len);
+ if (handler.send_to_mmisock( data, len+4+LengthBytes ))
+ {
+ eDebug("eSocket_UI::answerEnq failed");
+ return -1;
+ }
+ return 0;
+}
+
+int eSocket_UI::cancelEnq(int)
+{
+ unsigned char data[]={0x9f,0x88,0x08,0x01,0x00};
+ if (handler.send_to_mmisock( data, 5 ))
+ {
+ eDebug("eSocket_UI::cancelEnq failed");
+ return -1;
+ }
+ return 0;
+}
+
+int eSocket_UI::getState(int)
+{
+ return handler.connected() ? 2 : 0;
+}
+
+int eSocket_UI::getMMIState(int)
+{
+ return handler.connected();
+}
+
+//FIXME: correct "run/startlevel"
+eAutoInitP0<eSocket_UI> init_socketui(eAutoInitNumbers::rc, "Socket MMI");
+
+int eSocketMMIHandler::send_to_mmisock( void* buf, size_t len)
+{
+ int ret = write(connfd, buf, len);
+ if ( ret < 0 )
+ eDebug("[eSocketMMIHandler] write (%m)");
+ else if ( (uint)ret != len )
+ eDebug("[eSocketMMIHandler] only %d bytes sent.. %d bytes should be sent", ret, len );
+ else
+ return 0;
+ return ret;
+}
+
+eSocketMMIHandler::eSocketMMIHandler()
+ :buffer(512), connfd(-1), connsn(0), sockname("/tmp/mmi.socket"), name(0)
+{
+ memset(&servaddr, 0, sizeof(struct sockaddr_un));
+ servaddr.sun_family = AF_UNIX;
+ unlink(sockname);
+ strcpy(servaddr.sun_path, sockname);
+ clilen = sizeof(servaddr.sun_family) + strlen(servaddr.sun_path);
+ if ((listenfd = socket(AF_UNIX, SOCK_STREAM, 0)) < 0)
+ {
+ eDebug("[eSocketMMIHandler] socket (%m)");
+ return;
+ }
+
+ int val = 1;
+ if (setsockopt(listenfd, SOL_SOCKET, SO_REUSEADDR, &val, sizeof(val)) == -1)
+ eDebug("[eSocketMMIHandler] SO_REUSEADDR (%m)");
+ else if ((val = fcntl(listenfd, F_GETFL)) == -1)
+ eDebug("[eSocketMMIHandler] F_GETFL (%m)");
+ else if (fcntl(listenfd, F_SETFL, val | O_NONBLOCK) == -1)
+ eDebug("[eSocketMMIHandler] F_SETFL (%m)");
+ else if (bind(listenfd, (struct sockaddr *) &servaddr, clilen) == -1)
+ eDebug("[eSocketMMIHandler] bind (%m)");
+ else if (listen(listenfd, 0) == -1)
+ eDebug("[eSocketMMIHandler] listen (%m)");
+ else {
+ listensn = new eSocketNotifier( eApp, listenfd, POLLIN );
+ listensn->start();
+ CONNECT( listensn->activated, eSocketMMIHandler::listenDataAvail );
+ eDebug("[eSocketMMIHandler] created successfully");
+ return;
+ }
+
+ close(listenfd);
+ listenfd = -1;
+}
+
+#define CMD_SET_NAME "\x01\x02\x03\x04"
+
+void eSocketMMIHandler::listenDataAvail(int what)
+{
+ if (what & POLLIN) {
+ if ( connsn ) {
+ eDebug("[eSocketMMIHandler] connsn != NULL");
+ return;
+ }
+ connfd = accept(listenfd, (struct sockaddr *) &servaddr, (socklen_t *) &clilen);
+ if (connfd == -1) {
+ eDebug("[eSocketMMIHandler] accept (%m)");
+ return;
+ }
+
+ int val;
+ if ((val = fcntl(connfd, F_GETFL)) == -1)
+ eDebug("[eSocketMMIHandler] F_GETFL (%m)");
+ else if (fcntl(connfd, F_SETFL, val | O_NONBLOCK) == -1)
+ eDebug("[eSocketMMIHandler] F_SETFL (%m)");
+ else {
+ connsn = new eSocketNotifier( eApp, connfd, POLLIN|POLLHUP|POLLERR );
+ CONNECT( connsn->activated, eSocketMMIHandler::connDataAvail );
+ return;
+ }
+
+ close(connfd);
+ connfd = -1;
+ }
+}
+
+void eSocketMMIHandler::connDataAvail(int what)
+{
+ if (what & (POLLIN | POLLPRI | POLLRDNORM | POLLRDBAND)) {
+ char msgbuffer[4096];
+ ssize_t length = read(connfd, msgbuffer, sizeof(msgbuffer));
+
+ if (length == -1) {
+ if (errno != EAGAIN && errno != EINTR && errno != EBUSY) {
+ eDebug("[eSocketMMIHandler] read (%m)");
+ what |= POLLERR;
+ }
+ } else if (length == 0){
+ what |= POLLHUP;
+ } else if ((!name) && (length > 4) && (!memcmp(msgbuffer, CMD_SET_NAME, 4))) {
+ length -= 4;
+ delete [] name;
+ name = new char[length + 1];
+ memcpy(name, &msgbuffer[4], length);
+ name[length] = '\0';
+ eDebug("MMI NAME %s", name);
+ } else {
+ int len = length;
+ unsigned char *data = (unsigned char*)msgbuffer;
+ int clear = 1;
+ // If a new message starts, then the previous message
+ // should already have been processed. Otherwise the
+ // previous message was incomplete and should therefore
+ // be deleted.
+ if ((len >= 1) && (data[0] != 0x9f))
+ clear = 0;
+ if ((len >= 2) && (data[1] != 0x88))
+ clear = 0;
+ if (clear)
+ {
+ buffer.clear();
+#ifdef MMIDEBUG
+ eDebug("clear buffer");
+#endif
+ }
+#ifdef MMIDEBUG
+ eDebug("Put to buffer:");
+ for (int i=0; i < len; ++i)
+ eDebugNoNewLine("%02x ", data[i]);
+ eDebug("\n--------");
+#endif
+ buffer.write( data, len );
+
+ while ( buffer.size() >= (3 + MIN_LENGTH_BYTES) )
+ {
+ unsigned char tmp[3+MAX_LENGTH_BYTES];
+ buffer.peek(tmp, 3+MIN_LENGTH_BYTES);
+ if (tmp[0] != 0x9f || tmp[1] != 0x88)
+ {
+ buffer.skip(1);
+#ifdef MMIDEBUG
+ eDebug("skip %02x", tmp[0]);
+#endif
+ continue;
+ }
+ if (tmp[3] & 0x80) {
+ int peekLength = (tmp[3] & 0x7f) + 4;
+ if (buffer.size() < peekLength)
+ continue;
+ buffer.peek(tmp, peekLength);
+ }
+ int size=0;
+ int LengthBytes=eDVBCISession::parseLengthField(tmp+3, size);
+ int messageLength = 3+LengthBytes+size;
+ if ( buffer.size() >= messageLength )
+ {
+ unsigned char dest[messageLength];
+ buffer.read(dest, messageLength);
+#ifdef MMIDEBUG
+ eDebug("dump mmi:");
+ for (int i=0; i < messageLength; ++i)
+ eDebugNoNewLine("%02x ", dest[i]);
+ eDebug("\n--------");
+#endif
+ /*emit*/ mmi_progress(0, dest, (const void*)(dest+3+LengthBytes), messageLength-3-LengthBytes);
+ }
+ }
+ }
+ }
+
+ if (what & (POLLERR | POLLHUP)) {
+ eDebug("pollhup/pollerr");
+ closeConn();
+ /*emit*/ mmi_progress(0, (const unsigned char*)"\x9f\x88\x00", "\x00", 1);
+ }
+}
+
+void eSocketMMIHandler::closeConn()
+{
+ if ( connfd != -1 )
+ {
+ close(connfd);
+ connfd=-1;
+ }
+ if ( connsn )
+ {
+ delete connsn;
+ connsn=0;
+ }
+ if ( name )
+ {
+ delete [] name;
+ name=0;
+ }
+}
+
+eSocketMMIHandler::~eSocketMMIHandler()
+{
+ closeConn();
+ delete listensn;
+ unlink(sockname);
+}
+
+extern "C" {
+
+static PyObject *
+socketmmi_get_socket_state_changed_cb_list(PyObject *self)
+{
+ return eSocket_UI::getInstance()->socketStateChanged.get();
+}
+
+static PyObject *
+socketmmi_set_init(PyObject *self, PyObject *args)
+{
+ int slot;
+ if (PyTuple_Size(args) != 1 || !PyArg_ParseTuple(args, "i", &slot))
+ return NULL;
+ eSocket_UI::getInstance()->setInit(slot);
+ Py_RETURN_NONE;
+}
+
+static PyObject *
+socketmmi_set_reset(PyObject *self, PyObject *args)
+{
+ int slot;
+ if (PyTuple_Size(args) != 1 || !PyArg_ParseTuple(args, "i", &slot))
+ return NULL;
+ eSocket_UI::getInstance()->setReset(slot);
+ Py_RETURN_NONE;
+}
+
+static PyObject *
+socketmmi_available_mmi(PyObject *self, PyObject *args)
+{
+ int slot;
+ if (PyTuple_Size(args) != 1 || !PyArg_ParseTuple(args, "i", &slot))
+ return NULL;
+ return PyInt_FromLong(eSocket_UI::getInstance()->availableMMI(slot));
+}
+
+static PyObject *
+socketmmi_get_mmi_screen(PyObject *self, PyObject *args)
+{
+ int slot;
+ if (PyTuple_Size(args) != 1 || !PyArg_ParseTuple(args, "i", &slot))
+ return NULL;
+ return eSocket_UI::getInstance()->getMMIScreen(slot);
+}
+
+static PyObject *
+socketmmi_start_mmi(PyObject *self, PyObject *args)
+{
+ int slot;
+ if (PyTuple_Size(args) != 1 || !PyArg_ParseTuple(args, "i", &slot))
+ return NULL;
+ return PyInt_FromLong(eSocket_UI::getInstance()->startMMI(slot));
+}
+
+static PyObject *
+socketmmi_stop_mmi(PyObject *self, PyObject *args)
+{
+ int slot;
+ if (PyTuple_Size(args) != 1 || !PyArg_ParseTuple(args, "i", &slot))
+ return NULL;
+ return PyInt_FromLong(eSocket_UI::getInstance()->stopMMI(slot));
+}
+
+static PyObject *
+socketmmi_answer_menu(PyObject *self, PyObject *args)
+{
+ int slot, answer;
+ if (PyTuple_Size(args) != 2 || !PyArg_ParseTuple(args, "ii", &slot, &answer))
+ return NULL;
+ return PyInt_FromLong(eSocket_UI::getInstance()->answerMenu(slot, answer));
+}
+
+static PyObject *
+socketmmi_answer_enq(PyObject *self, PyObject *args)
+{
+ int slot;
+ char *answer;
+ if (PyTuple_Size(args) != 2 || !PyArg_ParseTuple(args, "is", &slot, &answer))
+ return NULL;
+ return PyInt_FromLong(eSocket_UI::getInstance()->answerEnq(slot, answer));
+}
+
+static PyObject *
+socketmmi_cancel_enq(PyObject *self, PyObject *args)
+{
+ int slot;
+ if (PyTuple_Size(args) != 1 || !PyArg_ParseTuple(args, "i", &slot))
+ return NULL;
+ return PyInt_FromLong(eSocket_UI::getInstance()->cancelEnq(slot));
+}
+
+static PyObject *
+socketmmi_get_state(PyObject *self, PyObject *args)
+{
+ int slot;
+ if (PyTuple_Size(args) != 1 || !PyArg_ParseTuple(args, "i", &slot))
+ return NULL;
+ return PyInt_FromLong(eSocket_UI::getInstance()->getState(slot));
+}
+
+static PyObject *
+socketmmi_get_mmi_state(PyObject *self, PyObject *args)
+{
+ int slot;
+ if (PyTuple_Size(args) != 1 || !PyArg_ParseTuple(args, "i", &slot))
+ return NULL;
+ return PyInt_FromLong(eSocket_UI::getInstance()->getMMIState(slot));
+}
+
+static PyObject *
+socketmmi_get_name(PyObject *self, PyObject *args)
+{
+ int slot;
+ if (PyTuple_Size(args) != 1 || !PyArg_ParseTuple(args, "i", &slot))
+ return NULL;
+ return PyString_FromString(eSocket_UI::getInstance()->getName(slot));
+}
+
+static PyMethodDef module_methods[] = {
+ {"getSocketStateChangedCallbackList", (PyCFunction)socketmmi_get_socket_state_changed_cb_list, METH_NOARGS,
+ "get socket state change callback list"
+ },
+ {"setInit", (PyCFunction)socketmmi_set_init, METH_VARARGS,
+ "set init"
+ },
+ {"setReset", (PyCFunction)socketmmi_set_reset, METH_VARARGS,
+ "set reset"
+ },
+ {"availableMMI", (PyCFunction)socketmmi_available_mmi, METH_VARARGS,
+ "available mmi"
+ },
+ {"getMMIScreen", (PyCFunction)socketmmi_get_mmi_screen, METH_VARARGS,
+ "get mmi screen"
+ },
+ {"startMMI", (PyCFunction)socketmmi_start_mmi, METH_VARARGS,
+ "start mmi"
+ },
+ {"stopMMI", (PyCFunction)socketmmi_stop_mmi, METH_VARARGS,
+ "start mmi"
+ },
+ {"answerMenu", (PyCFunction)socketmmi_answer_menu, METH_VARARGS,
+ "answer menu"
+ },
+ {"answerEnq", (PyCFunction)socketmmi_answer_enq, METH_VARARGS,
+ "answer enq"
+ },
+ {"cancelEnq", (PyCFunction)socketmmi_cancel_enq, METH_VARARGS,
+ "cancel enq"
+ },
+ {"getState", (PyCFunction)socketmmi_get_state, METH_VARARGS,
+ "get state of socket"
+ },
+ {"getMMIState", (PyCFunction)socketmmi_get_mmi_state, METH_VARARGS,
+ "get state of mmi"
+ },
+ {"getName", (PyCFunction)socketmmi_get_name, METH_VARARGS,
+ "get name of socket user"
+ },
+ {NULL, NULL, 0, NULL} /* Sentinel */
+};
+
+PyMODINIT_FUNC
+initsocketmmi(void)
+{
+ Py_InitModule3("socketmmi", module_methods,
+ "Module that implements mmi via unix domain socket.");
+}
+};
projects / vuplus_dvbapp / commitdiff