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