Add Camera Suite GPIO application for the ESP32-CAM module.

applications/external/camera-suite/scenes/camera_suite_scene.c

@@ -0,0 +1,30 @@
+#include "camera_suite_scene.h"
+
+// Generate scene on_enter handlers array
+#define ADD_SCENE(prefix, name, id) prefix##_scene_##name##_on_enter,
+void (*const camera_suite_on_enter_handlers[])(void*) = {
+#include "camera_suite_scene_config.h"
+};
+#undef ADD_SCENE
+
+// Generate scene on_event handlers array
+#define ADD_SCENE(prefix, name, id) prefix##_scene_##name##_on_event,
+bool (*const camera_suite_on_event_handlers[])(void* context, SceneManagerEvent event) = {
+#include "camera_suite_scene_config.h"
+};
+#undef ADD_SCENE
+
+// Generate scene on_exit handlers array
+#define ADD_SCENE(prefix, name, id) prefix##_scene_##name##_on_exit,
+void (*const camera_suite_on_exit_handlers[])(void* context) = {
+#include "camera_suite_scene_config.h"
+};
+#undef ADD_SCENE
+
+// Initialize scene handlers configuration structure
+const SceneManagerHandlers camera_suite_scene_handlers = {
+    .on_enter_handlers = camera_suite_on_enter_handlers,
+    .on_event_handlers = camera_suite_on_event_handlers,
+    .on_exit_handlers = camera_suite_on_exit_handlers,
+    .scene_num = CameraSuiteSceneNum,
+};

applications/external/camera-suite/scenes/camera_suite_scene.h

@@ -0,0 +1,29 @@
+#pragma once
+
+#include <gui/scene_manager.h>
+
+// Generate scene id and total number
+#define ADD_SCENE(prefix, name, id) CameraSuiteScene##id,
+typedef enum {
+#include "camera_suite_scene_config.h"
+    CameraSuiteSceneNum,
+} CameraSuiteScene;
+#undef ADD_SCENE
+
+extern const SceneManagerHandlers camera_suite_scene_handlers;
+
+// Generate scene on_enter handlers declaration
+#define ADD_SCENE(prefix, name, id) void prefix##_scene_##name##_on_enter(void*);
+#include "camera_suite_scene_config.h"
+#undef ADD_SCENE
+
+// Generate scene on_event handlers declaration
+#define ADD_SCENE(prefix, name, id) \
+    bool prefix##_scene_##name##_on_event(void* context, SceneManagerEvent event);
+#include "camera_suite_scene_config.h"
+#undef ADD_SCENE
+
+// Generate scene on_exit handlers declaration
+#define ADD_SCENE(prefix, name, id) void prefix##_scene_##name##_on_exit(void* context);
+#include "camera_suite_scene_config.h"
+#undef ADD_SCENE

applications/external/camera-suite/scenes/camera_suite_scene_config.h

@@ -0,0 +1,6 @@
+ADD_SCENE(camera_suite, start, Start)
+ADD_SCENE(camera_suite, menu, Menu)
+ADD_SCENE(camera_suite, style_1, Style_1)
+ADD_SCENE(camera_suite, style_2, Style_2)
+ADD_SCENE(camera_suite, guide, Guide)
+ADD_SCENE(camera_suite, settings, Settings)

applications/external/camera-suite/scenes/camera_suite_scene_guide.c

@@ -0,0 +1,51 @@
+#include "../camera-suite.h"
+#include "../helpers/camera_suite_custom_event.h"
+#include "../views/camera_suite_view_guide.h"
+
+void camera_suite_view_guide_callback(CameraSuiteCustomEvent event, void* context) {
+    furi_assert(context);
+    CameraSuite* app = context;
+    view_dispatcher_send_custom_event(app->view_dispatcher, event);
+}
+
+void camera_suite_scene_guide_on_enter(void* context) {
+    furi_assert(context);
+    CameraSuite* app = context;
+    camera_suite_view_guide_set_callback(
+        app->camera_suite_view_guide, camera_suite_view_guide_callback, app);
+    view_dispatcher_switch_to_view(app->view_dispatcher, CameraSuiteViewIdGuide);
+}
+
+bool camera_suite_scene_guide_on_event(void* context, SceneManagerEvent event) {
+    CameraSuite* app = context;
+    bool consumed = false;
+
+    if(event.type == SceneManagerEventTypeCustom) {
+        switch(event.event) {
+        case CameraSuiteCustomEventSceneGuideLeft:
+        case CameraSuiteCustomEventSceneGuideRight:
+        case CameraSuiteCustomEventSceneGuideUp:
+        case CameraSuiteCustomEventSceneGuideDown:
+            // Do nothing.
+            break;
+        case CameraSuiteCustomEventSceneGuideBack:
+            notification_message(app->notification, &sequence_reset_red);
+            notification_message(app->notification, &sequence_reset_green);
+            notification_message(app->notification, &sequence_reset_blue);
+            if(!scene_manager_search_and_switch_to_previous_scene(
+                   app->scene_manager, CameraSuiteSceneMenu)) {
+                scene_manager_stop(app->scene_manager);
+                view_dispatcher_stop(app->view_dispatcher);
+            }
+            consumed = true;
+            break;
+        }
+    }
+
+    return consumed;
+}
+
+void camera_suite_scene_guide_on_exit(void* context) {
+    CameraSuite* app = context;
+    UNUSED(app);
+}

applications/external/camera-suite/scenes/camera_suite_scene_menu.c

@@ -0,0 +1,87 @@
+#include "../camera-suite.h"
+
+enum SubmenuIndex {
+    /** Atkinson Dithering Algorithm. */
+    SubmenuIndexSceneStyle1 = 10,
+    /** Floyd-Steinberg Dithering Algorithm. */
+    SubmenuIndexSceneStyle2,
+    /** Guide/how-to. */
+    SubmenuIndexGuide,
+    /** Settings menu. */
+    SubmenuIndexSettings,
+};
+
+void camera_suite_scene_menu_submenu_callback(void* context, uint32_t index) {
+    CameraSuite* app = context;
+    view_dispatcher_send_custom_event(app->view_dispatcher, index);
+}
+
+void camera_suite_scene_menu_on_enter(void* context) {
+    CameraSuite* app = context;
+
+    submenu_add_item(
+        app->submenu,
+        "Open Camera",
+        SubmenuIndexSceneStyle1,
+        camera_suite_scene_menu_submenu_callback,
+        app);
+    // Staged view for the future.
+    // submenu_add_item(
+    //     app->submenu,
+    //     "Test",
+    //     SubmenuIndexSceneStyle2,
+    //     camera_suite_scene_menu_submenu_callback,
+    //     app);
+    submenu_add_item(
+        app->submenu, "Guide", SubmenuIndexGuide, camera_suite_scene_menu_submenu_callback, app);
+    submenu_add_item(
+        app->submenu,
+        "Settings",
+        SubmenuIndexSettings,
+        camera_suite_scene_menu_submenu_callback,
+        app);
+
+    submenu_set_selected_item(
+        app->submenu, scene_manager_get_scene_state(app->scene_manager, CameraSuiteSceneMenu));
+
+    view_dispatcher_switch_to_view(app->view_dispatcher, CameraSuiteViewIdMenu);
+}
+
+bool camera_suite_scene_menu_on_event(void* context, SceneManagerEvent event) {
+    CameraSuite* app = context;
+    UNUSED(app);
+    if(event.type == SceneManagerEventTypeBack) {
+        // Exit application.
+        scene_manager_stop(app->scene_manager);
+        view_dispatcher_stop(app->view_dispatcher);
+        return true;
+    } else if(event.type == SceneManagerEventTypeCustom) {
+        if(event.event == SubmenuIndexSceneStyle1) {
+            scene_manager_set_scene_state(
+                app->scene_manager, CameraSuiteSceneMenu, SubmenuIndexSceneStyle1);
+            scene_manager_next_scene(app->scene_manager, CameraSuiteSceneStyle_1);
+            return true;
+        } else if(event.event == SubmenuIndexSceneStyle2) {
+            scene_manager_set_scene_state(
+                app->scene_manager, CameraSuiteSceneMenu, SubmenuIndexSceneStyle2);
+            scene_manager_next_scene(app->scene_manager, CameraSuiteSceneStyle_2);
+            return true;
+        } else if(event.event == SubmenuIndexGuide) {
+            scene_manager_set_scene_state(
+                app->scene_manager, CameraSuiteSceneMenu, SubmenuIndexGuide);
+            scene_manager_next_scene(app->scene_manager, CameraSuiteSceneGuide);
+            return true;
+        } else if(event.event == SubmenuIndexSettings) {
+            scene_manager_set_scene_state(
+                app->scene_manager, CameraSuiteSceneMenu, SubmenuIndexSettings);
+            scene_manager_next_scene(app->scene_manager, CameraSuiteSceneSettings);
+            return true;
+        }
+    }
+    return false;
+}
+
+void camera_suite_scene_menu_on_exit(void* context) {
+    CameraSuite* app = context;
+    submenu_reset(app->submenu);
+}

applications/external/camera-suite/scenes/camera_suite_scene_settings.c

@@ -0,0 +1,137 @@
+#include "../camera-suite.h"
+#include <lib/toolbox/value_index.h>
+
+// Camera orientation, in degrees.
+const char* const orientation_text[4] = {
+    "0",
+    "90",
+    "180",
+    "270",
+};
+
+const uint32_t orientation_value[4] = {
+    CameraSuiteOrientation0,
+    CameraSuiteOrientation90,
+    CameraSuiteOrientation180,
+    CameraSuiteOrientation270,
+};
+
+const char* const haptic_text[2] = {
+    "OFF",
+    "ON",
+};
+
+const uint32_t haptic_value[2] = {
+    CameraSuiteHapticOff,
+    CameraSuiteHapticOn,
+};
+
+const char* const speaker_text[2] = {
+    "OFF",
+    "ON",
+};
+
+const uint32_t speaker_value[2] = {
+    CameraSuiteSpeakerOff,
+    CameraSuiteSpeakerOn,
+};
+
+const char* const led_text[2] = {
+    "OFF",
+    "ON",
+};
+
+const uint32_t led_value[2] = {
+    CameraSuiteLedOff,
+    CameraSuiteLedOn,
+};
+
+static void camera_suite_scene_settings_set_camera_orientation(VariableItem* item) {
+    CameraSuite* app = variable_item_get_context(item);
+    uint8_t index = variable_item_get_current_value_index(item);
+
+    variable_item_set_current_value_text(item, orientation_text[index]);
+    app->orientation = orientation_value[index];
+}
+
+static void camera_suite_scene_settings_set_haptic(VariableItem* item) {
+    CameraSuite* app = variable_item_get_context(item);
+    uint8_t index = variable_item_get_current_value_index(item);
+
+    variable_item_set_current_value_text(item, haptic_text[index]);
+    app->haptic = haptic_value[index];
+}
+
+static void camera_suite_scene_settings_set_speaker(VariableItem* item) {
+    CameraSuite* app = variable_item_get_context(item);
+    uint8_t index = variable_item_get_current_value_index(item);
+    variable_item_set_current_value_text(item, speaker_text[index]);
+    app->speaker = speaker_value[index];
+}
+
+static void camera_suite_scene_settings_set_led(VariableItem* item) {
+    CameraSuite* app = variable_item_get_context(item);
+    uint8_t index = variable_item_get_current_value_index(item);
+    variable_item_set_current_value_text(item, led_text[index]);
+    app->led = led_value[index];
+}
+
+void camera_suite_scene_settings_submenu_callback(void* context, uint32_t index) {
+    CameraSuite* app = context;
+    view_dispatcher_send_custom_event(app->view_dispatcher, index);
+}
+
+void camera_suite_scene_settings_on_enter(void* context) {
+    CameraSuite* app = context;
+    VariableItem* item;
+    uint8_t value_index;
+
+    // Camera Orientation
+    item = variable_item_list_add(
+        app->variable_item_list,
+        "Orientation:",
+        4,
+        camera_suite_scene_settings_set_camera_orientation,
+        app);
+    value_index = value_index_uint32(app->orientation, orientation_value, 4);
+    variable_item_set_current_value_index(item, value_index);
+    variable_item_set_current_value_text(item, orientation_text[value_index]);
+
+    // Haptic FX ON/OFF
+    item = variable_item_list_add(
+        app->variable_item_list, "Haptic FX:", 2, camera_suite_scene_settings_set_haptic, app);
+    value_index = value_index_uint32(app->haptic, haptic_value, 2);
+    variable_item_set_current_value_index(item, value_index);
+    variable_item_set_current_value_text(item, haptic_text[value_index]);
+
+    // Sound FX ON/OFF
+    item = variable_item_list_add(
+        app->variable_item_list, "Sound FX:", 2, camera_suite_scene_settings_set_speaker, app);
+    value_index = value_index_uint32(app->speaker, speaker_value, 2);
+    variable_item_set_current_value_index(item, value_index);
+    variable_item_set_current_value_text(item, speaker_text[value_index]);
+
+    // LED FX ON/OFF
+    item = variable_item_list_add(
+        app->variable_item_list, "LED FX:", 2, camera_suite_scene_settings_set_led, app);
+    value_index = value_index_uint32(app->led, led_value, 2);
+    variable_item_set_current_value_index(item, value_index);
+    variable_item_set_current_value_text(item, led_text[value_index]);
+
+    view_dispatcher_switch_to_view(app->view_dispatcher, CameraSuiteViewIdSettings);
+}
+
+bool camera_suite_scene_settings_on_event(void* context, SceneManagerEvent event) {
+    CameraSuite* app = context;
+    UNUSED(app);
+    bool consumed = false;
+    if(event.type == SceneManagerEventTypeCustom) {
+    }
+    return consumed;
+}
+
+void camera_suite_scene_settings_on_exit(void* context) {
+    CameraSuite* app = context;
+    variable_item_list_set_selected_item(app->variable_item_list, 0);
+    variable_item_list_reset(app->variable_item_list);
+}

applications/external/camera-suite/scenes/camera_suite_scene_start.c

@@ -0,0 +1,55 @@
+#include "../camera-suite.h"
+#include "../helpers/camera_suite_custom_event.h"
+#include "../views/camera_suite_view_start.h"
+
+void camera_suite_scene_start_callback(CameraSuiteCustomEvent event, void* context) {
+    furi_assert(context);
+    CameraSuite* app = context;
+    view_dispatcher_send_custom_event(app->view_dispatcher, event);
+}
+
+void camera_suite_scene_start_on_enter(void* context) {
+    furi_assert(context);
+    CameraSuite* app = context;
+    camera_suite_view_start_set_callback(
+        app->camera_suite_view_start, camera_suite_scene_start_callback, app);
+    view_dispatcher_switch_to_view(app->view_dispatcher, CameraSuiteViewIdStartscreen);
+}
+
+bool camera_suite_scene_start_on_event(void* context, SceneManagerEvent event) {
+    CameraSuite* app = context;
+    bool consumed = false;
+
+    if(event.type == SceneManagerEventTypeCustom) {
+        switch(event.event) {
+        case CameraSuiteCustomEventStartLeft:
+        case CameraSuiteCustomEventStartRight:
+            break;
+        case CameraSuiteCustomEventStartUp:
+        case CameraSuiteCustomEventStartDown:
+            break;
+        case CameraSuiteCustomEventStartOk:
+            scene_manager_next_scene(app->scene_manager, CameraSuiteSceneMenu);
+            consumed = true;
+            break;
+        case CameraSuiteCustomEventStartBack:
+            notification_message(app->notification, &sequence_reset_red);
+            notification_message(app->notification, &sequence_reset_green);
+            notification_message(app->notification, &sequence_reset_blue);
+            if(!scene_manager_search_and_switch_to_previous_scene(
+                   app->scene_manager, CameraSuiteSceneStart)) {
+                scene_manager_stop(app->scene_manager);
+                view_dispatcher_stop(app->view_dispatcher);
+            }
+            consumed = true;
+            break;
+        }
+    }
+
+    return consumed;
+}
+
+void camera_suite_scene_start_on_exit(void* context) {
+    CameraSuite* app = context;
+    UNUSED(app);
+}

applications/external/camera-suite/scenes/camera_suite_scene_style_1.c

@@ -0,0 +1,52 @@
+#include "../camera-suite.h"
+#include "../helpers/camera_suite_custom_event.h"
+#include "../views/camera_suite_view_style_1.h"
+
+static void camera_suite_view_style_1_callback(CameraSuiteCustomEvent event, void* context) {
+    furi_assert(context);
+    CameraSuite* app = context;
+    view_dispatcher_send_custom_event(app->view_dispatcher, event);
+}
+
+void camera_suite_scene_style_1_on_enter(void* context) {
+    furi_assert(context);
+    CameraSuite* app = context;
+    camera_suite_view_style_1_set_callback(
+        app->camera_suite_view_style_1, camera_suite_view_style_1_callback, app);
+    view_dispatcher_switch_to_view(app->view_dispatcher, CameraSuiteViewIdScene1);
+}
+
+bool camera_suite_scene_style_1_on_event(void* context, SceneManagerEvent event) {
+    CameraSuite* app = context;
+    bool consumed = false;
+
+    if(event.type == SceneManagerEventTypeCustom) {
+        switch(event.event) {
+        case CameraSuiteCustomEventSceneStyle1Left:
+        case CameraSuiteCustomEventSceneStyle1Right:
+        case CameraSuiteCustomEventSceneStyle1Up:
+        case CameraSuiteCustomEventSceneStyle1Down:
+        case CameraSuiteCustomEventSceneStyle1Ok:
+            // Do nothing.
+            break;
+        case CameraSuiteCustomEventSceneStyle1Back:
+            notification_message(app->notification, &sequence_reset_red);
+            notification_message(app->notification, &sequence_reset_green);
+            notification_message(app->notification, &sequence_reset_blue);
+            if(!scene_manager_search_and_switch_to_previous_scene(
+                   app->scene_manager, CameraSuiteSceneMenu)) {
+                scene_manager_stop(app->scene_manager);
+                view_dispatcher_stop(app->view_dispatcher);
+            }
+            consumed = true;
+            break;
+        }
+    }
+
+    return consumed;
+}
+
+void camera_suite_scene_style_1_on_exit(void* context) {
+    CameraSuite* app = context;
+    UNUSED(app);
+}

applications/external/camera-suite/scenes/camera_suite_scene_style_2.c

@@ -0,0 +1,54 @@
+#include "../camera-suite.h"
+#include "../helpers/camera_suite_custom_event.h"
+#include "../helpers/camera_suite_haptic.h"
+#include "../helpers/camera_suite_led.h"
+#include "../views/camera_suite_view_style_2.h"
+
+void camera_suite_view_style_2_callback(CameraSuiteCustomEvent event, void* context) {
+    furi_assert(context);
+    CameraSuite* app = context;
+    view_dispatcher_send_custom_event(app->view_dispatcher, event);
+}
+
+void camera_suite_scene_style_2_on_enter(void* context) {
+    furi_assert(context);
+    CameraSuite* app = context;
+    camera_suite_view_style_2_set_callback(
+        app->camera_suite_view_style_2, camera_suite_view_style_2_callback, app);
+    view_dispatcher_switch_to_view(app->view_dispatcher, CameraSuiteViewIdScene2);
+}
+
+bool camera_suite_scene_style_2_on_event(void* context, SceneManagerEvent event) {
+    CameraSuite* app = context;
+    bool consumed = false;
+
+    if(event.type == SceneManagerEventTypeCustom) {
+        switch(event.event) {
+        case CameraSuiteCustomEventSceneStyle2Left:
+        case CameraSuiteCustomEventSceneStyle2Right:
+        case CameraSuiteCustomEventSceneStyle2Up:
+        case CameraSuiteCustomEventSceneStyle2Down:
+        case CameraSuiteCustomEventSceneStyle2Ok:
+            // Do nothing.
+            break;
+        case CameraSuiteCustomEventSceneStyle2Back:
+            notification_message(app->notification, &sequence_reset_red);
+            notification_message(app->notification, &sequence_reset_green);
+            notification_message(app->notification, &sequence_reset_blue);
+            if(!scene_manager_search_and_switch_to_previous_scene(
+                   app->scene_manager, CameraSuiteSceneMenu)) {
+                scene_manager_stop(app->scene_manager);
+                view_dispatcher_stop(app->view_dispatcher);
+            }
+            consumed = true;
+            break;
+        }
+    }
+
+    return consumed;
+}
+
+void camera_suite_scene_style_2_on_exit(void* context) {
+    CameraSuite* app = context;
+    UNUSED(app);
+}