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;
}
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;
}
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;
}
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;
}
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;
}
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;
}
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;
}
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));
}
}
}
