2021-11-24 16:21:12 +00:00
|
|
|
#include "dolphin/dolphin.h"
|
|
|
|
#include "desktop/desktop.h"
|
|
|
|
#include "dolphin/helpers/dolphin_state.h"
|
2020-12-18 20:15:29 +00:00
|
|
|
#include "dolphin_i.h"
|
2021-11-24 16:21:12 +00:00
|
|
|
#include "furi/pubsub.h"
|
|
|
|
#include "sys/_stdint.h"
|
2021-09-28 09:40:39 +00:00
|
|
|
#include <furi.h>
|
2021-10-07 13:32:37 +00:00
|
|
|
#define DOLPHIN_TIMEGATE 86400 // one day
|
2021-09-30 19:50:58 +00:00
|
|
|
#define DOLPHIN_LOCK_EVENT_FLAG (0x1)
|
2021-03-25 17:48:58 +00:00
|
|
|
|
2021-09-28 09:40:39 +00:00
|
|
|
void dolphin_deed(Dolphin* dolphin, DolphinDeed deed) {
|
|
|
|
furi_assert(dolphin);
|
|
|
|
DolphinEvent event;
|
|
|
|
event.type = DolphinEventTypeDeed;
|
|
|
|
event.deed = deed;
|
2021-09-30 19:50:58 +00:00
|
|
|
dolphin_event_send_async(dolphin, &event);
|
2021-03-25 17:48:58 +00:00
|
|
|
}
|
|
|
|
|
2021-09-30 19:50:58 +00:00
|
|
|
DolphinStats dolphin_stats(Dolphin* dolphin) {
|
|
|
|
furi_assert(dolphin);
|
|
|
|
|
|
|
|
DolphinStats stats;
|
|
|
|
DolphinEvent event;
|
|
|
|
|
|
|
|
event.type = DolphinEventTypeStats;
|
|
|
|
event.stats = &stats;
|
|
|
|
|
|
|
|
dolphin_event_send_wait(dolphin, &event);
|
2021-05-05 09:50:03 +00:00
|
|
|
|
2021-09-28 09:40:39 +00:00
|
|
|
return stats;
|
2021-04-19 16:30:25 +00:00
|
|
|
}
|
|
|
|
|
2021-09-30 19:50:58 +00:00
|
|
|
void dolphin_flush(Dolphin* dolphin) {
|
|
|
|
furi_assert(dolphin);
|
|
|
|
|
|
|
|
DolphinEvent event;
|
|
|
|
event.type = DolphinEventTypeFlush;
|
|
|
|
|
|
|
|
dolphin_event_send_wait(dolphin, &event);
|
|
|
|
}
|
|
|
|
|
2020-12-18 20:15:29 +00:00
|
|
|
Dolphin* dolphin_alloc() {
|
|
|
|
Dolphin* dolphin = furi_alloc(sizeof(Dolphin));
|
2021-04-13 18:06:25 +00:00
|
|
|
|
2021-09-28 09:40:39 +00:00
|
|
|
dolphin->state = dolphin_state_alloc();
|
|
|
|
dolphin->event_queue = osMessageQueueNew(8, sizeof(DolphinEvent), NULL);
|
2021-11-24 16:21:12 +00:00
|
|
|
dolphin->pubsub = furi_pubsub_alloc();
|
2021-04-13 18:06:25 +00:00
|
|
|
|
2020-12-18 20:15:29 +00:00
|
|
|
return dolphin;
|
|
|
|
}
|
|
|
|
|
2021-04-13 18:06:25 +00:00
|
|
|
void dolphin_free(Dolphin* dolphin) {
|
|
|
|
furi_assert(dolphin);
|
|
|
|
|
|
|
|
dolphin_state_free(dolphin->state);
|
|
|
|
osMessageQueueDelete(dolphin->event_queue);
|
|
|
|
|
|
|
|
free(dolphin);
|
|
|
|
}
|
|
|
|
|
2021-09-30 19:50:58 +00:00
|
|
|
void dolphin_event_send_async(Dolphin* dolphin, DolphinEvent* event) {
|
|
|
|
furi_assert(dolphin);
|
|
|
|
furi_assert(event);
|
|
|
|
event->flag = NULL;
|
|
|
|
furi_check(osMessageQueuePut(dolphin->event_queue, event, 0, osWaitForever) == osOK);
|
|
|
|
}
|
|
|
|
|
|
|
|
void dolphin_event_send_wait(Dolphin* dolphin, DolphinEvent* event) {
|
|
|
|
furi_assert(dolphin);
|
|
|
|
furi_assert(event);
|
|
|
|
event->flag = osEventFlagsNew(NULL);
|
|
|
|
furi_check(event->flag);
|
|
|
|
furi_check(osMessageQueuePut(dolphin->event_queue, event, 0, osWaitForever) == osOK);
|
|
|
|
furi_check(
|
|
|
|
osEventFlagsWait(event->flag, DOLPHIN_LOCK_EVENT_FLAG, osFlagsWaitAny, osWaitForever) ==
|
|
|
|
DOLPHIN_LOCK_EVENT_FLAG);
|
|
|
|
furi_check(osEventFlagsDelete(event->flag) == osOK);
|
|
|
|
}
|
|
|
|
|
|
|
|
void dolphin_event_release(Dolphin* dolphin, DolphinEvent* event) {
|
|
|
|
if(event->flag) {
|
|
|
|
osEventFlagsSet(event->flag, DOLPHIN_LOCK_EVENT_FLAG);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2021-10-07 13:32:37 +00:00
|
|
|
static void dolphin_check_butthurt(DolphinState* state) {
|
|
|
|
furi_assert(state);
|
2021-11-24 16:21:12 +00:00
|
|
|
float diff_time = difftime(state->data.timestamp, dolphin_state_timestamp());
|
2021-10-07 13:32:37 +00:00
|
|
|
|
|
|
|
if((fabs(diff_time)) > DOLPHIN_TIMEGATE) {
|
|
|
|
dolphin_state_butthurted(state);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2021-11-24 16:21:12 +00:00
|
|
|
FuriPubSub* dolphin_get_pubsub(Dolphin* dolphin) {
|
|
|
|
return dolphin->pubsub;
|
|
|
|
}
|
|
|
|
|
2021-09-28 09:40:39 +00:00
|
|
|
int32_t dolphin_srv(void* p) {
|
2020-12-18 20:15:29 +00:00
|
|
|
Dolphin* dolphin = dolphin_alloc();
|
[FL-140] Core api dynamic records (#296)
* SYSTEM: tickless mode with deep sleep.
* Move FreeRTOS ticks to lptim2
* API: move all sumbodules init routines to one place. Timebase: working lptim2 at tick source.
* API Timebase: lp-timer routines, timer access safe zones prediction and synchronization. FreeRTOS: adjust configuration for tickless mode.
* NFC: support for tickless mode.
* API Timebase: improve tick error handling in IRQ. Apploader: use insomnia mode to run applications.
* BLE: prevent sleep while core2 starting
* HAL: nap while in insomnia mode
* init records work
* try to implement record delete
* tests and flapp
* flapp subsystem
* new core functions to get app stat, simplify core code
* fix thread termination
* add strdup to core
* fix tests
* Refactoring: remove all unusued parts, update API usage, aggreagate API sources and headers, new record storage
* Refactoring: update furi record api usage, cleanup code
* Fix broken merge for freertos apps
* Core, Target: fix compilation warnings
* Drop firmware target local
* HAL Timebase, Power, Clock: semaphore guarded access to clock and power modes, better sleep mode.
* SD-Filesystem: wait for all deps to arrive before adding widget. Core, BLE: disable debug dump to serial.
* delete old app example-ipc
* delete old app fatfs list
* fix strobe app, add input header
* delete old display driver
* comment old app qr-code
* fix sd-card test, add forced widget update
* remove unused new core test
* increase heap to 128k
* comment and assert old core tests
* fix syntax
Co-authored-by: Aleksandr Kutuzov <alleteam@gmail.com>
2021-01-20 16:09:26 +00:00
|
|
|
furi_record_create("dolphin", dolphin);
|
2020-12-18 20:15:29 +00:00
|
|
|
|
2021-09-30 19:50:58 +00:00
|
|
|
dolphin_state_load(dolphin->state);
|
|
|
|
|
2020-12-18 20:15:29 +00:00
|
|
|
DolphinEvent event;
|
|
|
|
while(1) {
|
2021-09-30 19:50:58 +00:00
|
|
|
if(osMessageQueueGet(dolphin->event_queue, &event, NULL, 60000) == osOK) {
|
|
|
|
if(event.type == DolphinEventTypeDeed) {
|
2021-11-24 16:21:12 +00:00
|
|
|
if(dolphin_state_on_deed(dolphin->state, event.deed)) {
|
|
|
|
DolphinPubsubEvent event = DolphinPubsubEventUpdate;
|
|
|
|
furi_pubsub_publish(dolphin->pubsub, &event);
|
|
|
|
}
|
2021-09-30 19:50:58 +00:00
|
|
|
} else if(event.type == DolphinEventTypeStats) {
|
2022-01-10 19:46:20 +00:00
|
|
|
// TODO: correct icounter/butthurt changing, stub till then
|
|
|
|
event.stats->icounter = 0;
|
|
|
|
event.stats->butthurt = 0;
|
2021-11-24 16:21:12 +00:00
|
|
|
event.stats->timestamp = dolphin->state->data.timestamp;
|
2022-01-10 19:46:20 +00:00
|
|
|
event.stats->level = 1;
|
|
|
|
event.stats->level_up_is_pending = 0;
|
2021-09-30 19:50:58 +00:00
|
|
|
} else if(event.type == DolphinEventTypeFlush) {
|
2022-01-10 19:46:20 +00:00
|
|
|
// TODO: correct icounter/butthurt changing, stub till then
|
|
|
|
dolphin->state->data.butthurt = 0;
|
|
|
|
dolphin->state->data.icounter = 0;
|
2021-09-30 19:50:58 +00:00
|
|
|
dolphin_state_save(dolphin->state);
|
|
|
|
}
|
|
|
|
dolphin_event_release(dolphin, &event);
|
|
|
|
} else {
|
2021-10-07 13:32:37 +00:00
|
|
|
dolphin_check_butthurt(dolphin->state);
|
2021-01-08 04:42:48 +00:00
|
|
|
dolphin_state_save(dolphin->state);
|
2020-12-18 20:15:29 +00:00
|
|
|
}
|
|
|
|
}
|
2021-09-28 09:40:39 +00:00
|
|
|
|
2021-04-13 18:06:25 +00:00
|
|
|
dolphin_free(dolphin);
|
2021-09-30 19:50:58 +00:00
|
|
|
|
2021-02-12 17:24:34 +00:00
|
|
|
return 0;
|
2020-12-18 20:15:29 +00:00
|
|
|
}
|
2021-11-24 16:21:12 +00:00
|
|
|
|
|
|
|
void dolphin_upgrade_level(Dolphin* dolphin) {
|
|
|
|
dolphin_state_increase_level(dolphin->state);
|
|
|
|
dolphin_flush(dolphin);
|
|
|
|
}
|