Momentum-Apps/flip_store/apps/flip_store_apps.c

#include <apps/flip_store_apps.h>

FlipStoreAppInfo* flip_catalog = NULL;

uint32_t app_selected_index = 0;
bool flip_store_sent_request = false;
bool flip_store_success = false;
bool flip_store_saved_data = false;
bool flip_store_saved_success = false;
uint32_t flip_store_category_index = 0;

// define the list of categories
char* categories[] = {
    "Bluetooth",
    "Games",
    "GPIO",
    "Infrared",
    "iButton",
    "Media",
    "NFC",
    "RFID",
    "Sub-GHz",
    "Tools",
    "USB",
};

FlipStoreAppInfo* flip_catalog_alloc() {
    FlipStoreAppInfo* app_catalog =
        (FlipStoreAppInfo*)malloc(MAX_APP_COUNT * sizeof(FlipStoreAppInfo));
    if(!app_catalog) {
        FURI_LOG_E(TAG, "Failed to allocate memory for flip_catalog.");
        return NULL;
    }
    for(int i = 0; i < MAX_APP_COUNT; i++) {
        app_catalog[i].app_name = (char*)malloc(MAX_APP_NAME_LENGTH * sizeof(char));
        if(!app_catalog[i].app_name) {
            FURI_LOG_E(TAG, "Failed to allocate memory for app_name.");
            return NULL;
        }
        app_catalog[i].app_id = (char*)malloc(MAX_APP_NAME_LENGTH * sizeof(char));
        if(!app_catalog[i].app_id) {
            FURI_LOG_E(TAG, "Failed to allocate memory for app_id.");
            return NULL;
        }
        app_catalog[i].app_build_id = (char*)malloc(MAX_ID_LENGTH * sizeof(char));
        if(!app_catalog[i].app_build_id) {
            FURI_LOG_E(TAG, "Failed to allocate memory for app_build_id.");
            return NULL;
        }
        app_catalog[i].app_version = (char*)malloc(MAX_APP_VERSION_LENGTH * sizeof(char));
        if(!app_catalog[i].app_version) {
            FURI_LOG_E(TAG, "Failed to allocate memory for app_version.");
            return NULL;
        }
        app_catalog[i].app_description = (char*)malloc(MAX_APP_DESCRIPTION_LENGTH * sizeof(char));
        if(!app_catalog[i].app_description) {
            FURI_LOG_E(TAG, "Failed to allocate memory for app_description.");
            return NULL;
        }
    }
    return app_catalog;
}
void flip_catalog_free() {
    if(!flip_catalog) {
        return;
    }
    for(int i = 0; i < MAX_APP_COUNT; i++) {
        if(flip_catalog[i].app_name) {
            free(flip_catalog[i].app_name);
        }
        if(flip_catalog[i].app_id) {
            free(flip_catalog[i].app_id);
        }
        if(flip_catalog[i].app_build_id) {
            free(flip_catalog[i].app_build_id);
        }
        if(flip_catalog[i].app_version) {
            free(flip_catalog[i].app_version);
        }
        if(flip_catalog[i].app_description) {
            free(flip_catalog[i].app_description);
        }
    }
}

bool flip_store_process_app_list() {
    // Initialize the flip_catalog
    flip_catalog = flip_catalog_alloc();
    if(!flip_catalog) {
        FURI_LOG_E(TAG, "Failed to allocate memory for flip_catalog.");
        return false;
    }

    FuriString* feed_data = flipper_http_load_from_file(fhttp.file_path);
    if(feed_data == NULL) {
        FURI_LOG_E(TAG, "Failed to load received data from file.");
        return false;
    }

    char* data_cstr = (char*)furi_string_get_cstr(feed_data);
    if(data_cstr == NULL) {
        FURI_LOG_E(TAG, "Failed to get C-string from FuriString.");
        furi_string_free(feed_data);
        return false;
    }

    // Parser state variables
    bool in_string = false;
    bool is_escaped = false;
    bool reading_key = false;
    bool reading_value = false;
    bool inside_app_object = false;
    bool found_name = false, found_id = false, found_build_id = false, found_version = false,
         found_description = false;
    char current_key[MAX_KEY_LENGTH] = {0};
    size_t key_index = 0;
    char current_value[MAX_VALUE_LENGTH] = {0};
    size_t value_index = 0;
    int app_count = 0;
    enum ObjectState object_state = OBJECT_EXPECT_KEY;
    enum {
        STATE_SEARCH_APPS_KEY,
        STATE_SEARCH_ARRAY_START,
        STATE_READ_ARRAY_ELEMENTS,
        STATE_DONE
    } state = STATE_SEARCH_APPS_KEY;

    // Iterate through the data
    for(size_t i = 0; data_cstr[i] != '\0' && state != STATE_DONE; ++i) {
        char c = data_cstr[i];

        if(is_escaped) {
            is_escaped = false;
            if(reading_key && key_index < MAX_KEY_LENGTH - 1) {
                current_key[key_index++] = c;
            } else if(reading_value && value_index < MAX_VALUE_LENGTH - 1) {
                current_value[value_index++] = c;
            }
            continue;
        }

        if(c == '\\') {
            is_escaped = true;
            continue;
        }

        if(c == '\"') {
            in_string = !in_string;
            if(in_string) {
                if(!reading_key && !reading_value) {
                    if(state == STATE_SEARCH_APPS_KEY || object_state == OBJECT_EXPECT_KEY) {
                        reading_key = true;
                        key_index = 0;
                        current_key[0] = '\0';
                    } else if(object_state == OBJECT_EXPECT_VALUE) {
                        reading_value = true;
                        value_index = 0;
                        current_value[0] = '\0';
                    }
                }
            } else {
                if(reading_key) {
                    reading_key = false;
                    current_key[key_index] = '\0';
                    if(state == STATE_SEARCH_APPS_KEY && strcmp(current_key, "apps") == 0) {
                        state = STATE_SEARCH_ARRAY_START;
                    } else if(inside_app_object) {
                        object_state = OBJECT_EXPECT_COLON;
                    }
                } else if(reading_value) {
                    reading_value = false;
                    current_value[value_index] = '\0';

                    if(inside_app_object) {
                        if(strcmp(current_key, "name") == 0) {
                            snprintf(
                                flip_catalog[app_count].app_name,
                                MAX_APP_NAME_LENGTH,
                                "%.31s",
                                current_value);
                            found_name = true;
                        } else if(strcmp(current_key, "id") == 0) {
                            snprintf(
                                flip_catalog[app_count].app_id,
                                MAX_ID_LENGTH,
                                "%.31s",
                                current_value);
                            found_id = true;
                        } else if(strcmp(current_key, "build_id") == 0) {
                            snprintf(
                                flip_catalog[app_count].app_build_id,
                                MAX_ID_LENGTH,
                                "%.31s",
                                current_value);
                            found_build_id = true;
                        } else if(strcmp(current_key, "version") == 0) {
                            snprintf(
                                flip_catalog[app_count].app_version,
                                MAX_APP_VERSION_LENGTH,
                                "%.3s",
                                current_value);
                            found_version = true;
                        } else if(strcmp(current_key, "description") == 0) {
                            snprintf(
                                flip_catalog[app_count].app_description,
                                MAX_APP_DESCRIPTION_LENGTH,
                                "%.99s",
                                current_value);
                            found_description = true;
                        }

                        if(found_name && found_id && found_build_id && found_version &&
                           found_description) {
                            app_count++;
                            if(app_count >= MAX_APP_COUNT) {
                                FURI_LOG_I(TAG, "Reached maximum app count.");
                                state = STATE_DONE;
                                break;
                            }

                            found_name = found_id = found_build_id = found_version =
                                found_description = false;
                        }

                        object_state = OBJECT_EXPECT_COMMA_OR_END;
                    }
                }
            }
            continue;
        }

        if(in_string) {
            if(reading_key && key_index < MAX_KEY_LENGTH - 1) {
                current_key[key_index++] = c;
            } else if(reading_value && value_index < MAX_VALUE_LENGTH - 1) {
                current_value[value_index++] = c;
            }
            continue;
        }

        if(state == STATE_SEARCH_ARRAY_START && c == '[') {
            state = STATE_READ_ARRAY_ELEMENTS;
            continue;
        }

        if(state == STATE_READ_ARRAY_ELEMENTS) {
            if(c == '{') {
                inside_app_object = true;
                object_state = OBJECT_EXPECT_KEY;
            } else if(c == '}') {
                inside_app_object = false;
            } else if(c == ':') {
                object_state = OBJECT_EXPECT_VALUE;
            } else if(c == ',') {
                object_state = OBJECT_EXPECT_KEY;
            } else if(c == ']') {
                state = STATE_DONE;
                break;
            }
        }
    }

    // Clean up
    furi_string_free(feed_data);
    free(data_cstr);
    return app_count > 0;
}

bool flip_store_get_fap_file(
    char* build_id,
    uint8_t target,
    uint16_t api_major,
    uint16_t api_minor) {
    char url[128];
    fhttp.save_received_data = false;
    fhttp.is_bytes_request = true;
    snprintf(
        url,
        sizeof(url),
        "https://catalog.flipperzero.one/api/v0/application/version/%s/build/compatible?target=f%d&api=%d.%d",
        build_id,
        target,
        api_major,
        api_minor);
    char* headers = jsmn("Content-Type", "application/octet-stream");
    bool sent_request = flipper_http_get_request_bytes(url, headers);
    free(headers);
    return sent_request;
}

// function to handle the entire installation process "asynchronously"
bool flip_store_install_app(Canvas* canvas, char* category) {
    // create /apps/FlipStore directory if it doesn't exist
    char directory_path[128];
    snprintf(directory_path, sizeof(directory_path), STORAGE_EXT_PATH_PREFIX "/apps/%s", category);

    // Create the directory
    Storage* storage = furi_record_open(RECORD_STORAGE);
    storage_common_mkdir(storage, directory_path);

    // Adjusted to access flip_catalog as an array of structures
    char installation_text[64];
    snprintf(
        installation_text,
        sizeof(installation_text),
        "Installing %s",
        flip_catalog[app_selected_index].app_name);
    snprintf(
        fhttp.file_path,
        sizeof(fhttp.file_path),
        STORAGE_EXT_PATH_PREFIX "/apps/%s/%s.fap",
        category,
        flip_catalog[app_selected_index].app_id);
    canvas_draw_str(canvas, 0, 10, installation_text);
    canvas_draw_str(canvas, 0, 20, "Sending request..");
    uint8_t target = furi_hal_version_get_hw_target();
    uint16_t api_major, api_minor;
    furi_hal_info_get_api_version(&api_major, &api_minor);
    if(fhttp.state != INACTIVE &&
       flip_store_get_fap_file(
           flip_catalog[app_selected_index].app_build_id, target, api_major, api_minor)) {
        canvas_draw_str(canvas, 0, 30, "Request sent.");
        fhttp.state = RECEIVING;
        canvas_draw_str(canvas, 0, 40, "Receiving...");
    } else {
        FURI_LOG_E(TAG, "Failed to send the request");
        flip_store_success = false;
        return false;
    }
    while(fhttp.state == RECEIVING && furi_timer_is_running(fhttp.get_timeout_timer) > 0) {
        // Wait for the feed to be received
        furi_delay_ms(10);
    }
    // furi_timer_stop(fhttp.get_timeout_timer);
    if(fhttp.state == ISSUE) {
        flip_store_request_error(canvas);
        flip_store_success = false;
        return false;
    }
    flip_store_success = true;
    return true;
}

// process the app list and return view
int32_t flip_store_handle_app_list(
    FlipStoreApp* app,
    int32_t success_view,
    char* category,
    Submenu** submenu) {
    // reset the flip_catalog
    flip_catalog_free();

    if(!app) {
        FURI_LOG_E(TAG, "FlipStoreApp is NULL");
        return FlipStoreViewPopup;
    }
    snprintf(
        fhttp.file_path,
        sizeof(fhttp.file_path),
        STORAGE_EXT_PATH_PREFIX "/apps_data/flip_store/%s.json",
        category);

    fhttp.save_received_data = true;
    fhttp.is_bytes_request = false;
    char url[128];
    snprintf(url, sizeof(url), "https://www.flipsocial.net/api/flipper/apps/%s/max/", category);
    // async call to the app list with timer
    if(fhttp.state != INACTIVE &&
       flipper_http_get_request_with_headers(url, "{\"Content-Type\":\"application/json\"}")) {
        furi_timer_start(fhttp.get_timeout_timer, TIMEOUT_DURATION_TICKS);
        fhttp.state = RECEIVING;
    } else {
        FURI_LOG_E(TAG, "Failed to send the request");
        fhttp.state = ISSUE;
        return FlipStoreViewPopup;
    }
    while(fhttp.state == RECEIVING && furi_timer_is_running(fhttp.get_timeout_timer) > 0) {
        // Wait for the feed to be received
        furi_delay_ms(10);
    }
    furi_timer_stop(fhttp.get_timeout_timer);
    if(fhttp.state == ISSUE) {
        FURI_LOG_E(TAG, "Failed to receive data");
        if(fhttp.last_response == NULL) {
            if(fhttp.last_response != NULL) {
                if(strstr(
                       fhttp.last_response,
                       "[ERROR] Not connected to Wifi. Failed to reconnect.") != NULL) {
                    popup_set_text(
                        app->popup,
                        "[ERROR] WiFi Disconnected.\n\n\nUpdate your WiFi settings.\nPress BACK to return.",
                        0,
                        10,
                        AlignLeft,
                        AlignTop);
                } else if(strstr(fhttp.last_response, "[ERROR] Failed to connect to Wifi.") != NULL) {
                    popup_set_text(
                        app->popup,
                        "[ERROR] WiFi Disconnected.\n\n\nUpdate your WiFi settings.\nPress BACK to return.",
                        0,
                        10,
                        AlignLeft,
                        AlignTop);
                } else {
                    popup_set_text(app->popup, fhttp.last_response, 0, 50, AlignLeft, AlignTop);
                }
            } else {
                popup_set_text(
                    app->popup,
                    "[ERROR] Unknown Error.\n\n\nUpdate your WiFi settings.\nPress BACK to return.",
                    0,
                    10,
                    AlignLeft,
                    AlignTop);
            }
            return FlipStoreViewPopup;
        } else {
            popup_set_text(app->popup, "Failed to received data.", 0, 50, AlignLeft, AlignTop);
            return FlipStoreViewPopup;
        }
    } else {
        // process the app list
        if(flip_store_process_app_list() && submenu && flip_catalog) {
            submenu_reset(*submenu);
            // add each app name to submenu
            for(int i = 0; i < MAX_APP_COUNT; i++) {
                if(strlen(flip_catalog[i].app_name) > 0) {
                    submenu_add_item(
                        *submenu,
                        flip_catalog[i].app_name,
                        FlipStoreSubmenuIndexStartAppList + i,
                        callback_submenu_choices,
                        app);
                } else {
                    break;
                }
            }
            return success_view;
        } else {
            FURI_LOG_E(TAG, "Failed to process the app list");
            popup_set_text(
                app->popup, "Failed to process the app list", 0, 10, AlignLeft, AlignTop);
            return FlipStoreViewPopup;
        }
    }
}