thread.h

Go to the documentation of this file.

 
#pragma once
 
#include "base.h"
#include "common_defines.h"
 
#include <stdint.h>
#include <stddef.h>
 
#ifdef __cplusplus
extern "C" {
#endif
 
typedef enum {
    FuriThreadStateStopped, 
    FuriThreadStateStopping, 
    FuriThreadStateStarting, 
    FuriThreadStateRunning, 
} FuriThreadState;
 
typedef enum {
    FuriThreadPriorityIdle = 0, 
    FuriThreadPriorityInit = 4, 
    FuriThreadPriorityLowest = 14, 
    FuriThreadPriorityLow = 15, 
    FuriThreadPriorityNormal = 16, 
    FuriThreadPriorityHigh = 17, 
    FuriThreadPriorityHighest = 18, 
    FuriThreadPriorityIsr =
        (FURI_CONFIG_THREAD_MAX_PRIORITIES - 1), 
} FuriThreadPriority;
 
typedef struct FuriThread FuriThread;
 
typedef struct FuriThreadList FuriThreadList;
 
typedef void* FuriThreadId;
 
typedef int32_t (*FuriThreadCallback)(void* context);
 
typedef void (*FuriThreadStdoutWriteCallback)(const char* data, size_t size, void* context);
 
typedef size_t (
    *FuriThreadStdinReadCallback)(char* buffer, size_t size, FuriWait timeout, void* context);
 
typedef void (*FuriThreadStateCallback)(FuriThread* thread, FuriThreadState state, void* context);
 
typedef bool (*FuriThreadSignalCallback)(uint32_t signal, void* arg, void* context);
 
FuriThread* furi_thread_alloc(void);
 
FuriThread* furi_thread_alloc_service(
    const char* name,
    uint32_t stack_size,
    FuriThreadCallback callback,
    void* context);
 
FuriThread* furi_thread_alloc_ex(
    const char* name,
    uint32_t stack_size,
    FuriThreadCallback callback,
    void* context);
 
void furi_thread_free(FuriThread* thread);
 
void furi_thread_set_name(FuriThread* thread, const char* name);
 
void furi_thread_set_appid(FuriThread* thread, const char* appid);
 
void furi_thread_set_stack_size(FuriThread* thread, size_t stack_size);
 
void furi_thread_set_callback(FuriThread* thread, FuriThreadCallback callback);
 
void furi_thread_set_context(FuriThread* thread, void* context);
 
void furi_thread_set_priority(FuriThread* thread, FuriThreadPriority priority);
 
FuriThreadPriority furi_thread_get_priority(FuriThread* thread);
 
void furi_thread_set_current_priority(FuriThreadPriority priority);
 
FuriThreadPriority furi_thread_get_current_priority(void);
 
void furi_thread_set_state_callback(FuriThread* thread, FuriThreadStateCallback callback);
 
void furi_thread_set_state_context(FuriThread* thread, void* context);
 
FuriThreadState furi_thread_get_state(FuriThread* thread);
 
void furi_thread_set_signal_callback(
    FuriThread* thread,
    FuriThreadSignalCallback callback,
    void* context);
 
FuriThreadSignalCallback furi_thread_get_signal_callback(const FuriThread* thread);
 
bool furi_thread_signal(const FuriThread* thread, uint32_t signal, void* arg);
 
void furi_thread_start(FuriThread* thread);
 
bool furi_thread_join(FuriThread* thread);
 
FuriThreadId furi_thread_get_id(FuriThread* thread);
 
void furi_thread_enable_heap_trace(FuriThread* thread);
 
void furi_thread_disable_heap_trace(FuriThread* thread);
 
size_t furi_thread_get_heap_size(FuriThread* thread);
 
int32_t furi_thread_get_return_code(FuriThread* thread);
 
FuriThreadId furi_thread_get_current_id(void);
 
FuriThread* furi_thread_get_current(void);
 
void furi_thread_yield(void);
 
uint32_t furi_thread_flags_set(FuriThreadId thread_id, uint32_t flags);
 
uint32_t furi_thread_flags_clear(uint32_t flags);
 
uint32_t furi_thread_flags_get(void);
 
uint32_t furi_thread_flags_wait(uint32_t flags, uint32_t options, uint32_t timeout);
 
bool furi_thread_enumerate(FuriThreadList* thread_list);
 
const char* furi_thread_get_name(FuriThreadId thread_id);
 
const char* furi_thread_get_appid(FuriThreadId thread_id);
 
uint32_t furi_thread_get_stack_space(FuriThreadId thread_id);
 
FuriThreadStdoutWriteCallback furi_thread_get_stdout_callback(void);
 
FuriThreadStdinReadCallback furi_thread_get_stdin_callback(void);
 
void furi_thread_set_stdout_callback(FuriThreadStdoutWriteCallback callback, void* context);
 
void furi_thread_set_stdin_callback(FuriThreadStdinReadCallback callback, void* context);
 
size_t furi_thread_stdout_write(const char* data, size_t size);
 
int32_t furi_thread_stdout_flush(void);
 
size_t furi_thread_stdin_read(char* buffer, size_t size, FuriWait timeout);
 
void furi_thread_stdin_unread(char* buffer, size_t size);
 
void furi_thread_suspend(FuriThreadId thread_id);
 
void furi_thread_resume(FuriThreadId thread_id);
 
bool furi_thread_is_suspended(FuriThreadId thread_id);
 
#ifdef __cplusplus
}
#endif