M7350/external/bluetooth/bluez/android/client/if-rc.c
2024-09-09 08:57:42 +00:00

400 lines
9.4 KiB
C

/*
* Copyright (C) 2014 Intel Corporation
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*
*/
#include<stdio.h>
#include<ctype.h>
#include<hardware/bluetooth.h>
#include<hardware/bt_hh.h>
#include "if-main.h"
#include "pollhandler.h"
#include "../hal-utils.h"
const btrc_interface_t *if_rc = NULL;
SINTMAP(btrc_play_status_t, -1, "(unknown)")
DELEMENT(BTRC_PLAYSTATE_STOPPED),
DELEMENT(BTRC_PLAYSTATE_PLAYING),
DELEMENT(BTRC_PLAYSTATE_PAUSED),
DELEMENT(BTRC_PLAYSTATE_FWD_SEEK),
DELEMENT(BTRC_PLAYSTATE_REV_SEEK),
DELEMENT(BTRC_PLAYSTATE_ERROR),
ENDMAP
SINTMAP(btrc_media_attr_t, -1, "(unknown)")
DELEMENT(BTRC_MEDIA_ATTR_TITLE),
DELEMENT(BTRC_MEDIA_ATTR_ARTIST),
DELEMENT(BTRC_MEDIA_ATTR_ALBUM),
DELEMENT(BTRC_MEDIA_ATTR_TRACK_NUM),
DELEMENT(BTRC_MEDIA_ATTR_NUM_TRACKS),
DELEMENT(BTRC_MEDIA_ATTR_GENRE),
DELEMENT(BTRC_MEDIA_ATTR_PLAYING_TIME),
ENDMAP
SINTMAP(btrc_status_t, -1, "(unknown)")
DELEMENT(BTRC_STS_BAD_CMD),
DELEMENT(BTRC_STS_BAD_PARAM),
DELEMENT(BTRC_STS_NOT_FOUND),
DELEMENT(BTRC_STS_INTERNAL_ERR),
DELEMENT(BTRC_STS_NO_ERROR),
ENDMAP
SINTMAP(btrc_event_id_t, -1, "(unknown)")
DELEMENT(BTRC_EVT_PLAY_STATUS_CHANGED),
DELEMENT(BTRC_EVT_TRACK_CHANGE),
DELEMENT(BTRC_EVT_TRACK_REACHED_END),
DELEMENT(BTRC_EVT_TRACK_REACHED_START),
DELEMENT(BTRC_EVT_PLAY_POS_CHANGED),
DELEMENT(BTRC_EVT_APP_SETTINGS_CHANGED),
ENDMAP
SINTMAP(btrc_notification_type_t, -1, "(unknown)")
DELEMENT(BTRC_NOTIFICATION_TYPE_INTERIM),
DELEMENT(BTRC_NOTIFICATION_TYPE_CHANGED),
ENDMAP
static char last_addr[MAX_ADDR_STR_LEN];
static void remote_features_cb(bt_bdaddr_t *bd_addr,
btrc_remote_features_t features)
{
haltest_info("%s: remote_bd_addr=%s features=%u\n", __func__,
bt_bdaddr_t2str(bd_addr, last_addr), features);
}
static void get_play_status_cb(void)
{
haltest_info("%s\n", __func__);
}
static void list_player_app_attr_cb(void)
{
haltest_info("%s\n", __func__);
}
static void list_player_app_values_cb(btrc_player_attr_t attr_id)
{
haltest_info("%s, attr_id=%d\n", __func__, attr_id);
}
static void get_player_app_value_cb(uint8_t num_attr,
btrc_player_attr_t *p_attrs)
{
int i;
haltest_info("%s, num_attr=%d\n", __func__, num_attr);
for (i = 0; i < num_attr; i++)
haltest_info("attribute=%u\n", p_attrs[i]);
}
static void get_player_app_attrs_text_cb(uint8_t num_attr,
btrc_player_attr_t *p_attrs)
{
int i;
haltest_info("%s, num_attr=%d\n", __func__, num_attr);
for (i = 0; i < num_attr; i++)
haltest_info("attribute=%u\n", p_attrs[i]);
}
static void get_player_app_values_text_cb(uint8_t attr_id, uint8_t num_val,
uint8_t *p_vals)
{
haltest_info("%s, attr_id=%d num_val=%d values=%p\n", __func__,
attr_id, num_val, p_vals);
}
static void set_player_app_value_cb(btrc_player_settings_t *p_vals)
{
int i;
haltest_info("%s, num_attr=%u\n", __func__, p_vals->num_attr);
for (i = 0; i < p_vals->num_attr; i++)
haltest_info("attr id=%u, values=%u\n", p_vals->attr_ids[i],
p_vals->attr_values[i]);
}
static void get_element_attr_cb(uint8_t num_attr, btrc_media_attr_t *attrs)
{
uint8_t i;
haltest_info("%s, num_of_attributes=%d\n", __func__, num_attr);
for (i = 0; i < num_attr; i++)
haltest_info("attr id=%s\n", btrc_media_attr_t2str(attrs[i]));
}
static void register_notification_cb(btrc_event_id_t event_id, uint32_t param)
{
haltest_info("%s, event=%u param=%u\n", __func__, event_id, param);
}
static void volume_change_cb(uint8_t volume, uint8_t ctype)
{
haltest_info("%s, volume=%d ctype=%d\n", __func__, volume, ctype);
}
static void passthrough_cmd_cb(int id, int key_state)
{
haltest_info("%s, id=%d key_state=%d\n", __func__, id, key_state);
}
static btrc_callbacks_t rc_cbacks = {
.size = sizeof(rc_cbacks),
.remote_features_cb = remote_features_cb,
.get_play_status_cb = get_play_status_cb,
.list_player_app_attr_cb = list_player_app_attr_cb,
.list_player_app_values_cb = list_player_app_values_cb,
.get_player_app_value_cb = get_player_app_value_cb,
.get_player_app_attrs_text_cb = get_player_app_attrs_text_cb,
.get_player_app_values_text_cb = get_player_app_values_text_cb,
.set_player_app_value_cb = set_player_app_value_cb,
.get_element_attr_cb = get_element_attr_cb,
.register_notification_cb = register_notification_cb,
.volume_change_cb = volume_change_cb,
.passthrough_cmd_cb = passthrough_cmd_cb,
};
/* init */
static void init_p(int argc, const char **argv)
{
RETURN_IF_NULL(if_rc);
EXEC(if_rc->init, &rc_cbacks);
}
/* get_play_status_rsp */
static void get_play_status_rsp_c(int argc, const char **argv,
enum_func *enum_func, void **user)
{
if (argc == 3) {
*user = TYPE_ENUM(btrc_play_status_t);
*enum_func = enum_defines;
}
}
static void get_play_status_rsp_p(int argc, const char **argv)
{
btrc_play_status_t play_status;
uint32_t song_len, song_pos;
RETURN_IF_NULL(if_rc);
if (argc <= 2) {
haltest_error("No play status specified");
return;
}
if (argc <= 3) {
haltest_error("No song length specified");
return;
}
if (argc <= 4) {
haltest_error("No song position specified");
return;
}
play_status = str2btrc_play_status_t(argv[2]);
song_len = (uint32_t) atoi(argv[3]);
song_pos = (uint32_t) atoi(argv[4]);
EXEC(if_rc->get_play_status_rsp, play_status, song_len, song_pos);
}
/* get_element_attr_rsp */
static void get_element_attr_rsp_c(int argc, const char **argv,
enum_func *enum_func, void **user)
{
if (argc == 4) {
*user = TYPE_ENUM(btrc_media_attr_t);
*enum_func = enum_defines;
}
}
static void get_element_attr_rsp_p(int argc, const char **argv)
{
uint8_t num_attr;
btrc_element_attr_val_t attrs;
RETURN_IF_NULL(if_rc);
if (argc <= 2) {
haltest_error("No number of attributes specified");
return;
}
if (argc <= 4) {
haltest_error("No attr id and value specified");
return;
}
num_attr = (uint8_t) atoi(argv[2]);
attrs.attr_id = str2btrc_media_attr_t(argv[3]);
strcpy((char *)attrs.text, argv[4]);
EXEC(if_rc->get_element_attr_rsp, num_attr, &attrs);
}
/* set_volume */
static void set_volume_c(int argc, const char **argv,
enum_func *enum_func, void **user)
{
}
static void set_volume_p(int argc, const char **argv)
{
uint8_t volume;
RETURN_IF_NULL(if_rc);
if (argc <= 2) {
haltest_error("No volume specified");
return;
}
volume = (uint8_t) atoi(argv[2]);
EXEC(if_rc->set_volume, volume);
}
/* set_player_app_value_rsp */
static void set_player_app_value_rsp_c(int argc, const char **argv,
enum_func *enum_func, void **user)
{
if (argc == 3) {
*user = TYPE_ENUM(btrc_status_t);
*enum_func = enum_defines;
}
}
static void set_player_app_value_rsp_p(int argc, const char **argv)
{
btrc_status_t rsp_status;
RETURN_IF_NULL(if_rc);
if (argc <= 2) {
haltest_error("No response status specified");
return;
}
rsp_status = str2btrc_status_t(argv[2]);
EXEC(if_rc->set_player_app_value_rsp, rsp_status);
}
/* register_notification_rsp */
static void register_notification_rsp_c(int argc, const char **argv,
enum_func *enum_func, void **user)
{
if (argc == 3) {
*user = TYPE_ENUM(btrc_event_id_t);
*enum_func = enum_defines;
}
if (argc == 4) {
*user = TYPE_ENUM(btrc_notification_type_t);
*enum_func = enum_defines;
}
}
static void register_notification_rsp_p(int argc, const char **argv)
{
btrc_event_id_t event_id;
btrc_notification_type_t type;
btrc_register_notification_t reg;
uint32_t song_pos;
uint64_t track;
RETURN_IF_NULL(if_rc);
memset(&reg, 0, sizeof(reg));
event_id = str2btrc_event_id_t(argv[2]);
type = str2btrc_notification_type_t(argv[3]);
switch (event_id) {
case BTRC_EVT_PLAY_STATUS_CHANGED:
reg.play_status = str2btrc_play_status_t(argv[4]);
break;
case BTRC_EVT_TRACK_CHANGE:
track = strtoull(argv[5], NULL, 10);
memcpy(reg.track, &track, sizeof(btrc_uid_t));
break;
case BTRC_EVT_TRACK_REACHED_END:
case BTRC_EVT_TRACK_REACHED_START:
break;
case BTRC_EVT_PLAY_POS_CHANGED:
song_pos = strtoul(argv[4], NULL, 10);
memcpy(&reg.song_pos, &song_pos, sizeof(uint32_t));
break;
case BTRC_EVT_APP_SETTINGS_CHANGED:
haltest_error("not supported");
return;
}
EXEC(if_rc->register_notification_rsp, event_id, type, &reg);
}
/* cleanup */
static void cleanup_p(int argc, const char **argv)
{
RETURN_IF_NULL(if_rc);
EXECV(if_rc->cleanup);
if_rc = NULL;
}
static struct method methods[] = {
STD_METHOD(init),
STD_METHODCH(get_play_status_rsp,
"<play_status> <song_len> <song_pos>"),
STD_METHODCH(get_element_attr_rsp, "<num_attr> <attrs_id> <value>"),
STD_METHODCH(set_player_app_value_rsp, "<rsp_status>"),
STD_METHODCH(set_volume, "<volume>"),
STD_METHODCH(register_notification_rsp,
"<event_id> <type> <respective_data...>\n"
"BTRC_EVT_PLAY_STATUS_CHANGED <type> <play_status>\n"
"BTRC_EVT_TRACK_CHANGE <type> <track>\n"
"BTRC_EVT_TRACK_REACHED_END <type>\n"
"BTRC_EVT_TRACK_REACHED_START <type>\n"
"BTRC_EVT_PLAY_POS_CHANGED <type> <song_pos>\n"),
STD_METHOD(cleanup),
END_METHOD
};
const struct interface rc_if = {
.name = "rc",
.methods = methods
};