Changed code syntax to Qt style

Documentation/index.html

@@ -90,7 +90,7 @@
     QTAT_SHARING</pre>
 	</li>
 								<li>In the <i>main()</i> body insert the call for initialize the library<br />
-	  <pre class="prettyprint">QtAndroidTools::InitializeQmlTools();</pre>
+	  <pre class="prettyprint">QtAndroidTools::initializeQmlTools();</pre>
 	</li>
 								
 							</ul>

QtAndroidTools/QAndroidAdMobBanner.cpp

@@ -26,55 +26,55 @@
 #include "QAndroidAdMobBanner.h"
 
 QMap<int, QAndroidAdMobBanner*> QAndroidAdMobBanner::m_pInstancesMap;
-int QAndroidAdMobBanner::m_InstancesCounter = 0;
+int QAndroidAdMobBanner::m_instancesCounter = 0;
 
 QAndroidAdMobBanner::QAndroidAdMobBanner(QQuickItem *parent) : QQuickItem(parent),
-                                                               m_JavaAdMobBanner("com/falsinsoft/qtandroidtools/AndroidAdMobBanner",
+                                                               m_javaAdMobBanner("com/falsinsoft/qtandroidtools/AndroidAdMobBanner",
                                                                                  "(Landroid/app/Activity;)V",
                                                                                  QtAndroid::androidActivity().object<jobject>()),
-                                                               m_InstanceIndex(m_InstancesCounter++),
-                                                               m_BannerType(TYPE_NO_BANNER),
-                                                               m_BannerShowed(false)
+                                                               m_instanceIndex(m_instancesCounter++),
+                                                               m_bannerType(TYPE_NO_BANNER),
+                                                               m_bannerShowed(false)
 {
-    m_pInstancesMap[m_InstanceIndex] = this;
+    m_pInstancesMap[m_instanceIndex] = this;
 
-    if(m_InstanceIndex == 0 && m_JavaAdMobBanner.isValid())
+    if(m_instanceIndex == 0 && m_javaAdMobBanner.isValid())
     {
-        const JNINativeMethod JniMethod[] = {
-            {"bannerEvent", "(I)V", reinterpret_cast<void *>(&QAndroidAdMobBanner::BannerEvent)},
-            {"bannerError", "(I)V", reinterpret_cast<void *>(&QAndroidAdMobBanner::BannerError)}
+        const JNINativeMethod jniMethod[] = {
+            {"bannerEvent", "(I)V", reinterpret_cast<void *>(&QAndroidAdMobBanner::bannerEvent)},
+            {"bannerError", "(I)V", reinterpret_cast<void *>(&QAndroidAdMobBanner::bannerError)}
         };
-        QAndroidJniEnvironment JniEnv;
-        jclass ObjectClass;
+        QAndroidJniEnvironment jniEnv;
+        jclass objectClass;
 
-        ObjectClass = JniEnv->GetObjectClass(m_JavaAdMobBanner.object<jobject>());
-        JniEnv->RegisterNatives(ObjectClass, JniMethod, sizeof(JniMethod)/sizeof(JNINativeMethod));
-        JniEnv->DeleteLocalRef(ObjectClass);
+        objectClass = jniEnv->GetObjectClass(m_javaAdMobBanner.object<jobject>());
+        jniEnv->RegisterNatives(objectClass, jniMethod, sizeof(jniMethod)/sizeof(JNINativeMethod));
+        jniEnv->DeleteLocalRef(objectClass);
     }
-    connect(qGuiApp, &QGuiApplication::applicationStateChanged, this, &QAndroidAdMobBanner::ApplicationStateChanged);
-    connect(qGuiApp->primaryScreen(), &QScreen::geometryChanged, this, &QAndroidAdMobBanner::ScreenGeometryChanged);
-    SetNewAppState(APP_STATE_CREATE);
+    connect(qGuiApp, &QGuiApplication::applicationStateChanged, this, &QAndroidAdMobBanner::applicationStateChanged);
+    connect(qGuiApp->primaryScreen(), &QScreen::geometryChanged, this, &QAndroidAdMobBanner::screenGeometryChanged);
+    setNewAppState(APP_STATE_CREATE);
 
 }
 
 QAndroidAdMobBanner::~QAndroidAdMobBanner()
 {
-    m_pInstancesMap.remove(m_InstanceIndex);
-    SetNewAppState(APP_STATE_DESTROY);
+    m_pInstancesMap.remove(m_instanceIndex);
+    setNewAppState(APP_STATE_DESTROY);
 }
 
-const QMap<int, QAndroidAdMobBanner*>& QAndroidAdMobBanner::Instances()
+const QMap<int, QAndroidAdMobBanner*>& QAndroidAdMobBanner::instances()
 {
     return m_pInstancesMap;
 }
 
 bool QAndroidAdMobBanner::show()
 {
-    if(m_JavaAdMobBanner.isValid() && m_BannerType != TYPE_NO_BANNER && m_UnitId.isEmpty() == false)
+    if(m_javaAdMobBanner.isValid() && m_bannerType != TYPE_NO_BANNER && m_unitId.isEmpty() == false)
     {
-        UpdatePosition();
-        m_JavaAdMobBanner.callMethod<void>("show");
-        m_BannerShowed = true;
+        updatePosition();
+        m_javaAdMobBanner.callMethod<void>("show");
+        m_bannerShowed = true;
         return true;
     }
 
@@ -83,10 +83,10 @@ bool QAndroidAdMobBanner::show()
 
 bool QAndroidAdMobBanner::hide()
 {
-    if(m_JavaAdMobBanner.isValid())
+    if(m_javaAdMobBanner.isValid())
     {
-        m_JavaAdMobBanner.callMethod<void>("hide");
-        m_BannerShowed = false;
+        m_javaAdMobBanner.callMethod<void>("hide");
+        m_bannerShowed = false;
         return true;
     }
 
@@ -95,15 +95,15 @@ bool QAndroidAdMobBanner::hide()
 
 bool QAndroidAdMobBanner::reload()
 {
-    if(m_JavaAdMobBanner.isValid() && m_BannerType != TYPE_NO_BANNER && m_UnitId.isEmpty() == false)
+    if(m_javaAdMobBanner.isValid() && m_bannerType != TYPE_NO_BANNER && m_unitId.isEmpty() == false)
     {
-        const bool BannerShowed = m_BannerShowed;
+        const bool bannerShowed = m_bannerShowed;
 
-        if(BannerShowed) hide();
-        m_JavaAdMobBanner.callMethod<void>("reload");
-        setType(m_BannerType);
-        setUnitId(m_UnitId);
-        if(BannerShowed) show();
+        if(bannerShowed) hide();
+        m_javaAdMobBanner.callMethod<void>("reload");
+        setType(m_bannerType);
+        setUnitId(m_unitId);
+        if(bannerShowed) show();
 
         return true;
     }
@@ -113,154 +113,154 @@ bool QAndroidAdMobBanner::reload()
 
 const QString& QAndroidAdMobBanner::getUnitId() const
 {
-    return m_UnitId;
+    return m_unitId;
 }
 
-void QAndroidAdMobBanner::setUnitId(const QString &UnitId)
+void QAndroidAdMobBanner::setUnitId(const QString &unitId)
 {
-    if(m_JavaAdMobBanner.isValid())
+    if(m_javaAdMobBanner.isValid())
     {
-        m_JavaAdMobBanner.callMethod<void>("setUnitId",
+        m_javaAdMobBanner.callMethod<void>("setUnitId",
                                            "(Ljava/lang/String;)V",
-                                           QAndroidJniObject::fromString(UnitId).object<jstring>()
+                                           QAndroidJniObject::fromString(unitId).object<jstring>()
                                            );
-        m_UnitId = UnitId;
+        m_unitId = unitId;
     }
 }
 
 const QStringList& QAndroidAdMobBanner::getKeywords() const
 {
-    return m_KeywordsList;
+    return m_keywordsList;
 }
 
-void QAndroidAdMobBanner::setKeywords(const QStringList &KeywordsList)
+void QAndroidAdMobBanner::setKeywords(const QStringList &keywordsList)
 {
-    if(m_JavaAdMobBanner.isValid())
+    if(m_javaAdMobBanner.isValid())
     {
-        const QAndroidJniObject StringObj("java/lang/String");
-        QAndroidJniObject StringArrayObj;
-        QAndroidJniEnvironment qJniEnv;
+        const QAndroidJniObject stringObj("java/lang/String");
+        QAndroidJniObject stringArrayObj;
+        QAndroidJniEnvironment jniEnv;
 
-        StringArrayObj = QAndroidJniObject::fromLocalRef(qJniEnv->NewObjectArray(KeywordsList.count(), qJniEnv->GetObjectClass(StringObj.object()), NULL));
+        stringArrayObj = QAndroidJniObject::fromLocalRef(jniEnv->NewObjectArray(keywordsList.count(), jniEnv->GetObjectClass(stringObj.object()), NULL));
 
-        for(int i = 0; i < KeywordsList.count(); i++)
+        for(int i = 0; i < keywordsList.count(); i++)
         {
-            qJniEnv->SetObjectArrayElement(StringArrayObj.object<jobjectArray>(), i, QAndroidJniObject::fromString(KeywordsList[i]).object<jstring>());
+            jniEnv->SetObjectArrayElement(stringArrayObj.object<jobjectArray>(), i, QAndroidJniObject::fromString(keywordsList[i]).object<jstring>());
         }
 
-        m_JavaAdMobBanner.callMethod<void>("setKeywords",
+        m_javaAdMobBanner.callMethod<void>("setKeywords",
                                            "([Ljava/lang/String;)V",
-                                           StringArrayObj.object<jobjectArray>()
+                                           stringArrayObj.object<jobjectArray>()
                                            );
-        m_KeywordsList = KeywordsList;
+        m_keywordsList = keywordsList;
     }
 }
 
 QAndroidAdMobBanner::BANNER_TYPE QAndroidAdMobBanner::getType() const
 {
-    return m_BannerType;
+    return m_bannerType;
 }
 
-void QAndroidAdMobBanner::setType(BANNER_TYPE Type)
+void QAndroidAdMobBanner::setType(BANNER_TYPE type)
 {
-    if(m_JavaAdMobBanner.isValid() && Type != TYPE_NO_BANNER)
+    if(m_javaAdMobBanner.isValid() && type != TYPE_NO_BANNER)
     {
-        const qreal PixelRatio = qApp->primaryScreen()->devicePixelRatio();
-        QAndroidJniObject BannerPixelsSizeObj;
+        const qreal pixelRatio = qApp->primaryScreen()->devicePixelRatio();
+        QAndroidJniObject bannerPixelsSizeObj;
 
-        m_JavaAdMobBanner.callMethod<void>("setType",
+        m_javaAdMobBanner.callMethod<void>("setType",
                                            "(I)V",
-                                           Type
+                                           type
                                            );        
-        m_BannerType = Type;
+        m_bannerType = type;
 
-        BannerPixelsSizeObj = m_JavaAdMobBanner.callObjectMethod("getPixelsSize",
+        bannerPixelsSizeObj = m_javaAdMobBanner.callObjectMethod("getPixelsSize",
                                                                  "()Lcom/falsinsoft/qtandroidtools/AndroidAdMobBanner$BannerSize;"
                                                                  );
-        setWidth(BannerPixelsSizeObj.getField<jint>("width") / PixelRatio);
-        setHeight(BannerPixelsSizeObj.getField<jint>("height") / PixelRatio);
+        setWidth(bannerPixelsSizeObj.getField<jint>("width") / pixelRatio);
+        setHeight(bannerPixelsSizeObj.getField<jint>("height") / pixelRatio);
     }
 }
 
-void QAndroidAdMobBanner::ScreenGeometryChanged(const QRect &Geometry)
+void QAndroidAdMobBanner::screenGeometryChanged(const QRect &geometry)
 {
-    Q_UNUSED(Geometry)
+    Q_UNUSED(geometry)
 
-    if(m_BannerShowed == true)
+    if(m_bannerShowed == true)
     {
         reload();
     }
 }
 
-void QAndroidAdMobBanner::UpdatePosition()
+void QAndroidAdMobBanner::updatePosition()
 {
-    if(m_JavaAdMobBanner.isValid())
+    if(m_javaAdMobBanner.isValid())
     {
-        const qreal PixelRatio = qApp->primaryScreen()->devicePixelRatio();
-        const QPointF ScreenPos = mapToGlobal(QPointF(0,0));
+        const qreal pixelRatio = qApp->primaryScreen()->devicePixelRatio();
+        const QPointF screenPos = mapToGlobal(QPointF(0,0));
 
-        m_JavaAdMobBanner.callMethod<void>("setPos",
+        m_javaAdMobBanner.callMethod<void>("setPos",
                                            "(II)V",
-                                           static_cast<int>(ScreenPos.x() * PixelRatio),
-                                           static_cast<int>(ScreenPos.y() * PixelRatio)
+                                           static_cast<int>(screenPos.x() * pixelRatio),
+                                           static_cast<int>(screenPos.y() * pixelRatio)
                                            );
     }
 }
 
-void QAndroidAdMobBanner::BannerEvent(JNIEnv *env, jobject thiz, jint eventId)
+void QAndroidAdMobBanner::bannerEvent(JNIEnv *env, jobject thiz, jint eventId)
 {
-    QMapIterator<int, QAndroidAdMobBanner*> Instance(m_pInstancesMap);
+    QMapIterator<int, QAndroidAdMobBanner*> instance(m_pInstancesMap);
 
     Q_UNUSED(env)
     Q_UNUSED(thiz)
 
-    while(Instance.hasNext())
+    while(instance.hasNext())
     {
-        Instance.next();
+        instance.next();
         switch(eventId)
         {
             case EVENT_LOADING:
-                emit Instance.value()->loading();
+                Q_EMIT instance.value()->loading();
                 break;
             case EVENT_LOADED:
-                emit Instance.value()->loaded();
+                Q_EMIT instance.value()->loaded();
                 break;
             case EVENT_CLOSED:
-                emit Instance.value()->closed();
+                Q_EMIT instance.value()->closed();
                 break;
             case EVENT_CLICKED:
-                emit Instance.value()->clicked();
+                Q_EMIT instance.value()->clicked();
                 break;
         }
     }
 }
 
-void QAndroidAdMobBanner::BannerError(JNIEnv *env, jobject thiz, jint errorId)
+void QAndroidAdMobBanner::bannerError(JNIEnv *env, jobject thiz, jint errorId)
 {
-    QMapIterator<int, QAndroidAdMobBanner*> Instance(m_pInstancesMap);
+    QMapIterator<int, QAndroidAdMobBanner*> instance(m_pInstancesMap);
 
     Q_UNUSED(env)
     Q_UNUSED(thiz)
 
-    while(Instance.hasNext())
+    while(instance.hasNext())
     {
-        Instance.next();
-        emit Instance.value()->loadError(errorId);
+        instance.next();
+        Q_EMIT instance.value()->loadError(errorId);
     }
 }
 
-void QAndroidAdMobBanner::ApplicationStateChanged(Qt::ApplicationState State)
+void QAndroidAdMobBanner::applicationStateChanged(Qt::ApplicationState state)
 {
-    SetNewAppState((State == Qt::ApplicationActive) ? APP_STATE_START : APP_STATE_STOP);
+    setNewAppState((state == Qt::ApplicationActive) ? APP_STATE_START : APP_STATE_STOP);
 }
 
-void QAndroidAdMobBanner::SetNewAppState(APP_STATE NewState)
+void QAndroidAdMobBanner::setNewAppState(APP_STATE newState)
 {
-    if(m_JavaAdMobBanner.isValid())
+    if(m_javaAdMobBanner.isValid())
     {
-        m_JavaAdMobBanner.callMethod<void>("appStateChanged",
+        m_javaAdMobBanner.callMethod<void>("appStateChanged",
                                            "(I)V",
-                                           NewState
+                                           newState
                                            );
     }
 }

QtAndroidTools/QAndroidAdMobBanner.h

@@ -63,34 +63,34 @@ public:
     Q_INVOKABLE bool reload();
 
     const QString& getUnitId() const;
-    void setUnitId(const QString &UnitId);
+    void setUnitId(const QString &unitId);
     BANNER_TYPE getType() const;
-    void setType(BANNER_TYPE Type);
+    void setType(BANNER_TYPE type);
     const QStringList& getKeywords() const;
-    void setKeywords(const QStringList &KeywordsList);
+    void setKeywords(const QStringList &keywordsList);
 
-    static const QMap<int, QAndroidAdMobBanner*>& Instances();
+    static const QMap<int, QAndroidAdMobBanner*>& instances();
 
-signals:
+Q_SIGNALS:
     void loadError(int errorId);
     void loading();
     void loaded();
     void closed();
     void clicked();
 
-private slots:
-    void ApplicationStateChanged(Qt::ApplicationState State);
-    void ScreenGeometryChanged(const QRect &Geometry);
+private Q_SLOTS:
+    void applicationStateChanged(Qt::ApplicationState state);
+    void screenGeometryChanged(const QRect &geometry);
 
 private:
-    const QAndroidJniObject m_JavaAdMobBanner;
+    const QAndroidJniObject m_javaAdMobBanner;
     static QMap<int, QAndroidAdMobBanner*> m_pInstancesMap;
-    static int m_InstancesCounter;
-    const int m_InstanceIndex;
-    BANNER_TYPE m_BannerType;
-    bool m_BannerShowed;
-    QString m_UnitId;
-    QStringList m_KeywordsList;
+    static int m_instancesCounter;
+    const int m_instanceIndex;
+    BANNER_TYPE m_bannerType;
+    bool m_bannerShowed;
+    QString m_unitId;
+    QStringList m_keywordsList;
 
     enum EVENT_TYPE
     {
@@ -100,8 +100,8 @@ private:
         EVENT_CLICKED
     };
 
-    static void BannerEvent(JNIEnv *env, jobject thiz, jint eventId);
-    static void BannerError(JNIEnv *env, jobject thiz, jint errorId);
+    static void bannerEvent(JNIEnv *env, jobject thiz, jint eventId);
+    static void bannerError(JNIEnv *env, jobject thiz, jint errorId);
 
     enum APP_STATE
     {
@@ -110,6 +110,6 @@ private:
         APP_STATE_STOP,
         APP_STATE_DESTROY
     };
-    void SetNewAppState(APP_STATE NewState);
-    void UpdatePosition();
+    void setNewAppState(APP_STATE newState);
+    void updatePosition();
 };

QtAndroidTools/QAndroidAdMobInterstitial.cpp

@@ -25,48 +25,48 @@
 #include "QAndroidAdMobInterstitial.h"
 
 QMap<int, QAndroidAdMobInterstitial*> QAndroidAdMobInterstitial::m_pInstancesMap;
-int QAndroidAdMobInterstitial::m_InstancesCounter = 0;
+int QAndroidAdMobInterstitial::m_instancesCounter = 0;
 
 QAndroidAdMobInterstitial::QAndroidAdMobInterstitial(QQuickItem *parent) : QQuickItem(parent),
-                                                                           m_JavaAdMobInterstitial("com/falsinsoft/qtandroidtools/AndroidAdMobInterstitial",
+                                                                           m_javaAdMobInterstitial("com/falsinsoft/qtandroidtools/AndroidAdMobInterstitial",
                                                                                                    "(Landroid/app/Activity;)V",
                                                                                                    QtAndroid::androidActivity().object<jobject>()),
-                                                                           m_InstanceIndex(m_InstancesCounter++)
+                                                                           m_instanceIndex(m_instancesCounter++)
 {
-    m_pInstancesMap[m_InstanceIndex] = this;
+    m_pInstancesMap[m_instanceIndex] = this;
 
-    if(m_InstanceIndex == 0 && m_JavaAdMobInterstitial.isValid())
+    if(m_instanceIndex == 0 && m_javaAdMobInterstitial.isValid())
     {
-        const JNINativeMethod JniMethod[] = {
-            {"interstitialEvent", "(I)V", reinterpret_cast<void *>(&QAndroidAdMobInterstitial::InterstitialEvent)},
-            {"interstitialError", "(I)V", reinterpret_cast<void *>(&QAndroidAdMobInterstitial::InterstitialError)}
+        const JNINativeMethod jniMethod[] = {
+            {"interstitialEvent", "(I)V", reinterpret_cast<void *>(&QAndroidAdMobInterstitial::interstitialEvent)},
+            {"interstitialError", "(I)V", reinterpret_cast<void *>(&QAndroidAdMobInterstitial::interstitialError)}
         };
-        QAndroidJniEnvironment JniEnv;
-        jclass ObjectClass;
+        QAndroidJniEnvironment jniEnv;
+        jclass objectClass;
 
-        ObjectClass = JniEnv->GetObjectClass(m_JavaAdMobInterstitial.object<jobject>());
-        JniEnv->RegisterNatives(ObjectClass, JniMethod, sizeof(JniMethod)/sizeof(JNINativeMethod));
-        JniEnv->DeleteLocalRef(ObjectClass);
+        objectClass = jniEnv->GetObjectClass(m_javaAdMobInterstitial.object<jobject>());
+        jniEnv->RegisterNatives(objectClass, jniMethod, sizeof(jniMethod)/sizeof(JNINativeMethod));
+        jniEnv->DeleteLocalRef(objectClass);
     }
-    SetNewAppState(APP_STATE_CREATE);
+    setNewAppState(APP_STATE_CREATE);
 }
 
 QAndroidAdMobInterstitial::~QAndroidAdMobInterstitial()
 {
-    m_pInstancesMap.remove(m_InstanceIndex);
-    SetNewAppState(APP_STATE_DESTROY);
+    m_pInstancesMap.remove(m_instanceIndex);
+    setNewAppState(APP_STATE_DESTROY);
 }
 
-const QMap<int, QAndroidAdMobInterstitial*>& QAndroidAdMobInterstitial::Instances()
+const QMap<int, QAndroidAdMobInterstitial*>& QAndroidAdMobInterstitial::instances()
 {
     return m_pInstancesMap;
 }
 
 bool QAndroidAdMobInterstitial::show()
 {
-    if(m_JavaAdMobInterstitial.isValid() && m_UnitId.isEmpty() == false)
+    if(m_javaAdMobInterstitial.isValid() && m_unitId.isEmpty() == false)
     {
-        m_JavaAdMobInterstitial.callMethod<void>("show");
+        m_javaAdMobInterstitial.callMethod<void>("show");
         return true;
     }
 
@@ -75,9 +75,9 @@ bool QAndroidAdMobInterstitial::show()
 
 bool QAndroidAdMobInterstitial::load()
 {
-    if(m_JavaAdMobInterstitial.isValid() && m_UnitId.isEmpty() == false)
+    if(m_javaAdMobInterstitial.isValid() && m_unitId.isEmpty() == false)
     {
-        m_JavaAdMobInterstitial.callMethod<void>("load");
+        m_javaAdMobInterstitial.callMethod<void>("load");
         return true;
     }
 
@@ -86,70 +86,70 @@ bool QAndroidAdMobInterstitial::load()
 
 const QString& QAndroidAdMobInterstitial::getUnitId() const
 {
-    return m_UnitId;
+    return m_unitId;
 }
 
-void QAndroidAdMobInterstitial::setUnitId(const QString &UnitId)
+void QAndroidAdMobInterstitial::setUnitId(const QString &unitId)
 {
-    if(m_JavaAdMobInterstitial.isValid())
+    if(m_javaAdMobInterstitial.isValid())
     {
-        m_JavaAdMobInterstitial.callMethod<void>("setUnitId",
+        m_javaAdMobInterstitial.callMethod<void>("setUnitId",
                                                  "(Ljava/lang/String;)V",
-                                                 QAndroidJniObject::fromString(UnitId).object<jstring>()
+                                                 QAndroidJniObject::fromString(unitId).object<jstring>()
                                                  );
-        m_UnitId = UnitId;
+        m_unitId = unitId;
     }
 }
 
-void QAndroidAdMobInterstitial::InterstitialEvent(JNIEnv *env, jobject thiz, jint eventId)
+void QAndroidAdMobInterstitial::interstitialEvent(JNIEnv *env, jobject thiz, jint eventId)
 {
-    QMapIterator<int, QAndroidAdMobInterstitial*> Instance(m_pInstancesMap);
+    QMapIterator<int, QAndroidAdMobInterstitial*> instance(m_pInstancesMap);
 
     Q_UNUSED(env)
     Q_UNUSED(thiz)
 
-    while(Instance.hasNext())
+    while(instance.hasNext())
     {
-        Instance.next();
+        instance.next();
         switch(eventId)
         {
             case EVENT_LOADING:
-                emit Instance.value()->loading();
+                Q_EMIT instance.value()->loading();
                 break;
             case EVENT_LOADED:
-                emit Instance.value()->loaded();
+                Q_EMIT instance.value()->loaded();
                 break;
             case EVENT_CLOSED:
-                emit Instance.value()->closed();
+                Q_EMIT instance.value()->closed();
                 break;
             case EVENT_CLICKED:
-                emit Instance.value()->clicked();
+                Q_EMIT instance.value()->clicked();
                 break;
         }
     }
 }
 
-void QAndroidAdMobInterstitial::InterstitialError(JNIEnv *env, jobject thiz, jint errorId)
+void QAndroidAdMobInterstitial::interstitialError(JNIEnv *env, jobject thiz, jint errorId)
 {
-    QMapIterator<int, QAndroidAdMobInterstitial*> Instance(m_pInstancesMap);
+    QMapIterator<int, QAndroidAdMobInterstitial*> instance(m_pInstancesMap);
 
     Q_UNUSED(env)
     Q_UNUSED(thiz)
 
-    while(Instance.hasNext())
+    while(instance.hasNext())
     {
-        Instance.next();
-        emit Instance.value()->loadError(errorId);
+        instance.next();
+        Q_EMIT instance.value()->loadError(errorId);
     }
 }
 
-void QAndroidAdMobInterstitial::SetNewAppState(APP_STATE NewState)
+void QAndroidAdMobInterstitial::setNewAppState(APP_STATE newState)
 {
-    if(m_JavaAdMobInterstitial.isValid())
+    if(m_javaAdMobInterstitial.isValid())
     {
-        m_JavaAdMobInterstitial.callMethod<void>("appStateChanged",
+        m_javaAdMobInterstitial.callMethod<void>("appStateChanged",
                                                  "(I)V",
-                                                 NewState
+                                                 newState
                                                  );
     }
 }

QtAndroidTools/QAndroidAdMobInterstitial.h

@@ -49,11 +49,11 @@ public:
     Q_INVOKABLE bool load();
 
     const QString& getUnitId() const;
-    void setUnitId(const QString &UnitId);
+    void setUnitId(const QString &unitId);
 
-    static const QMap<int, QAndroidAdMobInterstitial*>& Instances();
+    static const QMap<int, QAndroidAdMobInterstitial*>& instances();
 
-signals:
+Q_SIGNALS:
     void loadError(int errorId);
     void loading();
     void loaded();
@@ -61,11 +61,11 @@ signals:
     void clicked();
 
 private:
-    const QAndroidJniObject m_JavaAdMobInterstitial;
+    const QAndroidJniObject m_javaAdMobInterstitial;
     static QMap<int, QAndroidAdMobInterstitial*> m_pInstancesMap;
-    static int m_InstancesCounter;
-    const int m_InstanceIndex;
-    QString m_UnitId;
+    static int m_instancesCounter;
+    const int m_instanceIndex;
+    QString m_unitId;
 
     enum EVENT_TYPE
     {
@@ -75,8 +75,8 @@ private:
         EVENT_CLICKED
     };
 
-    static void InterstitialEvent(JNIEnv *env, jobject thiz, jint eventId);
-    static void InterstitialError(JNIEnv *env, jobject thiz, jint errorId);
+    static void interstitialEvent(JNIEnv *env, jobject thiz, jint eventId);
+    static void interstitialError(JNIEnv *env, jobject thiz, jint errorId);
 
     enum APP_STATE
     {
@@ -85,5 +85,5 @@ private:
         APP_STATE_STOP,
         APP_STATE_DESTROY
     };
-    void SetNewAppState(APP_STATE NewState);
+    void setNewAppState(APP_STATE newState);
 };

QtAndroidTools/QAndroidAdMobRewardedVideo.cpp

@@ -25,49 +25,49 @@
 #include "QAndroidAdMobRewardedVideo.h"
 
 QMap<int, QAndroidAdMobRewardedVideo*> QAndroidAdMobRewardedVideo::m_pInstancesMap;
-int QAndroidAdMobRewardedVideo::m_InstancesCounter = 0;
+int QAndroidAdMobRewardedVideo::m_instancesCounter = 0;
 
 QAndroidAdMobRewardedVideo::QAndroidAdMobRewardedVideo(QQuickItem *parent) : QQuickItem(parent),
-                                                                             m_JavaAdMobRewardedVideo("com/falsinsoft/qtandroidtools/AndroidAdMobRewardedVideo",
+                                                                             m_javaAdMobRewardedVideo("com/falsinsoft/qtandroidtools/AndroidAdMobRewardedVideo",
                                                                                                       "(Landroid/app/Activity;)V",
                                                                                                       QtAndroid::androidActivity().object<jobject>()),
-                                                                             m_InstanceIndex(m_InstancesCounter++)
+                                                                             m_instanceIndex(m_instancesCounter++)
 {
-    m_pInstancesMap[m_InstanceIndex] = this;
+    m_pInstancesMap[m_instanceIndex] = this;
 
-    if(m_InstanceIndex == 0 && m_JavaAdMobRewardedVideo.isValid())
+    if(m_instanceIndex == 0 && m_javaAdMobRewardedVideo.isValid())
     {
-        const JNINativeMethod JniMethod[] = {
-            {"rewardedVideoReward", "(Ljava/lang/String;I)V", reinterpret_cast<void *>(&QAndroidAdMobRewardedVideo::RewardedVideoReward)},
-            {"rewardedVideoEvent", "(I)V", reinterpret_cast<void *>(&QAndroidAdMobRewardedVideo::RewardedVideoEvent)},
-            {"rewardedVideoError", "(I)V", reinterpret_cast<void *>(&QAndroidAdMobRewardedVideo::RewardedVideoError)}
+        const JNINativeMethod jniMethod[] = {
+            {"rewardedVideoReward", "(Ljava/lang/String;I)V", reinterpret_cast<void *>(&QAndroidAdMobRewardedVideo::rewardedVideoReward)},
+            {"rewardedVideoEvent", "(I)V", reinterpret_cast<void *>(&QAndroidAdMobRewardedVideo::rewardedVideoEvent)},
+            {"rewardedVideoError", "(I)V", reinterpret_cast<void *>(&QAndroidAdMobRewardedVideo::rewardedVideoError)}
         };
-        QAndroidJniEnvironment JniEnv;
-        jclass ObjectClass;
+        QAndroidJniEnvironment jniEnv;
+        jclass objectClass;
 
-        ObjectClass = JniEnv->GetObjectClass(m_JavaAdMobRewardedVideo.object<jobject>());
-        JniEnv->RegisterNatives(ObjectClass, JniMethod, sizeof(JniMethod)/sizeof(JNINativeMethod));
-        JniEnv->DeleteLocalRef(ObjectClass);
+        objectClass = jniEnv->GetObjectClass(m_javaAdMobRewardedVideo.object<jobject>());
+        jniEnv->RegisterNatives(objectClass, jniMethod, sizeof(jniMethod)/sizeof(JNINativeMethod));
+        jniEnv->DeleteLocalRef(objectClass);
     }
-    SetNewAppState(APP_STATE_CREATE);
+    setNewAppState(APP_STATE_CREATE);
 }
 
 QAndroidAdMobRewardedVideo::~QAndroidAdMobRewardedVideo()
 {
-    m_pInstancesMap.remove(m_InstanceIndex);
-    SetNewAppState(APP_STATE_DESTROY);
+    m_pInstancesMap.remove(m_instanceIndex);
+    setNewAppState(APP_STATE_DESTROY);
 }
 
-const QMap<int, QAndroidAdMobRewardedVideo*>& QAndroidAdMobRewardedVideo::Instances()
+const QMap<int, QAndroidAdMobRewardedVideo*>& QAndroidAdMobRewardedVideo::instances()
 {
     return m_pInstancesMap;
 }
 
 bool QAndroidAdMobRewardedVideo::show()
 {
-    if(m_JavaAdMobRewardedVideo.isValid() && m_UnitId.isEmpty() == false)
+    if(m_javaAdMobRewardedVideo.isValid() && m_unitId.isEmpty() == false)
     {
-        m_JavaAdMobRewardedVideo.callMethod<void>("show");
+        m_javaAdMobRewardedVideo.callMethod<void>("show");
         return true;
     }
 
@@ -76,11 +76,11 @@ bool QAndroidAdMobRewardedVideo::show()
 
 bool QAndroidAdMobRewardedVideo::load()
 {
-    if(m_JavaAdMobRewardedVideo.isValid() && m_UnitId.isEmpty() == false)
+    if(m_javaAdMobRewardedVideo.isValid() && m_unitId.isEmpty() == false)
     {
-        m_JavaAdMobRewardedVideo.callMethod<void>("load",
+        m_javaAdMobRewardedVideo.callMethod<void>("load",
                                                   "(Ljava/lang/String;)V",
-                                                  QAndroidJniObject::fromString(m_UnitId).object<jstring>()
+                                                  QAndroidJniObject::fromString(m_unitId).object<jstring>()
                                                   );
         return true;
     }
@@ -90,87 +90,87 @@ bool QAndroidAdMobRewardedVideo::load()
 
 const QString& QAndroidAdMobRewardedVideo::getUnitId() const
 {
-    return m_UnitId;
+    return m_unitId;
 }
 
-void QAndroidAdMobRewardedVideo::setUnitId(const QString &UnitId)
+void QAndroidAdMobRewardedVideo::setUnitId(const QString &unitId)
 {
-    m_UnitId = UnitId;
+    m_unitId = unitId;
 }
 
-void QAndroidAdMobRewardedVideo::RewardedVideoReward(JNIEnv *env, jobject thiz, jstring type, jint amount)
+void QAndroidAdMobRewardedVideo::rewardedVideoReward(JNIEnv *env, jobject thiz, jstring type, jint amount)
 {
-    QMapIterator<int, QAndroidAdMobRewardedVideo*> Instance(m_pInstancesMap);
-    QAndroidJniEnvironment JniEnv;
+    QMapIterator<int, QAndroidAdMobRewardedVideo*> instance(m_pInstancesMap);
+    QAndroidJniEnvironment jniEnv;
 
     Q_UNUSED(env)
     Q_UNUSED(thiz)
 
-    while(Instance.hasNext())
+    while(instance.hasNext())
     {
-        Instance.next();
-        emit Instance.value()->rewarded(QString(JniEnv->GetStringUTFChars(type, NULL)), amount);
+        instance.next();
+        Q_EMIT instance.value()->rewarded(QString(jniEnv->GetStringUTFChars(type, NULL)), amount);
     }
 }
 
-void QAndroidAdMobRewardedVideo::RewardedVideoEvent(JNIEnv *env, jobject thiz, jint eventId)
+void QAndroidAdMobRewardedVideo::rewardedVideoEvent(JNIEnv *env, jobject thiz, jint eventId)
 {
-    QMapIterator<int, QAndroidAdMobRewardedVideo*> Instance(m_pInstancesMap);
+    QMapIterator<int, QAndroidAdMobRewardedVideo*> instance(m_pInstancesMap);
 
     Q_UNUSED(env)
     Q_UNUSED(thiz)
 
-    while(Instance.hasNext())
+    while(instance.hasNext())
     {
-        Instance.next();
+        instance.next();
         switch(eventId)
         {
             case EVENT_LOADING:
-                emit Instance.value()->loading();
+                Q_EMIT instance.value()->loading();
                 break;
             case EVENT_LOADED:
-                emit Instance.value()->loaded();
+                Q_EMIT instance.value()->loaded();
                 break;
             case EVENT_OPENED:
-                emit Instance.value()->opened();
+                Q_EMIT instance.value()->opened();
                 break;
             case EVENT_CLOSED:
-                emit Instance.value()->closed();
+                Q_EMIT instance.value()->closed();
                 break;
             case EVENT_STARTED:
-                emit Instance.value()->started();
+                Q_EMIT instance.value()->started();
                 break;
             case EVENT_COMPLETED:
-                emit Instance.value()->completed();
+                Q_EMIT instance.value()->completed();
                 break;
             case EVENT_LEFT_APPLICATION:
-                emit Instance.value()->leftApplication();
+                Q_EMIT instance.value()->leftApplication();
                 break;
         }
     }
 }
 
-void QAndroidAdMobRewardedVideo::RewardedVideoError(JNIEnv *env, jobject thiz, jint errorId)
+void QAndroidAdMobRewardedVideo::rewardedVideoError(JNIEnv *env, jobject thiz, jint errorId)
 {
-    QMapIterator<int, QAndroidAdMobRewardedVideo*> Instance(m_pInstancesMap);
+    QMapIterator<int, QAndroidAdMobRewardedVideo*> instance(m_pInstancesMap);
 
     Q_UNUSED(env)
     Q_UNUSED(thiz)
 
-    while(Instance.hasNext())
+    while(instance.hasNext())
     {
-        Instance.next();
-        emit Instance.value()->loadError(errorId);
+        instance.next();
+        Q_EMIT instance.value()->loadError(errorId);
     }
 }
 
-void QAndroidAdMobRewardedVideo::SetNewAppState(APP_STATE NewState)
+void QAndroidAdMobRewardedVideo::setNewAppState(APP_STATE newState)
 {
-    if(m_JavaAdMobRewardedVideo.isValid())
+    if(m_javaAdMobRewardedVideo.isValid())
     {
-        m_JavaAdMobRewardedVideo.callMethod<void>("appStateChanged",
+        m_javaAdMobRewardedVideo.callMethod<void>("appStateChanged",
                                                   "(I)V",
-                                                  NewState
+                                                  newState
                                                   );
     }
 }

QtAndroidTools/QAndroidAdMobRewardedVideo.h

@@ -49,11 +49,11 @@ public:
     Q_INVOKABLE bool load();
 
     const QString& getUnitId() const;
-    void setUnitId(const QString &UnitId);
+    void setUnitId(const QString &unitId);
 
-    static const QMap<int, QAndroidAdMobRewardedVideo*>& Instances();
+    static const QMap<int, QAndroidAdMobRewardedVideo*>& instances();
 
-signals:
+Q_SIGNALS:
     void rewarded(const QString &type, int amount);
     void loadError(int errorId);
     void loading();
@@ -65,11 +65,11 @@ signals:
     void leftApplication();
 
 private:
-    const QAndroidJniObject m_JavaAdMobRewardedVideo;
+    const QAndroidJniObject m_javaAdMobRewardedVideo;
     static QMap<int, QAndroidAdMobRewardedVideo*> m_pInstancesMap;
-    static int m_InstancesCounter;
-    const int m_InstanceIndex;
-    QString m_UnitId;
+    static int m_instancesCounter;
+    const int m_instanceIndex;
+    QString m_unitId;
 
     enum EVENT_TYPE
     {
@@ -82,9 +82,9 @@ private:
         EVENT_LEFT_APPLICATION
     };
 
-    static void RewardedVideoReward(JNIEnv *env, jobject thiz, jstring type, jint amount);
-    static void RewardedVideoEvent(JNIEnv *env, jobject thiz, jint eventId);
-    static void RewardedVideoError(JNIEnv *env, jobject thiz, jint errorId);
+    static void rewardedVideoReward(JNIEnv *env, jobject thiz, jstring type, jint amount);
+    static void rewardedVideoEvent(JNIEnv *env, jobject thiz, jint eventId);
+    static void rewardedVideoError(JNIEnv *env, jobject thiz, jint errorId);
 
     enum APP_STATE
     {
@@ -93,5 +93,5 @@ private:
         APP_STATE_STOP,
         APP_STATE_DESTROY
     };
-    void SetNewAppState(APP_STATE NewState);
+    void setNewAppState(APP_STATE newState);
 };

QtAndroidTools/QAndroidApkExpansionFiles.cpp

@@ -26,33 +26,33 @@
 
 QAndroidApkExpansionFiles *QAndroidApkExpansionFiles::m_pInstance = nullptr;
 
-QAndroidApkExpansionFiles::QAndroidApkExpansionFiles() : m_JavaApkExpansionFiles("com/falsinsoft/qtandroidtools/AndroidApkExpansionFiles",
+QAndroidApkExpansionFiles::QAndroidApkExpansionFiles() : m_javaApkExpansionFiles("com/falsinsoft/qtandroidtools/AndroidApkExpansionFiles",
                                                                                  "(Landroid/app/Activity;)V",
                                                                                  QtAndroid::androidActivity().object<jobject>())
 {
     m_pInstance = this;
 
-    if(m_JavaApkExpansionFiles.isValid())
+    if(m_javaApkExpansionFiles.isValid())
     {
-        const JNINativeMethod JniMethod[] = {
-            {"getString", "(I)Ljava/lang/String;", reinterpret_cast<void *>(&QAndroidApkExpansionFiles::DownloaderGetString)},
-            {"downloadStateChanged", "(I)V", reinterpret_cast<void *>(&QAndroidApkExpansionFiles::DownloadStateChanged)},
-            {"downloadProgress", "(JJJF)V", reinterpret_cast<void *>(&QAndroidApkExpansionFiles::DownloadProgress)}
+        const JNINativeMethod jniMethod[] = {
+            {"getString", "(I)Ljava/lang/String;", reinterpret_cast<void *>(&QAndroidApkExpansionFiles::downloaderGetString)},
+            {"downloadStateChanged", "(I)V", reinterpret_cast<void *>(&QAndroidApkExpansionFiles::downloaderStateChanged)},
+            {"downloadProgress", "(JJJF)V", reinterpret_cast<void *>(&QAndroidApkExpansionFiles::downloaderProgress)}
         };
-        QAndroidJniEnvironment JniEnv;
-        jclass ObjectClass;
+        QAndroidJniEnvironment jniEnv;
+        jclass objectClass;
 
-        ObjectClass = JniEnv->GetObjectClass(m_JavaApkExpansionFiles.object<jobject>());
-        JniEnv->RegisterNatives(ObjectClass, JniMethod, sizeof(JniMethod)/sizeof(JNINativeMethod));
-        JniEnv->DeleteLocalRef(ObjectClass);
+        objectClass = jniEnv->GetObjectClass(m_javaApkExpansionFiles.object<jobject>());
+        jniEnv->RegisterNatives(objectClass, jniMethod, sizeof(jniMethod)/sizeof(JNINativeMethod));
+        jniEnv->DeleteLocalRef(objectClass);
     }
-    connect(qGuiApp, &QGuiApplication::applicationStateChanged, this, &QAndroidApkExpansionFiles::ApplicationStateChanged);
-    SetNewAppState(APP_STATE_CREATE);
+    connect(qGuiApp, &QGuiApplication::applicationStateChanged, this, &QAndroidApkExpansionFiles::applicationStateChanged);
+    setNewAppState(APP_STATE_CREATE);
 }
 
 QAndroidApkExpansionFiles::~QAndroidApkExpansionFiles()
 {
-    SetNewAppState(APP_STATE_DESTROY);
+    setNewAppState(APP_STATE_DESTROY);
 }
 
 QObject* QAndroidApkExpansionFiles::qmlInstance(QQmlEngine *engine, QJSEngine *scriptEngine)
@@ -68,26 +68,26 @@ QAndroidApkExpansionFiles* QAndroidApkExpansionFiles::instance()
     return m_pInstance;
 }
 
-void QAndroidApkExpansionFiles::ApplicationStateChanged(Qt::ApplicationState State)
+void QAndroidApkExpansionFiles::applicationStateChanged(Qt::ApplicationState state)
 {
-    SetNewAppState((State == Qt::ApplicationActive) ? APP_STATE_START : APP_STATE_STOP);
+    setNewAppState((state == Qt::ApplicationActive) ? APP_STATE_START : APP_STATE_STOP);
 }
 
-void QAndroidApkExpansionFiles::SetNewAppState(APP_STATE NewState)
+void QAndroidApkExpansionFiles::setNewAppState(APP_STATE newState)
 {
-    if(m_JavaApkExpansionFiles.isValid())
+    if(m_javaApkExpansionFiles.isValid())
     {
-        m_JavaApkExpansionFiles.callMethod<void>("appStateChanged",
+        m_javaApkExpansionFiles.callMethod<void>("appStateChanged",
                                                  "(I)V",
-                                                 NewState
+                                                 newState
                                                  );
     }
 }
 
 QAndroidApkExpansionFiles::APKEF_STATE QAndroidApkExpansionFiles::startDownloadFiles()
 {
-    if(m_JavaApkExpansionFiles.isValid() == false) return APKEF_INVALID_JAVA_CLASS;
-    if(m_Base64PublicKey.count() == 0) return APKEF_INVALID_BASE64_PUBLIC_KEY;
+    if(m_javaApkExpansionFiles.isValid() == false) return APKEF_INVALID_JAVA_CLASS;
+    if(m_base64PublicKey.count() == 0) return APKEF_INVALID_BASE64_PUBLIC_KEY;
     if(m_SALT.count() != 20) return APKEF_INVALID_SALT;
     if(QtAndroid::androidSdkVersion() >= 23)
     {
@@ -97,33 +97,33 @@ QAndroidApkExpansionFiles::APKEF_STATE QAndroidApkExpansionFiles::startDownloadF
 
     for(int i = 0; i < 2; i++)
     {
-        if(m_ExpansionsFileInfo[i].Version > 0 && m_ExpansionsFileInfo[i].Size > 0)
+        if(m_expansionsFileInfo[i].Version > 0 && m_expansionsFileInfo[i].Size > 0)
         {
-            if(!m_JavaApkExpansionFiles.callMethod<jboolean>("isAPKFileDelivered",
+            if(!m_javaApkExpansionFiles.callMethod<jboolean>("isAPKFileDelivered",
                                                              "(ZII)Z",
                                                              (i == 0) ? true : false,
-                                                             m_ExpansionsFileInfo[i].Version,
-                                                             m_ExpansionsFileInfo[i].Size))
+                                                             m_expansionsFileInfo[i].Version,
+                                                             m_expansionsFileInfo[i].Size))
             {
                 enum { NO_DOWNLOAD_REQUIRED = 0, LVL_CHECK_REQUIRED = 1, DOWNLOAD_REQUIRED = 2 };
-                QAndroidJniEnvironment JniEnv;
-                int DownloadResult;
-                jbyte Buffer[20];
+                QAndroidJniEnvironment jniEnv;
+                int downloadResult;
+                jbyte buffer[20];
                 jbyteArray SALT;
 
-                for(int i = 0; i < 20; i++) Buffer[i] = static_cast<jbyte>(m_SALT[i]);
+                for(int i = 0; i < 20; i++) buffer[i] = static_cast<jbyte>(m_SALT[i]);
 
-                SALT = JniEnv->NewByteArray(20);
-                JniEnv->SetByteArrayRegion(SALT, 0, 20, Buffer);
+                SALT = jniEnv->NewByteArray(20);
+                jniEnv->SetByteArrayRegion(SALT, 0, 20, buffer);
 
-                DownloadResult = m_JavaApkExpansionFiles.callMethod<jint>("startDownloader",
+                downloadResult = m_javaApkExpansionFiles.callMethod<jint>("startDownloader",
                                                                           "(Ljava/lang/String;[B)I",
-                                                                          QAndroidJniObject::fromString(m_Base64PublicKey).object<jstring>(),
+                                                                          QAndroidJniObject::fromString(m_base64PublicKey).object<jstring>(),
                                                                           SALT
                                                                           );
-                JniEnv->DeleteLocalRef(SALT);
+                jniEnv->DeleteLocalRef(SALT);
 
-                switch(DownloadResult)
+                switch(downloadResult)
                 {
                     case NO_DOWNLOAD_REQUIRED:
                         return APKEF_NO_DOWNLOAD_REQUIRED;
@@ -143,58 +143,58 @@ QAndroidApkExpansionFiles::APKEF_STATE QAndroidApkExpansionFiles::startDownloadF
 
 QString QAndroidApkExpansionFiles::mainFileName()
 {
-    QString FileName;
+    QString fileName;
 
-    if(m_JavaApkExpansionFiles.isValid() && m_ExpansionsFileInfo[0].Version > 0)
+    if(m_javaApkExpansionFiles.isValid() && m_expansionsFileInfo[0].Version > 0)
     {
-        const QAndroidJniObject JavaFileName = m_JavaApkExpansionFiles.callObjectMethod("getExpansionAPKFileName",
+        const QAndroidJniObject JavaFileName = m_javaApkExpansionFiles.callObjectMethod("getExpansionAPKFileName",
                                                                                         "(ZI)Ljava/lang/String;",
                                                                                         true,
-                                                                                        m_ExpansionsFileInfo[0].Version
+                                                                                        m_expansionsFileInfo[0].Version
                                                                                         );
-        FileName = JavaFileName.toString();
+        fileName = JavaFileName.toString();
     }
 
-    return FileName;
+    return fileName;
 }
 
 QString QAndroidApkExpansionFiles::patchFileName()
 {
-    QString FileName;
+    QString fileName;
 
-    if(m_JavaApkExpansionFiles.isValid() && m_ExpansionsFileInfo[1].Version > 0)
+    if(m_javaApkExpansionFiles.isValid() && m_expansionsFileInfo[1].Version > 0)
     {
-        const QAndroidJniObject JavaFileName = m_JavaApkExpansionFiles.callObjectMethod("getExpansionAPKFileName",
+        const QAndroidJniObject JavaFileName = m_javaApkExpansionFiles.callObjectMethod("getExpansionAPKFileName",
                                                                                         "(ZI)Ljava/lang/String;",
                                                                                         false,
-                                                                                        m_ExpansionsFileInfo[1].Version
+                                                                                        m_expansionsFileInfo[1].Version
                                                                                         );
-        FileName = JavaFileName.toString();
+        fileName = JavaFileName.toString();
     }
 
-    return FileName;
+    return fileName;
 }
 
 void QAndroidApkExpansionFiles::abortDownload()
 {
-    SendRequest(REQUEST_ABORT_DOWNLOAD);
+    sendRequest(REQUEST_ABORT_DOWNLOAD);
 }
 
 void QAndroidApkExpansionFiles::pauseDownload()
 {
-    SendRequest(REQUEST_PAUSE_DOWNLOAD);
+    sendRequest(REQUEST_PAUSE_DOWNLOAD);
 }
 
 void QAndroidApkExpansionFiles::continueDownload()
 {
-    SendRequest(REQUEST_CONTINUE_DOWNLOAD);
+    sendRequest(REQUEST_CONTINUE_DOWNLOAD);
 }
 
-void QAndroidApkExpansionFiles::SendRequest(REQUEST_ID requestID)
+void QAndroidApkExpansionFiles::sendRequest(REQUEST_ID requestID)
 {
-    if(m_JavaApkExpansionFiles.isValid())
+    if(m_javaApkExpansionFiles.isValid())
     {
-        m_JavaApkExpansionFiles.callMethod<void>("sendRequest",
+        m_javaApkExpansionFiles.callMethod<void>("sendRequest",
                                                  "(I)V",
                                                  requestID
                                                  );
@@ -203,12 +203,12 @@ void QAndroidApkExpansionFiles::SendRequest(REQUEST_ID requestID)
 
 const QString& QAndroidApkExpansionFiles::getBase64PublicKey() const
 {
-    return m_Base64PublicKey;
+    return m_base64PublicKey;
 }
 
-void QAndroidApkExpansionFiles::setBase64PublicKey(const QString &Base64PublicKey)
+void QAndroidApkExpansionFiles::setBase64PublicKey(const QString &base64PublicKey)
 {
-    m_Base64PublicKey = Base64PublicKey;
+    m_base64PublicKey = base64PublicKey;
 }
 
 const QVector<int>& QAndroidApkExpansionFiles::getSALT() const
@@ -223,131 +223,131 @@ void QAndroidApkExpansionFiles::setSALT(const QVector<int> &SALT)
 
 const QAndroidApkExpansionFileInfo& QAndroidApkExpansionFiles::getMainExpansionFileInfo() const
 {
-    return m_ExpansionsFileInfo[0];
+    return m_expansionsFileInfo[0];
 }
 
-void QAndroidApkExpansionFiles::setMainExpansionFileInfo(const QAndroidApkExpansionFileInfo &MainExpansionFileInfo)
+void QAndroidApkExpansionFiles::setMainExpansionFileInfo(const QAndroidApkExpansionFileInfo &mainExpansionFileInfo)
 {
-    m_ExpansionsFileInfo[0] = MainExpansionFileInfo;
+    m_expansionsFileInfo[0] = mainExpansionFileInfo;
 }
 
 const QAndroidApkExpansionFileInfo& QAndroidApkExpansionFiles::getPatchExpansionFileInfo() const
 {
-    return m_ExpansionsFileInfo[1];
+    return m_expansionsFileInfo[1];
 }
 
-void QAndroidApkExpansionFiles::setPatchExpansionFileInfo(const QAndroidApkExpansionFileInfo &PatchExpansionFileInfo)
+void QAndroidApkExpansionFiles::setPatchExpansionFileInfo(const QAndroidApkExpansionFileInfo &patchExpansionFileInfo)
 {
-    m_ExpansionsFileInfo[1] = PatchExpansionFileInfo;
+    m_expansionsFileInfo[1] = patchExpansionFileInfo;
 }
 
-jstring QAndroidApkExpansionFiles::DownloaderGetString(JNIEnv *env, jobject thiz, jint StringID)
+jstring QAndroidApkExpansionFiles::downloaderGetString(JNIEnv *env, jobject thiz, jint stringID)
 {
-    QString TextString;
+    QString textString;
 
     Q_UNUSED(thiz)
 
     if(m_pInstance != nullptr)
     {
-        TextString = m_pInstance->getString(StringID);
+        textString = m_pInstance->getString(stringID);
     }
 
-    return env->NewString(TextString.utf16(), TextString.length());
+    return env->NewString(textString.utf16(), textString.length());
 }
 
-void QAndroidApkExpansionFiles::DownloadStateChanged(JNIEnv *env, jobject thiz, jint NewState)
+void QAndroidApkExpansionFiles::downloaderStateChanged(JNIEnv *env, jobject thiz, jint newState)
 {
     Q_UNUSED(env)
     Q_UNUSED(thiz)
 
     if(m_pInstance != nullptr)
     {
-        emit m_pInstance->downloadStateChanged(NewState);
+        Q_EMIT m_pInstance->downloadStateChanged(newState);
     }
 }
 
-void QAndroidApkExpansionFiles::DownloadProgress(JNIEnv *env, jobject thiz, jlong OverallTotal, jlong OverallProgress, jlong TimeRemaining, jfloat CurrentSpeed)
+void QAndroidApkExpansionFiles::downloaderProgress(JNIEnv *env, jobject thiz, jlong overallTotal, jlong overallProgress, jlong timeRemaining, jfloat currentSpeed)
 {
     Q_UNUSED(env)
     Q_UNUSED(thiz)
 
     if(m_pInstance != nullptr)
     {
-        emit m_pInstance->downloadProgress(OverallTotal, OverallProgress, TimeRemaining, CurrentSpeed);
+        Q_EMIT m_pInstance->downloadProgress(overallTotal, overallProgress, timeRemaining, currentSpeed);
     }
 }
 
 QString QAndroidApkExpansionFiles::getString(int stringID)
 {
-    QString TextString;
+    QString textString;
 
     switch(stringID)
     {
         case STRING_IDLE:
-            TextString = tr("Waiting for download to start");
+            textString = tr("Waiting for download to start");
             break;
         case STRING_FETCHING_URL:
-            TextString = tr("Looking for resources to download");
+            textString = tr("Looking for resources to download");
             break;
         case STRING_CONNECTING:
-            TextString = tr("Connecting to the download server");
+            textString = tr("Connecting to the download server");
             break;
         case STRING_DOWNLOADING:
-            TextString = tr("Downloading resources");
+            textString = tr("Downloading resources");
             break;
         case STRING_COMPLETED:
-            TextString = tr("Download finished");
+            textString = tr("Download finished");
             break;
         case STRING_PAUSED_NETWORK_UNAVAILABLE:
-            TextString = tr("Download paused because no network is available");
+            textString = tr("Download paused because no network is available");
             break;
         case STRING_PAUSED_BY_REQUEST:
-            TextString = tr("Download paused");
+            textString = tr("Download paused");
             break;
         case STRING_PAUSED_WIFI_DISABLED_NEED_CELLULAR_PERMISSION:
-            TextString = tr("Download paused because wifi is disabled");
+            textString = tr("Download paused because wifi is disabled");
             break;
         case STRING_PAUSED_NEED_CELLULAR_PERMISSION:
         case STRING_PAUSED_NEED_WIFI:
-            TextString = tr("Download paused because wifi is unavailable");
+            textString = tr("Download paused because wifi is unavailable");
             break;
         case STRING_PAUSED_WIFI_DISABLED:
-            TextString = tr("Download paused because wifi is disabled");
+            textString = tr("Download paused because wifi is disabled");
             break;
         case STRING_PAUSED_ROAMING:
-            TextString = tr("Download paused because you are roaming");
+            textString = tr("Download paused because you are roaming");
             break;
         case STRING_PAUSED_NETWORK_SETUP_FAILURE:
-            TextString = tr("Download paused. Test a website in browser");
+            textString = tr("Download paused. Test a website in browser");
             break;
         case STRING_PAUSED_SDCARD_UNAVAILABLE:
-            TextString = tr("Download paused because the external storage is unavailable");
+            textString = tr("Download paused because the external storage is unavailable");
             break;
         case STRING_FAILED_UNLICENSED:
-            TextString = tr("Download failed because you may not have purchased this app");
+            textString = tr("Download failed because you may not have purchased this app");
             break;
         case STRING_FAILED_FETCHING_URL:
-            TextString = tr("Download failed because the resources could not be found");
+            textString = tr("Download failed because the resources could not be found");
             break;
         case STRING_FAILED_SDCARD_FULL:
-            TextString = tr("Download failed because the external storage is full");
+            textString = tr("Download failed because the external storage is full");
             break;
         case STRING_FAILED_CANCELED:
-            TextString = tr("Download cancelled");
+            textString = tr("Download cancelled");
             break;
         case STRING_FAILED:
-            TextString = tr("Download failed");
+            textString = tr("Download failed");
             break;
         case STRING_UNKNOWN:
-            TextString = tr("Unknown error");
+            textString = tr("Unknown error");
             break;
         case STRING_TIME_LEFT:
-            TextString = tr("Time left");
+            textString = tr("Time left");
             break;
         case STRING_NOTIFICATION_CHANNEL_NAME:
-            TextString = tr("App data download");
+            textString = tr("App data download");
             break;
     }
 
-    return TextString;
+    return textString;
 }

QtAndroidTools/QAndroidApkExpansionFiles.h

@@ -126,31 +126,31 @@ public:
     Q_INVOKABLE void continueDownload();
 
     const QString& getBase64PublicKey() const;
-    void setBase64PublicKey(const QString &Base64PublicKey);
+    void setBase64PublicKey(const QString &base64PublicKey);
     const QVector<int>& getSALT() const;
     void setSALT(const QVector<int> &SALT);
     const QAndroidApkExpansionFileInfo& getMainExpansionFileInfo() const;
-    void setMainExpansionFileInfo(const QAndroidApkExpansionFileInfo &MainExpansionFileInfo);
+    void setMainExpansionFileInfo(const QAndroidApkExpansionFileInfo &mainExpansionFileInfo);
     const QAndroidApkExpansionFileInfo& getPatchExpansionFileInfo() const;
-    void setPatchExpansionFileInfo(const QAndroidApkExpansionFileInfo &PatchExpansionFileInfo);
+    void setPatchExpansionFileInfo(const QAndroidApkExpansionFileInfo &patchExpansionFileInfo);
 
-signals:
+Q_SIGNALS:
     void downloadStateChanged(int newState);
     void downloadProgress(qlonglong overallTotal, qlonglong overallProgress, qlonglong timeRemaining, float currentSpeed);
 
-private slots:
-    void ApplicationStateChanged(Qt::ApplicationState State);
+private Q_SLOTS:
+    void applicationStateChanged(Qt::ApplicationState state);
 
 private:
-    const QAndroidJniObject m_JavaApkExpansionFiles;
+    const QAndroidJniObject m_javaApkExpansionFiles;
     static QAndroidApkExpansionFiles *m_pInstance;
-    QAndroidApkExpansionFileInfo m_ExpansionsFileInfo[2];
-    QString m_Base64PublicKey;
+    QAndroidApkExpansionFileInfo m_expansionsFileInfo[2];
+    QString m_base64PublicKey;
     QVector<int> m_SALT;
 
-    static jstring DownloaderGetString(JNIEnv *env, jobject thiz, jint StringID);
-    static void DownloadStateChanged(JNIEnv *env, jobject thiz, jint NewState);
-    static void DownloadProgress(JNIEnv *env, jobject thiz, jlong OverallTotal, jlong OverallProgress, jlong TimeRemaining, jfloat CurrentSpeed);
+    static jstring downloaderGetString(JNIEnv *env, jobject thiz, jint stringID);
+    static void downloaderStateChanged(JNIEnv *env, jobject thiz, jint newState);
+    static void downloaderProgress(JNIEnv *env, jobject thiz, jlong overallTotal, jlong overallProgress, jlong timeRemaining, jfloat currentSpeed);
 
     enum APP_STATE
     {
@@ -159,7 +159,7 @@ private:
         APP_STATE_STOP,
         APP_STATE_DESTROY
     };
-    void SetNewAppState(APP_STATE NewState);
+    void setNewAppState(APP_STATE newState);
     enum REQUEST_ID
     {
         REQUEST_ABORT_DOWNLOAD = 0,
@@ -167,5 +167,5 @@ private:
         REQUEST_CONTINUE_DOWNLOAD,
         REQUEST_DOWNLOAD_STATUS
     };
-    void SendRequest(REQUEST_ID requestID);
+    void sendRequest(REQUEST_ID requestID);
 };

QtAndroidTools/QAndroidApkInfo.cpp

@@ -28,7 +28,7 @@ QAndroidApkInfo *QAndroidApkInfo::m_pInstance = nullptr;
 QAndroidApkInfo::QAndroidApkInfo()
 {
     m_pInstance = this;
-    LoadApkPackageInfo();
+    loadApkPackageInfo();
 }
 
 QObject* QAndroidApkInfo::qmlInstance(QQmlEngine *engine, QJSEngine *scriptEngine)
@@ -46,80 +46,80 @@ QAndroidApkInfo* QAndroidApkInfo::instance()
 
 qlonglong QAndroidApkInfo::getFirstInstallTime() const
 {
-    return m_ApkInfo.FirstInstallTime;
+    return m_apkInfo.firstInstallTime;
 }
 
 qlonglong QAndroidApkInfo::getLastUpdateTime() const
 {
-    return m_ApkInfo.LastUpdateTime;
+    return m_apkInfo.lastUpdateTime;
 }
 
 const QString& QAndroidApkInfo::getPackageName() const
 {
-    return m_ApkInfo.PackageName;
+    return m_apkInfo.packageName;
 }
 
 const QStringList& QAndroidApkInfo::getRequestedPermissions() const
 {
-    return m_ApkInfo.RequestedPermissions;
+    return m_apkInfo.requestedPermissions;
 }
 
 int QAndroidApkInfo::getVersionCode() const
 {
-    return m_ApkInfo.VersionCode;
+    return m_apkInfo.versionCode;
 }
 
 const QString& QAndroidApkInfo::getVersionName() const
 {
-    return m_ApkInfo.VersionName;
+    return m_apkInfo.versionName;
 }
 
-void QAndroidApkInfo::LoadApkPackageInfo()
+void QAndroidApkInfo::loadApkPackageInfo()
 {
-    const int InfoFlags = QAndroidJniObject::getStaticField<jint>("android/content/pm/PackageManager", "GET_PERMISSIONS");
-    const QAndroidJniObject Activity = QtAndroid::androidActivity();
-    QAndroidJniObject PackageName, PackageManager, PackageInfo;
-    QAndroidJniEnvironment JniEnv;
+    const int infoFlags = QAndroidJniObject::getStaticField<jint>("android/content/pm/PackageManager", "GET_PERMISSIONS");
+    const QAndroidJniObject activity = QtAndroid::androidActivity();
+    QAndroidJniObject packageName, packageManager, packageInfo;
+    QAndroidJniEnvironment jniEnv;
 
-    PackageManager = Activity.callObjectMethod("getPackageManager", "()Landroid/content/pm/PackageManager;");
-    PackageName = Activity.callObjectMethod("getPackageName", "()Ljava/lang/String;");
+    packageManager = activity.callObjectMethod("getPackageManager", "()Landroid/content/pm/PackageManager;");
+    packageName = activity.callObjectMethod("getPackageName", "()Ljava/lang/String;");
 
-    PackageInfo = PackageManager.callObjectMethod("getPackageInfo",
+    packageInfo = packageManager.callObjectMethod("getPackageInfo",
                                                   "(Ljava/lang/String;I)Landroid/content/pm/PackageInfo;",
-                                                  PackageName.object<jstring>(),
-                                                  InfoFlags
+                                                  packageName.object<jstring>(),
+                                                  infoFlags
                                                   );
-    if(!JniEnv->ExceptionCheck())
+    if(!jniEnv->ExceptionCheck())
     {
-        m_ApkInfo.FirstInstallTime = PackageInfo.getField<jlong>("firstInstallTime");
-        m_ApkInfo.LastUpdateTime = PackageInfo.getField<jlong>("lastUpdateTime");
-        m_ApkInfo.PackageName = PackageInfo.getObjectField<jstring>("packageName").toString();
-        m_ApkInfo.RequestedPermissions = GetStringListField(PackageInfo, "requestedPermissions");
-        m_ApkInfo.VersionCode = PackageInfo.getField<jint>("versionCode");
-        m_ApkInfo.VersionName = PackageInfo.getObjectField<jstring>("versionName").toString();
+        m_apkInfo.firstInstallTime = packageInfo.getField<jlong>("firstInstallTime");
+        m_apkInfo.lastUpdateTime = packageInfo.getField<jlong>("lastUpdateTime");
+        m_apkInfo.packageName = packageInfo.getObjectField<jstring>("packageName").toString();
+        m_apkInfo.requestedPermissions = getStringListField(packageInfo, "requestedPermissions");
+        m_apkInfo.versionCode = packageInfo.getField<jint>("versionCode");
+        m_apkInfo.versionName = packageInfo.getObjectField<jstring>("versionName").toString();
     }
     else
     {
-        JniEnv->ExceptionClear();
+        jniEnv->ExceptionClear();
     }
 }
 
-QStringList QAndroidApkInfo::GetStringListField(const QAndroidJniObject &JniObject, const QString &FieldName) const
+QStringList QAndroidApkInfo::getStringListField(const QAndroidJniObject &jniObject, const QString &fieldName) const
 {
-    const QAndroidJniObject StringArrayObj = JniObject.getObjectField(FieldName.toStdString().c_str(), "[Ljava/lang/String;");
-    QAndroidJniEnvironment JniEnv;
-    QStringList StringList;
+    const QAndroidJniObject stringArrayObj = jniObject.getObjectField(fieldName.toStdString().c_str(), "[Ljava/lang/String;");
+    QAndroidJniEnvironment jniEnv;
+    QStringList stringList;
 
-    if(StringArrayObj.isValid())
+    if(stringArrayObj.isValid())
     {
-        const jobjectArray StringJObjArray = StringArrayObj.object<jobjectArray>();
-        const int StringsNum = JniEnv->GetArrayLength(StringJObjArray);
+        const jobjectArray stringJObjArray = stringArrayObj.object<jobjectArray>();
+        const int StringsNum = jniEnv->GetArrayLength(stringJObjArray);
 
         for(int i = 0; i < StringsNum; i++)
         {
-            StringList << QAndroidJniObject::fromLocalRef(JniEnv->GetObjectArrayElement(StringJObjArray, i)).toString();
+            stringList << QAndroidJniObject::fromLocalRef(jniEnv->GetObjectArrayElement(stringJObjArray, i)).toString();
         }
     }
 
-    return StringList;
+    return stringList;
 }

QtAndroidTools/QAndroidApkInfo.h

@@ -54,14 +54,14 @@ private:
     static QAndroidApkInfo *m_pInstance;
 
     struct {
-        qlonglong FirstInstallTime;
-        qlonglong LastUpdateTime;
-        QString PackageName;
-        QStringList RequestedPermissions;
-        int VersionCode;
-        QString VersionName;
-    } m_ApkInfo;
+        qlonglong firstInstallTime;
+        qlonglong lastUpdateTime;
+        QString packageName;
+        QStringList requestedPermissions;
+        int versionCode;
+        QString versionName;
+    } m_apkInfo;
 
-    void LoadApkPackageInfo();
-    QStringList GetStringListField(const QAndroidJniObject &JniObject, const QString &FieldName) const;
+    void loadApkPackageInfo();
+    QStringList getStringListField(const QAndroidJniObject &jniObject, const QString &fieldName) const;
 };

QtAndroidTools/QAndroidAppPermissions.cpp

@@ -45,40 +45,40 @@ QAndroidAppPermissions* QAndroidAppPermissions::instance()
 
 void QAndroidAppPermissions::requestPermissions(const QStringList &permissionsNameList)
 {
-    QtAndroid::PermissionResultMap ResultMap;
+    QtAndroid::PermissionResultMap resultMap;
 
     if(QtAndroid::androidSdkVersion() >= 23)
     {
-        QStringList PermissionsNotGrantedList;
+        QStringList permissionsNotGrantedList;
 
         for(int i = 0; i < permissionsNameList.count(); i++)
         {
             if(QtAndroid::checkPermission(permissionsNameList[i]) != QtAndroid::PermissionResult::Granted)
             {
-                PermissionsNotGrantedList << permissionsNameList[i];
+                permissionsNotGrantedList << permissionsNameList[i];
             }
             else
             {
-                ResultMap[permissionsNameList[i]] = QtAndroid::PermissionResult::Granted;
+                resultMap[permissionsNameList[i]] = QtAndroid::PermissionResult::Granted;
             }
         }
 
-        if(PermissionsNotGrantedList.count() > 0)
+        if(permissionsNotGrantedList.count() > 0)
         {
-            QtAndroid::requestPermissions(PermissionsNotGrantedList, std::bind(&QAndroidAppPermissions::RequestPermissionResults, this, std::placeholders::_1));
+            QtAndroid::requestPermissions(permissionsNotGrantedList, std::bind(&QAndroidAppPermissions::requestPermissionResults, this, std::placeholders::_1));
         }
     }
     else
     {
         for(int i = 0; i < permissionsNameList.count(); i++)
         {
-            ResultMap[permissionsNameList[i]] = QtAndroid::PermissionResult::Granted;
+            resultMap[permissionsNameList[i]] = QtAndroid::PermissionResult::Granted;
         }
     }
 
-    if(ResultMap.size() > 0)
+    if(resultMap.size() > 0)
     {
-        emit requestPermissionsResults(ConvertToVariantList(ResultMap));
+        Q_EMIT requestPermissionsResults(convertToVariantList(resultMap));
     }
 }
 
@@ -86,13 +86,13 @@ void QAndroidAppPermissions::requestPermission(const QString &permissionName)
 {
     if(QtAndroid::androidSdkVersion() >= 23 && QtAndroid::checkPermission(permissionName) != QtAndroid::PermissionResult::Granted)
     {
-        QtAndroid::requestPermissions(QStringList() << permissionName, std::bind(&QAndroidAppPermissions::RequestPermissionResults, this, std::placeholders::_1));
+        QtAndroid::requestPermissions(QStringList() << permissionName, std::bind(&QAndroidAppPermissions::requestPermissionResults, this, std::placeholders::_1));
     }
     else
     {
-        QtAndroid::PermissionResultMap ResultMap;
-        ResultMap[permissionName] = QtAndroid::PermissionResult::Granted;
-        emit requestPermissionsResults(ConvertToVariantList(ResultMap));
+        QtAndroid::PermissionResultMap resultMap;
+        resultMap[permissionName] = QtAndroid::PermissionResult::Granted;
+        Q_EMIT requestPermissionsResults(convertToVariantList(resultMap));
     }
 }
 
@@ -111,26 +111,26 @@ bool QAndroidAppPermissions::isPermissionGranted(const QString &permissionName)
     return (QtAndroid::checkPermission(permissionName) == QtAndroid::PermissionResult::Granted) ? true : false;
 }
 
-void QAndroidAppPermissions::RequestPermissionResults(const QtAndroid::PermissionResultMap &ResultMap)
+void QAndroidAppPermissions::requestPermissionResults(const QtAndroid::PermissionResultMap &resultMap)
 {
-    emit requestPermissionsResults(ConvertToVariantList(ResultMap));
+    Q_EMIT requestPermissionsResults(convertToVariantList(resultMap));
 }
 
-QVariantList QAndroidAppPermissions::ConvertToVariantList(const QtAndroid::PermissionResultMap &ResultMap)
+QVariantList QAndroidAppPermissions::convertToVariantList(const QtAndroid::PermissionResultMap &resultMap)
 {
-    QtAndroid::PermissionResultMap::const_iterator PermissionItem = ResultMap.constBegin();
-    QVariantList PermissionsList;
+    QtAndroid::PermissionResultMap::const_iterator permissionItem = resultMap.constBegin();
+    QVariantList permissionsList;
 
-    while(PermissionItem != ResultMap.constEnd())
+    while(permissionItem != resultMap.constEnd())
     {
-        QVariantMap PermissionResult;
+        QVariantMap permissionResult;
 
-        PermissionResult["name"] = PermissionItem.key();
-        PermissionResult["granted"] = (PermissionItem.value() == QtAndroid::PermissionResult::Granted) ? true : false;
-        PermissionsList << PermissionResult;
+        permissionResult["name"] = permissionItem.key();
+        permissionResult["granted"] = (permissionItem.value() == QtAndroid::PermissionResult::Granted) ? true : false;
+        permissionsList << permissionResult;
 
-        ++PermissionItem;
+        ++permissionItem;
     }
 
-    return PermissionsList;
+    return permissionsList;
 }

QtAndroidTools/QAndroidAppPermissions.h

@@ -43,12 +43,12 @@ public:
     Q_INVOKABLE bool shouldShowRequestPermissionInfo(const QString &permissionName);
     Q_INVOKABLE bool isPermissionGranted(const QString &permissionName);
 
-signals:
+Q_SIGNALS:
     void requestPermissionsResults(const QVariantList &results);
 
 private:
     static QAndroidAppPermissions *m_pInstance;
 
-    void RequestPermissionResults(const QtAndroid::PermissionResultMap &ResultMap);
-    QVariantList ConvertToVariantList(const QtAndroid::PermissionResultMap &ResultMap);
+    void requestPermissionResults(const QtAndroid::PermissionResultMap &resultMap);
+    QVariantList convertToVariantList(const QtAndroid::PermissionResultMap &resultMap);
 };

QtAndroidTools/QAndroidBatteryState.cpp

@@ -26,32 +26,32 @@
 
 QAndroidBatteryState *QAndroidBatteryState::m_pInstance = nullptr;
 
-QAndroidBatteryState::QAndroidBatteryState() : m_JavaBatteryState("com/falsinsoft/qtandroidtools/AndroidBatteryState",
+QAndroidBatteryState::QAndroidBatteryState() : m_javaBatteryState("com/falsinsoft/qtandroidtools/AndroidBatteryState",
                                                                   "(Landroid/app/Activity;)V",
                                                                   QtAndroid::androidActivity().object<jobject>())
 {
     m_pInstance = this;
 
-    if(m_JavaBatteryState.isValid())
+    if(m_javaBatteryState.isValid())
     {
-        const JNINativeMethod JniMethod[] = {
-            {"batteryLevelChanged", "()V", reinterpret_cast<void *>(&QAndroidBatteryState::BatteryLevelChanged)},
-            {"batteryOnChargeChanged", "()V", reinterpret_cast<void *>(&QAndroidBatteryState::BatteryOnChargeChanged)}
+        const JNINativeMethod jniMethod[] = {
+            {"batteryLevelChanged", "()V", reinterpret_cast<void *>(&QAndroidBatteryState::batteryLevelChanged)},
+            {"batteryOnChargeChanged", "()V", reinterpret_cast<void *>(&QAndroidBatteryState::batteryOnChargeChanged)}
         };
-        QAndroidJniEnvironment JniEnv;
-        jclass ObjectClass;
+        QAndroidJniEnvironment jniEnv;
+        jclass objectClass;
 
-        ObjectClass = JniEnv->GetObjectClass(m_JavaBatteryState.object<jobject>());
-        JniEnv->RegisterNatives(ObjectClass, JniMethod, sizeof(JniMethod)/sizeof(JNINativeMethod));
-        JniEnv->DeleteLocalRef(ObjectClass);
+        objectClass = jniEnv->GetObjectClass(m_javaBatteryState.object<jobject>());
+        jniEnv->RegisterNatives(objectClass, jniMethod, sizeof(jniMethod)/sizeof(JNINativeMethod));
+        jniEnv->DeleteLocalRef(objectClass);
     }
-    connect(qGuiApp, &QGuiApplication::applicationStateChanged, this, &QAndroidBatteryState::ApplicationStateChanged);
-    SetNewAppState(APP_STATE_CREATE);
+    connect(qGuiApp, &QGuiApplication::applicationStateChanged, this, &QAndroidBatteryState::applicationStateChanged);
+    setNewAppState(APP_STATE_CREATE);
 }
 
 QAndroidBatteryState::~QAndroidBatteryState()
 {
-    SetNewAppState(APP_STATE_DESTROY);
+    setNewAppState(APP_STATE_DESTROY);
 }
 
 QObject* QAndroidBatteryState::qmlInstance(QQmlEngine *engine, QJSEngine *scriptEngine)
@@ -67,58 +67,58 @@ QAndroidBatteryState* QAndroidBatteryState::instance()
     return m_pInstance;
 }
 
-void QAndroidBatteryState::BatteryLevelChanged(JNIEnv *env, jobject thiz)
+void QAndroidBatteryState::batteryLevelChanged(JNIEnv *env, jobject thiz)
 {
     Q_UNUSED(env)
     Q_UNUSED(thiz)
 
     if(m_pInstance != nullptr)
     {
-        emit m_pInstance->levelChanged();
+        Q_EMIT m_pInstance->levelChanged();
     }
 }
 
-void QAndroidBatteryState::BatteryOnChargeChanged(JNIEnv *env, jobject thiz)
+void QAndroidBatteryState::batteryOnChargeChanged(JNIEnv *env, jobject thiz)
 {
     Q_UNUSED(env)
     Q_UNUSED(thiz)
 
     if(m_pInstance != nullptr)
     {
-        emit m_pInstance->onChargeChanged();
+        Q_EMIT m_pInstance->onChargeChanged();
     }
 }
 
 int QAndroidBatteryState::getLevel()
 {
-    if(m_JavaBatteryState.isValid())
+    if(m_javaBatteryState.isValid())
     {
-        return m_JavaBatteryState.callMethod<jint>("getLevel");
+        return m_javaBatteryState.callMethod<jint>("getLevel");
     }
     return 0;
 }
 
 bool QAndroidBatteryState::isOnCharge()
 {
-    if(m_JavaBatteryState.isValid())
+    if(m_javaBatteryState.isValid())
     {
-        return m_JavaBatteryState.callMethod<jboolean>("isOnCharge");
+        return m_javaBatteryState.callMethod<jboolean>("isOnCharge");
     }
     return false;
 }
 
-void QAndroidBatteryState::ApplicationStateChanged(Qt::ApplicationState State)
+void QAndroidBatteryState::applicationStateChanged(Qt::ApplicationState state)
 {
-    SetNewAppState((State == Qt::ApplicationActive) ? APP_STATE_START : APP_STATE_STOP);
+    setNewAppState((state == Qt::ApplicationActive) ? APP_STATE_START : APP_STATE_STOP);
 }
 
-void QAndroidBatteryState::SetNewAppState(APP_STATE NewState)
+void QAndroidBatteryState::setNewAppState(APP_STATE newState)
 {
-    if(m_JavaBatteryState.isValid())
+    if(m_javaBatteryState.isValid())
     {
-        m_JavaBatteryState.callMethod<void>("appStateChanged",
+        m_javaBatteryState.callMethod<void>("appStateChanged",
                                             "(I)V",
-                                            NewState
+                                            newState
                                             );
     }
 }

QtAndroidTools/QAndroidBatteryState.h

@@ -44,19 +44,19 @@ public:
     int getLevel();
     bool isOnCharge();
 
-signals:
+Q_SIGNALS:
     void levelChanged();
     void onChargeChanged();
 
-private slots:
-    void ApplicationStateChanged(Qt::ApplicationState State);
+private Q_SLOTS:
+    void applicationStateChanged(Qt::ApplicationState state);
 
 private:
-    const QAndroidJniObject m_JavaBatteryState;
+    const QAndroidJniObject m_javaBatteryState;
     static QAndroidBatteryState *m_pInstance;
 
-    static void BatteryLevelChanged(JNIEnv *env, jobject thiz);
-    static void BatteryOnChargeChanged(JNIEnv *env, jobject thiz);
+    static void batteryLevelChanged(JNIEnv *env, jobject thiz);
+    static void batteryOnChargeChanged(JNIEnv *env, jobject thiz);
 
     enum APP_STATE
     {
@@ -65,5 +65,5 @@ private:
         APP_STATE_STOP,
         APP_STATE_DESTROY
     };
-    void SetNewAppState(APP_STATE NewState);
+    void setNewAppState(APP_STATE newState);
 };

QtAndroidTools/QAndroidGoogleAccount.cpp

@@ -26,25 +26,25 @@
 
 QAndroidGoogleAccount *QAndroidGoogleAccount::m_pInstance = nullptr;
 
-QAndroidGoogleAccount::QAndroidGoogleAccount() : m_JavaGoogleAccount("com/falsinsoft/qtandroidtools/AndroidGoogleAccount",
+QAndroidGoogleAccount::QAndroidGoogleAccount() : m_javaGoogleAccount("com/falsinsoft/qtandroidtools/AndroidGoogleAccount",
                                                                      "(Landroid/app/Activity;)V",
                                                                      QtAndroid::androidActivity().object<jobject>())
 {
     m_pInstance = this;
 
-    if(m_JavaGoogleAccount.isValid())
+    if(m_javaGoogleAccount.isValid())
     {
-        const JNINativeMethod JniMethod[] = {
-            {"updateSignedInAccountInfo", "(Lcom/falsinsoft/qtandroidtools/AndroidGoogleAccount$AccountInfo;)V", reinterpret_cast<void*>(&QAndroidGoogleAccount::UpdateSignedInAccountInfo)},
-            {"signedIn", "(Z)V", reinterpret_cast<void*>(&QAndroidGoogleAccount::SignedIn)},
-            {"signedOut", "()V", reinterpret_cast<void*>(&QAndroidGoogleAccount::SignedOut)}
+        const JNINativeMethod jniMethod[] = {
+            {"updateSignedInAccountInfo", "(Lcom/falsinsoft/qtandroidtools/AndroidGoogleAccount$AccountInfo;)V", reinterpret_cast<void*>(&QAndroidGoogleAccount::updateSignedInAccountInfo)},
+            {"signedIn", "(Z)V", reinterpret_cast<void*>(&QAndroidGoogleAccount::signedInAccount)},
+            {"signedOut", "()V", reinterpret_cast<void*>(&QAndroidGoogleAccount::signedOutAccount)}
         };
         QAndroidJniEnvironment JniEnv;
-        jclass ObjectClass;
+        jclass objectClass;
 
-        ObjectClass = JniEnv->GetObjectClass(m_JavaGoogleAccount.object<jobject>());
-        JniEnv->RegisterNatives(ObjectClass, JniMethod, sizeof(JniMethod)/sizeof(JNINativeMethod));
-        JniEnv->DeleteLocalRef(ObjectClass);
+        objectClass = JniEnv->GetObjectClass(m_javaGoogleAccount.object<jobject>());
+        JniEnv->RegisterNatives(objectClass, jniMethod, sizeof(jniMethod)/sizeof(JNINativeMethod));
+        JniEnv->DeleteLocalRef(objectClass);
     }
 }
 
@@ -61,29 +61,29 @@ QAndroidGoogleAccount* QAndroidGoogleAccount::instance()
     return m_pInstance;
 }
 
-bool QAndroidGoogleAccount::signIn(const QString &ScopeName)
+bool QAndroidGoogleAccount::signIn(const QString &scopeName)
 {
-    if(m_JavaGoogleAccount.isValid())
+    if(m_javaGoogleAccount.isValid())
     {
-        return m_JavaGoogleAccount.callMethod<jboolean>("signIn",
+        return m_javaGoogleAccount.callMethod<jboolean>("signIn",
                                                         "(Ljava/lang/String;)Z",
-                                                        QAndroidJniObject::fromString(ScopeName).object<jstring>()
+                                                        QAndroidJniObject::fromString(scopeName).object<jstring>()
                                                         );
     }
     return false;
 }
 
-bool QAndroidGoogleAccount::signInSelectAccount(const QString &ScopeName)
+bool QAndroidGoogleAccount::signInSelectAccount(const QString &scopeName)
 {
-    if(m_JavaGoogleAccount.isValid())
+    if(m_javaGoogleAccount.isValid())
     {
-        const QAndroidJniObject SignInIntent = m_JavaGoogleAccount.callObjectMethod("getSignInIntent",
+        const QAndroidJniObject signInIntent = m_javaGoogleAccount.callObjectMethod("getSignInIntent",
                                                                                     "(Ljava/lang/String;)Landroid/content/Intent;",
-                                                                                    QAndroidJniObject::fromString(ScopeName).object<jstring>()
+                                                                                    QAndroidJniObject::fromString(scopeName).object<jstring>()
                                                                                     );
-        if(SignInIntent.isValid())
+        if(signInIntent.isValid())
         {
-            QtAndroid::startActivity(SignInIntent, m_SignInId, this);
+            QtAndroid::startActivity(signInIntent, m_signInId, this);
             return true;
         }
     }
@@ -92,110 +92,110 @@ bool QAndroidGoogleAccount::signInSelectAccount(const QString &ScopeName)
 
 bool QAndroidGoogleAccount::signOut()
 {
-    if(m_JavaGoogleAccount.isValid())
+    if(m_javaGoogleAccount.isValid())
     {
-        return m_JavaGoogleAccount.callMethod<jboolean>("signOut", "()Z");
+        return m_javaGoogleAccount.callMethod<jboolean>("signOut", "()Z");
     }
     return false;
 }
 
 bool QAndroidGoogleAccount::revokeAccess()
 {
-    if(m_JavaGoogleAccount.isValid())
+    if(m_javaGoogleAccount.isValid())
     {
-        return m_JavaGoogleAccount.callMethod<jboolean>("revokeAccess", "()Z");
+        return m_javaGoogleAccount.callMethod<jboolean>("revokeAccess", "()Z");
     }
     return false;
 }
 
-void QAndroidGoogleAccount::SetSignedInAccountInfo(const QAndroidJniObject &AccountInfoObj)
+void QAndroidGoogleAccount::setSignedInAccountInfo(const QAndroidJniObject &accountInfoObj)
 {
-    if(AccountInfoObj.isValid())
+    if(accountInfoObj.isValid())
     {
-        const QAndroidJniObject PhotoObj = AccountInfoObj.getObjectField("photo", "Landroid/graphics/Bitmap;");
+        const QAndroidJniObject photoObj = accountInfoObj.getObjectField("photo", "Landroid/graphics/Bitmap;");
 
-        m_SignedInAccountInfo.Id = AccountInfoObj.getObjectField<jstring>("id").toString();
-        m_SignedInAccountInfo.DisplayName = AccountInfoObj.getObjectField<jstring>("displayName").toString();
-        m_SignedInAccountInfo.Email = AccountInfoObj.getObjectField<jstring>("email").toString();
-        m_SignedInAccountInfo.FamilyName = AccountInfoObj.getObjectField<jstring>("familyName").toString();
-        m_SignedInAccountInfo.GivenName = AccountInfoObj.getObjectField<jstring>("givenName").toString();
+        m_signedInAccountInfo.id = accountInfoObj.getObjectField<jstring>("id").toString();
+        m_signedInAccountInfo.displayName = accountInfoObj.getObjectField<jstring>("displayName").toString();
+        m_signedInAccountInfo.email = accountInfoObj.getObjectField<jstring>("email").toString();
+        m_signedInAccountInfo.familyName = accountInfoObj.getObjectField<jstring>("familyName").toString();
+        m_signedInAccountInfo.givenName = accountInfoObj.getObjectField<jstring>("givenName").toString();
 
-        m_SignedInAccountInfo.Photo.clear();
-        if(PhotoObj.isValid())
+        m_signedInAccountInfo.photo.clear();
+        if(photoObj.isValid())
         {
-            const QImage Photo = AndroidBitmapToImage(PhotoObj);
-            QBuffer PhotoBuffer(&m_SignedInAccountInfo.Photo);
+            const QImage photo = androidBitmapToImage(photoObj);
+            QBuffer photoBuffer(&m_signedInAccountInfo.photo);
 
-            PhotoBuffer.open(QIODevice::WriteOnly);
-            Photo.save(&PhotoBuffer, "PNG");
+            photoBuffer.open(QIODevice::WriteOnly);
+            photo.save(&photoBuffer, "PNG");
         }
     }
     else
     {
-        m_SignedInAccountInfo = QAndroidGoogleAccountInfo();
+        m_signedInAccountInfo = QAndroidGoogleAccountInfo();
     }
 
-    emit signedInAccountInfoChanged();
+    Q_EMIT signedInAccountInfoChanged();
 }
 
 const QAndroidGoogleAccountInfo& QAndroidGoogleAccount::getSignedInAccountInfo() const
 {
-    return m_SignedInAccountInfo;
+    return m_signedInAccountInfo;
 }
 
 void QAndroidGoogleAccount::handleActivityResult(int receiverRequestCode, int resultCode, const QAndroidJniObject &data)
 {
     Q_UNUSED(resultCode)
 
-    if(receiverRequestCode == m_SignInId)
+    if(receiverRequestCode == m_signInId)
     {
-        if(m_JavaGoogleAccount.isValid())
+        if(m_javaGoogleAccount.isValid())
         {
-            m_JavaGoogleAccount.callMethod<void>("signInIntentDataResult", "(Landroid/content/Intent;)V", data.object<jobject>());
+            m_javaGoogleAccount.callMethod<void>("signInIntentDataResult", "(Landroid/content/Intent;)V", data.object<jobject>());
         }
     }
 }
 
-void QAndroidGoogleAccount::UpdateSignedInAccountInfo(JNIEnv *env, jobject thiz, jobject accountInfo)
+void QAndroidGoogleAccount::updateSignedInAccountInfo(JNIEnv *env, jobject thiz, jobject accountInfo)
 {
     Q_UNUSED(env)
     Q_UNUSED(thiz)
 
     if(m_pInstance != nullptr)
     {
-        m_pInstance->SetSignedInAccountInfo(QAndroidJniObject(accountInfo));
+        m_pInstance->setSignedInAccountInfo(QAndroidJniObject(accountInfo));
     }
 }
 
-void QAndroidGoogleAccount::SignedIn(JNIEnv *env, jobject thiz, jboolean signInSuccessfully)
+void QAndroidGoogleAccount::signedInAccount(JNIEnv *env, jobject thiz, jboolean signInSuccessfully)
 {
     Q_UNUSED(env)
     Q_UNUSED(thiz)
 
     if(m_pInstance != nullptr)
     {
-        emit m_pInstance->signedIn(signInSuccessfully);
+        Q_EMIT m_pInstance->signedIn(signInSuccessfully);
     }
 }
 
-void QAndroidGoogleAccount::SignedOut(JNIEnv *env, jobject thiz)
+void QAndroidGoogleAccount::signedOutAccount(JNIEnv *env, jobject thiz)
 {
     Q_UNUSED(env)
     Q_UNUSED(thiz)
 
     if(m_pInstance != nullptr)
     {
-        emit m_pInstance->signedOut();
+        Q_EMIT m_pInstance->signedOut();
     }
 }
 
 // Copyright KDAB (BogDan Vatra)
 // https://www.kdab.com/qt-on-android-how-to-convert-qt-images-to-android-images-and-vice-versa-2/
-QImage QAndroidGoogleAccount::AndroidBitmapToImage(const QAndroidJniObject &JniBmp)
+QImage QAndroidGoogleAccount::androidBitmapToImage(const QAndroidJniObject &jniBmp)
 {
     QAndroidJniEnvironment env;
     AndroidBitmapInfo info;
-    if (AndroidBitmap_getInfo(env, JniBmp.object(), &info) != ANDROID_BITMAP_RESULT_SUCCESS)
+    if (AndroidBitmap_getInfo(env, jniBmp.object(), &info) != ANDROID_BITMAP_RESULT_SUCCESS)
         return QImage();
 
     QImage::Format format;
@@ -217,7 +217,7 @@ QImage QAndroidGoogleAccount::AndroidBitmapToImage(const QAndroidJniObject &JniB
     }
 
     void *pixels;
-    if (AndroidBitmap_lockPixels(env, JniBmp.object(), &pixels) != ANDROID_BITMAP_RESULT_SUCCESS)
+    if (AndroidBitmap_lockPixels(env, jniBmp.object(), &pixels) != ANDROID_BITMAP_RESULT_SUCCESS)
         return QImage();
 
     QImage image(info.width, info.height, format);
@@ -232,7 +232,7 @@ QImage QAndroidGoogleAccount::AndroidBitmapToImage(const QAndroidJniObject &JniB
             memcpy((void*)image.constScanLine(y), bmpPtr, width);
     }
 
-    if (AndroidBitmap_unlockPixels(env, JniBmp.object()) != ANDROID_BITMAP_RESULT_SUCCESS)
+    if (AndroidBitmap_unlockPixels(env, jniBmp.object()) != ANDROID_BITMAP_RESULT_SUCCESS)
         return QImage();
 
     return image;

QtAndroidTools/QAndroidGoogleAccount.h

@@ -32,19 +32,19 @@
 struct QAndroidGoogleAccountInfo
 {
     Q_GADGET
-    Q_PROPERTY(QString id MEMBER Id)
-    Q_PROPERTY(QString displayName MEMBER DisplayName)
-    Q_PROPERTY(QString email MEMBER Email)
-    Q_PROPERTY(QString familyName MEMBER FamilyName)
-    Q_PROPERTY(QString givenName MEMBER GivenName)
-    Q_PROPERTY(QByteArray photo MEMBER Photo)
+    Q_PROPERTY(QString id MEMBER id)
+    Q_PROPERTY(QString displayName MEMBER displayName)
+    Q_PROPERTY(QString email MEMBER email)
+    Q_PROPERTY(QString familyName MEMBER familyName)
+    Q_PROPERTY(QString givenName MEMBER givenName)
+    Q_PROPERTY(QByteArray photo MEMBER photo)
 public:
-    QString Id;
-    QString DisplayName;
-    QString Email;
-    QString FamilyName;
-    QString GivenName;
-    QByteArray Photo;
+    QString id;
+    QString displayName;
+    QString email;
+    QString familyName;
+    QString givenName;
+    QByteArray photo;
 };
 Q_DECLARE_METATYPE(QAndroidGoogleAccountInfo)
 
@@ -60,30 +60,30 @@ public:
     static QObject* qmlInstance(QQmlEngine *engine, QJSEngine *scriptEngine);
     static QAndroidGoogleAccount* instance();
 
-    Q_INVOKABLE bool signIn(const QString &ScopeName = QString());
-    Q_INVOKABLE bool signInSelectAccount(const QString &ScopeName = QString());
+    Q_INVOKABLE bool signIn(const QString &scopeName = QString());
+    Q_INVOKABLE bool signInSelectAccount(const QString &scopeName = QString());
     Q_INVOKABLE bool signOut();
     Q_INVOKABLE bool revokeAccess();
 
     const QAndroidGoogleAccountInfo& getSignedInAccountInfo() const;
 
-signals:
+Q_SIGNALS:
     void signedInAccountInfoChanged();
     void signedIn(bool signInSuccessfully);
     void signedOut();
 
 private:
-    const QAndroidJniObject m_JavaGoogleAccount;
+    const QAndroidJniObject m_javaGoogleAccount;
     static QAndroidGoogleAccount *m_pInstance;
-    const int m_SignInId = 9001;
-    QAndroidGoogleAccountInfo m_SignedInAccountInfo;
+    const int m_signInId = 9001;
+    QAndroidGoogleAccountInfo m_signedInAccountInfo;
 
     void handleActivityResult(int receiverRequestCode, int resultCode, const QAndroidJniObject &data) override;
 
-    static void UpdateSignedInAccountInfo(JNIEnv *env, jobject thiz, jobject accountInfo);
-    static void SignedIn(JNIEnv *env, jobject thiz, jboolean signInSuccessfully);
-    static void SignedOut(JNIEnv *env, jobject thiz);
+    static void updateSignedInAccountInfo(JNIEnv *env, jobject thiz, jobject accountInfo);
+    static void signedInAccount(JNIEnv *env, jobject thiz, jboolean signInSuccessfully);
+    static void signedOutAccount(JNIEnv *env, jobject thiz);
 
-    void SetSignedInAccountInfo(const QAndroidJniObject &AccountInfoObj);
-    QImage AndroidBitmapToImage(const QAndroidJniObject &JniBmp);
+    void setSignedInAccountInfo(const QAndroidJniObject &accountInfoObj);
+    QImage androidBitmapToImage(const QAndroidJniObject &jniBmp);
 };

QtAndroidTools/QAndroidGoogleDrive.cpp

@@ -25,26 +25,26 @@
 
 QAndroidGoogleDrive *QAndroidGoogleDrive::m_pInstance = nullptr;
 
-QAndroidGoogleDrive::QAndroidGoogleDrive() : m_JavaGoogleDrive("com/falsinsoft/qtandroidtools/AndroidGoogleDrive",
+QAndroidGoogleDrive::QAndroidGoogleDrive() : m_javaGoogleDrive("com/falsinsoft/qtandroidtools/AndroidGoogleDrive",
                                                                "(Landroid/app/Activity;)V",
                                                                QtAndroid::androidActivity().object<jobject>())
 {
     m_pInstance = this;
 
-    if(m_JavaGoogleDrive.isValid())
+    if(m_javaGoogleDrive.isValid())
     {
-        const JNINativeMethod JniMethod[] = {
-            {"downloadProgressChanged", "(ID)V", reinterpret_cast<void *>(&QAndroidGoogleDrive::DownloadProgressChanged)},
-            {"uploadProgressChanged", "(ID)V", reinterpret_cast<void *>(&QAndroidGoogleDrive::UploadProgressChanged)}
+        const JNINativeMethod jniMethod[] = {
+            {"downloadProgressChanged", "(ID)V", reinterpret_cast<void *>(&QAndroidGoogleDrive::downloadDriveProgressChanged)},
+            {"uploadProgressChanged", "(ID)V", reinterpret_cast<void *>(&QAndroidGoogleDrive::uploadDriveProgressChanged)}
         };
-        QAndroidJniEnvironment JniEnv;
-        jclass ObjectClass;
+        QAndroidJniEnvironment jniEnv;
+        jclass objectClass;
 
-        ObjectClass = JniEnv->GetObjectClass(m_JavaGoogleDrive.object<jobject>());
-        JniEnv->RegisterNatives(ObjectClass, JniMethod, sizeof(JniMethod)/sizeof(JNINativeMethod));
-        JniEnv->DeleteLocalRef(ObjectClass);
+        objectClass = jniEnv->GetObjectClass(m_javaGoogleDrive.object<jobject>());
+        jniEnv->RegisterNatives(objectClass, jniMethod, sizeof(jniMethod)/sizeof(JNINativeMethod));
+        jniEnv->DeleteLocalRef(objectClass);
     }
-    LoadScopeDefinitions();
+    loadScopeDefinitions();
 }
 
 QObject* QAndroidGoogleDrive::qmlInstance(QQmlEngine *engine, QJSEngine *scriptEngine)
@@ -60,220 +60,220 @@ QAndroidGoogleDrive* QAndroidGoogleDrive::instance()
     return m_pInstance;
 }
 
-bool QAndroidGoogleDrive::authenticate(const QString &AppName, const QString &ScopeName)
+bool QAndroidGoogleDrive::authenticate(const QString &appName, const QString &scopeName)
 {
-    if(m_JavaGoogleDrive.isValid())
+    if(m_javaGoogleDrive.isValid())
     {
-        m_isAuthenticated = m_JavaGoogleDrive.callMethod<jboolean>("authenticate",
+        m_isAuthenticated = m_javaGoogleDrive.callMethod<jboolean>("authenticate",
                                                                    "(Ljava/lang/String;Ljava/lang/String;)Z",
-                                                                   QAndroidJniObject::fromString(AppName).object<jstring>(),
-                                                                   QAndroidJniObject::fromString(ScopeName).object<jstring>()
+                                                                   QAndroidJniObject::fromString(appName).object<jstring>(),
+                                                                   QAndroidJniObject::fromString(scopeName).object<jstring>()
                                                                    );
-        emit isAuthenticatedChanged();
+        Q_EMIT isAuthenticatedChanged();
         return m_isAuthenticated;
     }
     return false;
 }
 
-QVariantList QAndroidGoogleDrive::getFilesList(const QString &Query)
+QVariantList QAndroidGoogleDrive::getFilesList(const QString &query)
 {
-    QAndroidJniEnvironment JniEnv;
-    QVariantList FilesList;
+    QAndroidJniEnvironment jniEnv;
+    QVariantList filesList;
 
-    if(m_JavaGoogleDrive.isValid())
+    if(m_javaGoogleDrive.isValid())
     {
-        const QAndroidJniObject FilesListObj = m_JavaGoogleDrive.callObjectMethod("listFiles",
+        const QAndroidJniObject filesListObj = m_javaGoogleDrive.callObjectMethod("listFiles",
                                                                                   "(Ljava/lang/String;)[Lcom/falsinsoft/qtandroidtools/AndroidGoogleDrive$DriveFile;",
-                                                                                  QAndroidJniObject::fromString(Query).object<jstring>()
+                                                                                  QAndroidJniObject::fromString(query).object<jstring>()
                                                                                   );
-        if(FilesListObj.isValid())
+        if(filesListObj.isValid())
         {
-            const jobjectArray FilesListJObjArray = FilesListObj.object<jobjectArray>();
-            const int FilesNum = JniEnv->GetArrayLength(FilesListJObjArray);
+            const jobjectArray filesListJObjArray = filesListObj.object<jobjectArray>();
+            const int filesNum = jniEnv->GetArrayLength(filesListJObjArray);
 
-            for(int i = 0; i < FilesNum; i++)
+            for(int i = 0; i < filesNum; i++)
             {
-                const QAndroidJniObject JniObject = JniEnv->GetObjectArrayElement(FilesListJObjArray, i);
-                QAndroidJniObject ParentsListObj;
-                QVariantList FileParents;
-                QVariantMap FileInfo;
+                const QAndroidJniObject jniObject = jniEnv->GetObjectArrayElement(filesListJObjArray, i);
+                QAndroidJniObject parentsListObj;
+                QVariantList fileParents;
+                QVariantMap fileInfo;
 
-                FileInfo["id"] = JniObject.getObjectField<jstring>("id").toString();
-                FileInfo["name"] = JniObject.getObjectField<jstring>("name").toString();
-                FileInfo["mimeType"] = JniObject.getObjectField<jstring>("mimeType").toString();
-                ParentsListObj = JniObject.getObjectField("parents", "[Ljava/lang/String;");
-                if(ParentsListObj.isValid())
+                fileInfo["id"] = jniObject.getObjectField<jstring>("id").toString();
+                fileInfo["name"] = jniObject.getObjectField<jstring>("name").toString();
+                fileInfo["mimeType"] = jniObject.getObjectField<jstring>("mimeType").toString();
+                parentsListObj = jniObject.getObjectField("parents", "[Ljava/lang/String;");
+                if(parentsListObj.isValid())
                 {
-                    const jobjectArray ParentsListJObjArray = ParentsListObj.object<jobjectArray>();
-                    const int ParentsNum = JniEnv->GetArrayLength(ParentsListJObjArray);
+                    const jobjectArray parentsListJObjArray = parentsListObj.object<jobjectArray>();
+                    const int parentsNum = jniEnv->GetArrayLength(parentsListJObjArray);
 
-                    for(int p = 0; p < ParentsNum; p++)
+                    for(int p = 0; p < parentsNum; p++)
                     {
-                        FileParents << QAndroidJniObject(JniEnv->GetObjectArrayElement(ParentsListJObjArray, p)).toString();
+                        fileParents << QAndroidJniObject(jniEnv->GetObjectArrayElement(parentsListJObjArray, p)).toString();
                     }
                 }
-                FileInfo["parents"] = FileParents;
+                fileInfo["parents"] = fileParents;
 
-                FilesList << FileInfo;
+                filesList << fileInfo;
             }
         }
     }
 
-    return FilesList;
+    return filesList;
 }
 
 QString QAndroidGoogleDrive::getRootId()
 {
-    QString RootId;
+    QString rootId;
 
-    if(m_JavaGoogleDrive.isValid())
+    if(m_javaGoogleDrive.isValid())
     {
-        const QAndroidJniObject RootIdObj = m_JavaGoogleDrive.callObjectMethod("getRootId",
+        const QAndroidJniObject rootIdObj = m_javaGoogleDrive.callObjectMethod("getRootId",
                                                                                "()Ljava/lang/String;"
                                                                                );
-        if(RootIdObj.isValid())
+        if(rootIdObj.isValid())
         {
-            RootId = RootIdObj.toString();
+            rootId = rootIdObj.toString();
         }
     }
 
-    return RootId;
+    return rootId;
 }
 
-bool QAndroidGoogleDrive::createFolder(const QString &Name, const QString &ParentFolderId)
+bool QAndroidGoogleDrive::createFolder(const QString &name, const QString &parentFolderId)
 {
-    if(m_JavaGoogleDrive.isValid())
+    if(m_javaGoogleDrive.isValid())
     {
-        return m_JavaGoogleDrive.callMethod<jboolean>("createFolder",
+        return m_javaGoogleDrive.callMethod<jboolean>("createFolder",
                                                       "(Ljava/lang/String;Ljava/lang/String;)Z",
-                                                      QAndroidJniObject::fromString(Name).object<jstring>(),
-                                                      QAndroidJniObject::fromString(ParentFolderId).object<jstring>()
+                                                      QAndroidJniObject::fromString(name).object<jstring>(),
+                                                      QAndroidJniObject::fromString(parentFolderId).object<jstring>()
                                                       );
     }
     return false;
 }
 
-bool QAndroidGoogleDrive::isFolder(const QString &FileId)
+bool QAndroidGoogleDrive::isFolder(const QString &fileId)
 {
-    const FILE_METADATA FileMetadata = GetFileMetadata(FileId);
-    return (FileMetadata.Id.isEmpty() == false && FileMetadata.MimeType == "application/vnd.google-apps.folder") ? true : false;
+    const FILE_METADATA fileMetadata = getFileMetadata(fileId);
+    return (fileMetadata.id.isEmpty() == false && fileMetadata.mimeType == "application/vnd.google-apps.folder") ? true : false;
 }
 
-bool QAndroidGoogleDrive::downloadFile(const QString &FileId, const QString &LocalFilePath)
+bool QAndroidGoogleDrive::downloadFile(const QString &fileId, const QString &localFilePath)
 {
-    if(m_JavaGoogleDrive.isValid())
+    if(m_javaGoogleDrive.isValid())
     {
-        return m_JavaGoogleDrive.callMethod<jboolean>("downloadFile",
+        return m_javaGoogleDrive.callMethod<jboolean>("downloadFile",
                                                       "(Ljava/lang/String;Ljava/lang/String;)Z",
-                                                      QAndroidJniObject::fromString(FileId).object<jstring>(),
-                                                      QAndroidJniObject::fromString(LocalFilePath).object<jstring>()
+                                                      QAndroidJniObject::fromString(fileId).object<jstring>(),
+                                                      QAndroidJniObject::fromString(localFilePath).object<jstring>()
                                                       );
     }
     return false;
 }
 
-QString QAndroidGoogleDrive::uploadFile(const QString &LocalFilePath, const QString &MimeType, const QString &ParentFolderId)
+QString QAndroidGoogleDrive::uploadFile(const QString &localFilePath, const QString &mimeType, const QString &parentFolderId)
 {
-    const QFileInfo FileInfo(LocalFilePath);
-    QString UploadedFileId;
+    const QFileInfo fileInfo(localFilePath);
+    QString uploadedFileId;
 
-    if(m_JavaGoogleDrive.isValid())
+    if(m_javaGoogleDrive.isValid())
     {
-        const QAndroidJniObject UploadedFileIdObj = m_JavaGoogleDrive.callObjectMethod("uploadFile",
+        const QAndroidJniObject uploadedFileIdObj = m_javaGoogleDrive.callObjectMethod("uploadFile",
                                                                                        "(Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;)Ljava/lang/String;",
-                                                                                       QAndroidJniObject::fromString(LocalFilePath).object<jstring>(),
-                                                                                       QAndroidJniObject::fromString(FileInfo.fileName()).object<jstring>(),
-                                                                                       QAndroidJniObject::fromString(MimeType).object<jstring>(),
-                                                                                       QAndroidJniObject::fromString(ParentFolderId).object<jstring>()
+                                                                                       QAndroidJniObject::fromString(localFilePath).object<jstring>(),
+                                                                                       QAndroidJniObject::fromString(fileInfo.fileName()).object<jstring>(),
+                                                                                       QAndroidJniObject::fromString(mimeType).object<jstring>(),
+                                                                                       QAndroidJniObject::fromString(parentFolderId).object<jstring>()
                                                                                        );
-        if(UploadedFileIdObj.isValid())
+        if(uploadedFileIdObj.isValid())
         {
-            UploadedFileId = UploadedFileIdObj.toString();
+            uploadedFileId = uploadedFileIdObj.toString();
         }
     }
 
-    return UploadedFileId;
+    return uploadedFileId;
 }
 
-bool QAndroidGoogleDrive::moveFile(const QString &FileId, const QString &FolderId)
+bool QAndroidGoogleDrive::moveFile(const QString &fileId, const QString &folderId)
 {
-    if(m_JavaGoogleDrive.isValid())
+    if(m_javaGoogleDrive.isValid())
     {
-        return m_JavaGoogleDrive.callMethod<jboolean>("moveFile",
+        return m_javaGoogleDrive.callMethod<jboolean>("moveFile",
                                                       "(Ljava/lang/String;Ljava/lang/String;)Z",
-                                                      QAndroidJniObject::fromString(FileId).object<jstring>(),
-                                                      QAndroidJniObject::fromString(FolderId).object<jstring>()
+                                                      QAndroidJniObject::fromString(fileId).object<jstring>(),
+                                                      QAndroidJniObject::fromString(folderId).object<jstring>()
                                                       );
     }
     return false;
 }
 
-bool QAndroidGoogleDrive::deleteFile(const QString &FileId)
+bool QAndroidGoogleDrive::deleteFile(const QString &fileId)
 {
-    if(m_JavaGoogleDrive.isValid())
+    if(m_javaGoogleDrive.isValid())
     {
-        return m_JavaGoogleDrive.callMethod<jboolean>("deleteFile",
+        return m_javaGoogleDrive.callMethod<jboolean>("deleteFile",
                                                       "(Ljava/lang/String;)Z",
-                                                      QAndroidJniObject::fromString(FileId).object<jstring>()
+                                                      QAndroidJniObject::fromString(fileId).object<jstring>()
                                                       );
     }
     return false;
 }
 
-QAndroidGoogleDrive::FILE_METADATA QAndroidGoogleDrive::GetFileMetadata(const QString &FileId)
+QAndroidGoogleDrive::FILE_METADATA QAndroidGoogleDrive::getFileMetadata(const QString &fileId)
 {
-    const QString Fields("id, mimeType");
-    FILE_METADATA FileMetadata;
+    const QString fields("id, mimeType");
+    FILE_METADATA fileMetadata;
 
-    if(m_JavaGoogleDrive.isValid())
+    if(m_javaGoogleDrive.isValid())
     {
-        const QAndroidJniObject FileMetadataObj = m_JavaGoogleDrive.callObjectMethod("getFileMetadata",
+        const QAndroidJniObject fileMetadataObj = m_javaGoogleDrive.callObjectMethod("getFileMetadata",
                                                                                      "(Ljava/lang/String;Ljava/lang/String;)Lcom/google/api/services/drive/model/File;",
-                                                                                     QAndroidJniObject::fromString(FileId).object<jstring>(),
-                                                                                     QAndroidJniObject::fromString(Fields).object<jstring>()
+                                                                                     QAndroidJniObject::fromString(fileId).object<jstring>(),
+                                                                                     QAndroidJniObject::fromString(fields).object<jstring>()
                                                                                      );
-        if(FileMetadataObj.isValid())
+        if(fileMetadataObj.isValid())
         {
-            FileMetadata.Id = FileMetadataObj.callObjectMethod<jstring>("getId").toString();
-            FileMetadata.MimeType = FileMetadataObj.callObjectMethod<jstring>("getMimeType").toString();
+            fileMetadata.id = fileMetadataObj.callObjectMethod<jstring>("getId").toString();
+            fileMetadata.mimeType = fileMetadataObj.callObjectMethod<jstring>("getMimeType").toString();
         }
     }
 
-    return FileMetadata;
+    return fileMetadata;
 }
 
-void QAndroidGoogleDrive::DownloadProgressChanged(JNIEnv *env, jobject thiz, jint State, jdouble Progress)
+void QAndroidGoogleDrive::downloadDriveProgressChanged(JNIEnv *env, jobject thiz, jint state, jdouble progress)
 {
     Q_UNUSED(env)
     Q_UNUSED(thiz)
 
     if(m_pInstance != nullptr)
     {
-        emit m_pInstance->downloadProgressChanged(State, Progress);
+        Q_EMIT m_pInstance->downloadProgressChanged(state, progress);
     }
 }
 
-void QAndroidGoogleDrive::UploadProgressChanged(JNIEnv *env, jobject thiz, jint State, jdouble Progress)
+void QAndroidGoogleDrive::uploadDriveProgressChanged(JNIEnv *env, jobject thiz, jint state, jdouble progress)
 {
     Q_UNUSED(env)
     Q_UNUSED(thiz)
 
     if(m_pInstance != nullptr)
     {
-        emit m_pInstance->uploadProgressChanged(State, Progress);
+        Q_EMIT m_pInstance->uploadProgressChanged(state, progress);
     }
 }
 
-void QAndroidGoogleDrive::LoadScopeDefinitions()
+void QAndroidGoogleDrive::loadScopeDefinitions()
 {
-    const char ScopesClass[] = "com/google/api/services/drive/DriveScopes";
+    const char scopesClass[] = "com/google/api/services/drive/DriveScopes";
 
-    m_ScopeList[0] = QAndroidJniObject::getStaticObjectField<jstring>(ScopesClass, "DRIVE").toString();
-    m_ScopeList[1] = QAndroidJniObject::getStaticObjectField<jstring>(ScopesClass, "DRIVE_APPDATA").toString();
-    m_ScopeList[2] = QAndroidJniObject::getStaticObjectField<jstring>(ScopesClass, "DRIVE_FILE").toString();
-    m_ScopeList[3] = QAndroidJniObject::getStaticObjectField<jstring>(ScopesClass, "DRIVE_METADATA").toString();
-    m_ScopeList[4] = QAndroidJniObject::getStaticObjectField<jstring>(ScopesClass, "DRIVE_METADATA_READONLY").toString();
-    m_ScopeList[5] = QAndroidJniObject::getStaticObjectField<jstring>(ScopesClass, "DRIVE_PHOTOS_READONLY").toString();
-    m_ScopeList[6] = QAndroidJniObject::getStaticObjectField<jstring>(ScopesClass, "DRIVE_READONLY").toString();
-    m_ScopeList[7] = QAndroidJniObject::getStaticObjectField<jstring>(ScopesClass, "DRIVE_SCRIPTS").toString();
+    m_scopeList[0] = QAndroidJniObject::getStaticObjectField<jstring>(scopesClass, "DRIVE").toString();
+    m_scopeList[1] = QAndroidJniObject::getStaticObjectField<jstring>(scopesClass, "DRIVE_APPDATA").toString();
+    m_scopeList[2] = QAndroidJniObject::getStaticObjectField<jstring>(scopesClass, "DRIVE_FILE").toString();
+    m_scopeList[3] = QAndroidJniObject::getStaticObjectField<jstring>(scopesClass, "DRIVE_METADATA").toString();
+    m_scopeList[4] = QAndroidJniObject::getStaticObjectField<jstring>(scopesClass, "DRIVE_METADATA_READONLY").toString();
+    m_scopeList[5] = QAndroidJniObject::getStaticObjectField<jstring>(scopesClass, "DRIVE_PHOTOS_READONLY").toString();
+    m_scopeList[6] = QAndroidJniObject::getStaticObjectField<jstring>(scopesClass, "DRIVE_READONLY").toString();
+    m_scopeList[7] = QAndroidJniObject::getStaticObjectField<jstring>(scopesClass, "DRIVE_SCRIPTS").toString();
 }

QtAndroidTools/QAndroidGoogleDrive.h

@@ -43,21 +43,21 @@ class QAndroidGoogleDrive : public QObject
 
     struct FILE_METADATA
     {
-        QString Id;
-        QString MimeType;
+        QString id;
+        QString mimeType;
     };
 
     QAndroidGoogleDrive();
 
 public:
-    const QString &SCOPE_DRIVE = m_ScopeList[0];
-    const QString &SCOPE_DRIVE_APPDATA = m_ScopeList[1];
-    const QString &SCOPE_DRIVE_FILE = m_ScopeList[2];
-    const QString &SCOPE_DRIVE_METADATA = m_ScopeList[3];
-    const QString &SCOPE_DRIVE_METADATA_READONLY = m_ScopeList[4];
-    const QString &SCOPE_DRIVE_PHOTOS_READONLY = m_ScopeList[5];
-    const QString &SCOPE_DRIVE_READONLY = m_ScopeList[6];
-    const QString &SCOPE_DRIVE_SCRIPTS = m_ScopeList[7];
+    const QString &SCOPE_DRIVE = m_scopeList[0];
+    const QString &SCOPE_DRIVE_APPDATA = m_scopeList[1];
+    const QString &SCOPE_DRIVE_FILE = m_scopeList[2];
+    const QString &SCOPE_DRIVE_METADATA = m_scopeList[3];
+    const QString &SCOPE_DRIVE_METADATA_READONLY = m_scopeList[4];
+    const QString &SCOPE_DRIVE_PHOTOS_READONLY = m_scopeList[5];
+    const QString &SCOPE_DRIVE_READONLY = m_scopeList[6];
+    const QString &SCOPE_DRIVE_SCRIPTS = m_scopeList[7];
 
     enum PROGRESS_STATE
     {
@@ -70,32 +70,32 @@ public:
     static QObject* qmlInstance(QQmlEngine *engine, QJSEngine *scriptEngine);
     static QAndroidGoogleDrive* instance();
 
-    Q_INVOKABLE bool authenticate(const QString &AppName, const QString &ScopeName);
-    Q_INVOKABLE QVariantList getFilesList(const QString &Query = QString());
+    Q_INVOKABLE bool authenticate(const QString &appName, const QString &scopeName);
+    Q_INVOKABLE QVariantList getFilesList(const QString &query = QString());
     Q_INVOKABLE QString getRootId();
-    Q_INVOKABLE bool downloadFile(const QString &FileId, const QString &LocalFilePath);
-    Q_INVOKABLE QString uploadFile(const QString &LocalFilePath, const QString &MimeType, const QString &ParentFolderId = QString());
-    Q_INVOKABLE bool createFolder(const QString &Name, const QString &ParentFolderId = QString());
-    Q_INVOKABLE bool isFolder(const QString &FileId);
-    Q_INVOKABLE bool moveFile(const QString &FileId, const QString &FolderId);
-    Q_INVOKABLE bool deleteFile(const QString &FileId);
+    Q_INVOKABLE bool downloadFile(const QString &fileId, const QString &localFilePath);
+    Q_INVOKABLE QString uploadFile(const QString &localFilePath, const QString &mimeType, const QString &parentFolderId = QString());
+    Q_INVOKABLE bool createFolder(const QString &name, const QString &parentFolderId = QString());
+    Q_INVOKABLE bool isFolder(const QString &fileId);
+    Q_INVOKABLE bool moveFile(const QString &fileId, const QString &folderId);
+    Q_INVOKABLE bool deleteFile(const QString &fileId);
 
     bool isAuthenticated() { return m_isAuthenticated; }
 
-signals:
+Q_SIGNALS:
     void isAuthenticatedChanged();
     void downloadProgressChanged(int state, double progress);
     void uploadProgressChanged(int state, double progress);
 
 private:
-    const QAndroidJniObject m_JavaGoogleDrive;
+    const QAndroidJniObject m_javaGoogleDrive;
     static QAndroidGoogleDrive *m_pInstance;
     bool m_isAuthenticated = false;
-    QString m_ScopeList[8];
+    QString m_scopeList[8];
 
-    static void DownloadProgressChanged(JNIEnv *env, jobject thiz, jint State, jdouble Progress);
-    static void UploadProgressChanged(JNIEnv *env, jobject thiz, jint State, jdouble Progress);
+    static void downloadDriveProgressChanged(JNIEnv *env, jobject thiz, jint state, jdouble progress);
+    static void uploadDriveProgressChanged(JNIEnv *env, jobject thiz, jint state, jdouble progress);
 
-    FILE_METADATA GetFileMetadata(const QString &FileId);
-    void LoadScopeDefinitions();
+    FILE_METADATA getFileMetadata(const QString &fileId);
+    void loadScopeDefinitions();
 };

QtAndroidTools/QAndroidImages.cpp

@@ -25,7 +25,7 @@
 
 QAndroidImages *QAndroidImages::m_pInstance = nullptr;
 
-QAndroidImages::QAndroidImages() : m_JavaImages("com/falsinsoft/qtandroidtools/AndroidImages",
+QAndroidImages::QAndroidImages() : m_javaImages("com/falsinsoft/qtandroidtools/AndroidImages",
                                                 "(Landroid/app/Activity;)V",
                                                 QtAndroid::androidActivity().object<jobject>())
 {
@@ -47,68 +47,68 @@ QAndroidImages* QAndroidImages::instance()
 
 QVariantList QAndroidImages::getAlbumsList()
 {
-    QAndroidJniEnvironment qJniEnv;
-    QVariantList AlbumsList;
+    QAndroidJniEnvironment jniEnv;
+    QVariantList albumsList;
 
     if(QtAndroid::androidSdkVersion() >= 23)
     {
-        if(QtAndroid::checkPermission("android.permission.READ_EXTERNAL_STORAGE") != QtAndroid::PermissionResult::Granted) return AlbumsList;
+        if(QtAndroid::checkPermission("android.permission.READ_EXTERNAL_STORAGE") != QtAndroid::PermissionResult::Granted) return albumsList;
     }
 
-    if(m_JavaImages.isValid())
+    if(m_javaImages.isValid())
     {
-        const QAndroidJniObject AlbumsListObj = m_JavaImages.callObjectMethod("getAlbumsList",
+        const QAndroidJniObject albumsListObj = m_javaImages.callObjectMethod("getAlbumsList",
                                                                               "()[Lcom/falsinsoft/qtandroidtools/AndroidImages$AlbumInfo;"
                                                                               );
-        if(AlbumsListObj.isValid())
+        if(albumsListObj.isValid())
         {
-            const jobjectArray AlbumsListObjArray = AlbumsListObj.object<jobjectArray>();
-            const int AlbumsNum = qJniEnv->GetArrayLength(AlbumsListObjArray);
+            const jobjectArray albumsListObjArray = albumsListObj.object<jobjectArray>();
+            const int albumsNum = jniEnv->GetArrayLength(albumsListObjArray);
 
-            for(int i = 0; i < AlbumsNum; i++)
+            for(int i = 0; i < albumsNum; i++)
             {
-                const QAndroidJniObject AlbumInfoObj = QAndroidJniObject::fromLocalRef(qJniEnv->GetObjectArrayElement(AlbumsListObjArray, i));
-                QVariantMap AlbumInfo;
+                const QAndroidJniObject albumInfoObj = QAndroidJniObject::fromLocalRef(jniEnv->GetObjectArrayElement(albumsListObjArray, i));
+                QVariantMap albumInfo;
 
-                AlbumInfo["id"] = AlbumInfoObj.getField<jint>("id");
-                AlbumInfo["name"] = AlbumInfoObj.getObjectField<jstring>("name").toString();
+                albumInfo["id"] = albumInfoObj.getField<jint>("id");
+                albumInfo["name"] = albumInfoObj.getObjectField<jstring>("name").toString();
 
-                AlbumsList << AlbumInfo;
+                albumsList << albumInfo;
             }
         }
     }
 
-    return AlbumsList;
+    return albumsList;
 }
 
 QStringList QAndroidImages::getAlbumImagesList(int albumId)
 {
-    QAndroidJniEnvironment qJniEnv;
-    QStringList ImagesList;
+    QAndroidJniEnvironment jniEnv;
+    QStringList imagesList;
 
     if(QtAndroid::androidSdkVersion() >= 23)
     {
-        if(QtAndroid::checkPermission("android.permission.READ_EXTERNAL_STORAGE") != QtAndroid::PermissionResult::Granted) return ImagesList;
+        if(QtAndroid::checkPermission("android.permission.READ_EXTERNAL_STORAGE") != QtAndroid::PermissionResult::Granted) return imagesList;
     }
 
-    if(m_JavaImages.isValid())
+    if(m_javaImages.isValid())
     {
-        const QAndroidJniObject ImagesListObj = m_JavaImages.callObjectMethod("getAlbumImagesList",
+        const QAndroidJniObject imagesListObj = m_javaImages.callObjectMethod("getAlbumImagesList",
                                                                               "(I)[Ljava/lang/String;",
                                                                               albumId
                                                                               );
-        if(ImagesListObj.isValid())
+        if(imagesListObj.isValid())
         {
-            const jobjectArray ImagesListObjArray = ImagesListObj.object<jobjectArray>();
-            const int ImagesNum = qJniEnv->GetArrayLength(ImagesListObjArray);
+            const jobjectArray imagesListObjArray = imagesListObj.object<jobjectArray>();
+            const int imagesNum = jniEnv->GetArrayLength(imagesListObjArray);
 
-            for(int i = 0; i < ImagesNum; i++)
+            for(int i = 0; i < imagesNum; i++)
             {
-                const QAndroidJniObject ImagePathObj = QAndroidJniObject::fromLocalRef(qJniEnv->GetObjectArrayElement(ImagesListObjArray, i));
-                ImagesList << ImagePathObj.toString();
+                const QAndroidJniObject imagePathObj = QAndroidJniObject::fromLocalRef(jniEnv->GetObjectArrayElement(imagesListObjArray, i));
+                imagesList << imagePathObj.toString();
             }
         }
     }
 
-    return ImagesList;
+    return imagesList;
 }

QtAndroidTools/QAndroidImages.h

@@ -42,6 +42,6 @@ public:
     Q_INVOKABLE QStringList getAlbumImagesList(int albumId);
 
 private:
-    const QAndroidJniObject m_JavaImages;
+    const QAndroidJniObject m_javaImages;
     static QAndroidImages *m_pInstance;
 };

QtAndroidTools/QAndroidNotification.cpp

@@ -27,188 +27,188 @@
 #include "QAndroidNotification.h"
 
 QMap<int, QAndroidNotification*> QAndroidNotification::m_pInstancesMap;
-int QAndroidNotification::m_InstancesCounter = 0;
+int QAndroidNotification::m_instancesCounter = 0;
 
 QAndroidNotification::QAndroidNotification(QQuickItem *parent) : QQuickItem(parent),
-                                                                 m_JavaNotification("com/falsinsoft/qtandroidtools/AndroidNotification",
+                                                                 m_javaNotification("com/falsinsoft/qtandroidtools/AndroidNotification",
                                                                                     "(Landroid/app/Activity;I)V",
                                                                                     QtAndroid::androidActivity().object<jobject>(),
-                                                                                    m_InstancesCounter),
-                                                                 m_InstanceIndex(m_InstancesCounter++)
+                                                                                    m_instancesCounter),
+                                                                 m_instanceIndex(m_instancesCounter++)
 {
-    m_pInstancesMap[m_InstanceIndex] = this;
+    m_pInstancesMap[m_instanceIndex] = this;
 }
 
 QAndroidNotification::~QAndroidNotification()
 {
-    m_pInstancesMap.remove(m_InstanceIndex);
+    m_pInstancesMap.remove(m_instanceIndex);
 }
 
-const QMap<int, QAndroidNotification*>& QAndroidNotification::Instances()
+const QMap<int, QAndroidNotification*>& QAndroidNotification::instances()
 {
     return m_pInstancesMap;
 }
 
 void QAndroidNotification::show()
 {
-    if(m_JavaNotification.isValid() && m_SmallIconName.isEmpty() == false && m_Text.isEmpty() == false)
+    if(m_javaNotification.isValid() && m_smallIconName.isEmpty() == false && m_text.isEmpty() == false)
     {
-        m_JavaNotification.callMethod<void>("show");
+        m_javaNotification.callMethod<void>("show");
     }
 }
 
 void QAndroidNotification::cancel()
 {
-    if(m_JavaNotification.isValid())
+    if(m_javaNotification.isValid())
     {
-        m_JavaNotification.callMethod<void>("cancel");
+        m_javaNotification.callMethod<void>("cancel");
     }
 }
 
 const QString& QAndroidNotification::getTitle() const
 {
-    return m_Title;
+    return m_title;
 }
 
-void QAndroidNotification::setTitle(const QString &Title)
+void QAndroidNotification::setTitle(const QString &title)
 {
-    if(m_JavaNotification.isValid())
+    if(m_javaNotification.isValid())
     {
-        m_JavaNotification.callMethod<void>("setTitle",
+        m_javaNotification.callMethod<void>("setTitle",
                                             "(Ljava/lang/String;)V",
-                                            QAndroidJniObject::fromString(Title).object<jstring>()
+                                            QAndroidJniObject::fromString(title).object<jstring>()
                                             );
-        m_Title = Title;
+        m_title = title;
     }
 }
 
 const QString& QAndroidNotification::getText() const
 {
-    return m_Text;
+    return m_text;
 }
 
-void QAndroidNotification::setText(const QString &Text)
+void QAndroidNotification::setText(const QString &text)
 {
-    if(m_JavaNotification.isValid())
+    if(m_javaNotification.isValid())
     {
-        m_JavaNotification.callMethod<void>("setContent",
+        m_javaNotification.callMethod<void>("setContent",
                                             "(Ljava/lang/String;)V",
-                                            QAndroidJniObject::fromString(Text).object<jstring>()
+                                            QAndroidJniObject::fromString(text).object<jstring>()
                                             );
-        m_Text = Text;
+        m_text = text;
     }
 }
 
 const QString& QAndroidNotification::getExpandableText() const
 {
-    return m_ExpandableText;
+    return m_expandableText;
 }
 
-void QAndroidNotification::setExpandableText(const QString &ExpandableText)
+void QAndroidNotification::setExpandableText(const QString &expandableText)
 {
-    if(m_JavaNotification.isValid())
+    if(m_javaNotification.isValid())
     {
-        m_JavaNotification.callMethod<void>("setExpandableContent",
+        m_javaNotification.callMethod<void>("setExpandableContent",
                                             "(Ljava/lang/String;)V",
-                                            QAndroidJniObject::fromString(ExpandableText).object<jstring>()
+                                            QAndroidJniObject::fromString(expandableText).object<jstring>()
                                             );
-        m_ExpandableText = ExpandableText;
+        m_expandableText = expandableText;
     }
 }
 
 const QString& QAndroidNotification::getChannelName() const
 {
-    return m_ChannelName;
+    return m_channelName;
 }
 
-void QAndroidNotification::setChannelName(const QString &ChannelName)
+void QAndroidNotification::setChannelName(const QString &channelName)
 {
-    if(m_JavaNotification.isValid() && m_ChannelName.isEmpty())
+    if(m_javaNotification.isValid() && m_channelName.isEmpty())
     {
-        m_JavaNotification.callMethod<void>("createNotificationChannel",
+        m_javaNotification.callMethod<void>("createNotificationChannel",
                                             "(Ljava/lang/String;)V",
-                                            QAndroidJniObject::fromString(ChannelName).object<jstring>()
+                                            QAndroidJniObject::fromString(channelName).object<jstring>()
                                             );
-        m_ChannelName = ChannelName;
+        m_channelName = channelName;
     }
 }
 
 const QString& QAndroidNotification::getLargeIconSource() const
 {
-    return m_LargeIconSource;
+    return m_largeIconSource;
 }
 
-void QAndroidNotification::setLargeIconSource(const QString &LargeIconSource)
+void QAndroidNotification::setLargeIconSource(const QString &largeIconSource)
 {
-    const QImage LargeIcon((LargeIconSource.length() > 5 && LargeIconSource.left(5) == "qrc:/") ? LargeIconSource.right(LargeIconSource.length() - 3) : LargeIconSource);
+    const QImage largeIcon((largeIconSource.length() > 5 && largeIconSource.left(5) == "qrc:/") ? largeIconSource.right(largeIconSource.length() - 3) : largeIconSource);
 
-    if(m_JavaNotification.isValid() && LargeIcon.isNull() == false)
+    if(m_javaNotification.isValid() && largeIcon.isNull() == false)
     {
-        const QAndroidJniObject AndroidBitmap = ImageToAndroidBitmap(LargeIcon);
+        const QAndroidJniObject androidBitmap = imageToAndroidBitmap(largeIcon);
 
-        m_JavaNotification.callMethod<void>("setLargeIcon",
+        m_javaNotification.callMethod<void>("setLargeIcon",
                                             "(Landroid/graphics/Bitmap;)V",
-                                            AndroidBitmap.object()
+                                            androidBitmap.object()
                                             );
 
-        m_LargeIconSource = LargeIconSource;
+        m_largeIconSource = largeIconSource;
     }
 }
 
 const QString& QAndroidNotification::getSmallIconName() const
 {
-    return m_SmallIconName;
+    return m_smallIconName;
 }
 
-void QAndroidNotification::setSmallIconName(const QString &SmallIconName)
+void QAndroidNotification::setSmallIconName(const QString &smallIconName)
 {
-    const QAndroidJniObject Activity = QtAndroid::androidActivity();
-    QAndroidJniObject PackageName, PackageManager, Resources;
-    int SmallIconResourceId;
+    const QAndroidJniObject activity = QtAndroid::androidActivity();
+    QAndroidJniObject packageName, packageManager, resources;
+    int smallIconResourceId;
 
-    PackageManager = Activity.callObjectMethod("getPackageManager", "()Landroid/content/pm/PackageManager;");
-    PackageName = Activity.callObjectMethod("getPackageName", "()Ljava/lang/String;");
-    Resources = Activity.callObjectMethod("getResources", "()Landroid/content/res/Resources;");
+    packageManager = activity.callObjectMethod("getPackageManager", "()Landroid/content/pm/PackageManager;");
+    packageName = activity.callObjectMethod("getPackageName", "()Ljava/lang/String;");
+    resources = activity.callObjectMethod("getResources", "()Landroid/content/res/Resources;");
 
-    SmallIconResourceId = Resources.callMethod<jint>("getIdentifier",
+    smallIconResourceId = resources.callMethod<jint>("getIdentifier",
                                                      "(Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;)I",
-                                                     QAndroidJniObject::fromString(SmallIconName).object<jstring>(),
+                                                     QAndroidJniObject::fromString(smallIconName).object<jstring>(),
                                                      QAndroidJniObject::fromString("drawable").object<jstring>(),
-                                                     PackageName.object<jstring>()
+                                                     packageName.object<jstring>()
                                                      );
 
-    if(m_JavaNotification.isValid() && SmallIconResourceId != 0)
+    if(m_javaNotification.isValid() && smallIconResourceId != 0)
     {
-        m_JavaNotification.callMethod<void>("setSmallIcon",
+        m_javaNotification.callMethod<void>("setSmallIcon",
                                             "(I)V",
-                                            SmallIconResourceId
+                                            smallIconResourceId
                                             );
-        m_SmallIconName = SmallIconName;
+        m_smallIconName = smallIconName;
     }
 }
 
 const QAndroidNotificationProgressBar& QAndroidNotification::getProgressBar()
 {
-    return m_ProgressBar;
+    return m_progressBar;
 }
 
-void QAndroidNotification::setProgressBar(const QAndroidNotificationProgressBar &ProgressBar)
+void QAndroidNotification::setProgressBar(const QAndroidNotificationProgressBar &progressBar)
 {
-    if(m_JavaNotification.isValid())
+    if(m_javaNotification.isValid())
     {
-        m_JavaNotification.callMethod<void>("setProgressBar",
+        m_javaNotification.callMethod<void>("setProgressBar",
                                             "(IIZ)V",
-                                            ProgressBar.Max,
-                                            ProgressBar.Current,
-                                            ProgressBar.Indeterminate
+                                            progressBar.max,
+                                            progressBar.current,
+                                            progressBar.indeterminate
                                             );
-        m_ProgressBar = ProgressBar;
+        m_progressBar = progressBar;
     }
 }
 
 // Function to convert Qt image to Android images is credits of KDAB
 // https://www.kdab.com/qt-on-android-how-to-convert-qt-images-to-android-images-and-vice-versa-2/
-QAndroidJniObject QAndroidNotification::ImageToAndroidBitmap(const QImage &img)
+QAndroidJniObject QAndroidNotification::imageToAndroidBitmap(const QImage &img)
 {
     QImage image = img.format() == QImage::Format_RGBA8888 ? img : img.convertToFormat(QImage::Format_RGBA8888);
     QAndroidJniObject bitmap, config;

QtAndroidTools/QAndroidNotification.h

@@ -30,13 +30,13 @@
 struct QAndroidNotificationProgressBar
 {
     Q_GADGET
-    Q_PROPERTY(uint max MEMBER Max)
-    Q_PROPERTY(uint current MEMBER Current)
-    Q_PROPERTY(bool indeterminate MEMBER Indeterminate)
+    Q_PROPERTY(uint max MEMBER max)
+    Q_PROPERTY(uint current MEMBER current)
+    Q_PROPERTY(bool indeterminate MEMBER indeterminate)
 public:
-    uint Max = 0;
-    uint Current = 0;
-    bool Indeterminate = false;
+    uint max = 0;
+    uint current = 0;
+    bool indeterminate = false;
 };
 Q_DECLARE_METATYPE(QAndroidNotificationProgressBar)
 
@@ -56,34 +56,34 @@ public:
     ~QAndroidNotification();
 
     const QString& getChannelName() const;
-    void setChannelName(const QString &ChannelName);
+    void setChannelName(const QString &channelName);
     const QString& getLargeIconSource() const;
-    void setLargeIconSource(const QString &LargeIconSource);
+    void setLargeIconSource(const QString &largeIconSource);
     const QString& getSmallIconName() const;
-    void setSmallIconName(const QString &SmallIconName);
+    void setSmallIconName(const QString &smallIconName);
     const QString& getTitle() const;
-    void setTitle(const QString &Title);
+    void setTitle(const QString &title);
     const QString& getText() const;
-    void setText(const QString &Text);
+    void setText(const QString &text);
     const QString& getExpandableText() const;
-    void setExpandableText(const QString &ExpandableText);
+    void setExpandableText(const QString &expandableText);
     const QAndroidNotificationProgressBar& getProgressBar();
-    void setProgressBar(const QAndroidNotificationProgressBar &ProgressBar);
+    void setProgressBar(const QAndroidNotificationProgressBar &progressBar);
 
     Q_INVOKABLE void show();
     Q_INVOKABLE void cancel();
 
-    static const QMap<int, QAndroidNotification*>& Instances();
+    static const QMap<int, QAndroidNotification*>& instances();
 
 private:
-    const QAndroidJniObject m_JavaNotification;
+    const QAndroidJniObject m_javaNotification;
     static QMap<int, QAndroidNotification*> m_pInstancesMap;
-    static int m_InstancesCounter;
-    const int m_InstanceIndex;
-    QString m_ChannelName;
-    QString m_LargeIconSource, m_SmallIconName;
-    QString m_Title, m_Text, m_ExpandableText;
-    QAndroidNotificationProgressBar m_ProgressBar;
+    static int m_instancesCounter;
+    const int m_instanceIndex;
+    QString m_channelName;
+    QString m_largeIconSource, m_smallIconName;
+    QString m_title, m_text, m_expandableText;
+    QAndroidNotificationProgressBar m_progressBar;
 
-    QAndroidJniObject ImageToAndroidBitmap(const QImage &img);
+    QAndroidJniObject imageToAndroidBitmap(const QImage &img);
 };

QtAndroidTools/QAndroidPlayStore.cpp

@@ -25,7 +25,7 @@
 
 QAndroidPlayStore *QAndroidPlayStore::m_pInstance = nullptr;
 
-QAndroidPlayStore::QAndroidPlayStore() : m_JavaPlayStore("com/falsinsoft/qtandroidtools/AndroidPlayStore",
+QAndroidPlayStore::QAndroidPlayStore() : m_javaPlayStore("com/falsinsoft/qtandroidtools/AndroidPlayStore",
                                                          "(Landroid/app/Activity;)V",
                                                          QtAndroid::androidActivity().object<jobject>())
 {
@@ -47,32 +47,32 @@ QAndroidPlayStore* QAndroidPlayStore::instance()
 
 void QAndroidPlayStore::openAppDetails(const QString &packageName)
 {
-    QString DetailsParam("details?id=");
+    QString detailsParam("details?id=");
 
     if(packageName.isEmpty())
     {
-        const QAndroidJniObject Activity = QtAndroid::androidActivity();
-        DetailsParam += Activity.callObjectMethod("getPackageName", "()Ljava/lang/String;").toString();
+        const QAndroidJniObject activity = QtAndroid::androidActivity();
+        detailsParam += activity.callObjectMethod("getPackageName", "()Ljava/lang/String;").toString();
     }
     else
     {
-        DetailsParam += packageName;
+        detailsParam += packageName;
     }
 
-    if(m_JavaPlayStore.isValid())
+    if(m_javaPlayStore.isValid())
     {
-        m_JavaPlayStore.callMethod<void>("open",
+        m_javaPlayStore.callMethod<void>("open",
                                          "(Ljava/lang/String;)V",
-                                         QAndroidJniObject::fromString(DetailsParam).object<jstring>()
+                                         QAndroidJniObject::fromString(detailsParam).object<jstring>()
                                          );
     }
 }
 
 void QAndroidPlayStore::openDeveloperAppList(const QString &developerName)
 {
-    if(m_JavaPlayStore.isValid())
+    if(m_javaPlayStore.isValid())
     {
-        m_JavaPlayStore.callMethod<void>("open",
+        m_javaPlayStore.callMethod<void>("open",
                                          "(Ljava/lang/String;)V",
                                          QAndroidJniObject::fromString("developer?id=" + developerName).object<jstring>()
                                          );

QtAndroidTools/QAndroidPlayStore.h

@@ -41,6 +41,6 @@ public:
     Q_INVOKABLE void openDeveloperAppList(const QString &developerName);
 
 private:
-    const QAndroidJniObject m_JavaPlayStore;
+    const QAndroidJniObject m_javaPlayStore;
     static QAndroidPlayStore *m_pInstance;
 };

QtAndroidTools/QAndroidScreen.cpp

@@ -45,14 +45,14 @@ QAndroidScreen* QAndroidScreen::instance()
 
 bool QAndroidScreen::setOrientation(SCREEN_ORIENTATION orientation)
 {
-    const QAndroidJniObject Activity = QtAndroid::androidActivity();
-    QAndroidJniEnvironment JniEnv;
+    const QAndroidJniObject activity = QtAndroid::androidActivity();
+    QAndroidJniEnvironment jniEnv;
 
-    Activity.callMethod<void>("setRequestedOrientation", "(I)V", orientation);
+    activity.callMethod<void>("setRequestedOrientation", "(I)V", orientation);
 
-    if(JniEnv->ExceptionCheck())
+    if(jniEnv->ExceptionCheck())
     {
-        JniEnv->ExceptionClear();
+        jniEnv->ExceptionClear();
         return false;
     }
     return true;

QtAndroidTools/QAndroidSharing.cpp

@@ -25,23 +25,23 @@
 
 QAndroidSharing *QAndroidSharing::m_pInstance = nullptr;
 
-QAndroidSharing::QAndroidSharing() : m_JavaSharing("com/falsinsoft/qtandroidtools/AndroidSharing",
+QAndroidSharing::QAndroidSharing() : m_javaSharing("com/falsinsoft/qtandroidtools/AndroidSharing",
                                                    "(Landroid/app/Activity;)V",
                                                    QtAndroid::androidActivity().object<jobject>())
 {
     m_pInstance = this;
 
-    if(m_JavaSharing.isValid())
+    if(m_javaSharing.isValid())
     {
-        const JNINativeMethod JniMethod[] = {
-            {"requestedSharedFileInfo", "(Ljava/lang/String;Ljava/lang/String;J)V", reinterpret_cast<void*>(&QAndroidSharing::RequestedSharedFileInfo)}
+        const JNINativeMethod jniMethod[] = {
+            {"requestedSharedFileInfo", "(Ljava/lang/String;Ljava/lang/String;J)V", reinterpret_cast<void*>(&QAndroidSharing::requestedSharedFileInfo)}
         };
-        QAndroidJniEnvironment JniEnv;
-        jclass ObjectClass;
+        QAndroidJniEnvironment jniEnv;
+        jclass objectClass;
 
-        ObjectClass = JniEnv->GetObjectClass(m_JavaSharing.object<jobject>());
-        JniEnv->RegisterNatives(ObjectClass, JniMethod, sizeof(JniMethod)/sizeof(JNINativeMethod));
-        JniEnv->DeleteLocalRef(ObjectClass);
+        objectClass = jniEnv->GetObjectClass(m_javaSharing.object<jobject>());
+        jniEnv->RegisterNatives(objectClass, jniMethod, sizeof(jniMethod)/sizeof(JNINativeMethod));
+        jniEnv->DeleteLocalRef(objectClass);
     }
 }
 
@@ -58,27 +58,27 @@ QAndroidSharing* QAndroidSharing::instance()
     return m_pInstance;
 }
 
-bool QAndroidSharing::shareText(const QString &Text)
+bool QAndroidSharing::shareText(const QString &text)
 {
-    if(m_JavaSharing.isValid())
+    if(m_javaSharing.isValid())
     {
-        return m_JavaSharing.callMethod<jboolean>("shareText",
+        return m_javaSharing.callMethod<jboolean>("shareText",
                                                   "(Ljava/lang/String;)Z",
-                                                  QAndroidJniObject::fromString(Text).object<jstring>()
+                                                  QAndroidJniObject::fromString(text).object<jstring>()
                                                   );
     }
 
     return false;
 }
 
-bool QAndroidSharing::shareBinaryData(const QString &MimeType, const QString &DataFilePath)
+bool QAndroidSharing::shareBinaryData(const QString &mimeType, const QString &dataFilePath)
 {
-    if(m_JavaSharing.isValid())
+    if(m_javaSharing.isValid())
     {
-        return m_JavaSharing.callMethod<jboolean>("shareBinaryData",
+        return m_javaSharing.callMethod<jboolean>("shareBinaryData",
                                                   "(Ljava/lang/String;Ljava/lang/String;)Z",
-                                                  QAndroidJniObject::fromString(MimeType).object<jstring>(),
-                                                  QAndroidJniObject::fromString(DataFilePath).object<jstring>()
+                                                  QAndroidJniObject::fromString(mimeType).object<jstring>(),
+                                                  QAndroidJniObject::fromString(dataFilePath).object<jstring>()
                                                   );
     }
 
@@ -87,74 +87,74 @@ bool QAndroidSharing::shareBinaryData(const QString &MimeType, const QString &Da
 
 QString QAndroidSharing::getReceivedSharedText()
 {
-    QString SharedText;
+    QString sharedText;
 
-    if(m_JavaSharing.isValid())
+    if(m_javaSharing.isValid())
     {
-        const QAndroidJniObject SharedTextObj = m_JavaSharing.callObjectMethod("getReceivedSharedText", "()Ljava/lang/String;");
+        const QAndroidJniObject sharedTextObj = m_javaSharing.callObjectMethod("getReceivedSharedText", "()Ljava/lang/String;");
 
-        if(SharedTextObj.isValid())
+        if(sharedTextObj.isValid())
         {
-            SharedText = SharedTextObj.toString();
+            sharedText = sharedTextObj.toString();
         }
     }
 
-    return SharedText;
+    return sharedText;
 }
 
 QByteArray QAndroidSharing::getReceivedSharedBinaryData()
 {
-    QByteArray SharedData;
+    QByteArray sharedData;
 
-    if(m_JavaSharing.isValid())
+    if(m_javaSharing.isValid())
     {
-        const QAndroidJniObject SharedDataObj = m_JavaSharing.callObjectMethod("getReceivedSharedBinaryData", "()[B");
+        const QAndroidJniObject sharedDataObj = m_javaSharing.callObjectMethod("getReceivedSharedBinaryData", "()[B");
 
-        if(SharedDataObj.isValid())
+        if(sharedDataObj.isValid())
         {
-            SharedData = ConvertByteArray(SharedDataObj);
+            sharedData = convertByteArray(sharedDataObj);
         }
     }
 
-    return SharedData;
+    return sharedData;
 }
 
 QVariantList QAndroidSharing::getReceivedMultipleSharedBinaryData()
 {
-    QVariantList MultipleSharedData;
+    QVariantList multipleSharedData;
 
-    if(m_JavaSharing.isValid())
+    if(m_javaSharing.isValid())
     {
-        const QAndroidJniObject MultipleSharedDataObj = m_JavaSharing.callObjectMethod("getReceivedMultipleSharedBinaryData", "()[[B");
+        const QAndroidJniObject multipleSharedDataObj = m_javaSharing.callObjectMethod("getReceivedMultipleSharedBinaryData", "()[[B");
 
-        if(MultipleSharedDataObj.isValid())
+        if(multipleSharedDataObj.isValid())
         {
-            const jobjectArray DataArray = MultipleSharedDataObj.object<jobjectArray>();
-            QAndroidJniEnvironment pEnv;
-            int ArraySize;
+            const jobjectArray dataArray = multipleSharedDataObj.object<jobjectArray>();
+            QAndroidJniEnvironment jniEnv;
+            int arraySize;
 
-            ArraySize = pEnv->GetArrayLength(DataArray);
-            for(int i = 0; i < ArraySize; i++)
+            arraySize = jniEnv->GetArrayLength(dataArray);
+            for(int i = 0; i < arraySize; i++)
             {
-                MultipleSharedData << ConvertByteArray(QAndroidJniObject(pEnv->GetObjectArrayElement(DataArray, i)));
+                multipleSharedData << convertByteArray(QAndroidJniObject(jniEnv->GetObjectArrayElement(dataArray, i)));
             }
         }
     }
 
-    return MultipleSharedData;
+    return multipleSharedData;
 }
 
-bool QAndroidSharing::requestSharedFile(const QString &MimeType)
+bool QAndroidSharing::requestSharedFile(const QString &mimeType)
 {
-    if(m_JavaSharing.isValid())
+    if(m_javaSharing.isValid())
     {
-        const QAndroidJniObject RequestSharedFileIntent = m_JavaSharing.callObjectMethod("getRequestSharedFileIntent",
+        const QAndroidJniObject requestSharedFileIntent = m_javaSharing.callObjectMethod("getRequestSharedFileIntent",
                                                                                          "(Ljava/lang/String;)Landroid/content/Intent;",
-                                                                                         QAndroidJniObject::fromString(MimeType).object<jstring>()
+                                                                                         QAndroidJniObject::fromString(mimeType).object<jstring>()
                                                                                          );
-        if(RequestSharedFileIntent.isValid())
+        if(requestSharedFileIntent.isValid())
         {
-            QtAndroid::startActivity(RequestSharedFileIntent, m_SharedFileRequestId, this);
+            QtAndroid::startActivity(requestSharedFileIntent, m_sharedFileRequestId, this);
             return true;
         }
     }
@@ -162,24 +162,24 @@ bool QAndroidSharing::requestSharedFile(const QString &MimeType)
     return false;
 }
 
-bool QAndroidSharing::saveRequestedSharedFile(const QString &FilePath)
+bool QAndroidSharing::saveRequestedSharedFile(const QString &filePath)
 {
-    if(m_JavaSharing.isValid())
+    if(m_javaSharing.isValid())
     {
-        const QAndroidJniObject SharedFileDataObj = m_JavaSharing.callObjectMethod("getRequestedSharedFile", "()[B");
+        const QAndroidJniObject sharedFileDataObj = m_javaSharing.callObjectMethod("getRequestedSharedFile", "()[B");
 
-        if(SharedFileDataObj.isValid())
+        if(sharedFileDataObj.isValid())
         {
-            const QByteArray SharedFileData = ConvertByteArray(SharedFileDataObj);
-            QFile SharedFile(FilePath);
+            const QByteArray sharedFileData = convertByteArray(sharedFileDataObj);
+            QFile sharedFile(filePath);
 
-            if(SharedFile.open(QIODevice::WriteOnly) == true)
+            if(sharedFile.open(QIODevice::WriteOnly) == true)
             {
-                if(SharedFile.write(SharedFileData) == SharedFileData.size())
+                if(sharedFile.write(sharedFileData) == sharedFileData.size())
                 {
                     return true;
                 }
-                SharedFile.remove();
+                sharedFile.remove();
             }
         }
     }
@@ -189,21 +189,21 @@ bool QAndroidSharing::saveRequestedSharedFile(const QString &FilePath)
 
 void QAndroidSharing::closeRequestedSharedFile()
 {
-    if(m_JavaSharing.isValid())
+    if(m_javaSharing.isValid())
     {
-        m_JavaSharing.callMethod<void>("closeRequestedSharedFile");
+        m_javaSharing.callMethod<void>("closeRequestedSharedFile");
     }
 }
 
-bool QAndroidSharing::shareFile(bool FileAvailable, const QString &MimeType, const QString &FilePath)
+bool QAndroidSharing::shareFile(bool fileAvailable, const QString &mimeType, const QString &filePath)
 {
-    if(m_JavaSharing.isValid())
+    if(m_javaSharing.isValid())
     {
-        return m_JavaSharing.callMethod<jboolean>("shareFile",
+        return m_javaSharing.callMethod<jboolean>("shareFile",
                                                   "(ZLjava/lang/String;Ljava/lang/String;)Z",
-                                                  FileAvailable,
-                                                  QAndroidJniObject::fromString(MimeType).object<jstring>(),
-                                                  QAndroidJniObject::fromString(FilePath).object<jstring>()
+                                                  fileAvailable,
+                                                  QAndroidJniObject::fromString(mimeType).object<jstring>(),
+                                                  QAndroidJniObject::fromString(filePath).object<jstring>()
                                                   );
     }
 
@@ -214,51 +214,51 @@ void QAndroidSharing::handleActivityResult(int receiverRequestCode, int resultCo
 {
     Q_UNUSED(resultCode)
 
-    if(receiverRequestCode == m_SharedFileRequestId)
+    if(receiverRequestCode == m_sharedFileRequestId)
     {
         const int RESULT_OK = QAndroidJniObject::getStaticField<jint>("android/app/Activity", "RESULT_OK");
-        bool SharedFileAvailable = false;
+        bool sharedFileAvailable = false;
 
         if(resultCode == RESULT_OK)
         {
-            if(m_JavaSharing.isValid())
+            if(m_javaSharing.isValid())
             {
-                SharedFileAvailable = m_JavaSharing.callMethod<jboolean>("requestSharedFileIntentDataResult",
+                sharedFileAvailable = m_javaSharing.callMethod<jboolean>("requestSharedFileIntentDataResult",
                                                                          "(Landroid/content/Intent;)Z",
                                                                          data.object<jobject>()
                                                                          );
             }
         }
-        if(SharedFileAvailable == false)
+        if(sharedFileAvailable == false)
         {
-            emit requestedSharedFileNotAvailable();
+            Q_EMIT requestedSharedFileNotAvailable();
         }
     }
 }
 
-void QAndroidSharing::RequestedSharedFileInfo(JNIEnv *env, jobject thiz, jstring mimeType, jstring name, jlong size)
+void QAndroidSharing::requestedSharedFileInfo(JNIEnv *env, jobject thiz, jstring mimeType, jstring name, jlong size)
 {
     Q_UNUSED(env)
     Q_UNUSED(thiz)
 
     if(m_pInstance != nullptr)
     {
-        emit m_pInstance->requestedSharedFileReadyToSave(QAndroidJniObject(mimeType).toString(), QAndroidJniObject(name).toString(), size);
+        Q_EMIT m_pInstance->requestedSharedFileReadyToSave(QAndroidJniObject(mimeType).toString(), QAndroidJniObject(name).toString(), size);
     }
 }
 
-QByteArray QAndroidSharing::ConvertByteArray(const QAndroidJniObject &JavaByteArray)
+QByteArray QAndroidSharing::convertByteArray(const QAndroidJniObject &javaByteArray)
 {
-    const jbyteArray DataArray = JavaByteArray.object<jbyteArray>();
-    QAndroidJniEnvironment pEnv;
-    QByteArray ByteArray;
-    int ArraySize;
+    const jbyteArray dataArray = javaByteArray.object<jbyteArray>();
+    QAndroidJniEnvironment jniEnv;
+    QByteArray byteArray;
+    int arraySize;
     jbyte *pData;
 
-    ArraySize = pEnv->GetArrayLength(DataArray);
-    pData = pEnv->GetByteArrayElements(DataArray, NULL);
-    ByteArray = QByteArray(reinterpret_cast<const char*>(pData), ArraySize);
-    pEnv->ReleaseByteArrayElements(DataArray, pData, JNI_ABORT);
+    arraySize = jniEnv->GetArrayLength(dataArray);
+    pData = jniEnv->GetByteArrayElements(dataArray, NULL);
+    byteArray = QByteArray(reinterpret_cast<const char*>(pData), arraySize);
+    jniEnv->ReleaseByteArrayElements(dataArray, pData, JNI_ABORT);
 
-    return ByteArray;
+    return byteArray;
 }

QtAndroidTools/QAndroidSharing.h

@@ -37,28 +37,28 @@ public:
     static QObject* qmlInstance(QQmlEngine *engine, QJSEngine *scriptEngine);
     static QAndroidSharing* instance();
 
-    Q_INVOKABLE bool shareText(const QString &Text);
-    Q_INVOKABLE bool shareBinaryData(const QString &MimeType, const QString &DataFilePath);
+    Q_INVOKABLE bool shareText(const QString &text);
+    Q_INVOKABLE bool shareBinaryData(const QString &mimeType, const QString &dataFilePath);
     Q_INVOKABLE QString getReceivedSharedText();
     Q_INVOKABLE QByteArray getReceivedSharedBinaryData();
     Q_INVOKABLE QVariantList getReceivedMultipleSharedBinaryData();
-    Q_INVOKABLE bool requestSharedFile(const QString &MimeType);
-    Q_INVOKABLE bool saveRequestedSharedFile(const QString &FilePath);
+    Q_INVOKABLE bool requestSharedFile(const QString &mimeType);
+    Q_INVOKABLE bool saveRequestedSharedFile(const QString &filePath);
     Q_INVOKABLE void closeRequestedSharedFile();
-    Q_INVOKABLE bool shareFile(bool FileAvailable, const QString &MimeType = QString(), const QString &FilePath = QString());
+    Q_INVOKABLE bool shareFile(bool fileAvailable, const QString &mimeType = QString(), const QString &filePath = QString());
 
-signals:
+Q_SIGNALS:
     void requestedSharedFileReadyToSave(const QString &mimeType, const QString &name, long size);
     void requestedSharedFileNotAvailable();
 
 private:
-    const QAndroidJniObject m_JavaSharing;
+    const QAndroidJniObject m_javaSharing;
     static QAndroidSharing *m_pInstance;
-    const int m_SharedFileRequestId = 9002;
+    const int m_sharedFileRequestId = 9002;
 
     void handleActivityResult(int receiverRequestCode, int resultCode, const QAndroidJniObject &data) override;
 
-    static void RequestedSharedFileInfo(JNIEnv *env, jobject thiz, jstring mimeType, jstring name, jlong size);
+    static void requestedSharedFileInfo(JNIEnv *env, jobject thiz, jstring mimeType, jstring name, jlong size);
 
-    inline QByteArray ConvertByteArray(const QAndroidJniObject &JavaByteArray);
+    inline QByteArray convertByteArray(const QAndroidJniObject &javaByteArray);
 };

QtAndroidTools/QAndroidSignalStrength.cpp

@@ -26,31 +26,31 @@
 
 QAndroidSignalStrength *QAndroidSignalStrength::m_pInstance = nullptr;
 
-QAndroidSignalStrength::QAndroidSignalStrength() : m_JavaSignalStrength("com/falsinsoft/qtandroidtools/AndroidSignalStrength",
+QAndroidSignalStrength::QAndroidSignalStrength() : m_javaSignalStrength("com/falsinsoft/qtandroidtools/AndroidSignalStrength",
                                                                         "(Landroid/app/Activity;)V",
                                                                         QtAndroid::androidActivity().object<jobject>())
 {
     m_pInstance = this;
 
-    if(m_JavaSignalStrength.isValid())
+    if(m_javaSignalStrength.isValid())
     {
-        const JNINativeMethod JniMethod[] = {
-            {"signalStrengthChanged", "()V", reinterpret_cast<void *>(&QAndroidSignalStrength::SignalStrengthChanged)},
+        const JNINativeMethod jniMethod[] = {
+            {"signalStrengthChanged", "()V", reinterpret_cast<void *>(&QAndroidSignalStrength::deviceSignalStrengthChanged)},
         };
-        QAndroidJniEnvironment JniEnv;
-        jclass ObjectClass;
+        QAndroidJniEnvironment jniEnv;
+        jclass objectClass;
 
-        ObjectClass = JniEnv->GetObjectClass(m_JavaSignalStrength.object<jobject>());
-        JniEnv->RegisterNatives(ObjectClass, JniMethod, sizeof(JniMethod)/sizeof(JNINativeMethod));
-        JniEnv->DeleteLocalRef(ObjectClass);
+        objectClass = jniEnv->GetObjectClass(m_javaSignalStrength.object<jobject>());
+        jniEnv->RegisterNatives(objectClass, jniMethod, sizeof(jniMethod)/sizeof(JNINativeMethod));
+        jniEnv->DeleteLocalRef(objectClass);
     }
-    connect(qGuiApp, &QGuiApplication::applicationStateChanged, this, &QAndroidSignalStrength::ApplicationStateChanged);
-    SetNewAppState(APP_STATE_CREATE);
+    connect(qGuiApp, &QGuiApplication::applicationStateChanged, this, &QAndroidSignalStrength::applicationStateChanged);
+    setNewAppState(APP_STATE_CREATE);
 }
 
 QAndroidSignalStrength::~QAndroidSignalStrength()
 {
-    SetNewAppState(APP_STATE_DESTROY);
+    setNewAppState(APP_STATE_DESTROY);
 }
 
 QObject* QAndroidSignalStrength::qmlInstance(QQmlEngine *engine, QJSEngine *scriptEngine)
@@ -66,58 +66,58 @@ QAndroidSignalStrength* QAndroidSignalStrength::instance()
     return m_pInstance;
 }
 
-void QAndroidSignalStrength::SignalStrengthChanged(JNIEnv *env, jobject thiz)
+void QAndroidSignalStrength::deviceSignalStrengthChanged(JNIEnv *env, jobject thiz)
 {
     Q_UNUSED(env)
     Q_UNUSED(thiz)
 
     if(m_pInstance != nullptr)
     {
-        emit m_pInstance->signalStrengthChanged();
-        emit m_pInstance->signalLevelChanged();
+        Q_EMIT m_pInstance->signalStrengthChanged();
+        Q_EMIT m_pInstance->signalLevelChanged();
     }
 }
 
 int QAndroidSignalStrength::getSignalStrength()
 {
-    if(m_JavaSignalStrength.isValid())
+    if(m_javaSignalStrength.isValid())
     {
-        return m_JavaSignalStrength.callMethod<jint>("getSignalStrength");
+        return m_javaSignalStrength.callMethod<jint>("getSignalStrength");
     }
     return 0;
 }
 
 QAndroidSignalStrength::SIGNAL_LEVEL QAndroidSignalStrength::getSignalLevel()
 {
-    const int SignalStrength = getSignalStrength();
-    SIGNAL_LEVEL SignalLevel;
+    const int signalStrength = getSignalStrength();
+    SIGNAL_LEVEL signalLevel;
 
-    if(SignalStrength >= 30)
-        SignalLevel = LEVEL_GREAT;
-    else if(SignalStrength >= 20)
-        SignalLevel = LEVEL_GOOD;
-    else if(SignalStrength >= 12)
-        SignalLevel = LEVEL_MODERATE;
-    else if(SignalStrength >= 5)
-        SignalLevel = LEVEL_POOR;
+    if(signalStrength >= 30)
+        signalLevel = LEVEL_GREAT;
+    else if(signalStrength >= 20)
+        signalLevel = LEVEL_GOOD;
+    else if(signalStrength >= 12)
+        signalLevel = LEVEL_MODERATE;
+    else if(signalStrength >= 5)
+        signalLevel = LEVEL_POOR;
     else
-        SignalLevel = LEVEL_NONE;
+        signalLevel = LEVEL_NONE;
 
-    return SignalLevel;
+    return signalLevel;
 }
 
-void QAndroidSignalStrength::ApplicationStateChanged(Qt::ApplicationState State)
+void QAndroidSignalStrength::applicationStateChanged(Qt::ApplicationState state)
 {
-    SetNewAppState((State == Qt::ApplicationActive) ? APP_STATE_START : APP_STATE_STOP);
+    setNewAppState((state == Qt::ApplicationActive) ? APP_STATE_START : APP_STATE_STOP);
 }
 
-void QAndroidSignalStrength::SetNewAppState(APP_STATE NewState)
+void QAndroidSignalStrength::setNewAppState(APP_STATE newState)
 {
-    if(m_JavaSignalStrength.isValid())
+    if(m_javaSignalStrength.isValid())
     {
-        m_JavaSignalStrength.callMethod<void>("appStateChanged",
+        m_javaSignalStrength.callMethod<void>("appStateChanged",
                                               "(I)V",
-                                              NewState
+                                              newState
                                               );
     }
 }

QtAndroidTools/QAndroidSignalStrength.h

@@ -54,18 +54,18 @@ public:
     int getSignalStrength();
     SIGNAL_LEVEL getSignalLevel();
 
-signals:
+Q_SIGNALS:
     void signalStrengthChanged();
     void signalLevelChanged();
 
-private slots:
-    void ApplicationStateChanged(Qt::ApplicationState State);
+private Q_SLOTS:
+    void applicationStateChanged(Qt::ApplicationState state);
 
 private:
-    const QAndroidJniObject m_JavaSignalStrength;
+    const QAndroidJniObject m_javaSignalStrength;
     static QAndroidSignalStrength *m_pInstance;
 
-    static void SignalStrengthChanged(JNIEnv *env, jobject thiz);
+    static void deviceSignalStrengthChanged(JNIEnv *env, jobject thiz);
 
     enum APP_STATE
     {
@@ -74,5 +74,5 @@ private:
         APP_STATE_STOP,
         APP_STATE_DESTROY
     };
-    void SetNewAppState(APP_STATE NewState);
+    void setNewAppState(APP_STATE newState);
 };

QtAndroidTools/QAndroidSystem.cpp

@@ -28,7 +28,7 @@ QAndroidSystem *QAndroidSystem::m_pInstance = nullptr;
 QAndroidSystem::QAndroidSystem()
 {
     m_pInstance = this;
-    LoadStandardPaths();
+    loadStandardPaths();
 }
 
 QObject* QAndroidSystem::qmlInstance(QQmlEngine *engine, QJSEngine *scriptEngine)
@@ -46,40 +46,40 @@ QAndroidSystem* QAndroidSystem::instance()
 
 const QString& QAndroidSystem::getDataLocation() const
 {
-    return m_StandardPaths.DataLocation;
+    return m_standardPaths.dataLocation;
 }
 
 const QString& QAndroidSystem::getConfigLocation() const
 {
-    return m_StandardPaths.ConfigLocation;
+    return m_standardPaths.configLocation;
 }
 
 const QString& QAndroidSystem::getDownloadLocation() const
 {
-    return m_StandardPaths.DownloadLocation;
+    return m_standardPaths.downloadLocation;
 }
 
 const QString& QAndroidSystem::getMusicLocation() const
 {
-    return m_StandardPaths.MusicLocation;
+    return m_standardPaths.musicLocation;
 }
 
 const QString& QAndroidSystem::getMoviesLocation() const
 {
-    return m_StandardPaths.MoviesLocation;
+    return m_standardPaths.moviesLocation;
 }
 
 const QString& QAndroidSystem::getPicturesLocation() const
 {
-    return m_StandardPaths.PicturesLocation;
+    return m_standardPaths.picturesLocation;
 }
 
-void QAndroidSystem::LoadStandardPaths()
+void QAndroidSystem::loadStandardPaths()
 {
-    m_StandardPaths.DataLocation = QStandardPaths::writableLocation(QStandardPaths::DataLocation);
-    m_StandardPaths.ConfigLocation = QStandardPaths::writableLocation(QStandardPaths::ConfigLocation);
-    m_StandardPaths.DownloadLocation = QStandardPaths::writableLocation(QStandardPaths::DownloadLocation);
-    m_StandardPaths.MusicLocation = QStandardPaths::writableLocation(QStandardPaths::MusicLocation);
-    m_StandardPaths.MoviesLocation = QStandardPaths::writableLocation(QStandardPaths::MoviesLocation);
-    m_StandardPaths.PicturesLocation = QStandardPaths::writableLocation(QStandardPaths::PicturesLocation);
+    m_standardPaths.dataLocation = QStandardPaths::writableLocation(QStandardPaths::DataLocation);
+    m_standardPaths.configLocation = QStandardPaths::writableLocation(QStandardPaths::ConfigLocation);
+    m_standardPaths.downloadLocation = QStandardPaths::writableLocation(QStandardPaths::DownloadLocation);
+    m_standardPaths.musicLocation = QStandardPaths::writableLocation(QStandardPaths::MusicLocation);
+    m_standardPaths.moviesLocation = QStandardPaths::writableLocation(QStandardPaths::MoviesLocation);
+    m_standardPaths.picturesLocation = QStandardPaths::writableLocation(QStandardPaths::PicturesLocation);
 }

QtAndroidTools/QAndroidSystem.h

@@ -55,13 +55,13 @@ private:
     static QAndroidSystem *m_pInstance;
 
     struct {
-        QString DataLocation;
-        QString ConfigLocation;
-        QString DownloadLocation;
-        QString MusicLocation;
-        QString MoviesLocation;
-        QString PicturesLocation;
-    } m_StandardPaths;
+        QString dataLocation;
+        QString configLocation;
+        QString downloadLocation;
+        QString musicLocation;
+        QString moviesLocation;
+        QString picturesLocation;
+    } m_standardPaths;
 
-    void LoadStandardPaths();
+    void loadStandardPaths();
 };

QtAndroidTools/QtAndroidTools.cpp

@@ -74,12 +74,12 @@
 
 QtAndroidTools *QtAndroidTools::m_pInstance = nullptr;
 
-QtAndroidTools::QtAndroidTools() : m_JavaTools("com/falsinsoft/qtandroidtools/AndroidTools",
+QtAndroidTools::QtAndroidTools() : m_javaTools("com/falsinsoft/qtandroidtools/AndroidTools",
                                                "(Landroid/app/Activity;)V",
                                                QtAndroid::androidActivity().object<jobject>())
 {
     m_pInstance = this;
-    GetActivityData();
+    getActivityData();
 }
 
 QObject* QtAndroidTools::qmlInstance(QQmlEngine *engine, QJSEngine *scriptEngine)
@@ -88,7 +88,7 @@ QObject* QtAndroidTools::qmlInstance(QQmlEngine *engine, QJSEngine *scriptEngine
     Q_UNUSED(scriptEngine);
 
     QtAndroidTools *pAndroidTools = new QtAndroidTools();
-    engine->addImageProvider("QtAndroidTools", new PhotoImageProvider(&pAndroidTools->m_PhotoMap));
+    engine->addImageProvider("QtAndroidTools", new PhotoImageProvider(&pAndroidTools->m_photoMap));
     return pAndroidTools;
 }
 
@@ -99,78 +99,78 @@ QtAndroidTools* QtAndroidTools::instance()
 
 QtAndroidTools::ACTION_ID QtAndroidTools::getActivityAction() const
 {
-    return m_ActivityAction;
+    return m_activityAction;
 }
 
 QString QtAndroidTools::getActivityMimeType() const
 {
-    return m_ActivityMimeType;
+    return m_activityMimeType;
 }
 
-void QtAndroidTools::GetActivityData()
+void QtAndroidTools::getActivityData()
 {
-    if(m_JavaTools.isValid())
+    if(m_javaTools.isValid())
     {
-        QAndroidJniObject MimeTypeObj;
+        QAndroidJniObject mimeTypeObj;
 
-        m_ActivityAction = static_cast<ACTION_ID>(m_JavaTools.callMethod<jint>("getActivityAction", "()I"));
+        m_activityAction = static_cast<ACTION_ID>(m_javaTools.callMethod<jint>("getActivityAction", "()I"));
 
-        MimeTypeObj = m_JavaTools.callObjectMethod("getActivityMimeType", "()Ljava/lang/String;");
-        if(MimeTypeObj.isValid())
+        mimeTypeObj = m_javaTools.callObjectMethod("getActivityMimeType", "()Ljava/lang/String;");
+        if(mimeTypeObj.isValid())
         {
-            m_ActivityMimeType = MimeTypeObj.toString();
+            m_activityMimeType = mimeTypeObj.toString();
         }
     }
 }
 
-bool QtAndroidTools::insertImage(const QString &Name, const QByteArray &Data)
+bool QtAndroidTools::insertImage(const QString &name, const QByteArray &data)
 {
-    QPixmap DataImage;
+    QPixmap dataImage;
 
-    if(DataImage.loadFromData(Data) == true)
+    if(dataImage.loadFromData(data) == true)
     {
-        m_PhotoMap.insert(Name, DataImage);
+        m_photoMap.insert(name, dataImage);
         return true;
     }
 
     return false;
 }
 
-bool QtAndroidTools::removeImage(const QString &Name)
+bool QtAndroidTools::removeImage(const QString &name)
 {
-    return (m_PhotoMap.remove(Name) > 0) ? true : false;
+    return (m_photoMap.remove(name) > 0) ? true : false;
 }
 
-bool QtAndroidTools::binaryDataToFile(const QByteArray &BinaryData, const QString &FilePath)
+bool QtAndroidTools::binaryDataToFile(const QByteArray &binaryData, const QString &filePath)
 {
-    QFile BinaryFile(FilePath);
+    QFile binaryFile(filePath);
 
-    if(BinaryFile.open(QIODevice::WriteOnly) == true)
+    if(binaryFile.open(QIODevice::WriteOnly) == true)
     {
-        if(BinaryFile.write(BinaryData) == BinaryData.size())
+        if(binaryFile.write(binaryData) == binaryData.size())
         {
             return true;
         }
-        BinaryFile.remove();
+        binaryFile.remove();
     }
 
     return false;
 }
 
-QByteArray QtAndroidTools::fileToBinaryData(const QString &FilePath)
+QByteArray QtAndroidTools::fileToBinaryData(const QString &filePath)
 {
-    QFile BinaryFile(FilePath);
-    QByteArray BinaryData;
+    QFile binaryFile(filePath);
+    QByteArray binaryData;
 
-    if(BinaryFile.open(QIODevice::ReadOnly) == true)
+    if(binaryFile.open(QIODevice::ReadOnly) == true)
     {
-        BinaryData = BinaryFile.readAll();
+        binaryData = binaryFile.readAll();
     }
 
-    return BinaryData;
+    return binaryData;
 }
 
-void QtAndroidTools::InitializeQmlTools()
+void QtAndroidTools::initializeQmlTools()
 {
     qmlRegisterSingletonType<QtAndroidTools>("QtAndroidTools", 1, 0, "QtAndroidTools", &QtAndroidTools::qmlInstance);
 #ifdef QTAT_APP_PERMISSIONS

QtAndroidTools/QtAndroidTools.h

@@ -44,18 +44,18 @@ class QtAndroidTools : public QObject
 
         QPixmap requestPixmap(const QString &id, QSize *size, const QSize &requestedSize)
         {
-            QMap<QString, QPixmap>::const_iterator PhotoIterator = m_pPhotoMap->find(id);
+            QMap<QString, QPixmap>::const_iterator photoIterator = m_pPhotoMap->find(id);
 
-            if(PhotoIterator != m_pPhotoMap->constEnd())
+            if(photoIterator != m_pPhotoMap->constEnd())
             {
-                const QPixmap Photo = PhotoIterator.value();
+                const QPixmap photo = photoIterator.value();
 
-                if(size) *size = Photo.size();
+                if(size) *size = photo.size();
 
                 if(requestedSize.width() > 0 && requestedSize.height() > 0)
-                    return Photo.scaled(requestedSize);
+                    return photo.scaled(requestedSize);
                 else
-                    return Photo;
+                    return photo;
             }
 
             return QPixmap();
@@ -79,22 +79,22 @@ public:
 
     static QObject* qmlInstance(QQmlEngine *engine, QJSEngine *scriptEngine);
     static QtAndroidTools* instance();
-    static void InitializeQmlTools();
+    static void initializeQmlTools();
 
-    Q_INVOKABLE bool insertImage(const QString &Name, const QByteArray &Data);
-    Q_INVOKABLE bool removeImage(const QString &Name);
-    Q_INVOKABLE bool binaryDataToFile(const QByteArray &BinaryData, const QString &FilePath);
-    Q_INVOKABLE QByteArray fileToBinaryData(const QString &FilePath);
+    Q_INVOKABLE bool insertImage(const QString &name, const QByteArray &data);
+    Q_INVOKABLE bool removeImage(const QString &name);
+    Q_INVOKABLE bool binaryDataToFile(const QByteArray &binaryData, const QString &filePath);
+    Q_INVOKABLE QByteArray fileToBinaryData(const QString &filePath);
 
     ACTION_ID getActivityAction() const;
     QString getActivityMimeType() const;
 
 private:
-    const QAndroidJniObject m_JavaTools;
+    const QAndroidJniObject m_javaTools;
     static QtAndroidTools *m_pInstance;
-    QMap<QString, QPixmap> m_PhotoMap;
-    ACTION_ID m_ActivityAction = ACTION_NONE;
-    QString m_ActivityMimeType;
+    QMap<QString, QPixmap> m_photoMap;
+    ACTION_ID m_activityAction = ACTION_NONE;
+    QString m_activityMimeType;
 
-    void GetActivityData();
+    void getActivityData();
 };

QtAndroidTools/src/com/falsinsoft/qtandroidtools/AndroidAdMobBanner.java

@@ -50,11 +50,11 @@ public class AndroidAdMobBanner
     private BannerSize mBannerPixelsSize = new BannerSize();
     private String[] mKeywordsList = null;
 
-    public AndroidAdMobBanner(Activity ActivityInstance)
+    public AndroidAdMobBanner(Activity activityInstance)
     {
-        mViewGroup = (ViewGroup)ActivityInstance.getWindow().getDecorView().findViewById(android.R.id.content);
+        mViewGroup = (ViewGroup)activityInstance.getWindow().getDecorView().findViewById(android.R.id.content);
         mBannerListener = new BannerListener();
-        mActivityInstance = ActivityInstance;
+        mActivityInstance = activityInstance;
     }
 
     public BannerSize getPixelsSize()
@@ -62,9 +62,9 @@ public class AndroidAdMobBanner
         return mBannerPixelsSize;
     }
 
-    public void setKeywords(String[] KeywordsList)
+    public void setKeywords(String[] keywordsList)
     {
-        mKeywordsList = KeywordsList;
+        mKeywordsList = keywordsList;
     }
 
     public void setType(final int type)
@@ -74,40 +74,40 @@ public class AndroidAdMobBanner
             return;
         }
 
-        SyncRunOnUiThread UiThread = new SyncRunOnUiThread(mActivityInstance, new SyncRunOnUiThread.SyncRunOnUiThreadListener()
+        SyncRunOnUiThread uiThread = new SyncRunOnUiThread(mActivityInstance, new SyncRunOnUiThread.SyncRunOnUiThreadListener()
         {
             public void runOnUIThread()
             {
-                AdSize BannerSize = AdSize.BANNER;
+                AdSize bannerSize = AdSize.BANNER;
 
                 switch(type)
                 {
                     case TYPE_BANNER:
-                        BannerSize = AdSize.BANNER;
+                        bannerSize = AdSize.BANNER;
                         break;
                     case TYPE_FULL_BANNER:
-                        BannerSize = AdSize.FULL_BANNER;
+                        bannerSize = AdSize.FULL_BANNER;
                         break;
                     case TYPE_LARGE_BANNER:
-                        BannerSize = AdSize.LARGE_BANNER;
+                        bannerSize = AdSize.LARGE_BANNER;
                         break;
                     case TYPE_MEDIUM_RECTANGLE:
-                        BannerSize = AdSize.MEDIUM_RECTANGLE;
+                        bannerSize = AdSize.MEDIUM_RECTANGLE;
                         break;
                     case TYPE_SMART_BANNER:
-                        BannerSize = AdSize.SMART_BANNER;
+                        bannerSize = AdSize.SMART_BANNER;
                         break;
                     case TYPE_WIDE_SKYSCRAPER:
-                        BannerSize = AdSize.WIDE_SKYSCRAPER;
+                        bannerSize = AdSize.WIDE_SKYSCRAPER;
                         break;
                 }
-                mBannerView.setAdSize(BannerSize);
+                mBannerView.setAdSize(bannerSize);
 
-                mBannerPixelsSize.width  = BannerSize.getWidthInPixels(mActivityInstance);
-                mBannerPixelsSize.height = BannerSize.getHeightInPixels(mActivityInstance);
+                mBannerPixelsSize.width  = bannerSize.getWidthInPixels(mActivityInstance);
+                mBannerPixelsSize.height = bannerSize.getHeightInPixels(mActivityInstance);
             }
         });
-        UiThread.exec();
+        uiThread.exec();
     }
 
     public void setPos(final int posX, final int posY)
@@ -117,7 +117,7 @@ public class AndroidAdMobBanner
             return;
         }
 
-        SyncRunOnUiThread UiThread = new SyncRunOnUiThread(mActivityInstance, new SyncRunOnUiThread.SyncRunOnUiThreadListener()
+        SyncRunOnUiThread uiThread = new SyncRunOnUiThread(mActivityInstance, new SyncRunOnUiThread.SyncRunOnUiThreadListener()
         {
             public void runOnUIThread()
             {
@@ -125,7 +125,7 @@ public class AndroidAdMobBanner
                 mBannerView.setY(posY);
             }
         });
-        UiThread.exec();
+        uiThread.exec();
     }
 
     public void setUnitId(final String unitId)
@@ -135,14 +135,14 @@ public class AndroidAdMobBanner
             return;
         }
 
-        SyncRunOnUiThread UiThread = new SyncRunOnUiThread(mActivityInstance, new SyncRunOnUiThread.SyncRunOnUiThreadListener()
+        SyncRunOnUiThread uiThread = new SyncRunOnUiThread(mActivityInstance, new SyncRunOnUiThread.SyncRunOnUiThreadListener()
         {
             public void runOnUIThread()
             {
                 mBannerView.setAdUnitId(unitId);
             }
         });
-        UiThread.exec();
+        uiThread.exec();
     }
 
     public void show()
@@ -159,16 +159,16 @@ public class AndroidAdMobBanner
             {
                 if(mBannerLoaded == false)
                 {
-                    AdRequest.Builder BannerRequest = new AdRequest.Builder();
+                    AdRequest.Builder bannerRequest = new AdRequest.Builder();
 
                     if(mKeywordsList != null)
                     {
-                        for(String Keyword : mKeywordsList)
+                        for(String keyword : mKeywordsList)
                         {
-                            BannerRequest.addKeyword(Keyword);
+                            bannerRequest.addKeyword(keyword);
                         }
                     }
-                    mBannerView.loadAd(BannerRequest.build());
+                    mBannerView.loadAd(bannerRequest.build());
 
                     bannerEvent(EVENT_LOADING);
                 }
@@ -246,21 +246,21 @@ public class AndroidAdMobBanner
             return;
         }
 
-        SyncRunOnUiThread UiThread = new SyncRunOnUiThread(mActivityInstance, new SyncRunOnUiThread.SyncRunOnUiThreadListener()
+        SyncRunOnUiThread uiThread = new SyncRunOnUiThread(mActivityInstance, new SyncRunOnUiThread.SyncRunOnUiThreadListener()
         {
             public void runOnUIThread()
             {
-                final FrameLayout.LayoutParams LayoutParams = new FrameLayout.LayoutParams(FrameLayout.LayoutParams.WRAP_CONTENT, FrameLayout.LayoutParams.WRAP_CONTENT);
+                final FrameLayout.LayoutParams layoutParams = new FrameLayout.LayoutParams(FrameLayout.LayoutParams.WRAP_CONTENT, FrameLayout.LayoutParams.WRAP_CONTENT);
 
                 mBannerView = new AdView(mActivityInstance);
-                mBannerView.setLayoutParams(LayoutParams);
+                mBannerView.setLayoutParams(layoutParams);
                 mBannerView.setBackgroundColor(Color.BLACK);
                 mBannerView.setAdListener(mBannerListener);
                 mBannerView.setVisibility(View.GONE);
                 mViewGroup.addView(mBannerView);
             }
         });
-        UiThread.exec();
+        uiThread.exec();
     }
 
     private void destroyBanner()
@@ -270,7 +270,7 @@ public class AndroidAdMobBanner
             return;
         }
 
-        SyncRunOnUiThread UiThread = new SyncRunOnUiThread(mActivityInstance, new SyncRunOnUiThread.SyncRunOnUiThreadListener()
+        SyncRunOnUiThread uiThread = new SyncRunOnUiThread(mActivityInstance, new SyncRunOnUiThread.SyncRunOnUiThreadListener()
         {
             public void runOnUIThread()
             {
@@ -280,7 +280,7 @@ public class AndroidAdMobBanner
                 mBannerLoaded = false;
             }
         });
-        UiThread.exec();
+        uiThread.exec();
     }
 
     private class BannerListener extends AdListener

QtAndroidTools/src/com/falsinsoft/qtandroidtools/AndroidAdMobInterstitial.java

@@ -46,10 +46,10 @@ public class AndroidAdMobInterstitial
     private InterstitialAd mInterstitialAd = null;
     private boolean mInterstitialAdLoaded = false;
 
-    public AndroidAdMobInterstitial(Activity ActivityInstance)
+    public AndroidAdMobInterstitial(Activity activityInstance)
     {
         mInterstitialListener = new InterstitialListener();
-        mActivityInstance = ActivityInstance;
+        mActivityInstance = activityInstance;
     }
 
     public void setUnitId(final String unitId)
@@ -59,14 +59,14 @@ public class AndroidAdMobInterstitial
             return;
         }
 
-        SyncRunOnUiThread UiThread = new SyncRunOnUiThread(mActivityInstance, new SyncRunOnUiThread.SyncRunOnUiThreadListener()
+        SyncRunOnUiThread uiThread = new SyncRunOnUiThread(mActivityInstance, new SyncRunOnUiThread.SyncRunOnUiThreadListener()
         {
             public void runOnUIThread()
             {
                 mInterstitialAd.setAdUnitId(unitId);
             }
         });
-        UiThread.exec();
+        uiThread.exec();
     }
 
     public void load()
@@ -81,8 +81,8 @@ public class AndroidAdMobInterstitial
             @Override
             public void run()
             {
-                AdRequest.Builder InterstitialRequest = new AdRequest.Builder();
-                mInterstitialAd.loadAd(InterstitialRequest.build());
+                AdRequest.Builder interstitialRequest = new AdRequest.Builder();
+                mInterstitialAd.loadAd(interstitialRequest.build());
                 interstitialEvent(EVENT_LOADING);
                 mInterstitialAdLoaded = false;
             }
@@ -129,7 +129,7 @@ public class AndroidAdMobInterstitial
             return;
         }
 
-        SyncRunOnUiThread UiThread = new SyncRunOnUiThread(mActivityInstance, new SyncRunOnUiThread.SyncRunOnUiThreadListener()
+        SyncRunOnUiThread uiThread = new SyncRunOnUiThread(mActivityInstance, new SyncRunOnUiThread.SyncRunOnUiThreadListener()
         {
             public void runOnUIThread()
             {
@@ -137,7 +137,7 @@ public class AndroidAdMobInterstitial
                 mInterstitialAd.setAdListener(mInterstitialListener);
             }
         });
-        UiThread.exec();
+        uiThread.exec();
     }
 
     private void destroyInterstitial()
@@ -147,7 +147,7 @@ public class AndroidAdMobInterstitial
             return;
         }
 
-        SyncRunOnUiThread UiThread = new SyncRunOnUiThread(mActivityInstance, new SyncRunOnUiThread.SyncRunOnUiThreadListener()
+        SyncRunOnUiThread uiThread = new SyncRunOnUiThread(mActivityInstance, new SyncRunOnUiThread.SyncRunOnUiThreadListener()
         {
             public void runOnUIThread()
             {
@@ -155,7 +155,7 @@ public class AndroidAdMobInterstitial
                 mInterstitialAd = null;
             }
         });
-        UiThread.exec();
+        uiThread.exec();
     }
 
     private class InterstitialListener extends AdListener

QtAndroidTools/src/com/falsinsoft/qtandroidtools/AndroidAdMobRewardedVideo.java

@@ -41,11 +41,11 @@ public class AndroidAdMobRewardedVideo
 
     private RewardedVideoAd mRewardedVideoAd = null;
 
-    public AndroidAdMobRewardedVideo(Activity ActivityInstance)
+    public AndroidAdMobRewardedVideo(Activity activityInstance)
     {
         mRewardedVideoListener = new RewardedVideoListener();
-        MobileAds.initialize(ActivityInstance);
-        mActivityInstance = ActivityInstance;
+        MobileAds.initialize(activityInstance);
+        mActivityInstance = activityInstance;
     }
 
     public void load(String unitId)
@@ -111,7 +111,7 @@ public class AndroidAdMobRewardedVideo
             return;
         }
 
-        SyncRunOnUiThread UiThread = new SyncRunOnUiThread(mActivityInstance, new SyncRunOnUiThread.SyncRunOnUiThreadListener()
+        SyncRunOnUiThread uiThread = new SyncRunOnUiThread(mActivityInstance, new SyncRunOnUiThread.SyncRunOnUiThreadListener()
         {
             public void runOnUIThread()
             {
@@ -119,7 +119,7 @@ public class AndroidAdMobRewardedVideo
                 mRewardedVideoAd.setRewardedVideoAdListener(mRewardedVideoListener);
             }
         });
-        UiThread.exec();
+        uiThread.exec();
     }
 
     private void destroyRewardedVideoAd()
@@ -129,7 +129,7 @@ public class AndroidAdMobRewardedVideo
             return;
         }
 
-        SyncRunOnUiThread UiThread = new SyncRunOnUiThread(mActivityInstance, new SyncRunOnUiThread.SyncRunOnUiThreadListener()
+        SyncRunOnUiThread uiThread = new SyncRunOnUiThread(mActivityInstance, new SyncRunOnUiThread.SyncRunOnUiThreadListener()
         {
             public void runOnUIThread()
             {
@@ -137,7 +137,7 @@ public class AndroidAdMobRewardedVideo
                 mRewardedVideoAd = null;
             }
         });
-        UiThread.exec();
+        uiThread.exec();
     }
 
     private class RewardedVideoListener implements RewardedVideoAdListener

QtAndroidTools/src/com/falsinsoft/qtandroidtools/AndroidApkExpansionFiles.java

@@ -50,24 +50,24 @@ public class AndroidApkExpansionFiles
     private final DownloaderProxy mDownloaderProxy;
     private final Activity mActivityInstance;
 
-    public AndroidApkExpansionFiles(Activity ActivityInstance)
+    public AndroidApkExpansionFiles(Activity activityInstance)
     {
-        NOTIFICATION_CHANNEL_ID = ActivityInstance.getClass().getName();
+        NOTIFICATION_CHANNEL_ID = activityInstance.getClass().getName();
         mDownloaderClient = new DownloaderClient();
-        mDownloaderProxy = new DownloaderProxy(ActivityInstance);
-        mActivityInstance = ActivityInstance;
+        mDownloaderProxy = new DownloaderProxy(activityInstance);
+        mActivityInstance = activityInstance;
     }
 
-    public boolean isAPKFileDelivered(boolean IsMain, int FileVersion, int FileSize)
+    public boolean isAPKFileDelivered(boolean isMain, int fileVersion, int fileSize)
     {
-        final String FileName = Helpers.getExpansionAPKFileName(mActivityInstance, IsMain, FileVersion);
-        return Helpers.doesFileExist(mActivityInstance, FileName, FileSize, false);
+        final String fileName = Helpers.getExpansionAPKFileName(mActivityInstance, isMain, fileVersion);
+        return Helpers.doesFileExist(mActivityInstance, fileName, fileSize, false);
     }
 
-    public String getExpansionAPKFileName(boolean IsMain, int FileVersion)
+    public String getExpansionAPKFileName(boolean isMain, int fileVersion)
     {
-        final String FileName = Helpers.getExpansionAPKFileName(mActivityInstance, IsMain, FileVersion);
-        return Helpers.generateSaveFileName(mActivityInstance, FileName);
+        final String fileName = Helpers.getExpansionAPKFileName(mActivityInstance, isMain, fileVersion);
+        return Helpers.generateSaveFileName(mActivityInstance, fileName);
     }
 
     public void sendRequest(int requestID)
@@ -100,15 +100,15 @@ public class AndroidApkExpansionFiles
             case APP_STATE_CREATE:
                 if(Build.VERSION.SDK_INT >= Build.VERSION_CODES.O)
                 {
-                    NotificationManager Manager = mActivityInstance.getSystemService(NotificationManager.class);
-                    NotificationChannel Channel;
+                    NotificationManager manager = mActivityInstance.getSystemService(NotificationManager.class);
+                    NotificationChannel channel;
 
-                    Channel = new NotificationChannel(NOTIFICATION_CHANNEL_ID,
+                    channel = new NotificationChannel(NOTIFICATION_CHANNEL_ID,
                                                       getString(STRING_NOTIFICATION_CHANNEL_NAME),
                                                       NotificationManager.IMPORTANCE_DEFAULT
                                                       );
 
-                    Manager.createNotificationChannel(Channel);
+                    manager.createNotificationChannel(channel);
                 }
                 mDownloaderClient.register(mActivityInstance);
                 break;
@@ -122,8 +122,8 @@ public class AndroidApkExpansionFiles
             /*
                 if(Build.VERSION.SDK_INT >= Build.VERSION_CODES.O)
                 {
-                    NotificationManager Manager = mActivityInstance.getSystemService(NotificationManager.class);
-                    Manager.deleteNotificationChannel(NOTIFICATION_CHANNEL_ID);
+                    NotificationManager manager = mActivityInstance.getSystemService(NotificationManager.class);
+                    manager.deleteNotificationChannel(NOTIFICATION_CHANNEL_ID);
                 }
             */
                 mDownloaderClient.unregister(mActivityInstance);
@@ -133,25 +133,25 @@ public class AndroidApkExpansionFiles
 
     public int startDownloader(String BASE64_PUBLIC_KEY, byte[] SALT)
     {
-        int DownloadResult = -1;
+        int downloadResult = -1;
 
         try
         {
-            Intent IntentToLaunchThisActivityFromNotification;
-            PendingIntent PendingActivity;
+            Intent intentToLaunchThisActivityFromNotification;
+            PendingIntent pendingActivity;
 
-            IntentToLaunchThisActivityFromNotification = new Intent(mActivityInstance, mActivityInstance.getClass());
-            IntentToLaunchThisActivityFromNotification.setFlags(Intent.FLAG_ACTIVITY_NEW_TASK | Intent.FLAG_ACTIVITY_CLEAR_TOP);
+            intentToLaunchThisActivityFromNotification = new Intent(mActivityInstance, mActivityInstance.getClass());
+            intentToLaunchThisActivityFromNotification.setFlags(Intent.FLAG_ACTIVITY_NEW_TASK | Intent.FLAG_ACTIVITY_CLEAR_TOP);
 
-            PendingActivity = PendingIntent.getActivity(mActivityInstance,
+            pendingActivity = PendingIntent.getActivity(mActivityInstance,
                                                         0,
-                                                        IntentToLaunchThisActivityFromNotification,
+                                                        intentToLaunchThisActivityFromNotification,
                                                         PendingIntent.FLAG_UPDATE_CURRENT
                                                         );
 
-            DownloadResult = DownloaderService.startDownloadServiceIfRequired(mActivityInstance,
+            downloadResult = DownloaderService.startDownloadServiceIfRequired(mActivityInstance,
                                                                               NOTIFICATION_CHANNEL_ID,
-                                                                              PendingActivity,
+                                                                              pendingActivity,
                                                                               SALT,
                                                                               BASE64_PUBLIC_KEY
                                                                               );
@@ -161,7 +161,7 @@ public class AndroidApkExpansionFiles
             e.printStackTrace();
         }
 
-        return DownloadResult;
+        return downloadResult;
     }
 
     private class DownloaderClient extends BroadcastDownloaderClient

QtAndroidTools/src/com/falsinsoft/qtandroidtools/AndroidBatteryState.java

@@ -41,11 +41,11 @@ public class AndroidBatteryState
     private int mLevel = 0;
     private boolean mOnCharge = false;
 
-    public AndroidBatteryState(Activity ActivityInstance)
+    public AndroidBatteryState(Activity activityInstance)
     {
         mBatteryStateChangeReceiver = new BatteryStateChangeReceiver();
         mBatteryStateFilter = new IntentFilter(Intent.ACTION_BATTERY_CHANGED);
-        mActivityInstance = ActivityInstance;
+        mActivityInstance = activityInstance;
     }
 
     public int getLevel()
@@ -88,22 +88,22 @@ public class AndroidBatteryState
         @Override
         public void onReceive(Context context, Intent intent)
         {
-            final boolean CurrentOnCharge = (intent.getIntExtra(BatteryManager.EXTRA_PLUGGED, -1) == 0) ? false : true;
-            final int Level = intent.getIntExtra(BatteryManager.EXTRA_LEVEL, -1);
-            final int Scale = intent.getIntExtra(BatteryManager.EXTRA_SCALE, -1);
+            final boolean currentOnCharge = (intent.getIntExtra(BatteryManager.EXTRA_PLUGGED, -1) == 0) ? false : true;
+            final int level = intent.getIntExtra(BatteryManager.EXTRA_LEVEL, -1);
+            final int scale = intent.getIntExtra(BatteryManager.EXTRA_SCALE, -1);
 
-            if(Level >= 0 && Scale > 0)
+            if(level >= 0 && scale > 0)
             {
-                final int CurrentLevel = ((Level * 100) / Scale);
-                if(CurrentLevel != mLevel)
+                final int currentLevel = ((level * 100) / scale);
+                if(currentLevel != mLevel)
                 {
-                    mLevel = CurrentLevel;
+                    mLevel = currentLevel;
                     batteryLevelChanged();
                 }
             }
-            if(CurrentOnCharge != mOnCharge)
+            if(currentOnCharge != mOnCharge)
             {
-                mOnCharge = CurrentOnCharge;
+                mOnCharge = currentOnCharge;
                 batteryOnChargeChanged();
             }
         }

QtAndroidTools/src/com/falsinsoft/qtandroidtools/AndroidGoogleAccount.java

@@ -57,65 +57,65 @@ public class AndroidGoogleAccount
     private final Activity mActivityInstance;
     private GoogleSignInClient mGoogleSignInClient = null;
 
-    public AndroidGoogleAccount(Activity ActivityInstance)
+    public AndroidGoogleAccount(Activity activityInstance)
     {
-        mActivityInstance = ActivityInstance;
+        mActivityInstance = activityInstance;
     }
 
-    private GoogleSignInClient getSignInClient(String ScopeName)
+    private GoogleSignInClient getSignInClient(String scopeName)
     {
-        GoogleSignInOptions.Builder SignInOptions = new GoogleSignInOptions.Builder(GoogleSignInOptions.DEFAULT_SIGN_IN);
-        if(ScopeName.isEmpty() == false) SignInOptions.requestScopes(new Scope(ScopeName));
-        SignInOptions.requestEmail();
+        GoogleSignInOptions.Builder signInOptions = new GoogleSignInOptions.Builder(GoogleSignInOptions.DEFAULT_SIGN_IN);
+        if(scopeName.isEmpty() == false) signInOptions.requestScopes(new Scope(scopeName));
+        signInOptions.requestEmail();
 
-        return GoogleSignIn.getClient(mActivityInstance, SignInOptions.build());
+        return GoogleSignIn.getClient(mActivityInstance, signInOptions.build());
     }
 
-    public Intent getSignInIntent(String ScopeName)
+    public Intent getSignInIntent(String scopeName)
     {
-        Intent SignInIntent = null;
+        Intent signInIntent = null;
 
         if(mGoogleSignInClient == null)
         {
-            mGoogleSignInClient = getSignInClient(ScopeName);
-            SignInIntent = mGoogleSignInClient.getSignInIntent();
+            mGoogleSignInClient = getSignInClient(scopeName);
+            signInIntent = mGoogleSignInClient.getSignInIntent();
         }
 
-        return SignInIntent;
+        return signInIntent;
     }
 
-    public void signInIntentDataResult(Intent Data)
+    public void signInIntentDataResult(Intent data)
     {
-        final Task<GoogleSignInAccount> SignInTask = GoogleSignIn.getSignedInAccountFromIntent(Data);
+        final Task<GoogleSignInAccount> signInTask = GoogleSignIn.getSignedInAccountFromIntent(data);
 
-        if(SignInTask.isSuccessful())
+        if(signInTask.isSuccessful())
         {
-            loadSignedInAccountInfo(SignInTask.getResult());
+            loadSignedInAccountInfo(signInTask.getResult());
             signedIn(true);
         }
         else
         {
-            SignInTask.addOnCompleteListener(mActivityInstance, new SignInAccountListener());
+            signInTask.addOnCompleteListener(mActivityInstance, new SignInAccountListener());
         }
     }
 
-    public boolean signIn(String ScopeName)
+    public boolean signIn(String scopeName)
     {
         if(mGoogleSignInClient == null)
         {
-            Task<GoogleSignInAccount> SignInTask;
+            Task<GoogleSignInAccount> signInTask;
 
-            mGoogleSignInClient = getSignInClient(ScopeName);
+            mGoogleSignInClient = getSignInClient(scopeName);
 
-            SignInTask = mGoogleSignInClient.silentSignIn();
-            if(SignInTask.isSuccessful())
+            signInTask = mGoogleSignInClient.silentSignIn();
+            if(signInTask.isSuccessful())
             {
-                loadSignedInAccountInfo(SignInTask.getResult());
+                loadSignedInAccountInfo(signInTask.getResult());
                 signedIn(true);
             }
             else
             {
-                SignInTask.addOnCompleteListener(mActivityInstance, new SignInAccountListener());
+                signInTask.addOnCompleteListener(mActivityInstance, new SignInAccountListener());
             }
 
             return true;
@@ -128,9 +128,9 @@ public class AndroidGoogleAccount
     {
         if(mGoogleSignInClient != null)
         {
-            final Task<Void> SignOutTask = mGoogleSignInClient.signOut();
+            final Task<Void> signOutTask = mGoogleSignInClient.signOut();
 
-            if(SignOutTask.isSuccessful())
+            if(signOutTask.isSuccessful())
             {
                 updateSignedInAccountInfo(null);
                 mGoogleSignInClient = null;
@@ -138,7 +138,7 @@ public class AndroidGoogleAccount
             }
             else
             {
-                SignOutTask.addOnCompleteListener(mActivityInstance, new SignOutAccountListener());
+                signOutTask.addOnCompleteListener(mActivityInstance, new SignOutAccountListener());
             }
 
             return true;
@@ -151,9 +151,9 @@ public class AndroidGoogleAccount
     {
         if(mGoogleSignInClient != null)
         {
-            final Task<Void> SignOutTask = mGoogleSignInClient.revokeAccess();
+            final Task<Void> signOutTask = mGoogleSignInClient.revokeAccess();
 
-            if(SignOutTask.isSuccessful())
+            if(signOutTask.isSuccessful())
             {
                 updateSignedInAccountInfo(null);
                 mGoogleSignInClient = null;
@@ -161,7 +161,7 @@ public class AndroidGoogleAccount
             }
             else
             {
-                SignOutTask.addOnCompleteListener(mActivityInstance, new SignOutAccountListener());
+                signOutTask.addOnCompleteListener(mActivityInstance, new SignOutAccountListener());
             }
 
             return true;
@@ -170,28 +170,28 @@ public class AndroidGoogleAccount
         return false;
     }
 
-    private boolean loadSignedInAccountInfo(final GoogleSignInAccount SignedInAccount)
+    private boolean loadSignedInAccountInfo(final GoogleSignInAccount signedInAccount)
     {
-        if(SignedInAccount != null)
+        if(signedInAccount != null)
         {
-            AccountInfo SignedInAccountInfo = new AccountInfo();
-            final Uri PhotoUrl = SignedInAccount.getPhotoUrl();
+            AccountInfo signedInAccountInfo = new AccountInfo();
+            final Uri photoUrl = signedInAccount.getPhotoUrl();
 
-            SignedInAccountInfo.id = SignedInAccount.getId();
-            SignedInAccountInfo.displayName = SignedInAccount.getDisplayName();
-            SignedInAccountInfo.email = SignedInAccount.getEmail();
-            SignedInAccountInfo.familyName = SignedInAccount.getFamilyName();
-            SignedInAccountInfo.givenName = SignedInAccount.getGivenName();
+            signedInAccountInfo.id = signedInAccount.getId();
+            signedInAccountInfo.displayName = signedInAccount.getDisplayName();
+            signedInAccountInfo.email = signedInAccount.getEmail();
+            signedInAccountInfo.familyName = signedInAccount.getFamilyName();
+            signedInAccountInfo.givenName = signedInAccount.getGivenName();
 
-            if(PhotoUrl != null)
+            if(photoUrl != null)
             {
-                DownloadAccountPhotoTask DownloadAccountPhoto = new DownloadAccountPhotoTask(SignedInAccountInfo);
-                DownloadAccountPhoto.execute(PhotoUrl.toString());
+                DownloadAccountPhotoTask downloadAccountPhoto = new DownloadAccountPhotoTask(signedInAccountInfo);
+                downloadAccountPhoto.execute(photoUrl.toString());
             }
             else
             {
-                SignedInAccountInfo.photo = null;
-                updateSignedInAccountInfo(SignedInAccountInfo);
+                signedInAccountInfo.photo = null;
+                updateSignedInAccountInfo(signedInAccountInfo);
             }
 
             return true;
@@ -204,31 +204,31 @@ public class AndroidGoogleAccount
     {
         private AccountInfo mSignedInAccountInfo;
 
-        DownloadAccountPhotoTask(AccountInfo SignedInAccountInfo)
+        DownloadAccountPhotoTask(AccountInfo signedInAccountInfo)
         {
-            mSignedInAccountInfo = SignedInAccountInfo;
+            mSignedInAccountInfo = signedInAccountInfo;
         }
 
         protected Bitmap doInBackground(String... urls)
         {
-            final String PhotoUrl = urls[0];
-            Bitmap AccountPhoto = null;
+            final String photoUrl = urls[0];
+            Bitmap accountPhoto = null;
 
             try
             {
-                InputStream PhotoStream = new java.net.URL(PhotoUrl).openStream();
-                AccountPhoto = BitmapFactory.decodeStream(PhotoStream);
+                InputStream photoStream = new java.net.URL(photoUrl).openStream();
+                accountPhoto = BitmapFactory.decodeStream(photoStream);
             }
             catch(Exception e)
             {
             }
 
-            return AccountPhoto;
+            return accountPhoto;
         }
 
-        protected void onPostExecute(Bitmap AccountPhoto)
+        protected void onPostExecute(Bitmap accountPhoto)
         {
-            mSignedInAccountInfo.photo = AccountPhoto;
+            mSignedInAccountInfo.photo = accountPhoto;
             updateSignedInAccountInfo(mSignedInAccountInfo);
         }
     }
@@ -236,13 +236,13 @@ public class AndroidGoogleAccount
     private class SignInAccountListener implements OnCompleteListener<GoogleSignInAccount>
     {
         @Override
-        public void onComplete(@NonNull Task<GoogleSignInAccount> SignInTask)
+        public void onComplete(@NonNull Task<GoogleSignInAccount> signInTask)
         {
             boolean signInSuccessfully = true;
 
             try
             {
-                loadSignedInAccountInfo(SignInTask.getResult(ApiException.class));
+                loadSignedInAccountInfo(signInTask.getResult(ApiException.class));
             }
             catch(ApiException e)
             {
@@ -266,7 +266,7 @@ public class AndroidGoogleAccount
     private class SignOutAccountListener implements OnCompleteListener<Void>
     {
         @Override
-        public void onComplete(@NonNull Task<Void> SignOutTask)
+        public void onComplete(@NonNull Task<Void> signOutTask)
         {
             updateSignedInAccountInfo(null);
             mGoogleSignInClient = null;

QtAndroidTools/src/com/falsinsoft/qtandroidtools/AndroidGoogleDrive.java

@@ -66,26 +66,26 @@ public class AndroidGoogleDrive
     private final Activity mActivityInstance;
     private Drive mDriveService = null;
 
-    public AndroidGoogleDrive(Activity ActivityInstance)
+    public AndroidGoogleDrive(Activity activityInstance)
     {
-        mActivityInstance = ActivityInstance;
+        mActivityInstance = activityInstance;
     }
 
-    public boolean authenticate(String AppName, String ScopeName)
+    public boolean authenticate(String appName, String scopeName)
     {
-        final GoogleSignInAccount SignInAccount = GoogleSignIn.getLastSignedInAccount(mActivityInstance);
+        final GoogleSignInAccount signInAccount = GoogleSignIn.getLastSignedInAccount(mActivityInstance);
 
-        if(SignInAccount != null)
+        if(signInAccount != null)
         {
-            GoogleAccountCredential AccountCredential;
-            Drive.Builder DriveBuilder;
+            GoogleAccountCredential accountCredential;
+            Drive.Builder driveBuilder;
 
-            AccountCredential = GoogleAccountCredential.usingOAuth2(mActivityInstance, Collections.singleton(ScopeName));
-            AccountCredential.setSelectedAccount(SignInAccount.getAccount());
+            accountCredential = GoogleAccountCredential.usingOAuth2(mActivityInstance, Collections.singleton(scopeName));
+            accountCredential.setSelectedAccount(signInAccount.getAccount());
 
-            DriveBuilder = new Drive.Builder(AndroidHttp.newCompatibleTransport(), new GsonFactory(), AccountCredential);
-            DriveBuilder.setApplicationName(AppName);
-            mDriveService = DriveBuilder.build();
+            driveBuilder = new Drive.Builder(AndroidHttp.newCompatibleTransport(), new GsonFactory(), accountCredential);
+            driveBuilder.setApplicationName(appName);
+            mDriveService = driveBuilder.build();
 
             return true;
         }
@@ -103,12 +103,12 @@ public class AndroidGoogleDrive
     {
         if(mDriveService != null)
         {
-            DriveFile[] DriveFileList;
-            File[] FileList;
+            DriveFile[] driveFileList;
+            File[] fileList;
 
             try
             {
-                FileList = mDriveService.files()
+                fileList = mDriveService.files()
                                         .list()
                                         .setQ(Query)
                                         .setSpaces("drive")
@@ -128,21 +128,21 @@ public class AndroidGoogleDrive
                 return null;
             }
 
-            DriveFileList = new DriveFile[FileList.length];
-            for(int i = 0; i < FileList.length; i++)
+            driveFileList = new DriveFile[fileList.length];
+            for(int i = 0; i < fileList.length; i++)
             {
-                DriveFile FileData = new DriveFile();
-                final File FileInfo = FileList[i];
+                DriveFile fileData = new DriveFile();
+                final File fileInfo = fileList[i];
 
-                FileData.id = FileInfo.getId();
-                FileData.name = FileInfo.getName();
-                FileData.mimeType = FileInfo.getMimeType();
-                FileData.parents = (FileInfo.getParents() != null) ? FileInfo.getParents().toArray(new String[0]) : null;
+                fileData.id = fileInfo.getId();
+                fileData.name = fileInfo.getName();
+                fileData.mimeType = fileInfo.getMimeType();
+                fileData.parents = (fileInfo.getParents() != null) ? fileInfo.getParents().toArray(new String[0]) : null;
 
-                DriveFileList[i] = FileData;
+                driveFileList[i] = fileData;
             }
 
-            return DriveFileList;
+            return driveFileList;
         }
 
         return null;
@@ -152,11 +152,11 @@ public class AndroidGoogleDrive
     {
         if(mDriveService != null)
         {
-            File FileInfo;
+            File fileInfo;
 
             try
             {
-                FileInfo = mDriveService.files()
+                fileInfo = mDriveService.files()
                                         .get("root")
                                         .execute();
             }
@@ -166,27 +166,27 @@ public class AndroidGoogleDrive
                 return null;
             }
 
-            return FileInfo.getId();
+            return fileInfo.getId();
         }
 
         return null;
     }
 
-    public String createFolder(String Name, String ParentFolderId)
+    public String createFolder(String name, String parentFolderId)
     {
         if(mDriveService != null)
         {
-            File FolderMetadata = new File();
-            File FolderData;
+            File folderMetadata = new File();
+            File folderData;
 
-            FolderMetadata.setName(Name);
-            FolderMetadata.setMimeType("application/vnd.google-apps.folder");
-            if(!ParentFolderId.isEmpty()) FolderMetadata.setParents(Collections.singletonList(ParentFolderId));
+            folderMetadata.setName(name);
+            folderMetadata.setMimeType("application/vnd.google-apps.folder");
+            if(!parentFolderId.isEmpty()) folderMetadata.setParents(Collections.singletonList(parentFolderId));
 
             try
             {
-                FolderData = mDriveService.files()
-                                          .create(FolderMetadata)
+                folderData = mDriveService.files()
+                                          .create(folderMetadata)
                                           .setFields("id")
                                           .execute();
             }
@@ -196,23 +196,23 @@ public class AndroidGoogleDrive
                 return null;
             }
 
-            return FolderData.getId();
+            return folderData.getId();
         }
 
         return null;
     }
 
-    public File getFileMetadata(String FileId, String Fields)
+    public File getFileMetadata(String fileId, String fields)
     {
         if(mDriveService != null)
         {
-            File FileInfo;
+            File fileInfo;
 
             try
             {
-                FileInfo = mDriveService.files()
-                                        .get(FileId)
-                                        .setFields(Fields)
+                fileInfo = mDriveService.files()
+                                        .get(fileId)
+                                        .setFields(fields)
                                         .execute();
             }
             catch(IOException e)
@@ -221,23 +221,23 @@ public class AndroidGoogleDrive
                 return null;
             }
 
-            return FileInfo;
+            return fileInfo;
         }
 
         return null;
     }
 
-    public boolean moveFile(String FileId, String FolderId)
+    public boolean moveFile(String fileId, String folderId)
     {
         if(mDriveService != null)
         {
-            StringBuilder PreviousParents = new StringBuilder();
-            File ParentData, FileData;
+            StringBuilder previousParents = new StringBuilder();
+            File parentData, fileData;
 
             try
             {
-                ParentData = mDriveService.files()
-                                          .get(FileId)
+                parentData = mDriveService.files()
+                                          .get(fileId)
                                           .setFields("parents")
                                           .execute();
             }
@@ -247,18 +247,18 @@ public class AndroidGoogleDrive
                 return false;
             }
 
-            for(String ParentId : ParentData.getParents())
+            for(String parentId : parentData.getParents())
             {
-                PreviousParents.append(ParentId);
-                PreviousParents.append(',');
+                previousParents.append(parentId);
+                previousParents.append(',');
             }
 
             try
             {
-                FileData = mDriveService.files()
-                                        .update(FileId, null)
-                                        .setAddParents(FolderId)
-                                        .setRemoveParents(PreviousParents.toString())
+                fileData = mDriveService.files()
+                                        .update(fileId, null)
+                                        .setAddParents(folderId)
+                                        .setRemoveParents(previousParents.toString())
                                         .setFields("id, parents")
                                         .execute();
             }
@@ -274,14 +274,14 @@ public class AndroidGoogleDrive
         return false;
     }
 
-    public boolean deleteFile(String FileId)
+    public boolean deleteFile(String fileId)
     {
         if(mDriveService != null)
         {
             try
             {
                 mDriveService.files()
-                             .delete(FileId)
+                             .delete(fileId)
                              .execute();
             }
             catch(IOException e)
@@ -296,15 +296,15 @@ public class AndroidGoogleDrive
         return false;
     }
 
-    public boolean downloadFile(String FileId, String LocalFilePath)
+    public boolean downloadFile(String fileId, String localFilePath)
     {
         if(mDriveService != null)
         {
             try
             {
-                Drive.Files.Get FileDownloadRequest = mDriveService.files().get(FileId);
-                FileDownloadRequest.getMediaHttpDownloader().setProgressListener(new FileDownloadProgressListener());
-                FileDownloadRequest.executeMediaAndDownloadTo(new FileOutputStream(LocalFilePath));
+                Drive.Files.Get fileDownloadRequest = mDriveService.files().get(fileId);
+                fileDownloadRequest.getMediaHttpDownloader().setProgressListener(new FileDownloadProgressListener());
+                fileDownloadRequest.executeMediaAndDownloadTo(new FileOutputStream(localFilePath));
             }
             catch(IOException e)
             {
@@ -318,22 +318,22 @@ public class AndroidGoogleDrive
         return false;
     }
 
-    public String uploadFile(String LocalFilePath, String Name, String MimeType, String ParentFolderId)
+    public String uploadFile(String localFilePath, String name, String mimeType, String parentFolderId)
     {
         if(mDriveService != null)
         {
-            java.io.File MediaFile = new java.io.File(LocalFilePath);
-            File FileMetadata = new File();
-            File UploadedFileData;
+            java.io.File mediaFile = new java.io.File(localFilePath);
+            File fileMetadata = new File();
+            File uploadedFileData;
 
-            FileMetadata.setName(Name);
-            if(!ParentFolderId.isEmpty()) FileMetadata.setParents(Collections.singletonList(ParentFolderId));
+            fileMetadata.setName(name);
+            if(!parentFolderId.isEmpty()) fileMetadata.setParents(Collections.singletonList(parentFolderId));
 
             try
             {
-                Drive.Files.Create FileUploadRequest = mDriveService.files().create(FileMetadata, new FileContent(MimeType, MediaFile));
-                FileUploadRequest.getMediaHttpUploader().setProgressListener(new FileUploadProgressListener());
-                UploadedFileData = FileUploadRequest.setFields("id").execute();
+                Drive.Files.Create fileUploadRequest = mDriveService.files().create(fileMetadata, new FileContent(mimeType, mediaFile));
+                fileUploadRequest.getMediaHttpUploader().setProgressListener(new FileUploadProgressListener());
+                uploadedFileData = fileUploadRequest.setFields("id").execute();
             }
             catch(FileNotFoundException e)
             {
@@ -346,7 +346,7 @@ public class AndroidGoogleDrive
                 return null;
             }
 
-            return UploadedFileData.getId();
+            return uploadedFileData.getId();
         }
 
         return null;

QtAndroidTools/src/com/falsinsoft/qtandroidtools/AndroidImages.java

@@ -37,18 +37,18 @@ public class AndroidImages
 {
     private final Activity mActivityInstance;
 
-    public AndroidImages(Activity ActivityInstance)
+    public AndroidImages(Activity activityInstance)
     {
-        mActivityInstance = ActivityInstance;
+        mActivityInstance = activityInstance;
     }
 
     public AlbumInfo[] getAlbumsList()
     {
-        final ContentResolver Resolver = mActivityInstance.getContentResolver();
-        AlbumInfo[] AlbumsList = null;
+        final ContentResolver resolver = mActivityInstance.getContentResolver();
+        AlbumInfo[] albumsList = null;
         Cursor cur;
 
-        cur = Resolver.query(MediaStore.Files.getContentUri("external"),
+        cur = resolver.query(MediaStore.Files.getContentUri("external"),
                              new String[]{ MediaStore.Files.FileColumns.PARENT, MediaStore.Images.Media.BUCKET_DISPLAY_NAME },
                              MediaStore.Files.FileColumns.MEDIA_TYPE + "=? ) GROUP BY ( " + MediaStore.Files.FileColumns.PARENT + " ",
                              new String[] { String.valueOf(MediaStore.Files.FileColumns.MEDIA_TYPE_IMAGE) },
@@ -58,17 +58,17 @@ public class AndroidImages
         {
             if(cur.moveToFirst())
             {
-                final int IdColumnIdx = cur.getColumnIndex(MediaStore.Files.FileColumns.PARENT);
-                final int NameColumnIdx = cur.getColumnIndex(MediaStore.Images.Media.BUCKET_DISPLAY_NAME);
-                AlbumsList = new AlbumInfo[cur.getCount()];
+                final int idColumnIdx = cur.getColumnIndex(MediaStore.Files.FileColumns.PARENT);
+                final int nameColumnIdx = cur.getColumnIndex(MediaStore.Images.Media.BUCKET_DISPLAY_NAME);
+                albumsList = new AlbumInfo[cur.getCount()];
 
-                for(int i = 0; i < AlbumsList.length; i++)
+                for(int i = 0; i < albumsList.length; i++)
                 {
-                    AlbumInfo Album = new AlbumInfo();
+                    AlbumInfo album = new AlbumInfo();
 
-                    Album.id = cur.getInt(IdColumnIdx);
-                    Album.name = cur.getString(NameColumnIdx);
-                    AlbumsList[i] = Album;
+                    album.id = cur.getInt(idColumnIdx);
+                    album.name = cur.getString(nameColumnIdx);
+                    albumsList[i] = album;
 
                     cur.moveToNext();
                 }
@@ -76,16 +76,16 @@ public class AndroidImages
             cur.close();
         }
 
-        return AlbumsList;
+        return albumsList;
     }
 
     public String[] getAlbumImagesList(int albumId)
     {
-        final ContentResolver Resolver = mActivityInstance.getContentResolver();
-        String[] ImagesList = null;
+        final ContentResolver resolver = mActivityInstance.getContentResolver();
+        String[] imagesList = null;
         Cursor cur;
 
-        cur = Resolver.query(MediaStore.Files.getContentUri("external"),
+        cur = resolver.query(MediaStore.Files.getContentUri("external"),
                              new String[]{ MediaStore.Images.Media.DATA },
                              MediaStore.Files.FileColumns.MEDIA_TYPE + "=? and " + MediaStore.Files.FileColumns.PARENT + "=?",
                              new String[] { String.valueOf(MediaStore.Files.FileColumns.MEDIA_TYPE_IMAGE), String.valueOf(albumId) },
@@ -95,19 +95,19 @@ public class AndroidImages
         {
             if(cur.moveToFirst())
             {
-                final int NameColumnIdx = cur.getColumnIndex(MediaStore.Images.Media.DATA);
-                ImagesList = new String[cur.getCount()];
+                final int nameColumnIdx = cur.getColumnIndex(MediaStore.Images.Media.DATA);
+                imagesList = new String[cur.getCount()];
 
-                for(int i = 0; i < ImagesList.length; i++)
+                for(int i = 0; i < imagesList.length; i++)
                 {
-                    ImagesList[i] = cur.getString(NameColumnIdx);
+                    imagesList[i] = cur.getString(nameColumnIdx);
                     cur.moveToNext();
                 }
             }
             cur.close();
         }
 
-        return ImagesList;
+        return imagesList;
     }
 
     public static class AlbumInfo

QtAndroidTools/src/com/falsinsoft/qtandroidtools/AndroidNotification.java

@@ -43,12 +43,12 @@ public class AndroidNotification
     private final Activity mActivityInstance;
     private final int mNotificationId;
 
-    public AndroidNotification(Activity ActivityInstance, int InstanceId)
+    public AndroidNotification(Activity activityInstance, int instanceId)
     {
-        NOTIFICATION_CHANNEL_ID = (ActivityInstance.getClass().getName() + Integer.toString(InstanceId));
-        mAppNotification = new NotificationCompat.Builder(ActivityInstance, NOTIFICATION_CHANNEL_ID);
-        mActivityInstance = ActivityInstance;
-        mNotificationId = (InstanceId + 1);
+        NOTIFICATION_CHANNEL_ID = (activityInstance.getClass().getName() + Integer.toString(instanceId));
+        mAppNotification = new NotificationCompat.Builder(activityInstance, NOTIFICATION_CHANNEL_ID);
+        mActivityInstance = activityInstance;
+        mNotificationId = (instanceId + 1);
         configure();
     }
 
@@ -66,15 +66,15 @@ public class AndroidNotification
 
     public void show()
     {
-        NotificationManagerCompat Manager = NotificationManagerCompat.from(mActivityInstance);
+        NotificationManagerCompat manager = NotificationManagerCompat.from(mActivityInstance);
         mAppNotification.setPriority(NotificationCompat.PRIORITY_DEFAULT);
-        Manager.notify(mNotificationId, mAppNotification.build());
+        manager.notify(mNotificationId, mAppNotification.build());
     }
 
     public void cancel()
     {
-        NotificationManagerCompat Manager = NotificationManagerCompat.from(mActivityInstance);
-        Manager.cancel(mNotificationId);
+        NotificationManagerCompat manager = NotificationManagerCompat.from(mActivityInstance);
+        manager.cancel(mNotificationId);
     }
 
     public void setTitle(String title)
@@ -111,15 +111,15 @@ public class AndroidNotification
     {
         if(Build.VERSION.SDK_INT >= Build.VERSION_CODES.O)
         {
-            NotificationManager Manager = mActivityInstance.getSystemService(NotificationManager.class);
-            NotificationChannel Channel;
+            NotificationManager manager = mActivityInstance.getSystemService(NotificationManager.class);
+            NotificationChannel channel;
 
-            Channel = new NotificationChannel(NOTIFICATION_CHANNEL_ID,
+            channel = new NotificationChannel(NOTIFICATION_CHANNEL_ID,
                                               channelName,
                                               NotificationManager.IMPORTANCE_DEFAULT
                                               );
 
-            Manager.createNotificationChannel(Channel);
+            manager.createNotificationChannel(channel);
         }
     }
 
@@ -127,8 +127,8 @@ public class AndroidNotification
     {
         if(Build.VERSION.SDK_INT >= Build.VERSION_CODES.O)
         {
-            NotificationManager Manager = mActivityInstance.getSystemService(NotificationManager.class);
-            Manager.deleteNotificationChannel(NOTIFICATION_CHANNEL_ID);
+            NotificationManager manager = mActivityInstance.getSystemService(NotificationManager.class);
+            manager.deleteNotificationChannel(NOTIFICATION_CHANNEL_ID);
         }
     }
 }

QtAndroidTools/src/com/falsinsoft/qtandroidtools/AndroidPlayStore.java

@@ -38,35 +38,35 @@ public class AndroidPlayStore
 {
     private final Activity mActivityInstance;
 
-    public AndroidPlayStore(Activity ActivityInstance)
+    public AndroidPlayStore(Activity activityInstance)
     {
-        mActivityInstance = ActivityInstance;
+        mActivityInstance = activityInstance;
     }
 
     public void open(String params)
     {
-        Intent PlayStoreIntent = new Intent(Intent.ACTION_VIEW, Uri.parse("market://" + params));
-        final List<ResolveInfo> AppInfoList = mActivityInstance.getPackageManager().queryIntentActivities(PlayStoreIntent, 0);
-        boolean PlayStoreFound = false;
+        Intent playStoreIntent = new Intent(Intent.ACTION_VIEW, Uri.parse("market://" + params));
+        final List<ResolveInfo> appInfoList = mActivityInstance.getPackageManager().queryIntentActivities(playStoreIntent, 0);
+        boolean playStoreFound = false;
 
-        for(ResolveInfo AppInfo: AppInfoList)
+        for(ResolveInfo appInfo : appInfoList)
         {
-            if(AppInfo.activityInfo.applicationInfo.packageName.equals("com.android.vending"))
+            if(appInfo.activityInfo.applicationInfo.packageName.equals("com.android.vending"))
             {
-                PlayStoreFound = true;
+                playStoreFound = true;
 
-                PlayStoreIntent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK | Intent.FLAG_ACTIVITY_RESET_TASK_IF_NEEDED | Intent.FLAG_ACTIVITY_CLEAR_TOP);
-                PlayStoreIntent.setComponent(new ComponentName(AppInfo.activityInfo.applicationInfo.packageName, AppInfo.activityInfo.name));
+                playStoreIntent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK | Intent.FLAG_ACTIVITY_RESET_TASK_IF_NEEDED | Intent.FLAG_ACTIVITY_CLEAR_TOP);
+                playStoreIntent.setComponent(new ComponentName(appInfo.activityInfo.applicationInfo.packageName, appInfo.activityInfo.name));
 
-                mActivityInstance.startActivity(PlayStoreIntent);
+                mActivityInstance.startActivity(playStoreIntent);
                 break;
             }
         }
 
-        if(PlayStoreFound == false)
+        if(playStoreFound == false)
         {
-            Intent WebPlayStoreIntent = new Intent(Intent.ACTION_VIEW, Uri.parse("https://play.google.com/store/apps/" + params));
-            mActivityInstance.startActivity(WebPlayStoreIntent);
+            Intent webPlayStoreIntent = new Intent(Intent.ACTION_VIEW, Uri.parse("https://play.google.com/store/apps/" + params));
+            mActivityInstance.startActivity(webPlayStoreIntent);
         }
     }
 }

QtAndroidTools/src/com/falsinsoft/qtandroidtools/AndroidSharing.java

@@ -53,9 +53,9 @@ public class AndroidSharing
     private final Activity mActivityInstance;
     private ParcelFileDescriptor mRequestedSharedFile = null;
 
-    public AndroidSharing(Activity ActivityInstance)
+    public AndroidSharing(Activity activityInstance)
     {
-        mActivityInstance = ActivityInstance;
+        mActivityInstance = activityInstance;
     }
 
     public String getReceivedSharedText()
@@ -65,16 +65,16 @@ public class AndroidSharing
 
     public byte[] getReceivedSharedBinaryData()
     {
-        final Uri DataUri = (Uri) mActivityInstance.getIntent().getParcelableExtra(Intent.EXTRA_STREAM);
-        byte[] ByteArray = null;
+        final Uri dataUri = (Uri) mActivityInstance.getIntent().getParcelableExtra(Intent.EXTRA_STREAM);
+        byte[] binaryData = null;
 
-        if(DataUri != null)
+        if(dataUri != null)
         {
             try
             {
-                final InputStream DataStream = mActivityInstance.getContentResolver().openInputStream(DataUri);
-                ByteArray = new byte[DataStream.available()];
-                DataStream.read(ByteArray);
+                final InputStream dataStream = mActivityInstance.getContentResolver().openInputStream(dataUri);
+                binaryData = new byte[dataStream.available()];
+                dataStream.read(binaryData);
             }
             catch(FileNotFoundException e)
             {
@@ -86,27 +86,27 @@ public class AndroidSharing
             }
         }
 
-        return ByteArray;
+        return binaryData;
     }
 
     public byte[][] getReceivedMultipleSharedBinaryData()
     {
-        final ArrayList<Uri> UriArray = mActivityInstance.getIntent().getParcelableArrayListExtra(Intent.EXTRA_STREAM);
-        byte[][] MultipleByteArray = null;
+        final ArrayList<Uri> uriArray = mActivityInstance.getIntent().getParcelableArrayListExtra(Intent.EXTRA_STREAM);
+        byte[][] multipleBinaryData = null;
 
-        if(UriArray != null)
+        if(uriArray != null)
         {
-            final int UriNum = UriArray.size();
+            final int uriNum = uriArray.size();
 
-            MultipleByteArray = new byte[UriNum][];
+            multipleBinaryData = new byte[uriNum][];
 
-            for(int i = 0; i < UriNum; i++)
+            for(int i = 0; i < uriNum; i++)
             {
                 try
                 {
-                    final InputStream DataStream = mActivityInstance.getContentResolver().openInputStream(UriArray.get(i));
-                    MultipleByteArray[i] = new byte[DataStream.available()];
-                    DataStream.read(MultipleByteArray[i]);
+                    final InputStream dataStream = mActivityInstance.getContentResolver().openInputStream(uriArray.get(i));
+                    multipleBinaryData[i] = new byte[dataStream.available()];
+                    dataStream.read(multipleBinaryData[i]);
                 }
                 catch(FileNotFoundException e)
                 {
@@ -119,79 +119,79 @@ public class AndroidSharing
             }
         }
 
-        return MultipleByteArray;
+        return multipleBinaryData;
     }
 
-    public boolean shareText(String Text)
+    public boolean shareText(String text)
     {
-        final Intent SendIntent = new Intent();
+        final Intent sendIntent = new Intent();
 
-        SendIntent.setAction(Intent.ACTION_SEND);
-        SendIntent.putExtra(Intent.EXTRA_TEXT, Text);
-        SendIntent.setType("text/plain");
+        sendIntent.setAction(Intent.ACTION_SEND);
+        sendIntent.putExtra(Intent.EXTRA_TEXT, text);
+        sendIntent.setType("text/plain");
 
-        mActivityInstance.startActivity(Intent.createChooser(SendIntent, null));       
+        mActivityInstance.startActivity(Intent.createChooser(sendIntent, null));
         return true;
     }
 
-    public boolean shareBinaryData(String MimeType, String DataFilePath)
+    public boolean shareBinaryData(String mimeType, String dataFilePath)
     {
-        final String PackageName = mActivityInstance.getApplicationContext().getPackageName();
-        final Intent SendIntent = new Intent();
-        Uri FileUri;
+        final String packageName = mActivityInstance.getApplicationContext().getPackageName();
+        final Intent sendIntent = new Intent();
+        Uri fileUri;
 
         try
         {
-            FileUri = FileProvider.getUriForFile(mActivityInstance,
-                                                 PackageName + ".qtandroidtoolsfileprovider",
-                                                 new File(DataFilePath)
+            fileUri = FileProvider.getUriForFile(mActivityInstance,
+                                                 packageName + ".qtandroidtoolsfileprovider",
+                                                 new File(dataFilePath)
                                                  );
         }
         catch(IllegalArgumentException e)
         {
-            Log.e(TAG, "The selected file can't be shared: " + DataFilePath);
+            Log.e(TAG, "The selected file can't be shared: " + dataFilePath);
             return false;
         }
 
-        SendIntent.setAction(Intent.ACTION_SEND);
-        SendIntent.putExtra(Intent.EXTRA_STREAM, FileUri);
-        SendIntent.addFlags(Intent.FLAG_GRANT_READ_URI_PERMISSION);
-        SendIntent.setType(MimeType);
+        sendIntent.setAction(Intent.ACTION_SEND);
+        sendIntent.putExtra(Intent.EXTRA_STREAM, fileUri);
+        sendIntent.addFlags(Intent.FLAG_GRANT_READ_URI_PERMISSION);
+        sendIntent.setType(mimeType);
 
-        mActivityInstance.startActivity(Intent.createChooser(SendIntent, null));
+        mActivityInstance.startActivity(Intent.createChooser(sendIntent, null));
         return true;
     }
 
-    public boolean shareFile(boolean FileAvailable, String MimeType, String FilePath)
+    public boolean shareFile(boolean fileAvailable, String mimeType, String filePath)
     {
-        final String PackageName = mActivityInstance.getApplicationContext().getPackageName();
-        final Intent ReturnFileIntent = new Intent(PackageName + ".ACTION_RETURN_FILE");
+        final String packageName = mActivityInstance.getApplicationContext().getPackageName();
+        final Intent returnFileIntent = new Intent(packageName + ".ACTION_RETURN_FILE");
 
-        if(FileAvailable == true)
+        if(fileAvailable == true)
         {
-            Uri FileUri;
+            Uri fileUri;
 
             try
             {
-                FileUri = FileProvider.getUriForFile(mActivityInstance,
-                                                     PackageName + ".qtandroidtoolsfileprovider",
-                                                     new File(FilePath)
+                fileUri = FileProvider.getUriForFile(mActivityInstance,
+                                                     packageName + ".qtandroidtoolsfileprovider",
+                                                     new File(filePath)
                                                      );
             }
             catch(IllegalArgumentException e)
             {
-                Log.e(TAG, "The selected file can't be shared: " + FilePath);
+                Log.e(TAG, "The selected file can't be shared: " + filePath);
                 return false;
             }
 
-            ReturnFileIntent.addFlags(Intent.FLAG_GRANT_READ_URI_PERMISSION);
-            ReturnFileIntent.setDataAndType(FileUri, MimeType);
-            mActivityInstance.setResult(Activity.RESULT_OK, ReturnFileIntent);
+            returnFileIntent.addFlags(Intent.FLAG_GRANT_READ_URI_PERMISSION);
+            returnFileIntent.setDataAndType(fileUri, mimeType);
+            mActivityInstance.setResult(Activity.RESULT_OK, returnFileIntent);
         }
         else
         {
-            ReturnFileIntent.setDataAndType(null, "");
-            mActivityInstance.setResult(Activity.RESULT_CANCELED, ReturnFileIntent);
+            returnFileIntent.setDataAndType(null, "");
+            mActivityInstance.setResult(Activity.RESULT_CANCELED, returnFileIntent);
         }
 
         return true;
@@ -199,15 +199,15 @@ public class AndroidSharing
 
     public byte[] getRequestedSharedFile()
     {
-        byte[] ByteArray = null;
+        byte[] fileData = null;
 
         if(mRequestedSharedFile != null)
         {
             try
             {
-                final FileInputStream DataStream = new FileInputStream(mRequestedSharedFile.getFileDescriptor());
-                ByteArray = new byte[DataStream.available()];
-                DataStream.read(ByteArray);
+                final FileInputStream dataStream = new FileInputStream(mRequestedSharedFile.getFileDescriptor());
+                fileData = new byte[dataStream.available()];
+                dataStream.read(fileData);
             }
             catch(IOException e)
             {
@@ -217,29 +217,29 @@ public class AndroidSharing
             closeRequestedSharedFile();
         }
 
-        return ByteArray;
+        return fileData;
     }
 
-    public Intent getRequestSharedFileIntent(String MimeType)
+    public Intent getRequestSharedFileIntent(String mimeType)
     {
-        final Intent RequestFileIntent = new Intent(Intent.ACTION_PICK);
-        RequestFileIntent.setType(MimeType);
-        return RequestFileIntent;
+        final Intent requestFileIntent = new Intent(Intent.ACTION_PICK);
+        requestFileIntent.setType(mimeType);
+        return requestFileIntent;
     }
 
-    public boolean requestSharedFileIntentDataResult(Intent Data)
+    public boolean requestSharedFileIntentDataResult(Intent data)
     {
-        final ContentResolver Resolver = mActivityInstance.getContentResolver();
-        final Uri SharedFileUri = Data.getData();
-        String FileName, MimeType;
-        Cursor DataCursor;
-        long FileSize;
+        final ContentResolver resolver = mActivityInstance.getContentResolver();
+        final Uri sharedFileUri = data.getData();
+        String fileName, mimeType;
+        Cursor dataCursor;
+        long fileSize;
 
         closeRequestedSharedFile();
 
         try
         {
-            mRequestedSharedFile = Resolver.openFileDescriptor(SharedFileUri, "r");
+            mRequestedSharedFile = resolver.openFileDescriptor(sharedFileUri, "r");
         }
         catch(FileNotFoundException e)
         {
@@ -247,13 +247,13 @@ public class AndroidSharing
             return false;
         }
 
-        DataCursor = Resolver.query(SharedFileUri, null, null, null, null);
-        DataCursor.moveToFirst();
-        FileName = DataCursor.getString(DataCursor.getColumnIndex(OpenableColumns.DISPLAY_NAME));
-        FileSize = DataCursor.getLong(DataCursor.getColumnIndex(OpenableColumns.SIZE));
-        MimeType = Resolver.getType(SharedFileUri);
+        dataCursor = resolver.query(sharedFileUri, null, null, null, null);
+        dataCursor.moveToFirst();
+        fileName = dataCursor.getString(dataCursor.getColumnIndex(OpenableColumns.DISPLAY_NAME));
+        fileSize = dataCursor.getLong(dataCursor.getColumnIndex(OpenableColumns.SIZE));
+        mimeType = resolver.getType(sharedFileUri);
 
-        requestedSharedFileInfo(MimeType, FileName, FileSize);
+        requestedSharedFileInfo(mimeType, fileName, fileSize);
         return true;
     }
 

QtAndroidTools/src/com/falsinsoft/qtandroidtools/AndroidSignalStrength.java

@@ -38,9 +38,9 @@ public class AndroidSignalStrength
 
     private int mSignalStrength = 0;
 
-    public AndroidSignalStrength(Activity ActivityInstance)
+    public AndroidSignalStrength(Activity activityInstance)
     {
-        ActivityInstance.runOnUiThread(new Runnable()
+        activityInstance.runOnUiThread(new Runnable()
         {
             @Override
             public void run()
@@ -48,7 +48,7 @@ public class AndroidSignalStrength
                 mSignalStateListener = new SignalStateListener();
             }
         });
-        mActivityInstance = ActivityInstance;
+        mActivityInstance = activityInstance;
     }
 
     public int getSignalStrength()
@@ -58,29 +58,29 @@ public class AndroidSignalStrength
 
     public void appStateChanged(int newState)
     {
-        final TelephonyManager TelephonyMngr = (TelephonyManager)mActivityInstance.getSystemService(Context.TELEPHONY_SERVICE);
-        final SignalStateListener Listener = mSignalStateListener;
-        int ListenEvent = PhoneStateListener.LISTEN_NONE;
+        final TelephonyManager telephonyManager = (TelephonyManager)mActivityInstance.getSystemService(Context.TELEPHONY_SERVICE);
+        final SignalStateListener listener = mSignalStateListener;
+        int listenEvent = PhoneStateListener.LISTEN_NONE;
 
         switch(newState)
         {
             case APP_STATE_CREATE:
             case APP_STATE_START:
-                ListenEvent = PhoneStateListener.LISTEN_SIGNAL_STRENGTHS;
+                listenEvent = PhoneStateListener.LISTEN_SIGNAL_STRENGTHS;
                 break;
             case APP_STATE_STOP:
             case APP_STATE_DESTROY:
-                ListenEvent = PhoneStateListener.LISTEN_NONE;
+                listenEvent = PhoneStateListener.LISTEN_NONE;
                 break;
         }
 
-        final int Event = ListenEvent;
+        final int event = listenEvent;
         mActivityInstance.runOnUiThread(new Runnable()
         {
             @Override
             public void run()
             {
-                TelephonyMngr.listen(Listener, Event);
+                telephonyManager.listen(listener, event);
             }
         });
     }

QtAndroidTools/src/com/falsinsoft/qtandroidtools/AndroidTools.java

@@ -35,33 +35,33 @@
     private static final String TAG = "AndroidTools";
     private final Activity mActivityInstance;
 
-    public AndroidTools(Activity ActivityInstance)
+    public AndroidTools(Activity activityInstance)
     {
-        mActivityInstance = ActivityInstance;
+        mActivityInstance = activityInstance;
     }
 
     public int getActivityAction()
     {
-        final String ActionValue = mActivityInstance.getIntent().getAction();
-        int ActionId = ACTION_NONE;
+        final String actionValue = mActivityInstance.getIntent().getAction();
+        int actionId = ACTION_NONE;
 
-        if(ActionValue != null)
+        if(actionValue != null)
         {
-            switch(ActionValue)
+            switch(actionValue)
             {
                 case Intent.ACTION_SEND:
-                    ActionId = ACTION_SEND;
+                    actionId = ACTION_SEND;
                     break;
                 case Intent.ACTION_SEND_MULTIPLE:
-                    ActionId = ACTION_SEND_MULTIPLE;
+                    actionId = ACTION_SEND_MULTIPLE;
                     break;
                 case Intent.ACTION_PICK:
-                    ActionId = ACTION_PICK;
+                    actionId = ACTION_PICK;
                     break;
             }
         }
 
-        return ActionId;
+        return actionId;
     }
 
     public String getActivityMimeType()

QtAndroidTools/src/com/falsinsoft/qtandroidtools/SyncRunOnUiThread.java

@@ -38,10 +38,10 @@ public class SyncRunOnUiThread
 	   public void runOnUIThread();
 	}	
 	
-    public SyncRunOnUiThread(Activity ActivityInstance, SyncRunOnUiThreadListener CodeListener)
+    public SyncRunOnUiThread(Activity activityInstance, SyncRunOnUiThreadListener codeListener)
     {
-        mActivityInstance = ActivityInstance;
-		mCodeListener = CodeListener;
+        mActivityInstance = activityInstance;
+		mCodeListener = codeListener;
 
         mRunnableCode = new Runnable()
         {

QtAndroidToolsDemo/Main.cpp

@@ -4,15 +4,15 @@
 #include <QIcon>
 #include "QtAndroidTools.h"
 
-void PrepareSharedFiles(const QString &SharedFolderName)
+void prepareSharedFiles(const QString &sharedFolderName)
 {
-    const QDir SharedFilesFolder(QStandardPaths::writableLocation(QStandardPaths::AppDataLocation));
+    const QDir sharedFilesFolder(QStandardPaths::writableLocation(QStandardPaths::AppDataLocation));
 
-    if(SharedFilesFolder.mkdir(SharedFolderName) == true)
+    if(sharedFilesFolder.mkdir(sharedFolderName) == true)
     {
-        const QString SharedFilesPath = (SharedFilesFolder.path() + "/" + SharedFolderName);
+        const QString sharedFilesPath = (sharedFilesFolder.path() + "/" + sharedFolderName);
 
-        QFile::copy(":/images/logo_falsinsoft.jpg", SharedFilesPath + "/logo_falsinsoft.jpg");
+        QFile::copy(":/images/logo_falsinsoft.jpg", sharedFilesPath + "/logo_falsinsoft.jpg");
     }
 }
 
@@ -24,12 +24,12 @@ int main(int argc, char *argv[])
     QGuiApplication app(argc, argv);
     QQmlApplicationEngine engine;
 
-    QtAndroidTools::InitializeQmlTools();
+    QtAndroidTools::initializeQmlTools();
 
     QObject::connect(&engine, SIGNAL(quit()), &app, SLOT(quit()));
     engine.load(QUrl(QStringLiteral("qrc:/Main.qml")));
     if(engine.rootObjects().isEmpty()) return -1;
-    PrepareSharedFiles("sharedfiles");
+    prepareSharedFiles("sharedfiles");
 
     QtAndroid::hideSplashScreen();