#include // FURI_LOG_DEV will log only during app development. Be sure that Settings/System/Log Device is "LPUART"; so we dont use serial port. #ifdef DEVELOPMENT #define FURI_LOG_DEV(tag, format, ...) furi_log_print_format(FuriLogLevelInfo, tag, format, ##__VA_ARGS__) #define DEV_CRASH() furi_crash() #else #define FURI_LOG_DEV(tag, format, ...) #define DEV_CRASH() #endif static bool flip_library_wiki_fetch(FactLoaderModel *model) { UNUSED(model); snprintf( fhttp.file_path, sizeof(fhttp.file_path), STORAGE_EXT_PATH_PREFIX "/apps_data/flip_library/wiki.json"); // encode spaces for url for (size_t i = 0; i < strlen(app_instance->uart_text_input_buffer_query); i++) { if (app_instance->uart_text_input_buffer_query[i] == ' ') { app_instance->uart_text_input_buffer_query[i] = '_'; } } char url[260]; snprintf(url, sizeof(url), "https://api.wikimedia.org/core/v1/wikipedia/en/search/title?q=%s&limit=1", app_instance->uart_text_input_buffer_query); Storage *storage = furi_record_open(RECORD_STORAGE); storage_simply_remove_recursive(storage, fhttp.file_path); fhttp.save_received_data = true; return flipper_http_get_request_with_headers(url, "{\"Content-Type\":\"application/json\"}"); } static char *flip_library_wiki_parse(FactLoaderModel *model) { UNUSED(model); FuriString *data = flipper_http_load_from_file(fhttp.file_path); if (data == NULL) { FURI_LOG_E(TAG, "Failed to load received data from file."); return "Failed to load received data from file."; } char *data_cstr = (char *)furi_string_get_cstr(data); if (data_cstr == NULL) { FURI_LOG_E(TAG, "Failed to get C-string from FuriString."); furi_string_free(data); return "Failed to get C-string from FuriString."; } char *pages = get_json_array_value("pages", 0, data_cstr, MAX_TOKENS); if (pages == NULL) { furi_string_free(data); return data_cstr; } char *description = get_json_value("description", pages, 64); if (description == NULL) { furi_string_free(data); return data_cstr; } return description; } static void flip_library_wiki_switch_to_view(FlipLibraryApp *app) { text_input_set_header_text(app->uart_text_input_query, "Search Wikipedia"); flip_library_generic_switch_to_view(app, "Searching..", flip_library_wiki_fetch, flip_library_wiki_parse, 1, callback_to_submenu_library, FlipLibraryViewTextInputQuery); } // static bool flip_library_random_fact_fetch(FactLoaderModel *model) { UNUSED(model); return flipper_http_get_request("https://uselessfacts.jsph.pl/api/v2/facts/random"); } static char *flip_library_random_fact_parse(FactLoaderModel *model) { UNUSED(model); return get_json_value("text", fhttp.last_response, 128); } static void flip_library_random_fact_switch_to_view(FlipLibraryApp *app) { flip_library_generic_switch_to_view(app, "Random Fact", flip_library_random_fact_fetch, flip_library_random_fact_parse, 1, callback_to_random_facts, FlipLibraryViewLoader); } // static bool flip_library_cat_fact_fetch(FactLoaderModel *model) { UNUSED(model); return flipper_http_get_request_with_headers("https://catfact.ninja/fact", "{\"Content-Type\":\"application/json\"}"); } static char *flip_library_cat_fact_parse(FactLoaderModel *model) { UNUSED(model); return get_json_value("fact", fhttp.last_response, 128); } static void flip_library_cat_fact_switch_to_view(FlipLibraryApp *app) { flip_library_generic_switch_to_view(app, "Random Cat Fact", flip_library_cat_fact_fetch, flip_library_cat_fact_parse, 1, callback_to_random_facts, FlipLibraryViewLoader); } // static bool flip_library_dog_fact_fetch(FactLoaderModel *model) { UNUSED(model); return flipper_http_get_request_with_headers("https://dog-api.kinduff.com/api/facts", "{\"Content-Type\":\"application/json\"}"); } static char *flip_library_dog_fact_parse(FactLoaderModel *model) { UNUSED(model); return get_json_array_value("facts", 0, fhttp.last_response, 256); } static void flip_library_dog_fact_switch_to_view(FlipLibraryApp *app) { flip_library_generic_switch_to_view(app, "Random Dog Fact", flip_library_dog_fact_fetch, flip_library_dog_fact_parse, 1, callback_to_random_facts, FlipLibraryViewLoader); } // static bool flip_library_quote_fetch(FactLoaderModel *model) { UNUSED(model); return flipper_http_get_request("https://zenquotes.io/api/random"); } static char *flip_library_quote_parse(FactLoaderModel *model) { UNUSED(model); // remove [ and ] from the start and end of the string char *response = fhttp.last_response; if (response[0] == '[') { response++; } if (response[strlen(response) - 1] == ']') { response[strlen(response) - 1] = '\0'; } // remove white space from both sides while (response[0] == ' ') { response++; } while (response[strlen(response) - 1] == ' ') { response[strlen(response) - 1] = '\0'; } return get_json_value("q", response, 128); } static void flip_library_quote_switch_to_view(FlipLibraryApp *app) { flip_library_generic_switch_to_view(app, "Random Quote", flip_library_quote_fetch, flip_library_quote_parse, 1, callback_to_random_facts, FlipLibraryViewLoader); } // static bool flip_library_dictionary_fetch(FactLoaderModel *model) { UNUSED(model); char payload[128]; snprintf(payload, sizeof(payload), "{\"word\":\"%s\"}", app_instance->uart_text_input_buffer_query); return flipper_http_post_request_with_headers("https://www.flipsocial.net/api/define/", "{\"Content-Type\":\"application/json\"}", payload); } static char *flip_library_dictionary_parse(FactLoaderModel *model) { UNUSED(model); char *defn = get_json_value("definition", fhttp.last_response, 16); if (defn == NULL) { defn = get_json_value("[ERROR]", fhttp.last_response, 16); } return defn; } static void flip_library_dictionary_switch_to_view(FlipLibraryApp *app) { text_input_set_header_text(app->uart_text_input_query, "Enter a word"); flip_library_generic_switch_to_view(app, "Defining", flip_library_dictionary_fetch, flip_library_dictionary_parse, 1, callback_to_submenu_library, FlipLibraryViewTextInputQuery); } // static bool flip_library_gps_fetch(FactLoaderModel *model) { UNUSED(model); if (fhttp.state == INACTIVE) { FURI_LOG_E(TAG, "Board is INACTIVE"); flipper_http_ping(); // ping the device fhttp.state = ISSUE; return false; } if (!flipper_http_get_request_with_headers("https://ipwhois.app/json/", "{\"Content-Type\": \"application/json\"}")) { FURI_LOG_E(TAG, "Failed to send GET request"); fhttp.state = ISSUE; return false; } fhttp.state = RECEIVING; return true; } static char *flip_library_gps_parse(FactLoaderModel *model) { UNUSED(model); char *total_data = NULL; if (fhttp.last_response != NULL) { char *city = get_json_value("city", fhttp.last_response, MAX_TOKENS); char *region = get_json_value("region", fhttp.last_response, MAX_TOKENS); char *country = get_json_value("country", fhttp.last_response, MAX_TOKENS); char *latitude = get_json_value("latitude", fhttp.last_response, MAX_TOKENS); char *longitude = get_json_value("longitude", fhttp.last_response, MAX_TOKENS); if (city == NULL || region == NULL || country == NULL || latitude == NULL || longitude == NULL) { FURI_LOG_E(TAG, "Failed to get geo location data"); fhttp.state = ISSUE; return NULL; } if (!total_data) { total_data = (char *)malloc(512); if (!total_data) { FURI_LOG_E(TAG, "Failed to allocate memory for total_data"); fhttp.state = ISSUE; return NULL; } } snprintf(total_data, 512, "You are in %s, %s, %s. \nLatitude: %s, Longitude: %s", city, region, country, latitude, longitude); fhttp.state = IDLE; free(city); free(region); free(country); free(latitude); free(longitude); } return total_data; } static void flip_library_gps_switch_to_view(FlipLibraryApp *app) { flip_library_generic_switch_to_view(app, "Fetching GPS data..", flip_library_gps_fetch, flip_library_gps_parse, 1, callback_to_submenu_library, FlipLibraryViewLoader); } // static bool flip_library_weather_fetch(FactLoaderModel *model) { if (model->request_index == 0) { fhttp.save_received_data = true; snprintf( fhttp.file_path, sizeof(fhttp.file_path), STORAGE_EXT_PATH_PREFIX "/apps_data/flip_library/gps.json"); return flip_library_gps_fetch(model); // fetch the Lat and Long } else if (model->request_index == 1) { FuriString *data = flipper_http_load_from_file(fhttp.file_path); if (data == NULL) { FURI_LOG_E(TAG, "Failed to load received data from file."); return false; } char *data_cstr = (char *)furi_string_get_cstr(data); if (data_cstr == NULL) { FURI_LOG_E(TAG, "Failed to get C-string from FuriString."); furi_string_free(data); return false; } char url[512]; char *latitude = get_json_value("latitude", data_cstr, MAX_TOKENS); char *longitude = get_json_value("longitude", data_cstr, MAX_TOKENS); if (latitude == NULL || longitude == NULL) { FURI_LOG_E(TAG, "Failed to get geo location data"); fhttp.state = ISSUE; return false; } snprintf(url, 512, "https://api.open-meteo.com/v1/forecast?latitude=%s&longitude=%s¤t=temperature_2m,precipitation,rain,showers,snowfall&temperature_unit=celsius&wind_speed_unit=mph&precipitation_unit=inch&forecast_days=1", latitude, longitude); if (!flipper_http_get_request_with_headers(url, "{\"Content-Type\": \"application/json\"}")) { FURI_LOG_E(TAG, "Failed to send GET request"); fhttp.state = ISSUE; return false; } fhttp.state = RECEIVING; return true; } return false; } static char *flip_library_weather_parse(FactLoaderModel *model) { if (model->request_index == 0) { return flip_library_gps_parse(model); // show the location } else if (model->request_index == 1) { UNUSED(model); char *weather_data = NULL; if (fhttp.last_response != NULL) { char *current_data = get_json_value("current", fhttp.last_response, MAX_TOKENS); char *temperature = get_json_value("temperature_2m", current_data, MAX_TOKENS); char *precipitation = get_json_value("precipitation", current_data, MAX_TOKENS); char *rain = get_json_value("rain", current_data, MAX_TOKENS); char *showers = get_json_value("showers", current_data, MAX_TOKENS); char *snowfall = get_json_value("snowfall", current_data, MAX_TOKENS); char *time = get_json_value("time", current_data, MAX_TOKENS); if (current_data == NULL || temperature == NULL || precipitation == NULL || rain == NULL || showers == NULL || snowfall == NULL || time == NULL) { FURI_LOG_E(TAG, "Failed to get weather data"); fhttp.state = ISSUE; return NULL; } // replace the "T" in time with a space char *ptr = strstr(time, "T"); if (ptr != NULL) { *ptr = ' '; } if (!weather_data) { weather_data = (char *)malloc(512); if (!weather_data) { FURI_LOG_E(TAG, "Failed to allocate memory for weather_data"); fhttp.state = ISSUE; return NULL; } } snprintf(weather_data, 512, "Temperature: %s C\nPrecipitation: %s\nRain: %s\nShowers: %s\nSnowfall: %s\nTime: %s", temperature, precipitation, rain, showers, snowfall, time); fhttp.state = IDLE; free(current_data); free(temperature); free(precipitation); free(rain); free(showers); free(snowfall); free(time); } return weather_data; } return NULL; } static void flip_library_weather_switch_to_view(FlipLibraryApp *app) { flip_library_generic_switch_to_view(app, "Fetching Weather data..", flip_library_weather_fetch, flip_library_weather_parse, 2, callback_to_submenu_library, FlipLibraryViewLoader); } // static bool flip_library_elevation_fetch(FactLoaderModel *model) { if (model->request_index == 0) { fhttp.save_received_data = true; snprintf( fhttp.file_path, sizeof(fhttp.file_path), STORAGE_EXT_PATH_PREFIX "/apps_data/flip_library/gps.json"); return flip_library_gps_fetch(model); // fetch the Lat and Long } else if (model->request_index == 1) { FuriString *data = flipper_http_load_from_file(fhttp.file_path); if (data == NULL) { FURI_LOG_E(TAG, "Failed to load received data from file."); return false; } char *data_cstr = (char *)furi_string_get_cstr(data); if (data_cstr == NULL) { FURI_LOG_E(TAG, "Failed to get C-string from FuriString."); furi_string_free(data); return false; } char url[256]; char *latitude = get_json_value("latitude", data_cstr, MAX_TOKENS); char *longitude = get_json_value("longitude", data_cstr, MAX_TOKENS); if (latitude == NULL || longitude == NULL) { FURI_LOG_E(TAG, "Failed to get geo location data"); fhttp.state = ISSUE; return false; } fhttp.save_received_data = true; snprintf( fhttp.file_path, sizeof(fhttp.file_path), STORAGE_EXT_PATH_PREFIX "/apps_data/flip_library/elevation.json"); snprintf(url, sizeof(url), "https://api.opentopodata.org/v1/aster30m?locations=%s,%s", latitude, longitude); if (!flipper_http_get_request_with_headers(url, "{\"Content-Type\": \"application/json\"}")) { FURI_LOG_E(TAG, "Failed to send GET request"); fhttp.state = ISSUE; return false; } fhttp.state = RECEIVING; return true; } return false; } static char *flip_library_elevation_parse(FactLoaderModel *model) { if (model->request_index == 0) { return flip_library_gps_parse(model); // show the location } else if (model->request_index == 1) { UNUSED(model); FuriString *data = flipper_http_load_from_file(fhttp.file_path); if (data == NULL) { FURI_LOG_E(TAG, "Failed to load received data from file."); return NULL; } char *elevation_data = NULL; char *results = get_json_array_value("results", 0, (char *)furi_string_get_cstr(data), 64); char *elevation = get_json_value("elevation", results, 16); if (elevation == NULL) { FURI_LOG_E(TAG, "Failed to get elevation data"); fhttp.state = ISSUE; return NULL; } elevation_data = (char *)malloc(64); if (!elevation_data) { FURI_LOG_E(TAG, "Failed to allocate memory for elevation_data"); fhttp.state = ISSUE; return NULL; } snprintf(elevation_data, 64, "Elevation: %s meters", elevation); fhttp.state = IDLE; free(elevation); return elevation_data; } return NULL; } static void flip_library_elevation_switch_to_view(FlipLibraryApp *app) { flip_library_generic_switch_to_view(app, "Fetching Elevation data..", flip_library_elevation_fetch, flip_library_elevation_parse, 2, callback_to_submenu_library, FlipLibraryViewLoader); } // static bool flip_library_asset_price_fetch(FactLoaderModel *model) { UNUSED(model); if (!app_instance->uart_text_input_buffer_query) { FURI_LOG_E(TAG, "Query is NULL"); fhttp.state = ISSUE; return false; } char url[128]; snprintf( fhttp.file_path, sizeof(fhttp.file_path), STORAGE_EXT_PATH_PREFIX "/apps_data/flip_library/price.txt"); // capitalize the query for (size_t i = 0; i < strlen(app_instance->uart_text_input_buffer_query); i++) { app_instance->uart_text_input_buffer_query[i] = toupper(app_instance->uart_text_input_buffer_query[i]); } fhttp.save_received_data = true; snprintf(url, 128, "https://www.alphavantage.co/query?function=GLOBAL_QUOTE&symbol=%s&apikey=2X90WLEFMP43OJKE", app_instance->uart_text_input_buffer_query); if (!flipper_http_get_request_with_headers(url, "{\"Content-Type\":\"application/json\"}")) { FURI_LOG_E(TAG, "Failed to send GET request"); fhttp.state = ISSUE; return false; } fhttp.state = RECEIVING; return true; } static char *flip_library_asset_price_parse(FactLoaderModel *model) { UNUSED(model); // load the received data from the saved file FuriString *price_data = flipper_http_load_from_file(fhttp.file_path); if (price_data == NULL) { FURI_LOG_E(TAG, "Failed to load received data from file."); fhttp.state = ISSUE; return NULL; } char *data_cstr = (char *)furi_string_get_cstr(price_data); if (data_cstr == NULL) { FURI_LOG_E(TAG, "Failed to get C-string from FuriString."); furi_string_free(price_data); fhttp.state = ISSUE; return NULL; } char *global_quote = get_json_value("Global Quote", data_cstr, MAX_TOKENS); if (global_quote == NULL) { FURI_LOG_E(TAG, "Failed to get Global Quote"); fhttp.state = ISSUE; furi_string_free(price_data); free(global_quote); free(data_cstr); return NULL; } char *price = get_json_value("05. price", global_quote, MAX_TOKENS); if (price == NULL) { FURI_LOG_E(TAG, "Failed to get price"); fhttp.state = ISSUE; furi_string_free(price_data); free(global_quote); free(price); free(data_cstr); return NULL; } char *asset_price = (char *)malloc(64); if (!asset_price) { FURI_LOG_E(TAG, "Failed to allocate memory for asset_price"); fhttp.state = ISSUE; furi_string_free(price_data); free(global_quote); free(price); free(data_cstr); return NULL; } snprintf(asset_price, 64, "%s: $%s", app_instance->uart_text_input_buffer_query, price); fhttp.state = IDLE; furi_string_free(price_data); free(global_quote); free(price); free(data_cstr); return asset_price; } static void flip_library_asset_price_switch_to_view(FlipLibraryApp *app) { text_input_set_header_text(app->uart_text_input_query, "Enter an asset"); flip_library_generic_switch_to_view(app, "Fetching Asset Price..", flip_library_asset_price_fetch, flip_library_asset_price_parse, 1, callback_to_submenu_library, FlipLibraryViewTextInputQuery); } // static bool flip_library_next_holiday_fetch(FactLoaderModel *model) { UNUSED(model); char url[128]; snprintf( fhttp.file_path, sizeof(fhttp.file_path), STORAGE_EXT_PATH_PREFIX "/apps_data/flip_library/holiday.json"); fhttp.save_received_data = true; snprintf(url, sizeof(url), "https://date.nager.at/api/v3/NextPublicHolidays/%s", app_instance->uart_text_input_buffer_query); return flipper_http_get_request_with_headers(url, "{\"Content-Type\":\"application/json\"}"); } static char *flip_library_next_holiday_parse(FactLoaderModel *model) { UNUSED(model); FuriString *holiday_data = flipper_http_load_from_file(fhttp.file_path); if (holiday_data == NULL) { FURI_LOG_E(TAG, "Failed to load received data from file."); return "Failed to load received data from file."; } furi_string_replace_at(holiday_data, 0, 0, "{\"holidays\": "); size_t term = furi_string_search_char(holiday_data, 0x0d, 0); if (term == FURI_STRING_FAILURE) { term = furi_string_size(holiday_data); } furi_string_replace_at(holiday_data, term, 0, "}"); char *holiday = get_json_array_value("holidays", 0, (char *)furi_string_get_cstr(holiday_data), 512); if (holiday == NULL) { furi_string_free(holiday_data); return NULL; } char *name = get_json_value("name", holiday, 32); char *date = get_json_value("date", holiday, 32); char *result = (char *)malloc(strlen(name) + strlen(date) + 3); if (result == NULL) { furi_string_free(holiday_data); free(name); free(date); return NULL; } snprintf(result, strlen(name) + strlen(date) + 3, "%s: %s", date, name); furi_string_free(holiday_data); free(name); free(date); return result; } static void flip_library_next_holiday_switch_to_view(FlipLibraryApp *app) { text_input_set_header_text(app->uart_text_input_query, "Enter a country code"); flip_library_generic_switch_to_view(app, "Fetching Next Holiday..", flip_library_next_holiday_fetch, flip_library_next_holiday_parse, 1, callback_to_submenu_library, FlipLibraryViewTextInputQuery); } // static bool flip_library_predict_age_fetch(FactLoaderModel *model) { UNUSED(model); char url[128]; snprintf(url, sizeof(url), "https://api.agify.io/?name=%s", app_instance->uart_text_input_buffer_query); return flipper_http_get_request_with_headers(url, "{\"Content-Type\":\"application/json\"}"); } static char *flip_library_predict_age_parse(FactLoaderModel *model) { UNUSED(model); if (fhttp.last_response == NULL) { return "Failed to get response"; } char *age = get_json_value("age", fhttp.last_response, 16); if (age == NULL) { age = get_json_value("[ERROR]", fhttp.last_response, 16); } return age; } static void flip_library_predict_age_switch_to_view(FlipLibraryApp *app) { text_input_set_header_text(app->uart_text_input_query, "Enter a name"); flip_library_generic_switch_to_view(app, "Predicting Age..", flip_library_predict_age_fetch, flip_library_predict_age_parse, 1, callback_to_submenu_predict, FlipLibraryViewTextInputQuery); } // static bool flip_library_predict_gender_fetch(FactLoaderModel *model) { UNUSED(model); char url[128]; snprintf(url, sizeof(url), "https://api.genderize.io/?name=%s", app_instance->uart_text_input_buffer_query); return flipper_http_get_request_with_headers(url, "{\"Content-Type\":\"application/json\"}"); } static char *flip_library_predict_gender_parse(FactLoaderModel *model) { UNUSED(model); if (fhttp.last_response == NULL) { return "Failed to get response"; } char *gender = get_json_value("gender", fhttp.last_response, 16); if (gender == NULL) { gender = get_json_value("[ERROR]", fhttp.last_response, 16); } return gender; } static void flip_library_predict_gender_switch_to_view(FlipLibraryApp *app) { text_input_set_header_text(app->uart_text_input_query, "Enter a name"); flip_library_generic_switch_to_view(app, "Predicing Gender..", flip_library_predict_gender_fetch, flip_library_predict_gender_parse, 1, callback_to_submenu_predict, FlipLibraryViewTextInputQuery); } // static bool flip_library_predict_ethnicity_fetch(FactLoaderModel *model) { UNUSED(model); char url[128]; snprintf(url, sizeof(url), "https://api.nationalize.io/?name=%s", app_instance->uart_text_input_buffer_query); return flipper_http_get_request_with_headers(url, "{\"Content-Type\":\"application/json\"}"); } static char *flip_library_predict_ethnicity_parse(FactLoaderModel *model) { UNUSED(model); if (fhttp.last_response == NULL) { return "Failed to get response"; } char *country = get_json_array_value("country", 0, fhttp.last_response, 64); if (country == NULL) { return get_json_value("[ERROR]", fhttp.last_response, 16); } return get_json_value("country_id", country, 16); } static void flip_library_predict_ethnicity_switch_to_view(FlipLibraryApp *app) { text_input_set_header_text(app->uart_text_input_query, "Enter a name"); flip_library_generic_switch_to_view(app, "Predicting Ethnicity..", flip_library_predict_ethnicity_fetch, flip_library_predict_ethnicity_parse, 1, callback_to_submenu_predict, FlipLibraryViewTextInputQuery); } // static bool flip_library_random_advice_fetch(FactLoaderModel *model) { UNUSED(model); return flipper_http_get_request("https://api.adviceslip.com/advice"); } static char *flip_library_random_advice_parse(FactLoaderModel *model) { UNUSED(model); char *slip = get_json_value("slip", fhttp.last_response, 32); if (!slip) { return "Failed to get response"; } return get_json_value("advice", slip, 32); } static void flip_library_random_advice_switch_to_view(FlipLibraryApp *app) { flip_library_generic_switch_to_view(app, "Random Advice", flip_library_random_advice_fetch, flip_library_random_advice_parse, 1, callback_to_random_facts, FlipLibraryViewLoader); } // static bool flip_library_random_trivia_fetch(FactLoaderModel *model) { UNUSED(model); return flipper_http_get_request_with_headers("https://opentdb.com/api.php?amount=1", "{\"Content-Type\":\"application/json\"}"); } static char *flip_library_random_trivia_parse(FactLoaderModel *model) { UNUSED(model); if (!fhttp.last_response) { return "Failed to get response"; } // replace the " with " char *ptr = fhttp.last_response; while ((ptr = strstr(ptr, """)) != NULL) { ptr[0] = '"'; ptr[1] = '"'; ptr[2] = '"'; ptr[3] = '"'; } // replace the ' with ' ptr = fhttp.last_response; while ((ptr = strstr(ptr, "'")) != NULL) { ptr[0] = '\''; ptr[1] = '\0'; } // replace the & with & ptr = fhttp.last_response; while ((ptr = strstr(ptr, "&")) != NULL) { ptr[0] = '&'; ptr[1] = '\0'; } char *results = get_json_array_value("results", 0, fhttp.last_response, 256); if (!results) { FURI_LOG_E(TAG, "Failed to get response"); FURI_LOG_E(TAG, fhttp.last_response); return "Failed to get response"; } char *question = get_json_value("question", results, 32); char *correct_answer = get_json_value("correct_answer", results, 32); if (!question || !correct_answer) { return "Failed to get response"; } char *result = (char *)malloc(strlen(question) + strlen(correct_answer) + 128); if (!result) { return "Failed to allocate memory"; } snprintf(result, strlen(question) + strlen(correct_answer) + 128, "Q: %s\n\n(Scroll down for the answer)\n\nA: %s", question, correct_answer); return result; } static void flip_library_random_trivia_switch_to_view(FlipLibraryApp *app) { flip_library_generic_switch_to_view(app, "Random Trivia", flip_library_random_trivia_fetch, flip_library_random_trivia_parse, 1, callback_to_random_facts, FlipLibraryViewLoader); } // static bool flip_library_random_tech_phrase_fetch(FactLoaderModel *model) { UNUSED(model); return flipper_http_get_request("https://techy-api.vercel.app/api/json"); } static char *flip_library_random_tech_phrase_parse(FactLoaderModel *model) { UNUSED(model); if (!fhttp.last_response) { return "Failed to get response"; } char *message = get_json_value("message", fhttp.last_response, 32); if (!message) { return "Failed to get response"; } return message; } static void flip_library_random_tech_phrase_switch_to_view(FlipLibraryApp *app) { flip_library_generic_switch_to_view(app, "Random Tech Phrase", flip_library_random_tech_phrase_fetch, flip_library_random_tech_phrase_parse, 1, callback_to_random_facts, FlipLibraryViewLoader); } // static bool flip_library_random_uuid_fetch(FactLoaderModel *model) { UNUSED(model); return flipper_http_get_request("https://www.uuidtools.com/api/generate/v4"); } static char *flip_library_random_uuid_parse(FactLoaderModel *model) { UNUSED(model); if (!fhttp.last_response) { return "Failed to get response"; } // remove [ and ] from the start and end of the string and " from the start and end of the uuid char *response = fhttp.last_response; if (response[0] == '[') { response++; } if (response[strlen(response) - 1] == ']') { response[strlen(response) - 1] = '\0'; } if (response[0] == '"') { response++; } if (response[strlen(response) - 1] == '"') { response[strlen(response) - 1] = '\0'; } return response; } static void flip_library_random_uuid_switch_to_view(FlipLibraryApp *app) { flip_library_generic_switch_to_view(app, "Random UUID", flip_library_random_uuid_fetch, flip_library_random_uuid_parse, 1, callback_to_random_facts, FlipLibraryViewLoader); } // static bool flip_library_random_address_fetch(FactLoaderModel *model) { UNUSED(model); return flipper_http_get_request("https://fakerapi.it/api/v2/addresses?_quantity=1"); } static char *flip_library_random_address_parse(FactLoaderModel *model) { UNUSED(model); if (fhttp.last_response == NULL) { return "Failed to get response"; } char *data = get_json_array_value("data", 0, fhttp.last_response, 128); if (!data) { return "Failed to get response"; } char *street = get_json_value("street", data, 32); char *city = get_json_value("city", data, 32); char *country = get_json_value("country", data, 32); char *zip = get_json_value("zipcode", data, 32); if (!street || !city || !country || !zip) { return "Failed to get response"; } char *result = (char *)malloc(strlen(street) + strlen(city) + strlen(country) + strlen(zip) + 128); if (!result) { return "Failed to allocate memory"; } snprintf(result, strlen(street) + strlen(city) + strlen(country) + strlen(zip) + 128, "Street: %s\nCity: %s\nCountry: %s\nZip: %s", street, city, country, zip); return result; } static void flip_library_random_address_switch_to_view(FlipLibraryApp *app) { flip_library_generic_switch_to_view(app, "Random Address", flip_library_random_address_fetch, flip_library_random_address_parse, 1, callback_to_random_facts, FlipLibraryViewLoader); } // static bool flip_library_random_credit_card_fetch(FactLoaderModel *model) { UNUSED(model); return flipper_http_get_request("https://fakerapi.it/api/v2/creditCards?_quantity=1"); } static char *flip_library_random_credit_card_parse(FactLoaderModel *model) { UNUSED(model); if (!fhttp.last_response) { return "Failed to get response"; } char *data = get_json_array_value("data", 0, fhttp.last_response, 128); if (!data) { return "Failed to get response"; } char *card_number = get_json_value("number", data, 32); char *card_name = get_json_value("owner", data, 32); char *card_expiration = get_json_value("expiration", data, 32); char *card_type = get_json_value("type", data, 32); if (!card_number || !card_name || !card_expiration || !card_type) { return "Failed to get response"; } char *result = (char *)malloc(strlen(card_number) + strlen(card_name) + strlen(card_expiration) + strlen(card_type) + 128); if (!result) { return "Failed to allocate memory"; } snprintf(result, strlen(card_number) + strlen(card_name) + strlen(card_expiration) + strlen(card_type) + 128, "Card Number: %s\nName: %s\nExpiration: %s\nType: %s", card_number, card_name, card_expiration, card_type); return result; } static void flip_library_random_credit_card_switch_to_view(FlipLibraryApp *app) { flip_library_generic_switch_to_view(app, "Random Credit Card", flip_library_random_credit_card_fetch, flip_library_random_credit_card_parse, 1, callback_to_random_facts, FlipLibraryViewLoader); } // static bool flip_library_random_user_info_fetch(FactLoaderModel *model) { UNUSED(model); return flipper_http_get_request("https://fakerapi.it/api/v2/users?_quantity=1&_gender=male"); } static char *flip_library_random_user_info_parse(FactLoaderModel *model) { UNUSED(model); if (!fhttp.last_response) { return "Failed to get response"; } char *data = get_json_array_value("data", 0, fhttp.last_response, 128); if (!data) { return "Failed to get response"; } char *firstname = get_json_value("firstname", data, 32); char *lastname = get_json_value("lastname", data, 32); char *email = get_json_value("email", data, 32); char *username = get_json_value("username", data, 32); char *password = get_json_value("password", data, 32); if (!firstname || !lastname || !email || !username || !password) { return "Failed to get response"; } char *result = (char *)malloc(strlen(firstname) + strlen(lastname) + strlen(email) + strlen(username) + strlen(password) + 128); if (!result) { return "Failed to allocate memory"; } snprintf(result, strlen(firstname) + strlen(lastname) + strlen(email) + strlen(username) + strlen(password) + 128, "First Name: %s\nLast Name: %s\nEmail: %s\nUsername: %s\nPassword: %s", firstname, lastname, email, username, password); return result; } static void flip_library_random_user_info_switch_to_view(FlipLibraryApp *app) { flip_library_generic_switch_to_view(app, "Random User Info", flip_library_random_user_info_fetch, flip_library_random_user_info_parse, 1, callback_to_random_facts, FlipLibraryViewLoader); } // static void flip_library_request_error_draw(Canvas *canvas) { if (canvas == NULL) { FURI_LOG_E(TAG, "flip_library_request_error_draw - canvas is NULL"); DEV_CRASH(); return; } if (fhttp.last_response != NULL) { if (strstr(fhttp.last_response, "[ERROR] Not connected to Wifi. Failed to reconnect.") != NULL) { canvas_clear(canvas); canvas_draw_str(canvas, 0, 10, "[ERROR] Not connected to Wifi."); canvas_draw_str(canvas, 0, 22, "Failed to reconnect."); canvas_draw_str(canvas, 0, 50, "Update your WiFi settings."); canvas_draw_str(canvas, 0, 60, "Press BACK to return."); } else if (strstr(fhttp.last_response, "[ERROR] Failed to connect to Wifi.") != NULL) { canvas_clear(canvas); canvas_draw_str(canvas, 0, 10, "[ERROR] Not connected to Wifi."); canvas_draw_str(canvas, 0, 50, "Update your WiFi settings."); canvas_draw_str(canvas, 0, 60, "Press BACK to return."); } else if (strstr(fhttp.last_response, "[PONG]") != NULL) { canvas_clear(canvas); canvas_draw_str(canvas, 0, 10, "[STATUS]Connecting to AP..."); } else { canvas_clear(canvas); FURI_LOG_E(TAG, "Received an error: %s", fhttp.last_response); canvas_draw_str(canvas, 0, 10, "[ERROR] Unusual error..."); canvas_draw_str(canvas, 0, 60, "Press BACK and retry."); } } else { canvas_clear(canvas); canvas_draw_str(canvas, 0, 10, "Failed to receive data."); canvas_draw_str(canvas, 0, 60, "Press BACK to return."); } } static void flip_library_widget_set_text(char *message, Widget **widget) { if (widget == NULL) { FURI_LOG_E(TAG, "flip_library_set_widget_text - widget is NULL"); DEV_CRASH(); return; } if (message == NULL) { FURI_LOG_E(TAG, "flip_library_set_widget_text - message is NULL"); DEV_CRASH(); return; } widget_reset(*widget); uint32_t message_length = strlen(message); // Length of the message uint32_t i = 0; // Index tracker uint32_t formatted_index = 0; // Tracker for where we are in the formatted message char *formatted_message; // Buffer to hold the final formatted message // Allocate buffer with double the message length plus one for safety if (!easy_flipper_set_buffer(&formatted_message, message_length * 2 + 1)) { return; } while (i < message_length) { uint32_t max_line_length = 31; // Maximum characters per line uint32_t remaining_length = message_length - i; // Remaining characters uint32_t line_length = (remaining_length < max_line_length) ? remaining_length : max_line_length; // Check for newline character within the current segment uint32_t newline_pos = i; bool found_newline = false; for (; newline_pos < i + line_length && newline_pos < message_length; newline_pos++) { if (message[newline_pos] == '\n') { found_newline = true; break; } } if (found_newline) { // If newline found, set line_length up to the newline line_length = newline_pos - i; } // Temporary buffer to hold the current line char line[32]; strncpy(line, message + i, line_length); line[line_length] = '\0'; // If newline was found, skip it for the next iteration if (found_newline) { i += line_length + 1; // +1 to skip the '\n' character } else { // Check if the line ends in the middle of a word and adjust accordingly if (line_length == max_line_length && message[i + line_length] != '\0' && message[i + line_length] != ' ') { // Find the last space within the current line to avoid breaking a word char *last_space = strrchr(line, ' '); if (last_space != NULL) { // Adjust the line_length to avoid cutting the word line_length = last_space - line; line[line_length] = '\0'; // Null-terminate at the space } } // Move the index forward by the determined line_length i += line_length; // Skip any spaces at the beginning of the next line while (i < message_length && message[i] == ' ') { i++; } } // Manually copy the fixed line into the formatted_message buffer for (uint32_t j = 0; j < line_length; j++) { formatted_message[formatted_index++] = line[j]; } // Add a newline character for line spacing formatted_message[formatted_index++] = '\n'; } // Null-terminate the formatted_message formatted_message[formatted_index] = '\0'; // Add the formatted message to the widget widget_add_text_scroll_element(*widget, 0, 0, 128, 64, formatted_message); } void flip_library_loader_draw_callback(Canvas *canvas, void *model) { if (!canvas || !model) { FURI_LOG_E(TAG, "flip_library_loader_draw_callback - canvas or model is NULL"); return; } SerialState http_state = fhttp.state; FactLoaderModel *fact_loader_model = (FactLoaderModel *)model; FactState fact_state = fact_loader_model->fact_state; char *title = fact_loader_model->title; canvas_set_font(canvas, FontSecondary); if (http_state == INACTIVE) { canvas_draw_str(canvas, 0, 7, "Wifi Dev Board disconnected."); canvas_draw_str(canvas, 0, 17, "Please connect to the board."); canvas_draw_str(canvas, 0, 32, "If your board is connected,"); canvas_draw_str(canvas, 0, 42, "make sure you have flashed"); canvas_draw_str(canvas, 0, 52, "your WiFi Devboard with the"); canvas_draw_str(canvas, 0, 62, "latest FlipperHTTP flash."); return; } if (fact_state == FactStateError || fact_state == FactStateParseError) { flip_library_request_error_draw(canvas); return; } canvas_draw_str(canvas, 0, 7, title); canvas_draw_str(canvas, 0, 15, "Loading..."); if (fact_state == FactStateInitial) { return; } if (http_state == SENDING) { canvas_draw_str(canvas, 0, 22, "Sending..."); return; } if (http_state == RECEIVING || fact_state == FactStateRequested) { canvas_draw_str(canvas, 0, 22, "Receiving..."); return; } if (http_state == IDLE && fact_state == FactStateReceived) { canvas_draw_str(canvas, 0, 22, "Processing..."); return; } if (http_state == IDLE && fact_state == FactStateParsed) { canvas_draw_str(canvas, 0, 22, "Processed..."); return; } } static void flip_library_loader_process_callback(void *context) { if (context == NULL) { FURI_LOG_E(TAG, "flip_library_loader_process_callback - context is NULL"); DEV_CRASH(); return; } FlipLibraryApp *app = (FlipLibraryApp *)context; View *view = app->view_loader; FactState current_fact_state; with_view_model(view, FactLoaderModel * model, { current_fact_state = model->fact_state; }, false); if (current_fact_state == FactStateInitial) { with_view_model( view, FactLoaderModel * model, { model->fact_state = FactStateRequested; FactLoaderFetch fetch = model->fetcher; if (fetch == NULL) { FURI_LOG_E(TAG, "Model doesn't have Fetch function assigned."); model->fact_state = FactStateError; return; } // Clear any previous responses strncpy(fhttp.last_response, "", 1); bool request_status = fetch(model); if (!request_status) { model->fact_state = FactStateError; } }, true); } else if (current_fact_state == FactStateRequested || current_fact_state == FactStateError) { if (fhttp.state == IDLE && fhttp.last_response != NULL) { if (strstr(fhttp.last_response, "[PONG]") != NULL) { FURI_LOG_DEV(TAG, "PONG received."); } else if (strncmp(fhttp.last_response, "[SUCCESS]", 9) == 0) { FURI_LOG_DEV(TAG, "SUCCESS received. %s", fhttp.last_response ? fhttp.last_response : "NULL"); } else if (strncmp(fhttp.last_response, "[ERROR]", 9) == 0) { FURI_LOG_DEV(TAG, "ERROR received. %s", fhttp.last_response ? fhttp.last_response : "NULL"); } else if (strlen(fhttp.last_response) == 0) { // Still waiting on response } else { with_view_model(view, FactLoaderModel * model, { model->fact_state = FactStateReceived; }, true); } } else if (fhttp.state == SENDING || fhttp.state == RECEIVING) { // continue waiting } else if (fhttp.state == INACTIVE) { // inactive. try again } else if (fhttp.state == ISSUE) { with_view_model(view, FactLoaderModel * model, { model->fact_state = FactStateError; }, true); } else { FURI_LOG_DEV(TAG, "Unexpected state: %d lastresp: %s", fhttp.state, fhttp.last_response ? fhttp.last_response : "NULL"); DEV_CRASH(); } } else if (current_fact_state == FactStateReceived) { with_view_model( view, FactLoaderModel * model, { char *fact_text; if (model->parser == NULL) { fact_text = NULL; FURI_LOG_DEV(TAG, "Parser is NULL"); DEV_CRASH(); } else { fact_text = model->parser(model); } FURI_LOG_DEV(TAG, "Parsed fact: %s\r\ntext: %s", fhttp.last_response ? fhttp.last_response : "NULL", fact_text ? fact_text : "NULL"); model->fact_text = fact_text; if (fact_text == NULL) { model->fact_state = FactStateParseError; } else { model->fact_state = FactStateParsed; } }, true); } else if (current_fact_state == FactStateParsed) { with_view_model( view, FactLoaderModel * model, { if (++model->request_index < model->request_count) { model->fact_state = FactStateInitial; } else { flip_library_widget_set_text(model->fact_text != NULL ? model->fact_text : "Empty result", &app_instance->widget_result); if (model->fact_text != NULL) { free(model->fact_text); model->fact_text = NULL; } view_set_previous_callback(widget_get_view(app_instance->widget_result), model->back_callback); view_dispatcher_switch_to_view(app_instance->view_dispatcher, FlipLibraryViewWidgetResult); } }, true); } } static void flip_library_loader_timer_callback(void *context) { if (context == NULL) { FURI_LOG_E(TAG, "flip_library_loader_timer_callback - context is NULL"); DEV_CRASH(); return; } FlipLibraryApp *app = (FlipLibraryApp *)context; view_dispatcher_send_custom_event(app->view_dispatcher, FlipLibraryCustomEventProcess); } static void flip_library_loader_on_enter(void *context) { if (context == NULL) { FURI_LOG_E(TAG, "flip_library_loader_on_enter - context is NULL"); DEV_CRASH(); return; } FlipLibraryApp *app = (FlipLibraryApp *)context; View *view = app->view_loader; with_view_model( view, FactLoaderModel * model, { view_set_previous_callback(view, model->back_callback); if (model->timer == NULL) { model->timer = furi_timer_alloc(flip_library_loader_timer_callback, FuriTimerTypePeriodic, app); } furi_timer_start(model->timer, 250); }, true); } static void flip_library_loader_on_exit(void *context) { if (context == NULL) { FURI_LOG_E(TAG, "flip_library_loader_on_exit - context is NULL"); DEV_CRASH(); return; } FlipLibraryApp *app = (FlipLibraryApp *)context; View *view = app->view_loader; with_view_model( view, FactLoaderModel * model, { if (model->timer) { furi_timer_stop(model->timer); } }, false); } void flip_library_loader_init(View *view) { if (view == NULL) { FURI_LOG_E(TAG, "flip_library_loader_init - view is NULL"); DEV_CRASH(); return; } view_allocate_model(view, ViewModelTypeLocking, sizeof(FactLoaderModel)); view_set_enter_callback(view, flip_library_loader_on_enter); view_set_exit_callback(view, flip_library_loader_on_exit); } void flip_library_loader_free_model(View *view) { if (view == NULL) { FURI_LOG_E(TAG, "flip_library_loader_free_model - view is NULL"); DEV_CRASH(); return; } with_view_model( view, FactLoaderModel * model, { if (model->timer) { furi_timer_free(model->timer); model->timer = NULL; } if (model->parser_context) { free(model->parser_context); model->parser_context = NULL; } }, false); } bool flip_library_custom_event_callback(void *context, uint32_t index) { if (context == NULL) { FURI_LOG_E(TAG, "flip_library_custom_event_callback - context is NULL"); DEV_CRASH(); return false; } switch (index) { case FlipLibraryCustomEventProcess: flip_library_loader_process_callback(context); return true; default: FURI_LOG_DEV(TAG, "flip_library_custom_event_callback. Unknown index: %ld", index); return false; } } void callback_submenu_choices(void *context, uint32_t index) { if (context == NULL) { FURI_LOG_E(TAG, "callback_submenu_choices - context is NULL"); DEV_CRASH(); return; } FlipLibraryApp *app = (FlipLibraryApp *)context; switch (index) { case FlipLibrarySubmenuIndexRandomFacts: view_dispatcher_switch_to_view(app->view_dispatcher, FlipLibraryViewRandomFacts); break; case FlipLibrarySubmenuIndexAbout: view_dispatcher_switch_to_view(app->view_dispatcher, FlipLibraryViewAbout); break; case FlipLibrarySubmenuIndexSettings: view_dispatcher_switch_to_view(app->view_dispatcher, FlipLibraryViewSettings); break; case FlipLibrarySubmenuIndexDictionary: flip_library_dictionary_switch_to_view(app); break; case FlipLibrarySubmenuIndexRandomFactsCats: flip_library_cat_fact_switch_to_view(app); break; case FlipLibrarySubmenuIndexRandomFactsDogs: flip_library_dog_fact_switch_to_view(app); break; case FlipLibrarySubmenuIndexRandomFactsQuotes: flip_library_quote_switch_to_view(app); break; case FlipLibrarySubmenuIndexRandomFactsAll: flip_library_random_fact_switch_to_view(app); break; case FlipLibrarySubmenuIndexRandomAdvice: flip_library_random_advice_switch_to_view(app); break; case FlipLibrarySubmenuIndexRandomTrivia: flip_library_random_trivia_switch_to_view(app); break; case FlipLibrarySubmenuIndexRandomTechPhrase: flip_library_random_tech_phrase_switch_to_view(app); break; case FlipLibrarySubmenuIndexRandomUUID: flip_library_random_uuid_switch_to_view(app); break; case FlipLibrarySubmenuIndexRandomAddress: flip_library_random_address_switch_to_view(app); break; case FlipLibrarySubmenuIndexRandomCreditCard: flip_library_random_credit_card_switch_to_view(app); break; case FlipLibrarySubmenuIndexRandomUserInfo: flip_library_random_user_info_switch_to_view(app); break; case FlipLibrarySubmenuIndexWiki: flip_library_wiki_switch_to_view(app); break; case FlipLibrarySubmenuIndexGPS: flip_library_gps_switch_to_view(app); break; case FlipLibrarySubmenuIndexWeather: flip_library_weather_switch_to_view(app); break; case FlipLibrarySubmenuIndexElevation: flip_library_elevation_switch_to_view(app); break; case FlipLibrarySubmenuIndexAssetPrice: flip_library_asset_price_switch_to_view(app); break; case FlipLibrarySubmenuIndexNextHoliday: flip_library_next_holiday_switch_to_view(app); break; case FlipLibrarySubmenuIndexPredict: // predict submenu view_dispatcher_switch_to_view(app->view_dispatcher, FlipLibraryViewPredict); break; case FlipLibrarySubmenuIndexPredictGender: flip_library_predict_gender_switch_to_view(app); break; case FlipLibrarySubmenuIndexPredictAge: flip_library_predict_age_switch_to_view(app); break; case FlipLibrarySubmenuIndexPredictEthnicity: flip_library_predict_ethnicity_switch_to_view(app); break; case FlipLibrarySubmenuIndexLibrary: view_dispatcher_switch_to_view(app->view_dispatcher, FlipLibraryViewSubmenuLibrary); break; default: break; } } void text_updated_ssid(void *context) { FlipLibraryApp *app = (FlipLibraryApp *)context; if (!app) { FURI_LOG_E(TAG, "text_updated_ssid - FlipLibraryApp is NULL"); DEV_CRASH(); return; } // store the entered text strncpy(app->uart_text_input_buffer_ssid, app->uart_text_input_temp_buffer_ssid, app->uart_text_input_buffer_size_ssid); // Ensure null-termination app->uart_text_input_buffer_ssid[app->uart_text_input_buffer_size_ssid - 1] = '\0'; // update the variable item text if (app->variable_item_ssid) { variable_item_set_current_value_text(app->variable_item_ssid, app->uart_text_input_buffer_ssid); } // save settings save_settings(app->uart_text_input_buffer_ssid, app->uart_text_input_buffer_password); // save wifi settings to devboard if (strlen(app->uart_text_input_buffer_ssid) > 0 && strlen(app->uart_text_input_buffer_password) > 0) { if (!flipper_http_save_wifi(app->uart_text_input_buffer_ssid, app->uart_text_input_buffer_password)) { FURI_LOG_E(TAG, "Failed to save wifi settings."); } } // switch to the settings view view_dispatcher_switch_to_view(app->view_dispatcher, FlipLibraryViewSettings); } void text_updated_password(void *context) { FlipLibraryApp *app = (FlipLibraryApp *)context; if (!app) { FURI_LOG_E(TAG, "text_updated_password - FlipLibraryApp is NULL"); DEV_CRASH(); return; } // store the entered text strncpy(app->uart_text_input_buffer_password, app->uart_text_input_temp_buffer_password, app->uart_text_input_buffer_size_password); // Ensure null-termination app->uart_text_input_buffer_password[app->uart_text_input_buffer_size_password - 1] = '\0'; // update the variable item text if (app->variable_item_password) { variable_item_set_current_value_text(app->variable_item_password, app->uart_text_input_buffer_password); } // save settings save_settings(app->uart_text_input_buffer_ssid, app->uart_text_input_buffer_password); // save wifi settings to devboard if (strlen(app->uart_text_input_buffer_ssid) > 0 && strlen(app->uart_text_input_buffer_password) > 0) { if (!flipper_http_save_wifi(app->uart_text_input_buffer_ssid, app->uart_text_input_buffer_password)) { FURI_LOG_E(TAG, "Failed to save wifi settings"); } } // switch to the settings view view_dispatcher_switch_to_view(app->view_dispatcher, FlipLibraryViewSettings); } void text_updated_query(void *context) { FlipLibraryApp *app = (FlipLibraryApp *)context; if (!app) { FURI_LOG_E(TAG, "text_updated_query - FlipLibraryApp is NULL"); DEV_CRASH(); return; } // store the entered text strncpy(app->uart_text_input_buffer_query, app->uart_text_input_temp_buffer_query, app->uart_text_input_buffer_size_query); // Ensure null-termination app->uart_text_input_buffer_query[app->uart_text_input_buffer_size_query - 1] = '\0'; // switch to the loader view view_dispatcher_switch_to_view(app->view_dispatcher, FlipLibraryViewLoader); } uint32_t callback_to_submenu(void *context) { UNUSED(context); return FlipLibraryViewSubmenuMain; } uint32_t callback_to_wifi_settings(void *context) { UNUSED(context); return FlipLibraryViewSettings; } uint32_t callback_to_random_facts(void *context) { UNUSED(context); return FlipLibraryViewRandomFacts; } uint32_t callback_to_submenu_library(void *context) { UNUSED(context); return FlipLibraryViewSubmenuLibrary; } void settings_item_selected(void *context, uint32_t index) { FlipLibraryApp *app = (FlipLibraryApp *)context; if (!app) { FURI_LOG_E(TAG, "settings_item_selected - FlipLibraryApp is NULL"); DEV_CRASH(); return; } switch (index) { case 0: // Input SSID view_dispatcher_switch_to_view(app->view_dispatcher, FlipLibraryViewTextInputSSID); break; case 1: // Input Password view_dispatcher_switch_to_view(app->view_dispatcher, FlipLibraryViewTextInputPassword); break; default: FURI_LOG_E(TAG, "Unknown configuration item index"); break; } } /** * @brief Navigation callback for exiting the application * @param context The context - unused * @return next view id (VIEW_NONE to exit the app) */ uint32_t callback_exit_app(void *context) { // Exit the application if (!context) { FURI_LOG_E(TAG, "callback_exit_app - Context is NULL"); return VIEW_NONE; } UNUSED(context); return VIEW_NONE; // Return VIEW_NONE to exit the app } uint32_t callback_to_submenu_predict(void *context) { UNUSED(context); return FlipLibraryViewPredict; } void flip_library_generic_switch_to_view(FlipLibraryApp *app, char *title, FactLoaderFetch fetcher, FactLoaderParser parser, size_t request_count, ViewNavigationCallback back, uint32_t view_id) { if (app == NULL) { FURI_LOG_E(TAG, "flip_library_generic_switch_to_view - app is NULL"); DEV_CRASH(); return; } View *view = app->view_loader; if (view == NULL) { FURI_LOG_E(TAG, "flip_library_generic_switch_to_view - view is NULL"); DEV_CRASH(); return; } with_view_model( view, FactLoaderModel * model, { model->title = title; model->fetcher = fetcher; model->parser = parser; model->request_index = 0; model->request_count = request_count; model->back_callback = back; model->fact_state = FactStateInitial; model->fact_text = NULL; }, true); view_dispatcher_switch_to_view(app->view_dispatcher, view_id); }