Example #1
0
bool QBBVirtualKeyboard::connect()
{
    close();

    mEncoder = new pps_encoder_t;
    mDecoder = new pps_decoder_t;

    pps_encoder_initialize(mEncoder, false);
    pps_decoder_initialize(mDecoder, NULL);

    errno = 0;
    mFd = ::open(sPPSPath, O_RDWR);
    if (mFd == -1)
    {
        qCritical("QBBVirtualKeyboard: Unable to open \"%s\" for keyboard: %s (%d).",
                sPPSPath, strerror(errno), errno);
        close();
        return false;
    }

    mBuffer = new char[sBufferSize];
    if (!mBuffer) {
        qCritical("QBBVirtualKeyboard: Unable to allocate buffer of %d bytes. Size is unavailable.",  sBufferSize);
        return false;
    }

    if (!queryPPSInfo())
        return false;

    start();

    return true;
}
bool QQnxVirtualKeyboardPps::connect()
{
    close();

    m_encoder = new pps_encoder_t;
    m_decoder = new pps_decoder_t;

    pps_encoder_initialize(m_encoder, false);
    pps_decoder_initialize(m_decoder, 0);

    errno = 0;
    m_fd = ::open(ms_PPSPath, O_RDWR);
    if (m_fd == -1)
    {
        qCritical("QQnxVirtualKeyboard: Unable to open \"%s\" for keyboard: %s (%d).",
                ms_PPSPath, strerror(errno), errno);
        close();
        return false;
    }

    m_buffer = new char[ms_bufferSize];
    if (!m_buffer) {
        qCritical("QQnxVirtualKeyboard: Unable to allocate buffer of %d bytes. Size is unavailable.",  ms_bufferSize);
        return false;
    }

    if (!queryPPSInfo())
        return false;

    m_readNotifier = new QSocketNotifier(m_fd, QSocketNotifier::Read);
    QObject::connect(m_readNotifier, SIGNAL(activated(int)), this, SLOT(ppsDataReady()));

    return true;
}
Example #3
0
QByteArray QBBSystemLocaleData::readPpsValue(const char *ppsObject, int ppsFd)
{
    QByteArray result;
    if (!ppsObject || ppsFd == -1)
        return result;

    char buffer[ppsBufferSize];

    int bytes = qt_safe_read(ppsFd, buffer, ppsBufferSize - 1);
    if (bytes == -1) {
        qWarning("Failed to read Locale pps, errno=%d", errno);
        return result;
    }
    // ensure data is null terminated
    buffer[bytes] = '\0';

    pps_decoder_t ppsDecoder;
    pps_decoder_initialize(&ppsDecoder, 0);
    if (pps_decoder_parse_pps_str(&ppsDecoder, buffer) == PPS_DECODER_OK) {
        pps_decoder_push(&ppsDecoder, 0);
        const char *ppsBuff;
        if (pps_decoder_get_string(&ppsDecoder, ppsObject, &ppsBuff) == PPS_DECODER_OK) {
            result = ppsBuff;
        } else {
            int val;
            if (pps_decoder_get_int(&ppsDecoder, ppsObject, &val) == PPS_DECODER_OK)
                result = QByteArray::number(val);
        }
    }

    pps_decoder_cleanup(&ppsDecoder);

    return result;
}
Example #4
0
void QBBLocaleData::updateMesurementSystem()
{
    char buffer[ppsBufferSize];

    errno = 0;
    int bytes = qt_safe_read(ppsFd, buffer, ppsBufferSize - 1);
    if (bytes == -1) {
        qWarning("Failed to read Locale pps, errno=%d", errno);
        return;
    }
    // ensure data is null terminated
    buffer[bytes] = '\0';

    pps_decoder_t ppsDecoder;
    pps_decoder_initialize(&ppsDecoder, 0);
    if (pps_decoder_parse_pps_str(&ppsDecoder, buffer) == PPS_DECODER_OK) {
        pps_decoder_push(&ppsDecoder, 0);
        const char *measurementBuff;
        if (pps_decoder_get_string(&ppsDecoder, "uom", &measurementBuff) == PPS_DECODER_OK) {
            if (qstrcmp(measurementBuff, "imperial") == 0) {
                pps_decoder_cleanup(&ppsDecoder);
                ppsMeasurement = QLocale::ImperialSystem;
                return;
            }
        }
    }

    pps_decoder_cleanup(&ppsDecoder);
    ppsMeasurement = QLocale::MetricSystem;
}
Example #5
0
QByteArray QBBSystemLocaleData::readPpsValue(const char *ppsObject, int ppsFd)
{
    QByteArray result;
    if (!ppsObject || ppsFd == -1)
        return result;


    // PPS objects are of unknown size, but must be read all at once.
    // Relying on the file size may not be a good idea since the size may change before reading.
    // Let's try with an initial size (512), and if the buffer is too small try with bigger one,
    // until we succeed or until other non buffer-size-related error occurs.
    // Using QVarLengthArray means the first try (of size == 512) uses a buffer on the stack - no allocation necessary.
     // Hopefully that covers most use cases.
    int bytes;
    QVarLengthArray<char, 512> buffer;
    for (;;) {
        errno = 0;
        bytes = qt_safe_read(ppsFd, buffer.data(), buffer.capacity() - 1);
        const bool bufferIsTooSmall = (bytes == -1 && errno == EMSGSIZE && buffer.capacity() < MAX_PPS_SIZE);
        if (!bufferIsTooSmall)
            break;

        buffer.resize(qMin(buffer.capacity()*2, MAX_PPS_SIZE));
    }

    // This method is called in the ctor(), so do not use qWarning to log warnings
    // if qt_safe_read fails to read the pps file
    // since the user code may install a message handler that invokes QLocale API again
    // (i.e QDate, QDateTime, ...) which will cause a infinite loop.
    if (bytes == -1) {
        fprintf(stderr, "Failed to read pps object:%s, errno=%d\n", ppsObject, errno);
        return result;
    }
    // ensure data is null terminated
    buffer[bytes] = '\0';

    pps_decoder_t ppsDecoder;
    pps_decoder_initialize(&ppsDecoder, 0);
    if (pps_decoder_parse_pps_str(&ppsDecoder, buffer.data()) == PPS_DECODER_OK) {
        pps_decoder_push(&ppsDecoder, 0);
        const char *ppsBuff;
        if (pps_decoder_get_string(&ppsDecoder, ppsObject, &ppsBuff) == PPS_DECODER_OK) {
            result = ppsBuff;
        } else {
            int val;
            if (pps_decoder_get_int(&ppsDecoder, ppsObject, &val) == PPS_DECODER_OK)
                result = QByteArray::number(val);
        }
    }

    pps_decoder_cleanup(&ppsDecoder);

    return result;
}
Example #6
0
QVariant ppsReadSetting(const char *property)
{
    int settingsFD;
    char buf[ppsBufferSize];
    if ((settingsFD = qt_safe_open(btSettingsFDPath, O_RDONLY)) == -1) {
        qCWarning(QT_BT_QNX) << Q_FUNC_INFO << "failed to open "<< btSettingsFDPath;
        return QVariant();
    }

    QVariant result;

    qt_safe_read( settingsFD, &buf, sizeof(buf));
    pps_decoder_t decoder;
    pps_decoder_initialize(&decoder, 0);

    if (pps_decoder_parse_pps_str(&decoder, buf) == PPS_DECODER_OK) {
        pps_decoder_push(&decoder, 0);
        pps_node_type_t nodeType = pps_decoder_type(&decoder, property);
        if (nodeType == PPS_TYPE_STRING) {
            const char *dat;
            if (pps_decoder_get_string(&decoder, property, &dat) == PPS_DECODER_OK) {
                result = QString::fromUtf8(dat);
                qCDebug(QT_BT_QNX) << "Read setting" << result;
            } else {
                qCWarning(QT_BT_QNX) << Q_FUNC_INFO << "could not read"<< property;
                return QVariant();
            }
        } else if (nodeType == PPS_TYPE_BOOL) {
            bool dat;
            if (pps_decoder_get_bool(&decoder, property, &dat) == PPS_DECODER_OK) {
                result = dat;
                qCDebug(QT_BT_QNX) << "Read setting" << result;
            } else {
                qCWarning(QT_BT_QNX) << Q_FUNC_INFO << "could not read"<< property;
                return QVariant();
            }
        } else if (nodeType == PPS_TYPE_NUMBER) {
            int dat;
            if (pps_decoder_get_int(&decoder, property, &dat) == PPS_DECODER_OK) {
                result = dat;
                qCDebug(QT_BT_QNX) << "Read setting" << result;
            } else {
                qCWarning(QT_BT_QNX) << Q_FUNC_INFO << "could not read"<< property;
                return QVariant();
            }
        } else {
            qCDebug(QT_BT_QNX) << Q_FUNC_INFO << "unrecognized entry for settings";
        }
    }
    pps_decoder_cleanup(&decoder);
    qt_safe_close(settingsFD);
    return result;
}
Example #7
0
QPpsAttributeMap QPpsObjectPrivate::decode(const QByteArray &rawData, bool *ok)
{
    QPpsAttributeMap attributeMap;
    pps_decoder_t decoder;

    QByteArray mutableData(rawData);
    pps_decoder_error_t error = pps_decoder_initialize(&decoder, mutableData.data());
    if (error == PPS_DECODER_OK) {
        // no need to check ok in this case
        attributeMap = decodeObject(&decoder, ok);
    } else {
        qWarning() << "QPpsObjectPrivate::decode: pps_decoder_initialize failed";
        *ok = false;
    }

    pps_decoder_cleanup(&decoder);
    return attributeMap;
}
QBluetoothLocalDevice::Pairing QBluetoothLocalDevice::pairingStatus(
    const QBluetoothAddress &address) const
{
    if (!isValid())
        return Unpaired;
    bool paired = false;
    bool btle = false; // Bluetooth Low Energy devices
    QByteArray qnxPath("/pps/services/bluetooth/remote_devices/");
    qnxPath.append(address.toString().toUtf8());
    int m_rdfd;
    if ((m_rdfd = qt_safe_open(qnxPath.constData(), O_RDONLY)) == -1) {
        btle = true;
        qnxPath.append("-00");
        if ((m_rdfd = qt_safe_open(qnxPath.constData(), O_RDONLY)) == -1) {
            qnxPath.replace((qnxPath.length()-3), 3, "-01");
            if ((m_rdfd = qt_safe_open(qnxPath.constData(), O_RDONLY)) == -1)
                return Unpaired;
        }
    }

    pps_decoder_t ppsDecoder;
    pps_decoder_initialize(&ppsDecoder, NULL);

    QBluetoothAddress deviceAddr;
    QString deviceName;

    if (!ppsReadRemoteDevice(m_rdfd, &ppsDecoder, &deviceAddr, &deviceName))
        return Unpaired;
    bool known = false;
    // Paired BTLE devices have only known field set to true.
    if (btle)
        pps_decoder_get_bool(&ppsDecoder, "known", &known);
    pps_decoder_get_bool(&ppsDecoder, "paired", &paired);
    pps_decoder_cleanup(&ppsDecoder);

    if (paired)
        return Paired;
    else if (btle && known)
        return Paired;
    else
        return Unpaired;
}
QList<QBluetoothAddress> QBluetoothLocalDevice::connectedDevices() const
{
    QList<QBluetoothAddress> devices;
    QDir bluetoothDevices(QStringLiteral("/pps/services/bluetooth/remote_devices/"));
    QStringList allFiles = bluetoothDevices.entryList(QDir::NoDotAndDotDot| QDir::Files);
    for (int i = 0; i < allFiles.size(); i++) {
        qCDebug(QT_BT_QNX) << allFiles.at(i);
        int fileId;
        const char *filePath = QByteArray("/pps/services/bluetooth/remote_devices/").append(allFiles.at(
                                                                                                i).toUtf8().constData())
                               .constData();
        if ((fileId = qt_safe_open(filePath, O_RDONLY)) == -1) {
            qCWarning(QT_BT_QNX) << "Failed to open remote device file";
        } else {
            pps_decoder_t ppsDecoder;
            pps_decoder_initialize(&ppsDecoder, 0);

            QBluetoothAddress deviceAddr;
            QString deviceName;

            if (!ppsReadRemoteDevice(fileId, &ppsDecoder, &deviceAddr, &deviceName)) {
                pps_decoder_cleanup(&ppsDecoder);
                qDebug() << "Failed to open remote device file";
            }

            bool connectedDevice = false;
            int a = pps_decoder_get_bool(&ppsDecoder, "acl_connected", &connectedDevice);
            if (a == PPS_DECODER_OK) {
                if (connectedDevice)
                    devices.append(deviceAddr);
            } else if (a == PPS_DECODER_BAD_TYPE) {
                qCDebug(QT_BT_QNX) << "Type missmatch";
            } else {
                qCDebug(QT_BT_QNX) << "An unknown error occurred while checking connected status.";
            }
            pps_decoder_cleanup(&ppsDecoder);
        }
    }

    return devices;
}
Example #10
0
QVariant ppsRemoteDeviceStatus(const QByteArray &address, const char *property)
{
    int rmFD;
    char buf[ppsBufferSize];
    QByteArray filename = btRemoteDevFDPath;
    filename.append(address);

    if ((rmFD = qt_safe_open(filename.constData(), O_RDONLY)) < 0) {
        qCWarning(QT_BT_QNX) << Q_FUNC_INFO << "failed to open "<< btRemoteDevFDPath << address;
        return false;
    }

    QVariant res;

    qt_safe_read(rmFD, &buf, sizeof(buf));
    pps_decoder_t ppsDecoder;
    pps_decoder_initialize(&ppsDecoder, 0);
    if (pps_decoder_parse_pps_str(&ppsDecoder, buf) == PPS_DECODER_OK) {
        pps_decoder_push(&ppsDecoder, 0);

        //Find out about the node type
        pps_node_type_t nodeType = pps_decoder_type(&ppsDecoder, property);
        if (nodeType == PPS_TYPE_STRING) {
            const char *dat;
            pps_decoder_get_string(&ppsDecoder,property,&dat);
            res = QString::fromUtf8(dat);
        } else if (nodeType == PPS_TYPE_BOOL) {
            bool dat;
            pps_decoder_get_bool(&ppsDecoder,property,&dat);
            res = QVariant(dat);
        } else {
            qCDebug(QT_BT_QNX) << "RDStatus: No node type" << property;
        }
    }
    pps_decoder_cleanup(&ppsDecoder);
    qt_safe_close(rmFD);
    return res;
}
static QNetworkConfiguration::BearerType cellularStatus()
{
    QNetworkConfiguration::BearerType ret = QNetworkConfiguration::BearerUnknown;

    int cellularStatusFD;
    if ((cellularStatusFD = qt_safe_open(cellularStatusFile, O_RDONLY)) == -1) {
        qWarning() << "failed to open" << cellularStatusFile;
        return ret;
    }
    char buf[2048];
    if (qt_safe_read(cellularStatusFD, &buf, sizeof(buf)) == -1) {
        qWarning() << "read from PPS file failed:" << strerror(errno);
        qt_safe_close(cellularStatusFD);
        return ret;
    }
    pps_decoder_t ppsDecoder;
    if (pps_decoder_initialize(&ppsDecoder, buf) != PPS_DECODER_OK) {
        qWarning("failed to initialize PPS decoder");
        qt_safe_close(cellularStatusFD);
        return ret;
    }
    pps_decoder_error_t err;
    if ((err = pps_decoder_push(&ppsDecoder, 0)) != PPS_DECODER_OK) {
        qWarning() << "pps_decoder_push failed" << err;
        pps_decoder_cleanup(&ppsDecoder);
        qt_safe_close(cellularStatusFD);
        return ret;
    }
    if (!pps_decoder_is_integer(&ppsDecoder, "network_technology")) {
        qWarning("field has not the expected data type");
        pps_decoder_cleanup(&ppsDecoder);
        qt_safe_close(cellularStatusFD);
        return ret;
    }
    int type;
    if (!pps_decoder_get_int(&ppsDecoder, "network_technology", &type)
            == PPS_DECODER_OK) {
        qWarning("could not read bearer type from PPS");
        pps_decoder_cleanup(&ppsDecoder);
        qt_safe_close(cellularStatusFD);
        return ret;
    }
    switch (type) {
    case 0: // 0 == NONE
        break; // unhandled
    case 1: // fallthrough, 1 == GSM
    case 4: // 4 == CDMA_1X
        ret = QNetworkConfiguration::Bearer2G;
        break;
    case 2: // 2 == UMTS
        ret = QNetworkConfiguration::BearerWCDMA;
        break;
    case 8: // 8 == EVDO
        ret = QNetworkConfiguration::BearerEVDO;
        break;
    case 16: // 16 == LTE
        ret = QNetworkConfiguration::BearerLTE;
        break;
    default:
        qWarning() << "unhandled bearer type" << type;
        break;
    }
    pps_decoder_cleanup(&ppsDecoder);
    qt_safe_close(cellularStatusFD);
    return ret;
}
Example #12
0
void ppsDecodeControlResponse()
{
    ppsResult result;
    ResultType resType = UNKNOWN;

    if (ppsCtrlFD != -1) {
        char buf[ppsBufferSize];
        qt_safe_read(ppsCtrlFD, &buf, sizeof(buf) );
        if (buf[0] != '@')
            return;
        qCDebug(QT_BT_QNX) << "CTRL Response" << buf;

        pps_decoder_t ppsDecoder;
        pps_decoder_initialize(&ppsDecoder, 0);
        if (pps_decoder_parse_pps_str(&ppsDecoder, buf) == PPS_DECODER_OK) {
            pps_decoder_push(&ppsDecoder, 0);
            const char *buf;

            //The pps response can either be of type 'res', 'msg' or 'evt'
            if (pps_decoder_get_string(&ppsDecoder, "res", &buf) == PPS_DECODER_OK) {
                result.msg = QString::fromUtf8(buf);
                resType = RESPONSE;
            } else if (pps_decoder_get_string(&ppsDecoder, "msg", &buf) == PPS_DECODER_OK) {
                result.msg = QString::fromUtf8(buf);
                resType = MESSAGE;
            } else if (pps_decoder_get_string(&ppsDecoder, "evt", &buf) == PPS_DECODER_OK) {
                result.msg = QString::fromUtf8(buf);
                resType = EVENT;
            }

            if (pps_decoder_get_string(&ppsDecoder, "id",  &buf) == PPS_DECODER_OK)
                result.id = QString::fromUtf8(buf).toInt();

            //read out the error message if there is one
            if (pps_decoder_get_string(&ppsDecoder, "errstr", &buf) == PPS_DECODER_OK)
                result.errorMsg = QString::fromUtf8(buf);

            int dat;
            if (pps_decoder_get_int(&ppsDecoder, "err", &dat) == PPS_DECODER_OK) {
                result.error = dat;
            }

            //The dat object can be either a string or a array
            pps_node_type_t nodeType = pps_decoder_type(&ppsDecoder,"dat");
            if (nodeType == PPS_TYPE_STRING) {
                pps_decoder_get_string(&ppsDecoder,"dat",&buf);
                result.dat << QString::fromUtf8(buf);
            } else if (nodeType == PPS_TYPE_OBJECT || nodeType == PPS_TYPE_ARRAY) {
                pps_decoder_push(&ppsDecoder,"dat");
                pps_decoder_goto_index(&ppsDecoder, 0);
                int len = pps_decoder_length(&ppsDecoder);

                for (int i = 0; i < len; ++i) {
                    switch ( pps_decoder_type(&ppsDecoder, 0)) {
                    case PPS_TYPE_STRING:
                         result.dat << QString::fromUtf8(pps_decoder_name(&ppsDecoder));
                         pps_decoder_get_string(&ppsDecoder, 0, &buf);
                         result.dat << QString::fromUtf8(buf);
                         break;
                     case PPS_TYPE_NUMBER:
                         result.dat << QString::fromUtf8(pps_decoder_name(&ppsDecoder));
                         double dvalue;
                         pps_decoder_get_double(&ppsDecoder, 0, &dvalue);
                         result.dat << QString::number(dvalue);
                         break;
                     default:
                         pps_decoder_next(&ppsDecoder);
                     }
                 }
            } else {
                qCDebug(QT_BT_QNX) << "Control Response: No node type" << result.msg;
            }
        }
        pps_decoder_cleanup(&ppsDecoder);
    }

    if (result.msg == QStringLiteral("radio_init")) {
        qCDebug(QT_BT_QNX) << "Radio initialized";
    } else if (result.msg == QStringLiteral("access_changed") && __newHostMode != -1) {
        qCDebug(QT_BT_QNX) << "Access changed after radio init";
        ppsSendControlMessage("set_access", QStringLiteral("{\"access\":%1}").arg(__newHostMode), 0);
        __newHostMode = -1;
    }

    if (resType == RESPONSE) {
        QPair<int, QObject*> wMessage = takeObjectInWList(result.id);
        if (wMessage.second != 0)
            wMessage.second->metaObject()->invokeMethod(wMessage.second, "controlReply", Q_ARG(ppsResult, result));
    } else if (resType == EVENT) {
        //qCDebug(QT_BT_QNX) << "Distributing event" << result.msg;
        for (int i=0; i < evtRegistration.size(); i++) {
            if (result.msg == evtRegistration.at(i).first)
                evtRegistration.at(i).second->metaObject()->invokeMethod(evtRegistration.at(i).second, "controlEvent", Q_ARG(ppsResult, result));
        }
    }
}