Callback from Android to QML

[SyntaX]

Hey everyone :D
I am relatively new to Qt / QML, so please excuse me, if I am not getting everything right.

Currently I am integrating several Plugins into an existing Qml Application, with specific implementations for Android and iOS.

Basically, my project looks something like the following.

To achieve this, I have a myfunctions.h header file, where I specified all my methods:

#ifndef MYFUNCTIONS_H
#define MYFUNCTIONS_H

#include <QQuickItem> // QObject, QString, ...

class MyFunctions : public QObject {

    Q_OBJECT
    Q_DISABLE_COPY(MyFunctions)

    Q_PROPERTY(QString myString READ myString WRITE setMyString NOTIFY myStringChanged)

public:
    explicit MyFunctions(QObject *parent = 0);

    void setMyString(const QString &string);
    QString myString() const;


signals:
    void myStringChanged();

private slots:
    void updateMyString();

private:
    QString m_myString;

};
#endif // MYFUNCTIONS_H

Now I am able to implement the iOs calls in an myfunctions_ios.mm file:

#include "myfunctions.h"
// include native libraries and functions

// For Native iOS Functions
#import <UIKit/UIKit.h>
#import <Foundation/Foundation.h>

@interface QIOSApplicationDelegate
@end

@interface QIOSApplicationDelegate(AppDelegate)
@end

@implementation QIOSApplicationDelegate (AppDelegate)
@end

MyFunctions:: MyFunctions(QObject *parent) : QObject(parent){
    connect(this, SIGNAL(myStringChanged()), this, SLOT(updateMyString()));
}

void MyFunctions::setMyString(const QString &string) {
    m_myString = string;
    emit myStringChanged();
}

QString MyFunctions::myString() const {
    return m_myString;
}

void MyFunctions::updateMyString() {
    NSLog(@"iOS updateMyString with current value: %@", m_notification.toNSString());

    // call external Library
    // [LIB function: params]
}

and for android in myfunctions_android.cpp:

#include "myfunctions.h"

#include <QtAndroidExtras>


MyFunctions:: MyFunctions(QObject *parent) : QObject(parent){
    connect(this, SIGNAL(myStringChanged()), this, SLOT(updateMyString()));
}

void MyFunctions::setMyString(const QString &string) {
    m_myString = string;
    emit myStringChanged();
}

QString MyFunctions::myString() const {
    return m_myString;
}

void MyFunctions::updateMyString() {
    // call JNI function
    QAndroidJniObject javaNotification = QAndroidJniObject::fromString(m_myString);
    QAndroidJniObject::callStaticMethod<void>("path/to/my/class",
                                       "method name",
                                       "(Ljava/lang/String;)V",
                                       javaNotification.object<jstring>());
}

So I need an additional .java file to implement the function called per JNI from above.
I have managed to get along with this so far,
but now I need a callback or something like this, to return changes from inside the iOs/Android Application back to my QML app.

For iOs this wasn't much of a problem, because I was able to just emit signals directly from the myfunctions_ios.mm file.

But how do I achieve this in Android?

Is there a way back from my Android .java code, back to Qml?
How can I notify my QML app if something on the android device is changed (for example permissions, push-notifications, ...) ?

Can anyone suggest me, how to solve this or point me into any direction?

best Regards,
SyntaX

[Marc_Van_Daele]

This should help: https://doc.qt.io/qt-5/qandroidjniobject.html#java-native-methods
Basically you have to

• define your C++ functions that will be called from Java
• register these functions
• declare them in java using the "native" keyword
• call them in java as normal functions

Hope this helps,

Marc

[SyntaX]

thanks for your reply, this was indeed very helpful :D

I declared my "callback" function in the .java file with the native keyword:

public class MyJavaClass {

    // callback handler to send notifications back to c++
    public static native void StringChanged(String mystring);

    public void doSomeStuff () {
        // do stuff, then emit changes back to c++
        StringChanged("my new string");
    }
}

Then I registered those functions in my implementation

void StringChangeReceived(JNIEnv *env, jobject obj, jstring newstring) {

    Q_UNUSED(obj)

    QString qString(env->GetStringUTFChars(newstring, 0));
    qDebug().noquote().nospace() << "callback from Android received: " << qString;

    // to be able to emit the changes I either need an instance or (what I decided) a classic singleton
    if (nullptr != instance) {
        instance->myStringChanged(qString);
    }
}

void init () {
    // install callback for notifications received
    QAndroidJniEnvironment env;
    JNINativeMethod methods[] = {
        {
            "StringChanged",
            "(Ljava/lang/String;)V",
            reinterpret_cast<void*>(StringChangeReceived)
        }
    };
    QAndroidJniObject javaClass("path/to/my/JavaClass");
    jclass objectClass = env->GetObjectClass(javaClass.object<jobject>());

    env->RegisterNatives(objectClass, methods, sizeof(methods) / sizeof(methods[0]));
    env->DeleteLocalRef(objectClass);
}

With this I realised at least a most basic full roundtrip, from my qml -> over the c++ class -> to the native java class on the android device -> and back over c++ -> to qml. :DDD

Is it common practice to use that in combination with singletons? (Because I think I need them everywhere because of the static call?)
Are there best practices or key values to that kind of implementation?

best regards
an thank you very much,

SyntaX