/* * This setup always forces the flipper to the follower/slave role in the link. * This just makes our logic consistent and since we're going to be gobs faster * than a real Game Boy, we can be guaranteed to always be ready to respond. * * As documented here: http://www.adanscotney.com/2014/01/spoofing-pokemon-trades-with-stellaris.html * The general gist of the communication is as follows: * 1) Each Game Boy tries to listen for an external clock coming in on the link cable. * After some unknown timeout, this Game Boy decides its going to take the leader/master role. * In this state, it generates a clock and repeatedly sends out PKMN_MASTER(0x01) * 2) The other side, sensing a clock from the leader/master, then responds with PKMN_SLAVE(0x02) * 3) Once both sides understand their roles, they both respond with PKMN_BLANK(0x00) for a bit. * 4) Next, the leader/master sends CONNECTED(0x60) bytes that the follower/slave repeats * back. Then a bunch of BLANK bytes. * 5) At this point, each Game Boy repeatedly sends the menu item it has highlighted, * prepended by a BLANK, in groups of 3 bytes. These are ITEM_*_HIGHLIGHTED. * 6) Then, once both sides send ITEM_*_SELECTED, the next step occurs. * This application, from steps 3 through 6, just repeats bytes back and lets the Game Boy * dictate the steps. We stay here until we start seeing PREAMBLE(0xFD) bytes, * as those dictate the start of the next sections. * * The Flipper is now in the "READY" state. * * 7) Once the player on the Game Boy side uses the trade table, a block of data is * transmitted. This starts with 10x PREAMBLE(0xFD) bytes, 10x random bytes (to * sync the RNG between two devices, unused at this time), and then the 415 trade_block, * struct gets transferred. At the end of this is 3 ending bytes, DF FE 15. And, weirdly, * 3 PREAMBLE(0xFD) bytes. * 8) The patch list starts with 3x more PREAMBLE(0xFD) bytes for a total of 6x PREAMBLE, * followed by 7x BLANK bytes. Then remaining 189 bytes of patch list data. The patch * list is used to compensate for byte values of NO_DATA_BYE(0xFE) being transmitted. * The patch list is specifically for the party data of the trade_block. To patch * outgoing data, if a byte is 0xFE, it is changed to 0xFF, and the index+1 is * added to the patch list. There are two parts to the patch list as the data it * covers is longer than 0xFC. After each part is complete, 0xFF is added to the * patch list. The first part of the patch list can patch 0x00:0xFB of the party, * the second part can patch 0xFC:0x107 of the party. If there are no bytes to * patch in a part, 0xFF is just appended. After both terminators, it is expected * all remaining bytes are 0x00. * * The Flipper is now in the "WAITING" state. * * 9) At this point, both sides have full copies of each other's current party. The sides * simply indicate which Pokemon they are sending. This is done with a BLANK byte to * start, and then each side indicates which Pokemon it wants to trade with SEL_NUM_MASK(0x60) * + party index. We always transmit the first Pokemon. Once in a agreement, both * sides transmit a handful of BLANK bytes. * * The Flipper is now in the "DEAL?" state. * * A) Starting with another BLANK byte, both sides need to agree to the trade by * sending TRADE_ACCEPT(0x62) repeatedly, and then a handful of BLANK bytes. * To disagree with a trade, either side would send TRADE_REJECT(0x61), the * Flipper will never send this on its own. If the Game Boy does, both it and * the flipper got back to step 9 again. * * The Flipper is now in the "TRADING" state. * * B) The Flipper actually goes back to step 7, but keeps the drawing mode as * TRADING. After the trade is complete on the Game Boy, it re-sends the * trade_block data. This re-syncs the states between the Flipper and * Game Boy and another trade can occur. * * *) A point of note is that the Flipper can go back to the main menu from * any state. Though, doing so in the TRADING state might actually cause * the Game Boy to have issues. When in READY or WAITING state, the Flipper * can go back and modify the Pokemon that the Game Boy sent to it. If the * Flipper then goes back to Trade from the main menu, it will be in the * READY state. If the Game Boy is still on the trade menu, and it tries * to trade, the trade will be rejected. The Game Boy needs to exit the * trade menu, and then re-enter it by selecting the table in the trade * center. This will then push the Flipper to the WAITING state, and the * trade_blocks will re-sync between them with the new data. If the Game Boy * leave the trade menu while the Flipper is in the WAITING state, the * Flipper will go back to the READY state. * * TODO: Set up requiring a long back press to go back to the main menu * from the TRADING state or from the main menu to exit the application. */ #include #include #include #include #include #include "../pokemon_app.h" #include "trade_patch_list.h" #define DELAY_MICROSECONDS 15 #define PKMN_BLANK 0x00 #define ITEM_1_HIGHLIGHTED 0xD0 #define ITEM_2_HIGHLIGHTED 0xD1 #define ITEM_3_HIGHLIGHTED 0xD2 #define ITEM_1_SELECTED 0xD4 #define ITEM_2_SELECTED 0xD5 #define ITEM_3_SELECTED 0xD6 #define SERIAL_PREAMBLE_BYTE 0xFD #define SERIAL_PREAMBLE_LENGTH 6 #define SERIAL_RN_PREAMBLE_LENGTH 7 #define SERIAL_TRADE_PREAMBLE_LENGTH 9 #define SERIAL_RNS_LENGTH 10 #define SERIAL_PATCH_LIST_PART_TERMINATOR 0xFF #define SERIAL_NO_DATA_BYTE 0xFE #define PKMN_MASTER 0x01 #define PKMN_SLAVE 0x02 #define PKMN_CONNECTED 0x60 #define PKMN_TRADE_ACCEPT 0x62 #define PKMN_TRADE_REJECT 0x61 #define PKMN_TABLE_LEAVE 0x6f #define PKMN_SEL_NUM_MASK 0x60 #define PKMN_SEL_NUM_ONE 0x60 #define PKMN_ACTION 0x60 #define PKMN_TRADE_CENTRE ITEM_1_SELECTED #define PKMN_COLOSSEUM ITEM_2_SELECTED #define PKMN_BREAK_LINK ITEM_3_SELECTED /* States specific to the trade process. */ typedef enum { TRADE_RESET, TRADE_INIT, TRADE_RANDOM, TRADE_DATA, TRADE_PATCH_HEADER, TRADE_PATCH_DATA, TRADE_SELECT, TRADE_PENDING, TRADE_CONFIRMATION, TRADE_DONE } trade_centre_state_t; /* Global states for the trade logic. These are used to dictate what gets drawn * to the screen but also handle a few sync states. The CONN states are to denote * if a link has been established or note. READY through TRADING are all specific * screens to draw in the trade center. COLOSSEUM causes a data loopback so the * player can fight themselves. */ typedef enum { GAMEBOY_CONN_FALSE, GAMEBOY_CONN_TRUE, GAMEBOY_READY, GAMEBOY_WAITING, GAMEBOY_TRADE_PENDING, GAMEBOY_TRADING, GAMEBOY_COLOSSEUM } render_gameboy_state_t; /* Anonymous struct */ struct trade_ctx { trade_centre_state_t trade_centre_state; FuriTimer* draw_timer; View* view; uint8_t in_data; uint8_t out_data; uint8_t shift; TradeBlock* trade_block; TradeBlock* input_block; const PokemonTable* pokemon_table; struct patch_list* patch_list; void* gblink_handle; struct gblink_pins* gblink_pins; }; /* These are the needed variables for the draw callback */ struct trade_model { render_gameboy_state_t gameboy_status; bool ledon; // Controls the blue LED during trade uint8_t curr_pokemon; const PokemonTable* pokemon_table; }; /* A callback function that must be called outside of an interrupt context, * This will completely destroy the current patch list, and then rebuild it from * the current trade_block state. This is used mostly after a trade to rebuild * the list with the new data we just copied in. */ static void pokemon_plist_recreate_callback(void* context, uint32_t arg) { furi_assert(context); UNUSED(arg); struct trade_ctx* trade = context; plist_create(&(trade->patch_list), trade->trade_block); } /* Draws a whole screen image with Flipper mascot, Game Boy, etc. */ static void trade_draw_connect(Canvas* const canvas) { furi_assert(canvas); canvas_draw_frame(canvas, 0, 0, 128, 64); canvas_draw_icon(canvas, 1, 21, &I_Connect_me_62x31); canvas_draw_icon(canvas, 0, 53, &I_Background_128x11); canvas_draw_icon(canvas, 80, 0, &I_game_boy); canvas_draw_icon(canvas, 8, 2, &I_Space_65x18); canvas_draw_str(canvas, 18, 13, "Connect GB"); } /* Draws a whole screen image with Flipper mascot, Game Boy, etc. */ static void trade_draw_connected(Canvas* const canvas) { furi_assert(canvas); canvas_draw_frame(canvas, 0, 0, 128, 64); canvas_draw_icon(canvas, 1, 21, &I_Connected_62x31); canvas_draw_icon(canvas, 0, 53, &I_Background_128x11); canvas_draw_icon(canvas, 80, 0, &I_game_boy); canvas_draw_icon(canvas, 8, 2, &I_Space_65x18); canvas_draw_str(canvas, 18, 13, "Connected!"); } /* Draws a frame around the screen, with a box at the top for a text string, * and an icon of the player. */ static void trade_draw_frame(Canvas* canvas, const char* str) { furi_assert(canvas); canvas_draw_icon(canvas, 0, 53, &I_Background_128x11); canvas_draw_frame(canvas, 0, 0, 128, 64); canvas_draw_icon(canvas, 24, 0, &I_Space_80x18); canvas_draw_str(canvas, 48, 12, str); canvas_draw_icon(canvas, 27, 1, &I_red_16x15); } /* Draws the Pokemon's image in the middle of the screen */ static void trade_draw_pkmn_avatar(Canvas* canvas, const Icon* icon) { furi_assert(canvas); furi_assert(icon); canvas_draw_icon(canvas, 38, 11, icon); furi_hal_light_set(LightBlue, 0x00); furi_hal_light_set(LightGreen, 0x00); } /* Called every 250 ms on a timer. This controls the blue LED when in TRADING * state. This is necessary as Flipper OS does not make any guarantees on when * draw updates may or may not be called. There are situations where a draw * update is called much faster. Therefore, we need to control the update rate * via the ledon view_model variable. */ static void trade_draw_timer_callback(void* context) { furi_assert(context); struct trade_ctx* trade = (struct trade_ctx*)context; with_view_model( trade->view, struct trade_model * model, { model->ledon ^= 1; }, true); } static void trade_draw_callback(Canvas* canvas, void* view_model) { furi_assert(view_model); struct trade_model* model = view_model; const Icon* icon = model->pokemon_table[model->curr_pokemon].icon; canvas_clear(canvas); switch(model->gameboy_status) { case GAMEBOY_CONN_FALSE: furi_hal_light_set(LightGreen, 0x00); furi_hal_light_set(LightRed, 0xff); trade_draw_connect(canvas); break; case GAMEBOY_CONN_TRUE: furi_hal_light_set(LightGreen, 0xff); furi_hal_light_set(LightRed, 0x00); trade_draw_connected(canvas); break; case GAMEBOY_READY: trade_draw_pkmn_avatar(canvas, icon); trade_draw_frame(canvas, "READY"); break; case GAMEBOY_WAITING: trade_draw_pkmn_avatar(canvas, icon); trade_draw_frame(canvas, "WAITING"); break; case GAMEBOY_TRADE_PENDING: trade_draw_pkmn_avatar(canvas, icon); trade_draw_frame(canvas, "DEAL?"); break; case GAMEBOY_TRADING: furi_hal_light_set(LightGreen, 0x00); if(model->ledon) { furi_hal_light_set(LightBlue, 0xff); canvas_draw_icon(canvas, 0, 0, &I_gb_step_1); } else { furi_hal_light_set(LightBlue, 0x00); canvas_draw_icon(canvas, 0, 0, &I_gb_step_2); } trade_draw_frame(canvas, "TRADING"); break; case GAMEBOY_COLOSSEUM: trade_draw_frame(canvas, "FIGHT!"); break; default: trade_draw_frame(canvas, "INITIAL"); break; } } /* Get the response byte from the link partner, updating the connection * state if needed. */ static uint8_t getConnectResponse(struct trade_ctx* trade) { furi_assert(trade); uint8_t ret; switch(trade->in_data) { case PKMN_CONNECTED: with_view_model( trade->view, struct trade_model * model, { model->gameboy_status = GAMEBOY_CONN_TRUE; }, false); ret = PKMN_CONNECTED; break; case PKMN_MASTER: ret = PKMN_SLAVE; break; case PKMN_BLANK: ret = PKMN_BLANK; break; default: with_view_model( trade->view, struct trade_model * model, { model->gameboy_status = GAMEBOY_CONN_FALSE; }, false); ret = PKMN_BREAK_LINK; break; } return ret; } /* Receive what the Pokemon game is requesting and move to that mode. * * This reads bytes sent by the Game Boy and responds. The only things * we care about are when menu items are actually selected. The protocol * seems to send data both when one of the link menu items is highlighted * and when one of them is selected. * * If somehow we get a leader/master byte received, then go back to the * NOT_CONNECTED state. For the leader/master byte likely means that * the linked Game Boy is still trying to negotiate roles and we need to * respond with a follower/slave byte. * * Note that, we can probably eventually drop colosseum/battle connections, * though it may be an interesting exercise in better understanding how the * "random" seeding is done between the units. As noted here: * http://www.adanscotney.com/2014/01/spoofing-pokemon-trades-with-stellaris.html * it is presumed these bytes are to sync the RNG seed between the units to * not need arbitration on various die rolls. */ static uint8_t getMenuResponse(struct trade_ctx* trade) { furi_assert(trade); uint8_t response = PKMN_BLANK; switch(trade->in_data) { case PKMN_CONNECTED: response = PKMN_CONNECTED; break; case PKMN_TRADE_CENTRE: with_view_model( trade->view, struct trade_model * model, { model->gameboy_status = GAMEBOY_READY; }, false); break; case PKMN_COLOSSEUM: with_view_model( trade->view, struct trade_model * model, { model->gameboy_status = GAMEBOY_COLOSSEUM; }, false); break; case PKMN_BREAK_LINK: case PKMN_MASTER: with_view_model( trade->view, struct trade_model * model, { model->gameboy_status = GAMEBOY_CONN_FALSE; }, false); response = PKMN_BREAK_LINK; break; default: response = trade->in_data; break; } return response; } static uint8_t getTradeCentreResponse(struct trade_ctx* trade) { furi_assert(trade); uint8_t* trade_block_flat = (uint8_t*)trade->trade_block; uint8_t* input_block_flat = (uint8_t*)trade->input_block; uint8_t* input_party_flat = (uint8_t*)trade->input_block->party; struct trade_model* model = NULL; uint8_t in = trade->in_data; uint8_t send = in; static bool patch_pt_2; static int counter; static uint8_t in_pkmn_idx; /* TODO: Figure out how we should respond to a no_data_byte and/or how to * send one and what response to expect. * * This isn't a high priority since it should be unlikely that we would * actually ever receive a NO_DATA_BYE as the Game Boy is the leader/master * and therefore would only transmit when it has data ready. */ /* Since this is a fairly long function, it doesn't call any other functions, * the view model isn't locked, and we're in an interrupt context, lets just * map the view model to a local var and commit it back when we're done. */ model = view_get_model(trade->view); /* There is a handful of communications that happen once the Game Boy * clicks on the table. For all of them, the Flipper can just mirror back * the byte the Game Boy sends. We can spin in this forever until we see 10x * SERIAL_PREAMBLE_BYTEs. Once we receive those, the counters are synced, * and every byte after that can be easily counted for the actual transfer * of Pokemon data. */ switch(trade->trade_centre_state) { case TRADE_RESET: /* Reset counters and other static variables */ counter = 0; patch_pt_2 = false; trade->trade_centre_state = TRADE_INIT; break; /* This state runs through the end of the random preamble */ case TRADE_INIT: if(in == SERIAL_PREAMBLE_BYTE) { counter++; model->gameboy_status = GAMEBOY_WAITING; } else if((in & PKMN_SEL_NUM_MASK) == PKMN_SEL_NUM_MASK) { send = PKMN_TABLE_LEAVE; } if(counter == SERIAL_RNS_LENGTH) { trade->trade_centre_state = TRADE_RANDOM; counter = 0; } break; /* Once we start getting PKMN_BLANKs, we mirror them until we get 10x * SERIAL_PREAMBLE_BYTE, and then 10 random numbers. The 10 random * numbers are for synchronizing the PRNG between the two systems, * we do not use these numbers at this time. * * This waits through the end of the trade block preamble, a total of 20 * bytes. */ case TRADE_RANDOM: counter++; if(counter == (SERIAL_RNS_LENGTH + SERIAL_TRADE_PREAMBLE_LENGTH)) { trade->trade_centre_state = TRADE_DATA; counter = 0; } break; /* This is where we exchange trade_block data with the Game Boy */ case TRADE_DATA: input_block_flat[counter] = in; send = trade_block_flat[counter]; counter++; if(counter == sizeof(TradeBlock)) { trade->trade_centre_state = TRADE_PATCH_HEADER; counter = 0; } break; /* This absorbs the 3 byte ending sequence (DF FE 15) after the trade data is * swapped, then the 3x SERIAL_PREAMBLE_BYTEs that end the trade data, and * another 3x of them that start the patch data. By the time we're done with * this state, the patch list BLANK bytes are ready to be transmitted. * We only care about the 6x total preamble bytes. */ case TRADE_PATCH_HEADER: if(in == SERIAL_PREAMBLE_BYTE) { counter++; } if(counter == 6) { counter = 0; trade->trade_centre_state = TRADE_PATCH_DATA; } else { break; } [[fallthrough]]; case TRADE_PATCH_DATA: counter++; /* This magic number is basically the header length, 10, minus * the 3x 0xFD that we should be transmitting as part of the patch * list header. */ if(counter > 7) { send = plist_index_get(trade->patch_list, (counter - 8)); } /* Patch received data */ /* This relies on the data sent only ever sending 0x00 after * part 2 of the patch list has been terminated. This is the * case in official Gen I code at this time. */ switch(in) { case PKMN_BLANK: break; case SERIAL_PATCH_LIST_PART_TERMINATOR: patch_pt_2 = true; break; default: // Any nonzero value will cause a patch if(!patch_pt_2) { /* Pt 1 is 0x00 - 0xFB */ input_party_flat[in - 1] = SERIAL_NO_DATA_BYTE; } else { /* Pt 2 is 0xFC - 0x107 * 0xFC + in - 1 */ input_party_flat[0xFB + in] = SERIAL_NO_DATA_BYTE; } break; } /* What is interesting about the following check, is the Pokemon code * seems to allocate 203 bytes, 3x for the preamble, and then 200 bytes * of patch list. But in practice, the Game Boy seems to transmit 3x * preamble bytes, 7x 0x00, then 189 bytes for the patch list. A * total of 199 bytes transmitted. */ if(counter == 196) trade->trade_centre_state = TRADE_SELECT; break; /* Resets the incoming Pokemon index, and once a BLANK byte is received, * moves to the pending state. */ case TRADE_SELECT: in_pkmn_idx = 0; if(in == PKMN_BLANK) { trade->trade_centre_state = TRADE_PENDING; } else { break; } [[fallthrough]]; /* Handle the Game Boy selecting a Pokemon to trade, or leaving the table */ case TRADE_PENDING: /* If the player leaves the trade menu and returns to the room */ if(in == PKMN_TABLE_LEAVE) { trade->trade_centre_state = TRADE_RESET; send = PKMN_TABLE_LEAVE; model->gameboy_status = GAMEBOY_READY; /* If the player selected a Pokemon to send from the Game Boy */ } else if((in & PKMN_SEL_NUM_MASK) == PKMN_SEL_NUM_MASK) { in_pkmn_idx = in; send = PKMN_SEL_NUM_ONE; // We always send the first Pokemon model->gameboy_status = GAMEBOY_TRADE_PENDING; /* BLANKs are sent in a few places, we want to do nothing about them * unless the Game Boy already sent us an index they want to trade. */ } else if(in == PKMN_BLANK) { if(in_pkmn_idx != 0) { send = 0; trade->trade_centre_state = TRADE_CONFIRMATION; in_pkmn_idx &= 0x0F; } } break; /* Handle the Game Boy accepting or rejecting a trade deal */ case TRADE_CONFIRMATION: if(in == PKMN_TRADE_REJECT) { trade->trade_centre_state = TRADE_SELECT; model->gameboy_status = GAMEBOY_WAITING; } else if(in == PKMN_TRADE_ACCEPT) { trade->trade_centre_state = TRADE_DONE; } break; /* Start the actual trade. Waits in reset until the Game Boy is done with * its animation and re-exchanges updated party data. */ case TRADE_DONE: if(in == PKMN_BLANK) { trade->trade_centre_state = TRADE_RESET; model->gameboy_status = GAMEBOY_TRADING; /* Copy the traded-in Pokemon's main data to our struct */ trade->trade_block->party_members[0] = trade->input_block->party_members[in_pkmn_idx]; memcpy( &(trade->trade_block->party[0]), &(trade->input_block->party[in_pkmn_idx]), sizeof(struct pokemon_structure)); memcpy( &(trade->trade_block->nickname[0]), &(trade->input_block->nickname[in_pkmn_idx]), sizeof(struct name)); memcpy( &(trade->trade_block->ot_name[0]), &(trade->input_block->ot_name[in_pkmn_idx]), sizeof(struct name)); model->curr_pokemon = pokemon_table_get_num_from_index( trade->pokemon_table, trade->trade_block->party_members[0]); /* Schedule a callback outside of ISR context to rebuild the patch * list with the new Pokemon that we just accepted. */ furi_timer_pending_callback(pokemon_plist_recreate_callback, trade, 0); } break; default: // Do Nothing break; } view_commit_model(trade->view, false); return send; } static void transferBit(void* context, uint8_t in_byte) { furi_assert(context); struct trade_ctx* trade = (struct trade_ctx*)context; render_gameboy_state_t status; with_view_model( trade->view, struct trade_model * model, { status = model->gameboy_status; }, false); trade->in_data = in_byte; /* Once a byte of data has been shifted in, process it */ switch(status) { case GAMEBOY_CONN_FALSE: gblink_transfer(trade->gblink_handle, getConnectResponse(trade)); break; case GAMEBOY_CONN_TRUE: gblink_transfer(trade->gblink_handle, getMenuResponse(trade)); break; case GAMEBOY_COLOSSEUM: gblink_transfer(trade->gblink_handle, in_byte); break; /* Every other state is trade related */ default: gblink_transfer(trade->gblink_handle, getTradeCentreResponse(trade)); break; } } void trade_enter_callback(void* context) { furi_assert(context); struct trade_ctx* trade = (struct trade_ctx*)context; struct trade_model* model; struct gblink_def gblink_def = {0}; model = view_get_model(trade->view); if(model->gameboy_status == GAMEBOY_COLOSSEUM) { model->gameboy_status = GAMEBOY_CONN_FALSE; } else if(model->gameboy_status > GAMEBOY_READY) { model->gameboy_status = GAMEBOY_READY; } trade->trade_centre_state = TRADE_RESET; model->pokemon_table = trade->pokemon_table; model->curr_pokemon = pokemon_table_get_num_from_index( trade->pokemon_table, trade->trade_block->party_members[0]); model->ledon = false; view_commit_model(trade->view, true); /* TODO: This should be moved further back to struct pokemon_fap for whole * app flexibility since it would probably be written to by a different scene */ gblink_def.pins = trade->gblink_pins; gblink_def.callback = transferBit; gblink_def.cb_context = trade; trade->gblink_handle = gblink_alloc(&gblink_def); gblink_nobyte_set(trade->gblink_handle, SERIAL_NO_DATA_BYTE); /* Every 250 ms, trigger a draw update. 250 ms was chosen so that during * the trade process, each update can flip the LED and screen to make the * trade animation. */ trade->draw_timer = furi_timer_alloc(trade_draw_timer_callback, FuriTimerTypePeriodic, trade); furi_timer_start(trade->draw_timer, furi_ms_to_ticks(250)); /* Create a trade patch list from the current trade block */ plist_create(&(trade->patch_list), trade->trade_block); } void disconnect_pin(const GpioPin* pin) { /* Existing projects seem to set the pin back to analog mode upon exit */ furi_hal_gpio_init_simple(pin, GpioModeAnalog); } void trade_exit_callback(void* context) { furi_assert(context); struct trade_ctx* trade = (struct trade_ctx*)context; furi_hal_light_set(LightGreen, 0x00); furi_hal_light_set(LightBlue, 0x00); furi_hal_light_set(LightRed, 0x00); /* Stop the timer, and deallocate it as the enter callback allocates it on entry */ furi_timer_free(trade->draw_timer); trade->draw_timer = NULL; /* Unset the pin settings */ gblink_free(trade->gblink_handle); /* Destroy the patch list, it is allocated on the enter callback */ plist_free(trade->patch_list); trade->patch_list = NULL; } void* trade_alloc( TradeBlock* trade_block, const PokemonTable* table, struct gblink_pins* gblink_pins, ViewDispatcher* view_dispatcher, uint32_t view_id) { furi_assert(trade_block); struct trade_ctx* trade = malloc(sizeof(struct trade_ctx)); memset(trade, '\0', sizeof(struct trade_ctx)); trade->view = view_alloc(); trade->trade_block = trade_block; trade->input_block = malloc(sizeof(TradeBlock)); trade->pokemon_table = table; trade->patch_list = NULL; trade->gblink_pins = gblink_pins; view_set_context(trade->view, trade); view_allocate_model(trade->view, ViewModelTypeLockFree, sizeof(struct trade_model)); view_set_draw_callback(trade->view, trade_draw_callback); view_set_enter_callback(trade->view, trade_enter_callback); view_set_exit_callback(trade->view, trade_exit_callback); view_dispatcher_add_view(view_dispatcher, view_id, trade->view); return trade; } void trade_free(ViewDispatcher* view_dispatcher, uint32_t view_id, void* trade_ctx) { furi_assert(trade_ctx); struct trade_ctx* trade = (struct trade_ctx*)trade_ctx; view_dispatcher_remove_view(view_dispatcher, view_id); view_free_model(trade->view); view_free(trade->view); free(trade->input_block); free(trade); }