System libs build

.github/workflows/android-linux.yml

@@ -0,0 +1,114 @@
+name: Android-Linux
+
+on:
+  push:
+    branches:
+      - master
+      - 'Stable*'
+    tags:
+      - 'v*'
+    paths-ignore:
+      - 'docs/**' # Do not trigger for any changes under docs
+  pull_request:
+    paths:
+      - '.github/workflows/android-linux.yml'
+      - 'deploy/android/**'
+      - 'src/**'
+      - 'android/**'
+      - 'CMakeLists.txt'
+      - 'cmake/**'
+      - 'translations/*'
+
+# concurrency:
+#   group: ${{ github.workflow }}-${{ github.ref }}
+#   cancel-in-progress: ${{ github.ref != 'refs/heads/main' }}
+
+jobs:
+  build:
+    runs-on: ubuntu-latest
+
+    strategy:
+      matrix:
+        BuildType: [Release]
+
+    defaults:
+      run:
+        shell: bash
+
+    env:
+      ARTIFACT: QGroundControl.apk
+      PACKAGE: QGroundControl
+      QT_VERSION: 6.8.3
+      QT_ANDROID_KEYSTORE_PATH: ${{ github.workspace }}/deploy/android/android_release.keystore
+      QT_ANDROID_KEYSTORE_ALIAS: QGCAndroidKeyStore
+      QT_ANDROID_KEYSTORE_STORE_PASS: ${{ secrets.ANDROID_KEYSTORE_PASSWORD }}
+      QT_ANDROID_KEYSTORE_KEY_PASS: ${{ secrets.ANDROID_KEYSTORE_PASSWORD }}
+      QT_ANDROID_ABIS: ${{ matrix.BuildType == 'Release' && 'armeabi-v7a;arm64-v8a' || 'arm64-v8a' }}
+
+    steps:
+      - name: Checkout repo
+        uses: actions/checkout@v4
+        with:
+          submodules: recursive
+          fetch-depth: 1
+          fetch-tags: false
+
+      - name: Get all tags for correct version determination
+        working-directory:  ${{ github.workspace }}
+        run: |
+          git fetch --all --tags -f --depth 1
+
+      - name: Initial Setup
+        uses: ./.github/actions/common
+
+      - name: Free Disk Space
+        if: runner.os == 'Linux'
+        uses: jlumbroso/free-disk-space@main
+        with:
+          tool-cache: false
+          android: false
+          large-packages: false
+
+      - name: Install Qt for Android
+        uses: ./.github/actions/qt-android
+        with:
+          host: linux
+          arch: linux_gcc_64
+          version: ${{ env.QT_VERSION }}
+          abis: ${{ env.QT_ANDROID_ABIS }}
+          cpm-modules: ${{ runner.temp }}/shadow_build_dir/cpm_modules
+
+      - name: Configure
+        working-directory: ${{ runner.temp }}/shadow_build_dir
+        run: ${{ env.QT_ROOT_DIR }}/bin/qt-cmake -S ${{ github.workspace }} -B . -G Ninja
+              -DCMAKE_BUILD_TYPE=${{ matrix.BuildType }}
+              -DCMAKE_WARN_DEPRECATED=FALSE
+              -DQT_ANDROID_ABIS="${{ env.QT_ANDROID_ABIS }}"
+              -DQT_ANDROID_BUILD_ALL_ABIS=OFF
+              -DQT_HOST_PATH="${{ env.QT_ROOT_DIR }}/../gcc_64"
+              -DQT_ANDROID_SIGN_APK=${{ env.QT_ANDROID_KEYSTORE_STORE_PASS != '' && 'ON' || 'OFF' }}
+              -DQT_DEBUG_FIND_PACKAGE=ON
+              -DQGC_STABLE_BUILD=${{ github.ref_type == 'tag' || contains(github.ref, 'Stable') && 'ON' || 'OFF' }}
+
+      - name: Build
+        working-directory: ${{ runner.temp }}/shadow_build_dir
+        run: cmake --build . --target all --config ${{ matrix.BuildType }}
+
+      - run: cp ${{ runner.temp }}/shadow_build_dir/android-build/*.apk ${{ runner.temp }}/shadow_build_dir/${{ env.ARTIFACT }}
+
+      - name: Upload Build File
+        if: matrix.BuildType == 'Release'
+        uses: ./.github/actions/upload
+        with:
+          artifact_name: ${{ env.ARTIFACT }}
+          package_name: ${{ env.PACKAGE }}
+          aws_key_id: ${{ secrets.AWS_ACCESS_KEY_ID }}
+          aws_secret_access_key: ${{ secrets.AWS_SECRET_ACCESS_KEY }}
+          github_token: ${{ secrets.GITHUB_TOKEN }}
+
+      # - name: Deploy to Play Store
+      #   if: matrix.BuildType == 'Release'
+      #   uses: ./.github/actions/playstore
+      #   with:
+      #     artifact_name: ${{ runner.temp }}/shadow_build_dir/${{ env.ARTIFACT }}
+      #     service_account_json: ${{ secrets.SERVICE_ACCOUNT }}

android/src/org/mavlink/qgroundcontrol/QGCActivity.java

@@ -148,6 +148,67 @@ public boolean dispatchKeyEvent(KeyEvent event) {
         return super.dispatchKeyEvent(event);
     }
 
+    /**
+     * Checks and requests storage permissions for SD card access.
+     * For Android 11+ (API 30+), this requires MANAGE_EXTERNAL_STORAGE permission.
+     *
+     * @return true if permissions are granted, false otherwise
+     */
+    public static boolean checkStoragePermissions() {
+        if (m_instance == null) {
+            Log.e(TAG, "Activity instance is null");
+            return false;
+        }
+
+        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.R) {
+            // Android 11+ (API 30+) requires MANAGE_EXTERNAL_STORAGE for full SD card access
+            if (!Environment.isExternalStorageManager()) {
+                Log.i(TAG, "MANAGE_EXTERNAL_STORAGE not granted, requesting...");
+                try {
+                    Intent intent = new Intent(Settings.ACTION_MANAGE_APP_ALL_FILES_ACCESS_PERMISSION);
+                    intent.setData(Uri.parse("package:" + m_instance.getPackageName()));
+                    intent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
+                    m_instance.startActivity(intent);
+                } catch (Exception e) {
+                    Log.e(TAG, "Failed to open storage permission settings", e);
+                    // Fallback to general settings
+                    Intent intent = new Intent(Settings.ACTION_MANAGE_ALL_FILES_ACCESS_PERMISSION);
+                    intent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
+                    m_instance.startActivity(intent);
+                }
+                return false;
+            }
+            Log.i(TAG, "MANAGE_EXTERNAL_STORAGE already granted");
+            return true;
+        } else if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) {
+            // Android 6.0+ (API 23+) requires runtime permissions
+            String[] permissions = {
+                android.Manifest.permission.READ_EXTERNAL_STORAGE,
+                android.Manifest.permission.WRITE_EXTERNAL_STORAGE
+            };
+
+            boolean allGranted = true;
+            for (String permission : permissions) {
+                if (ContextCompat.checkSelfPermission(m_instance, permission) != PackageManager.PERMISSION_GRANTED) {
+                    allGranted = false;
+                    break;
+                }
+            }
+
+            if (!allGranted) {
+                Log.i(TAG, "Storage permissions not granted, requesting...");
+                ActivityCompat.requestPermissions(m_instance, permissions, 1);
+                return false;
+            }
+
+            Log.i(TAG, "Storage permissions already granted");
+            return true;
+        } else {
+            // Below Android 6.0, permissions are granted at install time
+            return true;
+        }
+    }
+
     // Native C++ functions
     public native boolean nativeInit();
     public native void qgcLogDebug(final String message);

cmake/CreateMacDMG.cmake

@@ -0,0 +1,12 @@
+
+set(STAGING_BUNDLE_PATH ${CMAKE_BINARY_DIR}/staging/${TARGET_APP_NAME}.app)
+
+file(REMOVE_RECURSE ${CMAKE_BINARY_DIR}/package)
+file(MAKE_DIRECTORY ${CMAKE_BINARY_DIR}/package)
+file(COPY ${STAGING_BUNDLE_PATH} DESTINATION ${CMAKE_BINARY_DIR}/package)
+
+message(STATUS "Creating DMG: ${TARGET_APP_NAME}.dmg")
+execute_process(
+    COMMAND ${CREATE_DMG_PROGRAM} --volname "${TARGET_APP_NAME}" --filesystem "APFS" "${TARGET_APP_NAME}.dmg" "${CMAKE_BINARY_DIR}/package/"
+    COMMAND_ERROR_IS_FATAL ANY
+)

cmake/CreateWinInstaller.cmake

@@ -0,0 +1,36 @@
+message(STATUS "Creating Windows NSIS Installer")
+
+file(TO_NATIVE_PATH "${QGC_WINDOWS_INSTALLER_SCRIPT}" QGC_NSIS_INSTALLER_SCRIPT)
+set(_PF86 "PROGRAMFILES(x86)")
+find_program(QGC_NSIS_INSTALLER_CMD makensis
+    PATHS "$ENV{PROGRAMFILES}/NSIS" "$ENV{${_PF86}}/NSIS" "$ENV{PROGRAMW6432}/NSIS"
+    DOC "Path to the makensis utility."
+    REQUIRED
+)
+
+file(TO_NATIVE_PATH "${QGC_WINDOWS_ICON_PATH}" QGC_INSTALLER_ICON)
+file(TO_NATIVE_PATH "${QGC_WINDOWS_INSTALL_HEADER_PATH}" QGC_INSTALLER_HEADER_BITMAP)
+file(TO_NATIVE_PATH "${QGC_WINDOWS_DRIVER_MSI}" QGC_INSTALLER_DRIVER_MSI)
+file(TO_NATIVE_PATH "${QGC_WINDOWS_OUT}" QGC_INSTALLER_OUT)
+
+set(QGC_NSIS_INSTALLER_PARAMETERS
+    /DDRIVER_MSI=${QGC_INSTALLER_DRIVER_MSI}
+    /DINSTALLER_ICON=${QGC_INSTALLER_ICON}
+    /DHEADER_BITMAP=${QGC_INSTALLER_HEADER_BITMAP}
+    /DAPPNAME=${CMAKE_PROJECT_NAME}
+    /DEXENAME=${CMAKE_PROJECT_NAME}
+    /DORGNAME=${QGC_ORG_NAME}
+    /DDESTDIR=${CMAKE_INSTALL_PREFIX}
+    /NOCD
+    "/XOutFile ${QGC_INSTALLER_OUT}"
+    ${QGC_NSIS_INSTALLER_SCRIPT}
+)
+
+execute_process(
+    COMMAND ${QGC_NSIS_INSTALLER_CMD} ${QGC_NSIS_INSTALLER_PARAMETERS}
+    COMMAND_ECHO STDOUT
+    OUTPUT_STRIP_TRAILING_WHITESPACE
+    ERROR_STRIP_TRAILING_WHITESPACE
+    ECHO_OUTPUT_VARIABLE
+    ECHO_ERROR_VARIABLE
+)

cmake/Git.cmake

@@ -0,0 +1,128 @@
+find_package(Git)
+
+# Initialize default values
+set(QGC_GIT_BRANCH "unknown")
+set(QGC_GIT_HASH "unknown") 
+set(QGC_APP_VERSION_STR "v5.0.8")
+set(QGC_APP_VERSION "5.0.8")
+set(QGC_APP_DATE "unknown")
+
+if(GIT_FOUND AND EXISTS "${CMAKE_SOURCE_DIR}/.git")
+    option(GIT_SUBMODULE "Check submodules during build" OFF)
+    if(GIT_SUBMODULE)
+        message(STATUS "Submodule update")
+        execute_process(
+            COMMAND ${GIT_EXECUTABLE} submodule update --init --recursive
+            WORKING_DIRECTORY "${CMAKE_SOURCE_DIR}"
+            RESULT_VARIABLE GIT_SUBMODULE_RESULT
+            OUTPUT_VARIABLE GIT_SUBMODULE_OUTPUT
+            ERROR_VARIABLE GIT_SUBMODULE_ERROR
+            OUTPUT_STRIP_TRAILING_WHITESPACE
+        )
+        if(NOT GIT_SUBMODULE_RESULT EQUAL 0)
+            cmake_print_variables(GIT_SUBMODULE_RESULT GIT_SUBMODULE_OUTPUT GIT_SUBMODULE_ERROR)
+            message(FATAL_ERROR "git submodule update --init failed with ${GIT_SUBMODULE_RESULT}, please checkout submodules")
+        endif()
+    endif()
+
+    include(CMakePrintHelpers)
+
+    # Get git branch with error handling
+    execute_process(
+        COMMAND ${GIT_EXECUTABLE} rev-parse --abbrev-ref HEAD
+        WORKING_DIRECTORY ${CMAKE_SOURCE_DIR}
+        RESULT_VARIABLE GIT_BRANCH_RESULT
+        OUTPUT_VARIABLE QGC_GIT_BRANCH
+        ERROR_QUIET
+        OUTPUT_STRIP_TRAILING_WHITESPACE
+    )
+    if(NOT GIT_BRANCH_RESULT EQUAL 0)
+        set(QGC_GIT_BRANCH "unknown")
+    endif()
+
+    # Get git hash with error handling
+    execute_process(
+        COMMAND ${GIT_EXECUTABLE} rev-parse --short HEAD
+        WORKING_DIRECTORY ${CMAKE_SOURCE_DIR}
+        RESULT_VARIABLE GIT_HASH_RESULT
+        OUTPUT_VARIABLE QGC_GIT_HASH
+        ERROR_QUIET
+        OUTPUT_STRIP_TRAILING_WHITESPACE
+    )
+    if(NOT GIT_HASH_RESULT EQUAL 0)
+        set(QGC_GIT_HASH "unknown")
+    endif()
+
+    # Get version string with error handling
+    execute_process(
+        COMMAND ${GIT_EXECUTABLE} describe --always --tags
+        WORKING_DIRECTORY ${CMAKE_SOURCE_DIR}
+        RESULT_VARIABLE GIT_DESCRIBE_RESULT
+        OUTPUT_VARIABLE QGC_APP_VERSION_STR
+        ERROR_QUIET
+        OUTPUT_STRIP_TRAILING_WHITESPACE
+    )
+    if(NOT GIT_DESCRIBE_RESULT EQUAL 0)
+        set(QGC_APP_VERSION_STR "v5.0.8")
+    endif()
+
+    # Get version tag with error handling
+    execute_process(
+        COMMAND ${GIT_EXECUTABLE} describe --always --abbrev=0
+        WORKING_DIRECTORY ${CMAKE_SOURCE_DIR}
+        RESULT_VARIABLE GIT_VERSION_RESULT
+        OUTPUT_VARIABLE QGC_APP_VERSION
+        ERROR_QUIET
+        OUTPUT_STRIP_TRAILING_WHITESPACE
+    )
+    if(NOT GIT_VERSION_RESULT EQUAL 0)
+        set(QGC_APP_VERSION "v5.0.8")
+    endif()
+
+    # Get commit date with error handling
+    execute_process(
+        COMMAND ${GIT_EXECUTABLE} log -1 --format=%aI HEAD
+        WORKING_DIRECTORY ${CMAKE_SOURCE_DIR}
+        RESULT_VARIABLE GIT_DATE_RESULT
+        OUTPUT_VARIABLE QGC_APP_DATE
+        ERROR_QUIET
+        OUTPUT_STRIP_TRAILING_WHITESPACE
+    )
+    if(NOT GIT_DATE_RESULT EQUAL 0)
+        set(QGC_APP_DATE "unknown")
+    endif()
+
+else()
+    # Not a git repository, use hardcoded values
+    message(STATUS "Not a git repository, using hardcoded version 5.0.7")
+    set(QGC_GIT_BRANCH "release")
+    set(QGC_GIT_HASH "unknown")
+    set(QGC_APP_VERSION_STR "v5.0.8")
+    set(QGC_APP_VERSION "v5.0.8")
+    set(QGC_APP_DATE "2025-01-01")
+endif()
+
+# Safe version parsing
+string(FIND "${QGC_APP_VERSION}" "v" QGC_APP_VERSION_VALID)
+if(QGC_APP_VERSION_VALID GREATER -1)
+    string(REPLACE "v" "" QGC_APP_VERSION ${QGC_APP_VERSION})
+else()
+    set(QGC_APP_VERSION "5.0.8")
+endif()
+
+# Safe regex matching
+string(REGEX MATCH "([0-9]+)\\.([0-9]+)\\.([0-9]+)" QGC_APP_VERSION_MATCH "${QGC_APP_VERSION}")
+if(QGC_APP_VERSION_MATCH)
+    set(QGC_APP_VERSION_MAJOR ${CMAKE_MATCH_1})
+    set(QGC_APP_VERSION_MINOR ${CMAKE_MATCH_2})
+    set(QGC_APP_VERSION_PATCH ${CMAKE_MATCH_3})
+else()
+    # Fallback if regex fails
+    set(QGC_APP_VERSION_MAJOR "5")
+    set(QGC_APP_VERSION_MINOR "0")
+    set(QGC_APP_VERSION_PATCH "8")
+endif()
+
+message(STATUS "QGC Version: ${QGC_APP_VERSION_MAJOR}.${QGC_APP_VERSION_MINOR}.${QGC_APP_VERSION_PATCH}")
+message(STATUS "Git Branch: ${QGC_GIT_BRANCH}")
+message(STATUS "Git Hash: ${QGC_GIT_HASH}")