/* Media player skeleton implementation */ /* * Copyright (c) 2019 - 2023 Nordic Semiconductor ASA * * SPDX-License-Identifier: Apache-2.0 */ #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include "ccid_internal.h" #include "media_proxy_internal.h" #include "mcs_internal.h" #include "mpl_internal.h" LOG_MODULE_REGISTER(bt_mpl, CONFIG_BT_MPL_LOG_LEVEL); #define TRACK_STATUS_INVALID 0x00 #define TRACK_STATUS_VALID 0x01 #define TRACK_POS_WORK_DELAY_MS 1000 #define TRACK_POS_WORK_DELAY K_MSEC(TRACK_POS_WORK_DELAY_MS) #define PLAYBACK_SPEED_PARAM_DEFAULT MEDIA_PROXY_PLAYBACK_SPEED_UNITY /* Temporary hardcoded setup for groups, tracks and segments */ /* There is one parent group, which is the parent of a number of groups. */ /* The groups have a number of tracks. */ /* (There is only one level of groups, there are no groups of groups.) */ /* The first track of the first group has track segments, other tracks not. */ /* Track segments */ static struct mpl_tseg seg_2; static struct mpl_tseg seg_3; static struct mpl_tseg seg_1 = { .name_len = 5, .name = "Start", .pos = 0, .prev = NULL, .next = &seg_2, }; static struct mpl_tseg seg_2 = { .name_len = 6, .name = "Middle", .pos = 2000, .prev = &seg_1, .next = &seg_3, }; static struct mpl_tseg seg_3 = { .name_len = 3, .name = "End", .pos = 5000, .prev = &seg_2, .next = NULL, }; static struct mpl_track track_1_2; static struct mpl_track track_1_3; static struct mpl_track track_1_4; static struct mpl_track track_1_5; /* Tracks */ static struct mpl_track track_1_1 = { .title = "Interlude #1 (Song for Alison)", .duration = 6300, .segment = &seg_1, .prev = NULL, .next = &track_1_2, }; static struct mpl_track track_1_2 = { .title = "Interlude #2 (For Bobbye)", .duration = 7500, .segment = NULL, .prev = &track_1_1, .next = &track_1_3, }; static struct mpl_track track_1_3 = { .title = "Interlude #3 (Levanto Seventy)", .duration = 7800, .segment = NULL, .prev = &track_1_2, .next = &track_1_4, }; static struct mpl_track track_1_4 = { .title = "Interlude #4 (Vesper Dreams)", .duration = 13500, .segment = NULL, .prev = &track_1_3, .next = &track_1_5, }; static struct mpl_track track_1_5 = { .title = "Interlude #5 (Shasti)", .duration = 7500, .segment = NULL, .prev = &track_1_4, .next = NULL, }; static struct mpl_track track_2_2; static struct mpl_track track_2_3; static struct mpl_track track_2_1 = { .title = "Track 2.1", .duration = 30000, .segment = NULL, .prev = NULL, .next = &track_2_2, }; static struct mpl_track track_2_2 = { .title = "Track 2.2", .duration = 30000, .segment = NULL, .prev = &track_2_1, .next = &track_2_3, }; static struct mpl_track track_2_3 = { .title = "Track 2.3", .duration = 30000, .segment = NULL, .prev = &track_2_2, .next = NULL, }; static struct mpl_track track_3_2; static struct mpl_track track_3_3; static struct mpl_track track_3_1 = { .title = "Track 3.1", .duration = 30000, .segment = NULL, .prev = NULL, .next = &track_3_2, }; static struct mpl_track track_3_2 = { .title = "Track 3.2", .duration = 30000, .segment = NULL, .prev = &track_3_1, .next = &track_3_3, }; static struct mpl_track track_3_3 = { .title = "Track 3.3", .duration = 30000, .segment = NULL, .prev = &track_3_2, .next = NULL, }; static struct mpl_track track_4_2; static struct mpl_track track_4_1 = { .title = "Track 4.1", .duration = 30000, .segment = NULL, .prev = NULL, .next = &track_4_2, }; static struct mpl_track track_4_2 = { .title = "Track 4.2", .duration = 30000, .segment = NULL, .prev = &track_4_1, .next = NULL, }; /* Groups */ static struct mpl_group group_2; static struct mpl_group group_3; static struct mpl_group group_4; static struct mpl_group group_p; static struct mpl_group group_1 = { .title = "Joe Pass - Guitar Interludes", .track = &track_1_1, .parent = &group_p, .prev = NULL, .next = &group_2, }; static struct mpl_group group_2 = { .title = "Group 2", .track = &track_2_2, .parent = &group_p, .prev = &group_1, .next = &group_3, }; static struct mpl_group group_3 = { .title = "Group 3", .track = &track_3_3, .parent = &group_p, .prev = &group_2, .next = &group_4, }; static struct mpl_group group_4 = { .title = "Group 4", .track = &track_4_2, .parent = &group_p, .prev = &group_3, .next = NULL, }; static struct mpl_group group_p = { .title = "Parent group", .track = &track_4_1, .parent = &group_p, .prev = NULL, .next = NULL, }; static struct mpl_mediaplayer media_player = { .name = CONFIG_BT_MPL_MEDIA_PLAYER_NAME, .icon_url = CONFIG_BT_MPL_ICON_URL, .group = &group_1, .track_pos = 0, .state = MEDIA_PROXY_STATE_PAUSED, .playback_speed_param = PLAYBACK_SPEED_PARAM_DEFAULT, .seeking_speed_factor = MEDIA_PROXY_SEEKING_SPEED_FACTOR_ZERO, .playing_order = MEDIA_PROXY_PLAYING_ORDER_INORDER_REPEAT, .playing_orders_supported = MEDIA_PROXY_PLAYING_ORDERS_SUPPORTED_INORDER_ONCE | MEDIA_PROXY_PLAYING_ORDERS_SUPPORTED_INORDER_REPEAT, .opcodes_supported = 0x001fffff, /* All opcodes */ #ifdef CONFIG_BT_MPL_OBJECTS .search_results_id = 0, .calls = { 0 }, #endif /* CONFIG_BT_MPL_OBJECTS */ .next_track_set = false }; static void set_track_position(int32_t position); static void set_relative_track_position(int32_t rel_pos); static void do_track_change_notifications(struct mpl_mediaplayer *pl); static void do_group_change_notifications(struct mpl_mediaplayer *pl); #ifdef CONFIG_BT_MPL_OBJECTS /* The types of objects we keep in the Object Transfer Service */ enum mpl_objects { MPL_OBJ_NONE = 0, MPL_OBJ_ICON, MPL_OBJ_TRACK_SEGMENTS, MPL_OBJ_TRACK, MPL_OBJ_PARENT_GROUP, MPL_OBJ_GROUP, MPL_OBJ_SEARCH_RESULTS, }; /* The active object */ /* Only a single object is selected or being added (active) at a time. */ /* And, except for the icon object, all objects can be created dynamically. */ /* So a single buffer to hold object content is sufficient. */ struct obj_t { /* ID of the currently selected object*/ uint64_t selected_id; bool busy; /* Type of object being added, e.g. MPL_OBJ_ICON */ uint8_t add_type; /* Descriptor of object being added */ struct bt_ots_obj_created_desc *desc; union { /* Pointer to track being added */ struct mpl_track *add_track; /* Pointer to group being added */ struct mpl_group *add_group; }; struct net_buf_simple *content; }; static struct obj_t obj = { .selected_id = 0, .add_type = MPL_OBJ_NONE, .busy = false, .add_track = NULL, .add_group = NULL, .content = NET_BUF_SIMPLE(CONFIG_BT_MPL_MAX_OBJ_SIZE) }; /* Set up content buffer for the icon object */ static int setup_icon_object(void) { uint16_t index; uint8_t k; /* The icon object is supposed to be a bitmap. */ /* For now, fill it with dummy data. */ net_buf_simple_reset(obj.content); /* Size may be larger than what fits in 8 bits, use 16-bit for index */ for (index = 0, k = 0; index < MIN(CONFIG_BT_MPL_MAX_OBJ_SIZE, CONFIG_BT_MPL_ICON_BITMAP_SIZE); index++, k++) { net_buf_simple_add_u8(obj.content, k); } return obj.content->len; } /* Set up content buffer for a track segments object */ static uint32_t setup_segments_object(struct mpl_track *track) { struct mpl_tseg *seg = track->segment; net_buf_simple_reset(obj.content); if (seg) { uint32_t tot_size = 0; while (seg->prev) { seg = seg->prev; } while (seg) { uint32_t seg_size = sizeof(seg->name_len); seg_size += seg->name_len; seg_size += sizeof(seg->pos); if (tot_size + seg_size > obj.content->size) { LOG_DBG("Segments object out of space"); break; } net_buf_simple_add_u8(obj.content, seg->name_len); net_buf_simple_add_mem(obj.content, seg->name, seg->name_len); net_buf_simple_add_le32(obj.content, seg->pos); tot_size += seg_size; seg = seg->next; } LOG_HEXDUMP_DBG(obj.content->data, obj.content->len, "Segments Object"); LOG_DBG("Segments object length: %d", obj.content->len); } else { LOG_ERR("No seg!"); } return obj.content->len; } /* Set up content buffer for a track object */ static uint32_t setup_track_object(struct mpl_track *track) { uint16_t index; uint8_t k; /* The track object is supposed to be in Id3v2 format */ /* For now, fill it with dummy data */ net_buf_simple_reset(obj.content); /* Size may be larger than what fits in 8 bits, use 16-bit for index */ for (index = 0, k = 0; index < MIN(CONFIG_BT_MPL_MAX_OBJ_SIZE, CONFIG_BT_MPL_TRACK_MAX_SIZE); index++, k++) { net_buf_simple_add_u8(obj.content, k); } return obj.content->len; } /* Set up content buffer for the parent group object */ static uint32_t setup_parent_group_object(struct mpl_group *group) { /* This function actually does not use the parent. */ /* It just follows the list of groups. */ /* The implementation has a fixed structure, with one parent group, */ /* and one level of groups containing tracks only. */ /* The track groups have a pointer to the parent, but there is no */ /* pointer in the other direction, so it is not possible to go from */ /* the parent group to a group of tracks. */ uint8_t type = MEDIA_PROXY_GROUP_OBJECT_GROUP_TYPE; uint8_t record_size = sizeof(type) + BT_OTS_OBJ_ID_SIZE; int next_size = record_size; net_buf_simple_reset(obj.content); if (group) { while (group->prev) { group = group->prev; } /* While there is a group, and the record fits in the object */ while (group && (next_size <= obj.content->size)) { net_buf_simple_add_u8(obj.content, type); net_buf_simple_add_le48(obj.content, group->id); group = group->next; next_size += record_size; } if (next_size > obj.content->size) { LOG_WRN("Not room for full group in object"); } LOG_HEXDUMP_DBG(obj.content->data, obj.content->len, "Parent Group Object"); LOG_DBG("Group object length: %d", obj.content->len); } return obj.content->len; } /* Set up contents for a group object */ /* The group object contains a concatenated list of records, where each */ /* record consists of a type byte and a UUID */ static uint32_t setup_group_object(struct mpl_group *group) { struct mpl_track *track = group->track; uint8_t type = MEDIA_PROXY_GROUP_OBJECT_TRACK_TYPE; uint8_t record_size = sizeof(type) + BT_OTS_OBJ_ID_SIZE; int next_size = record_size; net_buf_simple_reset(obj.content); if (track) { while (track->prev) { track = track->prev; } /* While there is a track, and the record fits in the object */ while (track && (next_size <= obj.content->size)) { net_buf_simple_add_u8(obj.content, type); net_buf_simple_add_le48(obj.content, track->id); track = track->next; next_size += record_size; } if (next_size > obj.content->size) { LOG_WRN("Not room for full group in object"); } LOG_HEXDUMP_DBG(obj.content->data, obj.content->len, "Group Object"); LOG_DBG("Group object length: %d", obj.content->len); } return obj.content->len; } /* Add the icon object to the OTS */ static int add_icon_object(struct mpl_mediaplayer *pl) { int ret; struct bt_ots_obj_add_param add_param = {}; struct bt_ots_obj_created_desc created_desc = {}; const struct bt_uuid *icon_type = BT_UUID_OTS_TYPE_MPL_ICON; static char *icon_name = "Icon"; if (obj.busy) { /* TODO: Can there be a collision between select and internal */ /* activities, like adding new objects? */ LOG_ERR("Object busy"); return 0; } obj.busy = true; obj.add_type = MPL_OBJ_ICON; obj.desc = &created_desc; obj.desc->size.alloc = obj.desc->size.cur = setup_icon_object(); obj.desc->name = icon_name; BT_OTS_OBJ_SET_PROP_READ(obj.desc->props); add_param.size = obj.desc->size.alloc; add_param.type.uuid.type = BT_UUID_TYPE_16; add_param.type.uuid_16.val = BT_UUID_16(icon_type)->val; ret = bt_ots_obj_add(bt_mcs_get_ots(), &add_param); if (ret < 0) { LOG_WRN("Unable to add icon object, error %d", ret); obj.busy = false; return ret; } return 0; } /* Add a track segments object to the OTS */ static int add_current_track_segments_object(struct mpl_mediaplayer *pl) { int ret; struct bt_ots_obj_add_param add_param = {}; struct bt_ots_obj_created_desc created_desc = {}; const struct bt_uuid *segs_type = BT_UUID_OTS_TYPE_TRACK_SEGMENT; if (obj.busy) { LOG_ERR("Object busy"); return 0; } obj.busy = true; obj.add_type = MPL_OBJ_TRACK_SEGMENTS; obj.desc = &created_desc; obj.desc->size.alloc = obj.desc->size.cur = setup_segments_object(pl->group->track); obj.desc->name = pl->group->track->title; BT_OTS_OBJ_SET_PROP_READ(obj.desc->props); add_param.size = obj.desc->size.alloc; add_param.type.uuid.type = BT_UUID_TYPE_16; add_param.type.uuid_16.val = BT_UUID_16(segs_type)->val; ret = bt_ots_obj_add(bt_mcs_get_ots(), &add_param); if (ret < 0) { LOG_WRN("Unable to add track segments object: %d", ret); obj.busy = false; return ret; } return 0; } /* Add a single track to the OTS */ static int add_track_object(struct mpl_track *track) { struct bt_ots_obj_add_param add_param = {}; struct bt_ots_obj_created_desc created_desc = {}; const struct bt_uuid *track_type = BT_UUID_OTS_TYPE_TRACK; int ret; if (obj.busy) { LOG_ERR("Object busy"); return 0; } if (!track) { LOG_ERR("No track"); return -EINVAL; } obj.busy = true; obj.add_type = MPL_OBJ_TRACK; obj.add_track = track; obj.desc = &created_desc; obj.desc->size.alloc = obj.desc->size.cur = setup_track_object(track); obj.desc->name = track->title; BT_OTS_OBJ_SET_PROP_READ(obj.desc->props); add_param.size = obj.desc->size.alloc; add_param.type.uuid.type = BT_UUID_TYPE_16; add_param.type.uuid_16.val = BT_UUID_16(track_type)->val; ret = bt_ots_obj_add(bt_mcs_get_ots(), &add_param); if (ret < 0) { LOG_WRN("Unable to add track object: %d", ret); obj.busy = false; return ret; } return 0; } /* Add the parent group to the OTS */ static int add_parent_group_object(struct mpl_mediaplayer *pl) { int ret; struct bt_ots_obj_add_param add_param = {}; struct bt_ots_obj_created_desc created_desc = {}; const struct bt_uuid *group_type = BT_UUID_OTS_TYPE_GROUP; if (obj.busy) { LOG_ERR("Object busy"); return 0; } obj.busy = true; obj.add_type = MPL_OBJ_PARENT_GROUP; obj.desc = &created_desc; obj.desc->size.alloc = obj.desc->size.cur = setup_parent_group_object(pl->group); obj.desc->name = pl->group->parent->title; BT_OTS_OBJ_SET_PROP_READ(obj.desc->props); add_param.size = obj.desc->size.alloc; add_param.type.uuid.type = BT_UUID_TYPE_16; add_param.type.uuid_16.val = BT_UUID_16(group_type)->val; ret = bt_ots_obj_add(bt_mcs_get_ots(), &add_param); if (ret < 0) { LOG_WRN("Unable to add parent group object"); obj.busy = false; return ret; } return 0; } /* Add a single group to the OTS */ static int add_group_object(struct mpl_group *group) { struct bt_ots_obj_add_param add_param = {}; struct bt_ots_obj_created_desc created_desc = {}; const struct bt_uuid *group_type = BT_UUID_OTS_TYPE_GROUP; int ret; if (obj.busy) { LOG_ERR("Object busy"); return 0; } if (!group) { LOG_ERR("No group"); return -EINVAL; } obj.busy = true; obj.add_type = MPL_OBJ_GROUP; obj.add_group = group; obj.desc = &created_desc; obj.desc->size.alloc = obj.desc->size.cur = setup_group_object(group); obj.desc->name = group->title; BT_OTS_OBJ_SET_PROP_READ(obj.desc->props); add_param.size = obj.desc->size.alloc; add_param.type.uuid.type = BT_UUID_TYPE_16; add_param.type.uuid_16.val = BT_UUID_16(group_type)->val; ret = bt_ots_obj_add(bt_mcs_get_ots(), &add_param); if (ret < 0) { LOG_WRN("Unable to add group object: %d", ret); obj.busy = false; return ret; } return 0; } /* Add all tracks of a group to the OTS */ static int add_group_tracks(struct mpl_group *group) { int ret_overall = 0; struct mpl_track *track = group->track; if (track) { while (track->prev) { track = track->prev; } while (track) { int ret = add_track_object(track); if (ret && !ret_overall) { ret_overall = ret; } track = track->next; } } return ret_overall; } /* Add all groups (except the parent group) and their tracks to the OTS */ static int add_group_and_track_objects(struct mpl_mediaplayer *pl) { int ret_overall = 0; int ret; struct mpl_group *group = pl->group; if (group) { while (group->prev) { group = group->prev; } while (group) { ret = add_group_tracks(group); if (ret && !ret_overall) { ret_overall = ret; } ret = add_group_object(group); if (ret && !ret_overall) { ret_overall = ret; } group = group->next; } } ret = add_parent_group_object(pl); if (ret && !ret_overall) { ret_overall = ret; } return ret_overall; } /**** Callbacks from the object transfer service ******************************/ static int on_obj_deleted(struct bt_ots *ots, struct bt_conn *conn, uint64_t id) { LOG_DBG_OBJ_ID("Object Id deleted: ", id); return 0; } static void on_obj_selected(struct bt_ots *ots, struct bt_conn *conn, uint64_t id) { if (obj.busy) { /* TODO: Can there be a collision between select and internal */ /* activities, like adding new objects? */ LOG_ERR("Object busy - select not performed"); return; } obj.busy = true; LOG_DBG_OBJ_ID("Object Id selected: ", id); if (id == media_player.icon_id) { LOG_DBG("Icon Object ID"); (void)setup_icon_object(); } else if (id == media_player.group->track->segments_id) { LOG_DBG("Current Track Segments Object ID"); (void)setup_segments_object(media_player.group->track); } else if (id == media_player.group->track->id) { LOG_DBG("Current Track Object ID"); (void)setup_track_object(media_player.group->track); } else if (media_player.next_track_set && id == media_player.next.track->id) { /* Next track, if the next track has been explicitly set */ LOG_DBG("Next Track Object ID"); (void)setup_track_object(media_player.next.track); } else if (id == media_player.group->track->next->id) { /* Next track, if next track has not been explicitly set */ LOG_DBG("Next Track Object ID"); (void)setup_track_object(media_player.group->track->next); } else if (id == media_player.group->parent->id) { LOG_DBG("Parent Group Object ID"); (void)setup_parent_group_object(media_player.group); } else if (id == media_player.group->id) { LOG_DBG("Current Group Object ID"); (void)setup_group_object(media_player.group); } else { LOG_ERR("Unknown Object ID"); obj.busy = false; return; } obj.selected_id = id; obj.busy = false; } static int on_obj_created(struct bt_ots *ots, struct bt_conn *conn, uint64_t id, const struct bt_ots_obj_add_param *add_param, struct bt_ots_obj_created_desc *created_desc) { LOG_DBG_OBJ_ID("Object Id created: ", id); *created_desc = *obj.desc; if (!bt_uuid_cmp(&add_param->type.uuid, BT_UUID_OTS_TYPE_MPL_ICON)) { LOG_DBG("Icon Obj Type"); if (obj.add_type == MPL_OBJ_ICON) { obj.add_type = MPL_OBJ_NONE; media_player.icon_id = id; } else { LOG_DBG("Unexpected object creation"); } } else if (!bt_uuid_cmp(&add_param->type.uuid, BT_UUID_OTS_TYPE_TRACK_SEGMENT)) { LOG_DBG("Track Segments Obj Type"); if (obj.add_type == MPL_OBJ_TRACK_SEGMENTS) { obj.add_type = MPL_OBJ_NONE; media_player.group->track->segments_id = id; } else { LOG_DBG("Unexpected object creation"); } } else if (!bt_uuid_cmp(&add_param->type.uuid, BT_UUID_OTS_TYPE_TRACK)) { LOG_DBG("Track Obj Type"); if (obj.add_type == MPL_OBJ_TRACK) { obj.add_type = MPL_OBJ_NONE; obj.add_track->id = id; obj.add_track = NULL; } else { LOG_DBG("Unexpected object creation"); } } else if (!bt_uuid_cmp(&add_param->type.uuid, BT_UUID_OTS_TYPE_GROUP)) { LOG_DBG("Group Obj Type"); if (obj.add_type == MPL_OBJ_PARENT_GROUP) { LOG_DBG("Parent group"); obj.add_type = MPL_OBJ_NONE; media_player.group->parent->id = id; } else if (obj.add_type == MPL_OBJ_GROUP) { LOG_DBG("Other group"); obj.add_type = MPL_OBJ_NONE; obj.add_group->id = id; obj.add_group = NULL; } else { LOG_DBG("Unexpected object creation"); } } else { LOG_DBG("Unknown Object ID"); } if (obj.add_type == MPL_OBJ_NONE) { obj.busy = false; } return 0; } static ssize_t on_object_send(struct bt_ots *ots, struct bt_conn *conn, uint64_t id, void **data, size_t len, off_t offset) { if (obj.busy) { /* TODO: Can there be a collision between select and internal */ /* activities, like adding new objects? */ LOG_ERR("Object busy"); return 0; } obj.busy = true; if (IS_ENABLED(CONFIG_BT_MPL_LOG_LEVEL_DBG)) { char t[BT_OTS_OBJ_ID_STR_LEN]; (void)bt_ots_obj_id_to_str(id, t, sizeof(t)); LOG_DBG("Object Id %s, offset %lu, length %zu", t, (long)offset, len); } if (id != obj.selected_id) { LOG_ERR("Read from unselected object"); obj.busy = false; return 0; } if (!data) { LOG_DBG("Read complete"); obj.busy = false; return 0; } if (offset >= obj.content->len) { LOG_DBG("Offset too large"); obj.busy = false; return 0; } if (IS_ENABLED(CONFIG_BT_MPL_LOG_LEVEL_DBG)) { if (len > obj.content->len - offset) { LOG_DBG("Requested len too large"); } } *data = &obj.content->data[offset]; obj.busy = false; return MIN(len, obj.content->len - offset); } static struct bt_ots_cb ots_cbs = { .obj_created = on_obj_created, .obj_read = on_object_send, .obj_selected = on_obj_selected, .obj_deleted = on_obj_deleted, }; #endif /* CONFIG_BT_MPL_OBJECTS */ /* TODO: It must be possible to replace the do_prev_segment(), do_prev_track */ /* and do_prev_group() with a generic do_prev() command that can be used at */ /* all levels. Similarly for do_next, do_prev, and so on. */ static void do_prev_segment(struct mpl_mediaplayer *pl) { LOG_DBG("Segment name before: %s", pl->group->track->segment->name); if (pl->group->track->segment->prev != NULL) { pl->group->track->segment = pl->group->track->segment->prev; } LOG_DBG("Segment name after: %s", pl->group->track->segment->name); } static void do_next_segment(struct mpl_mediaplayer *pl) { LOG_DBG("Segment name before: %s", pl->group->track->segment->name); if (pl->group->track->segment->next != NULL) { pl->group->track->segment = pl->group->track->segment->next; } LOG_DBG("Segment name after: %s", pl->group->track->segment->name); } static void do_first_segment(struct mpl_mediaplayer *pl) { LOG_DBG("Segment name before: %s", pl->group->track->segment->name); while (pl->group->track->segment->prev != NULL) { pl->group->track->segment = pl->group->track->segment->prev; } LOG_DBG("Segment name after: %s", pl->group->track->segment->name); } static void do_last_segment(struct mpl_mediaplayer *pl) { LOG_DBG("Segment name before: %s", pl->group->track->segment->name); while (pl->group->track->segment->next != NULL) { pl->group->track->segment = pl->group->track->segment->next; } LOG_DBG("Segment name after: %s", pl->group->track->segment->name); } static void do_goto_segment(struct mpl_mediaplayer *pl, int32_t segnum) { int32_t k; LOG_DBG("Segment name before: %s", pl->group->track->segment->name); if (segnum > 0) { /* Goto first segment */ while (pl->group->track->segment->prev != NULL) { pl->group->track->segment = pl->group->track->segment->prev; } /* Then go segnum - 1 tracks forward */ for (k = 0; k < (segnum - 1); k++) { if (pl->group->track->segment->next != NULL) { pl->group->track->segment = pl->group->track->segment->next; } } } else if (segnum < 0) { /* Goto last track */ while (pl->group->track->segment->next != NULL) { pl->group->track->segment = pl->group->track->segment->next; } /* Then go |segnum - 1| tracks back */ for (k = 0; k < (-segnum - 1); k++) { if (pl->group->track->segment->prev != NULL) { pl->group->track->segment = pl->group->track->segment->prev; } } } LOG_DBG("Segment name after: %s", pl->group->track->segment->name); set_track_position(pl->group->track->segment->pos); } static void do_prev_track(struct mpl_mediaplayer *pl) { #ifdef CONFIG_BT_MPL_OBJECTS LOG_DBG_OBJ_ID("Track ID before: ", pl->group->track->id); #endif /* CONFIG_BT_MPL_OBJECTS */ if (pl->group->track->prev != NULL) { pl->group->track = pl->group->track->prev; pl->track_pos = 0; do_track_change_notifications(pl); } else { /* For previous track, the position is reset to 0 */ /* even if we stay at the same track (goto start of */ /* track) */ set_track_position(0); } #ifdef CONFIG_BT_MPL_OBJECTS LOG_DBG_OBJ_ID("Track ID after: ", pl->group->track->id); #endif /* CONFIG_BT_MPL_OBJECTS */ } /* Change to next track according to the current track's next track */ static void do_next_track_normal_order(struct mpl_mediaplayer *pl) { #ifdef CONFIG_BT_MPL_OBJECTS LOG_DBG_OBJ_ID("Track ID before: ", pl->group->track->id); #endif /* CONFIG_BT_MPL_OBJECTS */ if (pl->group->track->next != NULL) { pl->group->track = pl->group->track->next; pl->track_pos = 0; do_track_change_notifications(pl); } #ifdef CONFIG_BT_MPL_OBJECTS LOG_DBG_OBJ_ID("Track ID after: ", pl->group->track->id); #endif /* CONFIG_BT_MPL_OBJECTS */ } /* Change to next track when the next track has been explicitly set * * ALWAYS changes the track, changes the group if required * Resets the next_track_set and the "next" pointers * * Returns true if the _group_ has been changed, otherwise false */ static void do_next_track_next_track_set(struct mpl_mediaplayer *pl) { if (pl->next.group != pl->group) { pl->group = pl->next.group; do_group_change_notifications(pl); } pl->group->track = pl->next.track; pl->next.track = NULL; pl->next.group = NULL; pl->next_track_set = false; pl->track_pos = 0; do_track_change_notifications(pl); } static void do_next_track(struct mpl_mediaplayer *pl) { if (pl->next_track_set) { LOG_DBG("Next track set"); do_next_track_next_track_set(pl); } else { do_next_track_normal_order(pl); } } static void do_first_track(struct mpl_mediaplayer *pl, bool group_change) { bool track_changed = false; #ifdef CONFIG_BT_MPL_OBJECTS LOG_DBG_OBJ_ID("Track ID before: ", pl->group->track->id); #endif /* CONFIG_BT_MPL_OBJECTS */ /* Set first track */ while (pl->group->track->prev != NULL) { pl->group->track = pl->group->track->prev; track_changed = true; } /* Notify about new track */ if (group_change || track_changed) { media_player.track_pos = 0; do_track_change_notifications(&media_player); } else { /* For first track, the position is reset to 0 even */ /* if we stay at the same track (goto start of track) */ set_track_position(0); } #ifdef CONFIG_BT_MPL_OBJECTS LOG_DBG_OBJ_ID("Track ID after: ", pl->group->track->id); #endif /* CONFIG_BT_MPL_OBJECTS */ } static void do_last_track(struct mpl_mediaplayer *pl) { #ifdef CONFIG_BT_MPL_OBJECTS LOG_DBG_OBJ_ID("Track ID before: ", pl->group->track->id); #endif /* CONFIG_BT_MPL_OBJECTS */ if (pl->group->track->next != NULL) { pl->group->track = pl->group->track->next; media_player.track_pos = 0; do_track_change_notifications(&media_player); } else { /* For last track, the position is reset to 0 even */ /* if we stay at the same track (goto start of track) */ set_track_position(0); } while (pl->group->track->next != NULL) { pl->group->track = pl->group->track->next; } #ifdef CONFIG_BT_MPL_OBJECTS LOG_DBG_OBJ_ID("Track ID after: ", pl->group->track->id); #endif /* CONFIG_BT_MPL_OBJECTS */ } static void do_goto_track(struct mpl_mediaplayer *pl, int32_t tracknum) { int32_t count = 0; int32_t k; #ifdef CONFIG_BT_MPL_OBJECTS LOG_DBG_OBJ_ID("Track ID before: ", pl->group->track->id); #endif /* CONFIG_BT_MPL_OBJECTS */ if (tracknum > 0) { /* Goto first track */ while (pl->group->track->prev != NULL) { pl->group->track = pl->group->track->prev; count--; } /* Then go tracknum - 1 tracks forward */ for (k = 0; k < (tracknum - 1); k++) { if (pl->group->track->next != NULL) { pl->group->track = pl->group->track->next; count++; } } } else if (tracknum < 0) { /* Goto last track */ while (pl->group->track->next != NULL) { pl->group->track = pl->group->track->next; count++; } /* Then go |tracknum - 1| tracks back */ for (k = 0; k < (-tracknum - 1); k++) { if (pl->group->track->prev != NULL) { pl->group->track = pl->group->track->prev; count--; } } } #ifdef CONFIG_BT_MPL_OBJECTS LOG_DBG_OBJ_ID("Track ID after: ", pl->group->track->id); #endif /* CONFIG_BT_MPL_OBJECTS */ /* The track has changed if we have moved more in one direction */ /* than in the other */ if (count != 0) { media_player.track_pos = 0; do_track_change_notifications(&media_player); } else { /* For goto track, the position is reset to 0 */ /* even if we stay at the same track (goto */ /* start of track) */ set_track_position(0); } } static void do_prev_group(struct mpl_mediaplayer *pl) { #ifdef CONFIG_BT_MPL_OBJECTS LOG_DBG_OBJ_ID("Group ID before: ", pl->group->id); #endif /* CONFIG_BT_MPL_OBJECTS */ if (pl->group->prev != NULL) { pl->group = pl->group->prev; do_group_change_notifications(pl); } #ifdef CONFIG_BT_MPL_OBJECTS LOG_DBG_OBJ_ID("Group ID after: ", pl->group->id); #endif /* CONFIG_BT_MPL_OBJECTS */ } static void do_next_group(struct mpl_mediaplayer *pl) { #ifdef CONFIG_BT_MPL_OBJECTS LOG_DBG_OBJ_ID("Group ID before: ", pl->group->id); #endif /* CONFIG_BT_MPL_OBJECTS */ if (pl->group->next != NULL) { pl->group = pl->group->next; do_group_change_notifications(pl); } #ifdef CONFIG_BT_MPL_OBJECTS LOG_DBG_OBJ_ID("Group ID after: ", pl->group->id); #endif /* CONFIG_BT_MPL_OBJECTS */ } static void do_first_group(struct mpl_mediaplayer *pl) { #ifdef CONFIG_BT_MPL_OBJECTS LOG_DBG_OBJ_ID("Group ID before: ", pl->group->id); #endif /* CONFIG_BT_MPL_OBJECTS */ if (pl->group->prev != NULL) { pl->group = pl->group->prev; do_group_change_notifications(pl); } while (pl->group->prev != NULL) { pl->group = pl->group->prev; } #ifdef CONFIG_BT_MPL_OBJECTS LOG_DBG_OBJ_ID("Group ID after: ", pl->group->id); #endif /* CONFIG_BT_MPL_OBJECTS */ } static void do_last_group(struct mpl_mediaplayer *pl) { #ifdef CONFIG_BT_MPL_OBJECTS LOG_DBG_OBJ_ID("Group ID before: ", pl->group->id); #endif /* CONFIG_BT_MPL_OBJECTS */ if (pl->group->next != NULL) { pl->group = pl->group->next; do_group_change_notifications(pl); } while (pl->group->next != NULL) { pl->group = pl->group->next; } #ifdef CONFIG_BT_MPL_OBJECTS LOG_DBG_OBJ_ID("Group ID after: ", pl->group->id); #endif /* CONFIG_BT_MPL_OBJECTS */ } static void do_goto_group(struct mpl_mediaplayer *pl, int32_t groupnum) { int32_t count = 0; int32_t k; #ifdef CONFIG_BT_MPL_OBJECTS LOG_DBG_OBJ_ID("Group ID before: ", pl->group->id); #endif /* CONFIG_BT_MPL_OBJECTS */ if (groupnum > 0) { /* Goto first group */ while (pl->group->prev != NULL) { pl->group = pl->group->prev; count--; } /* Then go groupnum - 1 groups forward */ for (k = 0; k < (groupnum - 1); k++) { if (pl->group->next != NULL) { pl->group = pl->group->next; count++; } } } else if (groupnum < 0) { /* Goto last group */ while (pl->group->next != NULL) { pl->group = pl->group->next; count++; } /* Then go |groupnum - 1| groups back */ for (k = 0; k < (-groupnum - 1); k++) { if (pl->group->prev != NULL) { pl->group = pl->group->prev; count--; } } } #ifdef CONFIG_BT_MPL_OBJECTS LOG_DBG_OBJ_ID("Group ID after: ", pl->group->id); #endif /* CONFIG_BT_MPL_OBJECTS */ /* The group has changed if we have moved more in one direction */ /* than in the other */ if (count != 0) { do_group_change_notifications(pl); } } static void do_track_change_notifications(struct mpl_mediaplayer *pl) { media_proxy_pl_track_changed_cb(); media_proxy_pl_track_title_cb(pl->group->track->title); media_proxy_pl_track_duration_cb(pl->group->track->duration); media_proxy_pl_track_position_cb(pl->track_pos); #ifdef CONFIG_BT_MPL_OBJECTS media_proxy_pl_current_track_id_cb(pl->group->track->id); if (pl->group->track->next) { media_proxy_pl_next_track_id_cb(pl->group->track->next->id); } else { /* Send a zero value to indicate that there is no next track */ media_proxy_pl_next_track_id_cb(MPL_NO_TRACK_ID); } #endif /* CONFIG_BT_MPL_OBJECTS */ } static void do_group_change_notifications(struct mpl_mediaplayer *pl) { #ifdef CONFIG_BT_MPL_OBJECTS media_proxy_pl_current_group_id_cb(pl->group->id); #endif /* CONFIG_BT_MPL_OBJECTS */ } static void do_full_prev_group(struct mpl_mediaplayer *pl) { /* Change the group (if not already on first group) */ do_prev_group(pl); /* Whether there is a group change or not, we always go to the first track */ do_first_track(pl, true); } static void do_full_next_group(struct mpl_mediaplayer *pl) { /* Change the group (if not already on last group) */ do_next_group(pl); /* Whether there is a group change or not, we always go to the first track */ do_first_track(pl, true); } static void do_full_first_group(struct mpl_mediaplayer *pl) { /* Change the group (if not already on first group) */ do_first_group(pl); /* Whether there is a group change or not, we always go to the first track */ do_first_track(pl, true); } static void do_full_last_group(struct mpl_mediaplayer *pl) { /* Change the group (if not already on last group) */ do_last_group(pl); /* Whether there is a group change or not, we always go to the first track */ do_first_track(pl, true); } static void do_full_goto_group(struct mpl_mediaplayer *pl, int32_t groupnum) { /* Change the group (if not already on given group) */ do_goto_group(pl, groupnum); /* Whether there is a group change or not, we always go to the first track */ do_first_track(pl, true); } static void mpl_set_state(uint8_t state) { switch (state) { case MEDIA_PROXY_STATE_INACTIVE: case MEDIA_PROXY_STATE_PLAYING: case MEDIA_PROXY_STATE_PAUSED: (void)k_work_cancel_delayable(&media_player.pos_work); break; case MEDIA_PROXY_STATE_SEEKING: (void)k_work_schedule(&media_player.pos_work, TRACK_POS_WORK_DELAY); break; default: __ASSERT(false, "Invalid state: %u", state); } media_player.state = state; media_proxy_pl_media_state_cb(media_player.state); } /* Command handlers (state machines) */ static uint8_t inactive_state_command_handler(const struct mpl_cmd *command) { uint8_t result_code = MEDIA_PROXY_CMD_SUCCESS; LOG_DBG("Command opcode: %d", command->opcode); if (IS_ENABLED(CONFIG_BT_MPL_LOG_LEVEL_DBG)) { if (command->use_param) { LOG_DBG("Command parameter: %d", command->param); } } switch (command->opcode) { case MEDIA_PROXY_OP_PLAY: /* Fall-through - handle several cases identically */ case MEDIA_PROXY_OP_PAUSE: case MEDIA_PROXY_OP_FAST_REWIND: case MEDIA_PROXY_OP_FAST_FORWARD: case MEDIA_PROXY_OP_STOP: case MEDIA_PROXY_OP_MOVE_RELATIVE: case MEDIA_PROXY_OP_PREV_SEGMENT: case MEDIA_PROXY_OP_NEXT_SEGMENT: case MEDIA_PROXY_OP_FIRST_SEGMENT: case MEDIA_PROXY_OP_LAST_SEGMENT: case MEDIA_PROXY_OP_GOTO_SEGMENT: result_code = MEDIA_PROXY_CMD_PLAYER_INACTIVE; break; case MEDIA_PROXY_OP_PREV_TRACK: do_prev_track(&media_player); mpl_set_state(MEDIA_PROXY_STATE_PAUSED); break; case MEDIA_PROXY_OP_NEXT_TRACK: /* TODO: * The case where the next track has been set explicitly breaks somewhat * with the "next" order hardcoded into the group and track structure */ do_next_track(&media_player); /* For next track, the position is kept if the track */ /* does not change */ mpl_set_state(MEDIA_PROXY_STATE_PAUSED); break; case MEDIA_PROXY_OP_FIRST_TRACK: do_first_track(&media_player, false); mpl_set_state(MEDIA_PROXY_STATE_PAUSED); break; case MEDIA_PROXY_OP_LAST_TRACK: do_last_track(&media_player); mpl_set_state(MEDIA_PROXY_STATE_PAUSED); break; case MEDIA_PROXY_OP_GOTO_TRACK: if (command->use_param) { do_goto_track(&media_player, command->param); mpl_set_state(MEDIA_PROXY_STATE_PAUSED); } else { result_code = MEDIA_PROXY_CMD_CANNOT_BE_COMPLETED; } break; case MEDIA_PROXY_OP_PREV_GROUP: do_full_prev_group(&media_player); mpl_set_state(MEDIA_PROXY_STATE_PAUSED); break; case MEDIA_PROXY_OP_NEXT_GROUP: do_full_next_group(&media_player); mpl_set_state(MEDIA_PROXY_STATE_PAUSED); break; case MEDIA_PROXY_OP_FIRST_GROUP: do_full_first_group(&media_player); mpl_set_state(MEDIA_PROXY_STATE_PAUSED); break; case MEDIA_PROXY_OP_LAST_GROUP: do_full_last_group(&media_player); mpl_set_state(MEDIA_PROXY_STATE_PAUSED); break; case MEDIA_PROXY_OP_GOTO_GROUP: if (command->use_param) { do_full_goto_group(&media_player, command->param); mpl_set_state(MEDIA_PROXY_STATE_PAUSED); } else { result_code = MEDIA_PROXY_CMD_CANNOT_BE_COMPLETED; } break; default: LOG_DBG("Invalid command: %d", command->opcode); result_code = MEDIA_PROXY_CMD_NOT_SUPPORTED; break; } return result_code; } static uint8_t playing_state_command_handler(const struct mpl_cmd *command) { uint8_t result_code = MEDIA_PROXY_CMD_SUCCESS; LOG_DBG("Command opcode: %d", command->opcode); if (IS_ENABLED(CONFIG_BT_MPL_LOG_LEVEL_DBG)) { if (command->use_param) { LOG_DBG("Command parameter: %d", command->param); } } switch (command->opcode) { case MEDIA_PROXY_OP_PLAY: /* Continue playing - i.e. do nothing */ break; case MEDIA_PROXY_OP_PAUSE: mpl_set_state(MEDIA_PROXY_STATE_PAUSED); break; case MEDIA_PROXY_OP_FAST_REWIND: /* We're in playing state, seeking speed must have been zero */ media_player.seeking_speed_factor = -MPL_SEEKING_SPEED_FACTOR_STEP; mpl_set_state(MEDIA_PROXY_STATE_SEEKING); media_proxy_pl_seeking_speed_cb(media_player.seeking_speed_factor); break; case MEDIA_PROXY_OP_FAST_FORWARD: /* We're in playing state, seeking speed must have been zero */ media_player.seeking_speed_factor = MPL_SEEKING_SPEED_FACTOR_STEP; mpl_set_state(MEDIA_PROXY_STATE_SEEKING); media_proxy_pl_seeking_speed_cb(media_player.seeking_speed_factor); break; case MEDIA_PROXY_OP_STOP: set_track_position(0); mpl_set_state(MEDIA_PROXY_STATE_PAUSED); break; case MEDIA_PROXY_OP_MOVE_RELATIVE: if (command->use_param) { set_relative_track_position(command->param); } else { result_code = MEDIA_PROXY_CMD_CANNOT_BE_COMPLETED; } break; case MEDIA_PROXY_OP_PREV_SEGMENT: /* Switch to previous segment if we are less than */ /* into the segment, otherwise go to start of segment */ if (media_player.track_pos - PREV_MARGIN < media_player.group->track->segment->pos) { do_prev_segment(&media_player); } set_track_position(media_player.group->track->segment->pos); break; case MEDIA_PROXY_OP_NEXT_SEGMENT: do_next_segment(&media_player); set_track_position(media_player.group->track->segment->pos); break; case MEDIA_PROXY_OP_FIRST_SEGMENT: do_first_segment(&media_player); set_track_position(media_player.group->track->segment->pos); break; case MEDIA_PROXY_OP_LAST_SEGMENT: do_last_segment(&media_player); set_track_position(media_player.group->track->segment->pos); break; case MEDIA_PROXY_OP_GOTO_SEGMENT: if (command->use_param) { if (command->param != 0) { do_goto_segment(&media_player, command->param); } /* If the argument to "goto segment" is zero, */ /* the segment shall stay the same, and the */ /* track position shall not change. */ } else { result_code = MEDIA_PROXY_CMD_CANNOT_BE_COMPLETED; } break; case MEDIA_PROXY_OP_PREV_TRACK: do_prev_track(&media_player); break; case MEDIA_PROXY_OP_NEXT_TRACK: do_next_track(&media_player); break; case MEDIA_PROXY_OP_FIRST_TRACK: do_first_track(&media_player, false); break; case MEDIA_PROXY_OP_LAST_TRACK: do_last_track(&media_player); break; case MEDIA_PROXY_OP_GOTO_TRACK: if (command->use_param) { do_goto_track(&media_player, command->param); } else { result_code = MEDIA_PROXY_CMD_CANNOT_BE_COMPLETED; } break; case MEDIA_PROXY_OP_PREV_GROUP: do_full_prev_group(&media_player); break; case MEDIA_PROXY_OP_NEXT_GROUP: do_full_next_group(&media_player); break; case MEDIA_PROXY_OP_FIRST_GROUP: do_full_first_group(&media_player); break; case MEDIA_PROXY_OP_LAST_GROUP: do_full_last_group(&media_player); break; case MEDIA_PROXY_OP_GOTO_GROUP: if (command->use_param) { do_full_goto_group(&media_player, command->param); } else { result_code = MEDIA_PROXY_CMD_CANNOT_BE_COMPLETED; } break; default: LOG_DBG("Invalid command: %d", command->opcode); result_code = MEDIA_PROXY_CMD_NOT_SUPPORTED; break; } return result_code; } static uint8_t paused_state_command_handler(const struct mpl_cmd *command) { uint8_t result_code = MEDIA_PROXY_CMD_SUCCESS; LOG_DBG("Command opcode: %d", command->opcode); if (IS_ENABLED(CONFIG_BT_MPL_LOG_LEVEL_DBG)) { if (command->use_param) { LOG_DBG("Command parameter: %d", command->param); } } switch (command->opcode) { case MEDIA_PROXY_OP_PLAY: mpl_set_state(MEDIA_PROXY_STATE_PLAYING); break; case MEDIA_PROXY_OP_PAUSE: /* No change */ break; case MEDIA_PROXY_OP_FAST_REWIND: /* We're in paused state, seeking speed must have been zero */ media_player.seeking_speed_factor = -MPL_SEEKING_SPEED_FACTOR_STEP; mpl_set_state(MEDIA_PROXY_STATE_SEEKING); media_proxy_pl_seeking_speed_cb(media_player.seeking_speed_factor); break; case MEDIA_PROXY_OP_FAST_FORWARD: /* We're in paused state, seeking speed must have been zero */ media_player.seeking_speed_factor = MPL_SEEKING_SPEED_FACTOR_STEP; mpl_set_state(MEDIA_PROXY_STATE_SEEKING); media_proxy_pl_seeking_speed_cb(media_player.seeking_speed_factor); break; case MEDIA_PROXY_OP_STOP: set_track_position(0); mpl_set_state(MEDIA_PROXY_STATE_PAUSED); break; case MEDIA_PROXY_OP_MOVE_RELATIVE: if (command->use_param) { set_relative_track_position(command->param); } else { result_code = MEDIA_PROXY_CMD_CANNOT_BE_COMPLETED; } break; case MEDIA_PROXY_OP_PREV_SEGMENT: /* Switch to previous segment if we are less than 5 seconds */ /* into the segment, otherwise go to start of segment */ if (media_player.group->track->segment != NULL) { if (media_player.track_pos - PREV_MARGIN < media_player.group->track->segment->pos) { do_prev_segment(&media_player); } set_track_position(media_player.group->track->segment->pos); } else { result_code = MEDIA_PROXY_CMD_CANNOT_BE_COMPLETED; } break; case MEDIA_PROXY_OP_NEXT_SEGMENT: if (media_player.group->track->segment != NULL) { do_next_segment(&media_player); set_track_position(media_player.group->track->segment->pos); } else { result_code = MEDIA_PROXY_CMD_CANNOT_BE_COMPLETED; } break; case MEDIA_PROXY_OP_FIRST_SEGMENT: if (media_player.group->track->segment != NULL) { do_first_segment(&media_player); set_track_position(media_player.group->track->segment->pos); } else { result_code = MEDIA_PROXY_CMD_CANNOT_BE_COMPLETED; } break; case MEDIA_PROXY_OP_LAST_SEGMENT: if (media_player.group->track->segment != NULL) { do_last_segment(&media_player); set_track_position(media_player.group->track->segment->pos); } else { result_code = MEDIA_PROXY_CMD_CANNOT_BE_COMPLETED; } break; case MEDIA_PROXY_OP_GOTO_SEGMENT: if (command->use_param && media_player.group->track->segment != NULL) { if (command->param != 0) { do_goto_segment(&media_player, command->param); } /* If the argument to "goto segment" is zero, */ /* the segment shall stay the same, and the */ /* track position shall not change. */ } else { result_code = MEDIA_PROXY_CMD_CANNOT_BE_COMPLETED; } break; case MEDIA_PROXY_OP_PREV_TRACK: do_prev_track(&media_player); break; case MEDIA_PROXY_OP_NEXT_TRACK: do_next_track(&media_player); /* For next track, the position is kept if the track */ /* does not change */ break; case MEDIA_PROXY_OP_FIRST_TRACK: do_first_track(&media_player, false); break; case MEDIA_PROXY_OP_LAST_TRACK: do_last_track(&media_player); break; case MEDIA_PROXY_OP_GOTO_TRACK: if (command->use_param) { do_goto_track(&media_player, command->param); } else { result_code = MEDIA_PROXY_CMD_CANNOT_BE_COMPLETED; } break; case MEDIA_PROXY_OP_PREV_GROUP: do_full_prev_group(&media_player); break; case MEDIA_PROXY_OP_NEXT_GROUP: do_full_next_group(&media_player); break; case MEDIA_PROXY_OP_FIRST_GROUP: do_full_first_group(&media_player); break; case MEDIA_PROXY_OP_LAST_GROUP: do_full_last_group(&media_player); break; case MEDIA_PROXY_OP_GOTO_GROUP: if (command->use_param) { do_full_goto_group(&media_player, command->param); } else { result_code = MEDIA_PROXY_CMD_CANNOT_BE_COMPLETED; } break; default: LOG_DBG("Invalid command: %d", command->opcode); result_code = MEDIA_PROXY_CMD_NOT_SUPPORTED; break; } return result_code; } static uint8_t seeking_state_command_handler(const struct mpl_cmd *command) { uint8_t result_code = MEDIA_PROXY_CMD_SUCCESS; LOG_DBG("Command opcode: %d", command->opcode); if (IS_ENABLED(CONFIG_BT_MPL_LOG_LEVEL_DBG)) { if (command->use_param) { LOG_DBG("Command parameter: %d", command->param); } } switch (command->opcode) { case MEDIA_PROXY_OP_PLAY: media_player.seeking_speed_factor = MEDIA_PROXY_SEEKING_SPEED_FACTOR_ZERO; mpl_set_state(MEDIA_PROXY_STATE_PLAYING); media_proxy_pl_seeking_speed_cb(media_player.seeking_speed_factor); break; case MEDIA_PROXY_OP_PAUSE: media_player.seeking_speed_factor = MEDIA_PROXY_SEEKING_SPEED_FACTOR_ZERO; /* TODO: Set track and track position */ mpl_set_state(MEDIA_PROXY_STATE_PAUSED); media_proxy_pl_seeking_speed_cb(media_player.seeking_speed_factor); break; case MEDIA_PROXY_OP_FAST_REWIND: /* TODO: Here, and for FAST_FORWARD */ /* Decide on algorithm for multiple presses - add step (as */ /* now) or double/half? */ /* What about FR followed by FF? */ /* Currently, the seeking speed may also become zero */ /* Lowest value allowed by spec is -64, notify on change only */ if (media_player.seeking_speed_factor >= -(MEDIA_PROXY_SEEKING_SPEED_FACTOR_MAX - MPL_SEEKING_SPEED_FACTOR_STEP)) { media_player.seeking_speed_factor -= MPL_SEEKING_SPEED_FACTOR_STEP; media_proxy_pl_seeking_speed_cb(media_player.seeking_speed_factor); } break; case MEDIA_PROXY_OP_FAST_FORWARD: /* Highest value allowed by spec is 64, notify on change only */ if (media_player.seeking_speed_factor <= (MEDIA_PROXY_SEEKING_SPEED_FACTOR_MAX - MPL_SEEKING_SPEED_FACTOR_STEP)) { media_player.seeking_speed_factor += MPL_SEEKING_SPEED_FACTOR_STEP; media_proxy_pl_seeking_speed_cb(media_player.seeking_speed_factor); } break; case MEDIA_PROXY_OP_STOP: media_player.seeking_speed_factor = MEDIA_PROXY_SEEKING_SPEED_FACTOR_ZERO; set_track_position(0); mpl_set_state(MEDIA_PROXY_STATE_PAUSED); media_proxy_pl_seeking_speed_cb(media_player.seeking_speed_factor); break; case MEDIA_PROXY_OP_MOVE_RELATIVE: if (command->use_param) { set_relative_track_position(command->param); } else { result_code = MEDIA_PROXY_CMD_CANNOT_BE_COMPLETED; } break; case MEDIA_PROXY_OP_PREV_SEGMENT: /* Switch to previous segment if we are less than 5 seconds */ /* into the segment, otherwise go to start of segment */ if (media_player.track_pos - PREV_MARGIN < media_player.group->track->segment->pos) { do_prev_segment(&media_player); } set_track_position(media_player.group->track->segment->pos); break; case MEDIA_PROXY_OP_NEXT_SEGMENT: do_next_segment(&media_player); set_track_position(media_player.group->track->segment->pos); break; case MEDIA_PROXY_OP_FIRST_SEGMENT: do_first_segment(&media_player); set_track_position(media_player.group->track->segment->pos); break; case MEDIA_PROXY_OP_LAST_SEGMENT: do_last_segment(&media_player); set_track_position(media_player.group->track->segment->pos); break; case MEDIA_PROXY_OP_GOTO_SEGMENT: if (command->use_param) { if (command->param != 0) { do_goto_segment(&media_player, command->param); } /* If the argument to "goto segment" is zero, */ /* the segment shall stay the same, and the */ /* track position shall not change. */ } else { result_code = MEDIA_PROXY_CMD_CANNOT_BE_COMPLETED; } break; case MEDIA_PROXY_OP_PREV_TRACK: do_prev_track(&media_player); media_player.seeking_speed_factor = MEDIA_PROXY_SEEKING_SPEED_FACTOR_ZERO; mpl_set_state(MEDIA_PROXY_STATE_PAUSED); break; case MEDIA_PROXY_OP_NEXT_TRACK: do_next_track(&media_player); /* For next track, the position is kept if the track */ /* does not change */ media_player.seeking_speed_factor = MEDIA_PROXY_SEEKING_SPEED_FACTOR_ZERO; mpl_set_state(MEDIA_PROXY_STATE_PAUSED); break; case MEDIA_PROXY_OP_FIRST_TRACK: do_first_track(&media_player, false); media_player.seeking_speed_factor = MEDIA_PROXY_SEEKING_SPEED_FACTOR_ZERO; mpl_set_state(MEDIA_PROXY_STATE_PAUSED); break; case MEDIA_PROXY_OP_LAST_TRACK: do_last_track(&media_player); media_player.seeking_speed_factor = MEDIA_PROXY_SEEKING_SPEED_FACTOR_ZERO; mpl_set_state(MEDIA_PROXY_STATE_PAUSED); break; case MEDIA_PROXY_OP_GOTO_TRACK: if (command->use_param) { do_goto_track(&media_player, command->param); media_player.seeking_speed_factor = MEDIA_PROXY_SEEKING_SPEED_FACTOR_ZERO; mpl_set_state(MEDIA_PROXY_STATE_PAUSED); } else { result_code = MEDIA_PROXY_CMD_CANNOT_BE_COMPLETED; } break; case MEDIA_PROXY_OP_PREV_GROUP: do_full_prev_group(&media_player); mpl_set_state(MEDIA_PROXY_STATE_PAUSED); break; case MEDIA_PROXY_OP_NEXT_GROUP: do_full_next_group(&media_player); mpl_set_state(MEDIA_PROXY_STATE_PAUSED); break; case MEDIA_PROXY_OP_FIRST_GROUP: do_full_first_group(&media_player); mpl_set_state(MEDIA_PROXY_STATE_PAUSED); break; case MEDIA_PROXY_OP_LAST_GROUP: do_full_last_group(&media_player); mpl_set_state(MEDIA_PROXY_STATE_PAUSED); break; case MEDIA_PROXY_OP_GOTO_GROUP: if (command->use_param) { do_full_goto_group(&media_player, command->param); mpl_set_state(MEDIA_PROXY_STATE_PAUSED); } else { result_code = MEDIA_PROXY_CMD_CANNOT_BE_COMPLETED; } break; default: LOG_DBG("Invalid command: %d", command->opcode); result_code = MEDIA_PROXY_CMD_NOT_SUPPORTED; break; } return result_code; } static uint8_t (*command_handlers[MEDIA_PROXY_STATE_LAST])(const struct mpl_cmd *command) = { inactive_state_command_handler, playing_state_command_handler, paused_state_command_handler, seeking_state_command_handler, }; #ifdef CONFIG_BT_MPL_OBJECTS /* Find a track by ID * * If found, return pointers to the group of the track and the track, * otherwise, the pointers returned are NULL * * Returns true if found, false otherwise */ static bool find_track_by_id(const struct mpl_mediaplayer *pl, uint64_t id, struct mpl_group **group, struct mpl_track **track) { struct mpl_group *tmp_group = pl->group; struct mpl_track *tmp_track; while (tmp_group->prev != NULL) { tmp_group = tmp_group->prev; } while (tmp_group != NULL) { tmp_track = tmp_group->track; while (tmp_track->prev != NULL) { tmp_track = tmp_track->prev; } while (tmp_track != 0) { if (tmp_track->id == id) { /* Found the track */ *group = tmp_group; *track = tmp_track; return true; } tmp_track = tmp_track->next; } tmp_group = tmp_group->next; } /* Track not found */ *group = NULL; *track = NULL; return false; } /* Find a group by ID * * If found, return pointer to the group, otherwise, the pointer returned is NULL * * Returns true if found, false otherwise */ static bool find_group_by_id(const struct mpl_mediaplayer *pl, uint64_t id, struct mpl_group **group) { struct mpl_group *tmp_group = pl->group; while (tmp_group->prev != NULL) { tmp_group = tmp_group->prev; } while (tmp_group != NULL) { if (tmp_group->id == id) { /* Found the group */ *group = tmp_group; return true; } tmp_group = tmp_group->next; } /* Group not found */ *group = NULL; return false; } #endif /* CONFIG_BT_MPL_OBJECTS */ static const char *get_player_name(void) { return media_player.name; } #ifdef CONFIG_BT_MPL_OBJECTS static uint64_t get_icon_id(void) { return media_player.icon_id; } #endif /* CONFIG_BT_MPL_OBJECTS */ static const char *get_icon_url(void) { return media_player.icon_url; } static const char *get_track_title(void) { return media_player.group->track->title; } static int32_t get_track_duration(void) { return media_player.group->track->duration; } static int32_t get_track_position(void) { return media_player.track_pos; } static void set_track_position(int32_t position) { int32_t old_pos = media_player.track_pos; int32_t new_pos; if (position >= 0) { if (position > media_player.group->track->duration) { /* Do not go beyond end of track */ new_pos = media_player.group->track->duration; } else { new_pos = position; } } else { /* Negative position, handle as offset from _end_ of track */ /* (Note minus sign below) */ if (position < -media_player.group->track->duration) { new_pos = 0; } else { /* (Remember position is negative) */ new_pos = media_player.group->track->duration + position; } } LOG_DBG("Pos. given: %d, resulting pos.: %d (duration is %d)", position, new_pos, media_player.group->track->duration); /* Notify when the position changes when not in the playing state, or if the position is set * to 0 which is a special value that typically indicates that the track has stopped or * changed. Since this might occur when media_player.group->track->duration is still 0, we * should always notify this value. */ if (new_pos != old_pos || new_pos == 0) { /* Set new position and notify it */ media_player.track_pos = new_pos; /* MCS 1.0, section 3.7.1, states: * to avoid an excessive number of notifications, the Track Position should * not be notified when the Media State is set to “Playing” and playback happens * at a constant speed. */ if (media_player.state != MEDIA_PROXY_STATE_PLAYING) { media_proxy_pl_track_position_cb(new_pos); } } } static void set_relative_track_position(int32_t rel_pos) { int64_t pos; pos = media_player.track_pos + rel_pos; /* Clamp to allowed values */ pos = CLAMP(pos, 0, media_player.group->track->duration); set_track_position((int32_t)pos); } static int8_t get_playback_speed(void) { return media_player.playback_speed_param; } static void set_playback_speed(int8_t speed) { /* Set new speed parameter and notify, if different from current */ if (speed != media_player.playback_speed_param) { media_player.playback_speed_param = speed; media_proxy_pl_playback_speed_cb(media_player.playback_speed_param); } } static int8_t get_seeking_speed(void) { return media_player.seeking_speed_factor; } #ifdef CONFIG_BT_MPL_OBJECTS static uint64_t get_track_segments_id(void) { return media_player.group->track->segments_id; } static uint64_t get_current_track_id(void) { return media_player.group->track->id; } static void set_current_track_id(uint64_t id) { struct mpl_group *group; struct mpl_track *track; LOG_DBG_OBJ_ID("Track ID to set: ", id); if (find_track_by_id(&media_player, id, &group, &track)) { if (media_player.group != group) { media_player.group = group; do_group_change_notifications(&media_player); /* Group change implies track change (even if same track in other group) */ media_player.group->track = track; do_track_change_notifications(&media_player); } else if (media_player.group->track != track) { media_player.group->track = track; do_track_change_notifications(&media_player); } return; } LOG_DBG("Track not found"); /* TODO: Should an error be returned here? * That would require a rewrite of the MPL api to add return values to the functions. */ } static uint64_t get_next_track_id(void) { /* If the next track has been set explicitly */ if (media_player.next_track_set) { return media_player.next.track->id; } /* Normal playing order */ if (media_player.group->track->next) { return media_player.group->track->next->id; } /* Return zero value to indicate that there is no next track */ return MPL_NO_TRACK_ID; } static void set_next_track_id(uint64_t id) { struct mpl_group *group; struct mpl_track *track; LOG_DBG_OBJ_ID("Next Track ID to set: ", id); if (find_track_by_id(&media_player, id, &group, &track)) { media_player.next_track_set = true; media_player.next.group = group; media_player.next.track = track; media_proxy_pl_next_track_id_cb(id); return; } LOG_DBG("Track not found"); } static uint64_t get_parent_group_id(void) { return media_player.group->parent->id; } static uint64_t get_current_group_id(void) { return media_player.group->id; } static void set_current_group_id(uint64_t id) { struct mpl_group *group; LOG_DBG_OBJ_ID("Group ID to set: ", id); if (find_group_by_id(&media_player, id, &group)) { if (media_player.group != group) { /* Change to found group */ media_player.group = group; do_group_change_notifications(&media_player); /* And change to first track in group */ do_first_track(&media_player, false); } return; } LOG_DBG("Group not found"); } #endif /* CONFIG_BT_MPL_OBJECTS */ static uint8_t get_playing_order(void) { return media_player.playing_order; } static void set_playing_order(uint8_t order) { if (order != media_player.playing_order) { if (BIT(order - 1) & media_player.playing_orders_supported) { media_player.playing_order = order; media_proxy_pl_playing_order_cb(media_player.playing_order); } } } static uint16_t get_playing_orders_supported(void) { return media_player.playing_orders_supported; } static uint8_t get_media_state(void) { return media_player.state; } static void send_command(const struct mpl_cmd *command) { struct mpl_cmd_ntf ntf; if (command->use_param) { LOG_DBG("opcode: %d, param: %d", command->opcode, command->param); } else { LOG_DBG("opcode: %d", command->opcode); } if (media_player.state < MEDIA_PROXY_STATE_LAST) { ntf.requested_opcode = command->opcode; ntf.result_code = command_handlers[media_player.state](command); media_proxy_pl_command_cb(&ntf); } else { LOG_DBG("INVALID STATE"); } } static uint32_t get_commands_supported(void) { return media_player.opcodes_supported; } #ifdef CONFIG_BT_MPL_OBJECTS static bool parse_sci(struct bt_data *data, void *user_data) { LOG_DBG("type: %u len %u", data->type, data->data_len); LOG_HEXDUMP_DBG(data->data, data->data_len, "param:"); if (data->type < MEDIA_PROXY_SEARCH_TYPE_TRACK_NAME || data->type > MEDIA_PROXY_SEARCH_TYPE_ONLY_GROUPS) { LOG_DBG("Invalid search type: %u", data->type); return false; } return true; } static void parse_search(const struct mpl_search *search) { bool search_failed = false; if (search->len > SEARCH_LEN_MAX) { LOG_WRN("Search too long (%d) - aborting", search->len); search_failed = true; } else { uint8_t search_ltv[SEARCH_LEN_MAX]; struct net_buf_simple buf; /* Copy so that we can parse it using the net_buf_simple when search is const */ memcpy(search_ltv, search->search, search->len); net_buf_simple_init_with_data(&buf, search_ltv, search->len); bt_data_parse(&buf, parse_sci, NULL); if (buf.len != 0U) { search_failed = true; } } /* TODO: Add real search functionality. */ /* For now, just fake it. */ if (search_failed) { media_player.search_results_id = 0; media_proxy_pl_search_cb(MEDIA_PROXY_SEARCH_FAILURE); } else { /* Use current group as search result for now */ media_player.search_results_id = media_player.group->id; media_proxy_pl_search_cb(MEDIA_PROXY_SEARCH_SUCCESS); } media_proxy_pl_search_results_id_cb(media_player.search_results_id); } static void send_search(const struct mpl_search *search) { if (search->len > SEARCH_LEN_MAX) { LOG_WRN("Search too long: %d", search->len); } LOG_HEXDUMP_DBG(search->search, search->len, "Search"); parse_search(search); } static uint64_t get_search_results_id(void) { return media_player.search_results_id; } #endif /* CONFIG_BT_MPL_OBJECTS */ static uint8_t get_content_ctrl_id(void) { return media_player.content_ctrl_id; } static void pos_work_cb(struct k_work *work) { const int32_t pos_diff_cs = TRACK_POS_WORK_DELAY_MS / 10; /* position is in centiseconds*/ if (media_player.state == MEDIA_PROXY_STATE_SEEKING) { /* When seeking, apply the seeking speed factor */ set_relative_track_position(pos_diff_cs * media_player.seeking_speed_factor); } else if (media_player.state == MEDIA_PROXY_STATE_PLAYING) { set_relative_track_position(pos_diff_cs); } if (media_player.track_pos == media_player.group->track->duration) { /* Go to next track */ do_next_track(&media_player); } (void)k_work_schedule(&media_player.pos_work, TRACK_POS_WORK_DELAY); } int media_proxy_pl_init(void) { static bool initialized; int ret; if (initialized) { LOG_DBG("Already initialized"); return -EALREADY; } /* Set up the media control service */ /* TODO: Fix initialization - who initializes what * https://github.com/zephyrproject-rtos/zephyr/issues/42965 * Temporarily only initializing if service is present */ #ifdef CONFIG_BT_MCS #ifdef CONFIG_BT_MPL_OBJECTS ret = bt_mcs_init(&ots_cbs); #else ret = bt_mcs_init(NULL); #endif /* CONFIG_BT_MPL_OBJECTS */ if (ret < 0) { LOG_ERR("Could not init MCS: %d", ret); return ret; } #else LOG_WRN("MCS not configured"); #endif /* CONFIG_BT_MCS */ /* Get a Content Control ID */ media_player.content_ctrl_id = bt_ccid_get_value(); #ifdef CONFIG_BT_MPL_OBJECTS /* Initialize the object content buffer */ net_buf_simple_init(obj.content, 0); /* Icon Object */ ret = add_icon_object(&media_player); if (ret < 0) { LOG_ERR("Unable to add icon object, error %d", ret); return ret; } /* Add all tracks and groups to OTS */ ret = add_group_and_track_objects(&media_player); if (ret < 0) { LOG_ERR("Error adding tracks and groups to OTS, error %d", ret); return ret; } /* Initial setup of Track Segments Object */ /* TODO: Later, this should be done when the tracks are added */ /* but for no only one of the tracks has segments .*/ ret = add_current_track_segments_object(&media_player); if (ret < 0) { LOG_ERR("Error adding Track Segments Object to OTS, error %d", ret); return ret; } #endif /* CONFIG_BT_MPL_OBJECTS */ /* Set up the calls structure */ media_player.calls.get_player_name = get_player_name; #ifdef CONFIG_BT_MPL_OBJECTS media_player.calls.get_icon_id = get_icon_id; #endif /* CONFIG_BT_MPL_OBJECTS */ media_player.calls.get_icon_url = get_icon_url; media_player.calls.get_track_title = get_track_title; media_player.calls.get_track_duration = get_track_duration; media_player.calls.get_track_position = get_track_position; media_player.calls.set_track_position = set_track_position; media_player.calls.get_playback_speed = get_playback_speed; media_player.calls.set_playback_speed = set_playback_speed; media_player.calls.get_seeking_speed = get_seeking_speed; #ifdef CONFIG_BT_MPL_OBJECTS media_player.calls.get_track_segments_id = get_track_segments_id; media_player.calls.get_current_track_id = get_current_track_id; media_player.calls.set_current_track_id = set_current_track_id; media_player.calls.get_next_track_id = get_next_track_id; media_player.calls.set_next_track_id = set_next_track_id; media_player.calls.get_parent_group_id = get_parent_group_id; media_player.calls.get_current_group_id = get_current_group_id; media_player.calls.set_current_group_id = set_current_group_id; #endif /* CONFIG_BT_MPL_OBJECTS */ media_player.calls.get_playing_order = get_playing_order; media_player.calls.set_playing_order = set_playing_order; media_player.calls.get_playing_orders_supported = get_playing_orders_supported; media_player.calls.get_media_state = get_media_state; media_player.calls.send_command = send_command; media_player.calls.get_commands_supported = get_commands_supported; #ifdef CONFIG_BT_MPL_OBJECTS media_player.calls.send_search = send_search; media_player.calls.get_search_results_id = get_search_results_id; #endif /* CONFIG_BT_MPL_OBJECTS */ media_player.calls.get_content_ctrl_id = get_content_ctrl_id; ret = media_proxy_pl_register(&media_player.calls); if (ret < 0) { LOG_ERR("Unable to register player"); return ret; } k_work_init_delayable(&media_player.pos_work, pos_work_cb); initialized = true; return 0; } #if CONFIG_BT_MPL_LOG_LEVEL_DBG /* Special commands for debugging */ void mpl_debug_dump_state(void) { #if CONFIG_BT_MPL_OBJECTS char t[BT_OTS_OBJ_ID_STR_LEN]; struct mpl_group *group; struct mpl_track *track; #endif /* CONFIG_BT_MPL_OBJECTS */ LOG_DBG("Mediaplayer name: %s", media_player.name); #if CONFIG_BT_MPL_OBJECTS (void)bt_ots_obj_id_to_str(media_player.icon_id, t, sizeof(t)); LOG_DBG("Icon ID: %s", t); #endif /* CONFIG_BT_MPL_OBJECTS */ LOG_DBG("Icon URL: %s", media_player.icon_url); LOG_DBG("Track position: %d", media_player.track_pos); LOG_DBG("Media state: %d", media_player.state); LOG_DBG("Playback speed parameter: %d", media_player.playback_speed_param); LOG_DBG("Seeking speed factor: %d", media_player.seeking_speed_factor); LOG_DBG("Playing order: %d", media_player.playing_order); LOG_DBG("Playing orders supported: 0x%x", media_player.playing_orders_supported); LOG_DBG("Opcodes supported: %d", media_player.opcodes_supported); LOG_DBG("Content control ID: %d", media_player.content_ctrl_id); #if CONFIG_BT_MPL_OBJECTS (void)bt_ots_obj_id_to_str(media_player.group->parent->id, t, sizeof(t)); LOG_DBG("Current group's parent: %s", t); (void)bt_ots_obj_id_to_str(media_player.group->id, t, sizeof(t)); LOG_DBG("Current group: %s", t); (void)bt_ots_obj_id_to_str(media_player.group->track->id, t, sizeof(t)); LOG_DBG("Current track: %s", t); if (media_player.next_track_set) { (void)bt_ots_obj_id_to_str(media_player.next.track->id, t, sizeof(t)); LOG_DBG("Next track: %s", t); } else if (media_player.group->track->next) { (void)bt_ots_obj_id_to_str(media_player.group->track->next->id, t, sizeof(t)); LOG_DBG("Next track: %s", t); } else { LOG_DBG("No next track"); } if (media_player.search_results_id) { (void)bt_ots_obj_id_to_str(media_player.search_results_id, t, sizeof(t)); LOG_DBG("Search results: %s", t); } else { LOG_DBG("No search results"); } LOG_DBG("Groups and tracks:"); group = media_player.group; while (group->prev != NULL) { group = group->prev; } while (group) { (void)bt_ots_obj_id_to_str(group->id, t, sizeof(t)); LOG_DBG("Group: %s, %s", t, group->title); (void)bt_ots_obj_id_to_str(group->parent->id, t, sizeof(t)); LOG_DBG("\tParent: %s, %s", t, group->parent->title); track = group->track; while (track->prev != NULL) { track = track->prev; } while (track) { (void)bt_ots_obj_id_to_str(track->id, t, sizeof(t)); LOG_DBG("\tTrack: %s, %s, duration: %d", t, track->title, track->duration); track = track->next; } group = group->next; } #endif /* CONFIG_BT_MPL_OBJECTS */ } #endif /* CONFIG_BT_MPL_LOG_LEVEL_DBG */ #if defined(CONFIG_BT_MPL_LOG_LEVEL_DBG) && \ defined(CONFIG_BT_TESTING) /* Special commands for testing */ #if CONFIG_BT_MPL_OBJECTS void mpl_test_unset_parent_group(void) { LOG_DBG("Setting current group to be it's own parent"); media_player.group->parent = media_player.group; } #endif /* CONFIG_BT_MPL_OBJECTS */ void mpl_test_media_state_set(uint8_t state) { mpl_set_state(state); } void mpl_test_player_name_changed_cb(void) { media_proxy_pl_name_cb(media_player.name); } void mpl_test_player_icon_url_changed_cb(void) { media_proxy_pl_icon_url_cb(media_player.icon_url); } void mpl_test_track_changed_cb(void) { media_proxy_pl_track_changed_cb(); } void mpl_test_title_changed_cb(void) { media_proxy_pl_track_title_cb(media_player.group->track->title); } void mpl_test_duration_changed_cb(void) { media_proxy_pl_track_duration_cb(media_player.group->track->duration); } void mpl_test_position_changed_cb(void) { media_proxy_pl_track_position_cb(media_player.track_pos); } void mpl_test_playback_speed_changed_cb(void) { media_proxy_pl_playback_speed_cb(media_player.playback_speed_param); } void mpl_test_seeking_speed_changed_cb(void) { media_proxy_pl_seeking_speed_cb(media_player.seeking_speed_factor); } #ifdef CONFIG_BT_MPL_OBJECTS void mpl_test_current_track_id_changed_cb(void) { media_proxy_pl_current_track_id_cb(media_player.group->track->id); } void mpl_test_next_track_id_changed_cb(void) { media_proxy_pl_next_track_id_cb(media_player.group->track->next->id); } void mpl_test_parent_group_id_changed_cb(void) { media_proxy_pl_parent_group_id_cb(media_player.group->id); } void mpl_test_current_group_id_changed_cb(void) { media_proxy_pl_current_group_id_cb(media_player.group->id); } #endif /* CONFIG_BT_MPL_OBJECTS */ void mpl_test_playing_order_changed_cb(void) { media_proxy_pl_playing_order_cb(media_player.playing_order); } void mpl_test_media_state_changed_cb(void) { media_proxy_pl_media_state_cb(media_player.playing_order); } void mpl_test_opcodes_supported_changed_cb(void) { media_proxy_pl_commands_supported_cb(media_player.opcodes_supported); } #ifdef CONFIG_BT_MPL_OBJECTS void mpl_test_search_results_changed_cb(void) { media_proxy_pl_search_cb(media_player.search_results_id); } #endif /* CONFIG_BT_MPL_OBJECTS */ #endif /* CONFIG_BT_MPL_LOG_LEVEL_DBG && CONFIG_BT_TESTING */