QByteArray visto come una stringa in Javascript tramite QWebChannel

Question

Migrazione da QtWebKit a QtWebEngine, utilizzando QWebChannel.

Ho una funzione invokable che invia un oggetto QVariant al Javascript, che è visto come un oggetto JSON. Quindi un QString diventa string, un QInt un int, ecc

Utilizzando QtWebKit senza QWebChannel, un QByteArray è stato visto come un Uint8ClampedArray, ma ora è direttamente trasformato in un string usando UTF-8 (che il mio non è QByteArray:()

ho fatto qualcosa di sbagliato Cosa devo fare

Ecco la parte codice rilevante:??

//Qt Window class signal to javascript 
void MyWindow::uplink(Response msg) 
{ 
    emit _nativeToJs(msg->toJson()); 
} 



//Response class toJson() method 
QVariantMap Response::toJson() const 
{ 
    QVariantMap map; 

    map["id"] = m_id; //qulonglong 
    map["src"] = QString(m_src); 
    map["dst"] = QString(m_dst); 
    map["status"] = m_status; //qint16 
    map["result"] = m_result; //QVariant, can be a map of string, arrays, etc 

    return map; 
} 


//Javascript 

var foo; 
new QWebChannel(qt.webChannelTransport, function(channel) { 
    //we connect the signal 
    channel.objects.foo._nativeToJs.connect(function(msg){ 
     //msg is now a JSON object 
    }); 
}); 

msg.result dovrebbe contenere un array bloccato (dati msgpack) che decodificherò in seguito. Ora ho un brutto string di caratteri non UTF-8 interpretati come UTF-8, che non posso fare nulla con.

Answer 1

Non è affatto una risposta, ma un inizio di ricerca, in quanto è una domanda molto interessante.

Nelle versioni Qt < Qt5.6, è possibile trovare il modo in cui la conversione viene eseguita esaminando le origini Qt. In particolare, ho trovato questa funzione nel file C:\Qt\5.5\Src\qtwebkit\Source\WebCore\bridge\qt\qt_runtime.cpp:

JSValueRef convertQVariantToValue(JSContextRef context, PassRefPtr<RootObject> root, const QVariant& variant, JSValueRef *exception) 

e questo pezzo di codice interno:

if (type == QMetaType::QByteArray) { 
    QByteArray qtByteArray = variant.value<QByteArray>(); 
    WTF::RefPtr<WTF::Uint8ClampedArray> wtfByteArray = WTF::Uint8ClampedArray::createUninitialized(qtByteArray.length()); 
    memcpy(wtfByteArray->data(), qtByteArray.constData(), qtByteArray.length()); 
    ExecState* exec = toJS(context); 
    APIEntryShim entryShim(exec); 
    return toRef(exec, toJS(exec, static_cast<JSDOMGlobalObject*>(exec->lexicalGlobalObject()), wtfByteArray.get())); 
} 

che sembra essere l'elaborazione di un QByteArray sul lato JS.

Credo anche che per la migrazione da Qt WebKit per Qt WebEngine, Qt utilizza ora V8, mentre prima era WebCore and JavaScript Core (fonte: this thread). Quindi, le cose potrebbero essere cambiate ma non so fino a che punto.

Al momento, non riesco a cercare ulteriormente nelle fonti Qt per Qt5.6, e quindi non posso fornire una risposta reale, ma spero che questo possa motivare voi o chiunque altro a esaminarlo e a chiarisci questo comportamento :-).