Mirrors/unleashed-firmware
2
0
Fork 0
mirror of https://github.com/DarkFlippers/unleashed-firmware synced 2024-09-20 22:52:01 +00:00
Code Issues Projects Releases Packages Wiki Activity

Merge branch 'ofw-dev' into dev

Browse source 
:(
This commit is contained in:
MX 2023-05-11 17:47:14 +03:00
commit b2e55d7d84
No known key found for this signature in database
GPG key ID: 7CCC66B7DBDD1C83
26 changed files with 244 additions and 343 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

44
applications/services/desktop/desktop.c
View file

@ -6,6 +6,8 @@
#include <notification/notification_messages.h>
#include <furi.h>
#include <furi_hal.h>
#include <cli/cli.h>
#include <cli/cli_vcp.h>
#include "animations/animation_manager.h"
#include "desktop/scenes/desktop_scene.h"
@ -14,7 +16,7 @@
#include "desktop/views/desktop_view_pin_input.h"
#include "desktop/views/desktop_view_pin_timeout.h"
#include "desktop_i.h"
#include "helpers/pin_lock.h"
#include "helpers/pin.h"
#include "helpers/slideshow_filename.h"
#define TAG "Desktop"
@ -70,9 +72,6 @@ static bool desktop_custom_event_callback(void* context, uint32_t event) {
return true;
case DesktopGlobalAutoLock:
if(!loader_is_locked(desktop->loader)) {
if(desktop->settings.auto_lock_with_pin && desktop->settings.pin_code.length > 0) {
desktop_pin_lock(&desktop->settings);
}
desktop_lock(desktop);
}
return true;
@ -135,6 +134,15 @@ static void desktop_auto_lock_inhibit(Desktop* desktop) {
}
void desktop_lock(Desktop* desktop) {
furi_hal_rtc_set_flag(FuriHalRtcFlagLock);
furi_hal_rtc_set_pin_fails(0);
if(desktop->settings.pin_code.length) {
Cli* cli = furi_record_open(RECORD_CLI);
cli_session_close(cli);
furi_record_close(RECORD_CLI);
}
desktop_auto_lock_inhibit(desktop);
scene_manager_set_scene_state(
desktop->scene_manager, DesktopSceneLocked, SCENE_LOCKED_FIRST_ENTER);
@ -150,6 +158,13 @@ void desktop_unlock(Desktop* desktop) {
desktop_view_locked_unlock(desktop->locked_view);
scene_manager_search_and_switch_to_previous_scene(desktop->scene_manager, DesktopSceneMain);
desktop_auto_lock_arm(desktop);
furi_hal_rtc_reset_flag(FuriHalRtcFlagLock);
if(desktop->settings.pin_code.length) {
Cli* cli = furi_record_open(RECORD_CLI);
cli_session_open(cli, &cli_vcp);
furi_record_close(RECORD_CLI);
}
}
void desktop_set_dummy_mode_state(Desktop* desktop, bool enabled) {
@ -293,11 +308,14 @@ Desktop* desktop_alloc() {
desktop->auto_lock_timer =
furi_timer_alloc(desktop_auto_lock_timer_callback, FuriTimerTypeOnce, desktop);
furi_record_create(RECORD_DESKTOP, desktop);
return desktop;
}
void desktop_free(Desktop* desktop) {
furi_assert(desktop);
furi_check(furi_record_destroy(RECORD_DESKTOP));
furi_pubsub_unsubscribe(
loader_get_pubsub(desktop->loader), desktop->app_start_stop_subscription);
@ -355,6 +373,16 @@ static bool desktop_check_file_flag(const char* flag_path) {
return exists;
}
bool desktop_api_is_locked(Desktop* instance) {
furi_assert(instance);
return furi_hal_rtc_is_flag_set(FuriHalRtcFlagLock);
}
void desktop_api_unlock(Desktop* instance) {
furi_assert(instance);
view_dispatcher_send_custom_event(instance->view_dispatcher, DesktopLockedEventUnlocked);
}
int32_t desktop_srv(void* p) {
UNUSED(p);
@ -378,14 +406,12 @@ int32_t desktop_srv(void* p) {
scene_manager_next_scene(desktop->scene_manager, DesktopSceneMain);
desktop_pin_lock_init(&desktop->settings);
if(!desktop_pin_lock_is_locked()) {
if(furi_hal_rtc_is_flag_set(FuriHalRtcFlagLock)) {
desktop_lock(desktop);
} else {
if(!loader_is_locked(desktop->loader)) {
desktop_auto_lock_arm(desktop);
}
} else {
desktop_lock(desktop);
}
if(desktop_check_file_flag(SLIDESHOW_FS_PATH)) {

6
applications/services/desktop/desktop.h
View file

@ -1,3 +1,9 @@
#pragma once
typedef struct Desktop Desktop;
#define RECORD_DESKTOP "desktop"
bool desktop_api_is_locked(Desktop* instance);
void desktop_api_unlock(Desktop* instance);

4
applications/services/desktop/desktop_settings.h
View file

@ -8,7 +8,7 @@
#include <toolbox/saved_struct.h>
#include <storage/storage.h>
#define DESKTOP_SETTINGS_VER (8)
#define DESKTOP_SETTINGS_VER (9)
#define DESKTOP_SETTINGS_PATH INT_PATH(DESKTOP_SETTINGS_FILE_NAME)
#define DESKTOP_SETTINGS_MAGIC (0x17)
@ -60,9 +60,7 @@ typedef struct {
FavoriteApp favorite_secondary;
FavoriteApp favorite_tertiary;
PinCode pin_code;
uint8_t is_locked;
uint32_t auto_lock_delay_ms;
uint8_t displayBatteryPercentage;
uint8_t dummy_mode;
bool auto_lock_with_pin;
} DesktopSettings;

74
applications/services/desktop/helpers/pin.c Normal file
View file

@ -0,0 +1,74 @@
#include "pin.h"
#include <notification/notification.h>
#include <notification/notification_messages.h>
#include <stddef.h>
#include <furi.h>
#include <furi_hal.h>
#include <gui/gui.h>
#include "../desktop_i.h"
static const NotificationSequence sequence_pin_fail = {
&message_display_backlight_on,
&message_red_255,
&message_vibro_on,
&message_delay_100,
&message_vibro_off,
&message_red_0,
&message_delay_250,
&message_red_255,
&message_vibro_on,
&message_delay_100,
&message_vibro_off,
&message_red_0,
NULL,
};
static const uint8_t desktop_helpers_fails_timeout[] = {
0,
0,
0,
0,
30,
60,
90,
120,
150,
180,
/* +60 for every next fail */
};
void desktop_pin_lock_error_notify() {
NotificationApp* notification = furi_record_open(RECORD_NOTIFICATION);
notification_message(notification, &sequence_pin_fail);
furi_record_close(RECORD_NOTIFICATION);
}
uint32_t desktop_pin_lock_get_fail_timeout() {
uint32_t pin_fails = furi_hal_rtc_get_pin_fails();
uint32_t pin_timeout = 0;
uint32_t max_index = COUNT_OF(desktop_helpers_fails_timeout) - 1;
if(pin_fails <= max_index) {
pin_timeout = desktop_helpers_fails_timeout[pin_fails];
} else {
pin_timeout = desktop_helpers_fails_timeout[max_index] + (pin_fails - max_index) * 60;
}
return pin_timeout;
}
bool desktop_pin_compare(const PinCode* pin_code1, const PinCode* pin_code2) {
furi_assert(pin_code1);
furi_assert(pin_code2);
bool result = false;
if(pin_code1->length == pin_code2->length) {
result = !memcmp(pin_code1->data, pin_code2->data, pin_code1->length);
}
return result;
}

11
applications/services/desktop/helpers/pin.h Normal file
View file

@ -0,0 +1,11 @@
#pragma once
#include <stdbool.h>
#include <stdint.h>
#include "../desktop.h"
#include <desktop/desktop_settings.h>
void desktop_pin_lock_error_notify();
uint32_t desktop_pin_lock_get_fail_timeout();
bool desktop_pin_compare(const PinCode* pin_code1, const PinCode* pin_code2);

140
applications/services/desktop/helpers/pin_lock.c
View file

@ -1,140 +0,0 @@
#include <notification/notification.h>
#include <notification/notification_messages.h>
#include <stddef.h>
#include <furi.h>
#include <furi_hal.h>
#include <gui/gui.h>
#include "../helpers/pin_lock.h"
#include "../desktop_i.h"
#include <cli/cli.h>
#include <cli/cli_vcp.h>
static const NotificationSequence sequence_pin_fail = {
&message_display_backlight_on,
&message_red_255,
&message_vibro_on,
&message_delay_100,
&message_vibro_off,
&message_red_0,
&message_delay_250,
&message_red_255,
&message_vibro_on,
&message_delay_100,
&message_vibro_off,
&message_red_0,
NULL,
};
static const uint8_t desktop_helpers_fails_timeout[] = {
0,
0,
0,
0,
30,
60,
90,
120,
150,
180,
/* +60 for every next fail */
};
void desktop_pin_lock_error_notify() {
NotificationApp* notification = furi_record_open(RECORD_NOTIFICATION);
notification_message(notification, &sequence_pin_fail);
furi_record_close(RECORD_NOTIFICATION);
}
uint32_t desktop_pin_lock_get_fail_timeout() {
uint32_t pin_fails = furi_hal_rtc_get_pin_fails();
uint32_t pin_timeout = 0;
uint32_t max_index = COUNT_OF(desktop_helpers_fails_timeout) - 1;
if(pin_fails <= max_index) {
pin_timeout = desktop_helpers_fails_timeout[pin_fails];
} else {
pin_timeout = desktop_helpers_fails_timeout[max_index] + (pin_fails - max_index) * 60;
}
return pin_timeout;
}
void desktop_pin_lock(DesktopSettings* settings) {
furi_assert(settings);
furi_hal_rtc_set_pin_fails(0);
furi_hal_rtc_set_flag(FuriHalRtcFlagLock);
Cli* cli = furi_record_open(RECORD_CLI);
cli_session_close(cli);
furi_record_close(RECORD_CLI);
settings->is_locked = 1;
DESKTOP_SETTINGS_SAVE(settings);
}
void desktop_pin_unlock(DesktopSettings* settings) {
furi_assert(settings);
furi_hal_rtc_reset_flag(FuriHalRtcFlagLock);
Cli* cli = furi_record_open(RECORD_CLI);
cli_session_open(cli, &cli_vcp);
furi_record_close(RECORD_CLI);
settings->is_locked = 0;
DESKTOP_SETTINGS_SAVE(settings);
}
void desktop_pin_lock_init(DesktopSettings* settings) {
furi_assert(settings);
if(settings->pin_code.length > 0) {
if(settings->is_locked == 1) {
furi_hal_rtc_set_flag(FuriHalRtcFlagLock);
} else {
if(desktop_pin_lock_is_locked()) {
settings->is_locked = 1;
DESKTOP_SETTINGS_SAVE(settings);
}
}
} else {
furi_hal_rtc_set_pin_fails(0);
furi_hal_rtc_reset_flag(FuriHalRtcFlagLock);
}
if(desktop_pin_lock_is_locked()) {
Cli* cli = furi_record_open(RECORD_CLI);
cli_session_close(cli);
furi_record_close(RECORD_CLI);
}
}
bool desktop_pin_lock_verify(const PinCode* pin_set, const PinCode* pin_entered) {
bool result = false;
if(desktop_pins_are_equal(pin_set, pin_entered)) {
furi_hal_rtc_set_pin_fails(0);
result = true;
} else {
uint32_t pin_fails = furi_hal_rtc_get_pin_fails();
furi_hal_rtc_set_pin_fails(pin_fails + 1);
result = false;
}
return result;
}
bool desktop_pin_lock_is_locked() {
return furi_hal_rtc_is_flag_set(FuriHalRtcFlagLock);
}
bool desktop_pins_are_equal(const PinCode* pin_code1, const PinCode* pin_code2) {
furi_assert(pin_code1);
furi_assert(pin_code2);
bool result = false;
if(pin_code1->length == pin_code2->length) {
result = !memcmp(pin_code1->data, pin_code2->data, pin_code1->length);
}
return result;
}

21
applications/services/desktop/helpers/pin_lock.h
View file

@ -1,21 +0,0 @@
#pragma once
#include <stdbool.h>
#include <stdint.h>
#include "../desktop.h"
#include <desktop/desktop_settings.h>
void desktop_pin_lock_error_notify();
uint32_t desktop_pin_lock_get_fail_timeout();
void desktop_pin_lock(DesktopSettings* settings);
void desktop_pin_unlock(DesktopSettings* settings);
bool desktop_pin_lock_is_locked();
void desktop_pin_lock_init(DesktopSettings* settings);
bool desktop_pin_lock_verify(const PinCode* pin_set, const PinCode* pin_entered);
bool desktop_pins_are_equal(const PinCode* pin_code1, const PinCode* pin_code2);

19
applications/services/desktop/scenes/desktop_scene_lock_menu.c
View file

@ -10,7 +10,7 @@
#include "../views/desktop_view_lock_menu.h"
#include "desktop_scene_i.h"
#include "desktop_scene.h"
#include "../helpers/pin_lock.h"
#include "../helpers/pin.h"
#define TAG "DesktopSceneLock"
@ -25,7 +25,6 @@ void desktop_scene_lock_menu_on_enter(void* context) {
DESKTOP_SETTINGS_LOAD(&desktop->settings);
scene_manager_set_scene_state(desktop->scene_manager, DesktopSceneLockMenu, 0);
desktop_lock_menu_set_callback(desktop->lock_menu, desktop_scene_lock_menu_callback, desktop);
desktop_lock_menu_set_pin_state(desktop->lock_menu, desktop->settings.pin_code.length > 0);
desktop_lock_menu_set_dummy_mode_state(desktop->lock_menu, desktop->settings.dummy_mode);
desktop_lock_menu_set_stealth_mode_state(
desktop->lock_menu, furi_hal_rtc_is_flag_set(FuriHalRtcFlagStealthMode));
@ -44,7 +43,6 @@ bool desktop_scene_lock_menu_on_event(void* context, SceneManagerEvent event) {
if(check_pin_changed) {
DESKTOP_SETTINGS_LOAD(&desktop->settings);
if(desktop->settings.pin_code.length > 0) {
desktop_lock_menu_set_pin_state(desktop->lock_menu, true);
scene_manager_set_scene_state(desktop->scene_manager, DesktopSceneLockMenu, 0);
}
}
@ -55,21 +53,6 @@ bool desktop_scene_lock_menu_on_event(void* context, SceneManagerEvent event) {
desktop_lock(desktop);
consumed = true;
break;
case DesktopLockMenuEventPinLock:
if(desktop->settings.pin_code.length > 0) {
desktop_pin_lock(&desktop->settings);
desktop_lock(desktop);
} else {
LoaderStatus status =
loader_start(desktop->loader, "Desktop", DESKTOP_SETTINGS_RUN_PIN_SETUP_ARG);
if(status == LoaderStatusOk) {
scene_manager_set_scene_state(desktop->scene_manager, DesktopSceneLockMenu, 1);
} else {
FURI_LOG_E(TAG, "Unable to start desktop settings");
}
}
consumed = true;
break;
case DesktopLockMenuEventDummyModeOn:
desktop_set_dummy_mode_state(desktop, true);
scene_manager_search_and_switch_to_previous_scene(

4
applications/services/desktop/scenes/desktop_scene_locked.c
View file

@ -7,7 +7,7 @@
#include "../desktop.h"
#include "../desktop_i.h"
#include "../helpers/pin_lock.h"
#include "../helpers/pin.h"
#include "../animations/animation_manager.h"
#include "../views/desktop_events.h"
#include "../views/desktop_view_pin_input.h"
@ -45,7 +45,7 @@ void desktop_scene_locked_on_enter(void* context) {
bool switch_to_timeout_scene = false;
uint32_t state = scene_manager_get_scene_state(desktop->scene_manager, DesktopSceneLocked);
if(state == SCENE_LOCKED_FIRST_ENTER) {
bool pin_locked = desktop_pin_lock_is_locked();
bool pin_locked = desktop->settings.pin_code.length > 0;
view_port_enabled_set(desktop->lock_icon_viewport, true);
Gui* gui = furi_record_open(RECORD_GUI);
gui_set_lockdown(gui, true);

9
applications/services/desktop/scenes/desktop_scene_main.c
View file

@ -108,13 +108,8 @@ bool desktop_scene_main_on_event(void* context, SceneManagerEvent event) {
break;
case DesktopMainEventLock:
if(desktop->settings.pin_code.length > 0) {
desktop_pin_lock(&desktop->settings);
desktop_lock(desktop);
} else {
scene_manager_set_scene_state(desktop->scene_manager, DesktopSceneLockMenu, 0);
desktop_lock(desktop);
}
scene_manager_set_scene_state(desktop->scene_manager, DesktopSceneLockMenu, 0);
desktop_lock(desktop);
consumed = true;
break;

8
applications/services/desktop/scenes/desktop_scene_pin_input.c
View file

@ -12,7 +12,7 @@
#include "../animations/animation_manager.h"
#include "../views/desktop_events.h"
#include "../views/desktop_view_pin_input.h"
#include "../helpers/pin_lock.h"
#include "../helpers/pin.h"
#include "desktop_scene.h"
#include "desktop_scene_i.h"
@ -54,9 +54,12 @@ static void desktop_scene_pin_input_back_callback(void* context) {
static void desktop_scene_pin_input_done_callback(const PinCode* pin_code, void* context) {
Desktop* desktop = (Desktop*)context;
if(desktop_pin_lock_verify(&desktop->settings.pin_code, pin_code)) {
if(desktop_pin_compare(&desktop->settings.pin_code, pin_code)) {
furi_hal_rtc_set_pin_fails(0);
view_dispatcher_send_custom_event(desktop->view_dispatcher, DesktopPinInputEventUnlocked);
} else {
uint32_t pin_fails = furi_hal_rtc_get_pin_fails();
furi_hal_rtc_set_pin_fails(pin_fails + 1);
view_dispatcher_send_custom_event(
desktop->view_dispatcher, DesktopPinInputEventUnlockFailed);
}
@ -126,7 +129,6 @@ bool desktop_scene_pin_input_on_event(void* context, SceneManagerEvent event) {
consumed = true;
break;
case DesktopPinInputEventUnlocked:
desktop_pin_unlock(&desktop->settings);
desktop_unlock(desktop);
consumed = true;
break;

1
applications/services/desktop/views/desktop_events.h
View file

@ -36,7 +36,6 @@ typedef enum {
DesktopDebugEventExit,
DesktopLockMenuEventLock,
DesktopLockMenuEventPinLock,
DesktopLockMenuEventDummyModeOn,
DesktopLockMenuEventDummyModeOff,
DesktopLockMenuEventStealthModeOn,

14
applications/services/desktop/views/desktop_view_lock_menu.c
View file

@ -23,14 +23,6 @@ void desktop_lock_menu_set_callback(
lock_menu->context = context;
}
void desktop_lock_menu_set_pin_state(DesktopLockMenuView* lock_menu, bool pin_is_set) {
with_view_model(
lock_menu->view,
DesktopLockMenuViewModel * model,
{ model->pin_is_set = pin_is_set; },
true);
}
void desktop_lock_menu_set_dummy_mode_state(DesktopLockMenuView* lock_menu, bool dummy_mode) {
with_view_model(
lock_menu->view,
@ -102,7 +94,6 @@ bool desktop_lock_menu_input_callback(InputEvent* event, void* context) {
bool consumed = false;
bool dummy_mode = false;
bool stealth_mode = false;
bool pin_is_set = false;
bool update = false;
with_view_model(
@ -131,15 +122,12 @@ bool desktop_lock_menu_input_callback(InputEvent* event, void* context) {
idx = model->idx;
dummy_mode = model->dummy_mode;
stealth_mode = model->stealth_mode;
pin_is_set = model->pin_is_set;
},
update);
if(event->key == InputKeyOk) {
if((idx == DesktopLockMenuIndexLock)) {
if((pin_is_set) && (event->type == InputTypeLong)) {
lock_menu->callback(DesktopLockMenuEventPinLock, lock_menu->context);
} else if(event->type == InputTypeShort) {
if(event->type == InputTypeShort) {
lock_menu->callback(DesktopLockMenuEventLock, lock_menu->context);
}
} else if(idx == DesktopLockMenuIndexStealth) {

2
applications/services/desktop/views/desktop_view_lock_menu.h
View file

@ -17,7 +17,6 @@ struct DesktopLockMenuView {
typedef struct {
uint8_t idx;
bool pin_is_set;
bool dummy_mode;
bool stealth_mode;
} DesktopLockMenuViewModel;
@ -28,7 +27,6 @@ void desktop_lock_menu_set_callback(
void* context);
View* desktop_lock_menu_get_view(DesktopLockMenuView* lock_menu);
void desktop_lock_menu_set_pin_state(DesktopLockMenuView* lock_menu, bool pin_is_set);
void desktop_lock_menu_set_dummy_mode_state(DesktopLockMenuView* lock_menu, bool dummy_mode);
void desktop_lock_menu_set_stealth_mode_state(DesktopLockMenuView* lock_menu, bool stealth_mode);
void desktop_lock_menu_set_idx(DesktopLockMenuView* lock_menu, uint8_t idx);

79
applications/services/desktop/views/desktop_view_pin_setup_done.c
View file

@ -1,79 +0,0 @@
#include <furi.h>
#include <furi_hal.h>
#include <gui/elements.h>
#include <gui/canvas.h>
#include <toolbox/version.h>
#include <assets_icons.h>
#include <dolphin/helpers/dolphin_state.h>
#include <dolphin/dolphin.h>
#include "../desktop_i.h"
#include "desktop_view_pin_setup_done.h"
struct DesktopViewPinSetupDone {
View* view;
DesktopViewPinSetupDoneDoneCallback callback;
void* context;
};
static void desktop_view_pin_done_draw(Canvas* canvas, void* model) {
furi_assert(canvas);
UNUSED(model);
canvas_set_font(canvas, FontPrimary);
elements_multiline_text_aligned(
canvas, 64, 0, AlignCenter, AlignTop, "Prepare to use\narrows as\nPIN symbols");
canvas_set_font(canvas, FontSecondary);
elements_multiline_text(canvas, 58, 24, "Prepare to use\narrows as\nPIN symbols");
canvas_draw_icon(canvas, 16, 18, &I_Pin_attention_dpad_29x29);
elements_button_right(canvas, "Next");
}
static bool desktop_view_pin_done_input(InputEvent* event, void* context) {
furi_assert(event);
furi_assert(context);
DesktopViewPinSetupDone* instance = context;
bool consumed = false;
if((event->key == InputKeyRight) && (event->type == InputTypeShort)) {
instance->callback(instance->context);
consumed = true;
}
return consumed;
}
void desktop_view_pin_done_set_callback(
DesktopViewPinSetupDone* instance,
DesktopViewPinSetupDoneDoneCallback callback,
void* context) {
furi_assert(instance);
furi_assert(callback);
instance->callback = callback;
instance->context = context;
}
DesktopViewPinSetupDone* desktop_view_pin_done_alloc() {
DesktopViewPinSetupDone* view = malloc(sizeof(DesktopViewPinSetupDone));
view->view = view_alloc();
view_set_context(view->view, view);
view_set_draw_callback(view->view, desktop_view_pin_done_draw);
view_set_input_callback(view->view, desktop_view_pin_done_input);
return view;
}
void desktop_view_pin_done_free(DesktopViewPinSetupDone* instance) {
furi_assert(instance);
view_free(instance->view);
free(instance);
}
View* desktop_view_pin_done_get_view(DesktopViewPinSetupDone* instance) {
furi_assert(instance);
return instance->view;
}

15
applications/services/desktop/views/desktop_view_pin_setup_done.h
View file

@ -1,15 +0,0 @@
#pragma once
#include <gui/view.h>
typedef struct DesktopViewPinSetupDone DesktopViewPinSetupDone;
typedef void (*DesktopViewPinSetupDoneDoneCallback)(void*);
void desktop_view_pin_done_set_callback(
DesktopViewPinSetupDone* instance,
DesktopViewPinSetupDoneDoneCallback callback,
void* context);
DesktopViewPinSetupDone* desktop_view_pin_done_alloc();
void desktop_view_pin_done_free(DesktopViewPinSetupDone* instance);
View* desktop_view_pin_done_get_view(DesktopViewPinSetupDone* instance);

4
applications/services/rpc/rpc.c
View file

@ -57,6 +57,10 @@ static RpcSystemCallbacks rpc_systems[] = {
.alloc = rpc_system_property_alloc,
.free = NULL,
},
{
.alloc = rpc_desktop_alloc,
.free = rpc_desktop_free,
},
};
struct RpcSession {

73
applications/services/rpc/rpc_desktop.c Normal file
View file

@ -0,0 +1,73 @@
#include "flipper.pb.h"
#include "rpc_i.h"
#include <desktop/desktop.h>
#include "desktop.pb.h"
#define TAG "RpcDesktop"
typedef struct {
RpcSession* session;
Desktop* desktop;
} RpcDesktop;
static void rpc_desktop_on_is_locked_request(const PB_Main* request, void* context) {
furi_assert(request);
furi_assert(context);
furi_assert(request->which_content == PB_Main_desktop_is_locked_request_tag);
FURI_LOG_D(TAG, "IsLockedRequest");
RpcDesktop* rpc_desktop = context;
RpcSession* session = rpc_desktop->session;
PB_CommandStatus ret = desktop_api_is_locked(rpc_desktop->desktop) ? PB_CommandStatus_OK :
PB_CommandStatus_ERROR;
rpc_send_and_release_empty(session, request->command_id, ret);
}
static void rpc_desktop_on_unlock_request(const PB_Main* request, void* context) {
furi_assert(request);
furi_assert(context);
furi_assert(request->which_content == PB_Main_desktop_unlock_request_tag);
FURI_LOG_D(TAG, "UnlockRequest");
RpcDesktop* rpc_desktop = context;
RpcSession* session = rpc_desktop->session;
desktop_api_unlock(rpc_desktop->desktop);
rpc_send_and_release_empty(session, request->command_id, PB_CommandStatus_OK);
}
void* rpc_desktop_alloc(RpcSession* session) {
furi_assert(session);
RpcDesktop* rpc_desktop = malloc(sizeof(RpcDesktop));
rpc_desktop->desktop = furi_record_open(RECORD_DESKTOP);
rpc_desktop->session = session;
RpcHandler rpc_handler = {
.message_handler = NULL,
.decode_submessage = NULL,
.context = rpc_desktop,
};
rpc_handler.message_handler = rpc_desktop_on_is_locked_request;
rpc_add_handler(session, PB_Main_desktop_is_locked_request_tag, &rpc_handler);
rpc_handler.message_handler = rpc_desktop_on_unlock_request;
rpc_add_handler(session, PB_Main_desktop_unlock_request_tag, &rpc_handler);
return rpc_desktop;
}
void rpc_desktop_free(void* context) {
furi_assert(context);
RpcDesktop* rpc_desktop = context;
furi_assert(rpc_desktop->desktop);
furi_record_close(RECORD_DESKTOP);
rpc_desktop->session = NULL;
free(rpc_desktop);
}

3
applications/services/rpc/rpc_i.h
View file

@ -36,6 +36,9 @@ void* rpc_system_gpio_alloc(RpcSession* session);
void rpc_system_gpio_free(void* ctx);
void* rpc_system_property_alloc(RpcSession* session);
void* rpc_desktop_alloc(RpcSession* session);
void rpc_desktop_free(void* ctx);
void rpc_debug_print_message(const PB_Main* message);
void rpc_debug_print_data(const char* prefix, uint8_t* buffer, size_t size);

4
applications/settings/desktop_settings/scenes/desktop_settings_scene_pin_auth.c
View file

@ -1,7 +1,7 @@
#include <stdint.h>
#include <core/check.h>
#include <gui/scene_manager.h>
#include <desktop/helpers/pin_lock.h>
#include <desktop/helpers/pin.h>
#include "../desktop_settings_app.h"
#include <desktop/desktop_settings.h>
#include <desktop/views/desktop_view_pin_input.h>
@ -18,7 +18,7 @@ static void pin_auth_done_callback(const PinCode* pin_code, void* context) {
DesktopSettingsApp* app = context;
app->pincode_buffer = *pin_code;
if(desktop_pins_are_equal(&app->settings.pin_code, pin_code)) {
if(desktop_pin_compare(&app->settings.pin_code, pin_code)) {
view_dispatcher_send_custom_event(app->view_dispatcher, SCENE_EVENT_PINS_EQUAL);
} else {
view_dispatcher_send_custom_event(app->view_dispatcher, SCENE_EVENT_PINS_DIFFERENT);

2
applications/settings/desktop_settings/scenes/desktop_settings_scene_pin_error.c
View file

@ -6,7 +6,7 @@
#include <desktop/views/desktop_view_pin_input.h>
#include "desktop_settings_scene.h"
#include "desktop_settings_scene_i.h"
#include <desktop/helpers/pin_lock.h>
#include <desktop/helpers/pin.h>
#include "../desktop_settings_app.h"
#define SCENE_EVENT_EXIT (0U)

4
applications/settings/desktop_settings/scenes/desktop_settings_scene_pin_setup.c
View file

@ -7,7 +7,7 @@
#include <desktop/views/desktop_view_pin_input.h>
#include "desktop_settings_scene.h"
#include "desktop_settings_scene_i.h"
#include <desktop/helpers/pin_lock.h>
#include <desktop/helpers/pin.h>
#define SCENE_EVENT_EXIT (0U)
#define SCENE_EVENT_1ST_PIN_ENTERED (1U)
@ -25,7 +25,7 @@ static void pin_setup_done_callback(const PinCode* pin_code, void* context) {
view_dispatcher_send_custom_event(app->view_dispatcher, SCENE_EVENT_1ST_PIN_ENTERED);
} else {
app->pincode_buffer_filled = false;
if(desktop_pins_are_equal(&app->pincode_buffer, pin_code)) {
if(desktop_pin_compare(&app->pincode_buffer, pin_code)) {
view_dispatcher_send_custom_event(app->view_dispatcher, SCENE_EVENT_PINS_EQUAL);
} else {
view_dispatcher_send_custom_event(app->view_dispatcher, SCENE_EVENT_PINS_DIFFERENT);

24
applications/settings/desktop_settings/scenes/desktop_settings_scene_start.c
View file

@ -10,8 +10,7 @@
#define SCENE_EVENT_SELECT_FAVORITE_TERTIARY 2
#define SCENE_EVENT_SELECT_PIN_SETUP 3
#define SCENE_EVENT_SELECT_AUTO_LOCK_DELAY 4
#define SCENE_EVENT_SELECT_AUTO_LOCK_PIN 5
#define SCENE_EVENT_SELECT_BATTERY_DISPLAY 6
#define SCENE_EVENT_SELECT_BATTERY_DISPLAY 5
#define AUTO_LOCK_DELAY_COUNT 9
const char* const auto_lock_delay_text[AUTO_LOCK_DELAY_COUNT] = {
@ -63,14 +62,6 @@ static void desktop_settings_scene_start_auto_lock_delay_changed(VariableItem* i
app->settings.auto_lock_delay_ms = auto_lock_delay_value[index];
}
static void desktop_settings_scene_start_auto_lock_pin_changed(VariableItem* item) {
DesktopSettingsApp* app = variable_item_get_context(item);
uint8_t value = variable_item_get_current_value_index(item);
variable_item_set_current_value_text(item, value ? "ON" : "OFF");
app->settings.auto_lock_with_pin = value;
}
void desktop_settings_scene_start_on_enter(void* context) {
DesktopSettingsApp* app = context;
VariableItemList* variable_item_list = app->variable_item_list;
@ -100,16 +91,6 @@ void desktop_settings_scene_start_on_enter(void* context) {
variable_item_set_current_value_index(item, value_index);
variable_item_set_current_value_text(item, auto_lock_delay_text[value_index]);
item = variable_item_list_add(
variable_item_list,
"Auto Lock Pin",
2,
desktop_settings_scene_start_auto_lock_pin_changed,
app);
variable_item_set_current_value_index(item, app->settings.auto_lock_with_pin);
variable_item_set_current_value_text(item, app->settings.auto_lock_with_pin ? "ON" : "OFF");
item = variable_item_list_add(
variable_item_list,
"Battery View",
@ -155,9 +136,6 @@ bool desktop_settings_scene_start_on_event(void* context, SceneManagerEvent even
case SCENE_EVENT_SELECT_AUTO_LOCK_DELAY:
consumed = true;
break;
case SCENE_EVENT_SELECT_AUTO_LOCK_PIN:
consumed = true;
break;
case SCENE_EVENT_SELECT_BATTERY_DISPLAY:
consumed = true;
break;

2
assets/protobuf

@ -1 +1 @@
Subproject commit 1f6b4a08c5d05c2b17926a3ba79f60109638932f
Subproject commit a13c5ddd0397511bd4c6de4afdd1031a5b6f5bca

15
firmware/targets/f7/ble_glue/ble_glue.c
View file

@ -2,6 +2,7 @@
#include "app_common.h"
#include "ble_app.h"
#include <ble/ble.h>
#include <hci_tl.h>
#include <interface/patterns/ble_thread/tl/tl.h>
#include <interface/patterns/ble_thread/shci/shci.h>
@ -72,6 +73,20 @@ void shci_register_io_bus(tSHciIO* fops) {
fops->Send = ble_glue_TL_SYS_SendCmd;
}
static int32_t ble_glue_TL_BLE_SendCmd(uint8_t* buffer, uint16_t size) {
if(furi_hal_bt_get_hardfault_info()) {
furi_crash("ST(R) Copro(R) HardFault");
}
return TL_BLE_SendCmd(buffer, size);
}
void hci_register_io_bus(tHciIO* fops) {
/* Register IO bus services */
fops->Init = TL_BLE_Init;
fops->Send = ble_glue_TL_BLE_SendCmd;
}
///////////////////////////////////////////////////////////////////////////////
void ble_glue_init() {

5
lib/stm32wb.scons
View file

@ -48,7 +48,10 @@ sources += Glob(
)
sources += Glob(
"stm32wb_copro/wpan/interface/patterns/ble_thread/tl/*_tl*.c",
exclude="stm32wb_copro/wpan/interface/patterns/ble_thread/tl/shci_tl_if.c",
exclude=[
"stm32wb_copro/wpan/interface/patterns/ble_thread/tl/hci_tl_if.c",
"stm32wb_copro/wpan/interface/patterns/ble_thread/tl/shci_tl_if.c",
],
source=True,
)
sources += [