dm_collector_c and Message Parser¶

// Return: successful or not
static PyObject *
dm_collector_c_disable_logs (PyObject *self, PyObject *args) {
    IdVector empty;
    BinaryBuffer buf;
    PyObject *serial_port = NULL;
    if (!PyArg_ParseTuple(args, "O", &serial_port)) {
        return NULL;
    }
    Py_INCREF(serial_port);

    // Check arguments
    if (!check_serial_port(serial_port)) {
        PyErr_SetString(PyExc_TypeError, "\'port\' is not a serial port.");
        goto raise_exception;
    }

    buf = encode_log_config(DISABLE, empty);
    if (buf.first == NULL || buf.second == 0) {
        Py_DECREF(serial_port);
        Py_RETURN_FALSE;
    }
    (void) send_msg(serial_port, buf.first, buf.second);
    Py_DECREF(serial_port);
    delete [] buf.first;
    Py_RETURN_TRUE;

    raise_exception:
        Py_DECREF(serial_port);
        return NULL;
}

// Return: successful or not
static PyObject *
dm_collector_c_enable_logs (PyObject *self, PyObject *args) {
    PyObject *serial_port = NULL;
    PyObject *sequence = NULL;
    bool success = false;

    if (!PyArg_ParseTuple(args, "OO", &serial_port, &sequence)) {
        return NULL;
    }
    Py_INCREF(serial_port);
    Py_INCREF(sequence);

    // Check arguments
    if (!check_serial_port(serial_port)) {
        PyErr_SetString(PyExc_TypeError, "\'port\' is not a serial port.");
        goto raise_exception;
    }
    if (!PySequence_Check(sequence)) {
        PyErr_SetString(PyExc_TypeError, "\'type_names\' is not a sequence.");
        goto raise_exception;
    }

    success = generate_log_config_msgs(serial_port, sequence);
    if (!success) {
        goto raise_exception;
    }
    Py_DECREF(sequence);
    Py_DECREF(serial_port);
    Py_RETURN_TRUE;

    raise_exception:
        Py_DECREF(sequence);
        Py_DECREF(serial_port);
        return NULL;
}

// Return: successful or not
static PyObject *
dm_collector_c_generate_diag_cfg (PyObject *self, PyObject *args) {
    PyObject *file = NULL;
    PyObject *sequence = NULL;
    bool success = false;
    BinaryBuffer buf;
    IdVector empty;

    if (!PyArg_ParseTuple(args, "OO", &file, &sequence)) {
        return NULL;
    }
    Py_INCREF(file);
    Py_INCREF(sequence);

    // Check arguments
    if (!check_file(file)) {
        PyErr_SetString(PyExc_TypeError, "\'file\' is not a file object.");
        goto raise_exception;
    }
    if (!PySequence_Check(sequence)) {
        PyErr_SetString(PyExc_TypeError, "\'type_names\' is not a sequence.");
        goto raise_exception;
    }

    // Disable previous logs
    for (int k = 0; k < 2; k++) {
        if (k == 0) {   // Disable normal log msgs
            buf = encode_log_config(DISABLE, empty);
        } else {        // Disable debug msgs
            buf = encode_log_config(DISABLE_DEBUG, empty);
        }
        if (buf.first != NULL && buf.second != 0) {
            (void) send_msg(file, buf.first, buf.second);
            delete [] buf.first;
            buf.first = NULL;
        } else {
            PyErr_SetString(PyExc_RuntimeError, "Log config msg failed to encode.");
            goto raise_exception;
        }
    }

    success = generate_log_config_msgs(file, sequence);
    if (!success) {
        goto raise_exception;
    }
    Py_DECREF(sequence);
    Py_DECREF(file);
    Py_RETURN_TRUE;

    raise_exception:
        Py_DECREF(sequence);
        Py_DECREF(file);
        return NULL;
}

// Return: successful or not
static PyObject *
dm_collector_c_set_filtered_export (PyObject *self, PyObject *args) {
    const char *path;
    PyObject *sequence = NULL;
    IdVector type_ids;
    bool success = false;

    if (!PyArg_ParseTuple(args, "sO", &path, &sequence)) {
        return NULL;
    }
    Py_INCREF(sequence);

    // Check arguments
    if (!PySequence_Check(sequence)) {
        PyErr_SetString(PyExc_TypeError, "\'type_names\' is not a sequence.");
        goto raise_exception;
    }

    success = map_typenames_to_ids(sequence, type_ids);
    if (!success) {
        PyErr_SetString(PyExc_ValueError, "Wrong type name.");
        goto raise_exception;
    }
    Py_DECREF(sequence);

    manager_change_config(&g_emanager, path, type_ids);
    Py_RETURN_TRUE;

    raise_exception:
        Py_DECREF(sequence);
        return NULL;
}

// Return: successful or not
static PyObject *
dm_collector_c_set_filtered (PyObject *self, PyObject *args) {
    PyObject *sequence = NULL;
    IdVector type_ids;
    bool success = false;

    if (!PyArg_ParseTuple(args, "O", &sequence)) {
        return NULL;
    }
    Py_INCREF(sequence);

    // Check arguments
    if (!PySequence_Check(sequence)) {
        PyErr_SetString(PyExc_TypeError, "\'type_names\' is not a sequence.");
        goto raise_exception;
    }

    success = map_typenames_to_ids(sequence, type_ids);
    if (!success) {
        PyErr_SetString(PyExc_ValueError, "Wrong type name.");
        goto raise_exception;
    }
    Py_DECREF(sequence);

    manager_change_config(&g_emanager, NULL, type_ids);
    Py_RETURN_TRUE;

    raise_exception:
        Py_DECREF(sequence);
        return NULL;
}

// Return: None
static PyObject *
dm_collector_c_feed_binary (PyObject *self, PyObject *args) {
    const char *b;
    int length;
    if (!PyArg_ParseTuple(args, "s#", &b, &length)){
        // printf("dm_collector_c_feed_binary returns NULL\n");
        return NULL;
    }
    feed_binary(b, length);
    Py_RETURN_NONE;
}

static PyObject *
dm_collector_c_reset (PyObject *self, PyObject *args) {
    reset_binary();
    Py_RETURN_NONE;
}


// Return: decoded_list or None
static PyObject *
dm_collector_c_receive_log_packet (PyObject *self, PyObject *args) {
    std::string frame;
    bool crc_correct = false;
    bool skip_decoding = false, include_timestamp = false;  // default values
    PyObject *arg_skip_decoding = NULL;
    PyObject *arg_include_timestamp = NULL;
    if (!PyArg_ParseTuple(args, "|OO:receive_log_packet",
                                &arg_skip_decoding, &arg_include_timestamp))
        return NULL;
    if (arg_skip_decoding != NULL) {
        Py_INCREF(arg_skip_decoding);
        skip_decoding = (PyObject_IsTrue(arg_skip_decoding) == 1);
        Py_DECREF(arg_skip_decoding);
    }
    if (arg_include_timestamp != NULL) {
        Py_INCREF(arg_include_timestamp);
        include_timestamp = (PyObject_IsTrue(arg_include_timestamp) == 1);
        Py_DECREF(arg_include_timestamp);
    }
    // printf("skip_decoding=%d, include_timestamp=%d\n", skip_decoding, include_timestamp);
    double posix_timestamp = (include_timestamp? get_posix_timestamp(): -1.0);

    bool success = get_next_frame(frame, crc_correct);
    // printf("success=%d crc_correct=%d is_log_packet=%d\n", success, crc_correct, is_log_packet(frame.c_str(), frame.size()));
    // if (success && crc_correct && is_log_packet(frame.c_str(), frame.size())) {
    if (success && crc_correct) {
        // manager_export_binary(&g_emanager, frame.c_str(), frame.size());
        if (!manager_export_binary(&g_emanager, frame.c_str(), frame.size())) {
            Py_RETURN_NONE;
        }
        else if(is_log_packet(frame.c_str(), frame.size())){
            const char *s = frame.c_str();
            // printf("%x %x %x %x\n",s[0],s[1],s[2],s[3]);
            PyObject *decoded = decode_log_packet(  s + 2,  // skip first two bytes
                                                    frame.size() - 2,
                                                    skip_decoding);
            if (include_timestamp) {
                PyObject *ret = Py_BuildValue("(Od)", decoded, posix_timestamp);
                Py_DECREF(decoded);
                return ret;
            } else {
                return decoded;
            }

        }
        else if(is_debug_packet(frame.c_str(), frame.size())){
            //Yuanjie: the original debug msg does not have header...

            unsigned short n_size = frame.size()+sizeof(char)*14;

            char tmp[14]={
                0xFF, 0xFF,
                0x00, 0x00, 0xeb, 0x1f,
                0x00, 0x00, 0x73, 0xB7,
                0xB8, 0x65, 0xDD, 0x00
            };
            // tmp[2]=(char)(n_size);
            *(tmp+2)=n_size;
            *(tmp)=n_size;
            char *s = new char[n_size];
            memmove(s,tmp,sizeof(char)*14);
            memmove(s+sizeof(char)*14,frame.c_str(),frame.size());
            PyObject *decoded = decode_log_packet_modem(s, n_size, skip_decoding);

            // char *s = new char[n_size];
            // memset(s,0,sizeof(char)*n_size);
            // *s = n_size;
            // *(s+2) = n_size;
            // *(s+4) = 0xeb;
            // *(s+5) = 0x1f;
            // memmove(s+sizeof(char)*14,frame.c_str(),frame.size());
            // PyObject *decoded = decode_log_packet(s, n_size, skip_decoding);



            // // The following code does not crash on Android.
            // // But if use s and frame.size(), it crashes
            // const char *s = frame.c_str();
            // PyObject *decoded = decode_log_packet(  s + 2,  // skip first two bytes
            //                                         frame.size() - 2,
            //                                         skip_decoding);

            if (include_timestamp) {
                PyObject *ret = Py_BuildValue("(Od)", decoded, posix_timestamp);
                Py_DECREF(decoded);
                // delete [] s; //Yuanjie: bug for it on Android, but no problem on laptop
                return ret;
            } else {
                // delete [] s; //Yuanjie: bug for it on Android, but no problem on laptop
                return decoded;
            }
        }
        else {
            Py_RETURN_NONE;
        }

    } else {
        Py_RETURN_NONE;
    }
}

sudo python setup.py build_ext --inplace