Merge branch 'dev' into nfcf

.github/workflows/amap_analyse.yml

@@ -1,103 +0,0 @@
-name: 'Analyze .map file with Amap'
-
-on:
-  push:
-    branches:
-      - dev
-      - "release*"
-    tags:
-      - '*'
-  pull_request:
-
-env:
-  TARGETS: f7
-  FBT_TOOLCHAIN_PATH: /opt
-
-jobs:
-  amap_analyse:
-    if: ${{ !github.event.pull_request.head.repo.fork }}
-    runs-on: [self-hosted,FlipperZeroMacShell]
-    timeout-minutes: 15
-    steps:
-      - name: 'Wait Build workflow'
-        uses: fountainhead/action-wait-for-check@v1.0.0
-        id: wait-for-build
-        with:
-          token: ${{ secrets.GITHUB_TOKEN }}
-          checkName: 'main'
-          ref: ${{ github.event.pull_request.head.sha || github.sha }}
-          intervalSeconds: 20
-
-      - name: 'Check Build workflow status'
-        if: steps.wait-for-build.outputs.conclusion == 'failure'
-        run: |
-          exit 1
-
-      - name: 'Decontaminate previous build leftovers'
-        run: |
-          if [ -d .git ]; then
-            git submodule status || git checkout "$(git rev-list --max-parents=0 HEAD | tail -n 1)"
-          fi
-
-      - name: 'Checkout code'
-        uses: actions/checkout@v3
-        with:
-          fetch-depth: 0
-          ref: ${{ github.event.pull_request.head.sha }}
-
-      - name: 'Get commit details'
-        run: |
-          if [[ ${{ github.event_name }} == 'pull_request' ]]; then
-            TYPE="pull"
-          elif [[ "${{ github.ref }}" == "refs/tags/"* ]]; then
-            TYPE="tag"
-          else
-            TYPE="other"
-          fi
-          python3 scripts/get_env.py "--event_file=${{ github.event_path }}" "--type=$TYPE"
-
-      - name: 'Make artifacts directory'
-        run: |
-          rm -rf artifacts
-          mkdir artifacts
-
-      - name: 'Download build artifacts'
-        run: |
-          mkdir -p ~/.ssh
-          ssh-keyscan -p ${{ secrets.RSYNC_DEPLOY_PORT }} -H ${{ secrets.RSYNC_DEPLOY_HOST }} > ~/.ssh/known_hosts
-          echo "${{ secrets.RSYNC_DEPLOY_KEY }}" > deploy_key;
-          chmod 600 ./deploy_key;
-          rsync -avzP \
-              -e 'ssh -p ${{ secrets.RSYNC_DEPLOY_PORT }} -i ./deploy_key' \
-              ${{ secrets.RSYNC_DEPLOY_USER }}@${{ secrets.RSYNC_DEPLOY_HOST }}:"${{ secrets.RSYNC_DEPLOY_BASE_PATH }}${BRANCH_NAME}/" artifacts/;
-          rm ./deploy_key;
-
-      - name: 'Make .map file analyze'
-        run: |
-          cd artifacts/
-          /Applications/amap/Contents/MacOS/amap -f "flipper-z-f7-firmware-${SUFFIX}.elf.map"
-
-      - name: 'Upload report to DB'
-        run: |
-          source scripts/toolchain/fbtenv.sh
-          get_size()
-          {
-            SECTION="$1";
-            arm-none-eabi-size \
-              -A artifacts/flipper-z-f7-firmware-$SUFFIX.elf \
-              | grep "^$SECTION" | awk '{print $2}'
-          }
-          export BSS_SIZE="$(get_size ".bss")"
-          export TEXT_SIZE="$(get_size ".text")"
-          export RODATA_SIZE="$(get_size ".rodata")"
-          export DATA_SIZE="$(get_size ".data")"
-          export FREE_FLASH_SIZE="$(get_size ".free_flash")"
-          python3 -m pip install mariadb==1.1.4
-          python3 scripts/amap_mariadb_insert.py \
-            ${{ secrets.AMAP_MARIADB_USER }} \
-            ${{ secrets.AMAP_MARIADB_PASSWORD }} \
-            ${{ secrets.AMAP_MARIADB_HOST }} \
-            ${{ secrets.AMAP_MARIADB_PORT }} \
-            ${{ secrets.AMAP_MARIADB_DATABASE }} \
-            artifacts/flipper-z-f7-firmware-$SUFFIX.elf.map.all
-

.github/workflows/build.yml

@@ -30,11 +30,6 @@ jobs:
           fetch-depth: 0
           ref: ${{ github.event.pull_request.head.sha }}
 
-      - name: 'Make artifacts directory'
-        run: |
-          rm -rf artifacts
-          mkdir artifacts
-
       - name: 'Get commit details'
         id: names
         run: |
@@ -46,6 +41,15 @@ jobs:
             TYPE="other"
           fi
           python3 scripts/get_env.py "--event_file=${{ github.event_path }}" "--type=$TYPE"
+          echo random_hash=$(openssl rand -base64 40 | shasum -a 256 | awk '{print $1}') >> $GITHUB_OUTPUT
+          echo "event_type=$TYPE" >> $GITHUB_OUTPUT
+
+      - name: 'Make artifacts directory'
+        run: |
+          rm -rf artifacts
+          rm -rf map_analyser_files
+          mkdir artifacts
+          mkdir map_analyser_files
 
       - name: 'Bundle scripts'
         if: ${{ !github.event.pull_request.head.repo.fork }}
@@ -82,9 +86,33 @@ jobs:
         run: |
           cp build/core2_firmware.tgz "artifacts/flipper-z-any-core2_firmware-${SUFFIX}.tgz"
 
-      - name: 'Copy .map file'
+      - name: 'Copy map analyser files'
+        if: ${{ !github.event.pull_request.head.repo.fork }}
         run: |
-          cp build/f7-firmware-*/firmware.elf.map "artifacts/flipper-z-f7-firmware-${SUFFIX}.elf.map"
+          cp build/f7-firmware-*/firmware.elf.map map_analyser_files/firmware.elf.map
+          cp build/f7-firmware-*/firmware.elf map_analyser_files/firmware.elf
+          cp ${{ github.event_path }} map_analyser_files/event.json
+
+      - name: 'Upload map analyser files to storage'
+        if: ${{ !github.event.pull_request.head.repo.fork }}
+        uses: keithweaver/aws-s3-github-action@v1.0.0
+        with:
+          source: map_analyser_files/
+          destination: "s3://${{ secrets.MAP_REPORT_AWS_BUCKET }}/${{steps.names.outputs.random_hash}}"
+          aws_access_key_id: "${{ secrets.MAP_REPORT_AWS_ACCESS_KEY }}"
+          aws_secret_access_key: "${{ secrets.MAP_REPORT_AWS_SECRET_KEY }}"
+          aws_region: "${{ secrets.MAP_REPORT_AWS_REGION }}"
+          flags: --recursive
+
+      - name: 'Trigger map file reporter'
+        if: ${{ !github.event.pull_request.head.repo.fork }}
+        uses: peter-evans/repository-dispatch@v2
+        with:
+          repository: flipperdevices/flipper-map-reporter
+          token: ${{ secrets.REPOSITORY_DISPATCH_TOKEN }}
+          event-type: map-file-analyse
+          client-payload: '{"random_hash": "${{steps.names.outputs.random_hash}}", "event_type": "${{steps.names.outputs.event_type}}"}'
+
 
       - name: 'Upload artifacts to update server'
         if: ${{ !github.event.pull_request.head.repo.fork }}

.github/workflows/pvs_studio.yml

@@ -50,7 +50,7 @@ jobs:
 
       - name: 'Generate compile_comands.json'
         run: |
-          ./fbt COMPACT=1 version_json proto_ver icons firmware_cdb dolphin_internal dolphin_blocking _fap_icons
+          ./fbt COMPACT=1 version_json proto_ver icons firmware_cdb dolphin_internal dolphin_blocking _fap_icons api_syms
 
       - name: 'Static code analysis'
         run: |
@@ -58,15 +58,25 @@ jobs:
           pvs-studio-analyzer credentials ${{ secrets.PVS_STUDIO_CREDENTIALS }}
           pvs-studio-analyzer analyze \
               @.pvsoptions \
+              -C gccarm \
               -j$(grep -c processor /proc/cpuinfo) \
               -f build/f7-firmware-DC/compile_commands.json \
               -o PVS-Studio.log
 
-      - name: 'Convert PVS-Studio output to html page'
-        run: plog-converter -a GA:1,2,3 -t fullhtml PVS-Studio.log -o reports/${DEFAULT_TARGET}-${SUFFIX}
+      - name: 'Convert PVS-Studio output to html and detect warnings'
+        id: pvs-warn
+        run: |
+          WARNINGS=0
+          plog-converter \
+              -a GA:1,2,3 \
+              -t fullhtml \
+              --indicate-warnings \
+              PVS-Studio.log \
+              -o reports/${DEFAULT_TARGET}-${SUFFIX} || WARNINGS=1
+          echo "warnings=${WARNINGS}" >> $GITHUB_OUTPUT
 
       - name: 'Upload artifacts to update server'
-        if: ${{ !github.event.pull_request.head.repo.fork }}
+        if: ${{ !github.event.pull_request.head.repo.fork && (steps.pvs-warn.outputs.warnings != 0) }}
         run: |
           mkdir -p ~/.ssh
           ssh-keyscan -p ${{ secrets.RSYNC_DEPLOY_PORT }} -H ${{ secrets.RSYNC_DEPLOY_HOST }} > ~/.ssh/known_hosts
@@ -78,8 +88,8 @@ jobs:
           rm ./deploy_key;
 
       - name: 'Find Previous Comment'
-        if: ${{ !github.event.pull_request.head.repo.fork && github.event.pull_request }}
-        uses: peter-evans/find-comment@v1
+        if: ${{ !github.event.pull_request.head.repo.fork && github.event.pull_request && (steps.pvs-warn.outputs.warnings != 0) }}
+        uses: peter-evans/find-comment@v2
         id: fc
         with:
           issue-number: ${{ github.event.pull_request.number }}
@@ -87,7 +97,7 @@ jobs:
           body-includes: 'PVS-Studio report for commit'
 
       - name: 'Create or update comment'
-        if: ${{ !github.event.pull_request.head.repo.fork && github.event.pull_request}}
+        if: ${{ !github.event.pull_request.head.repo.fork && github.event.pull_request && (steps.pvs-warn.outputs.warnings != 0) }}
         uses: peter-evans/create-or-update-comment@v1
         with:
           comment-id: ${{ steps.fc.outputs.comment-id }}
@@ -96,3 +106,10 @@ jobs:
             **PVS-Studio report for commit `${{steps.names.outputs.commit_sha}}`:**
             - [Report](https://update.flipperzero.one/builds/firmware-pvs-studio-report/${{steps.names.outputs.branch_name}}/${{steps.names.outputs.default_target}}-${{steps.names.outputs.suffix}}/index.html)
           edit-mode: replace
+
+      - name: 'Raise exception'
+        if: ${{ steps.pvs-warn.outputs.warnings != 0 }}
+        run: |
+          echo "Please fix all PVS varnings before merge"
+          exit 1
+

.pvsconfig

@@ -1,4 +1,5 @@
 # MLib macros we can't do much about.
+//-V:M_LET:1048,1044
 //-V:M_EACH:1048,1044
 //-V:ARRAY_DEF:760,747,568,776,729,712,654
 //-V:LIST_DEF:760,747,568,712,729,654,776
@@ -16,8 +17,30 @@
 # Potentially null argument warnings
 //-V:memset:575
 //-V:memcpy:575
+//-V:memcmp:575
+//-V:strlen:575
 //-V:strcpy:575
+//-V:strncpy:575
 //-V:strchr:575
 
 # For loop warning on M_FOREACH
 //-V:for:1044
+
+# Bitwise OR
+//-V:bit:792
+
+# Do not complain about similar code
+//-V::525
+
+# Common embedded development pointer operations
+//-V::566
+//-V::1032
+
+# Warnings about length mismatch
+//-V:property_value_out:666
+
+# Model-related warnings
+//-V:with_view_model:1044,1048
+
+# Functions that always return the same error code
+//-V:picopass_device_decrypt:1048

.pvsoptions

@@ -1 +1 @@
---rules-config .pvsconfig -e lib/fatfs -e lib/fnv1a-hash -e lib/FreeRTOS-Kernel -e lib/heatshrink -e lib/libusb_stm32 -e lib/littlefs -e lib/mbedtls -e lib/micro-ecc -e lib/microtar -e lib/mlib -e lib/qrcode -e lib/ST25RFAL002 -e lib/STM32CubeWB -e lib/u8g2 -e */arm-none-eabi/*
+--rules-config .pvsconfig -e lib/fatfs -e lib/fnv1a-hash -e lib/FreeRTOS-Kernel -e lib/heatshrink -e lib/libusb_stm32 -e lib/littlefs -e lib/mbedtls -e lib/micro-ecc -e lib/microtar -e lib/mlib -e lib/qrcode -e lib/ST25RFAL002 -e lib/STM32CubeWB -e lib/u8g2 -e lib/nanopb -e */arm-none-eabi/* -e applications/plugins/dap_link/lib/free-dap

applications/debug/unit_tests/float_tools/float_tools_test.c

@@ -0,0 +1,60 @@
+#include <float.h>
+#include <float_tools.h>
+
+#include "../minunit.h"
+
+MU_TEST(float_tools_equal_test) {
+    mu_check(float_is_equal(FLT_MAX, FLT_MAX));
+    mu_check(float_is_equal(FLT_MIN, FLT_MIN));
+    mu_check(float_is_equal(-FLT_MAX, -FLT_MAX));
+    mu_check(float_is_equal(-FLT_MIN, -FLT_MIN));
+
+    mu_check(!float_is_equal(FLT_MIN, FLT_MAX));
+    mu_check(!float_is_equal(-FLT_MIN, FLT_MAX));
+    mu_check(!float_is_equal(FLT_MIN, -FLT_MAX));
+    mu_check(!float_is_equal(-FLT_MIN, -FLT_MAX));
+
+    const float pi = 3.14159f;
+    mu_check(float_is_equal(pi, pi));
+    mu_check(float_is_equal(-pi, -pi));
+    mu_check(!float_is_equal(pi, -pi));
+    mu_check(!float_is_equal(-pi, pi));
+
+    const float one_third = 1.f / 3.f;
+    const float one_third_dec = 0.3333333f;
+    mu_check(one_third != one_third_dec);
+    mu_check(float_is_equal(one_third, one_third_dec));
+
+    const float big_num = 1.e12f;
+    const float med_num = 95.389f;
+    const float smol_num = 1.e-12f;
+    mu_check(float_is_equal(big_num, big_num));
+    mu_check(float_is_equal(med_num, med_num));
+    mu_check(float_is_equal(smol_num, smol_num));
+    mu_check(!float_is_equal(smol_num, big_num));
+    mu_check(!float_is_equal(med_num, smol_num));
+    mu_check(!float_is_equal(big_num, med_num));
+
+    const float more_than_one = 1.f + FLT_EPSILON;
+    const float less_than_one = 1.f - FLT_EPSILON;
+    mu_check(!float_is_equal(more_than_one, less_than_one));
+    mu_check(!float_is_equal(more_than_one, -less_than_one));
+    mu_check(!float_is_equal(-more_than_one, less_than_one));
+    mu_check(!float_is_equal(-more_than_one, -less_than_one));
+
+    const float slightly_more_than_one = 1.f + FLT_EPSILON / 2.f;
+    const float slightly_less_than_one = 1.f - FLT_EPSILON / 2.f;
+    mu_check(float_is_equal(slightly_more_than_one, slightly_less_than_one));
+    mu_check(float_is_equal(-slightly_more_than_one, -slightly_less_than_one));
+    mu_check(!float_is_equal(slightly_more_than_one, -slightly_less_than_one));
+    mu_check(!float_is_equal(-slightly_more_than_one, slightly_less_than_one));
+}
+
+MU_TEST_SUITE(float_tools_suite) {
+    MU_RUN_TEST(float_tools_equal_test);
+}
+
+int run_minunit_test_float_tools() {
+    MU_RUN_SUITE(float_tools_suite);
+    return MU_EXIT_CODE;
+}

applications/debug/unit_tests/subghz/subghz_test.c

@@ -13,7 +13,7 @@
 #define CAME_ATOMO_DIR_NAME EXT_PATH("subghz/assets/came_atomo")
 #define NICE_FLOR_S_DIR_NAME EXT_PATH("subghz/assets/nice_flor_s")
 #define TEST_RANDOM_DIR_NAME EXT_PATH("unit_tests/subghz/test_random_raw.sub")
-#define TEST_RANDOM_COUNT_PARSE 253
+#define TEST_RANDOM_COUNT_PARSE 273
 #define TEST_TIMEOUT 10000
 
 static SubGhzEnvironment* environment_handler;
@@ -597,6 +597,13 @@ MU_TEST(subghz_decoder_smc5326_test) {
         "Test decoder " SUBGHZ_PROTOCOL_SMC5326_NAME " error\r\n");
 }
 
+MU_TEST(subghz_decoder_holtek_ht12x_test) {
+    mu_assert(
+        subghz_decoder_test(
+            EXT_PATH("unit_tests/subghz/holtek_ht12x_raw.sub"), SUBGHZ_PROTOCOL_HOLTEK_HT12X_NAME),
+        "Test decoder " SUBGHZ_PROTOCOL_HOLTEK_HT12X_NAME " error\r\n");
+}
+
 //test encoders
 MU_TEST(subghz_encoder_princeton_test) {
     mu_assert(
@@ -730,6 +737,12 @@ MU_TEST(subghz_encoder_smc5326_test) {
         "Test encoder " SUBGHZ_PROTOCOL_SMC5326_NAME " error\r\n");
 }
 
+MU_TEST(subghz_encoder_holtek_ht12x_test) {
+    mu_assert(
+        subghz_encoder_test(EXT_PATH("unit_tests/subghz/holtek_ht12x.sub")),
+        "Test encoder " SUBGHZ_PROTOCOL_HOLTEK_HT12X_NAME " error\r\n");
+}
+
 MU_TEST(subghz_random_test) {
     mu_assert(subghz_decode_random_test(TEST_RANDOM_DIR_NAME), "Random test error\r\n");
 }
@@ -774,6 +787,7 @@ MU_TEST_SUITE(subghz) {
     MU_RUN_TEST(subghz_decoder_clemsa_test);
     MU_RUN_TEST(subghz_decoder_ansonic_test);
     MU_RUN_TEST(subghz_decoder_smc5326_test);
+    MU_RUN_TEST(subghz_decoder_holtek_ht12x_test);
 
     MU_RUN_TEST(subghz_encoder_princeton_test);
     MU_RUN_TEST(subghz_encoder_came_test);
@@ -797,6 +811,7 @@ MU_TEST_SUITE(subghz) {
     MU_RUN_TEST(subghz_encoder_clemsa_test);
     MU_RUN_TEST(subghz_encoder_ansonic_test);
     MU_RUN_TEST(subghz_encoder_smc5326_test);
+    MU_RUN_TEST(subghz_encoder_holtek_ht12x_test);
 
     MU_RUN_TEST(subghz_random_test);
     subghz_test_deinit();

applications/debug/unit_tests/test_index.c

@@ -24,6 +24,7 @@ int run_minunit_test_protocol_dict();
 int run_minunit_test_lfrfid_protocols();
 int run_minunit_test_nfc();
 int run_minunit_test_bit_lib();
+int run_minunit_test_float_tools();
 int run_minunit_test_bt();
 
 typedef int (*UnitTestEntry)();
@@ -50,6 +51,7 @@ const UnitTest unit_tests[] = {
     {.name = "protocol_dict", .entry = run_minunit_test_protocol_dict},
     {.name = "lfrfid", .entry = run_minunit_test_lfrfid_protocols},
     {.name = "bit_lib", .entry = run_minunit_test_bit_lib},
+    {.name = "float_tools", .entry = run_minunit_test_float_tools},
     {.name = "bt", .entry = run_minunit_test_bt},
 };
 

applications/main/archive/helpers/archive_apps.c

@@ -13,7 +13,7 @@ ArchiveAppTypeEnum archive_get_app_type(const char* path) {
     }
     app_name++;
 
-    for(size_t i = 0; i < COUNT_OF(known_apps); i++) {
+    for(size_t i = 0; i < COUNT_OF(known_apps); i++) { //-V1008
         if(strncmp(app_name, known_apps[i], strlen(known_apps[i])) == 0) {
             return i;
         }

applications/main/archive/helpers/archive_favorites.c

@@ -177,7 +177,7 @@ bool archive_favorites_read(void* context) {
 
     archive_set_item_count(browser, file_count);
 
-    if(need_refresh) {
+    if(need_refresh) { //-V547
         archive_favourites_rescan();
     }
 

applications/main/archive/scenes/archive_scene_browser.c

@@ -116,7 +116,7 @@ bool archive_scene_browser_on_event(void* context, SceneManagerEvent event) {
         case ArchiveBrowserEventFileMenuPin: {
             const char* name = archive_get_name(browser);
             if(favorites) {
-                archive_favorites_delete(name);
+                archive_favorites_delete("%s", name);
                 archive_file_array_rm_selected(browser);
                 archive_show_file_menu(browser, false);
             } else if(archive_is_known_app(selected->type)) {

applications/main/bad_usb/bad_usb_script.c

@@ -218,8 +218,8 @@ static bool ducky_string(const char* param) {
 }
 
 static uint16_t ducky_get_keycode(const char* param, bool accept_chars) {
-    for(uint8_t i = 0; i < (sizeof(ducky_keys) / sizeof(ducky_keys[0])); i++) {
-        uint8_t key_cmd_len = strlen(ducky_keys[i].name);
+    for(size_t i = 0; i < (sizeof(ducky_keys) / sizeof(ducky_keys[0])); i++) {
+        size_t key_cmd_len = strlen(ducky_keys[i].name);
         if((strncmp(param, ducky_keys[i].name, key_cmd_len) == 0) &&
            (ducky_is_line_end(param[key_cmd_len]))) {
             return ducky_keys[i].keycode;
@@ -417,7 +417,7 @@ static int32_t ducky_script_execute_next(BadUsbScript* bad_usb, File* script_fil
             return 0;
         } else if(delay_val < 0) { // Script error
             bad_usb->st.error_line = bad_usb->st.line_cur - 1;
-            FURI_LOG_E(WORKER_TAG, "Unknown command at line %u", bad_usb->st.line_cur - 1);
+            FURI_LOG_E(WORKER_TAG, "Unknown command at line %u", bad_usb->st.line_cur - 1U);
             return SCRIPT_STATE_ERROR;
         } else {
             return (delay_val + bad_usb->defdelay);
@@ -596,7 +596,9 @@ static int32_t bad_usb_worker(void* context) {
                 }
                 bad_usb->st.state = worker_state;
                 continue;
-            } else if((flags == FuriFlagErrorTimeout) || (flags == FuriFlagErrorResource)) {
+            } else if(
+                (flags == (unsigned)FuriFlagErrorTimeout) ||
+                (flags == (unsigned)FuriFlagErrorResource)) {
                 if(delay_val > 0) {
                     bad_usb->st.delay_remain--;
                     continue;
@@ -650,7 +652,7 @@ static int32_t bad_usb_worker(void* context) {
 BadUsbScript* bad_usb_script_open(FuriString* file_path) {
     furi_assert(file_path);
 
-    BadUsbScript* bad_usb = malloc(sizeof(BadUsbScript)); //-V773
+    BadUsbScript* bad_usb = malloc(sizeof(BadUsbScript));
     bad_usb->file_path = furi_string_alloc();
     furi_string_set(bad_usb->file_path, file_path);
 
@@ -660,7 +662,7 @@ BadUsbScript* bad_usb_script_open(FuriString* file_path) {
     bad_usb->thread = furi_thread_alloc_ex("BadUsbWorker", 2048, bad_usb_worker, bad_usb);
     furi_thread_start(bad_usb->thread);
     return bad_usb;
-}
+} //-V773
 
 void bad_usb_script_close(BadUsbScript* bad_usb) {
     furi_assert(bad_usb);

applications/main/fap_loader/fap_loader_app.c

@@ -156,7 +156,7 @@ static bool fap_loader_select_app(FapLoader* loader) {
 }
 
 static FapLoader* fap_loader_alloc(const char* path) {
-    FapLoader* loader = malloc(sizeof(FapLoader)); //-V773
+    FapLoader* loader = malloc(sizeof(FapLoader)); //-V799
     loader->fap_path = furi_string_alloc_set(path);
     loader->storage = furi_record_open(RECORD_STORAGE);
     loader->dialogs = furi_record_open(RECORD_DIALOGS);
@@ -167,7 +167,7 @@ static FapLoader* fap_loader_alloc(const char* path) {
         loader->view_dispatcher, loader->gui, ViewDispatcherTypeFullscreen);
     view_dispatcher_add_view(loader->view_dispatcher, 0, loading_get_view(loader->loading));
     return loader;
-}
+} //-V773
 
 static void fap_loader_free(FapLoader* loader) {
     view_dispatcher_remove_view(loader->view_dispatcher, 0);

applications/main/ibutton/ibutton.c

@@ -278,7 +278,7 @@ bool ibutton_save_key(iButton* ibutton, const char* key_name) {
 
     flipper_format_free(file);
 
-    if(!result) {
+    if(!result) { //-V547
         dialog_message_show_storage_error(ibutton->dialogs, "Cannot save\nkey file");
     }
 
@@ -302,7 +302,7 @@ void ibutton_text_store_set(iButton* ibutton, const char* text, ...) {
 }
 
 void ibutton_text_store_clear(iButton* ibutton) {
-    memset(ibutton->text_store, 0, IBUTTON_TEXT_STORE_SIZE);
+    memset(ibutton->text_store, 0, IBUTTON_TEXT_STORE_SIZE + 1);
 }
 
 void ibutton_notification_message(iButton* ibutton, uint32_t message) {
@@ -343,7 +343,7 @@ int32_t ibutton_app(void* p) {
     } else {
         view_dispatcher_attach_to_gui(
             ibutton->view_dispatcher, ibutton->gui, ViewDispatcherTypeFullscreen);
-        if(key_loaded) {
+        if(key_loaded) { //-V547
             scene_manager_next_scene(ibutton->scene_manager, iButtonSceneEmulate);
             DOLPHIN_DEED(DolphinDeedIbuttonEmulate);
         } else {

applications/main/infrared/infrared.c

@@ -360,7 +360,7 @@ void infrared_text_store_set(Infrared* infrared, uint32_t bank, const char* text
 }
 
 void infrared_text_store_clear(Infrared* infrared, uint32_t bank) {
-    memset(infrared->text_store[bank], 0, INFRARED_TEXT_STORE_SIZE);
+    memset(infrared->text_store[bank], 0, INFRARED_TEXT_STORE_SIZE + 1);
 }
 
 void infrared_play_notification_message(Infrared* infrared, uint32_t message) {
@@ -455,7 +455,7 @@ int32_t infrared_app(void* p) {
     } else {
         view_dispatcher_attach_to_gui(
             infrared->view_dispatcher, infrared->gui, ViewDispatcherTypeFullscreen);
-        if(is_remote_loaded) {
+        if(is_remote_loaded) { //-V547
             scene_manager_next_scene(infrared->scene_manager, InfraredSceneRemote);
         } else {
             scene_manager_next_scene(infrared->scene_manager, InfraredSceneStart);

applications/main/infrared/infrared_brute_force.c

@@ -65,7 +65,7 @@ bool infrared_brute_force_calculate_messages(InfraredBruteForce* brute_force) {
         while(flipper_format_read_string(ff, "name", signal_name)) {
             InfraredBruteForceRecord* record =
                 InfraredBruteForceRecordDict_get(brute_force->records, signal_name);
-            if(record) {
+            if(record) { //-V547
                 ++(record->count);
             }
         }

applications/main/infrared/infrared_cli.c

@@ -55,7 +55,7 @@ static void signal_received_callback(void* context, InfraredWorkerSignal* receiv
         size_t timings_cnt;
         infrared_worker_get_raw_signal(received_signal, &timings, &timings_cnt);
 
-        buf_cnt = snprintf(buf, sizeof(buf), "RAW, %d samples:\r\n", timings_cnt);
+        buf_cnt = snprintf(buf, sizeof(buf), "RAW, %zu samples:\r\n", timings_cnt);
         cli_write(cli, (uint8_t*)buf, buf_cnt);
         for(size_t i = 0; i < timings_cnt; ++i) {
             buf_cnt = snprintf(buf, sizeof(buf), "%lu ", timings[i]);
@@ -276,7 +276,9 @@ static bool infrared_cli_decode_file(FlipperFormat* input_file, FlipperFormat* o
         }
         InfraredRawSignal* raw_signal = infrared_signal_get_raw_signal(signal);
         printf(
-            "Raw signal: %s, %u samples\r\n", furi_string_get_cstr(tmp), raw_signal->timings_size);
+            "Raw signal: %s, %zu samples\r\n",
+            furi_string_get_cstr(tmp),
+            raw_signal->timings_size);
         if(!infrared_cli_decode_raw_signal(
                raw_signal, decoder, output_file, furi_string_get_cstr(tmp)))
             break;
@@ -382,7 +384,7 @@ static void infrared_cli_list_remote_signals(FuriString* remote_name) {
         while(flipper_format_read_string(ff, "name", signal_name)) {
             furi_string_set_str(key, furi_string_get_cstr(signal_name));
             int* v = dict_signals_get(signals_dict, key);
-            if(v != NULL) {
+            if(v != NULL) { //-V547
                 (*v)++;
                 max = M_MAX(*v, max);
             } else {
@@ -436,7 +438,7 @@ static void
             break;
         }
 
-        printf("Sending %ld signal(s)...\r\n", record_count);
+        printf("Sending %lu signal(s)...\r\n", record_count);
         printf("Press Ctrl-C to stop.\r\n");
 
         int records_sent = 0;

applications/main/infrared/infrared_remote.c

@@ -145,15 +145,14 @@ bool infrared_remote_load(InfraredRemote* remote, FuriString* path) {
     buf = furi_string_alloc();
 
     FURI_LOG_I(TAG, "load file: \'%s\'", furi_string_get_cstr(path));
-    bool success = flipper_format_buffered_file_open_existing(ff, furi_string_get_cstr(path));
+    bool success = false;
 
-    if(success) {
+    do {
+        if(!flipper_format_buffered_file_open_existing(ff, furi_string_get_cstr(path))) break;
         uint32_t version;
-        success = flipper_format_read_header(ff, buf, &version) &&
-                  !furi_string_cmp(buf, "IR signals file") && (version == 1);
-    }
+        if(!flipper_format_read_header(ff, buf, &version)) break;
+        if(!furi_string_equal(buf, "IR signals file") || (version != 1)) break;
 
-    if(success) {
         path_extract_filename(path, buf, true);
         infrared_remote_clear_buttons(remote);
         infrared_remote_set_name(remote, furi_string_get_cstr(buf));
@@ -169,7 +168,8 @@ bool infrared_remote_load(InfraredRemote* remote, FuriString* path) {
                 infrared_remote_button_free(button);
             }
         }
-    }
+        success = true;
+    } while(false);
 
     furi_string_free(buf);
     flipper_format_free(ff);

applications/main/infrared/infrared_signal.c

@@ -74,7 +74,7 @@ static bool infrared_signal_is_raw_valid(InfraredRawSignal* raw) {
     } else if((raw->timings_size <= 0) || (raw->timings_size > MAX_TIMINGS_AMOUNT)) {
         FURI_LOG_E(
             TAG,
-            "Timings amount is out of range (0 - %X): %X",
+            "Timings amount is out of range (0 - %X): %zX",
             MAX_TIMINGS_AMOUNT,
             raw->timings_size);
         return false;
@@ -275,8 +275,8 @@ bool infrared_signal_search_and_read(
             is_name_found = furi_string_equal(name, tmp);
             if(is_name_found) break;
         }
-        if(!is_name_found) break;
-        if(!infrared_signal_read_body(signal, ff)) break;
+        if(!is_name_found) break; //-V547
+        if(!infrared_signal_read_body(signal, ff)) break; //-V779
         success = true;
     } while(false);
 

applications/main/infrared/scenes/infrared_scene_debug.c

@@ -26,7 +26,7 @@ bool infrared_scene_debug_on_event(void* context, SceneManagerEvent event) {
                 InfraredRawSignal* raw = infrared_signal_get_raw_signal(signal);
                 infrared_debug_view_set_text(debug_view, "RAW\n%d samples\n", raw->timings_size);
 
-                printf("RAW, %d samples:\r\n", raw->timings_size);
+                printf("RAW, %zu samples:\r\n", raw->timings_size);
                 for(size_t i = 0; i < raw->timings_size; ++i) {
                     printf("%lu ", raw->timings[i]);
                 }

applications/main/lfrfid/lfrfid.c

@@ -32,7 +32,7 @@ static void rpc_command_callback(RpcAppSystemEvent rpc_event, void* context) {
 }
 
 static LfRfid* lfrfid_alloc() {
-    LfRfid* lfrfid = malloc(sizeof(LfRfid)); //-V773
+    LfRfid* lfrfid = malloc(sizeof(LfRfid));
 
     lfrfid->storage = furi_record_open(RECORD_STORAGE);
     lfrfid->dialogs = furi_record_open(RECORD_DIALOGS);
@@ -100,7 +100,7 @@ static LfRfid* lfrfid_alloc() {
         lfrfid->view_dispatcher, LfRfidViewRead, lfrfid_view_read_get_view(lfrfid->read_view));
 
     return lfrfid;
-}
+} //-V773
 
 static void lfrfid_free(LfRfid* lfrfid) {
     furi_assert(lfrfid);

applications/main/lfrfid/lfrfid_cli.c

@@ -87,7 +87,7 @@ static void lfrfid_cli_read(Cli* cli, FuriString* args) {
         uint32_t flags =
             furi_event_flag_wait(context.event, available_flags, FuriFlagWaitAny, 100);
 
-        if(flags != FuriFlagErrorTimeout) {
+        if(flags != (unsigned)FuriFlagErrorTimeout) {
             if(FURI_BIT(flags, LFRFIDWorkerReadDone)) {
                 break;
             }
@@ -153,7 +153,7 @@ static bool lfrfid_cli_parse_args(FuriString* args, ProtocolDict* dict, Protocol
 
             for(ProtocolId i = 0; i < LFRFIDProtocolMax; i++) {
                 printf(
-                    "\t%s, %d bytes long\r\n",
+                    "\t%s, %zu bytes long\r\n",
                     protocol_dict_get_name(dict, i),
                     protocol_dict_get_data_size(dict, i));
             }
@@ -165,7 +165,7 @@ static bool lfrfid_cli_parse_args(FuriString* args, ProtocolDict* dict, Protocol
         // check data arg
         if(!args_read_hex_bytes(data_text, data, data_size)) {
             printf(
-                "%s data needs to be %d bytes long\r\n",
+                "%s data needs to be %zu bytes long\r\n",
                 protocol_dict_get_name(dict, *protocol),
                 data_size);
             break;
@@ -211,7 +211,7 @@ static void lfrfid_cli_write(Cli* cli, FuriString* args) {
 
     while(!cli_cmd_interrupt_received(cli)) {
         uint32_t flags = furi_event_flag_wait(event, available_flags, FuriFlagWaitAny, 100);
-        if(flags != FuriFlagErrorTimeout) {
+        if(flags != (unsigned)FuriFlagErrorTimeout) {
             if(FURI_BIT(flags, LFRFIDWorkerWriteOK)) {
                 printf("Written!\r\n");
                 break;
@@ -309,9 +309,9 @@ static void lfrfid_cli_raw_analyze(Cli* cli, FuriString* args) {
                     warn = true;
                 }
 
-                furi_string_printf(info_string, "[%ld %ld]", pulse, duration);
+                furi_string_printf(info_string, "[%lu %lu]", pulse, duration);
                 printf("%-16s", furi_string_get_cstr(info_string));
-                furi_string_printf(info_string, "[%ld %ld]", pulse, duration - pulse);
+                furi_string_printf(info_string, "[%lu %lu]", pulse, duration - pulse);
                 printf("%-16s", furi_string_get_cstr(info_string));
 
                 if(warn) {
@@ -335,7 +335,7 @@ static void lfrfid_cli_raw_analyze(Cli* cli, FuriString* args) {
                 total_pulse += pulse;
                 total_duration += duration;
 
-                if(total_protocol != PROTOCOL_NO) {
+                if(total_protocol != PROTOCOL_NO) { //-V1051
                     break;
                 }
             } else {
@@ -346,9 +346,9 @@ static void lfrfid_cli_raw_analyze(Cli* cli, FuriString* args) {
 
         printf("   Frequency: %f\r\n", (double)frequency);
         printf("  Duty Cycle: %f\r\n", (double)duty_cycle);
-        printf("       Warns: %ld\r\n", total_warns);
-        printf("   Pulse sum: %ld\r\n", total_pulse);
-        printf("Duration sum: %ld\r\n", total_duration);
+        printf("       Warns: %lu\r\n", total_warns);
+        printf("   Pulse sum: %lu\r\n", total_pulse);
+        printf("Duration sum: %lu\r\n", total_duration);
         printf("     Average: %f\r\n", (double)((float)total_pulse / (float)total_duration));
         printf("    Protocol: ");
 
@@ -435,7 +435,7 @@ static void lfrfid_cli_raw_read(Cli* cli, FuriString* args) {
         while(true) {
             uint32_t flags = furi_event_flag_wait(event, available_flags, FuriFlagWaitAny, 100);
 
-            if(flags != FuriFlagErrorTimeout) {
+            if(flags != (unsigned)FuriFlagErrorTimeout) {
                 if(FURI_BIT(flags, LFRFIDWorkerReadRawFileError)) {
                     printf("File is not RFID raw file\r\n");
                     break;
@@ -510,7 +510,7 @@ static void lfrfid_cli_raw_emulate(Cli* cli, FuriString* args) {
         while(true) {
             uint32_t flags = furi_event_flag_wait(event, available_flags, FuriFlagWaitAny, 100);
 
-            if(flags != FuriFlagErrorTimeout) {
+            if(flags != (unsigned)FuriFlagErrorTimeout) {
                 if(FURI_BIT(flags, LFRFIDWorkerEmulateRawFileError)) {
                     printf("File is not RFID raw file\r\n");
                     break;
@@ -573,4 +573,4 @@ static void lfrfid_cli(Cli* cli, FuriString* args, void* context) {
     }
 
     furi_string_free(cmd);
-}
+}

applications/main/nfc/scenes/nfc_scene_emulate_uid.c

@@ -39,7 +39,7 @@ static void nfc_scene_emulate_uid_widget_config(Nfc* nfc, bool data_received) {
 
     widget_add_icon_element(widget, 0, 3, &I_NFC_dolphin_emulation_47x61);
     widget_add_string_element(widget, 57, 13, AlignLeft, AlignTop, FontPrimary, "Emulating UID");
-    if(strcmp(nfc->dev->dev_name, "")) {
+    if(strcmp(nfc->dev->dev_name, "") != 0) {
         furi_string_printf(info_str, "%s", nfc->dev->dev_name);
     } else {
         for(uint8_t i = 0; i < data->uid_len; i++) {

applications/main/nfc/scenes/nfc_scene_extra_actions.c

@@ -43,7 +43,7 @@ bool nfc_scene_extra_actions_on_event(void* context, SceneManagerEvent event) {
 
     if(event.type == SceneManagerEventTypeCustom) {
         if(event.event == SubmenuIndexMfClassicKeys) {
-            if(mf_classic_dict_check_presence(MfClassicDictTypeFlipper)) {
+            if(mf_classic_dict_check_presence(MfClassicDictTypeSystem)) {
                 scene_manager_next_scene(nfc->scene_manager, NfcSceneMfClassicKeys);
             } else {
                 scene_manager_next_scene(nfc->scene_manager, NfcSceneDictNotFound);

applications/main/nfc/scenes/nfc_scene_mf_classic_dict_attack.c

@@ -53,10 +53,10 @@ static void nfc_scene_mf_classic_dict_attack_prepare_view(Nfc* nfc, DictAttackSt
     // Setup view
     if(state == DictAttackStateUserDictInProgress) {
         worker_state = NfcWorkerStateMfClassicDictAttack;
-        dict_attack_set_header(nfc->dict_attack, "Mf Classic User Dict.");
+        dict_attack_set_header(nfc->dict_attack, "MF Classic User Dictionary");
         dict = mf_classic_dict_alloc(MfClassicDictTypeUser);
 
-        // If failed to load user dictionary - try flipper dictionary
+        // If failed to load user dictionary - try the system dictionary
         if(!dict) {
             FURI_LOG_E(TAG, "User dictionary not found");
             state = DictAttackStateFlipperDictInProgress;
@@ -64,11 +64,11 @@ static void nfc_scene_mf_classic_dict_attack_prepare_view(Nfc* nfc, DictAttackSt
     }
     if(state == DictAttackStateFlipperDictInProgress) {
         worker_state = NfcWorkerStateMfClassicDictAttack;
-        dict_attack_set_header(nfc->dict_attack, "Mf Classic Flipper Dict.");
-        dict = mf_classic_dict_alloc(MfClassicDictTypeFlipper);
+        dict_attack_set_header(nfc->dict_attack, "MF Classic System Dictionary");
+        dict = mf_classic_dict_alloc(MfClassicDictTypeSystem);
         if(!dict) {
             FURI_LOG_E(TAG, "Flipper dictionary not found");
-            // Pass through to let worker handle the failure
+            // Pass through to let the worker handle the failure
         }
     }
     // Free previous dictionary
@@ -153,6 +153,15 @@ bool nfc_scene_mf_classic_dict_attack_on_event(void* context, SceneManagerEvent
                 nfc_worker_stop(nfc->worker);
                 consumed = true;
             }
+        } else if(event.event == NfcWorkerEventKeyAttackStart) {
+            dict_attack_set_key_attack(
+                nfc->dict_attack,
+                true,
+                nfc->dev->dev_data.mf_classic_dict_attack_data.current_sector);
+        } else if(event.event == NfcWorkerEventKeyAttackStop) {
+            dict_attack_set_key_attack(nfc->dict_attack, false, 0);
+        } else if(event.event == NfcWorkerEventKeyAttackNextSector) {
+            dict_attack_inc_key_attack_current_sector(nfc->dict_attack);
         }
     } else if(event.type == SceneManagerEventTypeBack) {
         scene_manager_next_scene(nfc->scene_manager, NfcSceneExitConfirm);

applications/main/nfc/scenes/nfc_scene_mf_classic_emulate.c

@@ -18,7 +18,7 @@ void nfc_scene_mf_classic_emulate_on_enter(void* context) {
     // Setup view
     Popup* popup = nfc->popup;
     popup_set_header(popup, "Emulating", 67, 13, AlignLeft, AlignTop);
-    if(strcmp(nfc->dev->dev_name, "")) {
+    if(strcmp(nfc->dev->dev_name, "") != 0) {
         nfc_text_store_set(nfc, "%s", nfc->dev->dev_name);
     } else {
         nfc_text_store_set(nfc, "MIFARE\nClassic");

applications/main/nfc/scenes/nfc_scene_mf_classic_keys.c

@@ -12,7 +12,7 @@ void nfc_scene_mf_classic_keys_on_enter(void* context) {
 
     // Load flipper dict keys total
     uint32_t flipper_dict_keys_total = 0;
-    MfClassicDict* dict = mf_classic_dict_alloc(MfClassicDictTypeFlipper);
+    MfClassicDict* dict = mf_classic_dict_alloc(MfClassicDictTypeSystem);
     if(dict) {
         flipper_dict_keys_total = mf_classic_dict_get_total_keys(dict);
         mf_classic_dict_free(dict);
@@ -26,11 +26,11 @@ void nfc_scene_mf_classic_keys_on_enter(void* context) {
     }
 
     widget_add_string_element(
-        nfc->widget, 0, 0, AlignLeft, AlignTop, FontPrimary, "Mifare Classic Keys");
+        nfc->widget, 0, 0, AlignLeft, AlignTop, FontPrimary, "MIFARE Classic Keys");
     char temp_str[32];
-    snprintf(temp_str, sizeof(temp_str), "Flipper list: %ld", flipper_dict_keys_total);
+    snprintf(temp_str, sizeof(temp_str), "System dict: %lu", flipper_dict_keys_total);
     widget_add_string_element(nfc->widget, 0, 20, AlignLeft, AlignTop, FontSecondary, temp_str);
-    snprintf(temp_str, sizeof(temp_str), "User list: %ld", user_dict_keys_total);
+    snprintf(temp_str, sizeof(temp_str), "User dict: %lu", user_dict_keys_total);
     widget_add_string_element(nfc->widget, 0, 32, AlignLeft, AlignTop, FontSecondary, temp_str);
     widget_add_button_element(
         nfc->widget, GuiButtonTypeCenter, "Add", nfc_scene_mf_classic_keys_widget_callback, nfc);

applications/main/nfc/scenes/nfc_scene_mf_classic_keys_list.c

@@ -27,7 +27,7 @@ void nfc_scene_mf_classic_keys_list_prepare(Nfc* nfc, MfClassicDict* dict) {
         char* current_key = (char*)malloc(sizeof(char) * 13);
         strncpy(current_key, furi_string_get_cstr(temp_key), 12);
         MfClassicUserKeys_push_back(nfc->mfc_key_strs, current_key);
-        FURI_LOG_D("ListKeys", "Key %ld: %s", index, current_key);
+        FURI_LOG_D("ListKeys", "Key %lu: %s", index, current_key);
         submenu_add_item(
             submenu, current_key, index++, nfc_scene_mf_classic_keys_list_submenu_callback, nfc);
     }

applications/main/nfc/scenes/nfc_scene_mf_desfire_read_success.c

@@ -26,13 +26,13 @@ void nfc_scene_mf_desfire_read_success_on_enter(void* context) {
         furi_string_cat_printf(temp_str, " %02X", nfc_data->uid[i]);
     }
 
-    uint32_t bytes_total = 1 << (data->version.sw_storage >> 1);
+    uint32_t bytes_total = 1UL << (data->version.sw_storage >> 1);
     uint32_t bytes_free = data->free_memory ? data->free_memory->bytes : 0;
-    furi_string_cat_printf(temp_str, "\n%ld", bytes_total);
+    furi_string_cat_printf(temp_str, "\n%lu", bytes_total);
     if(data->version.sw_storage & 1) {
         furi_string_push_back(temp_str, '+');
     }
-    furi_string_cat_printf(temp_str, " bytes, %ld bytes free\n", bytes_free);
+    furi_string_cat_printf(temp_str, " bytes, %lu bytes free\n", bytes_free);
 
     uint16_t n_apps = 0;
     uint16_t n_files = 0;

applications/main/nfc/scenes/nfc_scene_mf_ultralight_emulate.c

@@ -21,7 +21,7 @@ void nfc_scene_mf_ultralight_emulate_on_enter(void* context) {
                          (type == MfUltralightTypeUnknown);
     Popup* popup = nfc->popup;
     popup_set_header(popup, "Emulating", 67, 13, AlignLeft, AlignTop);
-    if(strcmp(nfc->dev->dev_name, "")) {
+    if(strcmp(nfc->dev->dev_name, "") != 0) {
         nfc_text_store_set(nfc, "%s", nfc->dev->dev_name);
     } else if(is_ultralight) {
         nfc_text_store_set(nfc, "MIFARE\nUltralight");

applications/main/nfc/scenes/nfc_scene_nfc_data_info.c

@@ -58,13 +58,13 @@ void nfc_scene_nfc_data_info_on_enter(void* context) {
     // Set application specific data
     if(protocol == NfcDeviceProtocolMifareDesfire) {
         MifareDesfireData* data = &dev_data->mf_df_data;
-        uint32_t bytes_total = 1 << (data->version.sw_storage >> 1);
+        uint32_t bytes_total = 1UL << (data->version.sw_storage >> 1);
         uint32_t bytes_free = data->free_memory ? data->free_memory->bytes : 0;
-        furi_string_cat_printf(temp_str, "\n%ld", bytes_total);
+        furi_string_cat_printf(temp_str, "\n%lu", bytes_total);
         if(data->version.sw_storage & 1) {
             furi_string_push_back(temp_str, '+');
         }
-        furi_string_cat_printf(temp_str, " bytes, %ld bytes free\n", bytes_free);
+        furi_string_cat_printf(temp_str, " bytes, %lu bytes free\n", bytes_free);
 
         uint16_t n_apps = 0;
         uint16_t n_files = 0;
@@ -148,4 +148,4 @@ void nfc_scene_nfc_data_info_on_exit(void* context) {
     Nfc* nfc = context;
 
     widget_reset(nfc->widget);
-}
+}

applications/main/nfc/scenes/nfc_scene_read.c

@@ -71,7 +71,7 @@ bool nfc_scene_read_on_event(void* context, SceneManagerEvent event) {
         } else if(event.event == NfcWorkerEventReadMfUltralight) {
             notification_message(nfc->notifications, &sequence_success);
             // Set unlock password input to 0xFFFFFFFF only on fresh read
-            memset(nfc->byte_input_store, 0xFF, 4);
+            memset(nfc->byte_input_store, 0xFF, sizeof(nfc->byte_input_store));
             scene_manager_next_scene(nfc->scene_manager, NfcSceneMfUltralightReadSuccess);
             DOLPHIN_DEED(DolphinDeedNfcReadSuccess);
             consumed = true;
@@ -91,7 +91,7 @@ bool nfc_scene_read_on_event(void* context, SceneManagerEvent event) {
             DOLPHIN_DEED(DolphinDeedNfcReadSuccess);
             consumed = true;
         } else if(event.event == NfcWorkerEventReadMfClassicDictAttackRequired) {
-            if(mf_classic_dict_check_presence(MfClassicDictTypeFlipper)) {
+            if(mf_classic_dict_check_presence(MfClassicDictTypeSystem)) {
                 scene_manager_next_scene(nfc->scene_manager, NfcSceneMfClassicDictAttack);
             } else {
                 scene_manager_next_scene(nfc->scene_manager, NfcSceneDictNotFound);

applications/main/nfc/scenes/nfc_scene_save_name.c

@@ -55,7 +55,7 @@ bool nfc_scene_save_name_on_event(void* context, SceneManagerEvent event) {
 
     if(event.type == SceneManagerEventTypeCustom) {
         if(event.event == NfcCustomEventTextInputDone) {
-            if(strcmp(nfc->dev->dev_name, "")) {
+            if(strcmp(nfc->dev->dev_name, "") != 0) {
                 nfc_device_delete(nfc->dev, true);
             }
             if(scene_manager_has_previous_scene(nfc->scene_manager, NfcSceneSetUid)) {

applications/main/nfc/views/dict_attack.c

@@ -24,6 +24,8 @@ typedef struct {
     uint8_t keys_found;
     uint16_t dict_keys_total;
     uint16_t dict_keys_current;
+    bool is_key_attack;
+    uint8_t key_attack_current_sector;
 } DictAttackViewModel;
 
 static void dict_attack_draw_callback(Canvas* canvas, void* model) {
@@ -36,10 +38,19 @@ static void dict_attack_draw_callback(Canvas* canvas, void* model) {
             canvas, 64, 23, AlignCenter, AlignTop, "Make sure the tag is\npositioned correctly.");
     } else if(m->state == DictAttackStateRead) {
         char draw_str[32] = {};
-        canvas_set_font(canvas, FontPrimary);
-        canvas_draw_str_aligned(
-            canvas, 64, 2, AlignCenter, AlignTop, furi_string_get_cstr(m->header));
         canvas_set_font(canvas, FontSecondary);
+        canvas_draw_str_aligned(
+            canvas, 64, 0, AlignCenter, AlignTop, furi_string_get_cstr(m->header));
+        if(m->is_key_attack) {
+            snprintf(
+                draw_str,
+                sizeof(draw_str),
+                "Reuse key check for sector: %d",
+                m->key_attack_current_sector);
+        } else {
+            snprintf(draw_str, sizeof(draw_str), "Unlocking sector: %d", m->sector_current);
+        }
+        canvas_draw_str_aligned(canvas, 0, 10, AlignLeft, AlignTop, draw_str);
         float dict_progress = m->dict_keys_total == 0 ?
                                   0 :
                                   (float)(m->dict_keys_current) / (float)(m->dict_keys_total);
@@ -49,13 +60,14 @@ static void dict_attack_draw_callback(Canvas* canvas, void* model) {
         if(progress > 1.0) {
             progress = 1.0;
         }
-        elements_progress_bar(canvas, 5, 15, 120, progress);
+        snprintf(draw_str, sizeof(draw_str), "%d/%d", m->dict_keys_current, m->dict_keys_total);
+        elements_progress_bar_with_text(canvas, 0, 20, 128, dict_progress, draw_str);
         canvas_set_font(canvas, FontSecondary);
         snprintf(draw_str, sizeof(draw_str), "Keys found: %d/%d", m->keys_found, m->keys_total);
-        canvas_draw_str_aligned(canvas, 1, 28, AlignLeft, AlignTop, draw_str);
+        canvas_draw_str_aligned(canvas, 0, 33, AlignLeft, AlignTop, draw_str);
         snprintf(
             draw_str, sizeof(draw_str), "Sectors Read: %d/%d", m->sectors_read, m->sectors_total);
-        canvas_draw_str_aligned(canvas, 1, 40, AlignLeft, AlignTop, draw_str);
+        canvas_draw_str_aligned(canvas, 0, 43, AlignLeft, AlignTop, draw_str);
     }
     elements_button_center(canvas, "Skip");
 }
@@ -113,6 +125,7 @@ void dict_attack_reset(DictAttack* dict_attack) {
             model->keys_found = 0;
             model->dict_keys_total = 0;
             model->dict_keys_current = 0;
+            model->is_key_attack = false;
             furi_string_reset(model->header);
         },
         false);
@@ -235,3 +248,28 @@ void dict_attack_inc_current_dict_key(DictAttack* dict_attack, uint16_t keys_tri
         },
         true);
 }
+
+void dict_attack_set_key_attack(DictAttack* dict_attack, bool is_key_attack, uint8_t sector) {
+    furi_assert(dict_attack);
+    with_view_model(
+        dict_attack->view,
+        DictAttackViewModel * model,
+        {
+            model->is_key_attack = is_key_attack;
+            model->key_attack_current_sector = sector;
+        },
+        true);
+}
+
+void dict_attack_inc_key_attack_current_sector(DictAttack* dict_attack) {
+    furi_assert(dict_attack);
+    with_view_model(
+        dict_attack->view,
+        DictAttackViewModel * model,
+        {
+            if(model->key_attack_current_sector < model->sectors_total) {
+                model->key_attack_current_sector++;
+            }
+        },
+        true);
+}

applications/main/nfc/views/dict_attack.h

@@ -38,3 +38,7 @@ void dict_attack_inc_keys_found(DictAttack* dict_attack);
 void dict_attack_set_total_dict_keys(DictAttack* dict_attack, uint16_t dict_keys_total);
 
 void dict_attack_inc_current_dict_key(DictAttack* dict_attack, uint16_t keys_tried);
+
+void dict_attack_set_key_attack(DictAttack* dict_attack, bool is_key_attack, uint8_t sector);
+
+void dict_attack_inc_key_attack_current_sector(DictAttack* dict_attack);

applications/main/subghz/helpers/subghz_frequency_analyzer_worker.c

@@ -2,6 +2,7 @@
 #include <lib/drivers/cc1101.h>
 
 #include <furi.h>
+#include <float_tools.h>
 
 #define TAG "SubghzFrequencyAnalyzerWorker"
 
@@ -197,7 +198,7 @@ static int32_t subghz_frequency_analyzer_worker_thread(void* context) {
             rssi_temp = (rssi_temp + frequency_rssi.rssi_fine) / 2;
             frequency_temp = frequency_rssi.frequency_fine;
 
-            if(instance->filVal) {
+            if(!float_is_equal(instance->filVal, 0.f)) {
                 frequency_rssi.frequency_fine =
                     subghz_frequency_analyzer_worker_expRunningAverageAdaptive(
                         instance, frequency_rssi.frequency_fine);
@@ -219,7 +220,7 @@ static int32_t subghz_frequency_analyzer_worker_thread(void* context) {
             instance->sample_hold_counter = 20;
             rssi_temp = (rssi_temp + frequency_rssi.rssi_coarse) / 2;
             frequency_temp = frequency_rssi.frequency_coarse;
-            if(instance->filVal) {
+            if(!float_is_equal(instance->filVal, 0.f)) {
                 frequency_rssi.frequency_coarse =
                     subghz_frequency_analyzer_worker_expRunningAverageAdaptive(
                         instance, frequency_rssi.frequency_coarse);

applications/main/subghz/scenes/subghz_scene_read_raw.c

@@ -3,6 +3,7 @@
 #include <dolphin/dolphin.h>
 #include <lib/subghz/protocols/raw.h>
 #include <lib/toolbox/path.h>
+#include <float_tools.h>
 
 #define RAW_FILE_NAME "Raw_signal_"
 #define TAG "SubGhzSceneReadRAW"
@@ -358,7 +359,7 @@ bool subghz_scene_read_raw_on_event(void* context, SceneManagerEvent event) {
 
             float rssi = furi_hal_subghz_get_rssi();
 
-            if(subghz->txrx->raw_threshold_rssi == SUBGHZ_RAW_TRESHOLD_MIN) {
+            if(float_is_equal(subghz->txrx->raw_threshold_rssi, SUBGHZ_RAW_TRESHOLD_MIN)) {
                 subghz_read_raw_add_data_rssi(subghz->subghz_read_raw, rssi, true);
                 subghz_protocol_raw_save_to_file_pause(
                     (SubGhzProtocolDecoderRAW*)subghz->txrx->decoder_result, false);

applications/main/subghz/scenes/subghz_scene_save_name.c

@@ -94,7 +94,7 @@ bool subghz_scene_save_name_on_event(void* context, SceneManagerEvent event) {
         return true;
     } else if(event.type == SceneManagerEventTypeCustom) {
         if(event.event == SubGhzCustomEventSceneSaveName) {
-            if(strcmp(subghz->file_name_tmp, "")) {
+            if(strcmp(subghz->file_name_tmp, "") != 0) {
                 furi_string_cat_printf(
                     subghz->file_path, "/%s%s", subghz->file_name_tmp, SUBGHZ_APP_EXTENSION);
                 if(subghz_path_is_file(subghz->file_path_tmp)) {

applications/main/subghz/scenes/subghz_scene_set_type.c

@@ -46,7 +46,7 @@ bool subghz_scene_set_type_submenu_gen_data_protocol(
 
         uint8_t key_data[sizeof(uint64_t)] = {0};
         for(size_t i = 0; i < sizeof(uint64_t); i++) {
-            key_data[sizeof(uint64_t) - i - 1] = (key >> i * 8) & 0xFF;
+            key_data[sizeof(uint64_t) - i - 1] = (key >> (i * 8)) & 0xFF;
         }
         if(!flipper_format_update_hex(subghz->txrx->fff_data, "Key", key_data, sizeof(uint64_t))) {
             FURI_LOG_E(TAG, "Unable to update Key");

applications/main/subghz/subghz_cli.c

@@ -152,11 +152,11 @@ void subghz_cli_command_tx(Cli* cli, FuriString* args, void* context) {
         "Protocol: Princeton\n"
         "Bit: 24\n"
         "Key: 00 00 00 00 00 %02X %02X %02X\n"
-        "TE: %ld\n"
-        "Repeat: %ld\n",
-        (uint8_t)((key >> 16) & 0xFF),
-        (uint8_t)((key >> 8) & 0xFF),
-        (uint8_t)(key & 0xFF),
+        "TE: %lu\n"
+        "Repeat: %lu\n",
+        (uint8_t)((key >> 16) & 0xFFU),
+        (uint8_t)((key >> 8) & 0xFFU),
+        (uint8_t)(key & 0xFFU),
         te,
         repeat);
     FlipperFormat* flipper_format = flipper_format_string_alloc();
@@ -300,7 +300,7 @@ void subghz_cli_command_rx(Cli* cli, FuriString* args, void* context) {
 
     furi_hal_power_suppress_charge_exit();
 
-    printf("\r\nPackets received %u\r\n", instance->packet_count);
+    printf("\r\nPackets received %zu\r\n", instance->packet_count);
 
     // Cleanup
     subghz_receiver_free(receiver);
@@ -787,8 +787,9 @@ static bool subghz_on_system_start_istream_decode_band(
     }
 
     region->bands_count += 1;
-    region =
-        realloc(region, sizeof(FuriHalRegion) + sizeof(FuriHalRegionBand) * region->bands_count);
+    region = realloc( //-V701
+        region,
+        sizeof(FuriHalRegion) + sizeof(FuriHalRegionBand) * region->bands_count);
     size_t pos = region->bands_count - 1;
     region->bands[pos].start = band.start;
     region->bands[pos].end = band.end;
@@ -798,7 +799,7 @@ static bool subghz_on_system_start_istream_decode_band(
 
     FURI_LOG_I(
         "SubGhzOnStart",
-        "Add allowed band: start %ldHz, stop %ldHz, power_limit %ddBm, duty_cycle %d%%",
+        "Add allowed band: start %luHz, stop %luHz, power_limit %ddBm, duty_cycle %u%%",
         band.start,
         band.end,
         band.power_limit,

applications/main/subghz/subghz_i.c

@@ -164,7 +164,7 @@ bool subghz_tx_start(SubGhz* subghz, FlipperFormat* flipper_format) {
 
         if(subghz->txrx->transmitter) {
             if(subghz_transmitter_deserialize(subghz->txrx->transmitter, flipper_format)) {
-                if(strcmp(furi_string_get_cstr(subghz->txrx->preset->name), "")) {
+                if(strcmp(furi_string_get_cstr(subghz->txrx->preset->name), "") != 0) {
                     subghz_begin(
                         subghz,
                         subghz_setting_get_preset_data_by_name(
@@ -544,11 +544,8 @@ void subghz_hopper_update(SubGhz* subghz) {
 
     switch(subghz->txrx->hopper_state) {
     case SubGhzHopperStateOFF:
-        return;
-        break;
     case SubGhzHopperStatePause:
         return;
-        break;
     case SubGhzHopperStateRSSITimeOut:
         if(subghz->txrx->hopper_timeout != 0) {
             subghz->txrx->hopper_timeout--;

applications/main/subghz/views/subghz_frequency_analyzer.c

@@ -11,6 +11,7 @@
 #include "../helpers/subghz_frequency_analyzer_log_item_array.h"
 
 #include <assets_icons.h>
+#include <float_tools.h>
 
 #define LOG_FREQUENCY_MAX_ITEMS 60 // uint8_t (limited by 'seq' of SubGhzFrequencyAnalyzerLogItem)
 
@@ -47,7 +48,8 @@ typedef struct {
 } SubGhzFrequencyAnalyzerModel;
 
 static inline uint8_t rssi_sanitize(float rssi) {
-    return (rssi ? (uint8_t)(rssi - SUBGHZ_FREQUENCY_ANALYZER_THRESHOLD) : 0);
+    return (
+        !float_is_equal(rssi, 0.f) ? (uint8_t)(rssi - SUBGHZ_FREQUENCY_ANALYZER_THRESHOLD) : 0);
 }
 
 void subghz_frequency_analyzer_set_callback(
@@ -294,9 +296,6 @@ static bool subghz_frequency_analyzer_log_frequency_insert(SubGhzFrequencyAnalyz
     if(items_count < LOG_FREQUENCY_MAX_ITEMS) {
         SubGhzFrequencyAnalyzerLogItem_t* item =
             SubGhzFrequencyAnalyzerLogItemArray_push_new(model->log_frequency);
-        if(item == NULL) {
-            return false;
-        }
         (*item)->frequency = model->frequency;
         (*item)->count = 1;
         (*item)->rssi_max = model->rssi;
@@ -340,7 +339,7 @@ void subghz_frequency_analyzer_pair_callback(
     float rssi,
     bool signal) {
     SubGhzFrequencyAnalyzer* instance = context;
-    if((rssi == 0.f) && (instance->locked)) {
+    if(float_is_equal(rssi, 0.f) && instance->locked) {
         if(instance->callback) {
             instance->callback(SubGhzCustomEventSceneAnalyzerUnlock, instance->context);
         }
@@ -355,13 +354,13 @@ void subghz_frequency_analyzer_pair_callback(
                 model->history_frequency[0] = model->frequency;
             },
             false);
-    } else if((rssi != 0.f) && (!instance->locked)) {
+    } else if(!float_is_equal(rssi, 0.f) && !instance->locked) {
         if(instance->callback) {
             instance->callback(SubGhzCustomEventSceneAnalyzerLock, instance->context);
         }
     }
 
-    instance->locked = (rssi != 0.f);
+    instance->locked = !float_is_equal(rssi, 0.f);
     with_view_model(
         instance->view,
         SubGhzFrequencyAnalyzerModel * model,

applications/main/subghz/views/subghz_read_raw.c

@@ -91,7 +91,7 @@ void subghz_read_raw_update_sample_write(SubGhzReadRAW* instance, size_t sample)
     with_view_model(
         instance->view,
         SubGhzReadRAWModel * model,
-        { furi_string_printf(model->sample_write, "%d spl.", sample); },
+        { furi_string_printf(model->sample_write, "%zu spl.", sample); },
         false);
 }
 
@@ -161,7 +161,7 @@ void subghz_read_raw_draw_sin(Canvas* canvas, SubGhzReadRAWModel* model) {
         canvas_draw_line(
             canvas,
             i + 1,
-            32 - subghz_read_raw_tab_sin((i + model->ind_sin * 16)) / SUBGHZ_RAW_SIN_AMPLITUDE,
+            32 - subghz_read_raw_tab_sin(i + model->ind_sin * 16) / SUBGHZ_RAW_SIN_AMPLITUDE,
             i + 2,
             32 + subghz_read_raw_tab_sin((i + model->ind_sin * 16 + 1) * 2) /
                      SUBGHZ_RAW_SIN_AMPLITUDE);

applications/main/subghz/views/subghz_test_packet.c

@@ -114,7 +114,7 @@ static void subghz_test_packet_draw(Canvas* canvas, SubGhzTestPacketModel* model
     snprintf(buffer, sizeof(buffer), "Path: %d - %s", model->path, path_name);
     canvas_draw_str(canvas, 0, 31, buffer);
 
-    snprintf(buffer, sizeof(buffer), "Packets: %d", model->packets);
+    snprintf(buffer, sizeof(buffer), "Packets: %zu", model->packets);
     canvas_draw_str(canvas, 0, 42, buffer);
 
     if(model->status == SubGhzTestPacketModelStatusRx) {

applications/main/u2f/scenes/u2f_scene_main.c

@@ -58,7 +58,7 @@ bool u2f_scene_main_on_event(void* context, SceneManagerEvent event) {
                 app->event_cur = event.event;
                 if(event.event == U2fCustomEventRegister)
                     u2f_view_set_state(app->u2f_view, U2fMsgRegister);
-                else if(event.event == U2fCustomEventAuth)
+                else if(event.event == U2fCustomEventAuth) //-V547
                     u2f_view_set_state(app->u2f_view, U2fMsgAuth);
                 notification_message(app->notifications, &sequence_display_backlight_on);
                 notification_message(app->notifications, &sequence_single_vibro);

applications/main/u2f/u2f_data.c

@@ -402,9 +402,9 @@ bool u2f_data_cnt_read(uint32_t* cnt_val) {
                 FURI_LOG_E(TAG, "Unable to load encryption key");
                 break;
             }
-            memset(&cnt, 0, 32);
-            if(!furi_hal_crypto_decrypt(cnt_encr, (uint8_t*)&cnt, 32)) {
-                memset(&cnt, 0, 32);
+            memset(&cnt, 0, sizeof(U2fCounterData));
+            if(!furi_hal_crypto_decrypt(cnt_encr, (uint8_t*)&cnt, sizeof(U2fCounterData))) {
+                memset(&cnt, 0, sizeof(U2fCounterData));
                 FURI_LOG_E(TAG, "Decryption failed");
                 break;
             }

applications/main/u2f/u2f_hid.c

@@ -94,7 +94,7 @@ static void u2f_hid_send_response(U2fHid* u2f_hid) {
     uint16_t data_ptr = 0;
 
     memset(packet_buf, 0, HID_U2F_PACKET_LEN);
-    memcpy(packet_buf, &(u2f_hid->packet.cid), 4);
+    memcpy(packet_buf, &(u2f_hid->packet.cid), sizeof(uint32_t)); //-V1086
 
     // Init packet
     packet_buf[4] = u2f_hid->packet.cmd;
@@ -166,7 +166,7 @@ static bool u2f_hid_parse_request(U2fHid* u2f_hid) {
             return false;
         u2f_hid->packet.len = 17;
         uint32_t random_cid = furi_hal_random_get();
-        memcpy(&(u2f_hid->packet.payload[8]), &random_cid, 4);
+        memcpy(&(u2f_hid->packet.payload[8]), &random_cid, sizeof(uint32_t)); //-V1086
         u2f_hid->packet.payload[12] = 2; // Protocol version
         u2f_hid->packet.payload[13] = 1; // Device version major
         u2f_hid->packet.payload[14] = 0; // Device version minor
@@ -177,7 +177,7 @@ static bool u2f_hid_parse_request(U2fHid* u2f_hid) {
     } else if(u2f_hid->packet.cmd == U2F_HID_WINK) { // WINK - notify user
         if(u2f_hid->packet.len != 0) return false;
         u2f_wink(u2f_hid->u2f_instance);
-        u2f_hid->packet.len = 0;
+        u2f_hid->packet.len = 0; //-V1048
         u2f_hid_send_response(u2f_hid);
     } else
         return false;

applications/plugins/dap_link/usb/dap_v2_usb.c

@@ -568,12 +568,12 @@ void dap_common_usb_set_state_callback(DapStateCallback callback) {
 static void* dap_usb_alloc_string_descr(const char* str) {
     furi_assert(str);
 
-    uint8_t len = strlen(str);
-    uint8_t wlen = (len + 1) * sizeof(uint16_t);
+    size_t len = strlen(str);
+    size_t wlen = (len + 1) * sizeof(uint16_t);
     struct usb_string_descriptor* dev_str_desc = malloc(wlen);
     dev_str_desc->bLength = wlen;
     dev_str_desc->bDescriptorType = USB_DTYPE_STRING;
-    for(uint8_t i = 0; i < len; i++) {
+    for(size_t i = 0; i < len; i++) {
         dev_str_desc->wString[i] = str[i];
     }
 
@@ -974,4 +974,4 @@ static usbd_respond hid_control(usbd_device* dev, usbd_ctlreq* req, usbd_rqc_cal
     }
 
     return usbd_fail;
-}
+}

applications/plugins/hid_app/hid.c

@@ -42,10 +42,12 @@ static void bt_hid_connection_status_changed_callback(BtStatus status, void* con
     furi_assert(context);
     Hid* hid = context;
     bool connected = (status == BtStatusConnected);
-    if(connected) {
-        notification_internal_message(hid->notifications, &sequence_set_blue_255);
-    } else {
-        notification_internal_message(hid->notifications, &sequence_reset_blue);
+    if(hid->transport == HidTransportBle) {
+        if(connected) {
+            notification_internal_message(hid->notifications, &sequence_set_blue_255);
+        } else {
+            notification_internal_message(hid->notifications, &sequence_reset_blue);
+        }
     }
     hid_keynote_set_connected_status(hid->hid_keynote, connected);
     hid_keyboard_set_connected_status(hid->hid_keyboard, connected);
@@ -186,7 +188,9 @@ void hid_free(Hid* app) {
     furi_assert(app);
 
     // Reset notification
-    notification_internal_message(app->notifications, &sequence_reset_blue);
+    if(app->transport == HidTransportBle) {
+        notification_internal_message(app->notifications, &sequence_reset_blue);
+    }
 
     // Free views
     view_dispatcher_remove_view(app->view_dispatcher, HidViewSubmenu);

applications/plugins/hid_app/views/hid_keyboard.c

@@ -25,6 +25,7 @@ typedef struct {
     bool back_pressed;
     bool connected;
     char key_string[5];
+    HidTransport transport;
 } HidKeyboardModel;
 
 typedef struct {
@@ -207,7 +208,7 @@ static void hid_keyboard_draw_callback(Canvas* canvas, void* context) {
     HidKeyboardModel* model = context;
 
     // Header
-    if(!model->connected) {
+    if((!model->connected) && (model->transport == HidTransportBle)) {
         canvas_draw_icon(canvas, 0, 0, &I_Ble_disconnected_15x15);
         canvas_set_font(canvas, FontPrimary);
         elements_multiline_text_aligned(canvas, 17, 3, AlignLeft, AlignTop, "Keyboard");
@@ -249,30 +250,19 @@ static void hid_keyboard_draw_callback(Canvas* canvas, void* context) {
 
 static uint8_t hid_keyboard_get_selected_key(HidKeyboardModel* model) {
     HidKeyboardKey key = hid_keyboard_keyset[model->y][model->x];
-    // Use upper case if shift is toggled
-    bool useUppercase = model->shift;
-    // Check if the key has an upper case version
-    bool hasUppercase = key.shift_key != 0;
-    if(useUppercase && hasUppercase)
-        return key.value;
-    else
-        return key.value;
+    return key.value;
 }
 
 static void hid_keyboard_get_select_key(HidKeyboardModel* model, HidKeyboardPoint delta) {
     // Keep going until a valid spot is found, this allows for nulls and zero width keys in the map
     do {
-        if(((int8_t)model->y) + delta.y < 0)
-            model->y = ROW_COUNT - 1;
-        else
-            model->y = (model->y + delta.y) % ROW_COUNT;
+        const int delta_sum = model->y + delta.y;
+        model->y = delta_sum < 0 ? ROW_COUNT - 1 : delta_sum % ROW_COUNT;
     } while(delta.y != 0 && hid_keyboard_keyset[model->y][model->x].value == 0);
 
     do {
-        if(((int8_t)model->x) + delta.x < 0)
-            model->x = COLUMN_COUNT - 1;
-        else
-            model->x = (model->x + delta.x) % COLUMN_COUNT;
+        const int delta_sum = model->x + delta.x;
+        model->x = delta_sum < 0 ? COLUMN_COUNT - 1 : delta_sum % COLUMN_COUNT;
     } while(delta.x != 0 && hid_keyboard_keyset[model->y][model->x].width ==
                                 0); // Skip zero width keys, pretend they are one key
 }
@@ -372,6 +362,12 @@ HidKeyboard* hid_keyboard_alloc(Hid* bt_hid) {
     view_set_draw_callback(hid_keyboard->view, hid_keyboard_draw_callback);
     view_set_input_callback(hid_keyboard->view, hid_keyboard_input_callback);
 
+    with_view_model(
+        hid_keyboard->view,
+        HidKeyboardModel * model,
+        { model->transport = bt_hid->transport; },
+        true);
+
     return hid_keyboard;
 }
 

applications/plugins/hid_app/views/hid_keynote.c

@@ -19,6 +19,7 @@ typedef struct {
     bool ok_pressed;
     bool back_pressed;
     bool connected;
+    HidTransport transport;
 } HidKeynoteModel;
 
 static void hid_keynote_draw_arrow(Canvas* canvas, uint8_t x, uint8_t y, CanvasDirection dir) {
@@ -39,11 +40,14 @@ static void hid_keynote_draw_callback(Canvas* canvas, void* context) {
     HidKeynoteModel* model = context;
 
     // Header
-    if(model->connected) {
-        canvas_draw_icon(canvas, 0, 0, &I_Ble_connected_15x15);
-    } else {
-        canvas_draw_icon(canvas, 0, 0, &I_Ble_disconnected_15x15);
+    if(model->transport == HidTransportBle) {
+        if(model->connected) {
+            canvas_draw_icon(canvas, 0, 0, &I_Ble_connected_15x15);
+        } else {
+            canvas_draw_icon(canvas, 0, 0, &I_Ble_disconnected_15x15);
+        }
     }
+
     canvas_set_font(canvas, FontPrimary);
     elements_multiline_text_aligned(canvas, 17, 3, AlignLeft, AlignTop, "Keynote");
 
@@ -186,6 +190,9 @@ HidKeynote* hid_keynote_alloc(Hid* hid) {
     view_set_draw_callback(hid_keynote->view, hid_keynote_draw_callback);
     view_set_input_callback(hid_keynote->view, hid_keynote_input_callback);
 
+    with_view_model(
+        hid_keynote->view, HidKeynoteModel * model, { model->transport = hid->transport; }, true);
+
     return hid_keynote;
 }
 

applications/plugins/hid_app/views/hid_media.c

@@ -21,6 +21,7 @@ typedef struct {
     bool down_pressed;
     bool ok_pressed;
     bool connected;
+    HidTransport transport;
 } HidMediaModel;
 
 static void hid_media_draw_arrow(Canvas* canvas, uint8_t x, uint8_t y, CanvasDirection dir) {
@@ -41,11 +42,14 @@ static void hid_media_draw_callback(Canvas* canvas, void* context) {
     HidMediaModel* model = context;
 
     // Header
-    if(model->connected) {
-        canvas_draw_icon(canvas, 0, 0, &I_Ble_connected_15x15);
-    } else {
-        canvas_draw_icon(canvas, 0, 0, &I_Ble_disconnected_15x15);
+    if(model->transport == HidTransportBle) {
+        if(model->connected) {
+            canvas_draw_icon(canvas, 0, 0, &I_Ble_connected_15x15);
+        } else {
+            canvas_draw_icon(canvas, 0, 0, &I_Ble_disconnected_15x15);
+        }
     }
+
     canvas_set_font(canvas, FontPrimary);
     elements_multiline_text_aligned(canvas, 17, 3, AlignLeft, AlignTop, "Media");
     canvas_set_font(canvas, FontSecondary);
@@ -190,6 +194,9 @@ HidMedia* hid_media_alloc(Hid* hid) {
     view_set_draw_callback(hid_media->view, hid_media_draw_callback);
     view_set_input_callback(hid_media->view, hid_media_input_callback);
 
+    with_view_model(
+        hid_media->view, HidMediaModel * model, { model->transport = hid->transport; }, true);
+
     return hid_media;
 }
 

applications/plugins/hid_app/views/hid_mouse.c

@@ -20,6 +20,7 @@ typedef struct {
     bool left_mouse_held;
     bool right_mouse_pressed;
     bool connected;
+    HidTransport transport;
 } HidMouseModel;
 
 static void hid_mouse_draw_callback(Canvas* canvas, void* context) {
@@ -27,11 +28,14 @@ static void hid_mouse_draw_callback(Canvas* canvas, void* context) {
     HidMouseModel* model = context;
 
     // Header
-    if(model->connected) {
-        canvas_draw_icon(canvas, 0, 0, &I_Ble_connected_15x15);
-    } else {
-        canvas_draw_icon(canvas, 0, 0, &I_Ble_disconnected_15x15);
+    if(model->transport == HidTransportBle) {
+        if(model->connected) {
+            canvas_draw_icon(canvas, 0, 0, &I_Ble_connected_15x15);
+        } else {
+            canvas_draw_icon(canvas, 0, 0, &I_Ble_disconnected_15x15);
+        }
     }
+
     canvas_set_font(canvas, FontPrimary);
     elements_multiline_text_aligned(canvas, 17, 3, AlignLeft, AlignTop, "Mouse");
     canvas_set_font(canvas, FontSecondary);
@@ -198,6 +202,9 @@ HidMouse* hid_mouse_alloc(Hid* hid) {
     view_set_draw_callback(hid_mouse->view, hid_mouse_draw_callback);
     view_set_input_callback(hid_mouse->view, hid_mouse_input_callback);
 
+    with_view_model(
+        hid_mouse->view, HidMouseModel * model, { model->transport = hid->transport; }, true);
+
     return hid_mouse;
 }
 

applications/plugins/hid_app/views/hid_mouse_jiggler.c

@@ -16,6 +16,7 @@ typedef struct {
     bool connected;
     bool running;
     uint8_t counter;
+    HidTransport transport;
 } HidMouseJigglerModel;
 
 static void hid_mouse_jiggler_draw_callback(Canvas* canvas, void* context) {
@@ -23,11 +24,14 @@ static void hid_mouse_jiggler_draw_callback(Canvas* canvas, void* context) {
     HidMouseJigglerModel* model = context;
 
     // Header
-    if(model->connected) {
-        canvas_draw_icon(canvas, 0, 0, &I_Ble_connected_15x15);
-    } else {
-        canvas_draw_icon(canvas, 0, 0, &I_Ble_disconnected_15x15);
+    if(model->transport == HidTransportBle) {
+        if(model->connected) {
+            canvas_draw_icon(canvas, 0, 0, &I_Ble_connected_15x15);
+        } else {
+            canvas_draw_icon(canvas, 0, 0, &I_Ble_disconnected_15x15);
+        }
     }
+
     canvas_set_font(canvas, FontPrimary);
     elements_multiline_text_aligned(canvas, 17, 3, AlignLeft, AlignTop, "Mouse Jiggler");
 
@@ -120,6 +124,12 @@ HidMouseJiggler* hid_mouse_jiggler_alloc(Hid* hid) {
     hid_mouse_jiggler->timer = furi_timer_alloc(
         hid_mouse_jiggler_timer_callback, FuriTimerTypePeriodic, hid_mouse_jiggler);
 
+    with_view_model(
+        hid_mouse_jiggler->view,
+        HidMouseJigglerModel * model,
+        { model->transport = hid->transport; },
+        true);
+
     return hid_mouse_jiggler;
 }
 

applications/plugins/hid_app/views/hid_tiktok.c

@@ -19,6 +19,7 @@ typedef struct {
     bool ok_pressed;
     bool connected;
     bool is_cursor_set;
+    HidTransport transport;
 } HidTikTokModel;
 
 static void hid_tiktok_draw_callback(Canvas* canvas, void* context) {
@@ -26,11 +27,14 @@ static void hid_tiktok_draw_callback(Canvas* canvas, void* context) {
     HidTikTokModel* model = context;
 
     // Header
-    if(model->connected) {
-        canvas_draw_icon(canvas, 0, 0, &I_Ble_connected_15x15);
-    } else {
-        canvas_draw_icon(canvas, 0, 0, &I_Ble_disconnected_15x15);
+    if(model->transport == HidTransportBle) {
+        if(model->connected) {
+            canvas_draw_icon(canvas, 0, 0, &I_Ble_connected_15x15);
+        } else {
+            canvas_draw_icon(canvas, 0, 0, &I_Ble_disconnected_15x15);
+        }
     }
+
     canvas_set_font(canvas, FontPrimary);
     elements_multiline_text_aligned(canvas, 17, 3, AlignLeft, AlignTop, "TikTok");
     canvas_set_font(canvas, FontSecondary);
@@ -207,6 +211,9 @@ HidTikTok* hid_tiktok_alloc(Hid* bt_hid) {
     view_set_draw_callback(hid_tiktok->view, hid_tiktok_draw_callback);
     view_set_input_callback(hid_tiktok->view, hid_tiktok_input_callback);
 
+    with_view_model(
+        hid_tiktok->view, HidTikTokModel * model, { model->transport = bt_hid->transport; }, true);
+
     return hid_tiktok;
 }
 

applications/plugins/music_player/music_player.c

@@ -180,7 +180,7 @@ static void render_callback(Canvas* canvas, void* ctx) {
 
     // note stack view_port
     x_pos = 73;
-    y_pos = 0;
+    y_pos = 0; //-V1048
     canvas_set_color(canvas, ColorBlack);
     canvas_set_font(canvas, FontPrimary);
     canvas_draw_frame(canvas, x_pos, y_pos, 49, 64);

applications/plugins/picopass/lib/loclass/optimized_cipher.c

@@ -111,9 +111,9 @@ static void init_opt_select_LUT(void) {
 ***********************************************************************************/
 
 #define loclass_opt__select(x, y, r)                                                        \
-    (4 & (((r & (r << 2)) >> 5) ^ ((r & ~(r << 2)) >> 4) ^ ((r | r << 2) >> 3))) |          \
-        (2 & (((r | r << 2) >> 6) ^ ((r | r << 2) >> 1) ^ (r >> 5) ^ r ^ ((x ^ y) << 1))) | \
-        (1 & (((r & ~(r << 2)) >> 4) ^ ((r & (r << 2)) >> 3) ^ r ^ x))
+    (4 & ((((r) & ((r) << 2)) >> 5) ^ (((r) & ~((r) << 2)) >> 4) ^ (((r) | (r) << 2) >> 3))) |          \
+        (2 & ((((r) | (r) << 2) >> 6) ^ (((r) | (r) << 2) >> 1) ^ ((r) >> 5) ^ (r) ^ (((x) ^ (y)) << 1))) | \
+        (1 & ((((r) & ~((r) << 2)) >> 4) ^ (((r) & ((r) << 2)) >> 3) ^ (r) ^ (x)))
 
 static void loclass_opt_successor(const uint8_t* k, LoclassState_t* s, uint8_t y) {
     uint16_t Tt = s->t & 0xc533;
@@ -149,30 +149,11 @@ static void loclass_opt_suc(
     uint8_t length,
     bool add32Zeroes) {
     for(int i = 0; i < length; i++) {
-        uint8_t head;
-        head = in[i];
-        loclass_opt_successor(k, s, head);
-
-        head >>= 1;
-        loclass_opt_successor(k, s, head);
-
-        head >>= 1;
-        loclass_opt_successor(k, s, head);
-
-        head >>= 1;
-        loclass_opt_successor(k, s, head);
-
-        head >>= 1;
-        loclass_opt_successor(k, s, head);
-
-        head >>= 1;
-        loclass_opt_successor(k, s, head);
-
-        head >>= 1;
-        loclass_opt_successor(k, s, head);
-
-        head >>= 1;
-        loclass_opt_successor(k, s, head);
+        uint8_t head = in[i];
+        for(int j = 0; j < 8; j++) {
+            loclass_opt_successor(k, s, head);
+            head >>= 1;
+        }
     }
     //For tag MAC, an additional 32 zeroes
     if(add32Zeroes) {

applications/plugins/picopass/picopass_worker.c

@@ -143,7 +143,7 @@ ReturnCode picopass_read_preauth(PicopassBlock* AA1) {
         AA1[PICOPASS_CSN_BLOCK_INDEX].data[7]);
 
     rfalPicoPassReadBlockRes cfg = {0};
-    err = rfalPicoPassPollerReadBlock(PICOPASS_CONFIG_BLOCK_INDEX, &cfg);
+    rfalPicoPassPollerReadBlock(PICOPASS_CONFIG_BLOCK_INDEX, &cfg);
     memcpy(AA1[PICOPASS_CONFIG_BLOCK_INDEX].data, cfg.data, sizeof(cfg.data));
     FURI_LOG_D(
         TAG,
@@ -158,7 +158,7 @@ ReturnCode picopass_read_preauth(PicopassBlock* AA1) {
         AA1[PICOPASS_CONFIG_BLOCK_INDEX].data[7]);
 
     rfalPicoPassReadBlockRes aia;
-    err = rfalPicoPassPollerReadBlock(PICOPASS_AIA_BLOCK_INDEX, &aia);
+    rfalPicoPassPollerReadBlock(PICOPASS_AIA_BLOCK_INDEX, &aia);
     memcpy(AA1[PICOPASS_AIA_BLOCK_INDEX].data, aia.data, sizeof(aia.data));
     FURI_LOG_D(
         TAG,
@@ -221,7 +221,7 @@ ReturnCode picopass_auth(PicopassBlock* AA1, PicopassPacs* pacs) {
     while(iclass_elite_dict_get_next_key(dict, key)) {
         FURI_LOG_D(
             TAG,
-            "Try to auth with key %d %02x%02x%02x%02x%02x%02x%02x%02x",
+            "Try to auth with key %zu %02x%02x%02x%02x%02x%02x%02x%02x",
             index++,
             key[0],
             key[1],
@@ -249,9 +249,7 @@ ReturnCode picopass_auth(PicopassBlock* AA1, PicopassPacs* pacs) {
         }
     }
 
-    if(dict) {
-        iclass_elite_dict_free(dict);
-    }
+    iclass_elite_dict_free(dict);
 
     return err;
 }

applications/plugins/picopass/scenes/picopass_scene_save_name.c

@@ -54,7 +54,7 @@ bool picopass_scene_save_name_on_event(void* context, SceneManagerEvent event) {
 
     if(event.type == SceneManagerEventTypeCustom) {
         if(event.event == PicopassCustomEventTextInputDone) {
-            if(strcmp(picopass->dev->dev_name, "")) {
+            if(strcmp(picopass->dev->dev_name, "") != 0) {
                 // picopass_device_delete(picopass->dev, true);
             }
             strlcpy(

applications/plugins/signal_generator/scenes/signal_gen_scene_pwm.c

@@ -15,12 +15,12 @@ static void
     app->pwm_freq = freq;
     app->pwm_duty = duty;
 
-    if(app->pwm_ch != pwm_ch_id[channel_id]) {
+    if(app->pwm_ch != pwm_ch_id[channel_id]) { //-V1051
         app->pwm_ch_prev = app->pwm_ch;
         app->pwm_ch = pwm_ch_id[channel_id];
         view_dispatcher_send_custom_event(app->view_dispatcher, SignalGenPwmEventChannelChange);
     } else {
-        app->pwm_ch = pwm_ch_id[channel_id];
+        app->pwm_ch = pwm_ch_id[channel_id]; //-V1048
         view_dispatcher_send_custom_event(app->view_dispatcher, SignalGenPwmEventUpdate);
     }
 }

applications/plugins/signal_generator/views/signal_gen_pwm.c

@@ -127,12 +127,12 @@ static void signal_gen_pwm_draw_callback(Canvas* canvas, void* _model) {
     char* line_label = NULL;
     char val_text[16];
 
-    for(uint8_t line = 0; line < LineIndexTotalCount; line++) {
+    for(size_t line = 0; line < LineIndexTotalCount; line++) {
         if(line == LineIndexChannel) {
             line_label = "GPIO Pin";
         } else if(line == LineIndexFrequency) {
             line_label = "Frequency";
-        } else if(line == LineIndexDuty) {
+        } else if(line == LineIndexDuty) { //-V547
             line_label = "Pulse width";
         }
 
@@ -169,7 +169,7 @@ static void signal_gen_pwm_draw_callback(Canvas* canvas, void* _model) {
                 canvas_draw_icon(canvas, icon_x, text_y - 9, &I_SmallArrowUp_3x5);
                 canvas_draw_icon(canvas, icon_x, text_y + 5, &I_SmallArrowDown_3x5);
             }
-        } else if(line == LineIndexDuty) {
+        } else if(line == LineIndexDuty) { //-V547
             snprintf(val_text, sizeof(val_text), "%d%%", model->duty);
             canvas_draw_str_aligned(canvas, VALUE_X, text_y, AlignCenter, AlignCenter, val_text);
             if(model->duty != 0) {

applications/plugins/snake_game/snake_game.c

@@ -130,7 +130,7 @@ static void snake_game_render_callback(Canvas* const canvas, void* ctx) {
 
         canvas_set_font(canvas, FontSecondary);
         char buffer[12];
-        snprintf(buffer, sizeof(buffer), "Score: %u", snake_state->len - 7);
+        snprintf(buffer, sizeof(buffer), "Score: %u", snake_state->len - 7U);
         canvas_draw_str_aligned(canvas, 64, 41, AlignCenter, AlignBottom, buffer);
     }
 
@@ -153,7 +153,7 @@ static void snake_game_update_timer_callback(FuriMessageQueue* event_queue) {
 
 static void snake_game_init_game(SnakeState* const snake_state) {
     Point p[] = {{8, 6}, {7, 6}, {6, 6}, {5, 6}, {4, 6}, {3, 6}, {2, 6}};
-    memcpy(snake_state->points, p, sizeof(p));
+    memcpy(snake_state->points, p, sizeof(p)); //-V1086
 
     snake_state->len = 7;
 

applications/plugins/weather_station/protocols/oregon2.c

@@ -343,7 +343,7 @@ bool ws_protocol_decoder_oregon2_deserialize(void* context, FlipperFormat* flipp
                flipper_format,
                "VarData",
                (uint8_t*)&instance->var_data,
-               sizeof(instance->var_data))) {
+               sizeof(instance->var_data))) { //-V1051
             FURI_LOG_E(TAG, "Missing VarData");
             break;
         }

applications/plugins/weather_station/protocols/oregon_v1.c

@@ -147,7 +147,7 @@ static void ws_protocol_oregon_v1_remote_controller(WSBlockGeneric* instance) {
         instance->temp = -temp_raw;
     }
 
-    instance->battery_low = !(instance->data >> 23) & 1;
+    instance->battery_low = !((instance->data >> 23) & 1ULL);
 
     instance->btn = WS_NO_BTN;
     instance->humidity = WS_NO_HUMIDITY;

applications/plugins/weather_station/protocols/ws_generic.c

@@ -79,7 +79,7 @@ bool ws_block_generic_serialize(
 
         uint8_t key_data[sizeof(uint64_t)] = {0};
         for(size_t i = 0; i < sizeof(uint64_t); i++) {
-            key_data[sizeof(uint64_t) - i - 1] = (instance->data >> i * 8) & 0xFF;
+            key_data[sizeof(uint64_t) - i - 1] = (instance->data >> (i * 8)) & 0xFF;
         }
 
         if(!flipper_format_write_hex(flipper_format, "Data", key_data, sizeof(uint64_t))) {
@@ -208,4 +208,4 @@ bool ws_block_generic_deserialize(WSBlockGeneric* instance, FlipperFormat* flipp
     } while(0);
 
     return res;
-}
+}

applications/plugins/weather_station/views/weather_station_receiver_info.c

@@ -4,8 +4,7 @@
 #include "../protocols/ws_generic.h"
 #include <input/input.h>
 #include <gui/elements.h>
-
-#define abs(x) ((x) > 0 ? (x) : -(x))
+#include <float_tools.h>
 
 struct WSReceiverInfo {
     View* view;
@@ -79,7 +78,7 @@ void ws_view_receiver_info_draw(Canvas* canvas, WSReceiverInfoModel* model) {
     elements_bold_rounded_frame(canvas, 0, 38, 127, 25);
     canvas_set_font(canvas, FontPrimary);
 
-    if(model->generic->temp != WS_NO_TEMPERATURE) {
+    if(!float_is_equal(model->generic->temp, WS_NO_TEMPERATURE)) {
         canvas_draw_icon(canvas, 6, 43, &I_Therm_7x16);
 
         uint8_t temp_x1 = 0;

applications/plugins/weather_station/weather_station_app_i.c

@@ -111,11 +111,8 @@ void ws_hopper_update(WeatherStationApp* app) {
 
     switch(app->txrx->hopper_state) {
     case WSHopperStateOFF:
-        return;
-        break;
     case WSHopperStatePause:
         return;
-        break;
     case WSHopperStateRSSITimeOut:
         if(app->txrx->hopper_timeout != 0) {
             app->txrx->hopper_timeout--;

applications/plugins/weather_station/weather_station_history.c

@@ -186,7 +186,7 @@ WSHistoryStateAddKey
     }
 
     // or add new record
-    if(!sensor_found) {
+    if(!sensor_found) { //-V547
         WSHistoryItem* item = WSHistoryItemArray_push_raw(instance->history->data);
         item->preset = malloc(sizeof(SubGhzRadioPreset));
         item->type = decoder_base->protocol->type;

applications/services/bt/bt_service/bt.c

@@ -36,7 +36,7 @@ static void bt_pin_code_view_port_draw_callback(Canvas* canvas, void* context) {
     Bt* bt = context;
     char pin_code_info[24];
     canvas_draw_icon(canvas, 0, 0, &I_BLE_Pairing_128x64);
-    snprintf(pin_code_info, sizeof(pin_code_info), "Pairing code\n%06ld", bt->pin_code);
+    snprintf(pin_code_info, sizeof(pin_code_info), "Pairing code\n%06lu", bt->pin_code);
     elements_multiline_text_aligned(canvas, 64, 4, AlignCenter, AlignTop, pin_code_info);
     elements_button_left(canvas, "Quit");
 }
@@ -78,7 +78,7 @@ static bool bt_pin_code_verify_event_handler(Bt* bt, uint32_t pin) {
     notification_message(bt->notification, &sequence_display_backlight_on);
     FuriString* pin_str;
     dialog_message_set_icon(bt->dialog_message, &I_BLE_Pairing_128x64, 0, 0);
-    pin_str = furi_string_alloc_printf("Verify code\n%06ld", pin);
+    pin_str = furi_string_alloc_printf("Verify code\n%06lu", pin);
     dialog_message_set_text(
         bt->dialog_message, furi_string_get_cstr(pin_str), 64, 4, AlignCenter, AlignTop);
     dialog_message_set_buttons(bt->dialog_message, "Cancel", "OK", NULL);
@@ -163,7 +163,7 @@ static uint16_t bt_serial_event_callback(SerialServiceEvent event, void* context
             rpc_session_feed(bt->rpc_session, event.data.buffer, event.data.size, 1000);
         if(bytes_processed != event.data.size) {
             FURI_LOG_E(
-                TAG, "Only %d of %d bytes processed by RPC", bytes_processed, event.data.size);
+                TAG, "Only %zu of %u bytes processed by RPC", bytes_processed, event.data.size);
         }
         ret = rpc_session_get_available_size(bt->rpc_session);
     } else if(event.event == SerialServiceEventTypeDataSent) {

applications/services/bt/bt_service/bt_keys_storage.c

@@ -115,7 +115,7 @@ bool bt_keys_storage_update(BtKeysStorage* instance, uint8_t* start_addr, uint32
 
     FURI_LOG_I(
         TAG,
-        "Base address: %p. Start update address: %p. Size changed: %ld",
+        "Base address: %p. Start update address: %p. Size changed: %lu",
         (void*)instance->nvm_sram_buff,
         start_addr,
         size);

applications/services/cli/cli.c

@@ -225,7 +225,7 @@ static void cli_handle_enter(Cli* cli) {
     furi_check(furi_mutex_acquire(cli->mutex, FuriWaitForever) == FuriStatusOk);
     CliCommand* cli_command_ptr = CliCommandTree_get(cli->commands, command);
 
-    if(cli_command_ptr) {
+    if(cli_command_ptr) { //-V547
         CliCommand cli_command;
         memcpy(&cli_command, cli_command_ptr, sizeof(CliCommand));
         furi_check(furi_mutex_release(cli->mutex) == FuriStatusOk);
@@ -353,7 +353,7 @@ void cli_process_input(Cli* cli) {
         cli_handle_backspace(cli);
     } else if(in_chr == CliSymbolAsciiCR) {
         cli_handle_enter(cli);
-    } else if(in_chr >= 0x20 && in_chr < 0x7F) {
+    } else if(in_chr >= 0x20 && in_chr < 0x7F) { //-V560
         if(cli->cursor_position == furi_string_size(cli->line)) {
             furi_string_push_back(cli->line, in_chr);
             cli_putc(cli, in_chr);

applications/services/cli/cli_command_gpio.c

@@ -1,5 +1,6 @@
 #include "cli_command_gpio.h"
 
+#include "core/string.h"
 #include <furi.h>
 #include <furi_hal.h>
 #include <lib/toolbox/args.h>
@@ -36,26 +37,24 @@ void cli_command_gpio_print_usage() {
 }
 
 static bool pin_name_to_int(FuriString* pin_name, size_t* result) {
-    bool found = false;
-    bool debug = furi_hal_rtc_is_flag_set(FuriHalRtcFlagDebug);
+    bool is_debug_mode = furi_hal_rtc_is_flag_set(FuriHalRtcFlagDebug);
     for(size_t i = 0; i < COUNT_OF(cli_command_gpio_pins); i++) {
-        if(!furi_string_cmp(pin_name, cli_command_gpio_pins[i].name)) {
-            if(!cli_command_gpio_pins[i].debug || debug) {
+        if(furi_string_equal(pin_name, cli_command_gpio_pins[i].name)) {
+            if(!cli_command_gpio_pins[i].debug || is_debug_mode) {
                 *result = i;
-                found = true;
-                break;
+                return true;
             }
         }
     }
 
-    return found;
+    return false;
 }
 
 static void gpio_print_pins(void) {
     printf("Wrong pin name. Available pins: ");
-    bool debug = furi_hal_rtc_is_flag_set(FuriHalRtcFlagDebug);
+    bool is_debug_mode = furi_hal_rtc_is_flag_set(FuriHalRtcFlagDebug);
     for(size_t i = 0; i < COUNT_OF(cli_command_gpio_pins); i++) {
-        if(!cli_command_gpio_pins[i].debug || debug) {
+        if(!cli_command_gpio_pins[i].debug || is_debug_mode) {
             printf("%s ", cli_command_gpio_pins[i].name);
         }
     }
@@ -69,34 +68,29 @@ typedef enum {
 } GpioParseReturn;
 
 static GpioParseReturn gpio_command_parse(FuriString* args, size_t* pin_num, uint8_t* value) {
-    FuriString* pin_name;
-    pin_name = furi_string_alloc();
+    GpioParseReturn ret = GpioParseReturnOk;
+    FuriString* pin_name = furi_string_alloc();
 
-    size_t ws = furi_string_search_char(args, ' ');
-    if(ws == FURI_STRING_FAILURE) {
-        return GpioParseReturnCmdSyntaxError;
-    }
+    do {
+        if(!args_read_string_and_trim(args, pin_name)) {
+            ret = GpioParseReturnCmdSyntaxError;
+            break;
+        } else if(!pin_name_to_int(pin_name, pin_num)) {
+            ret = GpioParseReturnPinError;
+            break;
+        }
 
-    furi_string_set_n(pin_name, args, 0, ws);
-    furi_string_right(args, ws);
-    furi_string_trim(args);
+        int pin_mode; //-V779
+        if(!args_read_int_and_trim(args, &pin_mode) || pin_mode < 0 || pin_mode > 1) {
+            ret = GpioParseReturnValueError;
+            break;
+        }
 
-    if(!pin_name_to_int(pin_name, pin_num)) {
-        furi_string_free(pin_name);
-        return GpioParseReturnPinError;
-    }
+        *value = pin_mode;
+    } while(false);
 
     furi_string_free(pin_name);
-
-    if(!furi_string_cmp(args, "0")) {
-        *value = 0;
-    } else if(!furi_string_cmp(args, "1")) {
-        *value = 1;
-    } else {
-        return GpioParseReturnValueError;
-    }
-
-    return GpioParseReturnOk;
+    return ret;
 }
 
 void cli_command_gpio_mode(Cli* cli, FuriString* args, void* context) {
@@ -111,7 +105,7 @@ void cli_command_gpio_mode(Cli* cli, FuriString* args, void* context) {
     if(err == GpioParseReturnCmdSyntaxError) {
         cli_print_usage("gpio mode", "<pin_name> <0|1>", furi_string_get_cstr(args));
         return;
-    } else if(err == GpioParseReturnPinError) {
+    } else if(err == GpioParseReturnPinError) { //-V547
         gpio_print_pins();
         return;
     } else if(err == GpioParseReturnValueError) {
@@ -119,7 +113,7 @@ void cli_command_gpio_mode(Cli* cli, FuriString* args, void* context) {
         return;
     }
 
-    if(cli_command_gpio_pins[num].debug) {
+    if(cli_command_gpio_pins[num].debug) { //-V779
         printf(
             "Changing this pin mode may damage hardware. Are you sure you want to continue? (y/n)?\r\n");
         char c = cli_getc(cli);
@@ -149,7 +143,7 @@ void cli_command_gpio_read(Cli* cli, FuriString* args, void* context) {
         return;
     }
 
-    if(LL_GPIO_MODE_INPUT !=
+    if(LL_GPIO_MODE_INPUT != //-V779
        LL_GPIO_GetPinMode(
            cli_command_gpio_pins[num].pin->port, cli_command_gpio_pins[num].pin->pin)) {
         printf("Err: pin %s is not set as an input.", cli_command_gpio_pins[num].name);
@@ -171,7 +165,7 @@ void cli_command_gpio_set(Cli* cli, FuriString* args, void* context) {
     if(err == GpioParseReturnCmdSyntaxError) {
         cli_print_usage("gpio set", "<pin_name> <0|1>", furi_string_get_cstr(args));
         return;
-    } else if(err == GpioParseReturnPinError) {
+    } else if(err == GpioParseReturnPinError) { //-V547
         gpio_print_pins();
         return;
     } else if(err == GpioParseReturnValueError) {
@@ -179,7 +173,7 @@ void cli_command_gpio_set(Cli* cli, FuriString* args, void* context) {
         return;
     }
 
-    if(LL_GPIO_MODE_OUTPUT !=
+    if(LL_GPIO_MODE_OUTPUT != //-V779
        LL_GPIO_GetPinMode(
            cli_command_gpio_pins[num].pin->port, cli_command_gpio_pins[num].pin->pin)) {
         printf("Err: pin %s is not set as an output.", cli_command_gpio_pins[num].name);

applications/services/cli/cli_commands.c

@@ -354,7 +354,7 @@ void cli_command_ps(Cli* cli, FuriString* args, void* context) {
     for(uint8_t i = 0; i < thread_num; i++) {
         TaskControlBlock* tcb = (TaskControlBlock*)threads_ids[i];
         printf(
-            "%-20s 0x%-12lx %-8d %-8ld %-8ld\r\n",
+            "%-20s 0x%-12lx %-8zu %-8lu %-8lu\r\n",
             furi_thread_get_name(threads_ids[i]),
             (uint32_t)tcb->pxStack,
             memmgr_heap_get_thread_memory(threads_ids[i]),
@@ -369,13 +369,13 @@ void cli_command_free(Cli* cli, FuriString* args, void* context) {
     UNUSED(args);
     UNUSED(context);
 
-    printf("Free heap size: %d\r\n", memmgr_get_free_heap());
-    printf("Total heap size: %d\r\n", memmgr_get_total_heap());
-    printf("Minimum heap size: %d\r\n", memmgr_get_minimum_free_heap());
-    printf("Maximum heap block: %d\r\n", memmgr_heap_get_max_free_block());
+    printf("Free heap size: %zu\r\n", memmgr_get_free_heap());
+    printf("Total heap size: %zu\r\n", memmgr_get_total_heap());
+    printf("Minimum heap size: %zu\r\n", memmgr_get_minimum_free_heap());
+    printf("Maximum heap block: %zu\r\n", memmgr_heap_get_max_free_block());
 
-    printf("Pool free: %d\r\n", memmgr_pool_get_free());
-    printf("Maximum pool block: %d\r\n", memmgr_pool_get_max_block());
+    printf("Pool free: %zu\r\n", memmgr_pool_get_free());
+    printf("Maximum pool block: %zu\r\n", memmgr_pool_get_max_block());
 }
 
 void cli_command_free_blocks(Cli* cli, FuriString* args, void* context) {

applications/services/crypto/crypto_cli.c

@@ -142,7 +142,7 @@ void crypto_cli_decrypt(Cli* cli, FuriString* args) {
             if(args_read_hex_bytes(hex_input, input, size)) {
                 if(furi_hal_crypto_decrypt(input, output, size)) {
                     printf("Decrypted data:\r\n");
-                    printf("%s\r\n", output);
+                    printf("%s\r\n", output); //-V576
                 } else {
                     printf("Failed to decrypt\r\n");
                 }

applications/services/desktop/animations/animation_manager.c

@@ -244,10 +244,8 @@ static bool animation_manager_check_blocking(AnimationManager* animation_manager
     furi_record_close(RECORD_DOLPHIN);
     if(!blocking_animation && stats.level_up_is_pending) {
         blocking_animation = animation_storage_find_animation(NEW_MAIL_ANIMATION_NAME);
-        furi_assert(blocking_animation);
-        if(blocking_animation) {
-            animation_manager->levelup_pending = true;
-        }
+        furi_check(blocking_animation);
+        animation_manager->levelup_pending = true;
     }
 
     if(blocking_animation) {
@@ -448,7 +446,7 @@ void animation_manager_unload_and_stall_animation(AnimationManager* animation_ma
 
     if(animation_manager->state == AnimationManagerStateBlocked) {
         animation_manager->state = AnimationManagerStateFreezedBlocked;
-    } else if(animation_manager->state == AnimationManagerStateIdle) {
+    } else if(animation_manager->state == AnimationManagerStateIdle) { //-V547
         animation_manager->state = AnimationManagerStateFreezedIdle;
 
         animation_manager->freezed_animation_time_left =
@@ -491,7 +489,7 @@ void animation_manager_load_and_continue_animation(AnimationManager* animation_m
         furi_assert(restore_animation);
         animation_manager_replace_current_animation(animation_manager, restore_animation);
         animation_manager->state = AnimationManagerStateBlocked;
-    } else if(animation_manager->state == AnimationManagerStateFreezedIdle) {
+    } else if(animation_manager->state == AnimationManagerStateFreezedIdle) { //-V547
         /* check if we missed some system notifications, and set current_animation */
         bool blocked = animation_manager_check_blocking(animation_manager);
         if(!blocked) {

applications/services/desktop/animations/animation_storage.c

@@ -360,7 +360,6 @@ static bool animation_storage_load_bubbles(BubbleAnimation* animation, FlipperFo
         if(u32value > 20) break;
         animation->frame_bubble_sequences_count = u32value;
         if(animation->frame_bubble_sequences_count == 0) {
-            animation->frame_bubble_sequences = NULL;
             success = true;
             break;
         }
@@ -481,7 +480,7 @@ static BubbleAnimation* animation_storage_load_animation(const char* name) {
         if(!animation_storage_load_frames(storage, name, animation, u32array, width, height))
             break;
 
-        if(!flipper_format_read_uint32(ff, "Active cycles", &u32value, 1)) break;
+        if(!flipper_format_read_uint32(ff, "Active cycles", &u32value, 1)) break; //-V779
         animation->active_cycles = u32value;
         if(!flipper_format_read_uint32(ff, "Frame rate", &u32value, 1)) break;
         FURI_CONST_ASSIGN(animation->icon_animation.frame_rate, u32value);
@@ -500,7 +499,7 @@ static BubbleAnimation* animation_storage_load_animation(const char* name) {
         free(u32array);
     }
 
-    if(!success) {
+    if(!success) { //-V547
         if(animation->frame_order) {
             free((void*)animation->frame_order);
         }

applications/services/desktop/helpers/slideshow.c

@@ -41,7 +41,7 @@ Slideshow* slideshow_alloc() {
 
 void slideshow_free(Slideshow* slideshow) {
     Icon* icon = &slideshow->icon;
-    if(icon) {
+    if(icon) { //-V547
         for(int frame_idx = 0; frame_idx < icon->frame_count; ++frame_idx) {
             uint8_t* frame_data = (uint8_t*)icon->frames[frame_idx];
             free(frame_data);

applications/services/desktop/views/desktop_view_debug.c

@@ -52,7 +52,7 @@ void desktop_debug_render(Canvas* canvas, void* model) {
 #ifdef SRV_BT
         c2_ver = ble_glue_get_c2_info();
 #endif
-        if(!ver) {
+        if(!ver) { //-V1051
             canvas_draw_str(canvas, 0, 30 + STATUS_BAR_Y_SHIFT, "No info");
             return;
         }
@@ -88,19 +88,19 @@ void desktop_debug_render(Canvas* canvas, void* model) {
         uint32_t remaining = dolphin_state_xp_to_levelup(m->icounter);
 
         canvas_set_font(canvas, FontSecondary);
-        snprintf(buffer, sizeof(buffer), "Icounter: %ld  Butthurt %ld", m->icounter, m->butthurt);
+        snprintf(buffer, sizeof(buffer), "Icounter: %lu  Butthurt %lu", m->icounter, m->butthurt);
         canvas_draw_str(canvas, 5, 19 + STATUS_BAR_Y_SHIFT, buffer);
 
         snprintf(
             buffer,
             sizeof(buffer),
-            "Level: %ld  To level up: %ld",
+            "Level: %lu  To level up: %lu",
             current_lvl,
             (remaining == (uint32_t)(-1) ? remaining : 0));
         canvas_draw_str(canvas, 5, 29 + STATUS_BAR_Y_SHIFT, buffer);
 
         // even if timestamp is uint64_t, it's safe to cast it to uint32_t, because furi_hal_rtc_datetime_to_timestamp only returns uint32_t
-        snprintf(buffer, sizeof(buffer), "%ld", (uint32_t)m->timestamp);
+        snprintf(buffer, sizeof(buffer), "%lu", (uint32_t)m->timestamp);
 
         canvas_draw_str(canvas, 5, 39 + STATUS_BAR_Y_SHIFT, buffer);
         canvas_draw_str(canvas, 0, 49 + STATUS_BAR_Y_SHIFT, "[< >] icounter value   [ok] save");

applications/services/desktop/views/desktop_view_lock_menu.c

@@ -53,7 +53,7 @@ void desktop_lock_menu_draw_callback(Canvas* canvas, void* model) {
     canvas_draw_icon(canvas, 116, 0 + STATUS_BAR_Y_SHIFT, &I_DoorRight_70x55);
     canvas_set_font(canvas, FontSecondary);
 
-    for(uint8_t i = 0; i < DesktopLockMenuIndexTotalCount; ++i) {
+    for(size_t i = 0; i < DesktopLockMenuIndexTotalCount; ++i) {
         const char* str = NULL;
 
         if(i == DesktopLockMenuIndexLock) {
@@ -64,7 +64,7 @@ void desktop_lock_menu_draw_callback(Canvas* canvas, void* model) {
             } else {
                 str = "Set PIN";
             }
-        } else if(i == DesktopLockMenuIndexDummy) {
+        } else if(i == DesktopLockMenuIndexDummy) { //-V547
             if(m->dummy_mode) {
                 str = "Brainiac Mode";
             } else {
@@ -72,7 +72,7 @@ void desktop_lock_menu_draw_callback(Canvas* canvas, void* model) {
             }
         }
 
-        if(str)
+        if(str) //-V547
             canvas_draw_str_aligned(
                 canvas, 64, 9 + (i * 17) + STATUS_BAR_Y_SHIFT, AlignCenter, AlignCenter, str);
 

applications/services/desktop/views/desktop_view_main.c

@@ -102,7 +102,6 @@ DesktopMainView* desktop_main_alloc() {
     DesktopMainView* main_view = malloc(sizeof(DesktopMainView));
 
     main_view->view = view_alloc();
-    view_allocate_model(main_view->view, ViewModelTypeLockFree, 1);
     view_set_context(main_view->view, main_view);
     view_set_input_callback(main_view->view, desktop_main_input_callback);
 

applications/services/desktop/views/desktop_view_pin_setup_done.c

@@ -18,7 +18,7 @@ struct DesktopViewPinSetupDone {
 
 static void desktop_view_pin_done_draw(Canvas* canvas, void* model) {
     furi_assert(canvas);
-    furi_assert(model);
+    UNUSED(model);
 
     canvas_set_font(canvas, FontPrimary);
     elements_multiline_text_aligned(
@@ -59,7 +59,6 @@ void desktop_view_pin_done_set_callback(
 DesktopViewPinSetupDone* desktop_view_pin_done_alloc() {
     DesktopViewPinSetupDone* view = malloc(sizeof(DesktopViewPinSetupDone));
     view->view = view_alloc();
-    view_allocate_model(view->view, ViewModelTypeLockFree, 1);
     view_set_context(view->view, view);
     view_set_draw_callback(view->view, desktop_view_pin_done_draw);
     view_set_input_callback(view->view, desktop_view_pin_done_input);

applications/services/desktop/views/desktop_view_pin_timeout.c

@@ -67,7 +67,7 @@ static void desktop_view_pin_timeout_draw(Canvas* canvas, void* _model) {
 
     canvas_set_font(canvas, FontSecondary);
     char str[30] = {0};
-    snprintf(str, sizeof(str), "Timeout: %lds", model->time_left);
+    snprintf(str, sizeof(str), "Timeout: %lus", model->time_left);
     canvas_draw_str_aligned(canvas, 64, 38, AlignCenter, AlignCenter, str);
 }
 

applications/services/dolphin/helpers/dolphin_state.c

@@ -171,7 +171,7 @@ void dolphin_state_on_deed(DolphinState* dolphin_state, DolphinDeed deed) {
 
     FURI_LOG_D(
         TAG,
-        "icounter %ld, butthurt %ld",
+        "icounter %lu, butthurt %ld",
         dolphin_state->data.icounter,
         dolphin_state->data.butthurt);
 }

applications/services/gui/canvas.h

@@ -17,6 +17,7 @@ extern "C" {
 typedef enum {
     ColorWhite = 0x00,
     ColorBlack = 0x01,
+    ColorXOR = 0x02,
 } Color;
 
 /** Fonts enumeration */

applications/services/gui/elements.c

@@ -41,6 +41,31 @@ void elements_progress_bar(Canvas* canvas, uint8_t x, uint8_t y, uint8_t width,
     canvas_draw_box(canvas, x + 1, y + 1, progress_length, height - 2);
 }
 
+void elements_progress_bar_with_text(
+    Canvas* canvas,
+    uint8_t x,
+    uint8_t y,
+    uint8_t width,
+    float progress,
+    const char* text) {
+    furi_assert(canvas);
+    furi_assert((progress >= 0.0f) && (progress <= 1.0f));
+    uint8_t height = 11;
+
+    uint8_t progress_length = roundf(progress * (width - 2));
+
+    canvas_set_color(canvas, ColorWhite);
+    canvas_draw_box(canvas, x + 1, y + 1, width - 2, height - 2);
+    canvas_set_color(canvas, ColorBlack);
+    canvas_draw_rframe(canvas, x, y, width, height, 3);
+
+    canvas_draw_box(canvas, x + 1, y + 1, progress_length, height - 2);
+
+    canvas_set_color(canvas, ColorXOR);
+    canvas_set_font(canvas, FontSecondary);
+    canvas_draw_str_aligned(canvas, x + width / 2, y + 2, AlignCenter, AlignTop, text);
+}
+
 void elements_scrollbar_pos(
     Canvas* canvas,
     uint8_t x,
@@ -291,11 +316,11 @@ void elements_multiline_text(Canvas* canvas, uint8_t x, uint8_t y, const char* t
         end = strchr(start, '\n');
         if(end) {
             furi_string_set_strn(str, start, end - start);
+            start = end + 1;
         } else {
             furi_string_set(str, start);
         }
         canvas_draw_str(canvas, x, y, furi_string_get_cstr(str));
-        start = end + 1;
         y += font_height;
     } while(end && y < 64);
     furi_string_free(str);

applications/services/gui/elements.h

@@ -31,6 +31,23 @@ extern "C" {
  */
 void elements_progress_bar(Canvas* canvas, uint8_t x, uint8_t y, uint8_t width, float progress);
 
+/** Draw progress bar with text.
+ *
+ * @param   canvas      Canvas instance
+ * @param   x           progress bar position on X axis
+ * @param   y           progress bar position on Y axis
+ * @param   width       progress bar width
+ * @param   progress    progress (0.0 - 1.0)
+ * @param   text        text to draw
+ */
+void elements_progress_bar_with_text(
+    Canvas* canvas,
+    uint8_t x,
+    uint8_t y,
+    uint8_t width,
+    float progress,
+    const char* text);
+
 /** Draw scrollbar on canvas at specific position.
  *
  * @param   canvas  Canvas instance

applications/services/gui/modules/button_panel.c

@@ -172,7 +172,7 @@ void button_panel_add_item(
     void* callback_context) {
     furi_assert(button_panel);
 
-    with_view_model(
+    with_view_model( //-V773
         button_panel->view,
         ButtonPanelModel * model,
         {

applications/services/gui/modules/byte_input.c

@@ -71,11 +71,13 @@ static uint8_t byte_input_get_row_size(uint8_t row_index) {
 
     switch(row_index + 1) {
     case 1:
-        row_size = sizeof(keyboard_keys_row_1) / sizeof(ByteInputKey);
+        row_size = COUNT_OF(keyboard_keys_row_1);
         break;
     case 2:
-        row_size = sizeof(keyboard_keys_row_2) / sizeof(ByteInputKey);
+        row_size = COUNT_OF(keyboard_keys_row_2);
         break;
+    default:
+        furi_crash(NULL);
     }
 
     return row_size;
@@ -97,6 +99,8 @@ static const ByteInputKey* byte_input_get_row(uint8_t row_index) {
     case 2:
         row = keyboard_keys_row_2;
         break;
+    default:
+        furi_crash(NULL);
     }
 
     return row;
@@ -383,6 +387,7 @@ static void byte_input_dec_selected_byte(ByteInputModel* model) {
     if(model->selected_byte > 0) {
         model->selected_byte -= 1;
 
+        furi_assert(model->selected_byte >= model->first_visible_byte);
         if(model->selected_byte - model->first_visible_byte < 1) {
             if(model->first_visible_byte > 0) {
                 model->first_visible_byte--;

applications/services/gui/modules/dialog_ex.c

@@ -147,7 +147,7 @@ DialogEx* dialog_ex_alloc() {
     DialogEx* dialog_ex = malloc(sizeof(DialogEx));
     dialog_ex->view = view_alloc();
     view_set_context(dialog_ex->view, dialog_ex);
-    view_allocate_model(dialog_ex->view, ViewModelTypeLockFree, sizeof(DialogExModel));
+    view_allocate_model(dialog_ex->view, ViewModelTypeLocking, sizeof(DialogExModel));
     view_set_draw_callback(dialog_ex->view, dialog_ex_view_draw_callback);
     view_set_input_callback(dialog_ex->view, dialog_ex_view_input_callback);
     with_view_model(

applications/services/gui/modules/file_browser.c

@@ -514,7 +514,7 @@ static void browser_draw_list(Canvas* canvas, FileBrowserModel* model) {
             scroll_counter = 0;
         }
 
-        if(custom_icon_data) {
+        if(custom_icon_data) { //-V547
             // Currently only 10*10 icons are supported
             canvas_draw_bitmap(
                 canvas, 2, Y_OFFSET + 1 + i * FRAME_HEIGHT, 10, 10, custom_icon_data);
@@ -544,6 +544,18 @@ static void browser_draw_list(Canvas* canvas, FileBrowserModel* model) {
             model->item_cnt);
     }
 
+    uint32_t folder_item_cnt = (model->is_root) ? (model->item_cnt) : (model->item_cnt - 1);
+    if(folder_item_cnt == 0) {
+        canvas_set_color(canvas, ColorBlack);
+        canvas_draw_str_aligned(
+            canvas,
+            canvas_width(canvas) / 2,
+            canvas_height(canvas) / 2,
+            AlignCenter,
+            AlignCenter,
+            "<Empty>");
+    }
+
     furi_string_free(filename);
 }
 
@@ -657,9 +669,7 @@ static bool file_browser_view_input_callback(InputEvent* event, void* context) {
 
             if(!is_root && !file_browser_worker_is_in_start_folder(browser->worker)) {
                 consumed = true;
-                if(!is_root) {
-                    file_browser_worker_folder_exit(browser->worker);
-                }
+                file_browser_worker_folder_exit(browser->worker);
             }
         }
     }

applications/services/gui/modules/file_browser_worker.c

@@ -375,7 +375,7 @@ BrowserWorker* file_browser_worker_alloc(
     const char* filter_ext,
     bool skip_assets,
     bool hide_dot_files) {
-    BrowserWorker* browser = malloc(sizeof(BrowserWorker)); //-V773
+    BrowserWorker* browser = malloc(sizeof(BrowserWorker));
 
     idx_last_array_init(browser->idx_last);
 
@@ -395,7 +395,7 @@ BrowserWorker* file_browser_worker_alloc(
     furi_thread_start(browser->thread);
 
     return browser;
-}
+} //-V773
 
 void file_browser_worker_free(BrowserWorker* browser) {
     furi_assert(browser);

applications/services/gui/modules/popup.c

@@ -117,7 +117,7 @@ Popup* popup_alloc() {
     popup->timer_enabled = false;
 
     view_set_context(popup->view, popup);
-    view_allocate_model(popup->view, ViewModelTypeLockFree, sizeof(PopupModel));
+    view_allocate_model(popup->view, ViewModelTypeLocking, sizeof(PopupModel));
     view_set_draw_callback(popup->view, popup_view_draw_callback);
     view_set_input_callback(popup->view, popup_view_input_callback);
     view_set_enter_callback(popup->view, popup_start_timer);

applications/services/gui/modules/submenu.c

@@ -225,8 +225,11 @@ void submenu_set_selected_item(Submenu* submenu, uint32_t index) {
 
             if(items_size <= items_on_screen) {
                 model->window_position = 0;
-            } else if(model->window_position >= items_size - items_on_screen) {
-                model->window_position = items_size - items_on_screen;
+            } else {
+                const size_t pos = items_size - items_on_screen;
+                if(model->window_position > pos) {
+                    model->window_position = pos;
+                }
             }
         },
         true);
@@ -242,8 +245,7 @@ void submenu_process_up(Submenu* submenu) {
 
             if(model->position > 0) {
                 model->position--;
-                if((model->position - model->window_position < 1) &&
-                   (model->window_position > 0)) {
+                if((model->position == model->window_position) && (model->window_position > 0)) {
                     model->window_position--;
                 }
             } else {

applications/services/gui/modules/text_input.c

@@ -92,14 +92,16 @@ static uint8_t get_row_size(uint8_t row_index) {
 
     switch(row_index + 1) {
     case 1:
-        row_size = sizeof(keyboard_keys_row_1) / sizeof(TextInputKey);
+        row_size = COUNT_OF(keyboard_keys_row_1);
         break;
     case 2:
-        row_size = sizeof(keyboard_keys_row_2) / sizeof(TextInputKey);
+        row_size = COUNT_OF(keyboard_keys_row_2);
         break;
     case 3:
-        row_size = sizeof(keyboard_keys_row_3) / sizeof(TextInputKey);
+        row_size = COUNT_OF(keyboard_keys_row_3);
         break;
+    default:
+        furi_crash(NULL);
     }
 
     return row_size;
@@ -118,6 +120,8 @@ static const TextInputKey* get_row(uint8_t row_index) {
     case 3:
         row = keyboard_keys_row_3;
         break;
+    default:
+        furi_crash(NULL);
     }
 
     return row;
@@ -184,7 +188,7 @@ static void text_input_view_draw_callback(Canvas* canvas, void* _model) {
 
     canvas_set_font(canvas, FontKeyboard);
 
-    for(uint8_t row = 0; row <= keyboard_row_count; row++) {
+    for(uint8_t row = 0; row < keyboard_row_count; row++) {
         const uint8_t column_count = get_row_size(row);
         const TextInputKey* keys = get_row(row);
 
@@ -303,7 +307,7 @@ static void text_input_handle_right(TextInput* text_input, TextInputModel* model
 
 static void text_input_handle_ok(TextInput* text_input, TextInputModel* model, bool shift) {
     char selected = get_selected_char(model);
-    uint8_t text_length = strlen(model->text_buffer);
+    size_t text_length = strlen(model->text_buffer);
 
     if(shift) {
         selected = char_to_uppercase(selected);
@@ -481,7 +485,6 @@ void text_input_reset(TextInput* text_input) {
         text_input->view,
         TextInputModel * model,
         {
-            model->text_buffer_size = 0;
             model->header = "";
             model->selected_row = 0;
             model->selected_column = 0;

applications/services/gui/modules/validators.c

@@ -18,15 +18,12 @@ bool validator_is_file_callback(const char* text, FuriString* error, void* conte
         }
     }
 
-    bool ret = true;
     FuriString* path = furi_string_alloc_printf(
         "%s/%s%s", instance->app_path_folder, text, instance->app_extension);
     Storage* storage = furi_record_open(RECORD_STORAGE);
-    if(storage_common_stat(storage, furi_string_get_cstr(path), NULL) == FSE_OK) {
-        ret = false;
+    const bool ret = storage_common_stat(storage, furi_string_get_cstr(path), NULL) != FSE_OK;
+    if(!ret) {
         furi_string_printf(error, "This name\nexists!\nChoose\nanother one.");
-    } else {
-        ret = true;
     }
     furi_string_free(path);
     furi_record_close(RECORD_STORAGE);

applications/services/gui/modules/variable_item_list.c

@@ -188,8 +188,8 @@ void variable_item_list_process_up(VariableItemList* variable_item_list) {
             uint8_t items_on_screen = 4;
             if(model->position > 0) {
                 model->position--;
-                if(((model->position - model->window_position) < 1) &&
-                   model->window_position > 0) {
+
+                if((model->position == model->window_position) && (model->window_position > 0)) {
                     model->window_position--;
                 }
             } else {

applications/services/gui/modules/widget_elements/widget_element_button.c

@@ -60,7 +60,7 @@ WidgetElement* widget_element_button_create(
     ButtonCallback callback,
     void* context) {
     // Allocate and init model
-    GuiButtonModel* model = malloc(sizeof(GuiButtonModel)); //-V773
+    GuiButtonModel* model = malloc(sizeof(GuiButtonModel));
     model->button_type = button_type;
     model->callback = callback;
     model->context = context;
@@ -75,4 +75,4 @@ WidgetElement* widget_element_button_create(
     gui_button->model = model;
 
     return gui_button;
-}
+} //-V773

applications/services/gui/modules/widget_elements/widget_element_string.c

@@ -62,4 +62,4 @@ WidgetElement* widget_element_string_create(
     gui_string->model = model;
 
     return gui_string;
-}
+} //-V773

applications/services/gui/modules/widget_elements/widget_element_string_multiline.c

@@ -63,4 +63,4 @@ WidgetElement* widget_element_string_multiline_create(
     gui_string->model = model;
 
     return gui_string;
-}
+} //-V773