docs: Add extensive documentation in code comments

This commit adds extensive documentation in the form of code comments for various functions, classes, and enumerations related to sub-brute forcing tasks within the subbrute module. The aim of these comments is to clarify the responsibilities and behaviors of functions and data structures, and to explain the meaning of some important constants and parameters. The documentation serves as a guide for developers to understand the code better without having to infer the purpose of functions or the meaning of parameters from raw code.

helpers/subbrute_radio_device_loader.h

@@ -2,14 +2,39 @@
 
 #include <lib/subghz/devices/devices.h>
 
-/** SubGhzRadioDeviceType */
+/**
+ * @file subghz_radio.h
+ * @brief Defines the Sub-GHz radio device type.
+ */
 typedef enum {
     SubGhzRadioDeviceTypeInternal,
     SubGhzRadioDeviceTypeExternalCC1101,
 } SubGhzRadioDeviceType;
 
+/**
+ * @brief Sets the SubGhz radio device type.
+ *
+ * This function is used to set the SubGhz radio device type for the SubBrute radio device loader.
+ *
+ * @param current_radio_device Pointer to the current SubGhz radio device.
+ * @param radio_device_type The desired SubGhz radio device type.
+ * @return const SubGhzDevice* Pointer to the new SubGhz radio device.
+ *
+ * @remark This function sets the SubGhz radio device type for the SubBrute radio device loader.
+ *         The current radio device will be replaced with a new instance of the specified radio device type.
+ *         If @p current_radio_device is NULL, a new instance of the specified radio device type will be created.
+ *
+ * @note The caller is responsible for handling memory deallocation of the returned pointer.
+ */
 const SubGhzDevice* subbrute_radio_device_loader_set(
     const SubGhzDevice* current_radio_device,
     SubGhzRadioDeviceType radio_device_type);
 
+/**
+ * @brief Unloads a SubGhz radio device.
+ *
+ * This function unloads a SubGhz radio device and performs any necessary cleanup.
+ *
+ * @param radio_device Pointer to the SubGhzDevice structure representing the radio device to be unloaded.
+ */
 void subbrute_radio_device_loader_end(const SubGhzDevice* radio_device);

helpers/subbrute_worker.h

@@ -3,6 +3,18 @@
 #include "../subbrute_protocols.h"
 #include "subbrute_radio_device_loader.h"
 
+/**
+ * @enum SubBruteWorkerState
+ * @brief Enumeration defining the different states of the SubBruteWorker.
+ *
+ * This enumeration defines the possible states of the SubBruteWorker, which is responsible for performing
+ * sub-brute forcing tasks.
+ *
+ * @var SubBruteWorkerStateIDLE The worker is in idle state and not performing any task.
+ * @var SubBruteWorkerStateReady The worker is ready to start a new task.
+ * @var SubBruteWorkerStateTx The worker is currently performing a sub-brute forcing task.
+ * @var SubBruteWorkerStateFinished The worker has finished the sub-brute forcing task.
+ */
 typedef enum {
     SubBruteWorkerStateIDLE,
     SubBruteWorkerStateReady,
@@ -14,17 +26,94 @@ typedef void (*SubBruteWorkerCallback)(void* context, SubBruteWorkerState state)
 
 typedef struct SubBruteWorker SubBruteWorker;
 
+/**
+ * @brief Allocates memory for a SubBruteWorker object and initializes it with the given radio_device.
+ *
+ * This function creates a new SubBruteWorker object by allocating memory for it on the heap and
+ * initializes it with the provided radio_device. The radio_device parameter must not be NULL.
+ *
+ * @param radio_device A pointer to a valid SubGhzDevice object.
+ * @return A pointer to the newly allocated SubBruteWorker object, or NULL if memory allocation failed.
+ */
 SubBruteWorker* subbrute_worker_alloc(const SubGhzDevice* radio_device);
+
+/**
+ * @brief Frees the memory associated with the given SubBruteWorker instance.
+ *
+ * This function must be called to release the resources allocated to the SubBruteWorker instance.
+ *
+ * @param instance Pointer to the SubBruteWorker instance to be freed.
+ */
 void subbrute_worker_free(SubBruteWorker* instance);
+
+/**
+ * @brief Get the current step of a sub brute force worker.
+ *
+ * @param instance A pointer to the SubBruteWorker instance.
+ * @return The current step of the sub brute force worker as a uint64_t value.
+ */
 uint64_t subbrute_worker_get_step(SubBruteWorker* instance);
+
+/**
+ * @brief Set the step value for a SubBruteWorker instance.
+ *
+ * This function sets the step value for a given SubBruteWorker instance. The step value determines the increment that
+ * will be used for each iteration in the worker's execution loop.
+ *
+ * @param instance Pointer to the SubBruteWorker instance.
+ * @param step The step value to set.
+ * @return true if the step value was successfully set, false otherwise.
+ */
 bool subbrute_worker_set_step(SubBruteWorker* instance, uint64_t step);
+
+/**
+ * @brief Check if the SubBruteWorker is currently running.
+ *
+ * @param instance Pointer to the SubBruteWorker instance.
+ *
+ * @return true if the SubBruteWorker is running, false otherwise.
+ */
 bool subbrute_worker_is_running(SubBruteWorker* instance);
+
+/**
+ * @brief Initializes a SubBruteWorker with default attack settings.
+ *
+ * This function initializes a SubBruteWorker instance with default attack settings. The attack_type parameter determines the type of attack to be performed. The step parameter specifies
+* the iteration step to be used during the attack. The protocol parameter provides the necessary protocol information for the attack. The repeats parameter specifies the number of times
+* the attack should be repeated.
+ *
+ * @param instance A pointer to a SubBruteWorker instance.
+ * @param attack_type The type of attack to be performed.
+ * @param step The iteration step to be used during the attack.
+ * @param protocol A pointer to the SubBruteProtocol structure containing protocol information.
+ * @param repeats The number of times the attack should be repeated.
+ * @return Returns true if the initialization is successful, false otherwise.
+ */
 bool subbrute_worker_init_default_attack(
     SubBruteWorker* instance,
     SubBruteAttacks attack_type,
     uint64_t step,
     const SubBruteProtocol* protocol,
     uint8_t repeats);
+
+/**
+ * @brief Initializes a file-based attack worker for the sub-brute algorithm.
+ *
+ * This function initializes a sub-brute worker to perform file-based attacks.
+ * It sets the necessary parameters for the attack, such as the attack step,
+ * the load index, the file key, the protocol to use, the number of repeats,
+ * and whether to use two bytes.
+ *
+ * @param instance A pointer to the sub-brute worker instance.
+ * @param step The attack step value to set.
+ * @param load_index The load index value to set.
+ * @param file_key The file key value to set.
+ * @param protocol The sub-brute protocol to use for the attack.
+ * @param repeats The number of times to repeat the attack.
+ * @param two_bytes A flag indicating whether to use two bytes for the attack.
+ *
+ * @return True if the initialization was successful, false otherwise.
+ */
 bool subbrute_worker_init_file_attack(
     SubBruteWorker* instance,
     uint64_t step,
@@ -33,24 +122,155 @@ bool subbrute_worker_init_file_attack(
     SubBruteProtocol* protocol,
     uint8_t repeats,
     bool two_bytes);
+
+/**
+ * @brief Start the SubBruteWorker instance.
+ *
+ * This function starts the SubBruteWorker instance, allowing it to begin its work.
+ *
+ * @param instance Pointer to the SubBruteWorker instance to start.
+ * @return Whether starting the SubBruteWorker instance was successful.
+ *     - true: Starting the SubBruteWorker instance was successful.
+ *     - false: Starting the SubBruteWorker instance failed.
+ *
+ * @note Before calling this function, make sure all the necessary inputs and configurations
+ *       have been set on the SubBruteWorker instance.
+ */
 bool subbrute_worker_start(SubBruteWorker* instance);
+
+/**
+ * @brief Stops the given SubBruteWorker instance.
+ *
+ * This function stops the SubBruteWorker instance by performing necessary clean-up operations.
+ * After calling this function, the instance is no longer usable.
+ *
+ * @param instance A pointer to the SubBruteWorker instance to stop.
+ */
 void subbrute_worker_stop(SubBruteWorker* instance);
+
+/**
+ * @brief Transmits the current key of the SubBruteWorker instance to another device.
+ *
+ * This function transmits the current key of the SubBruteWorker instance to another device
+ * using the specified step value.
+ *
+ * @param instance The pointer to the SubBruteWorker instance.
+ * @param step The step value used for transmission.
+ *
+ * @return True if the key was successfully transmitted, otherwise false.
+ */
 bool subbrute_worker_transmit_current_key(SubBruteWorker* instance, uint64_t step);
+
+/**
+ * @brief Check if the `SubBruteWorker` instance can transmit manually.
+ *
+ * This function is used to determine if the `SubBruteWorker` instance is capable of manual transmission.
+ *
+ * @param instance Pointer to the `SubBruteWorker` instance.
+ * @return `true` if the `SubBruteWorker` instance can transmit manually, `false` otherwise.
+ */
 bool subbrute_worker_can_manual_transmit(SubBruteWorker* instance);
+
+/**
+ * @brief Set the callback function and its context for the SubBruteWorker.
+ *
+ * This function allows you to set the callback function and its context for
+ * the given SubBruteWorker instance. The callback function will be called
+ * by the SubBruteWorker at specific events, providing information to the
+ * caller through the callback parameters.
+ *
+ * @param instance The SubBruteWorker instance to set the callback for.
+ * @param callback The callback function to set.
+ * @param context The context to be passed to the callback function.
+ *
+ * @note The callback function should be of the form:
+ *        void callback(SubBruteWorker* instance, void* context);
+ *      The instance parameter is the SubBruteWorker instance that triggered
+ *      the callback, while the context parameter is the user-defined context
+ *      that was set with this function.
+ *
+ * @see SubBruteWorkerCallback
+ */
 void subbrute_worker_set_callback(
     SubBruteWorker* instance,
     SubBruteWorkerCallback callback,
     void* context);
 
+/**
+ * @brief Get the timeout value of the SubBruteWorker instance.
+ *
+ * This function returns the timeout value of the SubBruteWorker instance.
+ *
+ * @param instance  Pointer to the SubBruteWorker instance.
+ *
+ * @return The timeout value as a uint8_t.
+ */
 uint8_t subbrute_worker_get_timeout(SubBruteWorker* instance);
+
+/**
+ * @brief Set the timeout for the SubBruteWorker instance.
+ *
+ * This function sets the timeout value for the SubBruteWorker instance. The timeout defines the maximum time allowed for the worker to complete its task before it is interrupted.
+ *
+ * @param instance A pointer to the SubBruteWorker instance.
+ * @param timeout The timeout value in milliseconds.
+ */
 void subbrute_worker_set_timeout(SubBruteWorker* instance, uint8_t timeout);
+
+/**
+ * @brief Retrieves the number of repeated substrings found by the SubBruteWorker instance.
+ *
+ * This function returns the count of repeated substrings found during the execution of the SubBruteWorker instance.
+ *
+ * @param instance A pointer to the SubBruteWorker instance.
+ * @return The number of repeated substrings.
+ */
 uint8_t subbrute_worker_get_repeats(SubBruteWorker* instance);
+
+/**
+ * @brief Set the number of repeats for the SubBruteWorker instance.
+ *
+ * This function sets the number of repeats for the SubBruteWorker instance. The repeats
+ * determines how many times a certain operation should be repeated.
+ *
+ * @param instance A pointer to the SubBruteWorker instance.
+ * @param repeats The number of repeats to be set.
+ */
 void subbrute_worker_set_repeats(SubBruteWorker* instance, uint8_t repeats);
+
+/**
+ * @brief Get the value of te from a SubBruteWorker instance.
+ *
+ * This function returns the value of the te member variable of the SubBruteWorker instance.
+ *
+ * @param instance A pointer to the SubBruteWorker instance.
+ * @return The value of the te member variable.
+ */
 uint32_t subbrute_worker_get_te(SubBruteWorker* instance);
+
+/**
+ * @brief Set the value of te for the SubBruteWorker instance.
+ *
+ * This function sets the value of the te member variable for the given SubBruteWorker instance.
+ * The te value determines the threshold for the worker to stop processing.
+ *
+ * @param instance Pointer to the SubBruteWorker instance
+ * @param te The threshold value to set
+ */
 void subbrute_worker_set_te(SubBruteWorker* instance, uint32_t te);
 
 // void subbrute_worker_timeout_inc(SubBruteWorker* instance);
 
 // void subbrute_worker_timeout_dec(SubBruteWorker* instance);
 
+/**
+  * @brief Checks if transmission is allowed for the given value.
+  *
+  * This function checks the transmission allowance for the given value based on the state of the SubBruteWorker instance.
+  *
+  * @param instance A pointer to the SubBruteWorker instance.
+  * @param value The value to check transmission allowance for.
+  *
+  * @return True if transmission is allowed for the given value, false otherwise.
+  */
 bool subbrute_worker_is_tx_allowed(SubBruteWorker* instance, uint32_t value);

helpers/subbrute_worker_private.h

@@ -6,6 +6,13 @@
 #include <lib/subghz/receiver.h>
 #include <lib/subghz/environment.h>
 
+/**
+ * @class SubBruteWorker
+ * @brief Class representing a SubBruteWorker object.
+ *
+ * The SubBruteWorker class is responsible for performing sub-brute forcing tasks.
+ * It manages the state, configuration and execution of the sub-brute forcing algorithm.
+ */
 struct SubBruteWorker {
     SubBruteWorkerState state;
     volatile bool worker_running;
@@ -45,6 +52,37 @@ struct SubBruteWorker {
     void* context;
 };
 
+/**
+ * @brief This function is the entry point for the sub-brute worker thread.
+ *
+ * @param context A pointer to the context data for the worker thread.
+ * @return int32_t The return status of the worker thread.
+ *
+ * The sub-brute worker thread performs a sub-brute force operation based on the given context.
+ * It takes the context as an input, processes the data, and returns a status code.
+ * The function is used as an entry point for the worker thread.
+ */
 int32_t subbrute_worker_thread(void* context);
+
+/**
+ * @brief Transmits FlipperFormat using subGHz.
+ *
+ * This function transmits the specified FlipperFormat using the subGHz
+ * protocol.
+ *
+ * @param instance The SubBruteWorker instance.
+ * @param flipper_format Pointer to the FlipperFormat to be transmitted.
+ */
 void subbrute_worker_subghz_transmit(SubBruteWorker* instance, FlipperFormat* flipper_format);
+
+/**
+ * @brief Send a callback for a SubBruteWorker instance.
+ *
+ * This function is used to send a callback for the SubBruteWorker instance. The callback is triggered
+ * when certain conditions are met during the worker's execution.
+ *
+ * @param instance The SubBruteWorker instance for which the callback is sent.
+ *
+ * @note This function does not return any values.
+ */
 void subbrute_worker_send_callback(SubBruteWorker* instance);

subbrute_custom_event.h

@@ -1,5 +1,75 @@
 #pragma once
 
+/**
+ * @enum SubBruteCustomEvent
+ * @brief Enumerates the custom event types used in the SubBrute application.
+ *
+ * This enumeration defines custom event types used in the SubBrute application.
+ * The first 100 event types are reserved for button types and indexes, starting
+ * from 0. The remaining event types are specific to the application and are used
+ * to handle various events.
+ *
+ * @note These event types are used to define custom events in the application's
+ *       event handling system. They should be used to specify the type of custom
+ *       events and differentiate them from other events.
+ *
+ * @var SubBruteCustomEventTypeReserved
+ * Reserved event type for button types and indexes. Starting from 0.
+ *
+ * @var SubBruteCustomEventTypeBackPressed
+ * Event type for the back button press event.
+ *
+ * @var SubBruteCustomEventTypeIndexSelected
+ * Event type for the index selection event.
+ *
+ * @var SubBruteCustomEventTypeTransmitStarted
+ * Event type for the transmit start event.
+ *
+ * @var SubBruteCustomEventTypeError
+ * Event type for the error event.
+ *
+ * @var SubBruteCustomEventTypeTransmitFinished
+ * Event type for the transmit finish event.
+ *
+ * @var SubBruteCustomEventTypeTransmitNotStarted
+ * Event type for the transmit not started event.
+ *
+ * @var SubBruteCustomEventTypeTransmitCustom
+ * Event type for the custom transmit event.
+ *
+ * @var SubBruteCustomEventTypeSaveFile
+ * Event type for the save file event.
+ *
+ * @var SubBruteCustomEventTypeExtraSettings
+ * Event type for the extra settings event.
+ *
+ * @var SubBruteCustomEventTypeUpdateView
+ * Event type for the update view event.
+ *
+ * @var SubBruteCustomEventTypeChangeStepUp
+ * Event type for the change step up event.
+ *
+ * @var SubBruteCustomEventTypeChangeStepDown
+ * Event type for the change step down event.
+ *
+ * @var SubBruteCustomEventTypeChangeStepUpMore
+ * Event type for the change step up more event.
+ *
+ * @var SubBruteCustomEventTypeChangeStepDownMore
+ * Event type for the change step down more event.
+ *
+ * @var SubBruteCustomEventTypeMenuSelected
+ * Event type for the menu selection event.
+ *
+ * @var SubBruteCustomEventTypeTextEditDone
+ * Event type for the text edit done event.
+ *
+ * @var SubBruteCustomEventTypePopupClosed
+ * Event type for the popup close event.
+ *
+ * @var SubBruteCustomEventTypeLoadFile
+ * Event type for the load file event.
+ */
 typedef enum {
     // Reserve first 100 events for button types and indexes, starting from 0
     SubBruteCustomEventTypeReserved = 100,

subbrute_device.h

@@ -11,6 +11,14 @@
 #define SUBBRUTE_PATH EXT_PATH("subghz")
 #define SUBBRUTE_FILE_EXT ".sub"
 
+/**
+ * @enum SubBruteFileResult
+ * @brief Represents the possible results of a sub-brute force file operation.
+ *
+ * This enumeration defines a set of possible results that can occur when performing
+ * a sub-brute force operation on a file. Each result represents a specific error or
+ * condition that can occur during the operation.
+ */
 typedef enum {
     SubBruteFileResultUnknown,
     SubBruteFileResultOk,
@@ -28,6 +36,13 @@ typedef enum {
     SubBruteFileResultMissingOrIncorrectTe,
 } SubBruteFileResult;
 
+/**
+ * @struct SubBruteDevice
+ * @brief Represents a device for SubBrute attack.
+ *
+ * This structure contains information and state variables required for performing
+ * a SubBrute attack.
+ */
 typedef struct {
     const SubBruteProtocol* protocol_info;
     SubBruteProtocol* file_protocol_info;
@@ -55,20 +70,102 @@ typedef struct {
     uint8_t bit_index;
 } SubBruteDevice;
 
+/**
+ * @brief Allocates memory for a SubBruteDevice structure.
+ *
+ * This function allocates memory for a SubBruteDevice structure and
+ * initializes it using the given SubGhzDevice.
+ *
+ * @param radio_device The SubGhzDevice used to initialize the SubBruteDevice.
+ * @return A pointer to the allocated SubBruteDevice structure.
+ */
 SubBruteDevice* subbrute_device_alloc(const SubGhzDevice* radio_device);
+
+/**
+ * @brief Frees the memory allocated for a SubBruteDevice instance.
+ *
+ * This function frees the memory allocated for a SubBruteDevice instance.
+ * After calling this function, the instance is no longer valid and should not be used.
+ *
+ * @param instance Pointer to the SubBruteDevice instance to be freed.
+ */
 void subbrute_device_free(SubBruteDevice* instance);
 
+/**
+ * Saves a file with the specified key name using the given SubBruteDevice instance.
+ *
+ * @param instance The SubBruteDevice instance to use for saving the file.
+ * @param key_name The name of the key to be used for saving the file.
+ * @return True if the file is successfully saved, False otherwise.
+ */
 bool subbrute_device_save_file(SubBruteDevice* instance, const char* key_name);
+
+/**
+ * @brief Retrieves the description for a specific device error.
+ *
+ * This function returns a string that describes the given device error ID. The error ID
+ * should be obtained from a SubBruteFileResult value. The returned string provides
+ * additional information about the error, such as its cause or possible solutions.
+ *
+ * @param error_id The device error ID for which to retrieve the description.
+ *
+ * @return A pointer to a constant string containing the description of the device error.
+ */
 const char* subbrute_device_error_get_desc(SubBruteFileResult error_id);
 SubBruteFileResult subbrute_device_attack_set(
     SubBruteDevice* context,
     SubBruteAttacks type,
     uint8_t extra_repeats);
+
+/**
+ * @brief Loads data from a file into a SubBruteDevice context.
+ *
+ * This function reads data from the specified file and populates the
+ * SubBruteDevice context with the loaded data. The file contents are
+ * expected to be in a specific format supported by the SubBruteDevice.
+ * Use this function to initialize the context with pre-existing data.
+ *
+ * @param context Pointer to the SubBruteDevice context to be populated.
+ * @param file_path Path of the file to load data from.
+ * @return The status of the loading operation.
+ *     - Returns 0 if the loading is successful.
+ *     - Returns a non-zero value if an error occurs during loading.
+ */
 uint8_t subbrute_device_load_from_file(SubBruteDevice* context, const char* file_path);
 
+/**
+ * @brief Adds a step to the SubBruteDevice instance.
+ *
+ * This function adds a step to the given SubBruteDevice instance. It updates
+ * the internal state of the device accordingly.
+ *
+ * @param[in,out] instance The SubBruteDevice instance.
+ * @param[in] step The step to be added.
+ *
+ * @return The updated value of the device state after adding the step.
+ */
 uint64_t subbrute_device_add_step(SubBruteDevice* instance, int8_t step);
 
+/**
+ * @brief Frees the memory allocated for the protocol information of a SubBruteDevice instance.
+ *
+ * This function will deallocate the memory used by the protocol information of a SubBruteDevice instance,
+ * including all the individual protocol objects and their data.
+ *
+ * @param instance Pointer to the SubBruteDevice instance.
+ */
 void subbrute_device_free_protocol_info(SubBruteDevice* instance);
+
+/**
+ * @brief Set the default values for a SubBruteDevice attack configuration.
+ *
+ * This function sets the default values for a SubBruteDevice attack configuration based on the specified default_attack type.
+ *
+ * @param context Pointer to a SubBruteDevice instance.
+ * @param default_attack The default attack type to use.
+ *
+ * @see SubBruteDevice
+ */
 void subbrute_device_attack_set_default_values(
     SubBruteDevice* context,
     SubBruteAttacks default_attack);

subbrute_i.h

@@ -37,6 +37,13 @@
 //#define SUBBRUTE_FAST_TRACK false
 #endif
 
+/**
+ * @enum SubBruteView
+ * @brief An enumeration representing the different views of the SubBrute application
+ *
+ * This enumeration represents the possible views that the SubBrute application can have. Each view
+ * corresponds to a specific screen or UI element in the application.
+ */
 typedef enum {
     SubBruteViewNone,
     SubBruteViewMain,
@@ -49,6 +56,12 @@ typedef enum {
     SubBruteViewVarList,
 } SubBruteView;
 
+/**
+ * @class SubBruteState
+ * @brief Represents the state of a SubBrute application.
+ *
+ * This class contains the various elements and variables necessary for the functioning of a SubBrute application.
+ */
 struct SubBruteState {
     // GUI elements
     NotificationApp* notifications;
@@ -82,6 +95,38 @@ struct SubBruteState {
     SubBruteSettings* settings;
 };
 
+/**
+ * @brief Function to show or hide a loading popup.
+ *
+ * This function is used to display or hide a loading popup in a user interface.
+ * The loading popup appears when an action is being performed that may take some time to complete.
+ *
+ * @param context A pointer to the context object associated with the loading popup.
+ * @param show A boolean value indicating whether to display or hide the loading popup.
+ */
 void subbrute_show_loading_popup(void* context, bool show);
+
+/**
+ * @brief Callback function for text input in the sub-brute module.
+ *
+ * This function serves as a callback for handling text input in the sub-brute module.
+ * It should be registered as a callback function for text input events.
+ *
+ * @param context A pointer to additional context data (if any).
+ *
+ * @return None
+ */
 void subbrute_text_input_callback(void* context);
+
+/**
+ * @brief Callback function called when a popup window is closed.
+ *
+ * This function is called when a popup window is closed. It can be used to perform
+ * any necessary cleanup or additional processing after the popup window is closed.
+ *
+ * @param context A void pointer to the context data associated with the popup window.
+ *                It can be used to pass any additional information needed by the callback function.
+ *
+ * @return void
+ */
 void subbrute_popup_closed_callback(void* context);

subbrute_protocols.h

@@ -7,6 +7,36 @@
 
 #define SUBBRUTE_PROTOCOL_MAX_REPEATS 9
 
+/**
+ * @enum SubBruteFileProtocol
+ * @brief Enum defining various file protocols used in a system
+ *
+ * This enum defines different file protocols that can be used in the system.
+ * Each file protocol is identified by its name.
+ *
+ * The possible values for this enum are:
+ * - CAMEFileProtocol: CAME file protocol
+ * - NICEFileProtocol: NICE file protocol
+ * - ChamberlainFileProtocol: Chamberlain file protocol
+ * - LinearFileProtocol: Linear file protocol
+ * - LinearDeltaFileProtocol: Linear Delta file protocol
+ * - PrincetonFileProtocol: Princeton file protocol
+ * - RAWFileProtocol: RAW file protocol
+ * - BETTFileProtocol: BETT file protocol
+ * - ClemsaFileProtocol: Clemsa file protocol
+ * - DoitrandFileProtocol: Doitrand file protocol
+ * - GateTXFileProtocol: GateTX file protocol
+ * - MagellanFileProtocol: Magellan file protocol
+ * - IntertechnoV3FileProtocol: Intertechno V3 file protocol
+ * - AnsonicFileProtocol: Ansonic file protocol
+ * - SMC5326FileProtocol: SMC5326 file protocol
+ * - UNILARMFileProtocol: UNILARM file protocol
+ * - PT2260FileProtocol: PT2260 file protocol
+ * - HoneywellFileProtocol: Honeywell file protocol
+ * - HoltekFileProtocol: Holtek file protocol
+ * - UnknownFileProtocol: Unknown file protocol
+ * - TotalFileProtocol: Total file protocol
+ */
 typedef enum {
     CAMEFileProtocol,
     NICEFileProtocol,
@@ -31,6 +61,56 @@ typedef enum {
     TotalFileProtocol,
 } SubBruteFileProtocol;
 
+/**
+ * @enum SubBruteAttacks
+ *
+ * Enumeration of all supported sub-brute attacks.
+ *
+ * The `SubBruteAttacks` represents the different types of sub-brute attacks
+ * that can be performed. Each attack has a unique identifier, which can be used
+ * to specify the attack when calling functions that handle sub-brute attacks.
+ *
+ * The possible values of `SubBruteAttacks` are as follows:
+ *
+ * - `SubBruteAttackCAME12bit303`: CAME 12-bit 303 MHz sub-brute attack.
+ * - `SubBruteAttackCAME12bit307`: CAME 12-bit 307 MHz sub-brute attack.
+ * - `SubBruteAttackCAME12bit315`: CAME 12-bit 315 MHz sub-brute attack.
+ * - `SubBruteAttackCAME12bit433`: CAME 12-bit 433 MHz sub-brute attack.
+ * - `SubBruteAttackCAME12bit868`: CAME 12-bit 868 MHz sub-brute attack.
+ * - `SubBruteAttackNICE12bit433`: NICE 12-bit 433 MHz sub-brute attack.
+ * - `SubBruteAttackNICE12bit868`: NICE 12-bit 868 MHz sub-brute attack.
+ * - `SubBruteAttackAnsonic12bit433075`: Ansonic 12-bit 433.075 MHz sub-brute attack.
+ * - `SubBruteAttackAnsonic12bit433`: Ansonic 12-bit 433 MHz sub-brute attack.
+ * - `SubBruteAttackAnsonic12bit434`: Ansonic 12-bit 434 MHz sub-brute attack.
+ * - `SubBruteAttackHoltek12bitFM433`: Holtek 12-bit FM 433 MHz sub-brute attack.
+ * - `SubBruteAttackHoltek12bitAM433`: Holtek 12-bit AM 433 MHz sub-brute attack.
+ * - `SubBruteAttackHoltek12bitAM315`: Holtek 12-bit AM 315 MHz sub-brute attack.
+ * - `SubBruteAttackHoltek12bitAM868`: Holtek 12-bit AM 868 MHz sub-brute attack.
+ * - `SubBruteAttackHoltek12bitAM915`: Holtek 12-bit AM 915 MHz sub-brute attack.
+ * - `SubBruteAttackChamberlain9bit300`: Chamberlain 9-bit 300 MHz sub-brute attack.
+ * - `SubBruteAttackChamberlain9bit315`: Chamberlain 9-bit 315 MHz sub-brute attack.
+ * - `SubBruteAttackChamberlain9bit390`: Chamberlain 9-bit 390 MHz sub-brute attack.
+ * - `SubBruteAttackChamberlain9bit433`: Chamberlain 9-bit 433 MHz sub-brute attack.
+ * - `SubBruteAttackChamberlain8bit300`: Chamberlain 8-bit 300 MHz sub-brute attack.
+ * - `SubBruteAttackChamberlain8bit315`: Chamberlain 8-bit 315 MHz sub-brute attack.
+ * - `SubBruteAttackChamberlain8bit390`: Chamberlain 8-bit 390 MHz sub-brute attack.
+ * - `SubBruteAttackChamberlain7bit300`: Chamberlain 7-bit 300 MHz sub-brute attack.
+ * - `SubBruteAttackChamberlain7bit315`: Chamberlain 7-bit 315 MHz sub-brute attack.
+ * - `SubBruteAttackChamberlain7bit390`: Chamberlain 7-bit 390 MHz sub-brute attack.
+ * - `SubBruteAttackLinear10bit300`: Linear 10-bit 300 MHz sub-brute attack.
+ * - `SubBruteAttackLinear10bit310`: Linear 10-bit 310 MHz sub-brute attack.
+ * - `SubBruteAttackLinearDelta8bit310`: Linear Delta 8-bit 310 MHz sub-brute attack.
+ * - `SubBruteAttackUNILARM24bit330`: UNILARM 24-bit 330 MHz sub-brute attack.
+ * - `SubBruteAttackUNILARM24bit433`: UNILARM 24-bit 433 MHz sub-brute attack.
+ * - `SubBruteAttackSMC532624bit330`: SMC5326 24-bit 330 MHz sub-brute attack.
+ * - `SubBruteAttackSMC532624bit433`: SMC5326 6-bit 433 MHz sub-brute attack.
+ * - `SubBruteAttackPT226024bit315`: PT2260 24-bit 315 MHz sub-brute attack.
+ * - `SubBruteAttackPT226024bit330`: PT2260 24-bit 330 MHz sub-brute attack.
+ * - `SubBruteAttackPT226024bit390`: PT2260 24-bit 390 MHz sub-brute attack.
+ * - `SubBruteAttackPT226024bit433`: PT2260 24-bit 433 MHz sub-brute attack.
+ * - `SubBruteAttackLoadFile`: Sub-brute attack using values loaded from a file.
+ * - `SubBruteAttackTotalCount`: Total number of sub-brute attacks.
+ */
 typedef enum {
     SubBruteAttackCAME12bit303,
     SubBruteAttackCAME12bit307,
@@ -72,6 +152,13 @@ typedef enum {
     SubBruteAttackTotalCount,
 } SubBruteAttacks;
 
+/**
+ * @struct SubBruteProtocol
+ * @brief Structure representing the SubBrute protocol.
+ *
+ * The SubBruteProtocol struct contains information about the protocol parameters such as frequency,
+ * bits, transmission time (te), repeat count, preset type, and file details using SubBruteFileProtocol.
+ */
 typedef struct {
     uint32_t frequency;
     uint8_t bits;
@@ -81,14 +168,95 @@ typedef struct {
     SubBruteFileProtocol file;
 } SubBruteProtocol;
 
+/**
+ * @brief Get the SubBruteProtocol object based on the given index
+ *
+ * This function returns the SubBruteProtocol object based on the provided index.
+ *
+ * @param index The index of the SubBruteProtocol
+ * @return const SubBruteProtocol* The pointer to the SubBruteProtocol object
+ */
 const SubBruteProtocol* subbrute_protocol(SubBruteAttacks index);
+
+/**
+ * @brief Retrieves a sub-GHz protocol preset for brute force attack.
+ *
+ * Given a FuriHalSubGhzPreset value, this function retrieves a sub-GHz protocol
+ * preset suitable for performing a brute force attack. The protocol preset is
+ * returned as a null-terminated string.
+ *
+ * @param preset The FuriHalSubGhzPreset value representing the desired sub-GHz
+ *               protocol preset.
+ * @return A null-terminated string representing the protocol preset.
+ */
 const char* subbrute_protocol_preset(FuriHalSubGhzPreset preset);
+
+/**
+ * @brief Determines the file protocol used by SubBrute
+ *
+ * This function takes a SubBruteFileProtocol and returns the corresponding file protocol used by SubBrute.
+ *
+ * @param protocol The SubBruteFileProtocol to retrieve the file protocol for
+ *
+ * @returns The file protocol as a C string
+ */
 const char* subbrute_protocol_file(SubBruteFileProtocol protocol);
+
+/**
+ * @brief Convert a preset name to a FuriHalSubGhzPreset.
+ *
+ * This function takes a preset name as a FuriString pointer and converts it to a corresponding FuriHalSubGhzPreset value.
+ * The converted preset is returned as a FuriHalSubGhzPreset value. If the preset name is not recognized, the behavior is undefined.
+ *
+ * @param preset_name The preset name to be converted.
+ *
+ * @return The converted FuriHalSubGhzPreset value.
+ */
 FuriHalSubGhzPreset subbrute_protocol_convert_preset(FuriString* preset_name);
+
+/**
+ * @brief Creates a SubBruteFileProtocol with the given name.
+ *
+ * @param name The name of the protocol.
+ * @return The created SubBruteFileProtocol.
+ */
 SubBruteFileProtocol subbrute_protocol_file_protocol_name(FuriString* name);
+
+/**
+ * @brief Get the number of protocol repeats for a specific SubBrute attack.
+ *
+ * This function returns the number of protocol repeats for a specific SubBrute attack, identified by its index.
+ *
+ * @param index The index of the SubBrute attack.
+ * @return The number of protocol repeats for the specified SubBrute attack.
+ */
 uint8_t subbrute_protocol_repeats_count(SubBruteAttacks index);
+
+/**
+ * @brief Retrieves the protocol name for a given SubBrute attack.
+ *
+ * This function returns the protocol name associated with the specified SubBrute attack.
+ *
+ * @param index The index of the SubBrute attack.
+ * @return The protocol name as a constant character pointer.
+ */
 const char* subbrute_protocol_name(SubBruteAttacks index);
 
+/**
+ * @brief Executes a sub-brute force attack with default payload.
+ *
+ * This function performs a sub-brute force attack using the default payload on the specified stream and file protocol.
+ * It continues the attack in steps, with each step increasing the payload by a specified number of bits.
+ *
+ * @param stream The stream to perform the attack on.
+ * @param file The file protocol to use for the attack.
+ * @param step The number of bits to increase the payload with in each step.
+ * @param bits The initial number of bits in the payload.
+ * @param te The timeout value in milliseconds.
+ * @param repeat The number of times to repeat the attack.
+ *
+ * @note The function does not return any value.
+ */
 void subbrute_protocol_default_payload(
     Stream* stream,
     SubBruteFileProtocol file,
@@ -96,6 +264,25 @@ void subbrute_protocol_default_payload(
     uint8_t bits,
     uint32_t te,
     uint8_t repeat);
+
+/**
+ * @brief Performs a sub-brute force protocol operation with file payload.
+ *
+ * This function takes in a stream, step, bits, te, repeat, bit_index,
+ * file_key, and two_bytes as input parameters and performs a sub-brute
+ * force protocol operation with a file payload.
+ *
+ * @param stream The Stream object to operate on.
+ * @param step The step value to use during the operation.
+ * @param bits The number of bits to use.
+ * @param te The te value to use during the operation.
+ * @param repeat The number of times to repeat the operation.
+ * @param bit_index The bit index to use during the operation.
+ * @param file_key The file key to use during the operation.
+ * @param two_bytes A boolean indicating whether to use two bytes in the operation.
+ *
+ * @return None
+ */
 void subbrute_protocol_file_payload(
     Stream* stream,
     uint64_t step,
@@ -105,6 +292,20 @@ void subbrute_protocol_file_payload(
     uint8_t bit_index,
     uint64_t file_key,
     bool two_bytes);
+
+/**
+ * @brief Generates a file using the SubBrute protocol with default settings.
+ *
+ * This function generates a file using the SubBrute protocol with default settings.
+ *
+ * @param stream The stream used for writing the file.
+ * @param frequency The frequency of the SubBrute protocol.
+ * @param preset The SubGhzPreset used for transmission.
+ * @param file The SubBruteFileProtocol used for generating the file.
+ * @param step The step size used for generating the file.
+ * @param bits The number of bits to generate for each interval.
+ * @param te The duration of each transmission interval in milliseconds.
+ */
 void subbrute_protocol_default_generate_file(
     Stream* stream,
     uint32_t frequency,
@@ -113,6 +314,24 @@ void subbrute_protocol_default_generate_file(
     uint64_t step,
     uint8_t bits,
     uint32_t te);
+
+/**
+ * @brief Generates a file for the SubBrute protocol with the given parameters.
+ *
+ * This function generates a file for the SubBrute protocol using the provided parameters.
+ * The generated file can be used for various purposes, such as testing or data analysis.
+ *
+ * @param stream The Stream to output the generated file to.
+ * @param frequency The frequency to use for the SubBrute protocol.
+ * @param preset The SubGhzPreset to use for the SubBrute protocol.
+ * @param file The SubBruteFileProtocol to generate.
+ * @param step The step value to use for the SubBrute protocol.
+ * @param bits The number of bits to use for each transmission in the SubBrute protocol.
+ * @param te The TE value to use for the SubBrute protocol.
+ * @param bit_index The starting bit index for the SubBrute protocol.
+ * @param file_key The file key to use for generating the SubBrute file.
+ * @param two_bytes Indicates whether two bytes should be used for each transmission (true) or not (false).
+ */
 void subbrute_protocol_file_generate_file(
     Stream* stream,
     uint32_t frequency,
@@ -124,5 +343,19 @@ void subbrute_protocol_file_generate_file(
     uint8_t bit_index,
     uint64_t file_key,
     bool two_bytes);
+
+/**
+ * @brief Calculates the maximum value based on the attack type, number of bits, and whether two bytes are used.
+ *
+ * This function calculates the maximum value that can be generated based on the specified attack type,
+ * number of bits, and whether two bytes are used. The result is returned as a 64-bit unsigned integer.
+ *
+ * @param attack_type   The type of attack to be performed (SubBruteAttacks).
+ * @param bits          The number of bits used for the attack (uint8_t).
+ * @param two_bytes     Whether two bytes are used for the attack (bool).
+ *
+ * @return The maximum value that can be generated based on the attack parameters (uint64_t).
+ */
 uint64_t
     subbrute_protocol_calc_max_value(SubBruteAttacks attack_type, uint8_t bits, bool two_bytes);
+    subbrute_protocol_calc_max_value(SubBruteAttacks attack_type, uint8_t bits, bool two_bytes);

subbrute_settings.h

@@ -6,16 +6,100 @@
 #include <storage/storage.h>
 #include "subbrute_protocols.h"
 
+/**
+ * @struct SubBruteSettings
+ * @brief Structure to store settings for a sub-brute attack.
+ *
+ * This structure stores the settings for a sub-brute attack, such as an array of repeat values and
+ * the last index used.
+ */
 typedef struct {
     uint8_t repeat_values[SubBruteAttackTotalCount];
     uint32_t last_index;
 } SubBruteSettings;
 
+/**
+ * @brief Allocates memory for a SubBruteSettings structure.
+ *
+ * @return A pointer to a newly allocated SubBruteSettings structure.
+ * @note The returned structure should be freed using subbrute_settings_free() function.
+ */
 SubBruteSettings* subbrute_settings_alloc(void);
+
+/**
+ * @brief Frees the memory allocated for the SubBruteSettings instance and all its members.
+ *
+ * This function should be used to release the memory allocated for an instance of the SubBruteSettings structure.
+ * It ensures that all members of the structure are properly freed.
+ *
+ * @param instance The SubBruteSettings instance to be freed.
+ */
 void subbrute_settings_free(SubBruteSettings* instance);
+
+/**
+ * @brief Loads the settings for the SubBrute instance.
+ *
+ * This function loads the settings for the SubBrute instance and populates the SubBruteSettings structure
+ * pointed to by the given instance.
+ *
+ * @param instance A pointer to the SubBruteSettings structure to populate with the loaded settings.
+ */
 void subbrute_settings_load(SubBruteSettings* instance);
+
+/**
+ * @brief Saves the settings of the SubBrute instance.
+ *
+ * This function is used to save the settings of the SubBrute instance to a storage.
+ *
+ * @param instance A pointer to the SubBruteSettings instance.
+ *
+ * @note The settings will be saved to a storage. The exact storage and format
+ *       will depend on the implementation. It is the responsibility of the caller
+ *       to ensure that the instance is valid and has been initialized properly.
+ *       The caller should handle any errors that may occur during the saving process.
+ */
 bool subbrute_settings_save(SubBruteSettings* instance);
+
+/**
+ * @brief Sets the value for a specific attack in the SubBruteSettings instance.
+ *
+ * This function allows you to set the value for a specific attack in the SubBruteSettings instance.
+ *
+ * @param instance A pointer to the SubBruteSettings instance.
+ * @param index The index of the attack for which the value needs to be set.
+ * @param value The value to be set for the specified attack.
+ */
 void subbrute_settings_set_value(SubBruteSettings* instance, SubBruteAttacks index, uint8_t value);
+
+/**
+ * @brief Get the value of a specific attack setting in the SubBruteSettings instance.
+ *
+ * @param instance The pointer to the SubBruteSettings instance.
+ * @param index    The index of the attack setting to get the value of.
+ *
+ * @return The value of the specified attack setting.
+ *
+ * @note The index parameter should be one of the SubBruteAttacks enum values.
+ */
 uint8_t subbrute_settings_get_value(SubBruteSettings* instance, SubBruteAttacks index);
+
+/**
+ * @brief Sets the repeated values for the SubBruteSettings instance.
+ *
+ * This function sets the repeated values for the SubBruteSettings instance.
+ * The repeated values are used for the sub-brute operation.
+ *
+ * @param instance Pointer to the SubBruteSettings instance.
+ * @param repeated_values Pointer to an array of repeated values.
+ */
 void subbrute_settings_set_repeats(SubBruteSettings* instance, const uint8_t* repeated_values);
+
+/**
+ * @brief Gets the current number of repeats from the SubBruteSettings instance.
+ *
+ * This function retrieves the current number of repeats stored in the given SubBruteSettings instance.
+ *
+ * @param instance Pointer to the SubBruteSettings instance.
+ * @return The current number of repeats as a uint8_t.
+ */
 uint8_t subbrute_settings_get_current_repeats(SubBruteSettings* instance);

views/subbrute_attack_view.h

@@ -8,14 +8,79 @@
 typedef void (*SubBruteAttackViewCallback)(SubBruteCustomEvent event, void* context);
 typedef struct SubBruteAttackView SubBruteAttackView;
 
+/**
+ * @brief Sets the callback function and context for the SubBruteAttackView.
+ *
+ * This function sets the callback function and context that will be used by the SubBruteAttackView
+ * instance. The callback function will be called when a certain event occurs in the SubBruteAttackView.
+ * The context parameter will be passed to the callback function as an argument.
+ *
+ * @param instance The SubBruteAttackView instance to set the callback for.
+ * @param callback The callback function to be called when the event occurs.
+ * @param context The context to be passed to the callback function when it is called.
+ *
+ * @note The callback function should have the following signature:
+ *       void callback(void* context)
+ *
+ * @note The callback function should not take ownership of the instance, it should only perform
+ *       the necessary logic based on the event.
+ *
+ * @warning The instance parameter must not be NULL.
+ * @warning The callback parameter must not be NULL.
+ *
+ */
 void subbrute_attack_view_set_callback(
     SubBruteAttackView* instance,
     SubBruteAttackViewCallback callback,
     void* context);
+
+/**
+ * @brief Allocates memory for a new SubBruteAttackView object.
+ *
+ * This function allocates memory for a new SubBruteAttackView object on the heap and returns a pointer to it.
+ *
+ * @return A pointer to a newly allocated SubBruteAttackView object.
+ */
 SubBruteAttackView* subbrute_attack_view_alloc();
+
+/**
+ * @brief Frees the memory allocated for a SubBruteAttackView instance.
+ *
+ * @param instance Pointer to the SubBruteAttackView instance to free.
+ */
 void subbrute_attack_view_free(SubBruteAttackView* instance);
+
+/**
+ * @brief Retrieves the view associated with the SubBruteAttackView instance.
+ *
+ * @param instance The SubBruteAttackView instance to retrieve the view from.
+ *
+ * @return A pointer to the associated view.
+ */
 View* subbrute_attack_view_get_view(SubBruteAttackView* instance);
+
+/**
+ * @brief Sets the current step for the SubBruteAttackView instance.
+ *
+ * This function sets the current step of the SubBruteAttackView instance
+ * to the specified value.
+ *
+ * @param instance A pointer to the SubBruteAttackView instance.
+ * @param current_step The value to set as the current step.
+ *
+ * @note The current step represents the current progress of the attack view.
+ *       It should be an unsigned 64-bit integer.
+ */
 void subbrute_attack_view_set_current_step(SubBruteAttackView* instance, uint64_t current_step);
+
+/**
+ * @class SubBruteAttackView
+ * @brief Class for initializing the values of a SubBruteAttackView instance.
+ *
+ * The SubBruteAttackView class is used to store and initialize the values
+ * of a SubBruteAttackView instance. These values include the index, maximum value,
+ * current step, attack status, and extra repeats.
+ */
 void subbrute_attack_view_init_values(
     SubBruteAttackView* instance,
     uint8_t index,

views/subbrute_main_view.h

@@ -9,14 +9,60 @@
 typedef void (*SubBruteMainViewCallback)(SubBruteCustomEvent event, void* context);
 typedef struct SubBruteMainView SubBruteMainView;
 
+/**
+ * @brief Sets the callback function and context for the SubBruteMainView instance.
+ *
+ * This function sets the callback function and context for the SubBruteMainView instance. The callback function will be
+ * invoked when specific events occur in the SubBruteMainView. The context parameter allows passing additional data
+ * to the callback function.
+ *
+ * @param instance Pointer to the SubBruteMainView instance.
+ * @param callback Pointer to the callback function.
+ * @param context Pointer to the context data.
+ */
 void subbrute_main_view_set_callback(
     SubBruteMainView* instance,
     SubBruteMainViewCallback callback,
     void* context);
 
+/**
+ * @brief Allocates memory for a new instance of SubBruteMainView.
+ *
+ * @return A pointer to the newly allocated SubBruteMainView object.
+ * @note The caller is responsible for freeing the allocated memory using the `subbrute_main_view_free` function.
+ */
 SubBruteMainView* subbrute_main_view_alloc();
+
+/**
+ * @brief Frees the memory allocated for a SubBruteMainView instance.
+ *
+ * This function frees all the memory allocated for the given SubBruteMainView instance,
+ * including its internal data structures.
+ *
+ * @param instance  The SubBruteMainView instance to be freed.
+ */
 void subbrute_main_view_free(SubBruteMainView* instance);
+
+/**
+ * @brief Get the view associated with the SubBruteMainView instance.
+ *
+ * This function returns the view associated with the given SubBruteMainView instance.
+ *
+ * @param instance The SubBruteMainView instance.
+ * @return A pointer to the View object.
+ */
 View* subbrute_main_view_get_view(SubBruteMainView* instance);
+
+/**
+ * @brief Sets the index and other parameters for the SubBruteMainView instance.
+ *
+ * @param instance The SubBruteMainView instance.
+ * @param idx The index value to be set.
+ * @param repeats Pointer to an array of repeat values.
+ * @param is_select_byte Select byte value true or false.
+ * @param two_bytes Two bytes value true or false.
+ * @param key_from_file The key value from file.
+ */
 void subbrute_main_view_set_index(
     SubBruteMainView* instance,
     uint8_t idx,
@@ -24,10 +70,82 @@ void subbrute_main_view_set_index(
     bool is_select_byte,
     bool two_bytes,
     uint64_t key_from_file);
+
+/**
+ * @brief Get the index of the current subview in the main view.
+ *
+ * This function retrieves the index of the current subview within the main view. The current
+ * subview is represented by a SubBruteMainView instance.
+ *
+ * @param instance A pointer to the SubBruteMainView instance.
+ * @return The index of the current subview.
+ */
 SubBruteAttacks subbrute_main_view_get_index(SubBruteMainView* instance);
+
+/**
+ * @brief Retrieves the repeats of the main view in the SubBrute application.
+ *
+ * This function returns the repeats of the main view in the SubBrute application as a constant pointer to an array of uint8_t values.
+ *
+ * @param instance A pointer to the SubBruteMainView instance.
+ * @return A constant pointer to an array of uint8_t values representing the repeats of the main view.
+ */
 const uint8_t* subbrute_main_view_get_repeats(SubBruteMainView* instance);
+
+/**
+ * @brief Retrieves two bytes from the SubBruteMainView instance.
+ *
+ * This function retrieves two bytes from the SubBruteMainView instance.
+ * It returns a boolean value indicating the success of the operation.
+ *
+ * @param instance The SubBruteMainView instance from which to retrieve two bytes.
+ *
+ * @return true if the bytes were successfully retrieved, false otherwise.
+ */
 bool subbrute_main_view_get_two_bytes(SubBruteMainView* instance);
+
+/**
+ * @brief The function handles the entry point for the brute force attack view.
+ *
+ * This function is responsible for handling the entry point for the brute force
+ * attack view. It takes a void pointer to the context data as an argument.
+ *
+ * @param context A void pointer to the context data.
+ */
 void subbrute_attack_view_enter(void* context);
+
+/**
+ * @brief Function to exit the subbrute attack view.
+ *
+ * This function is used to exit the subbrute attack view, by performing any necessary clean
+ * up operations and freeing up any allocated memory.
+ *
+ * @param context A pointer to the context of the subbrute attack view.
+ *                This context contains all the necessary data and variables required by the view.
+ *                It should not be NULL.
+ */
 void subbrute_attack_view_exit(void* context);
+
+/**
+ * @brief View input handler for subbrute attack.
+ *
+ * This function processes an input event and performs the appropriate action
+ * for the subbrute attack view. It is called by the main event loop.
+ *
+ * @param event       The input event to be processed.
+ * @param context     A pointer to the context data for the subbrute attack view.
+ * @return            Boolean indicating whether the input event was handled successfully.
+ *                    True if the event was handled successfully, false otherwise.
+ */
 bool subbrute_attack_view_input(InputEvent* event, void* context);
+
+/**
+ * @brief Draws a subbrute attack view on the given canvas.
+ *
+ * This function is responsible for drawing the subbrute attack view on the canvas.
+ * The provided canvas should already be initialized and in a valid state.
+ *
+ * @param canvas   The canvas on which the view should be drawn.
+ * @param context  A pointer to any additional context or data that may be needed for drawing.
+ */
 void subbrute_attack_view_draw(Canvas* canvas, void* context);