How to make full screen

Reply to How to make full screen on Mon, 13 Feb 2023 05:05:43 GMT

serkan_tr — Mon, 13 Feb 2023 05:05:43 GMT

@JoeCFD I made the comments line everywhere, I only made the part you said active, but it is still full screen, the vindow and application parts are visible at the bottom.

ApplicationWindow {
    id:             mainWindow
//    minimumWidth:   ScreenTools.isMobile ? Screen.width  : Math.min(ScreenTools.defaultFontPixelWidth * 100, Screen.width)
//    minimumHeight:  ScreenTools.isMobile ? Screen.height : Math.min(ScreenTools.defaultFontPixelWidth * 50, Screen.height)
//    visible: true
    visibility: Window.FullScreen
//    visibility: Window.FullScreen
//    visibility: mainWindow.FullScreen
//    Component.onCompleted: {
//        console.log((ScreenTools.defaultFontPixelWidth * 100).toString(),"--",Screen.width.toString(),"\n\n")
//        //-- Full screen on mobile or tiny screens
////        mainWindow.minimumWidth = Math.min(1000,1000/*ScreenTools.defaultFontPixelWidth * 100, Screen.width*/)
////        mainWindow.showFullScreen()
////        console.log("\n\nsignal\n\n")
//        if (!ScreenTools.isMobile || Screen.height / ScreenTools.realPixelDensity < 120 /*|| 1 === 1*/) {
//             console.log("APP: true")
////            mainWindow.FullScreen
//            mainWindow.showFullScreen()

//        } else {
//            console.log("APP: false")
//            width   = ScreenTools.isMobile ? Screen.width  : Math.min(250 * Screen.pixelDensity, Screen.width)
//            height  = ScreenTools.isMobile ? Screen.height : Math.min(150 * Screen.pixelDensity, Screen.height)
////            mainWindow.showFullScreen()
//        }

//        // Start the sequence of first run prompt(s)
//        firstRunPromptManager.nextPrompt()
//    }

Reply to How to make full screen on Fri, 10 Feb 2023 15:01:53 GMT

JoeCFD — Fri, 10 Feb 2023 15:01:53 GMT

@serkan_tr I said remove or comment them out.
Use only
visibility: Window.FullScreen

Reply to How to make full screen on Fri, 10 Feb 2023 14:58:03 GMT

serkan_tr — Fri, 10 Feb 2023 14:58:03 GMT

@JoeCFD
27 and 28 no matter what I do, only the smallest state changes
The "windows taskbar" part at the bottom still appears
![Screenshot (1).png](Request Entity Too Large)

Reply to How to make full screen on Fri, 10 Feb 2023 15:07:28 GMT

JoeCFD — Fri, 10 Feb 2023 15:07:28 GMT

@serkan_tr can you show your picture? I use it for Linux and Android without issues. Maybe Windows 10 is too old.
mainWindow.showFullScreen() is not needed.

You can also try to get screen size from your main and set it somewhere.
QRect rec = QGuiApplication::screens().at( 0 )->geometry();
QSize( rec.width(), rec.height() ) is the screen size;

then, pass the size to
height and width of your mainWindow

Reply to How to make full screen on Fri, 10 Feb 2023 14:46:35 GMT

serkan_tr — Fri, 10 Feb 2023 14:46:35 GMT

@JoeCFD I tried changing these lines but the screen size still did not change.
what exactly should i write

Reply to How to make full screen on Fri, 10 Feb 2023 14:43:51 GMT

serkan_tr — Fri, 10 Feb 2023 14:43:51 GMT

@serkan_tr said in How to make full screen:

if (!ScreenTools.isMobile || Screen.height / ScreenTools.realPixelDensity < 120 /|| 1 === 1/) {
console.log("APP: true")
// mainWindow.FullScreen
mainWindow.showFullScreen()
    } else {
        console.log("APP: false")
        width   = ScreenTools.isMobile ? Screen.width  : Math.min(250 * Screen.pixelDensity, Screen.width)
        height  = ScreenTools.isMobile ? Screen.height : Math.min(150 * Screen.pixelDensity, Screen.height)
// mainWindow.showFullScreen()
}
I guess this is what I'm doing. Even if I put "mainWindow.showFullScreen()" else here, it doesn't work, the bottom part is still visible.
My goal is to show the inside of my app as it was before formatting the tablet. I want it to completely fill the screen. no matter what device, tablet phone computer only this one should appear

Reply to How to make full screen on Fri, 10 Feb 2023 14:41:06 GMT

JoeCFD — Fri, 10 Feb 2023 14:41:06 GMT

@serkan_tr I happend to know the source code a bit. You may try to replace the two lines(line 27 and 28):

    minimumWidth:   ScreenTools.isMobile ? Screen.width  : Math.min(ScreenTools.defaultFontPixelWidth * 100, Screen.width)
    minimumHeight:  ScreenTools.isMobile ? Screen.height : Math.min(ScreenTools.defaultFontPixelWidth * 50, Screen.height)

of the code here
https://github.com/mavlink/qgroundcontrol/blob/master/src/ui/MainRootWindow.qml
with
visibility: Window.FullScreen
to see if it helps.

Reply to How to make full screen on Fri, 10 Feb 2023 14:39:44 GMT

serkan_tr — Fri, 10 Feb 2023 14:39:44 GMT

@serkan_tr main.qml

ApplicationWindow {
    id:             mainWindow
    minimumWidth:   ScreenTools.isMobile ? Screen.width  : Math.min(ScreenTools.defaultFontPixelWidth * 100, Screen.width)
    minimumHeight:  ScreenTools.isMobile ? Screen.height : Math.min(ScreenTools.defaultFontPixelWidth * 50, Screen.height)
    visible: true
//    visibility: mainWindow.FullScreen
    Component.onCompleted: {
        console.log((ScreenTools.defaultFontPixelWidth * 100).toString(),"--",Screen.width.toString(),"\n\n")
        //-- Full screen on mobile or tiny screens
//        mainWindow.minimumWidth = Math.min(1000,1000/*ScreenTools.defaultFontPixelWidth * 100, Screen.width*/)
//        mainWindow.showFullScreen()
//        console.log("\n\nsignal\n\n")
        if (!ScreenTools.isMobile || Screen.height / ScreenTools.realPixelDensity < 120 /*|| 1 === 1*/) {
             console.log("APP: true")
//            mainWindow.FullScreen
            mainWindow.showFullScreen()

        } else {
            console.log("APP: false")
            width   = ScreenTools.isMobile ? Screen.width  : Math.min(250 * Screen.pixelDensity, Screen.width)
            height  = ScreenTools.isMobile ? Screen.height : Math.min(150 * Screen.pixelDensity, Screen.height)
//            mainWindow.showFullScreen()
        }

        // Start the sequence of first run prompt(s)
        firstRunPromptManager.nextPrompt()
    }

    QtObject {
        id: firstRunPromptManager

        property var currentDialog:     null
        property var rgPromptIds:       QGroundControl.corePlugin.firstRunPromptsToShow()
        property int nextPromptIdIndex: 0

        function clearNextPromptSignal() {
            if (currentDialog) {
                currentDialog.closed.disconnect(nextPrompt)
            }
        }

        function nextPrompt() {
            if (nextPromptIdIndex < rgPromptIds.length) {
                var component = Qt.createComponent(QGroundControl.corePlugin.firstRunPromptResource(rgPromptIds[nextPromptIdIndex]));
                currentDialog = component.createObject(mainWindow)
                currentDialog.closed.connect(nextPrompt)
                currentDialog.open()
                nextPromptIdIndex++
            } else {
                currentDialog = null
                showPreFlightChecklistIfNeeded()
            }
        }
    }

    property var                _rgPreventViewSwitch:       [ false ]

    readonly property real      _topBottomMargins:          ScreenTools.defaultFontPixelHeight * 0.5

    //-------------------------------------------------------------------------
    //-- Global Scope Variables

    QtObject {
        id: globals

        readonly property var       activeVehicle:                  QGroundControl.multiVehicleManager.activeVehicle
        readonly property real      defaultTextHeight:              ScreenTools.defaultFontPixelHeight
        readonly property real      defaultTextWidth:               ScreenTools.defaultFontPixelWidth
        readonly property var       planMasterControllerFlyView:    flightView.planController
        readonly property var       guidedControllerFlyView:        flightView.guidedController

        property var                planMasterControllerPlanView:   null
        property var                currentPlanMissionItem:         planMasterControllerPlanView ? planMasterControllerPlanView.missionController.currentPlanViewItem : null
    }

    /// Default color palette used throughout the UI
    QGCPalette { id: qgcPal; colorGroupEnabled: true }

    //-------------------------------------------------------------------------
    //-- Actions

    signal armVehicleRequest
    signal forceArmVehicleRequest
    signal disarmVehicleRequest
    signal vtolTransitionToFwdFlightRequest
    signal vtolTransitionToMRFlightRequest
    signal showPreFlightChecklistIfNeeded

    //-------------------------------------------------------------------------
    //-- Global Scope Functions

    /// Prevent view switching
    function pushPreventViewSwitch() {
        _rgPreventViewSwitch.push(true)
    }

    /// Allow view switching
    function popPreventViewSwitch() {
        if (_rgPreventViewSwitch.length == 1) {
            console.warn("mainWindow.popPreventViewSwitch called when nothing pushed")
            return
        }
        _rgPreventViewSwitch.pop()
    }

    /// @return true: View switches are not currently allowed
    function preventViewSwitch() {
        return _rgPreventViewSwitch[_rgPreventViewSwitch.length - 1]
    }

    function viewSwitch(currentToolbar) {
        toolDrawer.visible      = false
        toolDrawer.toolSource   = ""
        flightView.visible      = false
        planView.visible        = false
        toolbar.currentToolbar  = currentToolbar
    }

    function showFlyView() {
        if (!flightView.visible) {
            mainWindow.showPreFlightChecklistIfNeeded()
        }
        viewSwitch(toolbar.flyViewToolbar)
        flightView.visible = true
    }

    function showPlanView() {
        viewSwitch(toolbar.planViewToolbar)
        planView.visible = true
    }

    function showTool(toolTitle, toolSource, toolIcon) {
        toolDrawer.backIcon     = flightView.visible ? "/qmlimages/PaperPlane.svg" : "/qmlimages/Plan.svg"
        toolDrawer.toolTitle    = toolTitle
        toolDrawer.toolSource   = toolSource
        toolDrawer.toolIcon     = toolIcon
        toolDrawer.visible      = true
    }
    function showMapTool(toolSourceMap) {
        toolDrawermap.toolSourceMap   = toolSourceMap
        toolDrawermap.visible         = true
    }
    function showLedTool(toolSourceLed){
      toolDrawerled.toolSourceLed=toolSourceLed
        if(toolDrawerled.visible==false){
         toolDrawerled.visible=true
        }
        else{
         toolDrawerled.visible=false
        }
    }
    function showCalibTool(toolSourceCalib){
        toolDrawercalibration.toolSourceCalib = toolSourceCalib
        if(toolDrawercalibration.visible==false){
         toolDrawercalibration.visible=true
        }
        else{
         toolDrawercalibration.visible=false
        }
    }

    function showAnalyzeTool() {
        showTool(qsTr("Analyze Tools"), "AnalyzeView.qml", "/qmlimages/Analyze.svg")
    }

    function showSetupTool() {
        showTool(qsTr("Vehicle Setup"), "SetupView.qml", "/qmlimages/Gears.svg")
    }

    function showSettingsTool() {
        showTool(qsTr("Application Settings"), "AppSettings.qml", "/res/QGCLogoWhite")
    }
    function showLedToolpup(){
       showLedTool("LedSettings2.qml")
    }
    function showMapToolpup(){
    showMapTool("MapSettings.qml")
    }
    function showCamTool(){
    showTool(qsTr("Camera Settings"),"CameraSettings.qml","/InstrumentValueIcons/camera-svgrepo-white.svg")
    }
    function showCalibToolpup(){
    showCalibTool("CalibrationSettings.qml")
    }

    //-------------------------------------------------------------------------
    //-- Global simple message dialog

    function showMessageDialog(dialogTitle, dialogText, buttons = StandardButton.Ok, acceptFunction = null) {
        simpleMessageDialogComponent.createObject(mainWindow, { title: dialogTitle, text: dialogText, buttons: buttons, acceptFunction: acceptFunction }).open()
    }

    // This variant is only meant to be called by QGCApplication
    function _showMessageDialog(dialogTitle, dialogText) {
        showMessageDialog(dialogTitle, dialogText)
    }

    Component {
        id: simpleMessageDialogComponent

        QGCSimpleMessageDialog {
        }
    }

    /// Saves main window position and size
    MainWindowSavedState {
        window: mainWindow
    }

    property bool _forceClose: false

    function finishCloseProcess() {
        _forceClose = true
        // For some reason on the Qml side Qt doesn't automatically disconnect a signal when an object is destroyed.
        // So we have to do it ourselves otherwise the signal flows through on app shutdown to an object which no longer exists.
        firstRunPromptManager.clearNextPromptSignal()
        QGroundControl.linkManager.shutdown()
        QGroundControl.videoManager.stopVideo();
        mainWindow.close()
    }

    // On attempting an application close we check for:
    //  Unsaved missions - then
    //  Pending parameter writes - then
    //  Active connections

    property string closeDialogTitle: qsTr("Close %1").arg(QGroundControl.appName)

    function checkForUnsavedMission() {
        if (globals.planMasterControllerPlanView && globals.planMasterControllerPlanView.dirty) {
            showMessageDialog(closeDialogTitle,
                              qsTr("You have a mission edit in progress which has not been saved/sent. If you close you will lose changes. Are you sure you want to close?"),
                              StandardButton.Yes | StandardButton.No,
                              function() { checkForPendingParameterWrites() })
        } else {
            checkForPendingParameterWrites()
        }
    }

    function checkForPendingParameterWrites() {
        for (var index=0; index 5
            color:              qgcPal.alertText
            MouseArea {
                anchors.fill:   parent
                onClicked: {
                    criticalVehicleMessageFlick.flick(0,-500)
                }
            }
        }
    }

    //-------------------------------------------------------------------------
    //-- Indicator Popups

    function showIndicatorPopup(item, dropItem) {
        indicatorPopup.currentIndicator = dropItem
        indicatorPopup.currentItem = item
        indicatorPopup.open()
    }

    function hideIndicatorPopup() {
        indicatorPopup.close()
        indicatorPopup.currentItem = null
        indicatorPopup.currentIndicator = null
    }

    Popup {
        id:             indicatorPopup
        padding:        ScreenTools.defaultFontPixelWidth * 0.75
        modal:          true
        focus:          true
        closePolicy:    Popup.CloseOnEscape | Popup.CloseOnPressOutside
        property var    currentItem:        null
        property var    currentIndicator:   null
        background: Rectangle {
            width:  loader.width
            height: loader.height
            color:  Qt.rgba(0,0,0,0)
        }
        Loader {
            id:             loader
            onLoaded: {
                var centerX = mainWindow.contentItem.mapFromItem(indicatorPopup.currentItem, 0, 0).x - (loader.width * 0.5)
                if((centerX + indicatorPopup.width) > (mainWindow.width - ScreenTools.defaultFontPixelWidth)) {
                    centerX = mainWindow.width - indicatorPopup.width - ScreenTools.defaultFontPixelWidth
                }
                indicatorPopup.x = centerX
            }
        }
        onOpened: {
            loader.sourceComponent = indicatorPopup.currentIndicator
        }
        onClosed: {
            loader.sourceComponent = null
            indicatorPopup.currentIndicator = null
        }
    }
}

Reply to How to make full screen on Fri, 10 Feb 2023 14:38:59 GMT

serkan_tr — Fri, 10 Feb 2023 14:38:59 GMT

@serkan_tr QGCApplication.cpp


class FinishVideoInitialization : public QRunnable
{
public:
  FinishVideoInitialization(VideoManager* manager)
      : _manager(manager)
  {}

  void run () {
      _manager->_initVideo();
  }

private:
  VideoManager* _manager;
};


QGCApplication* QGCApplication::_app = nullptr;

const char* QGCApplication::_deleteAllSettingsKey           = "DeleteAllSettingsNextBoot";
const char* QGCApplication::_settingsVersionKey             = "SettingsVersion";

// Mavlink status structures for entire app
mavlink_status_t m_mavlink_status[MAVLINK_COMM_NUM_BUFFERS];

// Qml Singleton factories

static QObject* screenToolsControllerSingletonFactory(QQmlEngine*, QJSEngine*)
{
    ScreenToolsController* screenToolsController = new ScreenToolsController;
    return screenToolsController;
}

static QObject* mavlinkSingletonFactory(QQmlEngine*, QJSEngine*)
{
    return new QGCMAVLink();
}

static QObject* qgroundcontrolQmlGlobalSingletonFactory(QQmlEngine*, QJSEngine*)
{
    // We create this object as a QGCTool even though it isn't in the toolbox
    QGroundControlQmlGlobal* qmlGlobal = new QGroundControlQmlGlobal(qgcApp(), qgcApp()->toolbox());
    qmlGlobal->setToolbox(qgcApp()->toolbox());

    return qmlGlobal;
}

static QObject* shapeFileHelperSingletonFactory(QQmlEngine*, QJSEngine*)
{
    return new ShapeFileHelper;
}

QGCApplication::QGCApplication(int &argc, char* argv[], bool unitTesting)
    : QApplication          (argc, argv)
    , _runningUnitTests     (unitTesting)
{
    _app = this;
    _msecsElapsedTime.start();

#ifdef Q_OS_LINUX
#ifndef __mobile__
    if (!_runningUnitTests) {
        if (getuid() == 0) {
            _exitWithError(QString(
                tr("You are running %1 as root. "
                    "You should not do this since it will cause other issues with %1."
                    "%1 will now exit.

"
                    "If you are having serial port issues on Ubuntu, execute the following commands to fix most issues:
"
                    "sudo usermod -a -G dialout $USER
"
                    "sudo apt-get remove modemmanager").arg(qgcApp()->applicationName())));
            return;
        }
        // Determine if we have the correct permissions to access USB serial devices
        QFile permFile("/etc/group");
        if(permFile.open(QIODevice::ReadOnly)) {
            while(!permFile.atEnd()) {
                QString line = permFile.readLine();
                if (line.contains("dialout") && !line.contains(getenv("USER"))) {
                    permFile.close();
                    _exitWithError(QString(
                        tr("The current user does not have the correct permissions to access serial devices. "
                           "You should also remove modemmanager since it also interferes.

"
                           "If you are using Ubuntu, execute the following commands to fix these issues:
"
                           "sudo usermod -a -G dialout $USER
"
                           "sudo apt-get remove modemmanager")));
                    return;
                }
            }
            permFile.close();
        }

        // Always set style to default, this way QT_QUICK_CONTROLS_STYLE environment variable doesn't cause random changes in ui
        QQuickStyle::setStyle("Default");
    }
#endif
#endif

    // Setup for network proxy support
    QNetworkProxyFactory::setUseSystemConfiguration(true);

    // Parse command line options

    bool fClearSettingsOptions = false; // Clear stored settings
    bool fClearCache = false;           // Clear parameter/airframe caches
    bool logging = false;               // Turn on logging
    QString loggingOptions;

    CmdLineOpt_t rgCmdLineOptions[] = {
        { "--clear-settings",   &fClearSettingsOptions, nullptr },
        { "--clear-cache",      &fClearCache,           nullptr },
        { "--logging",          &logging,               &loggingOptions },
        { "--fake-mobile",      &_fakeMobile,           nullptr },
        { "--log-output",       &_logOutput,            nullptr },
        // Add additional command line option flags here
    };

    ParseCmdLineOptions(argc, argv, rgCmdLineOptions, sizeof(rgCmdLineOptions)/sizeof(rgCmdLineOptions[0]), false);

    // Set up timer for delayed missing fact display
    _missingParamsDelayedDisplayTimer.setSingleShot(true);
    _missingParamsDelayedDisplayTimer.setInterval(_missingParamsDelayedDisplayTimerTimeout);
    connect(&_missingParamsDelayedDisplayTimer, &QTimer::timeout, this, &QGCApplication::_missingParamsDisplay);

    // Set application information
    QString applicationName;
    if (_runningUnitTests) {
        // We don't want unit tests to use the same QSettings space as the normal app. So we tweak the app
        // name. Also we want to run unit tests with clean settings every time.
        applicationName = QStringLiteral("%1_unittest").arg(QGC_APPLICATION_NAME);
    } else {
#ifdef DAILY_BUILD
        // This gives daily builds their own separate settings space. Allowing you to use daily and stable builds
        // side by side without daily screwing up your stable settings.
        applicationName = QStringLiteral("%1 Daily").arg(QGC_APPLICATION_NAME);
#else
        applicationName = QGC_APPLICATION_NAME;
#endif
    }
    setApplicationName(applicationName);
    setOrganizationName(QGC_ORG_NAME);
    setOrganizationDomain(QGC_ORG_DOMAIN);

    this->setApplicationVersion(QString(APP_VERSION_STR));

    // Set settings format
    QSettings::setDefaultFormat(QSettings::IniFormat);
    QSettings settings;
    qDebug() << "*******Settings location" << settings.fileName() << "Is writable?:" << settings.isWritable();

#ifdef UNITTEST_BUILD
    if (!settings.isWritable()) {
        qWarning() << "Setings location is not writable";
    }
#endif
    // The setting will delete all settings on this boot
    fClearSettingsOptions |= settings.contains(_deleteAllSettingsKey);

    if (_runningUnitTests) {
        // Unit tests run with clean settings
        fClearSettingsOptions = true;
    }

    if (fClearSettingsOptions) {
        // User requested settings to be cleared on command line
        settings.clear();

        // Clear parameter cache
        QDir paramDir(ParameterManager::parameterCacheDir());
        paramDir.removeRecursively();
        paramDir.mkpath(paramDir.absolutePath());
    } else {
        // Determine if upgrade message for settings version bump is required. Check and clear must happen before toolbox is started since
        // that will write some settings.
        if (settings.contains(_settingsVersionKey)) {
            if (settings.value(_settingsVersionKey).toInt() != QGC_SETTINGS_VERSION) {
                settings.clear();
                _settingsUpgraded = true;
            }
        }
    }
    settings.setValue(_settingsVersionKey, QGC_SETTINGS_VERSION);

    if (fClearCache) {
        QDir dir(ParameterManager::parameterCacheDir());
        dir.removeRecursively();
        QFile airframe(cachedAirframeMetaDataFile());
        airframe.remove();
        QFile parameter(cachedParameterMetaDataFile());
        parameter.remove();
    }

    // Set up our logging filters
    QGCLoggingCategoryRegister::instance()->setFilterRulesFromSettings(loggingOptions);

    // Initialize Bluetooth
#ifdef QGC_ENABLE_BLUETOOTH
    QBluetoothLocalDevice localDevice;
    if (localDevice.isValid())
    {
        _bluetoothAvailable = true;
    }
#endif

    // Gstreamer debug settings
    int gstDebugLevel = 0;
    if (settings.contains(AppSettings::gstDebugLevelName)) {
        gstDebugLevel = settings.value(AppSettings::gstDebugLevelName).toInt();
    }

#if defined(QGC_GST_STREAMING)
    // Initialize Video Receiver
    GStreamer::initialize(argc, argv, gstDebugLevel);
#else
    Q_UNUSED(gstDebugLevel)
#endif

    // We need to set language as early as possible prior to loading on JSON files.
    setLanguage();

    _toolbox = new QGCToolbox(this);
    _toolbox->setChildToolboxes();

#ifndef __mobile__
    _gpsRtkFactGroup = new GPSRTKFactGroup(this);
   GPSManager *gpsManager = _toolbox->gpsManager();
   if (gpsManager) {
       connect(gpsManager, &GPSManager::onConnect,          this, &QGCApplication::_onGPSConnect);
       connect(gpsManager, &GPSManager::onDisconnect,       this, &QGCApplication::_onGPSDisconnect);
       connect(gpsManager, &GPSManager::surveyInStatus,     this, &QGCApplication::_gpsSurveyInStatus);
       connect(gpsManager, &GPSManager::satelliteUpdate,    this, &QGCApplication::_gpsNumSatellites);
   }
#endif /* __mobile__ */
    _checkForNewVersion();
}

Just step the constructor part because the code is too long

Reply to How to make full screen on Fri, 10 Feb 2023 14:34:25 GMT

serkan_tr — Fri, 10 Feb 2023 14:34:25 GMT

@serkan_tr main.cpp


int main(int argc, char *argv[])
{

    rclcpp::init(argc, argv);
    #ifndef __mobile__
        QString runguardString(QGC_APPLICATION_NAME);
        runguardString.append("RunGuardKey");

        RunGuard guard(runguardString);
        if (!guard.tryToRun()) {
            // QApplication is necessary to use QMessageBox
            QApplication errorApp(argc, argv);
            QMessageBox::critical(nullptr, QObject::tr("Error"),
                QObject::tr("A second instance of %1 is already running. Please close the other instance and try again.").arg(QGC_APPLICATION_NAME)
            );
            return -1;
        }
    #endif

        //-- Record boot time
        QGC::initTimer();

    #ifdef Q_OS_UNIX
        //Force writing to the console on UNIX/BSD devices
        if (!qEnvironmentVariableIsSet("QT_LOGGING_TO_CONSOLE"))
            qputenv("QT_LOGGING_TO_CONSOLE", "1");
    #endif

        // install the message handler
        AppMessages::installHandler();



    #ifdef Q_OS_WIN
        // Set our own OpenGL buglist
        qputenv("QT_OPENGL_BUGLIST", ":/opengl/resources/opengl/buglist.json");

        // Allow for command line override of renderer
        for (int i = 0; i < argc; i++) {
            const QString arg(argv[i]);
            if (arg == QStringLiteral("-angle")) {
                QCoreApplication::setAttribute(Qt::AA_UseOpenGLES);
                break;
            } else if (arg == QStringLiteral("-swrast")) {
                QCoreApplication::setAttribute(Qt::AA_UseSoftwareOpenGL);
                break;
            }
        }
    #endif


    #ifndef NO_SERIAL_LINK
        qRegisterMetaType();
    #endif
    #ifdef QGC_ENABLE_BLUETOOTH
        qRegisterMetaType();
        qRegisterMetaType();
    #endif
        qRegisterMetaType();
        qRegisterMetaType("Vehicle::MavCmdResultFailureCode_t");

        // We statically link our own QtLocation plugin

    #ifdef Q_OS_WIN
        // In Windows, the compiler doesn't see the use of the class created by Q_IMPORT_PLUGIN
    #pragma warning( disable : 4930 4101 )
    #endif

    Q_IMPORT_PLUGIN(QGeoServiceProviderFactoryQGC)

    bool runUnitTests = false;          // Run unit tests


    QCoreApplication::setAttribute(Qt::AA_UseHighDpiPixmaps);
    QGCApplication* app = new QGCApplication(argc, argv, runUnitTests);
    Q_CHECK_PTR(app);
    if(app->isErrorState()) {
        app->exec();
        return -1;
    }

    // #ifdef Q_OS_LINUX

    QApplication::setWindowIcon(QIcon(":/res/resources/icons/qgroundcontrol.ico"));
    getQGCMapEngine()->init();
    qRegisterMetaType > >();
    app->_initCommon();

    int exitCode = 0;
    {
    #ifdef UNITTEST_BUILD
        if (runUnitTests) {
            for (int i=0; i < (stressUnitTests ? 20 : 1); i++) {
                if (!app->_initForUnitTests()) {
                    return -1;
                }

                // Run the test
                int failures = UnitTest::run(unitTestOptions);
                if (failures == 0) {
                    qDebug() << "ALL TESTS PASSED";
                    exitCode = 0;
                } else {
                    qDebug() << failures << " TESTS FAILED!";
                    exitCode = -failures;
                    break;
                }
            }
        } else
    #endif
    }

    {

    #ifdef __android__
            checkAndroidWritePermission();
    #endif
        if (!app->_initForNormalAppBoot()) {
            return -1;
        }
        exitCode = app->exec();
    }

    app->_shutdown();
    delete app;
    //-- Shutdown Cache System
    destroyMapEngine();

    rclcpp::shutdown();

    qDebug() << "After app delete";
    return exitCode;
}