Merge pull request #4 from LTX128/main

Add Device Name changer in System Settings

README.md

@@ -60,6 +60,10 @@ This project may incorporate, adapt, or build upon **other open-source projects*
 | Subaru | Subaru | 433 MHz | AM | Yes | Yes | No |
 | Suzuki | Suzuki | 433 MHz | FM | Yes | Yes | Yes |
 | Mitsubishi | Mitsubishi V0 | 868 MHz | FM | Yes | Yes | No |
+| Starline | Star Line | 433 MHz | AM | Yes | Yes | No |
+| Scher-Khan | Scher-Khan | 433 MHz | FM | Yes | Yes | No |
+| Scher-Khan | Magic Code PRO1/PRO2 | 433 MHz | FM | Yes | Yes | Yes |
+| Sheriff | Sheriff CFM (ZX-750/930) | 433 MHz | AM | Yes | Yes | No |
 
 ### Gate / Access Protocols
 

applications/main/subghz/views/transmitter.c

@@ -155,6 +155,22 @@ bool subghz_view_transmitter_input(InputEvent* event, void* context) {
         true);
 
     if(can_be_sent) {
+        if(event->type == InputTypeLong) {
+            if(event->key == InputKeyUp) {
+                subghz_custom_btn_set(SUBGHZ_CUSTOM_BTN_UP);
+                subghz_custom_btn_set_long(true);
+        } else if(event->key == InputKeyDown) {
+            subghz_custom_btn_set(SUBGHZ_CUSTOM_BTN_DOWN);
+            subghz_custom_btn_set_long(true);
+        } else if(event->key == InputKeyLeft) {
+            subghz_custom_btn_set(SUBGHZ_CUSTOM_BTN_LEFT);
+            subghz_custom_btn_set_long(true);
+        } else if(event->key == InputKeyRight) {
+            subghz_custom_btn_set(SUBGHZ_CUSTOM_BTN_RIGHT);
+            subghz_custom_btn_set_long(true);
+        }
+    }
+
         if(event->key == InputKeyOk && event->type == InputTypePress) {
             subghz_custom_btn_set(SUBGHZ_CUSTOM_BTN_OK);
             with_view_model(

applications/services/desktop/desktop.c

@@ -282,6 +282,7 @@ static Desktop* desktop_alloc(void) {
     desktop->pin_input_view = desktop_view_pin_input_alloc();
     desktop->pin_timeout_view = desktop_view_pin_timeout_alloc();
     desktop->slideshow_view = desktop_view_slideshow_alloc();
+    //desktop->tos_view = desktop_view_tos_alloc();
 
     desktop->main_view_stack = view_stack_alloc();
     desktop->main_view = desktop_main_alloc();
@@ -326,6 +327,10 @@ static Desktop* desktop_alloc(void) {
         desktop->view_dispatcher,
         DesktopViewIdSlideshow,
         desktop_view_slideshow_get_view(desktop->slideshow_view));
+    //view_dispatcher_add_view(
+        //desktop->view_dispatcher,
+        //DesktopViewIdTos,
+        //desktop_view_tos_get_view(desktop->tos_view));
 
     // Lock icon
     desktop->lock_icon_viewport = view_port_alloc();
@@ -511,7 +516,9 @@ int32_t desktop_srv(void* p) {
 
     if(storage_file_exists(desktop->storage, SLIDESHOW_FS_PATH)) {
         scene_manager_next_scene(desktop->scene_manager, DesktopSceneSlideshow);
-    }
+    } //else {
+        //scene_manager_next_scene(desktop->scene_manager, DesktopSceneTos);
+    //}
 
     if(!furi_hal_version_do_i_belong_here()) {
         scene_manager_next_scene(desktop->scene_manager, DesktopSceneHwMismatch);

applications/services/desktop/desktop_i.h

@@ -11,6 +11,8 @@
 #include "views/desktop_view_lock_menu.h"
 #include "views/desktop_view_debug.h"
 #include "views/desktop_view_slideshow.h"
+//#include "views/desktop_view_tos.h"
+
 
 #include <gui/gui.h>
 #include <gui/view_stack.h>

applications/services/desktop/scenes/desktop_scene_slideshow.c

@@ -30,6 +30,7 @@ bool desktop_scene_slideshow_on_event(void* context, SceneManagerEvent event) {
         switch(event.event) {
         case DesktopSlideshowCompleted:
             scene_manager_previous_scene(desktop->scene_manager);
+            //scene_manager_search_and_switch_to_another_scene(desktop->scene_manager, DesktopSceneTos);
             consumed = true;
             break;
         case DesktopSlideshowPoweroff:

applications/settings/system/application.fam

@@ -3,7 +3,7 @@ App(
     name="System",
     apptype=FlipperAppType.SETTINGS,
     entry_point="system_settings_app",
-    requires=["gui", "locale"],
-    stack_size=1 * 1024,
+    requires=["gui", "locale", "storage"],
+    stack_size=2 * 1024,
     order=30,
 )

applications/settings/system/system_settings.c

@@ -2,6 +2,9 @@
 #include <loader/loader.h>
 #include <lib/toolbox/value_index.h>
 #include <locale/locale.h>
+#include <flipper_format/flipper_format.h>
+#include <power/power_service/power.h>
+#include <applications/services/namechanger/namechanger.h>
 
 const char* const log_level_text[] = {
     "Default",
@@ -208,6 +211,81 @@ static void filename_scheme_changed(VariableItem* item) {
     }
 }
 
+// ---- Device Name --------------------------------------------------------
+
+#define DEVICE_NAME_ITEM_INDEX 11
+
+static bool system_settings_device_name_validator(
+    const char* text,
+    FuriString* error,
+    void* context) {
+    UNUSED(context);
+    for(; *text; ++text) {
+        const char c = *text;
+        if((c < '0' || c > '9') && (c < 'A' || c > 'Z') && (c < 'a' || c > 'z')) {
+            furi_string_printf(error, "Letters and\nnumbers only!");
+            return false;
+        }
+    }
+    return true;
+}
+
+static void system_settings_device_name_callback(void* context) {
+    SystemSettings* app = context;
+
+    // Save name to SD card (same path as namechanger service)
+    FlipperFormat* file = flipper_format_file_alloc(app->storage);
+    bool saved = false;
+    do {
+        if(app->device_name[0] == '\0') {
+            // Empty name -> remove file to restore real name
+            storage_simply_remove(app->storage, NAMECHANGER_PATH);
+            saved = true;
+            break;
+        }
+        if(!flipper_format_file_open_always(file, NAMECHANGER_PATH)) break;
+        if(!flipper_format_write_header_cstr(file, NAMECHANGER_HEADER, NAMECHANGER_VERSION)) break;
+        if(!flipper_format_write_string_cstr(file, "Name", app->device_name)) break;
+        saved = true;
+    } while(false);
+    flipper_format_free(file);
+
+    if(saved) {
+        // Reboot to apply
+        Power* power = furi_record_open(RECORD_POWER);
+        power_reboot(power, PowerBootModeNormal);
+    } else {
+        // Go back silently on failure
+        view_dispatcher_switch_to_view(app->view_dispatcher, SystemSettingsViewVarItemList);
+    }
+}
+
+static void system_settings_enter_callback(void* context, uint32_t index) {
+    SystemSettings* app = context;
+    if(index == DEVICE_NAME_ITEM_INDEX) {
+        text_input_reset(app->text_input);
+        text_input_set_header_text(app->text_input, "Device Name (empty=reset)");
+        text_input_set_validator(
+            app->text_input, system_settings_device_name_validator, NULL);
+        text_input_set_minimum_length(app->text_input, 0);
+        text_input_set_result_callback(
+            app->text_input,
+            system_settings_device_name_callback,
+            app,
+            app->device_name,
+            FURI_HAL_VERSION_ARRAY_NAME_LENGTH,
+            false);
+        view_dispatcher_switch_to_view(app->view_dispatcher, SystemSettingsViewTextInput);
+    }
+}
+
+static uint32_t system_settings_text_input_back(void* context) {
+    UNUSED(context);
+    return SystemSettingsViewVarItemList;
+}
+
+// -------------------------------------------------------------------------
+
 static uint32_t system_settings_exit(void* context) {
     UNUSED(context);
     return VIEW_NONE;
@@ -218,6 +296,7 @@ SystemSettings* system_settings_alloc(void) {
 
     // Load settings
     app->gui = furi_record_open(RECORD_GUI);
+    app->storage = furi_record_open(RECORD_STORAGE);
 
     app->view_dispatcher = view_dispatcher_alloc();
     view_dispatcher_set_event_callback_context(app->view_dispatcher, app);
@@ -314,6 +393,19 @@ SystemSettings* system_settings_alloc(void) {
     variable_item_set_current_value_index(item, value_index);
     variable_item_set_current_value_text(item, filename_scheme[value_index]);
 
+    // Device Name (index = DEVICE_NAME_ITEM_INDEX = 11)
+    const char* current_name = furi_hal_version_get_name_ptr();
+    strlcpy(
+        app->device_name,
+        current_name ? current_name : "",
+        FURI_HAL_VERSION_ARRAY_NAME_LENGTH);
+    item = variable_item_list_add(app->var_item_list, "Device Name", 0, NULL, app);
+    variable_item_set_current_value_text(
+        item, app->device_name[0] != '\0' ? app->device_name : "<default>");
+
+    variable_item_list_set_enter_callback(
+        app->var_item_list, system_settings_enter_callback, app);
+
     view_set_previous_callback(
         variable_item_list_get_view(app->var_item_list), system_settings_exit);
     view_dispatcher_add_view(
@@ -321,6 +413,15 @@ SystemSettings* system_settings_alloc(void) {
         SystemSettingsViewVarItemList,
         variable_item_list_get_view(app->var_item_list));
 
+    // TextInput for device name
+    app->text_input = text_input_alloc();
+    view_set_previous_callback(
+        text_input_get_view(app->text_input), system_settings_text_input_back);
+    view_dispatcher_add_view(
+        app->view_dispatcher,
+        SystemSettingsViewTextInput,
+        text_input_get_view(app->text_input));
+
     view_dispatcher_switch_to_view(app->view_dispatcher, SystemSettingsViewVarItemList);
 
     return app;
@@ -328,12 +429,16 @@ SystemSettings* system_settings_alloc(void) {
 
 void system_settings_free(SystemSettings* app) {
     furi_assert(app);
+    // TextInput
+    view_dispatcher_remove_view(app->view_dispatcher, SystemSettingsViewTextInput);
+    text_input_free(app->text_input);
     // Variable item list
     view_dispatcher_remove_view(app->view_dispatcher, SystemSettingsViewVarItemList);
     variable_item_list_free(app->var_item_list);
     // View dispatcher
     view_dispatcher_free(app->view_dispatcher);
     // Records
+    furi_record_close(RECORD_STORAGE);
     furi_record_close(RECORD_GUI);
     free(app);
 }

applications/settings/system/system_settings.h

@@ -2,17 +2,24 @@
 
 #include <furi.h>
 #include <furi_hal.h>
+#include <furi_hal_version.h>
 
 #include <gui/gui.h>
 #include <gui/view_dispatcher.h>
 #include <gui/modules/variable_item_list.h>
+#include <gui/modules/text_input.h>
+#include <storage/storage.h>
 
 typedef struct {
     Gui* gui;
     ViewDispatcher* view_dispatcher;
     VariableItemList* var_item_list;
+    TextInput* text_input;
+    Storage* storage;
+    char device_name[FURI_HAL_VERSION_ARRAY_NAME_LENGTH];
 } SystemSettings;
 
 typedef enum {
     SystemSettingsViewVarItemList,
+    SystemSettingsViewTextInput,
 } SystemSettingsView;

lib/subghz/blocks/custom_btn.c

@@ -5,6 +5,8 @@ static uint8_t custom_btn_original = 0;
 static uint8_t custom_btn_max_btns = 0;
 static uint8_t controller_programming_mode = PROG_MODE_OFF;
 
+static bool subghz_custom_btn_long = false;
+
 bool subghz_custom_btn_set(uint8_t btn_id) {
     if(btn_id > custom_btn_max_btns) {
         custom_btn_id = SUBGHZ_CUSTOM_BTN_OK;
@@ -36,6 +38,7 @@ void subghz_custom_btns_reset(void) {
     custom_btn_max_btns = 0;
     controller_programming_mode = PROG_MODE_OFF;
     custom_btn_id = SUBGHZ_CUSTOM_BTN_OK;
+    subghz_custom_btn_long = false;
 }
 
 bool subghz_custom_btn_is_allowed(void) {
@@ -49,3 +52,11 @@ void subghz_custom_btn_set_prog_mode(ProgMode prog_mode) {
 ProgMode subghz_custom_btn_get_prog_mode(void) {
     return controller_programming_mode;
 }
+
+void subghz_custom_btn_set_long(bool v) {
+    subghz_custom_btn_long = v;
+}
+
+bool subghz_custom_btn_get_long(void) {
+    return subghz_custom_btn_long;
+}

lib/subghz/blocks/custom_btn.h

@@ -25,6 +25,9 @@ void subghz_custom_btns_reset(void);
 
 bool subghz_custom_btn_is_allowed(void);
 
+void subghz_custom_btn_set_long(bool v);
+bool subghz_custom_btn_get_long(void);
+
 #ifdef __cplusplus
 }
 #endif

lib/subghz/protocols/ford_v0.h

@@ -1,23 +1,11 @@
 #pragma once
 
-#include <furi.h>
-#include <lib/subghz/protocols/base.h>
-#include <lib/subghz/types.h>
-#include <lib/subghz/blocks/const.h>
-#include <lib/subghz/blocks/decoder.h>
-#include <lib/subghz/blocks/encoder.h>
-#include <lib/subghz/blocks/generic.h>
-#include <lib/subghz/blocks/math.h>
-#include <flipper_format/flipper_format.h>
-#include <lib/toolbox/manchester_decoder.h>
+#include "base.h"
 
-#include <lib/subghz/blocks/custom_btn.h>
-
-#define FORD_PROTOCOL_V0_NAME "Ford V0"
+#define SUBGHZ_PROTOCOL_FORD_V0_NAME "FORD V0"
 
 extern const SubGhzProtocol subghz_protocol_ford_v0;
 
-// Decoder functions
 void* subghz_protocol_decoder_ford_v0_alloc(SubGhzEnvironment* environment);
 void subghz_protocol_decoder_ford_v0_free(void* context);
 void subghz_protocol_decoder_ford_v0_reset(void* context);
@@ -31,7 +19,6 @@ SubGhzProtocolStatus
     subghz_protocol_decoder_ford_v0_deserialize(void* context, FlipperFormat* flipper_format);
 void subghz_protocol_decoder_ford_v0_get_string(void* context, FuriString* output);
 
-// Encoder functions
 void* subghz_protocol_encoder_ford_v0_alloc(SubGhzEnvironment* environment);
 void subghz_protocol_encoder_ford_v0_free(void* context);
 SubGhzProtocolStatus

lib/subghz/protocols/protocol_items.c

@@ -72,6 +72,9 @@ const SubGhzProtocol* const subghz_protocol_registry_items[] = {
     &subghz_protocol_kia_v6,
     &subghz_protocol_suzuki, 
     &subghz_protocol_mitsubishi_v0,
+    &subghz_protocol_star_line,
+    &subghz_protocol_scher_khan,
+    &subghz_protocol_sheriff_cfm,
 };
 
 const SubGhzProtocolRegistry subghz_protocol_registry = {

lib/subghz/protocols/protocol_items.h

@@ -74,3 +74,6 @@
 #include "suzuki.h"
 #include "mitsubishi_v0.h"
 #include "mazda_siemens.h"
+#include "star_line.h"
+#include "scher_khan.h"
+#include "sheriff_cfm.h"

lib/subghz/protocols/scher_khan.h

@@ -0,0 +1,44 @@
+#pragma once
+#include <furi.h>
+#include <lib/subghz/protocols/base.h>
+#include <lib/subghz/types.h>
+#include <lib/subghz/blocks/const.h>
+#include <lib/subghz/blocks/decoder.h>
+#include <lib/subghz/blocks/encoder.h>
+#include <lib/subghz/blocks/generic.h>
+#include <lib/subghz/blocks/math.h>
+#include <lib/toolbox/manchester_decoder.h>
+#include <flipper_format/flipper_format.h>
+
+#define SUBGHZ_PROTOCOL_SCHER_KHAN_NAME "Scher-Khan"
+
+typedef struct SubGhzProtocolDecoderScherKhan SubGhzProtocolDecoderScherKhan;
+typedef struct SubGhzProtocolEncoderScherKhan SubGhzProtocolEncoderScherKhan;
+
+extern const SubGhzProtocolDecoder subghz_protocol_scher_khan_decoder;
+extern const SubGhzProtocolEncoder subghz_protocol_scher_khan_encoder;
+extern const SubGhzProtocol subghz_protocol_scher_khan;
+
+void* subghz_protocol_decoder_scher_khan_alloc(SubGhzEnvironment* environment);
+void subghz_protocol_decoder_scher_khan_free(void* context);
+void subghz_protocol_decoder_scher_khan_reset(void* context);
+void subghz_protocol_decoder_scher_khan_feed(void* context, bool level, uint32_t duration);
+
+uint8_t subghz_protocol_decoder_scher_khan_get_hash_data(void* context);
+
+SubGhzProtocolStatus subghz_protocol_decoder_scher_khan_serialize(
+    void* context,
+    FlipperFormat* flipper_format,
+    SubGhzRadioPreset* preset);
+
+SubGhzProtocolStatus
+    subghz_protocol_decoder_scher_khan_deserialize(void* context, FlipperFormat* flipper_format);
+
+void subghz_protocol_decoder_scher_khan_get_string(void* context, FuriString* output);
+
+void* subghz_protocol_encoder_scher_khan_alloc(SubGhzEnvironment* environment);
+void subghz_protocol_encoder_scher_khan_free(void* context);
+SubGhzProtocolStatus
+    subghz_protocol_encoder_scher_khan_deserialize(void* context, FlipperFormat* flipper_format);
+void subghz_protocol_encoder_scher_khan_stop(void* context);
+LevelDuration subghz_protocol_encoder_scher_khan_yield(void* context);

lib/subghz/protocols/sheriff_cfm.c

@@ -0,0 +1,634 @@
+#include "sheriff_cfm.h"
+#include "keeloq_common.h"
+#include "../blocks/custom_btn_i.h"
+#include "../blocks/generic.h"
+
+#include <string.h>
+
+#define TAG "SubGhzProtocolSheriffCfm"
+
+static const uint8_t cfm_pi_bytes[] = {
+    0xA4, 0x58, 0xFE, 0xA3, 0xF4, 0x93, 0x3D, 0x7E,
+    0x0D, 0x95, 0x74, 0x8F, 0x72, 0x8E, 0xB6, 0x58,
+};
+
+static const uint8_t cfm_zx750_encoded[8] = {
+    0x32, 0x4D, 0xCB, 0x84, 0x5F, 0xE9, 0x27, 0xCB,
+};
+
+static const uint8_t cfm_zx930_encoded[8] = {
+    0x94, 0x3B, 0x63, 0xA5, 0xE8, 0xF3, 0xAB, 0x60,
+};
+
+static void cfm_pi_decode(uint8_t* out, const uint8_t* encoded, size_t pi_offset, size_t len) {
+    for(size_t i = 0; i < len; i++) {
+        out[i] = encoded[i] ^ cfm_pi_bytes[pi_offset + i];
+    }
+}
+
+static uint8_t cfm_rlf(uint8_t in) {
+    return (uint8_t)((in << 1) | (in >> 7));
+}
+
+static uint8_t cfm_rrf(uint8_t in) {
+    return (uint8_t)((in >> 1) | (in << 7));
+}
+
+static uint8_t cfm_swap(uint8_t in) {
+    return (uint8_t)((in << 4) | (in >> 4));
+}
+
+typedef enum {
+    SheriffCfmModelZX750 = 0,
+    SheriffCfmModelZX930 = 1,
+    SheriffCfmModelCount = 2,
+} SheriffCfmModel;
+
+static const char* cfm_model_name(SheriffCfmModel model) {
+    switch(model) {
+    case SheriffCfmModelZX750: return "ZX-750";
+    case SheriffCfmModelZX930: return "ZX-930";
+    default: return "?";
+    }
+}
+
+static void cfm_decrypt_transform(uint8_t* hop, SheriffCfmModel model) {
+    uint8_t temp;
+    switch(model) {
+    case SheriffCfmModelZX750:
+        hop[0] = cfm_swap(hop[0]);
+        hop[2] = cfm_swap(hop[2]);
+        break;
+
+    case SheriffCfmModelZX930:
+        hop[0] = ~hop[0];
+        temp = hop[1];
+        hop[1] = hop[2];
+        hop[2] = temp;
+        hop[0] = cfm_rrf(hop[0]);
+        hop[1] = cfm_swap(hop[1]);
+        hop[1] = cfm_rlf(hop[1]);
+        hop[1] = cfm_rlf(hop[1]);
+        break;
+
+    default:
+        break;
+    }
+}
+
+static void cfm_encrypt_transform(uint8_t* hop, SheriffCfmModel model) {
+    uint8_t temp;
+    switch(model) {
+    case SheriffCfmModelZX750:
+        hop[0] = cfm_swap(hop[0]);
+        hop[2] = cfm_swap(hop[2]);
+        break;
+
+    case SheriffCfmModelZX930:
+        hop[1] = cfm_rrf(hop[1]);
+        hop[1] = cfm_rrf(hop[1]);
+        hop[1] = cfm_swap(hop[1]);
+        hop[0] = cfm_rlf(hop[0]);
+        hop[0] = ~hop[0];
+        temp = hop[1];
+        hop[1] = hop[2];
+        hop[2] = temp;
+        break;
+
+    default:
+        break;
+    }
+}
+
+static const char* cfm_btn_name(uint8_t btn) {
+    switch(btn) {
+    case 0x10: return "Lock";
+    case 0x20: return "Unlock";
+    case 0x40: return "Trunk";
+    case 0x80: return "Panic";
+    default: return "?";
+    }
+}
+
+static uint8_t cfm_btn_to_custom(uint8_t btn) {
+    switch(btn) {
+    case 0x10: return SUBGHZ_CUSTOM_BTN_UP;
+    case 0x20: return SUBGHZ_CUSTOM_BTN_DOWN;
+    case 0x40: return SUBGHZ_CUSTOM_BTN_LEFT;
+    case 0x80: return SUBGHZ_CUSTOM_BTN_RIGHT;
+    default: return SUBGHZ_CUSTOM_BTN_OK;
+    }
+}
+
+static uint8_t cfm_custom_to_btn(uint8_t custom, uint8_t original_btn) {
+    if(custom == SUBGHZ_CUSTOM_BTN_OK) return original_btn;
+    if(custom == SUBGHZ_CUSTOM_BTN_UP) return 0x10;
+    if(custom == SUBGHZ_CUSTOM_BTN_DOWN) return 0x20;
+    if(custom == SUBGHZ_CUSTOM_BTN_LEFT) return 0x40;
+    if(custom == SUBGHZ_CUSTOM_BTN_RIGHT) return 0x80;
+    return original_btn;
+}
+
+static uint8_t cfm_get_btn_code(uint8_t original_btn) {
+    return cfm_custom_to_btn(subghz_custom_btn_get(), original_btn);
+}
+
+static const SubGhzBlockConst subghz_protocol_sheriff_cfm_const = {
+    .te_short = 400,
+    .te_long = 800,
+    .te_delta = 140,
+    .min_count_bit_for_found = 64,
+};
+
+struct SubGhzProtocolDecoderSheriffCfm {
+    SubGhzProtocolDecoderBase base;
+    SubGhzBlockDecoder decoder;
+    SubGhzBlockGeneric generic;
+    uint16_t header_count;
+    SheriffCfmModel model;
+};
+
+struct SubGhzProtocolEncoderSheriffCfm {
+    SubGhzProtocolEncoderBase base;
+    SubGhzProtocolBlockEncoder encoder;
+    SubGhzBlockGeneric generic;
+    SheriffCfmModel model;
+};
+
+typedef enum {
+    SheriffCfmDecoderStepReset = 0,
+    SheriffCfmDecoderStepCheckPreambula,
+    SheriffCfmDecoderStepSaveDuration,
+    SheriffCfmDecoderStepCheckDuration,
+} SheriffCfmDecoderStep;
+
+const SubGhzProtocolDecoder subghz_protocol_sheriff_cfm_decoder = {
+    .alloc = subghz_protocol_decoder_sheriff_cfm_alloc,
+    .free = subghz_protocol_decoder_sheriff_cfm_free,
+    .feed = subghz_protocol_decoder_sheriff_cfm_feed,
+    .reset = subghz_protocol_decoder_sheriff_cfm_reset,
+    .get_hash_data = subghz_protocol_decoder_sheriff_cfm_get_hash_data,
+    .serialize = subghz_protocol_decoder_sheriff_cfm_serialize,
+    .deserialize = subghz_protocol_decoder_sheriff_cfm_deserialize,
+    .get_string = subghz_protocol_decoder_sheriff_cfm_get_string,
+};
+
+const SubGhzProtocolEncoder subghz_protocol_sheriff_cfm_encoder = {
+    .alloc = subghz_protocol_encoder_sheriff_cfm_alloc,
+    .free = subghz_protocol_encoder_sheriff_cfm_free,
+    .deserialize = subghz_protocol_encoder_sheriff_cfm_deserialize,
+    .stop = subghz_protocol_encoder_sheriff_cfm_stop,
+    .yield = subghz_protocol_encoder_sheriff_cfm_yield,
+};
+
+const SubGhzProtocol subghz_protocol_sheriff_cfm = {
+    .name = SUBGHZ_PROTOCOL_SHERIFF_CFM_NAME,
+    .type = SubGhzProtocolTypeDynamic,
+    .flag = SubGhzProtocolFlag_433 | SubGhzProtocolFlag_AM |
+            SubGhzProtocolFlag_Decodable |
+            SubGhzProtocolFlag_Load | SubGhzProtocolFlag_Save | SubGhzProtocolFlag_Send,
+    .decoder = &subghz_protocol_sheriff_cfm_decoder,
+    .encoder = &subghz_protocol_sheriff_cfm_encoder,
+};
+
+static uint64_t cfm_get_mfkey(SheriffCfmModel model) {
+    uint8_t dkey[8];
+    switch(model) {
+    case SheriffCfmModelZX750:
+        cfm_pi_decode(dkey, cfm_zx750_encoded, 0, 8);
+        break;
+    case SheriffCfmModelZX930:
+        cfm_pi_decode(dkey, cfm_zx930_encoded, 8, 8);
+        break;
+    default:
+        return 0;
+    }
+    uint64_t key = 0;
+    for(int i = 7; i >= 0; i--) {
+        key = (key << 8) | dkey[i];
+    }
+    return key;
+}
+
+static bool cfm_try_decrypt(
+    uint64_t data,
+    SheriffCfmModel* out_model,
+    uint8_t* out_btn,
+    uint32_t* out_serial,
+    uint16_t* out_cnt) {
+
+    uint32_t hop_encrypted = (uint32_t)(data & 0xFFFFFFFF);
+    uint32_t fix = (uint32_t)(data >> 32);
+
+    for(SheriffCfmModel model = 0; model < SheriffCfmModelCount; model++) {
+        uint8_t hop_bytes[4];
+        hop_bytes[0] = (uint8_t)(hop_encrypted & 0xFF);
+        hop_bytes[1] = (uint8_t)((hop_encrypted >> 8) & 0xFF);
+        hop_bytes[2] = (uint8_t)((hop_encrypted >> 16) & 0xFF);
+        hop_bytes[3] = (uint8_t)((hop_encrypted >> 24) & 0xFF);
+
+        cfm_decrypt_transform(hop_bytes, model);
+
+        uint32_t hop_transformed =
+            (uint32_t)hop_bytes[0] |
+            ((uint32_t)hop_bytes[1] << 8) |
+            ((uint32_t)hop_bytes[2] << 16) |
+            ((uint32_t)hop_bytes[3] << 24);
+
+        uint64_t mfkey = cfm_get_mfkey(model);
+        uint32_t decrypted = subghz_protocol_keeloq_common_decrypt(hop_transformed, mfkey);
+
+        uint16_t dec_serial_lo = (uint16_t)((decrypted >> 16) & 0x3FF);
+        uint16_t fix_serial_lo = (uint16_t)(fix & 0x3FF);
+
+        uint8_t btn_byte = (uint8_t)((decrypted >> 24) & 0xFF);
+        bool valid_btn = (btn_byte == 0x10 || btn_byte == 0x20 ||
+                          btn_byte == 0x40 || btn_byte == 0x80);
+
+        if(valid_btn && (dec_serial_lo == fix_serial_lo)) {
+            *out_model = model;
+            *out_btn = btn_byte;
+            *out_serial = fix;
+            *out_cnt = (uint16_t)(decrypted & 0xFFFF);
+            return true;
+        }
+    }
+    return false;
+}
+
+void* subghz_protocol_encoder_sheriff_cfm_alloc(SubGhzEnvironment* environment) {
+    UNUSED(environment);
+    SubGhzProtocolEncoderSheriffCfm* instance = malloc(sizeof(SubGhzProtocolEncoderSheriffCfm));
+    instance->base.protocol = &subghz_protocol_sheriff_cfm;
+    instance->generic.protocol_name = instance->base.protocol->name;
+    instance->encoder.repeat = 3;
+    instance->encoder.size_upload = 256;
+    instance->encoder.upload = malloc(instance->encoder.size_upload * sizeof(LevelDuration));
+    instance->encoder.is_running = false;
+    instance->encoder.front = 0;
+    instance->model = SheriffCfmModelZX750;
+    return instance;
+}
+
+void subghz_protocol_encoder_sheriff_cfm_free(void* context) {
+    furi_check(context);
+    SubGhzProtocolEncoderSheriffCfm* instance = context;
+    free(instance->encoder.upload);
+    free(instance);
+}
+
+static bool subghz_protocol_encoder_sheriff_cfm_get_upload(
+    SubGhzProtocolEncoderSheriffCfm* instance,
+    uint8_t btn) {
+    furi_check(instance);
+
+    if((instance->generic.cnt + 1) > 0xFFFF) {
+        instance->generic.cnt = 0;
+    } else {
+        instance->generic.cnt += 1;
+    }
+
+    uint32_t fix = (uint32_t)(instance->generic.data >> 32);
+    uint16_t serial_lo = (uint16_t)(fix & 0x3FF);
+    uint32_t hop_plain =
+        ((uint32_t)btn << 24) |
+        ((uint32_t)serial_lo << 16) |
+        (instance->generic.cnt & 0xFFFF);
+
+    uint64_t mfkey = cfm_get_mfkey(instance->model);
+    uint32_t hop_encrypted = subghz_protocol_keeloq_common_encrypt(hop_plain, mfkey);
+
+    uint8_t hop_bytes[4];
+    hop_bytes[0] = (uint8_t)(hop_encrypted & 0xFF);
+    hop_bytes[1] = (uint8_t)((hop_encrypted >> 8) & 0xFF);
+    hop_bytes[2] = (uint8_t)((hop_encrypted >> 16) & 0xFF);
+    hop_bytes[3] = (uint8_t)((hop_encrypted >> 24) & 0xFF);
+    cfm_encrypt_transform(hop_bytes, instance->model);
+
+    hop_encrypted =
+        (uint32_t)hop_bytes[0] |
+        ((uint32_t)hop_bytes[1] << 8) |
+        ((uint32_t)hop_bytes[2] << 16) |
+        ((uint32_t)hop_bytes[3] << 24);
+
+    instance->generic.data = ((uint64_t)fix << 32) | hop_encrypted;
+    instance->generic.btn = btn;
+
+    size_t index = 0;
+
+    for(uint8_t i = 11; i > 0; i--) {
+        instance->encoder.upload[index++] =
+            level_duration_make(true, (uint32_t)subghz_protocol_sheriff_cfm_const.te_short);
+        instance->encoder.upload[index++] =
+            level_duration_make(false, (uint32_t)subghz_protocol_sheriff_cfm_const.te_short);
+    }
+    instance->encoder.upload[index++] =
+        level_duration_make(true, (uint32_t)subghz_protocol_sheriff_cfm_const.te_short);
+    instance->encoder.upload[index++] =
+        level_duration_make(false, (uint32_t)subghz_protocol_sheriff_cfm_const.te_short * 10);
+
+    for(uint8_t i = instance->generic.data_count_bit; i > 0; i--) {
+        if(bit_read(instance->generic.data, i - 1)) {
+            instance->encoder.upload[index++] =
+                level_duration_make(true, (uint32_t)subghz_protocol_sheriff_cfm_const.te_short);
+            instance->encoder.upload[index++] =
+                level_duration_make(false, (uint32_t)subghz_protocol_sheriff_cfm_const.te_long);
+        } else {
+            instance->encoder.upload[index++] =
+                level_duration_make(true, (uint32_t)subghz_protocol_sheriff_cfm_const.te_long);
+            instance->encoder.upload[index++] =
+                level_duration_make(false, (uint32_t)subghz_protocol_sheriff_cfm_const.te_short);
+        }
+    }
+
+    instance->encoder.upload[index++] =
+        level_duration_make(true, (uint32_t)subghz_protocol_sheriff_cfm_const.te_short);
+    instance->encoder.upload[index++] =
+        level_duration_make(false, (uint32_t)subghz_protocol_sheriff_cfm_const.te_short * 40);
+
+    instance->encoder.size_upload = index;
+    return true;
+}
+
+SubGhzProtocolStatus
+    subghz_protocol_encoder_sheriff_cfm_deserialize(void* context, FlipperFormat* flipper_format) {
+    furi_check(context);
+    SubGhzProtocolEncoderSheriffCfm* instance = context;
+    SubGhzProtocolStatus ret = SubGhzProtocolStatusError;
+
+    do {
+        ret = subghz_block_generic_deserialize_check_count_bit(
+            &instance->generic,
+            flipper_format,
+            subghz_protocol_sheriff_cfm_const.min_count_bit_for_found);
+        if(ret != SubGhzProtocolStatusOk) break;
+
+        uint32_t model_temp = 0;
+        if(flipper_format_read_uint32(flipper_format, "Model", &model_temp, 1)) {
+            instance->model = (SheriffCfmModel)model_temp;
+        } else {
+            SheriffCfmModel detected;
+            uint8_t det_btn;
+            uint32_t det_serial;
+            uint16_t det_cnt;
+            if(cfm_try_decrypt(instance->generic.data, &detected, &det_btn, &det_serial, &det_cnt)) {
+                instance->model = detected;
+                instance->generic.btn = det_btn;
+                instance->generic.serial = det_serial;
+                instance->generic.cnt = det_cnt;
+            }
+        }
+
+        if(!flipper_format_read_uint32(
+               flipper_format, "Repeat", (uint32_t*)&instance->encoder.repeat, 1)) {
+            instance->encoder.repeat = 3;
+        }
+
+        subghz_custom_btn_set_original(cfm_btn_to_custom(instance->generic.btn));
+        subghz_custom_btn_set_max(4);
+
+        uint8_t selected_btn = cfm_get_btn_code(instance->generic.btn);
+
+        if(!subghz_protocol_encoder_sheriff_cfm_get_upload(instance, selected_btn)) {
+            break;
+        }
+
+        instance->encoder.is_running = true;
+        instance->encoder.front = 0;
+        ret = SubGhzProtocolStatusOk;
+    } while(false);
+
+    return ret;
+}
+
+void subghz_protocol_encoder_sheriff_cfm_stop(void* context) {
+    furi_check(context);
+    SubGhzProtocolEncoderSheriffCfm* instance = context;
+    instance->encoder.is_running = false;
+}
+
+LevelDuration subghz_protocol_encoder_sheriff_cfm_yield(void* context) {
+    SubGhzProtocolEncoderSheriffCfm* instance = context;
+
+    if(instance->encoder.repeat == 0 || !instance->encoder.is_running) {
+        instance->encoder.is_running = false;
+        return level_duration_reset();
+    }
+
+    LevelDuration ret = instance->encoder.upload[instance->encoder.front];
+
+    if(++instance->encoder.front == instance->encoder.size_upload) {
+        instance->encoder.repeat--;
+        instance->encoder.front = 0;
+    }
+
+    return ret;
+}
+
+void* subghz_protocol_decoder_sheriff_cfm_alloc(SubGhzEnvironment* environment) {
+    UNUSED(environment);
+    SubGhzProtocolDecoderSheriffCfm* instance = malloc(sizeof(SubGhzProtocolDecoderSheriffCfm));
+    instance->base.protocol = &subghz_protocol_sheriff_cfm;
+    instance->generic.protocol_name = instance->base.protocol->name;
+    return instance;
+}
+
+void subghz_protocol_decoder_sheriff_cfm_free(void* context) {
+    furi_check(context);
+    SubGhzProtocolDecoderSheriffCfm* instance = context;
+    free(instance);
+}
+
+void subghz_protocol_decoder_sheriff_cfm_reset(void* context) {
+    furi_check(context);
+    SubGhzProtocolDecoderSheriffCfm* instance = context;
+    instance->decoder.parser_step = SheriffCfmDecoderStepReset;
+    instance->header_count = 0;
+}
+
+void subghz_protocol_decoder_sheriff_cfm_feed(void* context, bool level, uint32_t duration) {
+    furi_check(context);
+    SubGhzProtocolDecoderSheriffCfm* instance = context;
+
+    switch(instance->decoder.parser_step) {
+    case SheriffCfmDecoderStepReset:
+        if((level) && DURATION_DIFF(duration, subghz_protocol_sheriff_cfm_const.te_short) <
+                          subghz_protocol_sheriff_cfm_const.te_delta) {
+            instance->decoder.parser_step = SheriffCfmDecoderStepCheckPreambula;
+            instance->header_count++;
+        }
+        break;
+
+    case SheriffCfmDecoderStepCheckPreambula:
+        if((!level) && (DURATION_DIFF(duration, subghz_protocol_sheriff_cfm_const.te_short) <
+                        subghz_protocol_sheriff_cfm_const.te_delta)) {
+            instance->decoder.parser_step = SheriffCfmDecoderStepReset;
+            break;
+        }
+        if((instance->header_count > 2) &&
+           (DURATION_DIFF(duration, subghz_protocol_sheriff_cfm_const.te_short * 10) <
+            subghz_protocol_sheriff_cfm_const.te_delta * 10)) {
+            instance->decoder.parser_step = SheriffCfmDecoderStepSaveDuration;
+            instance->decoder.decode_data = 0;
+            instance->decoder.decode_count_bit = 0;
+        } else {
+            instance->decoder.parser_step = SheriffCfmDecoderStepReset;
+            instance->header_count = 0;
+        }
+        break;
+
+    case SheriffCfmDecoderStepSaveDuration:
+        if(level) {
+            instance->decoder.te_last = duration;
+            instance->decoder.parser_step = SheriffCfmDecoderStepCheckDuration;
+        }
+        break;
+
+    case SheriffCfmDecoderStepCheckDuration:
+        if(!level) {
+            if(duration >= ((uint32_t)subghz_protocol_sheriff_cfm_const.te_short * 2 +
+                            subghz_protocol_sheriff_cfm_const.te_delta)) {
+                instance->decoder.parser_step = SheriffCfmDecoderStepReset;
+                if((instance->decoder.decode_count_bit >=
+                    subghz_protocol_sheriff_cfm_const.min_count_bit_for_found) &&
+                   (instance->decoder.decode_count_bit <=
+                    subghz_protocol_sheriff_cfm_const.min_count_bit_for_found + 2)) {
+                    SheriffCfmModel model;
+                    uint8_t btn;
+                    uint32_t serial;
+                    uint16_t cnt;
+                    if(cfm_try_decrypt(
+                           instance->decoder.decode_data, &model, &btn, &serial, &cnt)) {
+                        instance->generic.data = instance->decoder.decode_data;
+                        instance->generic.data_count_bit =
+                            subghz_protocol_sheriff_cfm_const.min_count_bit_for_found;
+                        instance->model = model;
+                        instance->generic.btn = btn;
+                        instance->generic.serial = serial;
+                        instance->generic.cnt = cnt;
+                        if(instance->base.callback)
+                            instance->base.callback(&instance->base, instance->base.context);
+                    }
+                }
+                instance->decoder.decode_data = 0;
+                instance->decoder.decode_count_bit = 0;
+                instance->header_count = 0;
+                break;
+            } else if(
+                (DURATION_DIFF(
+                     instance->decoder.te_last, subghz_protocol_sheriff_cfm_const.te_short) <
+                 subghz_protocol_sheriff_cfm_const.te_delta) &&
+                (DURATION_DIFF(duration, subghz_protocol_sheriff_cfm_const.te_long) <
+                 subghz_protocol_sheriff_cfm_const.te_delta * 2)) {
+                if(instance->decoder.decode_count_bit <
+                   subghz_protocol_sheriff_cfm_const.min_count_bit_for_found) {
+                    subghz_protocol_blocks_add_bit(&instance->decoder, 1);
+                } else {
+                    instance->decoder.decode_count_bit++;
+                }
+                instance->decoder.parser_step = SheriffCfmDecoderStepSaveDuration;
+            } else if(
+                (DURATION_DIFF(
+                     instance->decoder.te_last, subghz_protocol_sheriff_cfm_const.te_long) <
+                 subghz_protocol_sheriff_cfm_const.te_delta * 2) &&
+                (DURATION_DIFF(duration, subghz_protocol_sheriff_cfm_const.te_short) <
+                 subghz_protocol_sheriff_cfm_const.te_delta)) {
+                if(instance->decoder.decode_count_bit <
+                   subghz_protocol_sheriff_cfm_const.min_count_bit_for_found) {
+                    subghz_protocol_blocks_add_bit(&instance->decoder, 0);
+                } else {
+                    instance->decoder.decode_count_bit++;
+                }
+                instance->decoder.parser_step = SheriffCfmDecoderStepSaveDuration;
+            } else {
+                instance->decoder.parser_step = SheriffCfmDecoderStepReset;
+                instance->header_count = 0;
+            }
+        } else {
+            instance->decoder.parser_step = SheriffCfmDecoderStepReset;
+            instance->header_count = 0;
+        }
+        break;
+    }
+}
+
+uint8_t subghz_protocol_decoder_sheriff_cfm_get_hash_data(void* context) {
+    furi_check(context);
+    SubGhzProtocolDecoderSheriffCfm* instance = context;
+    return subghz_protocol_blocks_get_hash_data(
+        &instance->decoder, (instance->decoder.decode_count_bit / 8) + 1);
+}
+
+SubGhzProtocolStatus subghz_protocol_decoder_sheriff_cfm_serialize(
+    void* context,
+    FlipperFormat* flipper_format,
+    SubGhzRadioPreset* preset) {
+    furi_check(context);
+    SubGhzProtocolDecoderSheriffCfm* instance = context;
+    SubGhzProtocolStatus ret =
+        subghz_block_generic_serialize(&instance->generic, flipper_format, preset);
+
+    if(ret == SubGhzProtocolStatusOk) {
+        uint32_t model = (uint32_t)instance->model;
+        flipper_format_insert_or_update_uint32(flipper_format, "Model", &model, 1);
+    }
+    return ret;
+}
+
+SubGhzProtocolStatus
+    subghz_protocol_decoder_sheriff_cfm_deserialize(void* context, FlipperFormat* flipper_format) {
+    furi_check(context);
+    SubGhzProtocolDecoderSheriffCfm* instance = context;
+    SubGhzProtocolStatus ret = SubGhzProtocolStatusError;
+
+    do {
+        ret = subghz_block_generic_deserialize_check_count_bit(
+            &instance->generic,
+            flipper_format,
+            subghz_protocol_sheriff_cfm_const.min_count_bit_for_found);
+        if(ret != SubGhzProtocolStatusOk) break;
+
+        uint32_t model_temp = 0;
+        if(flipper_format_read_uint32(flipper_format, "Model", &model_temp, 1)) {
+            instance->model = (SheriffCfmModel)model_temp;
+        }
+
+        SheriffCfmModel detected;
+        uint8_t btn;
+        uint32_t serial;
+        uint16_t cnt;
+        if(cfm_try_decrypt(instance->generic.data, &detected, &btn, &serial, &cnt)) {
+            instance->model = detected;
+            instance->generic.btn = btn;
+            instance->generic.serial = serial;
+            instance->generic.cnt = cnt;
+        }
+    } while(false);
+
+    return ret;
+}
+
+void subghz_protocol_decoder_sheriff_cfm_get_string(void* context, FuriString* output) {
+    furi_check(context);
+    SubGhzProtocolDecoderSheriffCfm* instance = context;
+
+    subghz_custom_btn_set_original(cfm_btn_to_custom(instance->generic.btn));
+    subghz_custom_btn_set_max(4);
+
+    uint8_t selected_btn = cfm_get_btn_code(instance->generic.btn);
+
+    furi_string_cat_printf(
+        output,
+        "%s %dbit\r\n"
+        "Key:0x%lX%08lX\r\n"
+        "Sn:%08lX Btn:[%s]\r\n"
+        "Cnt:%04lX Model:%s\r\n",
+        instance->generic.protocol_name,
+        instance->generic.data_count_bit,
+        (uint32_t)(instance->generic.data >> 32),
+        (uint32_t)instance->generic.data,
+        instance->generic.serial,
+        cfm_btn_name(selected_btn),
+        (uint32_t)instance->generic.cnt,
+        cfm_model_name(instance->model));
+}

lib/subghz/protocols/sheriff_cfm.h

@@ -0,0 +1,43 @@
+#pragma once
+#include <furi.h>
+#include <lib/subghz/protocols/base.h>
+#include <lib/subghz/types.h>
+#include <lib/subghz/blocks/const.h>
+#include <lib/subghz/blocks/decoder.h>
+#include <lib/subghz/blocks/encoder.h>
+#include <lib/subghz/blocks/generic.h>
+#include <lib/subghz/blocks/math.h>
+#include <flipper_format/flipper_format.h>
+
+#define SUBGHZ_PROTOCOL_SHERIFF_CFM_NAME "Sheriff CFM"
+
+typedef struct SubGhzProtocolDecoderSheriffCfm SubGhzProtocolDecoderSheriffCfm;
+typedef struct SubGhzProtocolEncoderSheriffCfm SubGhzProtocolEncoderSheriffCfm;
+
+extern const SubGhzProtocolDecoder subghz_protocol_sheriff_cfm_decoder;
+extern const SubGhzProtocolEncoder subghz_protocol_sheriff_cfm_encoder;
+extern const SubGhzProtocol subghz_protocol_sheriff_cfm;
+
+void* subghz_protocol_decoder_sheriff_cfm_alloc(SubGhzEnvironment* environment);
+void subghz_protocol_decoder_sheriff_cfm_free(void* context);
+void subghz_protocol_decoder_sheriff_cfm_reset(void* context);
+void subghz_protocol_decoder_sheriff_cfm_feed(void* context, bool level, uint32_t duration);
+
+uint8_t subghz_protocol_decoder_sheriff_cfm_get_hash_data(void* context);
+
+SubGhzProtocolStatus subghz_protocol_decoder_sheriff_cfm_serialize(
+    void* context,
+    FlipperFormat* flipper_format,
+    SubGhzRadioPreset* preset);
+
+SubGhzProtocolStatus
+    subghz_protocol_decoder_sheriff_cfm_deserialize(void* context, FlipperFormat* flipper_format);
+
+void subghz_protocol_decoder_sheriff_cfm_get_string(void* context, FuriString* output);
+
+void* subghz_protocol_encoder_sheriff_cfm_alloc(SubGhzEnvironment* environment);
+void subghz_protocol_encoder_sheriff_cfm_free(void* context);
+SubGhzProtocolStatus
+    subghz_protocol_encoder_sheriff_cfm_deserialize(void* context, FlipperFormat* flipper_format);
+void subghz_protocol_encoder_sheriff_cfm_stop(void* context);
+LevelDuration subghz_protocol_encoder_sheriff_cfm_yield(void* context);

lib/subghz/protocols/star_line.h

@@ -0,0 +1,47 @@
+#pragma once
+#include <furi.h>
+#include <lib/subghz/protocols/base.h>
+#include <lib/subghz/types.h>
+#include <lib/subghz/blocks/const.h>
+#include <lib/subghz/blocks/decoder.h>
+#include <lib/subghz/blocks/encoder.h>
+#include <lib/subghz/blocks/generic.h>
+#include <lib/subghz/blocks/math.h>
+#include <lib/toolbox/manchester_decoder.h>
+#include <flipper_format/flipper_format.h>
+
+#define SUBGHZ_PROTOCOL_STAR_LINE_NAME "Star Line"
+
+typedef struct SubGhzProtocolDecoderStarLine SubGhzProtocolDecoderStarLine;
+typedef struct SubGhzProtocolEncoderStarLine SubGhzProtocolEncoderStarLine;
+
+extern const SubGhzProtocolDecoder subghz_protocol_star_line_decoder;
+extern const SubGhzProtocolEncoder subghz_protocol_star_line_encoder;
+extern const SubGhzProtocol subghz_protocol_star_line;
+
+void* subghz_protocol_encoder_star_line_alloc(SubGhzEnvironment* environment);
+void subghz_protocol_encoder_star_line_free(void* context);
+
+SubGhzProtocolStatus
+    subghz_protocol_encoder_star_line_deserialize(void* context, FlipperFormat* flipper_format);
+
+void subghz_protocol_encoder_star_line_stop(void* context);
+
+LevelDuration subghz_protocol_encoder_star_line_yield(void* context);
+
+void* subghz_protocol_decoder_star_line_alloc(SubGhzEnvironment* environment);
+void subghz_protocol_decoder_star_line_free(void* context);
+void subghz_protocol_decoder_star_line_reset(void* context);
+void subghz_protocol_decoder_star_line_feed(void* context, bool level, uint32_t duration);
+
+uint8_t subghz_protocol_decoder_star_line_get_hash_data(void* context);
+
+SubGhzProtocolStatus subghz_protocol_decoder_star_line_serialize(
+    void* context,
+    FlipperFormat* flipper_format,
+    SubGhzRadioPreset* preset);
+
+SubGhzProtocolStatus
+    subghz_protocol_decoder_star_line_deserialize(void* context, FlipperFormat* flipper_format);
+
+void subghz_protocol_decoder_star_line_get_string(void* context, FuriString* output);

targets/f7/api_symbols.csv

@@ -1,5 +1,5 @@
 entry,status,name,type,params
-Version,+,88.0,,
+Version,+,89.0,,
 Header,+,applications/drivers/subghz/cc1101_ext/cc1101_ext_interconnect.h,,
 Header,+,applications/services/applications.h,,
 Header,+,applications/services/bt/bt_service/bt.h,,
@@ -1447,6 +1447,8 @@ Function,+,furi_hal_cortex_instructions_per_microsecond,uint32_t,
 Function,+,furi_hal_cortex_timer_get,FuriHalCortexTimer,uint32_t
 Function,+,furi_hal_cortex_timer_is_expired,_Bool,FuriHalCortexTimer
 Function,+,furi_hal_cortex_timer_wait,void,FuriHalCortexTimer
+Function,+,furi_hal_crypto_aes128_ecb_decrypt,_Bool,"const uint8_t*, const uint8_t*, uint8_t*"
+Function,+,furi_hal_crypto_aes128_ecb_encrypt,_Bool,"const uint8_t*, const uint8_t*, uint8_t*"
 Function,+,furi_hal_crypto_ctr,_Bool,"const uint8_t*, const uint8_t*, const uint8_t*, uint8_t*, size_t"
 Function,+,furi_hal_crypto_decrypt,_Bool,"const uint8_t*, uint8_t*, size_t"
 Function,+,furi_hal_crypto_enclave_ensure_key,_Bool,uint8_t
@@ -1454,8 +1456,6 @@ Function,+,furi_hal_crypto_enclave_load_key,_Bool,"uint8_t, const uint8_t*"
 Function,+,furi_hal_crypto_enclave_store_key,_Bool,"FuriHalCryptoKey*, uint8_t*"
 Function,+,furi_hal_crypto_enclave_unload_key,_Bool,uint8_t
 Function,+,furi_hal_crypto_enclave_verify,_Bool,"uint8_t*, uint8_t*"
-Function,+,furi_hal_crypto_aes128_ecb_decrypt,_Bool,"const uint8_t*, const uint8_t*, uint8_t*"
-Function,+,furi_hal_crypto_aes128_ecb_encrypt,_Bool,"const uint8_t*, const uint8_t*, uint8_t*"
 Function,+,furi_hal_crypto_encrypt,_Bool,"const uint8_t*, uint8_t*, size_t"
 Function,+,furi_hal_crypto_gcm,_Bool,"const uint8_t*, const uint8_t*, const uint8_t*, size_t, const uint8_t*, uint8_t*, size_t, uint8_t*, _Bool"
 Function,+,furi_hal_crypto_gcm_decrypt_and_verify,FuriHalCryptoGCMState,"const uint8_t*, const uint8_t*, const uint8_t*, size_t, const uint8_t*, uint8_t*, size_t, const uint8_t*"
@@ -3461,9 +3461,11 @@ Function,+,subghz_block_generic_global_counter_override_set,void,uint32_t
 Function,+,subghz_block_generic_global_reset,void,void*
 Function,+,subghz_block_generic_serialize,SubGhzProtocolStatus,"SubGhzBlockGeneric*, FlipperFormat*, SubGhzRadioPreset*"
 Function,+,subghz_custom_btn_get,uint8_t,
+Function,-,subghz_custom_btn_get_long,_Bool,
 Function,+,subghz_custom_btn_get_original,uint8_t,
 Function,+,subghz_custom_btn_is_allowed,_Bool,
 Function,+,subghz_custom_btn_set,_Bool,uint8_t
+Function,-,subghz_custom_btn_set_long,void,_Bool
 Function,+,subghz_custom_btns_reset,void,
 Function,-,subghz_device_cc1101_ext_ep,const FlipperAppPluginDescriptor*,
 Function,+,subghz_devices_begin,_Bool,const SubGhzDevice*