bool ppsSendControlMessage(const char *msg, int service, const QBluetoothUuid &uuid, const QString &address, const QString &serviceName, QObject *sender, const int &subtype) { pps_encoder_t *encoder = beginCtrlMessage(msg, sender); pps_encoder_start_object(encoder, "dat"); pps_encoder_add_int(encoder, "service", service); if (subtype != -1) pps_encoder_add_int(encoder, "subtype", subtype); pps_encoder_add_string(encoder, "uuid", uuid.toString().mid(1,36).toUtf8().constData()); if (!serviceName.isEmpty()) { pps_encoder_add_string(encoder, "name", serviceName.toUtf8().constData()); } if (!address.isEmpty()) { pps_encoder_add_string(encoder, "addr", address.toUtf8().constData()); } pps_encoder_error_t rese = pps_encoder_end_object(encoder); if (rese != PPS_ENCODER_OK) { errno = EPERM; return false; } return endCtrlMessage(encoder); }
pps_encoder_t *beginCtrlMessage(const char *msg, QObject *sender) { pps_encoder_t *encoder= new pps_encoder_t; pps_encoder_initialize(encoder, 0); pps_encoder_add_string(encoder, "msg", msg); ctrlId++; pps_encoder_add_string(encoder, "id", QString::number(ctrlId).toStdString().c_str() ); waitingCtrlMsgs.append(QPair<int, QObject*>(ctrlId, sender)); return encoder; }
bool QQnxVirtualKeyboardPps::queryPPSInfo() { if (!prepareToSend()) return false; // Request info, requires id to regenerate res message. pps_encoder_add_string(m_encoder, "msg", "info"); pps_encoder_add_string(m_encoder, "id", "libWebView"); return writeCurrentPPSEncoder(); }
void ppsSendOpp(const char *msg, const QByteArray &url, const QBluetoothAddress &address, QObject *sender) { pps_encoder_t *encoder = beginCtrlMessage(msg, sender); pps_encoder_start_object(encoder, "dat"); pps_encoder_add_string(encoder, "address", address.toString().toUtf8().constData()); pps_encoder_start_array(encoder, "urls"); pps_encoder_add_string(encoder, 0, url.constData()); pps_encoder_end_array(encoder); pps_encoder_end_object(encoder); endCtrlMessage(encoder); }
bool QBBVirtualKeyboard::queryPPSInfo() { // Request info, requires id to regenerate res message. pps_encoder_add_string(mEncoder, "msg", "info"); pps_encoder_add_string(mEncoder, "id", "libWebView"); if (::write(mFd, pps_encoder_buffer(mEncoder), pps_encoder_length(mEncoder)) == -1) { close(); return false; } pps_encoder_reset(mEncoder); return true; }
bool QQnxVirtualKeyboardPps::hideKeyboard() { qVirtualKeyboardDebug() << Q_FUNC_INFO; if (m_fd == -1 && !connect()) return false; pps_encoder_add_string(m_encoder, "msg", "hide"); if (::write(m_fd, pps_encoder_buffer(m_encoder), pps_encoder_length(m_encoder)) == -1) { close(); //Try again. if (connect()) { if (::write(m_fd, pps_encoder_buffer(m_encoder), pps_encoder_length(m_encoder)) == -1) { close(); return false; } } else return false; } pps_encoder_reset(m_encoder); // Return true if no error occurs. Sizing response will be triggered when confirmation of // the change arrives. return true; }
bool QBBVirtualKeyboard::hideKeyboard() { #ifdef QBBVIRTUALKEYBOARD_DEBUG qDebug() << "QBB: hideKeyboard()"; #endif if(mFd == -1 && !connect()) return false; pps_encoder_add_string(mEncoder, "msg", "hide"); if (::write(mFd, pps_encoder_buffer(mEncoder), pps_encoder_length(mEncoder)) == -1) { close(); //Try again. if(connect()) { if (::write(mFd, pps_encoder_buffer(mEncoder), pps_encoder_length(mEncoder)) == -1) { close(); return false; } } else return false; } pps_encoder_reset(mEncoder); // Return true if no error occurs. Sizing response will be triggered when confirmation of // the change arrives. return true; }
bool QQnxVirtualKeyboardPps::showKeyboard() { qVirtualKeyboardDebug() << Q_FUNC_INFO; // Try to connect. if (m_fd == -1 && !connect()) return false; // NOTE: This must be done everytime the keyboard is shown even if there is no change because // hiding the keyboard wipes the setting. applyKeyboardModeOptions(keyboardMode()); if (isVisible()) return true; pps_encoder_reset(m_encoder); // Send the show message. pps_encoder_add_string(m_encoder, "msg", "show"); if (::write(m_fd, pps_encoder_buffer(m_encoder), pps_encoder_length(m_encoder)) == -1) { close(); return false; } pps_encoder_reset(m_encoder); // Return true if no error occurs. Sizing response will be triggered when confirmation of // the change arrives. return true; }
bool QBBVirtualKeyboard::showKeyboard() { #ifdef QBBVIRTUALKEYBOARD_DEBUG qDebug() << "QBB: showKeyboard()"; #endif // Try to connect. if (mFd == -1 && !connect()) return false; // NOTE: This must be done everytime the keyboard is shown even if there is no change because // hiding the keyboard wipes the setting. applyKeyboardModeOptions(); pps_encoder_reset(mEncoder); // Send the show message. pps_encoder_add_string(mEncoder, "msg", "show"); if (::write(mFd, pps_encoder_buffer(mEncoder), pps_encoder_length(mEncoder)) == -1) { close(); return false; } pps_encoder_reset(mEncoder); // Return true if no error occurs. Sizing response will be triggered when confirmation of // the change arrives. return true; }
void QQnxVirtualKeyboardPps::applyKeyboardOptions() { if (!prepareToSend()) return; // Send the options message. pps_encoder_add_string(m_encoder, "msg", "options"); pps_encoder_start_object(m_encoder, "dat"); pps_encoder_add_string(m_encoder, "enter", enterKeyTypeStr()); pps_encoder_add_string(m_encoder, "type", keyboardModeStr()); pps_encoder_end_object(m_encoder); writeCurrentPPSEncoder(); }
bool QQnxVirtualKeyboardPps::hideKeyboard() { qVirtualKeyboardDebug() << Q_FUNC_INFO; if (!prepareToSend()) return false; pps_encoder_add_string(m_encoder, "msg", "hide"); return writeCurrentPPSEncoder(); }
void QBBVirtualKeyboard::applyKeyboardModeOptions() { // Try to connect. if(mFd == -1 && !connect()) return; // Send the options message. pps_encoder_add_string(mEncoder, "msg", "options"); pps_encoder_start_object(mEncoder, "dat"); switch (mKeyboardMode) { case Url: addUrlModeOptions(); break; case Email: addEmailModeOptions(); break; case Web: addWebModeOptions(); break; case NumPunc: addNumPuncModeOptions(); break; case Symbol: addSymbolModeOptions(); break; case Phone: addPhoneModeOptions(); break; case Pin: addPinModeOptions(); break; case Default: default: addDefaultModeOptions(); break; } pps_encoder_end_object(mEncoder); if (::write(mFd, pps_encoder_buffer(mEncoder), pps_encoder_length(mEncoder)) == -1) { close(); } pps_encoder_reset(mEncoder); }
bool QQnxVirtualKeyboardPps::showKeyboard() { qVirtualKeyboardDebug() << Q_FUNC_INFO; if (!prepareToSend()) return false; // NOTE: This must be done everytime the keyboard is shown even if there is no change because // hiding the keyboard wipes the setting. applyKeyboardOptions(); if (isVisible()) return true; pps_encoder_reset(m_encoder); // Send the show message. pps_encoder_add_string(m_encoder, "msg", "show"); return writeCurrentPPSEncoder(); }
void QBBVirtualKeyboard::addSymbolModeOptions() { pps_encoder_add_string(mEncoder, "enter", "enter.default"); pps_encoder_add_string(mEncoder, "type", "symbol"); }
void QBBVirtualKeyboard::addPhoneModeOptions() { pps_encoder_add_string(mEncoder, "enter", "enter.default"); pps_encoder_add_string(mEncoder, "type", "phone"); }
void QBBVirtualKeyboard::addNumPuncModeOptions() { pps_encoder_add_string(mEncoder, "enter", "enter.default"); pps_encoder_add_string(mEncoder, "type", "numPunc"); }
void QPpsObjectPrivate::encodeData(pps_encoder_t *encoder, const char *name, const QVariant &data, bool *ok) { QString errorFunction; pps_encoder_error_t error = PPS_ENCODER_OK; switch (data.type()) { case QVariant::Bool: error = pps_encoder_add_bool(encoder, name, data.toBool()); errorFunction = QStringLiteral("pps_encoder_add_bool"); break; // We want to support encoding uint even though libpps doesn't support it directly. // We can't encode uint as an int since that will lose precision (e.g. 2^31+1 can't be // encoded that way). However, we can convert uint to double without losing precision. // QVariant.toDouble() conveniently takes care of the conversion for us. case QVariant::UInt: case QVariant::Double: error = pps_encoder_add_double(encoder, name, data.toDouble()); errorFunction = QStringLiteral("pps_encoder_add_double"); break; case QVariant::Int: error = pps_encoder_add_int(encoder, name, data.toInt()); errorFunction = QStringLiteral("pps_encoder_add_int"); break; case QVariant::LongLong: error = pps_encoder_add_int64(encoder, name, data.toLongLong()); errorFunction = QStringLiteral("pps_encoder_add_int64"); break; case QVariant::String: error = pps_encoder_add_string(encoder, name, data.toString().toUtf8().constData()); errorFunction = QStringLiteral("pps_encoder_add_string"); break; case QVariant::List: error = pps_encoder_start_array(encoder, name); errorFunction = QStringLiteral("pps_encoder_start_array"); if (error == PPS_ENCODER_OK) { encodeArray(encoder, data.toList(), ok); error = pps_encoder_end_array(encoder); errorFunction = QStringLiteral("pps_encoder_end_array"); } break; case QVariant::Map: error = pps_encoder_start_object(encoder, name); errorFunction = QStringLiteral("pps_encoder_start_object"); if (error == PPS_ENCODER_OK) { encodeObject(encoder, data.toMap(), ok); error = pps_encoder_end_object(encoder); errorFunction = QStringLiteral("pps_encoder_end_object"); } break; case QVariant::Invalid: error = pps_encoder_add_null(encoder, name); errorFunction = QStringLiteral("pps_encoder_add_null"); break; default: qWarning() << "QPpsObjectPrivate::encodeData: the type of the parameter data is invalid"; *ok = false; return; } if (error != PPS_ENCODER_OK) { qWarning() << "QPpsObjectPrivate::encodeData: " << errorFunction << " failed"; *ok = false; } else { *ok = true; } }
void QQnxVirtualKeyboardPps::addPinModeOptions() { pps_encoder_add_string(m_encoder, "enter", "enter.default"); pps_encoder_add_string(m_encoder, "type", "pin"); }