Name: capi-media-controller
Summary: Multimedia Controller for player application
-Version: 0.0.10
+Version: 0.0.11
Release: 1
Group: System/Libraries
License: Apache-2.0
mc_error("fail to mc_db_disconnect");
}
- if (mc_client->listeners != NULL) {
+ if (mc_client->listeners != NULL)
g_list_free(mc_client->listeners);
- }
MC_SAFE_FREE(mc_client->client_name);
MC_SAFE_FREE(mc_client);
}
/*Remove from filter_list*/
- for(idx = 0; idx < filter_cnt; idx++) {
+ for (idx = 0; idx < filter_cnt; idx++) {
char * interface_name = NULL;
interface_name = g_list_nth_data(*filter_list, idx);
} else {
/*Remove All filter listener*/
- for(idx = 0; idx < filter_cnt; idx++) {
+ for (idx = 0; idx < filter_cnt; idx++) {
char * interface_name = NULL;
interface_name = g_list_nth_data(*filter_list, idx);
/*Unregister listener*/
ret = mc_ipc_unregister_listener(mc_client->listeners, mc_client->dconn, interface_name, signal_name);
- if(ret != MEDIA_CONTROLLER_ERROR_NONE)
+ if (ret != MEDIA_CONTROLLER_ERROR_NONE)
mc_error("Fail mc_ipc_unregister_listener");
/*Remove from filter_list*/
mc_client->server_state_cb.user_data = user_data;
ret = mc_ipc_register_listener(mc_client->listeners, mc_client->dconn, MC_DBUS_UPDATE_INTERFACE, MC_DBUS_SIGNAL_NAME_SERVER_STATE,
- __client_server_cb, (void *)&(mc_client->server_state_cb));
+ __client_server_cb, (void *)&(mc_client->server_state_cb));
return ret;
}
mc_client->playback_cb.user_data = user_data;
ret = mc_ipc_register_listener(mc_client->listeners, mc_client->dconn, MC_DBUS_UPDATE_INTERFACE, MC_DBUS_SIGNAL_NAME_PLAY_BACK,
- __client_playback_cb, (void *)&(mc_client->playback_cb));
+ __client_playback_cb, (void *)&(mc_client->playback_cb));
return ret;
}
mc_client->metadata_cb.user_data = user_data;
ret = mc_ipc_register_listener(mc_client->listeners, mc_client->dconn, MC_DBUS_UPDATE_INTERFACE, MC_DBUS_SIGNAL_NAME_METADATA,
- __client_metadata_cb, (void *)(mc_client));
+ __client_metadata_cb, (void *)(mc_client));
return ret;
}
mc_client->shuffle_cb.user_data = user_data;
ret = mc_ipc_register_listener(mc_client->listeners, mc_client->dconn, MC_DBUS_UPDATE_INTERFACE, MC_DBUS_SIGNAL_NAME_PLAYBACK_SHUFFLE,
- __client_shuffle_cb, (void *)&(mc_client->shuffle_cb));
+ __client_shuffle_cb, (void *)&(mc_client->shuffle_cb));
return ret;
}
mc_client->repeat_cb.user_data = user_data;
ret = mc_ipc_register_listener(mc_client->listeners, mc_client->dconn, MC_DBUS_UPDATE_INTERFACE, MC_DBUS_SIGNAL_NAME_PLAYBACK_REPEAT,
- __client_repeat_cb, (void *)&(mc_client->repeat_cb));
+ __client_repeat_cb, (void *)&(mc_client->repeat_cb));
return ret;
}
mc_retvm_if(mc_client == NULL, MEDIA_CONTROLLER_ERROR_INVALID_PARAMETER, "Handle is NULL");
mc_retvm_if(!MC_STRING_VALID(server_name), MEDIA_CONTROLLER_ERROR_INVALID_PARAMETER, "Invalid server_name");
- switch(subscription_type) {
+ switch (subscription_type) {
case MC_SUBSCRIPTION_TYPE_SERVER_STATE:
mc_retvm_if(mc_client->server_state_cb.callback == NULL, MEDIA_CONTROLLER_ERROR_INVALID_PARAMETER, "Invalid callback");
mc_retvm_if(mc_client == NULL, MEDIA_CONTROLLER_ERROR_INVALID_PARAMETER, "Handle is NULL");
mc_retvm_if(!MC_STRING_VALID(server_name), MEDIA_CONTROLLER_ERROR_INVALID_PARAMETER, "Invalid server_name");
- switch(subscription_type) {
+ switch (subscription_type) {
case MC_SUBSCRIPTION_TYPE_SERVER_STATE:
mc_retvm_if(mc_client->server_state_cb.callback == NULL, MEDIA_CONTROLLER_ERROR_INVALID_PARAMETER, "Invalid callback. No list to unsubscribe");
mc_retvm_if(mc_client->server_state_cb.filter_list == NULL, MEDIA_CONTROLLER_ERROR_INVALID_PARAMETER, "Invalid filter_list. No list to unsubscribe");
mc_retvm_if(mc_client == NULL, MEDIA_CONTROLLER_ERROR_INVALID_PARAMETER, "Handle is NULL");
mc_retvm_if(callback == NULL, MEDIA_CONTROLLER_ERROR_INVALID_PARAMETER, "callback is NULL");
- switch(subscription_type) {
+ switch (subscription_type) {
case MC_SUBSCRIPTION_TYPE_SERVER_STATE:
filter_list = mc_client->server_state_cb.filter_list;
break;
filter_cnt = g_list_length(filter_list);
- for(idx = 0; idx < filter_cnt; idx++) {
+ for (idx = 0; idx < filter_cnt; idx++) {
filter_data = (char*)g_list_nth_data(filter_list, idx);
ret = __mc_parse_server_name(filter_data, &server_name);
mc_retvm_if(ret != MEDIA_CONTROLLER_ERROR_NONE, ret, "fail __mc_parse_server_name");
char *interface_name = mc_util_get_interface_name(MC_SERVER, server_name);
ret = mc_ipc_send_message(mc_client->dconn, NULL, interface_name, MC_DBUS_SIGNAL_NAME_PLAYBACK_STATE_CMD, message, 0);
- if (ret != MEDIA_CONTROLLER_ERROR_NONE) {
+ if (ret != MEDIA_CONTROLLER_ERROR_NONE)
mc_error("Error mc_ipc_send_message [%d]", ret);
- }
MC_SAFE_FREE(message);
MC_SAFE_FREE(interface_name);
char *interface_name_for_reply = mc_util_get_interface_name(MC_CLIENT, mc_client->client_name);
mc_client->reply_cb.callback = callback;
mc_client->reply_cb.user_data = user_data;
- mc_ipc_register_listener(mc_client->listeners, mc_client->dconn, interface_name_for_reply,
- MC_DBUS_SIGNAL_NAME_CMD_REPLY, __client_reply_cb, (void *)&(mc_client->reply_cb));
+ mc_ipc_register_listener(mc_client->listeners, mc_client->dconn, interface_name_for_reply, MC_DBUS_SIGNAL_NAME_CMD_REPLY, __client_reply_cb, (void *)&(mc_client->reply_cb));
MC_SAFE_FREE(interface_name_for_reply);
}
mc_retvm_if(ret != MEDIA_CONTROLLER_ERROR_NONE, ret, "fail while encoding bundle [%d]", ret);
}
- if ((size_r == 0) || (raw_data == NULL)) {
+ if ((size_r == 0) || (raw_data == NULL))
message = g_strdup_printf("%s%s%s%s%d", mc_client->client_name, MC_STRING_DELIMITER, command, MC_STRING_DELIMITER, size_r);
- } else {
+ else
message = g_strdup_printf("%s%s%s%s%d%s%s", mc_client->client_name, MC_STRING_DELIMITER, command, MC_STRING_DELIMITER, size_r, MC_STRING_DELIMITER, (unsigned char *)raw_data);
- }
+
if (message == NULL) {
mc_error("Error when making message");
return MEDIA_CONTROLLER_ERROR_INVALID_OPERATION;
/*Unregister all listener*/
ret = mc_ipc_unregister_all_listener(mc_client->listeners, mc_client->dconn);
- if (ret != MEDIA_CONTROLLER_ERROR_NONE) {
+ if (ret != MEDIA_CONTROLLER_ERROR_NONE)
mc_error("Error mc_ipc_unregister_all_listener [%d]", ret);
- }
/*Send Disconnection Msg to Server*/
ret = mc_ipc_send_message_to_server(MC_MSG_SERVER_DISCONNECTION, MC_SERVER_DISCONNECTION_MSG);
- if (ret != MEDIA_CONTROLLER_ERROR_NONE) {
+ if (ret != MEDIA_CONTROLLER_ERROR_NONE)
mc_error("Failed to mc_ipc_send_message_to_server [%d]", ret);
- }
ret = __mc_client_destroy(mc_client);
* See the License for the specific language governing permissions and
* limitations under the License.
*/
+
#include <unistd.h>
#include <stdlib.h>
#include <string.h>
mc_retvm_if(handle == NULL, MEDIA_CONTROLLER_ERROR_INVALID_PARAMETER, "Handle is NULL");
/*Connect DB*/
- if(need_write) {
+ if (need_write) {
ret = db_util_open_with_options(tzplatform_mkpath(TZ_USER_DB, MC_DB_NAME), &db_handle, SQLITE_OPEN_READWRITE, NULL);
} else {
ret = db_util_open_with_options(tzplatform_mkpath(TZ_USER_DB, MC_DB_NAME), &db_handle, SQLITE_OPEN_READONLY, NULL);
}
int mc_db_update_whole_metadata(void *handle, const char *server_name,
- const char *title, const char *artist, const char *album, const char *author, const char *genre, const char *duration, const char *date,
- const char *copyright, const char *description, const char *track_num, const char *picture)
+ const char *title, const char *artist, const char *album, const char *author, const char *genre, const char *duration, const char *date,
+ const char *copyright, const char *description, const char *track_num, const char *picture)
{
int ret = MEDIA_CONTROLLER_ERROR_NONE;
char *sql_str = NULL;
mc_retvm_if(server_name == NULL, MEDIA_CONTROLLER_ERROR_INVALID_PARAMETER, "server_name is NULL");
sql_str = sqlite3_mprintf(DB_UPDATE_METADATA_INFO_INFO_SERVER_TABLE, server_name,
- title, artist, album, author, genre, duration, date, copyright, description, track_num, picture);
+ title, artist, album, author, genre, duration, date, copyright, description, track_num, picture);
ret = __mc_db_update_db(handle, sql_str);
shuffle_mode INTEGER DEFAULT 1, \
repeat_mode INTEGER DEFAULT 1 \
);",
- server_name);
+ server_name);
ret = __mc_db_update_db(handle, sql_str);
}
static void __mc_ipc_signal_cb(GDBusConnection *connection,
- const gchar *sender_name,
- const gchar *object_path,
- const gchar *interface_name,
- const gchar *signal_name,
- GVariant *parameters,
- gpointer user_data)
+ const gchar *sender_name,
+ const gchar *object_path,
+ const gchar *interface_name,
+ const gchar *signal_name,
+ GVariant *parameters,
+ gpointer user_data)
{
char *key = __make_key_for_map(interface_name, signal_name);
GList *listener_list = (GList *)user_data;
static guint _mc_ipc_signal_subscribe(GDBusConnection *connection, const char *interface_name, const char *signal_name, void *user_data)
{
guint ret = g_dbus_connection_signal_subscribe(
- connection,
- NULL,
- interface_name,
- signal_name,
- MC_DBUS_PATH,
- NULL,
- G_DBUS_SIGNAL_FLAGS_NONE,
- __mc_ipc_signal_cb,
- user_data,
- NULL);
+ connection,
+ NULL,
+ interface_name,
+ signal_name,
+ MC_DBUS_PATH,
+ NULL,
+ G_DBUS_SIGNAL_FLAGS_NONE,
+ __mc_ipc_signal_cb,
+ user_data,
+ NULL);
return ret;
}
mc_debug("emit signal - interface_name [%s], signal_name [%s]", interface_name, signal_name);
gboolean emmiting = g_dbus_connection_emit_signal(
- connection,
- dbus_name,
- MC_DBUS_PATH,
- interface_name,
- signal_name,
- g_variant_new("(is)", 0, message),
- &error);
+ connection,
+ dbus_name,
+ MC_DBUS_PATH,
+ interface_name,
+ signal_name,
+ g_variant_new("(is)", 0, message),
+ &error);
if (!emmiting) {
mc_error("g_dbus_connection_emit_signal failed : %s", error ? error->message : "none");
if (error) {
mc_ipc_delete_client_socket(&sock_info);
- while((__is_service_activated() == FALSE) && (retrycount++ < MAX_WAIT_COUNT)) {
+ while ((__is_service_activated() == FALSE) && (retrycount++ < MAX_WAIT_COUNT)) {
MC_MILLISEC_SLEEP(200);
mc_error("[No-Error] retry count [%d]", retrycount);
}
mc_error("fail to mc_db_disconnect");
}
- if (mc_server->listeners != NULL) {
+ if (mc_server->listeners != NULL)
g_list_free(mc_server->listeners);
- }
MC_SAFE_FREE(mc_server->server_name);
params = g_strsplit(message, MC_STRING_DELIMITER, 0);
mc_retm_if(params == NULL, "invalid custom data");
- if(params[0])
+ if (params[0])
sender = strdup(params[0]);
if (mc_util_get_command_availabe(sender, MC_COMMAND_CUSTOM, params[1]) != MEDIA_CONTROLLER_ERROR_NONE) {
mc_retvm_if(interface_name == NULL, MEDIA_CONTROLLER_ERROR_INVALID_PARAMETER, "interface_name is NULL");
mc_retvm_if(signal_name == NULL, MEDIA_CONTROLLER_ERROR_INVALID_PARAMETER, "signal_name is NULL");
- if (!strcmp(MC_DBUS_SIGNAL_NAME_PLAY_BACK, signal_name)) {
+ if (!strcmp(MC_DBUS_SIGNAL_NAME_PLAY_BACK, signal_name))
message = g_strdup_printf("%s%s%d%s%llu", mc_server->server_name, MC_STRING_DELIMITER, param1, MC_STRING_DELIMITER, param2);
- } else if (!strcmp(MC_DBUS_SIGNAL_NAME_METADATA, signal_name)) {
+ else if (!strcmp(MC_DBUS_SIGNAL_NAME_METADATA, signal_name))
message = g_strdup_printf("%s", mc_server->server_name);
- } else {
+ else
message = g_strdup_printf("%s%s%d", mc_server->server_name, MC_STRING_DELIMITER, param1);
- }
if (message == NULL) {
mc_error("Error when making message");
}
ret = mc_ipc_send_message(mc_server->dconn, NULL, interface_name, signal_name, message, 0);
- if (ret != MEDIA_CONTROLLER_ERROR_NONE) {
+ if (ret != MEDIA_CONTROLLER_ERROR_NONE)
mc_error("Error mc_ipc_send_message [%d]", ret);
- }
mc_debug("interface_name[%s] signal_name[%s] message[%s]", interface_name, signal_name, message);
mc_error("Error mc_util_make_interface_name [%d]", ret);
} else {
ret = mc_ipc_send_message(mc_server->dconn, NULL, filter_interface_name, signal_name, message, 0);
- if (ret != MEDIA_CONTROLLER_ERROR_NONE) {
+ if (ret != MEDIA_CONTROLLER_ERROR_NONE)
mc_error("Error mc_ipc_send_message [%d]", ret);
- }
}
MC_SAFE_FREE(filter_interface_name);
}
ret = __mc_server_send_message(mc_server, MC_DBUS_UPDATE_INTERFACE, MC_DBUS_SIGNAL_NAME_PLAY_BACK, mc_server->playback.state, mc_server->playback.position);
- if (ret != MEDIA_CONTROLLER_ERROR_NONE) {
+ if (ret != MEDIA_CONTROLLER_ERROR_NONE)
mc_error("Error __mc_server_send_message [%d]", ret);
- }
if (mc_server->playback.state == MC_PLAYBACK_STATE_PLAYING) {
ret = mc_db_update_latest_server_table(mc_server->db_handle, mc_server->server_name);
mc_retvm_if(mc_server == NULL, MEDIA_CONTROLLER_ERROR_INVALID_PARAMETER, "Handle is NULL");
ret = mc_db_update_whole_metadata(mc_server->db_handle, mc_server->server_name,
- mc_server->metadata->title, mc_server->metadata->artist, mc_server->metadata->album, mc_server->metadata->author,
- mc_server->metadata->genre, mc_server->metadata->duration, mc_server->metadata->date, mc_server->metadata->copyright,
- mc_server->metadata->description, mc_server->metadata->track_num, mc_server->metadata->picture);
+ mc_server->metadata->title, mc_server->metadata->artist, mc_server->metadata->album, mc_server->metadata->author,
+ mc_server->metadata->genre, mc_server->metadata->duration, mc_server->metadata->date, mc_server->metadata->copyright,
+ mc_server->metadata->description, mc_server->metadata->track_num, mc_server->metadata->picture);
mc_retvm_if(ret != MEDIA_CONTROLLER_ERROR_NONE, ret, "fail to mc_db_update_whole_metadata");
ret = __mc_server_send_message(mc_server, MC_DBUS_UPDATE_INTERFACE, MC_DBUS_SIGNAL_NAME_METADATA, 0, 0);
mc_server->playback_state_reciever.user_data = user_data;
char *interface_name = mc_util_get_interface_name(MC_SERVER, mc_server->server_name);
- ret = mc_ipc_register_listener(mc_server->listeners, mc_server->dconn, interface_name,
- MC_DBUS_SIGNAL_NAME_PLAYBACK_STATE_CMD, __server_playback_state_command_cb, (void *)&(mc_server->playback_state_reciever));
+ ret = mc_ipc_register_listener(mc_server->listeners, mc_server->dconn, interface_name, MC_DBUS_SIGNAL_NAME_PLAYBACK_STATE_CMD, __server_playback_state_command_cb, (void *)&(mc_server->playback_state_reciever));
MC_SAFE_FREE(interface_name);
mc_retvm_if(mc_server == NULL, MEDIA_CONTROLLER_ERROR_INVALID_PARAMETER, "Handle is NULL");
char *interface_name = mc_util_get_interface_name(MC_SERVER, mc_server->server_name);
- ret = mc_ipc_unregister_listener(mc_server->listeners, mc_server->dconn, interface_name,
- MC_DBUS_SIGNAL_NAME_PLAYBACK_STATE_CMD);
+ ret = mc_ipc_unregister_listener(mc_server->listeners, mc_server->dconn, interface_name, MC_DBUS_SIGNAL_NAME_PLAYBACK_STATE_CMD);
mc_server->playback_state_reciever.callback = NULL;
mc_server->playback_state_reciever.user_data = NULL;
mc_server->custom_cmd_reciever.user_data = user_data;
char *interface_name = mc_util_get_interface_name(MC_SERVER, mc_server->server_name);
- ret = mc_ipc_register_listener(mc_server->listeners, mc_server->dconn, interface_name,
- MC_DBUS_SIGNAL_NAME_CUSTOM_CMD, __server_custom_command_cb, (void *)&(mc_server->custom_cmd_reciever));
+ ret = mc_ipc_register_listener(mc_server->listeners, mc_server->dconn, interface_name, MC_DBUS_SIGNAL_NAME_CUSTOM_CMD, __server_custom_command_cb, (void *)&(mc_server->custom_cmd_reciever));
MC_SAFE_FREE(interface_name);
}
ret = __mc_server_send_message(mc_server, MC_DBUS_UPDATE_INTERFACE, MC_DBUS_SIGNAL_NAME_SERVER_STATE, MC_SERVER_STATE_ACTIVATE, 0);
- if (ret != MEDIA_CONTROLLER_ERROR_NONE) {
+ if (ret != MEDIA_CONTROLLER_ERROR_NONE)
mc_error("Error __mc_server_send_message [%d]", ret);
- }
*server = (mc_server_h)mc_server;
mc_retvm_if(mc_server == NULL, MEDIA_CONTROLLER_ERROR_INVALID_PARAMETER, "Handle is NULL");
ret = mc_ipc_unregister_all_listener(mc_server->listeners, mc_server->dconn);
- if (ret != MEDIA_CONTROLLER_ERROR_NONE) {
+ if (ret != MEDIA_CONTROLLER_ERROR_NONE)
mc_error("fail mc_ipc_unregister_all_listener [%d]", ret);
- }
ret = mc_db_delete_server_address_from_table(mc_server->db_handle, MC_DB_TABLE_SERVER_LIST, mc_server->server_name);
if (ret != MEDIA_CONTROLLER_ERROR_NONE)
}
ret = __mc_server_send_message(mc_server, MC_DBUS_UPDATE_INTERFACE, MC_DBUS_SIGNAL_NAME_SERVER_STATE, MC_SERVER_STATE_DEACTIVATE, 0);
- if (ret != MEDIA_CONTROLLER_ERROR_NONE) {
+ if (ret != MEDIA_CONTROLLER_ERROR_NONE)
mc_error("Error __mc_server_send_message [%d]", ret);
- }
/*Send Disconnection Msg to Server*/
ret = mc_ipc_send_message_to_server(MC_MSG_SERVER_DISCONNECTION, MC_SERVER_DISCONNECTION_MSG);
- if (ret != MEDIA_CONTROLLER_ERROR_NONE) {
+ if (ret != MEDIA_CONTROLLER_ERROR_NONE)
mc_error("Failed to mc_ipc_send_message_to_server [%d]", ret);
- }
ret = __mc_server_destoy(mc_server);
if (ret != MEDIA_CONTROLLER_ERROR_NONE)
memset(old_word, 0, MAX_NAME_LENGTH);
memset(new_word, 0, MAX_NAME_LENGTH);
- if (strlen(name) > MAX_NAME_LENGTH) {
+ if (strlen(name) > MAX_NAME_LENGTH)
memcpy(old_word, name, MAX_NAME_LENGTH);
- } else {
+ else
memcpy(old_word, name, strlen(name));
- }
/* only 0~9, a~z, A~Z, '.', '_' will be used */
for (i = 0; i < strlen(old_word); i++) {
/*Quit Controller Thread*/
GMainLoop *mc_svc_mainloop = mc_svc_get_main_loop();
- if (mc_svc_mainloop && g_main_is_running(mc_svc_mainloop)) {
+ if (mc_svc_mainloop && g_main_is_running(mc_svc_mainloop))
g_main_loop_quit(mc_svc_mainloop);
- }
g_main_loop_quit(g_mc_mainloop);
}
g_source_destroy(g_main_context_find_source_by_id(g_main_context_get_thread_default(), timer_id));
GSource *timer_src = g_timeout_source_new_seconds(MC_MAIN_TIMEOUT_SEC_60);
- g_source_set_callback (timer_src, __mc_main_check_connection, NULL, NULL);
- g_mc_timer_id = g_source_attach (timer_src, g_main_context_get_thread_default());
+ g_source_set_callback(timer_src, __mc_main_check_connection, NULL, NULL);
+ g_mc_timer_id = g_source_attach(timer_src, g_main_context_get_thread_default());
}
int main(int argc, char **argv)
/*Init main loop*/
g_mc_mainloop = g_main_loop_new(NULL, FALSE);
- if(mc_cynara_initialize() != MEDIA_CONTROLLER_ERROR_NONE) {
+ if (mc_cynara_initialize() != MEDIA_CONTROLLER_ERROR_NONE) {
mc_error("Failed to initialize cynara");
return -1;
}
fd = mc_create_socket_activation();
- if (fd < 0) {
+ if (fd < 0)
mc_error("Failed to socekt creation");
- }
/*create each threads*/
svc_thread = g_thread_new("mc_svc_thread", (GThreadFunc)mc_svc_thread, NULL);
-/*\r
-* Copyright (c) 2011 Samsung Electronics Co., Ltd All Rights Reserved\r
-*\r
-* Licensed under the Apache License, Version 2.0 (the "License");\r
-* you may not use this file except in compliance with the License.\r
-* You may obtain a copy of the License at\r
-*\r
-* http://www.apache.org/licenses/LICENSE-2.0\r
-*\r
-* Unless required by applicable law or agreed to in writing, software\r
-* distributed under the License is distributed on an "AS IS" BASIS,\r
-* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\r
-* See the License for the specific language governing permissions and\r
-* limitations under the License.\r
-*/\r
-\r
-#define _GNU_SOURCE\r
-\r
-#include <errno.h>\r
-#include <glib.h>\r
-#include <stdio.h>\r
-#include <stdlib.h>\r
-#include <sys/socket.h>\r
-#include <unistd.h>\r
-\r
-#include <media_controller_cynara.h>\r
-#include <media_controller_type.h>\r
-#include <media_controller_private.h>\r
-\r
-#include <cynara-client.h>\r
-#include <cynara-session.h>\r
-#include <cynara-error.h>\r
-#include <cynara-creds-socket.h>\r
-\r
-/* this definition is missing in glibc headers (version 2.21). It was introduced in kernel version 2.6.17 */\r
-#ifndef SCM_SECURITY\r
-#define SCM_SECURITY 0x03\r
-#endif\r
-\r
-static cynara *_cynara = NULL;\r
-G_LOCK_DEFINE_STATIC(cynara_mutex);\r
-\r
-static void mc_cynara_dbg_err(const char *prefix, int error_code)\r
-{\r
- char error_buffer[256];\r
- int err;\r
- error_buffer[0] = '\0';\r
-\r
- err = cynara_strerror(error_code, error_buffer, sizeof(error_buffer));\r
- if (err == CYNARA_API_SUCCESS) {\r
- mc_error("%s: %s", prefix, error_buffer);\r
- } else {\r
- mc_error("%s: error code %i", prefix, error_code);\r
- }\r
-}\r
-\r
-int mc_cynara_initialize(void)\r
-{\r
- int ret = cynara_initialize(&_cynara, NULL);\r
- if (ret != CYNARA_API_SUCCESS) {\r
- mc_cynara_dbg_err("cynara_initialize", ret);\r
- return MEDIA_CONTROLLER_ERROR_INVALID_OPERATION;\r
- }\r
- return MEDIA_CONTROLLER_ERROR_NONE;\r
-}\r
-\r
-void mc_cynara_finish(void)\r
-{\r
- cynara_finish(_cynara);\r
- _cynara = NULL;\r
-}\r
-\r
-int mc_cynara_receive_untrusted_message(int sockfd, mc_comm_msg_s *recv_msg, mc_peer_creds *credentials)\r
-{\r
- int ret = 0;\r
- int recv_msg_size = 0;\r
-\r
- if (!recv_msg ||!credentials)\r
- return MEDIA_CONTROLLER_ERROR_INVALID_PARAMETER;\r
-\r
- if ((recv_msg_size = read(sockfd, recv_msg, sizeof(mc_comm_msg_s))) < 0) {\r
- if (errno == EWOULDBLOCK) {\r
- mc_error("Timeout. Can't try any more");\r
- return MEDIA_CONTROLLER_ERROR_INVALID_OPERATION;\r
- } else {\r
- mc_stderror("recv failed");\r
- return MEDIA_CONTROLLER_ERROR_INVALID_OPERATION;\r
- }\r
- }\r
-\r
-/* mc_debug("receive msg[%d] from [%d(%d)] %d, %s", recv_msg_size, recv_msg->pid, recv_msg->uid, recv_msg->msg_type, recv_msg->msg); */\r
-\r
- ret = cynara_creds_socket_get_pid(sockfd, &(credentials->pid));\r
- if(ret < 0) {\r
- mc_error("cynara_creds_socket_get_pid failed");\r
- return MEDIA_CONTROLLER_ERROR_INVALID_OPERATION;\r
- }\r
-\r
- ret = cynara_creds_socket_get_user(sockfd, USER_METHOD_UID, &(credentials->uid));\r
- if(ret < 0) {\r
- mc_error("cynara_creds_socket_get_user failed");\r
- return MEDIA_CONTROLLER_ERROR_INVALID_OPERATION;\r
- }\r
-\r
- ret = cynara_creds_socket_get_client(sockfd, CLIENT_METHOD_SMACK, &(credentials->smack));\r
- if(ret < 0) {\r
- mc_error("cynara_creds_socket_get_client failed");\r
- return MEDIA_CONTROLLER_ERROR_INVALID_OPERATION;\r
- }\r
-\r
-/* mc_error("cynara_creds_info : P[%d]U[%s]S[%s]", credentials->pid, credentials->uid, credentials->smack); */\r
-\r
- return MEDIA_CONTROLLER_ERROR_NONE;\r
-}\r
-\r
-int mc_cynara_check(const mc_peer_creds *creds, const char *privilege)\r
-{\r
- int result;\r
- char *session;\r
-\r
- if (!creds || !privilege)\r
- return MEDIA_CONTROLLER_ERROR_INVALID_PARAMETER;\r
-\r
- session = cynara_session_from_pid(creds->pid);\r
- if (session == NULL) {\r
- mc_error("cynara_session_from_pid failed");\r
- return MEDIA_CONTROLLER_ERROR_INVALID_OPERATION;\r
- }\r
-\r
- G_LOCK(cynara_mutex);\r
- result = cynara_check(_cynara, creds->smack, session, creds->uid, privilege);\r
- G_UNLOCK(cynara_mutex);\r
-\r
- if (result != CYNARA_API_ACCESS_ALLOWED)\r
- mc_cynara_dbg_err("cynara_check", result);\r
-\r
- MC_SAFE_FREE(session);\r
- return result == CYNARA_API_ACCESS_ALLOWED ? MEDIA_CONTROLLER_ERROR_NONE: MEDIA_CONTROLLER_ERROR_PERMISSION_DENIED;\r
-}\r
-\r
-int mc_cynara_enable_credentials_passing(int sockfd)\r
-{\r
- const int optval = 1;\r
- int err = 0;\r
-\r
- err = setsockopt(sockfd, SOL_SOCKET, SO_PASSSEC, &optval, sizeof(optval));\r
- if (err != 0) {\r
- mc_error("Failed to set SO_PASSSEC socket option");\r
- return MEDIA_CONTROLLER_ERROR_INVALID_OPERATION;\r
- }\r
-\r
- err = setsockopt(sockfd, SOL_SOCKET, SO_PASSCRED, &optval, sizeof(optval));\r
- if (err != 0) {\r
- mc_error("Failed to set SO_PASSCRED socket option");\r
- return MEDIA_CONTROLLER_ERROR_INVALID_OPERATION;\r
- }\r
-\r
- return MEDIA_CONTROLLER_ERROR_NONE;\r
-}\r
+/*
+* Copyright (c) 2011 Samsung Electronics Co., Ltd All Rights Reserved
+*
+* 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.
+*/
+
+#define _GNU_SOURCE
+
+#include <errno.h>
+#include <glib.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <sys/socket.h>
+#include <unistd.h>
+
+#include <media_controller_cynara.h>
+#include <media_controller_type.h>
+#include <media_controller_private.h>
+
+#include <cynara-client.h>
+#include <cynara-session.h>
+#include <cynara-error.h>
+#include <cynara-creds-socket.h>
+
+/* this definition is missing in glibc headers (version 2.21). It was introduced in kernel version 2.6.17 */
+#ifndef SCM_SECURITY
+#define SCM_SECURITY 0x03
+#endif
+
+static cynara *_cynara = NULL;
+G_LOCK_DEFINE_STATIC(cynara_mutex);
+
+static void mc_cynara_dbg_err(const char *prefix, int error_code)
+{
+ char error_buffer[256];
+ int err;
+ error_buffer[0] = '\0';
+
+ err = cynara_strerror(error_code, error_buffer, sizeof(error_buffer));
+ if (err == CYNARA_API_SUCCESS)
+ mc_error("%s: %s", prefix, error_buffer);
+ else
+ mc_error("%s: error code %i", prefix, error_code);
+}
+
+int mc_cynara_initialize(void)
+{
+ int ret = cynara_initialize(&_cynara, NULL);
+ if (ret != CYNARA_API_SUCCESS) {
+ mc_cynara_dbg_err("cynara_initialize", ret);
+ return MEDIA_CONTROLLER_ERROR_INVALID_OPERATION;
+ }
+ return MEDIA_CONTROLLER_ERROR_NONE;
+}
+
+void mc_cynara_finish(void)
+{
+ cynara_finish(_cynara);
+ _cynara = NULL;
+}
+
+int mc_cynara_receive_untrusted_message(int sockfd, mc_comm_msg_s *recv_msg, mc_peer_creds *credentials)
+{
+ int ret = 0;
+ int recv_msg_size = 0;
+
+ if (!recv_msg || !credentials)
+ return MEDIA_CONTROLLER_ERROR_INVALID_PARAMETER;
+
+ if ((recv_msg_size = read(sockfd, recv_msg, sizeof(mc_comm_msg_s))) < 0) {
+ if (errno == EWOULDBLOCK) {
+ mc_error("Timeout. Can't try any more");
+ return MEDIA_CONTROLLER_ERROR_INVALID_OPERATION;
+ } else {
+ mc_stderror("recv failed");
+ return MEDIA_CONTROLLER_ERROR_INVALID_OPERATION;
+ }
+ }
+
+/* mc_debug("receive msg[%d] from [%d(%d)] %d, %s", recv_msg_size, recv_msg->pid, recv_msg->uid, recv_msg->msg_type, recv_msg->msg); */
+
+ ret = cynara_creds_socket_get_pid(sockfd, &(credentials->pid));
+ if (ret < 0) {
+ mc_error("cynara_creds_socket_get_pid failed");
+ return MEDIA_CONTROLLER_ERROR_INVALID_OPERATION;
+ }
+
+ ret = cynara_creds_socket_get_user(sockfd, USER_METHOD_UID, &(credentials->uid));
+ if (ret < 0) {
+ mc_error("cynara_creds_socket_get_user failed");
+ return MEDIA_CONTROLLER_ERROR_INVALID_OPERATION;
+ }
+
+ ret = cynara_creds_socket_get_client(sockfd, CLIENT_METHOD_SMACK, &(credentials->smack));
+ if (ret < 0) {
+ mc_error("cynara_creds_socket_get_client failed");
+ return MEDIA_CONTROLLER_ERROR_INVALID_OPERATION;
+ }
+
+/* mc_error("cynara_creds_info : P[%d]U[%s]S[%s]", credentials->pid, credentials->uid, credentials->smack); */
+
+ return MEDIA_CONTROLLER_ERROR_NONE;
+}
+
+int mc_cynara_check(const mc_peer_creds *creds, const char *privilege)
+{
+ int result;
+ char *session;
+
+ if (!creds || !privilege)
+ return MEDIA_CONTROLLER_ERROR_INVALID_PARAMETER;
+
+ session = cynara_session_from_pid(creds->pid);
+ if (session == NULL) {
+ mc_error("cynara_session_from_pid failed");
+ return MEDIA_CONTROLLER_ERROR_INVALID_OPERATION;
+ }
+
+ G_LOCK(cynara_mutex);
+ result = cynara_check(_cynara, creds->smack, session, creds->uid, privilege);
+ G_UNLOCK(cynara_mutex);
+
+ if (result != CYNARA_API_ACCESS_ALLOWED)
+ mc_cynara_dbg_err("cynara_check", result);
+
+ MC_SAFE_FREE(session);
+ return result == CYNARA_API_ACCESS_ALLOWED ? MEDIA_CONTROLLER_ERROR_NONE : MEDIA_CONTROLLER_ERROR_PERMISSION_DENIED;
+}
+
+int mc_cynara_enable_credentials_passing(int sockfd)
+{
+ const int optval = 1;
+ int err = 0;
+
+ err = setsockopt(sockfd, SOL_SOCKET, SO_PASSSEC, &optval, sizeof(optval));
+ if (err != 0) {
+ mc_error("Failed to set SO_PASSSEC socket option");
+ return MEDIA_CONTROLLER_ERROR_INVALID_OPERATION;
+ }
+
+ err = setsockopt(sockfd, SOL_SOCKET, SO_PASSCRED, &optval, sizeof(optval));
+ if (err != 0) {
+ mc_error("Failed to set SO_PASSCRED socket option");
+ return MEDIA_CONTROLLER_ERROR_INVALID_OPERATION;
+ }
+
+ return MEDIA_CONTROLLER_ERROR_NONE;
+}
-/*\r
-* Copyright (c) 2011 Samsung Electronics Co., Ltd All Rights Reserved\r
-*\r
-* Licensed under the Apache License, Version 2.0 (the "License");\r
-* you may not use this file except in compliance with the License.\r
-* You may obtain a copy of the License at\r
-*\r
-* http://www.apache.org/licenses/LICENSE-2.0\r
-*\r
-* Unless required by applicable law or agreed to in writing, software\r
-* distributed under the License is distributed on an "AS IS" BASIS,\r
-* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\r
-* See the License for the specific language governing permissions and\r
-* limitations under the License.\r
-*/\r
-\r
-#ifndef __TIZEN_MEDIA_CONTROLLER_CYNARA_H__\r
-#define __TIZEN_MEDIA_CONTROLLER_CYNARA_H__\r
-\r
-#include <stdbool.h>\r
-\r
-#include <media_controller_private.h>\r
-\r
-#define MC_CLIENT_PRIVILEGE "http://tizen.org/privilege/mediacontroller.client"\r
-#define MC_SERVER_PRIVILEGE "http://tizen.org/privilege/mediacontroller.server"\r
-\r
-typedef struct {\r
- pid_t pid;\r
- char *uid;\r
- char *smack;\r
-} mc_peer_creds;\r
-\r
-int mc_cynara_initialize(void);\r
-int mc_cynara_check(const mc_peer_creds *creds, const char *privilege);\r
-int mc_cynara_receive_untrusted_message(int sockfd, mc_comm_msg_s *recv_msg, mc_peer_creds *credentials);\r
-int mc_cynara_enable_credentials_passing(int sockfd);\r
-void mc_cynara_finish(void);\r
-\r
-\r
-#endif/* _MEDIA_CONTROLLER_CYNARA_H_ */\r
+/*
+* Copyright (c) 2011 Samsung Electronics Co., Ltd All Rights Reserved
+*
+* 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.
+*/
+
+#ifndef __TIZEN_MEDIA_CONTROLLER_CYNARA_H__
+#define __TIZEN_MEDIA_CONTROLLER_CYNARA_H__
+
+#include <stdbool.h>
+
+#include <media_controller_private.h>
+
+#define MC_CLIENT_PRIVILEGE "http://tizen.org/privilege/mediacontroller.client"
+#define MC_SERVER_PRIVILEGE "http://tizen.org/privilege/mediacontroller.server"
+
+typedef struct {
+ pid_t pid;
+ char *uid;
+ char *smack;
+} mc_peer_creds;
+
+int mc_cynara_initialize(void);
+int mc_cynara_check(const mc_peer_creds *creds, const char *privilege);
+int mc_cynara_receive_untrusted_message(int sockfd, mc_comm_msg_s *recv_msg, mc_peer_creds *credentials);
+int mc_cynara_enable_credentials_passing(int sockfd);
+void mc_cynara_finish(void);
+
+
+#endif/* _MEDIA_CONTROLLER_CYNARA_H_ */
table_name = strdup((const char *)sqlite3_column_text(stmt, 0));
mc_debug("table_name: %s", table_name);
- if (MC_STRING_VALID(table_name)) {
+ if (MC_STRING_VALID(table_name))
(*list) = g_list_append((*list), table_name);
- }
}
ret = sqlite3_step(stmt);
sql_str = sqlite3_mprintf("DROP TABLE IF EXISTS '%q'", server_name);
ret = mc_db_util_update_db(handle, sql_str);
- if (MEDIA_CONTROLLER_ERROR_NONE != ret) {
+ if (MEDIA_CONTROLLER_ERROR_NONE != ret)
mc_error("Error mc_db_util_update_db %d", ret);
- }
SQLITE3_SAFE_FREE(sql_str);
sql_str = sqlite3_mprintf("CREATE TABLE IF NOT EXISTS %s (\
server_name TEXT PRIMARY KEY);",
- MC_DB_TABLE_SERVER_LIST);
+ MC_DB_TABLE_SERVER_LIST);
ret = mc_db_util_update_db(handle, sql_str);
char * dir = NULL;
memset(result_psswd, 0, sizeof(result_psswd));
- if(uid == getuid())
- {
+ if (uid == getuid()) {
strncpy(result_psswd, MC_DB_NAME, sizeof(result_psswd));
grpinfo = getgrnam("users");
- if(grpinfo == NULL) {
+ if (grpinfo == NULL) {
mc_error("getgrnam(users) returns NULL !");
return NULL;
}
- }
- else
- {
+ } else {
struct passwd *userinfo = getpwuid(uid);
- if(userinfo == NULL) {
+ if (userinfo == NULL) {
mc_error("getpwuid(%d) returns NULL !", uid);
return NULL;
}
grpinfo = getgrnam("users");
- if(grpinfo == NULL) {
+ if (grpinfo == NULL) {
mc_error("getgrnam(users) returns NULL !");
return NULL;
}
- // Compare git_t type and not group name
+ /* Compare git_t type and not group name */
if (grpinfo->gr_gid != userinfo->pw_gid) {
mc_error("UID [%d] does not belong to 'users' group!", uid);
return NULL;
}
dir = strrchr(result_psswd, '/');
- if(!dir)
+ if (!dir)
return strdup(result_psswd);
- //Control if db exist create otherwise
- if(access(dir + 1, F_OK)) {
+ /* Control if db exist create otherwise */
+ if (access(dir + 1, F_OK)) {
int ret;
mkdir(dir + 1, S_IRWXU | S_IRGRP | S_IXGRP | S_IXOTH);
ret = chown(dir + 1, uid, grpinfo->gr_gid);
}
/*Connect DB*/
- if(need_write) {
+ if (need_write)
ret = db_util_open_with_options(db_name, &db_handle, SQLITE_OPEN_READWRITE, NULL);
- } else {
+ else
ret = db_util_open_with_options(db_name, &db_handle, SQLITE_OPEN_READONLY, NULL);
- }
MC_SAFE_FREE(db_name);
mc_retvm_if(handle == NULL, MEDIA_CONTROLLER_ERROR_INVALID_PARAMETER, "Handle is NULL");
ret = __mc_foreach_table_list(handle, &table_list);
- if ( ret != MEDIA_CONTROLLER_ERROR_NONE) {
+ if (ret != MEDIA_CONTROLLER_ERROR_NONE) {
mc_error("Error __mc_foreach_table_list %d", ret);
return ret;
}
mc_debug("sockfd %d close", sock_info->sock_fd);
if (sock_info->sock_path != NULL) {
ret = unlink(sock_info->sock_path);
- if (ret < 0) {
+ if (ret < 0)
mc_stderror("unlink failed");
- }
+
free(sock_info->sock_path);
}
static GMainLoop *g_mc_svc_mainloop = NULL;
static int g_connection_cnt = -1;
-//////////////////////////////////////////////////////////////////////////////
-/// GET ACTIVATE USER ID
-//////////////////////////////////////////////////////////////////////////////
#define UID_DBUS_NAME "org.freedesktop.login1"
#define UID_DBUS_PATH "/org/freedesktop/login1"
#define UID_DBUS_INTERFACE UID_DBUS_NAME".Manager"
/* get client socket fd */
ret = mc_ipc_accept_client_tcp(sock, &client_sock);
- if (ret != MEDIA_CONTROLLER_ERROR_NONE) {
+ if (ret != MEDIA_CONTROLLER_ERROR_NONE)
return TRUE;
- }
memset(&creds, 0, sizeof(mc_peer_creds));
}
}
} else if (recv_msg.msg_type == MC_MSG_SERVER_CONNECTION) {
- if((recv_msg.msg_size > 0) && (recv_msg.msg != NULL)) {
+ if ((recv_msg.msg_size > 0) && (recv_msg.msg != NULL)) {
if (strncmp(recv_msg.msg, MC_SERVER_CONNECTION_MSG, recv_msg.msg_size) == 0) {
- if(g_connection_cnt == -1)
+ if (g_connection_cnt == -1)
g_connection_cnt = 1;
else
g_connection_cnt++;
send_msg = MEDIA_CONTROLLER_ERROR_INVALID_OPERATION;
}
} else if (recv_msg.msg_type == MC_MSG_SERVER_DISCONNECTION) {
- if((recv_msg.msg_size > 0) && (recv_msg.msg != NULL)) {
+ if ((recv_msg.msg_size > 0) && (recv_msg.msg != NULL)) {
if (strncmp(recv_msg.msg, MC_SERVER_DISCONNECTION_MSG, recv_msg.msg_size) == 0) {
g_connection_cnt--;
mc_error("[No-error] decreased connection count [%d]", g_connection_cnt);
- // remove resource for disconnected process
+ /* remove resource for disconnected process */
mc_svc_list_t *set_data = NULL;
for (i = (int)(g_list_length(mc_svc_data->mc_svc_list)) - 1; i >= 0; i--) {
set_data = (mc_svc_list_t *)g_list_nth_data(mc_svc_data->mc_svc_list, i);
}
ERROR:
- if (write(client_sock, &send_msg, sizeof(send_msg)) != sizeof(send_msg)) {
+ if (write(client_sock, &send_msg, sizeof(send_msg)) != sizeof(send_msg))
mc_stderror("send failed");
- } else {
+ else
mc_debug("Sent successfully");
- }
- if (close(client_sock) < 0) {
+ if (close(client_sock) < 0)
mc_stderror("close failed");
- }
+
MC_SAFE_FREE(creds.uid);
MC_SAFE_FREE(creds.smack);
return FALSE;
}
- ret = __mc_dbus_get_uid(UID_DBUS_NAME,UID_DBUS_PATH, UID_DBUS_INTERFACE, UID_DBUS_METHOD, &uid);
+ ret = __mc_dbus_get_uid(UID_DBUS_NAME, UID_DBUS_PATH, UID_DBUS_INTERFACE, UID_DBUS_METHOD, &uid);
if (ret < 0) {
mc_debug("Failed to send dbus (%d)", ret);
return MEDIA_CONTROLLER_ERROR_INVALID_OPERATION;
}
/* Connect media controller DB*/
- if(mc_db_util_connect(&(mc_svc_data->db_handle), uid, true) != MEDIA_CONTROLLER_ERROR_NONE) {
+ if (mc_db_util_connect(&(mc_svc_data->db_handle), uid, true) != MEDIA_CONTROLLER_ERROR_NONE) {
mc_error("Failed to connect DB");
return MEDIA_CONTROLLER_ERROR_INVALID_OPERATION;
}
/* Destroy tables */
- if (mc_db_util_delete_whole_server_tables(mc_svc_data->db_handle) != MEDIA_CONTROLLER_ERROR_NONE) {
+ if (mc_db_util_delete_whole_server_tables(mc_svc_data->db_handle) != MEDIA_CONTROLLER_ERROR_NONE)
mc_error("mc_db_util_delete_whole_server_tables failed [%d]", ret);
- }
/* Create tables */
if (mc_db_util_create_tables(mc_svc_data->db_handle) != MEDIA_CONTROLLER_ERROR_NONE) {
}
ret = mc_cynara_enable_credentials_passing(sockfd);
- if(ret != MEDIA_CONTROLLER_ERROR_NONE) {
+ if (ret != MEDIA_CONTROLLER_ERROR_NONE) {
mc_error("Failed to append socket options");
return FALSE;
}
context = g_main_context_new();
- if (context == NULL) {
+ if (context == NULL)
mc_error("g_main_context_new failed");
- } else {
+ else
mc_debug("g_main_context_new success");
- }
/*Init main loop*/
g_mc_svc_mainloop = g_main_loop_new(context, FALSE);
MC_SAFE_FREE(mc_svc_data);
/* Disconnect media controller DB*/
- if(mc_db_util_disconnect(mc_svc_data->db_handle) != MEDIA_CONTROLLER_ERROR_NONE) {
+ if (mc_db_util_disconnect(mc_svc_data->db_handle) != MEDIA_CONTROLLER_ERROR_NONE) {
mc_error("Failed to connect DB");
return MEDIA_CONTROLLER_ERROR_INVALID_OPERATION;
}
return FALSE;
}
ret = mc_client_get_playback_state(playback, &playback_state);
- if (ret != MEDIA_CONTROLLER_ERROR_NONE) {
+ if (ret != MEDIA_CONTROLLER_ERROR_NONE)
g_print("Fail to get playback state");
- }
+
ret = mc_client_get_playback_position(playback, &playback_position);
- if (ret != MEDIA_CONTROLLER_ERROR_NONE) {
+ if (ret != MEDIA_CONTROLLER_ERROR_NONE)
g_print("Fail to get playback position");
- }
+
g_print("playback state: %d, position: %lld", playback_state, playback_position);
ret = mc_client_destroy_playback(playback);
return FALSE;
}
ret = mc_client_get_metadata(metadata, MC_META_MEDIA_TITLE, &metadata_value);
- if (ret != MEDIA_CONTROLLER_ERROR_NONE) {
+ if (ret != MEDIA_CONTROLLER_ERROR_NONE)
g_print("Fail to get infot");
- }
+
g_print("metadata title: %s", metadata_value);
ret = mc_client_destroy_metadata(metadata);
static void display_menu(void)
{
- if (g_menu_state == CURRENT_STATE_MAIN_MENU) {
+ if (g_menu_state == CURRENT_STATE_MAIN_MENU)
display_main_menu();
- } else if (g_menu_state == CURRENT_STATE_INFORMATION_GET_MENU) {
+ else if (g_menu_state == CURRENT_STATE_INFORMATION_GET_MENU)
display_information_menu();
- } else {
+ else
g_print("*** Unknown status.\n");
- }
}
void _interpret_information_menu(char *cmd)
ret = mc_server_set_metadata(g_mc_server, g_metadata_type, metadata);
if (ret != MEDIA_CONTROLLER_ERROR_NONE) {
g_print("Fail to set metadata");
- if(metadata != NULL)
+ if (metadata != NULL)
free(metadata);
return FALSE;
}
g_print("set metadata value: %s", metadata);
- if(metadata != NULL)
+ if (metadata != NULL)
free(metadata);
break;
default:
projects / platform / core / api / media-controller.git / commitdiff