SubGHz: Show reason for TX blocked --nobuild

applications/main/subghz/subghz_i.c

@@ -29,7 +29,10 @@ bool subghz_tx_start(SubGhz* subghz, FlipperFormat* flipper_format) {
             subghz->dialogs, "Error in protocol\nparameters\ndescription");
         break;
     case SubGhzTxRxStartTxStateErrorOnlyRx:
-        subghz_dialog_message_freq_error(subghz, true);
+        flipper_format_rewind(flipper_format);
+        uint32_t temp_data32;
+        flipper_format_read_uint32(flipper_format, "Frequency", &temp_data32, 1);
+        subghz_dialog_message_freq_error(subghz, furi_hal_subghz_check_tx(temp_data32));
         break;
 
     default:
@@ -39,19 +42,33 @@ bool subghz_tx_start(SubGhz* subghz, FlipperFormat* flipper_format) {
     return false;
 }
 
-void subghz_dialog_message_freq_error(SubGhz* subghz, bool only_rx) {
+void subghz_dialog_message_freq_error(SubGhz* subghz, FuriHalSubGhzTx can_tx) {
     DialogsApp* dialogs = subghz->dialogs;
     DialogMessage* message = dialog_message_alloc();
-    const char* header_text = "Frequency not supported";
-    const char* message_text = "Frequency\nis outside of\nsupported range.";
+    const char* header_text = "Transmission is blocked";
+    const char* message_text;
 
-    if(only_rx) {
-        header_text = "Transmission is blocked";
-        message_text = "Frequency\nis outside of\ndefault range.\nCheck docs.";
+    switch(can_tx) {
+    case FuriHalSubGhzTxAllowed:
+    default:
+        return;
+    case FuriHalSubGhzTxBlockedRegionNotProvisioned:
+        message_text = "Region is not\nprovisioned.\nUpdate firmware\nor bypass region.";
+        break;
+    case FuriHalSubGhzTxBlockedRegion:
+        message_text = "Frequency outside\nof region range.\nMNTM > Protocols\n> Bypass Region";
+        break;
+    case FuriHalSubGhzTxBlockedDefault:
+        message_text = "Frequency outside\nof default range.\nMNTM > Protocols\n> Extend Bands";
+        break;
+    case FuriHalSubGhzTxBlockedUnsupported:
+        header_text = "Frequency not supported";
+        message_text = "Frequency is\noutside of\nsupported range.";
+        break;
     }
 
     dialog_message_set_header(message, header_text, 64, 3, AlignCenter, AlignTop);
-    dialog_message_set_text(message, message_text, 3, 23, AlignLeft, AlignTop);
+    dialog_message_set_text(message, message_text, 3, 20, AlignLeft, AlignTop);
 
     dialog_message_set_icon(message, &I_WarningDolphinFlip_45x42, 83, 22);
 
@@ -73,6 +90,7 @@ bool subghz_key_load(SubGhz* subghz, const char* file_path, bool show_dialog) {
     uint32_t temp_data32;
     float temp_lat = NAN; // NAN or 0.0?? because 0.0 is valid value
     float temp_lon = NAN;
+    FuriHalSubGhzTx can_tx = FuriHalSubGhzTxAllowed;
 
     do {
         stream_clean(fff_data_stream);
@@ -102,12 +120,14 @@ bool subghz_key_load(SubGhz* subghz, const char* file_path, bool show_dialog) {
 
         if(!subghz_txrx_radio_device_is_frequency_valid(subghz->txrx, temp_data32)) {
             FURI_LOG_E(TAG, "Frequency not supported on chosen radio module");
+            can_tx = FuriHalSubGhzTxBlockedUnsupported;
             load_key_state = SubGhzLoadKeyStateUnsuportedFreq;
             break;
         }
 
         // TODO: use different frequency allowed lists for differnet modules (non cc1101)
-        if(!furi_hal_subghz_is_tx_allowed(temp_data32)) {
+        can_tx = furi_hal_subghz_check_tx(temp_data32);
+        if(can_tx != FuriHalSubGhzTxAllowed) {
             FURI_LOG_E(TAG, "This frequency can only be used for RX");
 
             load_key_state = SubGhzLoadKeyStateOnlyRx;
@@ -212,14 +232,9 @@ bool subghz_key_load(SubGhz* subghz, const char* file_path, bool show_dialog) {
         return false;
 
     case SubGhzLoadKeyStateUnsuportedFreq:
-        if(show_dialog) {
-            subghz_dialog_message_freq_error(subghz, false);
-        }
-        return false;
-
     case SubGhzLoadKeyStateOnlyRx:
         if(show_dialog) {
-            subghz_dialog_message_freq_error(subghz, true);
+            subghz_dialog_message_freq_error(subghz, can_tx);
         }
         return false;
 

applications/main/subghz/subghz_i.h

@@ -115,7 +115,7 @@ void subghz_blink_start(SubGhz* subghz);
 void subghz_blink_stop(SubGhz* subghz);
 
 bool subghz_tx_start(SubGhz* subghz, FlipperFormat* flipper_format);
-void subghz_dialog_message_freq_error(SubGhz* subghz, bool only_rx);
+void subghz_dialog_message_freq_error(SubGhz* subghz, FuriHalSubGhzTx can_tx);
 
 bool subghz_key_load(SubGhz* subghz, const char* file_path, bool show_dialog);
 bool subghz_get_next_name_file(SubGhz* subghz, uint8_t max_len);

targets/f7/api_symbols.csv

@@ -1676,6 +1676,7 @@ Function,-,furi_hal_spi_config_init,void,
 Function,-,furi_hal_spi_config_init_early,void,
 Function,-,furi_hal_spi_dma_init,void,
 Function,+,furi_hal_spi_release,void,FuriHalSpiBusHandle*
+Function,+,furi_hal_subghz_check_tx,FuriHalSubGhzTx,uint32_t
 Function,-,furi_hal_subghz_dump_state,void,
 Function,+,furi_hal_subghz_flush_rx,void,
 Function,+,furi_hal_subghz_flush_tx,void,

targets/f7/furi_hal/furi_hal_subghz.c

@@ -1,6 +1,7 @@
 #include <furi_hal_subghz.h>
 #include <lib/subghz/devices/cc1101_configs.h>
 #include <furi_hal_region_i.h>
+#include <furi_hal_region.h>
 #include <furi_hal_version.h>
 #include <furi_hal_rtc.h>
 #include <furi_hal_spi.h>
@@ -389,32 +390,40 @@ uint32_t furi_hal_subghz_set_frequency_and_path(uint32_t value) {
     return value;
 }
 
-bool furi_hal_subghz_is_tx_allowed(uint32_t value) {
-    if(!furi_hal_subghz.bypass_region) {
-        if(!_furi_hal_region_is_frequency_allowed(value)) {
-            FURI_LOG_I(TAG, "Frequency blocked - outside region range");
-            return false;
+FuriHalSubGhzTx furi_hal_subghz_check_tx(uint32_t value) {
+    // Check against extended range of YARD Stick One, no configuration would allow this frequency
+    if(!furi_hal_subghz_is_frequency_valid(value)) {
+        FURI_LOG_I(TAG, "Frequency blocked - outside supported range");
+        return FuriHalSubGhzTxBlockedUnsupported;
     }
 
-        return true;
-    }
-
-    bool allow_extended_for_int = furi_hal_subghz.extended_frequency_i;
-
-    if(!(allow_extended_for_int) &&
+    // Check against default range, regardless of region restrictions
+    if(!furi_hal_subghz.extended_frequency_i &&
        !(value >= 299999755 && value <= 350000335) && // was increased from 348 to 350
        !(value >= 386999938 && value <= 467750000) && // was increased from 464 to 467.75
        !(value >= 778999847 && value <= 928000000)) {
         FURI_LOG_I(TAG, "Frequency blocked - outside default range");
-        return false;
-    } else if(
-        (allow_extended_for_int) && //
-        !furi_hal_subghz_is_frequency_valid(value)) {
-        FURI_LOG_I(TAG, "Frequency blocked - outside extended range");
-        return false;
+        return FuriHalSubGhzTxBlockedDefault;
     }
 
-    return true;
+    // Check against region restrictions, tighter than extended and default
+    if(!furi_hal_subghz.bypass_region) {
+        if(!furi_hal_region_is_provisioned()) {
+            FURI_LOG_I(TAG, "Frequency blocked - region not provisioned");
+            return FuriHalSubGhzTxBlockedRegionNotProvisioned;
+        }
+        if(!_furi_hal_region_is_frequency_allowed(value)) {
+            FURI_LOG_I(TAG, "Frequency blocked - outside region range");
+            return FuriHalSubGhzTxBlockedRegion;
+        }
+    }
+
+    // We already checked for extended range, default range, and region range
+    return FuriHalSubGhzTxAllowed;
+}
+
+bool furi_hal_subghz_is_tx_allowed(uint32_t value) {
+    return furi_hal_subghz_check_tx(value) == FuriHalSubGhzTxAllowed;
 }
 
 uint32_t furi_hal_subghz_set_frequency(uint32_t value) {

targets/f7/furi_hal/furi_hal_subghz.h

@@ -165,6 +165,22 @@ bool furi_hal_subghz_is_frequency_valid(uint32_t value);
  */
 uint32_t furi_hal_subghz_set_frequency_and_path(uint32_t value);
 
+typedef enum {
+    FuriHalSubGhzTxAllowed, // TX is allowed with this configuration
+    FuriHalSubGhzTxBlockedRegionNotProvisioned, // Region not provisioned and not bypassed
+    FuriHalSubGhzTxBlockedRegion, // Outside region, needs bypass region
+    FuriHalSubGhzTxBlockedDefault, // Outisde default, needs extended range
+    FuriHalSubGhzTxBlockedUnsupported, // No configuration would allow this
+} FuriHalSubGhzTx;
+
+/** Сheck if and why transmission is blocked on this frequency with current config
+ *
+ * @param      value  frequency in Hz
+ *
+ * @return     tx allowed or blocked enum
+ */
+FuriHalSubGhzTx furi_hal_subghz_check_tx(uint32_t value);
+
 /** Сheck if transmission is allowed on this frequency with your current config
  *
  * @param      value  frequency in Hz