Subversion Repositories tpanel

/*

 * Copyright (C) 2020 to 2022 by Andreas Theofilu <andreas@theosys.at>

 *

 * This program is free software; you can redistribute it and/or modify

 * it under the terms of the GNU General Public License as published by

 * the Free Software Foundation; either version 3 of the License, or

 * (at your option) any later version.

 *

 * This program is distributed in the hope that it will be useful,

 * but WITHOUT ANY WARRANTY; without even the implied warranty of

 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

 * GNU General Public License for more details.

 *

 * You should have received a copy of the GNU General Public License

 * along with this program; if not, write to the Free Software Foundation,

 * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA

 */

/** @file tqtmain.cpp

 * @brief Implements the surface of the application.

 *

 * This file implements the callback functions of the suface. While the most

 * classes are drawing the elements, the methods here take the ready elements

 * and display them. This file makes the surface completely independent of

 * the rest of the application which makes it easy to change the surface by

 * any other technology.

 */

#include <QApplication>

#include <QGuiApplication>

#include <QByteArray>

#include <QCommandLineParser>

#include <QCommandLineOption>

#include <QLabel>

#include <QtWidgets>

#include <QMouseEvent>

#include <QMoveEvent>

#include <QTouchEvent>

#include <QPalette>

#include <QPixmap>

#include <QFont>

#include <QFontDatabase>

#include <QtMultimediaWidgets/QVideoWidget>

#include <QtMultimedia/QMediaPlayer>

#ifdef QT5_LINUX

#   include <QtMultimedia/QMediaPlaylist>

#else

#   include <QAudioOutput>

#endif

#include <QListWidget>

#include <QLayout>

#include <QSizePolicy>

#include <QUrl>

#include <QThread>

#ifdef QT5_LINUX

#   include <QSound>

#   include <QtSensors/QOrientationSensor>

#   include <qpa/qplatformscreen.h>

#else

#   include <QPlainTextEdit>

#   include <QtSensors/QOrientationReading>

#endif

#if defined(Q_OS_ANDROID) && defined(QT5_LINUX)

#include <QtAndroidExtras/QAndroidJniObject>

#include <QtAndroidExtras/QtAndroid>

#endif

#include <functional>

#include <mutex>

#ifdef __ANDROID__

#include <android/log.h>

#endif

#include "tpagemanager.h"

#include "tqtmain.h"

#include "tconfig.h"

#ifdef QTSETTINGS

#include "tqtsettings.h"

#endif

#include "tqkeyboard.h"

#include "tqkeypad.h"

#include "tcolor.h"

#include "texcept.h"

#include "ttpinit.h"

#include "tqdownload.h"

#include "tqtphone.h"

#include "tqeditline.h"

#include "terror.h"

#ifdef Q_OS_IOS

#include "ios/QASettings.h"

#include "ios/tiosrotate.h"

#include "ios/tiosbattery.h"

#endif

#if __cplusplus < 201402L

#   error "This module requires at least C++14 standard!"

#else

#   if __cplusplus < 201703L

#       include <experimental/filesystem>

namespace fs = std::experimental::filesystem;

#       warning "Support for C++14 and experimental filesystem will be removed in a future version!"

#   else

#       include <filesystem>

#       ifdef __ANDROID__

namespace fs = std::__fs::filesystem;

#       else

namespace fs = std::filesystem;

#       endif

#   endif

#endif

/**

 * @def THREAD_WAIT

 * This defines a time in milliseconds. It is used in the callbacks for the

 * functions to draw the elements. Qt need a little time to do it's work.

 * Therefore we're waiting a little bit. Otherwise it may result in missing

 * elements or black areas on the screen.

 */

#define THREAD_WAIT     1

extern amx::TAmxNet *gAmxNet;                   //!< Pointer to the class running the thread which handles the communication with the controller.

extern bool _restart_;                          //!< If this is set to true then the whole program will start over.

extern TPageManager *gPageManager;              //!< The pointer to the global defined main class.

std::mutex draw_mutex;                          //!< We're using threads and need to block execution sometimes

static bool isRunning = false;                  //!< TRUE = the pageManager was started.

TObject *gObject = nullptr;                     //!< Internal used pointer to a TObject class. (Necessary because of threads!)

#if defined(Q_OS_ANDROID) || defined(Q_OS_IOS)

static double gScale = 1.0;                     //!< Global variable holding the scale factor.

static int gFullWidth = 0;                      //!< Global variable holding the width of the AMX screen. This is used to calculate the scale factor for the settings dialog.

std::atomic<double> mScaleFactorW{1.0};

std::atomic<double> mScaleFactorH{1.0};

int gScreenWidth{0};

int gScreenHeight{0};

#endif

using std::bind;

using std::pair;

using std::string;

using std::vector;

string _NO_OBJECT = "The global class TObject is not available!";

/**

 * @brief qtmain is used here as the entry point for the surface.

 *

 * The main entry function parses the command line parameters, if there were

 * any and sets the basic attributes. It creates the main window and starts the

 * application.

 *

 * @param argc      The number of command line arguments

 * @param argv      A pointer to a 2 dimensional array containing the command

 *                  line parameters.

 * @param pmanager  A pointer to the page manager class which is the main class

 *                  managing everything.

 *

 * @return If no errors occured it returns 0.

 */

int qtmain(int argc, char **argv, TPageManager *pmanager)

{

    DECL_TRACER("qtmain(int argc, char **argv, TPageManager *pmanager)");

    if (!pmanager)

    {

        MSG_ERROR("Fatal: No pointer to the page manager received!");

        return 1;

    }

    if (!gPageManager || gPageManager != pmanager)

        gPageManager = pmanager;

#ifdef __ANDROID__

    MSG_INFO("Android API version: " << __ANDROID_API__);

#   if __ANDROID_API__ < 29

#       warn "The Android API version is less than 29! Some functions may not work!"

#   endif

#endif

#if defined(Q_OS_ANDROID) || defined(Q_OS_IOS)

    QApplication::setAttribute(Qt::AA_ForceRasterWidgets);

    QApplication::setAttribute(Qt::AA_Use96Dpi);

//    QApplication::setAttribute(Qt::AA_EnableHighDpiScaling);

//    QApplication::setAttribute(Qt::AA_DontUseNativeDialogs);

#endif

    QApplication app(argc, argv);

    // Set the orientation

#if defined(Q_OS_ANDROID) || defined(Q_OS_IOS)

    QScreen *screen = QGuiApplication::primaryScreen();

    QOrientationReading::Orientation ori = QOrientationReading::Undefined;

    Qt::ScreenOrientations mask = Qt::PrimaryOrientation;

    QOrientationSensor qOri;

    QOrientationReading *pORead = qOri.reading();

    if (pORead)

    {

        ori = pORead->orientation();

        switch(ori)

        {

            case QOrientationReading::LeftUp:   mask = Qt::InvertedLandscapeOrientation; break;

            case QOrientationReading::RightUp:  mask = Qt::LandscapeOrientation; break;

            case QOrientationReading::TopDown:  mask = Qt::InvertedPortraitOrientation; break;

            default:

                mask = Qt::PortraitOrientation;

        }

    }

    if (!screen)

    {

        MSG_ERROR("Couldn't determine the primary screen!")

        return 1;

    }

#ifdef QT5_LINUX

    if (pmanager->getSettings()->isPortrait())  // portrait?

    {

        MSG_INFO("Orientation set to portrait mode.");

        if (mask == Qt::InvertedPortraitOrientation)

            screen->setOrientationUpdateMask(Qt::InvertedPortraitOrientation);

        else

            screen->setOrientationUpdateMask(Qt::PortraitOrientation);

    }

    else

    {

        MSG_INFO("Orientation set to landscape mode.");

        if (mask == Qt::InvertedLandscapeOrientation)

            screen->setOrientationUpdateMask(Qt::InvertedLandscapeOrientation);

        else

            screen->setOrientationUpdateMask(Qt::LandscapeOrientation);

    }

#endif  // QT5_LINUX

    double scale = 1.0;

    double setupScaleFactor = 1.0;

    // Calculate the scale factor

    if (TConfig::getScale())

    {

        // Because we've no window here we can not know on which screen, if

        // there are more than one, the application will start. Because on a

        // mobile mostly no external screen is connected, we take always the

        // resolution of the first (built in) screen.

        // TODO: Find a way to get the screen the application will start and

        // take this screen to calculate the scale factor.

        QList<QScreen *> screens = QGuiApplication::screens();

        QRect screenGeometry = screens.at(0)->availableGeometry();

        double width = 0.0;

        double height = 0.0;

        double sysWidth = 0.0;

        double sysHeight = 0.0;

        gScreenWidth = screenGeometry.width();

        gScreenHeight = screenGeometry.height();

        if (gScreenWidth < gScreenHeight)

        {

            int w = gScreenWidth;

            gScreenWidth = gScreenHeight;

            gScreenHeight = w;

        }

        int minWidth = pmanager->getSettings()->getWidth();

        int minHeight = pmanager->getSettings()->getHeight();

        int minSysWidth = pmanager->getSystemSettings()->getWidth();

        int minSysHeight = pmanager->getSystemSettings()->getHeight();

        if (pmanager->getSettings()->isPortrait())  // portrait?

        {

            width = std::min(gScreenWidth, gScreenHeight);

            height = std::max(gScreenHeight, gScreenWidth);

        }

        else

        {

            width = std::max(gScreenWidth, gScreenHeight);

            height = std::min(gScreenHeight, gScreenWidth);

        }

        // The setup pages are always landscape

        sysWidth = std::max(gScreenWidth, gScreenHeight);

        sysHeight = std::min(gScreenHeight, gScreenWidth);

        if (!TConfig::getToolbarSuppress() && TConfig::getToolbarForce())

            minWidth += 48;

        MSG_INFO("Dimension of AMX screen:" << minWidth << " x " << minHeight);

        MSG_INFO("Screen size: " << width << " x " << height);

        // The scale factor is always calculated in difference to the prefered

        // size of the original AMX panel.

        mScaleFactorW = width / (double)minWidth;

        mScaleFactorH = height / (double)minHeight;

        double scaleFactorW = sysWidth / (double)minSysWidth;

        double scaleFactorH = sysHeight / (double)minSysHeight;

        scale = std::min(mScaleFactorW, mScaleFactorH);

        setupScaleFactor = std::min(scaleFactorW, scaleFactorH);

#ifdef __ANDROID__

        __android_log_print(ANDROID_LOG_DEBUG, "tpanel", "scale: %f (Screen: %1.0fx%1.0f, Page: %dx%d)", scale, width, height, minWidth, minHeight);

        __android_log_print(ANDROID_LOG_DEBUG, "tpanel", "setupScaleFactor: %f (Screen: %1.0fx%1.0f, Page: %dx%d)", setupScaleFactor, sysWidth, sysHeight, minSysWidth, minSysHeight);

#endif

        gScale = scale;     // The calculated scale factor

        gFullWidth = width;

        MSG_INFO("Calculated scale factor: " << scale);

        // This preprocessor variable allows the scaling to be done by the Skia

        // library, which is used to draw everything. In comparison to Qt this

        // library is a bit slower and sometimes does not honor the aspect ratio

        // correct. But in case there is another framework than Qt in use, this

        // could be necessary.

#ifdef _SCALE_SKIA_

        if (scale != 0.0)

        {

            pmanager->setScaleFactor(scale);

            MSG_INFO("Scale factor: " << scale);

        }

        if (scaleW != 0.0)

            pmanager->setScaleFactorWidth(scaleW);

        if (scaleH != 0.0)

            pmanager->setScaleFactorHeight(scaleH);

#endif  // _SCALE_SKIA_

    }

#endif  // defined(Q_OS_ANDROID) || defined(Q_OS_IOS)

#if not defined(Q_OS_ANDROID) && not defined(Q_OS_IOS)

    double setupScaleFactor = 1.0;

    if (pmanager->getSettings() != pmanager->getSystemSettings())

    {

        double width = 0.0;

        double height = 0.0;

        int minWidth = pmanager->getSystemSettings()->getWidth();

        int minHeight = pmanager->getSystemSettings()->getHeight();

        if (!TConfig::getToolbarSuppress() && TConfig::getToolbarForce())

            minWidth += 48;

        width = std::max(pmanager->getSettings()->getWidth(), pmanager->getSettings()->getHeight());

        height = std::min(pmanager->getSettings()->getHeight(), pmanager->getSettings()->getWidth());

        MSG_INFO("Dimension of AMX screen:" << minWidth << " x " << minHeight);

        MSG_INFO("Screen size: " << width << " x " << height);

        // The scale factor is always calculated in difference to the prefered

        // size of the original AMX panel.

        double scaleFactorW = width / (double)minWidth;

        double scaleFactorH = height / (double)minHeight;

        setupScaleFactor = std::min(scaleFactorW, scaleFactorH);

    }

#endif

    // Initialize the application

    pmanager->setDPI(QGuiApplication::primaryScreen()->logicalDotsPerInch());

    QCoreApplication::setOrganizationName(TConfig::getProgName().c_str());

    QCoreApplication::setApplicationName("TPanel");

    QCoreApplication::setApplicationVersion(VERSION_STRING());

    QCommandLineParser parser;

    parser.setApplicationDescription(QCoreApplication::applicationName());

    parser.addHelpOption();

    parser.addVersionOption();

    parser.process(app);

    MainWindow mainWin;

#if defined(Q_OS_ANDROID) || defined(Q_OS_IOS)

#   ifndef _SCALE_SKIA_

    if (TConfig::getScale() && scale != 1.0)

        mainWin.setScaleFactor(scale);

#   endif   // _SCALE_SKIA_

#endif  // defined(Q_OS_ANDROID) || defined(Q_OS_IOS)

    mainWin.setConfigFile(TConfig::getConfigPath() + "/" + TConfig::getConfigFileName());

    mainWin.setStyleSheet("QMainWindow {background: 'black';}");    // Keep the background black. Helps to save battery on OLED displays.

    mainWin.grabGesture(Qt::PinchGesture);

    mainWin.grabGesture(Qt::SwipeGesture);

    if (setupScaleFactor != 1.0 && setupScaleFactor > 0.0)

        mainWin.setSetupScaleFactor(setupScaleFactor);

    mainWin.show();

    return app.exec();

}

/**

 * @brief MainWindow::MainWindow constructor

 *

 * This method is the constructor for this class. It registers the callback

 * functions to the class TPageManager and starts the main run loop.

 *

 * Qt is used only to manage widgets to handle pages and subpages. A page as

 * well as a subpage may contain a background graphic and some elements. The

 * elements could be buttons, bargraphs and other objects. The underlying layer

 * draw every element as a ready graphic image and call a callback function to

 * let Qt display the graphic.

 * If there are some animations on a subpage defined, this is also handled by

 * Qt. Especialy sliding and fading.

 */

MainWindow::MainWindow()

{

    DECL_TRACER("MainWindow::MainWindow()");

    gObject = new TObject;

#if defined(Q_OS_ANDROID) || defined(Q_OS_IOS)

    setAttribute(Qt::WA_AcceptTouchEvents, true);   // We accept touch events

    grabGesture(Qt::PinchGesture);                  // We use a pinch gesture to open the settings dialog

    grabGesture(Qt::SwipeGesture);                  // We support swiping also

    if (gPageManager && gPageManager->getSettings()->isPortrait() == 1)  // portrait?

    {

        MSG_INFO("Orientation set to portrait mode.");

        mOrientation = Qt::PortraitOrientation;

        _setOrientation(O_PORTRAIT);

    }

    else

    {

        MSG_INFO("Orientation set to landscape mode.");

        mOrientation = Qt::LandscapeOrientation;

        _setOrientation(O_LANDSCAPE);

    }

#ifdef Q_OS_IOS

    TIOSRotate::automaticRotation(false);

#endif

#else

    setWindowIcon(QIcon(":images/icon.png"));

#endif

    if (!gPageManager)

    {

        EXCEPTFATALMSG("The class TPageManager was not initialized!");

    }

    // First we register all our surface callbacks to the underlying work

    // layer. All the graphics are drawn by the Skia library. The layer below

    // call the following functions to let Qt display the graphics on the

    // screen let it manage the widgets containing the graphics.

    gPageManager->registerCallbackDB(bind(&MainWindow::_displayButton, this,

                                       std::placeholders::_1,

                                       std::placeholders::_2,

                                       std::placeholders::_3,

                                       std::placeholders::_4,

                                       std::placeholders::_5,

                                       std::placeholders::_6,

                                       std::placeholders::_7,

                                       std::placeholders::_8));

    gPageManager->registerCallbackSP(bind(&MainWindow::_setPage, this,

                                         std::placeholders::_1,

                                         std::placeholders::_2,

                                         std::placeholders::_3));

    gPageManager->registerCallbackSSP(bind(&MainWindow::_setSubPage, this,

                                          std::placeholders::_1,

                                          std::placeholders::_2,

                                          std::placeholders::_3,

                                          std::placeholders::_4,

                                          std::placeholders::_5,

                                          std::placeholders::_6,

                                          std::placeholders::_7));

    gPageManager->registerCallbackSB(bind(&MainWindow::_setBackground, this,

                                         std::placeholders::_1,

                                         std::placeholders::_2,

                                         std::placeholders::_3,

                                         std::placeholders::_4,

                                         std::placeholders::_5,

                                         std::placeholders::_6,

                                         std::placeholders::_7));

    gPageManager->regCallDropPage(bind(&MainWindow::_dropPage, this, std::placeholders::_1));

    gPageManager->regCallDropSubPage(bind(&MainWindow::_dropSubPage, this, std::placeholders::_1));

    gPageManager->regCallPlayVideo(bind(&MainWindow::_playVideo, this,

                                       std::placeholders::_1,

                                       std::placeholders::_2,

                                       std::placeholders::_3,

                                       std::placeholders::_4,

                                       std::placeholders::_5,

                                       std::placeholders::_6,

                                       std::placeholders::_7,

                                       std::placeholders::_8,

                                       std::placeholders::_9));

    gPageManager->regCallInputText(bind(&MainWindow::_inputText, this, std::placeholders::_1, std::placeholders::_2, std::placeholders::_3));

    gPageManager->regCallListBox(bind(&MainWindow::_listBox, this, std::placeholders::_1, std::placeholders::_2, std::placeholders::_3));

    gPageManager->registerDropButton(bind(&MainWindow::_dropButton, this, std::placeholders::_1));

    gPageManager->regCallbackKeyboard(bind(&MainWindow::_showKeyboard, this, std::placeholders::_1, std::placeholders::_2, std::placeholders::_3));

    gPageManager->regCallbackKeypad(bind(&MainWindow::_showKeypad, this, std::placeholders::_1, std::placeholders::_2, std::placeholders::_3));

    gPageManager->regCallResetKeyboard(bind(&MainWindow::_resetKeyboard, this));

    gPageManager->regCallShowSetup(bind(&MainWindow::_showSetup, this));

    gPageManager->regCallbackResetSurface(bind(&MainWindow::_resetSurface, this));

    gPageManager->regCallbackShutdown(bind(&MainWindow::_shutdown, this));

    gPageManager->regCallbackPlaySound(bind(&MainWindow::_playSound, this, std::placeholders::_1));

    gPageManager->regCallbackStopSound(bind(&MainWindow::_stopSound, this));

    gPageManager->regCallbackMuteSound(bind(&MainWindow::_muteSound, this, std::placeholders::_1));

    gPageManager->registerCBsetVisible(bind(&MainWindow::_setVisible, this, std::placeholders::_1, std::placeholders::_2));

    gPageManager->regSendVirtualKeys(bind(&MainWindow::_sendVirtualKeys, this, std::placeholders::_1));

    gPageManager->regShowPhoneDialog(bind(&MainWindow::_showPhoneDialog, this, std::placeholders::_1));

    gPageManager->regSetPhoneNumber(bind(&MainWindow::_setPhoneNumber, this, std::placeholders::_1));

    gPageManager->regSetPhoneStatus(bind(&MainWindow::_setPhoneStatus, this, std::placeholders::_1));

    gPageManager->regSetPhoneState(bind(&MainWindow::_setPhoneState, this, std::placeholders::_1, std::placeholders::_2));

#if defined(Q_OS_ANDROID) || defined(Q_OS_IOS)

    gPageManager->regOnOrientationChange(bind(&MainWindow::_orientationChanged, this, std::placeholders::_1));

#endif

    gPageManager->regRepaintWindows(bind(&MainWindow::_repaintWindows, this));

    gPageManager->regToFront(bind(&MainWindow::_toFront, this, std::placeholders::_1));

#ifndef __ANDROID__

    gPageManager->regSetMainWindowSize(bind(&MainWindow::_setSizeMainWindow, this, std::placeholders::_1, std::placeholders::_2));

#endif

    gPageManager->regDownloadSurface(bind(&MainWindow::_downloadSurface, this, std::placeholders::_1, std::placeholders::_2));

    gPageManager->regDisplayMessage(bind(&MainWindow::_displayMessage, this, std::placeholders::_1, std::placeholders::_2));

    gPageManager->regFileDialogFunction(bind(&MainWindow::_fileDialog, this,

                                             std::placeholders::_1,

                                             std::placeholders::_2,

                                             std::placeholders::_3,

                                             std::placeholders::_4));

    gPageManager->deployCallbacks();

    createActions();

#ifndef QT_NO_SESSIONMANAGER

#if defined(QT5_LINUX) && !defined(QT6_LINUX)

    QGuiApplication::setFallbackSessionManagementEnabled(false);

    connect(qApp, &QGuiApplication::commitDataRequest,

            this, &MainWindow::writeSettings);

#endif

#endif

    // Some types used to transport data from the layer below.

    qRegisterMetaType<size_t>("size_t");

    qRegisterMetaType<QByteArray>("QByteArray");

    qRegisterMetaType<ANIMATION_t>("ANIMATION_t");

    qRegisterMetaType<Button::TButton *>("TButton");

    qRegisterMetaType<std::string>("std::string");

    // All the callback functions doesn't act directly. Instead they emit an

    // event. Then Qt decides whether the real function is started directly and

    // immediately or if the call is queued and called later in a thread. To

    // handle this we're "connecting" the real functions to some signals.

    try

    {

        connect(this, &MainWindow::sigDisplayButton, this, &MainWindow::displayButton);

        connect(this, &MainWindow::sigSetPage, this, &MainWindow::setPage);

        connect(this, &MainWindow::sigSetSubPage, this, &MainWindow::setSubPage);

        connect(this, &MainWindow::sigSetBackground, this, &MainWindow::setBackground);

        connect(this, &MainWindow::sigDropPage, this, &MainWindow::dropPage);

        connect(this, &MainWindow::sigDropSubPage, this, &MainWindow::dropSubPage);

        connect(this, &MainWindow::sigPlayVideo, this, &MainWindow::playVideo);

        connect(this, &MainWindow::sigInputText, this, &MainWindow::inputText);

        connect(this, &MainWindow::sigListBox, this, &MainWindow::listBox);

        connect(this, &MainWindow::sigKeyboard, this, &MainWindow::showKeyboard);

        connect(this, &MainWindow::sigKeypad, this, &MainWindow::showKeypad);

        connect(this, &MainWindow::sigShowSetup, this, &MainWindow::showSetup);

        connect(this, &MainWindow::sigPlaySound, this, &MainWindow::playSound);

        connect(this, &MainWindow::sigDropButton, this, &MainWindow::dropButton);

        connect(this, &MainWindow::sigSetVisible, this, &MainWindow::SetVisible);

        connect(this, &MainWindow::sigSendVirtualKeys, this, &MainWindow::sendVirtualKeys);

        connect(this, &MainWindow::sigShowPhoneDialog, this, &MainWindow::showPhoneDialog);

        connect(this, &MainWindow::sigSetPhoneNumber, this, &MainWindow::setPhoneNumber);

        connect(this, &MainWindow::sigSetPhoneStatus, this, &MainWindow::setPhoneStatus);

        connect(this, &MainWindow::sigSetPhoneState, this, &MainWindow::setPhoneState);

        connect(this, &MainWindow::sigRepaintWindows, this, &MainWindow::repaintWindows);

        connect(this, &MainWindow::sigToFront, this, &MainWindow::toFront);

        connect(this, &MainWindow::sigOnProgressChanged, this, &MainWindow::onProgressChanged);

#if not defined(Q_OS_ANDROID) && not defined(Q_OS_IOS)

        connect(this, &MainWindow::sigSetSizeMainWindow, this, &MainWindow::setSizeMainWindow);

#endif

        connect(this, &MainWindow::sigDownloadSurface, this, &MainWindow::downloadSurface);

        connect(this, &MainWindow::sigDisplayMessage, this, &MainWindow::displayMessage);

        connect(this, &MainWindow::sigFileDialog, this, &MainWindow::fileDialog);

        connect(qApp, &QGuiApplication::applicationStateChanged, this, &MainWindow::onAppStateChanged);

#if defined(Q_OS_ANDROID) || defined(Q_OS_IOS)

        QScreen *screen = QGuiApplication::primaryScreen();

        connect(screen, &QScreen::orientationChanged, this, &MainWindow::onScreenOrientationChanged);

#endif

    }

    catch (std::exception& e)

    {

        MSG_ERROR("Connection error: " << e.what());

    }

    catch(...)

    {

        MSG_ERROR("Unexpected exception occured [MainWindow::MainWindow()]");

    }

    setUnifiedTitleAndToolBarOnMac(true);

#ifdef Q_OS_ANDROID

    // At least initialize the phone call listener

    if (gPageManager)

        gPageManager->initPhoneState();

    /*

     * In case this class was created not the first time, we initiate a small

     * thread to send the signal ApplicationActive to initiate the communication

     * with the controller again. This also starts the page manager thread

     * (TPageManager), which handles all elements of the surface.

     */

    if (_restart_ && gPageManager)

    {

        try

        {

            std::thread mThread = std::thread([=] { this->_signalState(Qt::ApplicationActive); });

            mThread.detach();   // We detach immediately to leave this method.

        }

        catch (std::exception& e)

        {

            MSG_ERROR("Error starting the thread to reinvoke communication!");

        }

        catch(...)

        {

            MSG_ERROR("Unexpected exception occured [MainWindow::MainWindow()]");

        }

    }

#endif

#ifdef Q_OS_IOS

    START_TEMPORARY_TRACE();

    // To get the battery level periodicaly we setup a timer.

    if (!mIosBattery)

        mIosBattery = new TIOSBattery;

    mIosBattery->update();

    if (gPageManager)

    {

        int left = mIosBattery->getBatteryLeft();

        int state = mIosBattery->getBatteryState();

        // At this point no buttons are registered and therefore the battery

        // state will not be visible. To have the state at the moment a button

        // is registered, we tell the page manager to store the values.

        gPageManager->setBattery(left, state);

        MSG_DEBUG("Battery state was set to " << left << "% and state " << state);

    }

    if (!mBatTimer)

        mBatTimer = new QTimer(this);

    connect(mBatTimer, &QTimer::timeout, this, &MainWindow::onBatteryTimeout);

    mBatTimer->start(30000);    // Every 30 seconds

    END_TEMPORARY_LOG();

#endif  // Q_OS_IOS

    _restart_ = false;

}

MainWindow::~MainWindow()

{

    DECL_TRACER("MainWindow::~MainWindow()");

    killed = true;

    prg_stopped = true;

    if (mMediaPlayer)

    {

#ifdef QT6_LINUX

        delete mAudioOutput;

#endif

        delete mMediaPlayer;

    }

    if (gAmxNet && !gAmxNet->isStopped())

        gAmxNet->stop();

    if (mToolbar)

    {

        removeToolBar(mToolbar);

        mToolbar = nullptr;

    }

    if (gObject)

    {

        delete gObject;

        gObject = nullptr;

    }

    isRunning = false;

#ifdef Q_OS_IOS

    TIOSRotate::automaticRotation(true);

    if (mBatTimer)

    {

        mBatTimer->stop();

        delete mBatTimer;

        mBatTimer = nullptr;

    }

    if (mIosBattery)

    {

        delete mIosBattery;

        mIosBattery = nullptr;

    }

#endif

}

#if defined(Q_OS_ANDROID) || defined(Q_OS_IOS)

/**

 * @brief Small thread to invoke the initialization on an Android device.

 *

 * On Android devices the signal ApplicationActive is not send if the class

 * \p MainWindow is destroyed and recreated. Therefore we need this little

 * helper to send the signal when the class is initialized.

 *

 * @param state     This defines the signal to send.

 */

void MainWindow::_signalState(Qt::ApplicationState state)

{

    DECL_TRACER("MainWindow::_signalState(Qt::ApplicationState state)");

    std::this_thread::sleep_for(std::chrono::seconds(1));   // Wait a second

    onAppStateChanged(state);

}

void MainWindow::_orientationChanged(int orientation)

{

    DECL_TRACER("MainWindow::_orientationChanged(int orientation)");

    if (gPageManager && gPageManager->getSettings()->isPortrait() == 1)  // portrait?

    {

        if (orientation == O_REVERSE_PORTRAIT && mOrientation != Qt::InvertedPortraitOrientation)

        {

            _setOrientation((J_ORIENTATION)orientation);

            mOrientation = Qt::InvertedPortraitOrientation;

        }

        else if (orientation == O_PORTRAIT && mOrientation != Qt::PortraitOrientation)

        {

            _setOrientation((J_ORIENTATION)orientation);

            mOrientation = Qt::PortraitOrientation;

        }

    }

    else

    {

        if (orientation == O_REVERSE_LANDSCAPE && mOrientation != Qt::InvertedLandscapeOrientation)

        {

            _setOrientation((J_ORIENTATION)orientation);

            mOrientation = Qt::InvertedLandscapeOrientation;

        }

        else if (orientation == O_LANDSCAPE && mOrientation != Qt::LandscapeOrientation)

        {

            _setOrientation((J_ORIENTATION)orientation);

            mOrientation = Qt::LandscapeOrientation;

        }

    }

}

/**

 * @brief MainWindow::_freezeWorkaround: A workaround for the screen freeze.

 * On Android the screen sometimes stay freezed after the application state

 * changes to ACTIVE.

 * The workaround produces a faked geometry change which makes the Qt framework

 * to reattach to the screen. This workaround is only for QT5.x necessary.

 */

#ifdef QT5_LINUX

void MainWindow::_freezeWorkaround()

{

    DECL_TRACER("MainWindow::_freezeWorkaround()");

    QScreen* scr = QGuiApplication::screens().first();

    QPlatformScreen* l_pScr = scr->handle(); /*QAndroidPlatformScreen*/

    QRect l_geomHackAdjustedRect = l_pScr->availableGeometry();

    QRect l_geomHackRect = l_geomHackAdjustedRect;

    l_geomHackAdjustedRect.adjust(0,0,0,5);

    QMetaObject::invokeMethod(dynamic_cast<QObject*>(l_pScr), "setAvailableGeometry", Qt::DirectConnection, Q_ARG( const QRect &, l_geomHackAdjustedRect ));

    QMetaObject::invokeMethod(dynamic_cast<QObject*>(l_pScr), "setAvailableGeometry", Qt::QueuedConnection, Q_ARG( const QRect &, l_geomHackRect ));

}

#endif  // QT5_LINUX

#endif  // Q_OS_ANDROID || Q_OS_IOS

void MainWindow::_repaintWindows()

{

    DECL_TRACER("MainWindow::_repaintWindows()");

    emit sigRepaintWindows();

}

void MainWindow::_toFront(ulong handle)

{

    DECL_TRACER("MainWindow::_toFront(ulong handle)");

    emit sigToFront(handle);

}