Javascript string array to QVariant in C++ API

[Bob64]

I have a C++ backend API in my QML application which contains a function that expects to receive an argument of differing basic types. It is currently defined as accepting a QVariant. (The function itself does not really care what the value type is as it passes it along to an RPC mechanism that converts the variant to a JSON string to make a remote call.)

Q_INVOKABLE void f(const QVariant& v) const;

This has worked so far, but I have just encountered a problem in trying to call this function from QML Javascript code in the case where the value is a JS string array:

var value = ["a"];
myApi.f(value);

In the Qt Creator debug environment, the value of the parameter shows as "<not accessible>". The debugger does seem to be aware that it should be a single element array but shows nothing for the [0] element. Higher up the call-stack, things get opaque but it looks like the argument is actually null (0x0).

Am I missing something about how array values are converted between Javascript and C++ in QML?

[ODБOï]

@Bob64 hi
can this page help ?

[Bob64]

Thanks for the suggestion, but I had already read that page and it seemed to support my expectation that this should just work. I forgot to mention that I am on 5.9.6 in case anything new had been added in this area in more recent releases.

I do have a small update in that, having been inspired by a mention of it in a StackOverflow article that I found, I tried messing about with using QJSValue on the C++ side and that does seem to provide a route for passing the string list value from Javascript to the C++ side. I am exploring doing something like this:

Q_INVOKABLE void f(const QVariant& v) const;
Q_INVOKABLE void f(const QJSValue& v) const;

where the second overload delegates to the first, using v.toVariant() as argument.

[GrecKo]

Are you sure it's not just just an issue with the debugger view?
It should work. What does qDebug() << v; outputs?

[Bob64]

Hi @GrecKo

No - I should have said, but I only started digging in the debugger because there was a genuine issue in my application.

I made a small example to test this (listed below). If I pass a simple string value ("Hello, World!") to my api function, the debug output is:

QVariant(QString, "Hello, World!")

If I pass an array, ["Hello, World!"], the output is:

QVariant(QJSValue, )

As mentioned earlier, I can work around this by adding an API function that accepts a QJSValue and then performing toVariant on it.

I also confirmed this behaviour in 5.12.1 (which I have installed but cannot use in production at the moment). I am surprised that I cannot find more discussion of this and still wonder if there is something I am missing.

api.h:

#pragma once
#include <QObject>
#include <QVariant>
class Api : public QObject
{
    Q_OBJECT
public:
    explicit Api(QObject *parent = nullptr);
    Q_INVOKABLE QString strVal(QVariant v);
};

main.cpp:

#include "api.h"

#include <QGuiApplication>
#include <QQmlApplicationEngine>
#include <QQmlContext>
#include <QtDebug>

Api::Api(QObject *parent) : QObject(parent) {}

QString Api::strVal(QVariant v) {
    qDebug() << v;
    return v.toString();
}

int main(int argc, char *argv[])
{
    QCoreApplication::setAttribute(Qt::AA_EnableHighDpiScaling);
    QGuiApplication app(argc, argv);
    QQmlApplicationEngine engine;

    Api api;
    auto context = engine.rootContext();
    context->setContextProperty("api", &api);

    const QUrl url(QStringLiteral("qrc:/main.qml"));
    engine.load(url);

    return app.exec();
}

main.qml:

import QtQuick 2.9
import QtQuick.Window 2.2
Window {
    visible: true; width: 640; height: 480
    title: api.strVal("Hello, World!")
}

[Bob64]

I'm giving this one a bump. I won't make a habit of doing this, but I was a little surprised that I didn't get more feedback on this one from some of the QML experts out there as it seems like quite a fundamental thing not to be working. Still keen to understand whether this is a bug in Qt, expected behaviour in Qt or something I am getting wrong.

[FKosmale]

I currently only have very recent versions of Qt at hand (5.14 and later), but there, the array gets treated correctly. Using

    if (v.canConvert<QJSValue>()) {
        auto jsval = v.value<QJSValue>();
        if (jsval.isArray()) {
            QString s = v.value<QJSValue>().property(0).toString();
            qDebug() << s;
            return s;
        }
    }
    return v.toString();

, I'll get the correct value.

[Bob64]

@FKosmale Thanks - maybe what I was missing was that we expected to see QJSValue involved here. I suppose I was expecting that a string list source would automatically have been converted to a QVariantList with QString elements and that is what I would have seen passed to the C++.

Certainly, if I understand it correctly, your solution is better than mine where I added an overload in the API to accept a QJSValue. At least the QJSValue is hidden in the implementation using your approach.