PKG_CHECK_MODULES(LIBPMCONTROL, deviced)
AC_SUBST(LIBPMCONTROL_CFLAGS)
AC_SUBST(LIBPMCONTROL_LIBS)
-else
- PKG_CHECK_MODULES(LIBPMCONTROL, pmapi)
- AC_SUBST(LIBPMCONTROL_CFLAGS)
- AC_SUBST(LIBPMCONTROL_LIBS)
fi
AM_CONDITIONAL(USE_DEVICED, test "x$USE_DEVICED" = "xyes")
MS_MSG_SCANNER_READY, /**< Ready from media scanner */
MS_MSG_SCANNER_RESULT, /**< Result of directory scanning */
MS_MSG_SCANNER_BULK_RESULT, /**< Request bulk insert */
+ MS_MSG_STORAGE_META, /**< Request updating meta data */
MS_MSG_MAX /**< Invalid msg type */
}ms_msg_type_e;
#define MEDIA_ROOT_PATH_INTERNAL MOUNT_PATH"/media"
#define MEDIA_ROOT_PATH_SDCARD STORAGE_PATH"/sdcard"
-#define MEDIA_THUMB_ROOT_PATH MOUNT_PATH"/media"
+#define MEDIA_THUMB_ROOT_PATH MOUNT_PATH"/share/media"
#define MEDIA_DB_NAME MOUNT_PATH"/dbspace/.media.db" /**< media db name*/
#define MEDIA_DATA_PATH MOUNT_PATH"/data/file-manager-service"
}
extern char MEDIA_IPC_PATH[][50];
+#define MAX_RETRY_COUNT 3
static int __media_db_request_update_tcp(ms_msg_type_e msg_type, const char *request_msg)
{
ms_sock_info_s sock_info;
struct sockaddr_un serv_addr;
int port = MS_DB_UPDATE_PORT;
+ int retry_count = 0;
if(!MS_STRING_VALID(request_msg))
{
goto RETRY;
}
- close(sockfd);
if (errno == EWOULDBLOCK) {
+ if(retry_count < MAX_RETRY_COUNT) {
+ MSAPI_DBG_ERR("TIME OUT[%d]", retry_count);
+ retry_count ++;
+ goto RETRY;
+ }
+
+ close(sockfd);
MSAPI_DBG_ERR("Timeout. Can't try any more");
return MS_MEDIA_ERR_SOCKET_RECEIVE_TIMEOUT;
} else {
MSAPI_DBG_ERR("recv failed : %s", strerror(errno));
+
+ close(sockfd);
+
return MS_MEDIA_ERR_SOCKET_RECEIVE;
}
}
req_result.pid = recv_msg.pid;
req_result.result = recv_msg.result;
if (recv_msg.msg_type ==MS_MSG_SCANNER_RESULT) {
- req_result.complete_path = strdup(recv_msg.msg);
+ req_result.complete_path = strndup(recv_msg.msg, MAX_FILEPATH_LEN);
req_result.request_type = MEDIA_DIRECTORY_SCAN;
MSAPI_DBG("complete_path :%d", req_result.complete_path);
} else if (recv_msg.msg_type == MS_MSG_SCANNER_BULK_RESULT) {
- req_result.complete_path = strdup(recv_msg.msg);
+ req_result.complete_path = strndup(recv_msg.msg, MAX_FILEPATH_LEN);
req_result.request_type = MEDIA_FILES_REGISTER;
}
</provide>
<request>
<smack request="system::media" type="rwxat"/>
+ <smack request="system::media::root" type="rwxat"/>
+ <smack request="system::ext_storage" type="rwxat"/>
<smack request="system::vconf" type="rwxat"/>
<smack request="system::vconf_system" type="r"/>
<smack request="deviced" type="rwx"/>
+++ /dev/null
-<manifest>
- <define>
- <domain name="media-server" policy="restricted" plist="media-thumbnail-server, media-data-sdk"/>
- <provide>
- <label name="media-server::vconf"/>
- </provide>
- <request>
- <smack request="system::media" type="rwxat"/>
- <smack request="system::ext_storage" type="rwxat"/>
- <smack request="system::vconf" type="rwxat"/>
- <smack request="system::vconf_system" type="r"/>
- <smack request="deviced" type="rwx"/>
- </request>
- </define>
- <request>
- <domain name="_"/>
- </request>
- <assign>
- <filesystem path="/usr/bin/media-server" label="media-server" exec_label="media-server" />
- <filesystem path="/usr/bin/media-scanner" label="media-server" exec_label="media-server" />
- <filesystem path="/usr/bin/mediadb-update" label="media-server" exec_label="media-server" />
- <filesystem path="/etc/rc.d/init.d/mediasvr" label="_" exec_label="none" />
- <filesystem path="/etc/rc.d/rc3.d/S99mediasvr" label="_" exec_label="none" />
- <filesystem path="/etc/rc.d/rc5.d/S99mediasvr" label="_" exec_label="none" />
- </assign>
-</manifest>
-
Source3: media-server.service.mobile
Requires(post): /usr/bin/vconftool
-
-%if %{_repository} == "wearable"
Requires: deviced
-%else
-Requires: system-server
-%endif
BuildRequires: pkgconfig(glib-2.0)
BuildRequires: pkgconfig(vconf)
BuildRequires: pkgconfig(dbus-glib-1)
BuildRequires: pkgconfig(sqlite3)
BuildRequires: pkgconfig(db-util)
-
-%if %{_repository} == "wearable"
BuildRequires: pkgconfig(deviced)
-%else
-BuildRequires: pkgconfig(pmapi)
-%endif
-
BuildRequires: pkgconfig(security-server)
-
-%if %{_repository} == "mobile"
BuildRequires: pkgconfig(notification)
-%endif
+
%description
Description: File manager service server
export FFLAGS="$FFLAGS -DTIZEN_DEBUG_ENABLE"
%endif
-%if %{_repository} == "wearable"
-export CFLAGS="$CFLAGS -DTIZEN_WEARABLE"
-export CXXFLAGS="$CXXFLAGS -DTIZEN_WEARABLE"
-export FFLAGS="$FFLAGS -DTIZEN_WEARABLE"
-%endif
-
%autogen
-%configure \
-%if %{_repository} == "wearable"
- --disable-notification \
-%else
- --disable-deviced \
-%endif
- --prefix=%{_prefix} --disable-static
-
+%configure --prefix=%{_prefix} --disable-static
make %{?jobs:-j%jobs}
%make_install
mkdir -p %{buildroot}/usr/lib/systemd/system/multi-user.target.wants
-%if %{_repository} == "wearable"
install -m 644 %{SOURCE1} %{buildroot}/usr/lib/systemd/system/media-server.service
-%else
-install -m 644 %{SOURCE3} %{buildroot}/usr/lib/systemd/system/media-server.service
-%endif
ln -s ../media-server.service %{buildroot}/usr/lib/systemd/system/multi-user.target.wants/media-server.service
-%if %{_repository} == "wearable"
install -m 644 %{SOURCE2} %{buildroot}/usr/lib/systemd/system/media-scanner.service
#ln -s ../media-scanner.service %{buildroot}/usr/lib/systemd/system/multi-user.target.wants/media-scanner.service
-%endif
mkdir -p %{buildroot}/usr/etc
cp -rf %{_builddir}/%{name}-%{version}/media-server-plugin %{buildroot}/usr/etc/media-server-plugin
vconftool set -t string db/private/mediaserver/mmc_info "" -f -s media-server::vconf
%files
-%if %{_repository} == "wearable"
-%manifest wearable/media-server.manifest
-%else
-%manifest mobile/media-server.manifest
-%endif
+%manifest media-server.manifest
%defattr(-,root,root,-)
%{_bindir}/media-server
%{_bindir}/media-scanner
%{_bindir}/mediadb-update
/usr/lib/systemd/system/media-server.service
/usr/lib/systemd/system/multi-user.target.wants/media-server.service
-%if %{_repository} == "wearable"
/usr/lib/systemd/system/media-scanner.service
-%endif
#/usr/lib/systemd/system/multi-user.target.wants/media-scanner.service
/usr/etc/media-server-plugin
#License
void
ms_mmc_removed_handler(void);
+#ifndef DISABLE_NOTIFICATION
int
ms_present_mmc_status(ms_sdcard_status_type_t status);
+#endif
void
ms_mmc_vconf_cb(void *data);
typedef enum {
MS_SCAN_INVALID,
MS_SCAN_PART,
+ MS_SCAN_META,
MS_SCAN_ALL,
} ms_dir_scan_type_t;
#include <malloc.h>
#include <vconf.h>
#include <errno.h>
-#ifndef TIZEN_WEARABLE
+#ifndef TIZEN_W
#include <notification.h>
#endif
int
ms_present_mmc_status(ms_sdcard_status_type_t status)
{
-#ifndef TIZEN_WEARABLE
+#ifndef TIZEN_W
int ret = NOTIFICATION_ERROR_NONE;
update_lang();
if (status == MS_SDCARD_INSERTED)
ret = notification_status_message_post(_GETSYSTEMSTR("IDS_COM_BODY_PREPARING_SD_CARD"));
else if (status == MS_SDCARD_REMOVED)
- ret = notification_status_message_post(_GETSYSTEMSTR("IDS_COM_BODY_SD_CARD_REMOVED"));
+ ret = notification_status_message_post(_GETSYSTEMSTR("IDS_COM_BODY_SD_CARD_UNEXPECTEDLY_REMOVED"));
if(ret != NOTIFICATION_ERROR_NONE)
return MS_MEDIA_ERR_INTERNAL;
-#endif
+#endif /*TIZEN_W*/
return MS_MEDIA_ERR_NONE;
}
res = vconf_get_str(key);
if (res) {
strncpy(value, res, strlen(res) + 1);
+ free(res);
return true;
}
typedef int (*DELETE_ITEM)(void *, const char *, char **);
typedef int (*GET_FOLDER_LIST)(void *, char*, char ***, int **, int **, int *, char **);
typedef int (*UPDATE_FOLDER_TIME)(void *, const char *, char **);
+typedef int (*UPDATE_ITEM_META)(void *, const char *, int, char **);
+typedef int (*UPDATE_ITEM_BEGIN)(void *, int, char **);
+typedef int (*UPDATE_ITEM_END)(void *, char **);
int
msc_load_functions(void);
int
msc_insert_item_immediately(void **handle, const char *path);
+
+int
+msc_update_meta_batch(void **handle, const char *path);
+
/****************************************************************************************************
FOR BULK COMMIT
*****************************************************************************************************/
void
msc_validate_end(void **handle);
+void
+msc_update_start(void **handle);
+
+void
+msc_update_end(void **handle);
+
#endif /*_MEDIA_SCANNER_DB_SVC_H_*/
eDELETE_ITEM,
eGET_FOLDER_LIST,
eUPDATE_FOLDER_TIME,
+ eUPDATE_ITEM_META,
+ eUPDATE_ITEM_BEGIN,
+ eUPDATE_ITEM_END,
eFUNC_MAX
};
"delete_item",
"get_folder_list",
"update_folder_time",
+ "update_item_meta",
+ "update_item_begin",
+ "update_item_end",
};
/*init array for adding name of so*/
so_array = g_array_new(FALSE, FALSE, sizeof(char*));
dlerror(); /* Clear any existing error */
/*allocate for array of functions*/
- MS_MALLOC(func_array, sizeof(void*) * lib_num);
+ MS_MALLOC(func_array, sizeof(void**) * lib_num);
if (func_array == NULL) {
MSC_DBG_ERR("malloc failed");
MS_SAFE_FREE(scan_func_handle);
MS_SAFE_FREE(func_array);
MS_SAFE_FREE(scan_func_handle);
- MSC_DBG_ERR("dlsym failed");
+ MSC_DBG_ERR("dlsym failed [%s]", func_list[func_index]);
return MS_MEDIA_ERR_DYNAMIC_LINK;
}
}
}
} else {
/* the file has same name but it is changed, so we have to update DB */
+ MSC_DBG_WAN("DELETE ITEM [%s]", path);
ret = ((DELETE_ITEM)func_array[lib_index][eDELETE_ITEM])(handle[lib_index], path, &err_msg); /*dlopen*/
if (ret != 0) {
MSC_DBG_ERR("error : %s [%s] %s", g_array_index(so_array, char*, lib_index), err_msg, path);
MS_SAFE_FREE(err_msg);
res = MS_MEDIA_ERR_DB_DELETE_FAIL;
} else {
- ret = msc_insert_item_immediately(handle, path);
+ ret = msc_insert_item_batch(handle, path);
if (ret != 0) {
res = MS_MEDIA_ERR_DB_INSERT_FAIL;
} else {
return MS_MEDIA_ERR_NONE;
}
+int
+msc_update_meta_batch(void **handle, const char *path)
+{
+ int lib_index;
+ int res = MS_MEDIA_ERR_NONE;
+ int ret;
+ char *err_msg = NULL;
+ ms_storage_type_t storage_type;
+
+ storage_type = ms_get_storage_type_by_full(path);
+
+ MSC_DBG_ERR("");
+
+ for (lib_index = 0; lib_index < lib_num; lib_index++) {
+ ret = ((UPDATE_ITEM_META)func_array[lib_index][eUPDATE_ITEM_META])(handle[lib_index], path, storage_type, &err_msg); /*dlopen*/
+ if (ret != 0) {
+ MSC_DBG_ERR("error : %s [%s] %s", g_array_index(so_array, char*, lib_index), err_msg, path);
+ MS_SAFE_FREE(err_msg);
+ res = MS_MEDIA_ERR_DB_INSERT_FAIL;
+ }
+ }
+
+ return res;
+}
+
/****************************************************************************************************
FOR BULK COMMIT
*****************************************************************************************************/
}
}
+void
+msc_update_start(void **handle)
+{
+ int lib_index;
+ int ret = 0;
+ char *err_msg = NULL;
+
+ for (lib_index = 0; lib_index < lib_num; lib_index++) {
+ ret = ((UPDATE_ITEM_BEGIN)func_array[lib_index][eUPDATE_ITEM_BEGIN])(handle[lib_index], MSC_VALID_COUNT, &err_msg);/*dlopen*/
+ if (ret != 0) {
+ MSC_DBG_ERR("error : %s [%s]", g_array_index(so_array, char*, lib_index), err_msg);
+ MS_SAFE_FREE(err_msg);
+ }
+ }
+}
+
+void
+msc_update_end(void **handle)
+{
+ int lib_index;
+ int ret = 0;
+ char *err_msg = NULL;
+
+ for (lib_index = 0; lib_index < lib_num; lib_index++) {
+ ret = ((UPDATE_ITEM_END)func_array[lib_index][eUPDATE_ITEM_END])(handle[lib_index], &err_msg);/*dlopen*/
+ if (ret != 0) {
+ MSC_DBG_ERR("error : %s [%s]", g_array_index(so_array, char*, lib_index), err_msg);
+ MS_SAFE_FREE(err_msg);
+ }
+ }
+}
+
#include <dirent.h>
#include <errno.h>
#include <malloc.h>
-#ifdef TIZEN_WEARABLE
#include <dd-display.h>
-#else
-#include <pmapi.h>
-#endif
#include <vconf.h>
#include "media-util.h"
switch (status) {
case MS_DB_UPDATING:
-#ifdef TIZEN_WEARABLE
err = display_lock_state(LCD_OFF, STAY_CUR_STATE, 0);
-#else
- err = pm_lock_state(LCD_OFF, STAY_CUR_STATE, 0);
-#endif
if (err != 0)
res = MS_MEDIA_ERR_INTERNAL;
break;
case MS_DB_UPDATED:
-#ifdef TIZEN_WEARABLE
err = display_unlock_state(LCD_OFF, STAY_CUR_STATE);
-#else
- err = pm_unlock_state(LCD_OFF, STAY_CUR_STATE);
-#endif
if (err != 0)
res = MS_MEDIA_ERR_INTERNAL;
break;
}
}
/* update modified time of directory */
- msc_update_folder_time(handle, current_path);
+ if (scan_type == MS_MSG_STORAGE_PARTIAL
+ && storage_type == MS_STORAGE_INTERNAL)
+ msc_update_folder_time(handle, current_path);
} else {
MSC_DBG_ERR("%s folder opendir fails", current_path);
}
return;
}
+static int __msc_dir_scan_meta_update(void **handle, const char*start_path, ms_storage_type_t storage_type)
+{
+ DIR *dp = NULL;
+ GArray *dir_array = NULL;
+ struct dirent entry;
+ struct dirent *result = NULL;
+ int ret = MS_MEDIA_ERR_NONE;
+ char *new_path = NULL;
+ char *current_path = NULL;
+ char path[MS_FILE_PATH_LEN_MAX] = { 0 };
+ int (*scan_function)(void **, const char*) = msc_update_meta_batch;
+
+ /* make new array for storing directory */
+ dir_array = g_array_new (FALSE, FALSE, sizeof (char*));
+ if (dir_array == NULL){
+ MSC_DBG_ERR("g_array_new failed");
+ return MS_MEDIA_ERR_ALLOCATE_MEMORY_FAIL;
+ }
+ /* add first direcotiry to directory array */
+ g_array_append_val (dir_array, start_path);
+
+ /*start db update. the number of element in the array , db update is complete.*/
+ while (dir_array->len != 0) {
+ /*check poweroff status*/
+ ret = __msc_check_stop_status(storage_type);
+ if (ret != MS_MEDIA_ERR_NONE) {
+ goto STOP_SCAN;
+ }
+
+ /* get the current path from directory array */
+ current_path = g_array_index(dir_array , char*, 0);
+ g_array_remove_index (dir_array, 0);
+// MSC_DBG_SLOG("%d", dir_array->len);
+
+ if (__msc_check_scan_ignore(current_path)) {
+ MSC_DBG_ERR("%s is ignore", current_path);
+ MS_SAFE_FREE(current_path);
+ continue;
+ }
+
+ dp = opendir(current_path);
+ if (dp != NULL) {
+ while (!readdir_r(dp, &entry, &result)) {
+ /*check poweroff status*/
+ ret = __msc_check_stop_status(storage_type);
+ if (ret != MS_MEDIA_ERR_NONE) {
+ goto STOP_SCAN;
+ }
+
+ if (result == NULL)
+ break;
+
+ if (entry.d_name[0] == '.')
+ continue;
+
+ if (entry.d_type & DT_REG) {
+ MSC_DBG_ERR("");
+ if (ms_strappend(path, sizeof(path), "%s/%s", current_path, entry.d_name) != MS_MEDIA_ERR_NONE) {
+ MSC_DBG_ERR("ms_strappend failed");
+ continue;
+ }
+ /* insert into media DB */
+ MSC_DBG_ERR("%s", path);
+ if (scan_function(handle,path) != MS_MEDIA_ERR_NONE) {
+ MSC_DBG_ERR("failed to update db");
+ continue;
+ }
+ } else if (entry.d_type & DT_DIR) {
+ /* this request is recursive scanning */
+ if (ms_strappend(path, sizeof(path), "%s/%s", current_path, entry.d_name) != MS_MEDIA_ERR_NONE) {
+ MSC_DBG_ERR("ms_strappend failed");
+ continue;
+ }
+ /* add new directory to dir_array */
+ new_path = strdup(path);
+ g_array_append_val (dir_array, new_path);
+ }
+ }
+ } else {
+ MSC_DBG_ERR("%s folder opendir fails", current_path);
+ }
+ if (dp) closedir(dp);
+ dp = NULL;
+ MS_SAFE_FREE(current_path);
+ } /*db update while */
+STOP_SCAN:
+ if (dp) closedir(dp);
+
+ __msc_clear_file_list(dir_array);
+
+ if (ret != MS_MEDIA_ERR_NONE) MSC_DBG_INFO("ret : %d", ret);
+
+ return ret;
+}
+
+
+gboolean msc_metadata_update(void *data)
+{
+ ms_comm_msg_s *scan_data = data;
+ int err;
+ int ret;
+ void **handle = NULL;
+ char *start_path = NULL;
+ ms_storage_type_t storage_type = MS_STORAGE_INTERNAL;
+
+ MSC_DBG_INFO("META UPDATE START");
+
+ /*connect to media db, if conneting is failed, db updating is stopped*/
+ err = msc_connect_db(&handle);
+ if (err != MS_MEDIA_ERR_NONE)
+ return false;
+
+ /*call for bundle commit*/
+ msc_update_start(handle);
+
+ /*insert data into media db */
+
+ start_path = strdup(MEDIA_ROOT_PATH_INTERNAL);
+ ret = __msc_dir_scan_meta_update(handle, start_path, storage_type);
+
+ /* send notification */
+ msc_send_dir_update_noti(handle, MEDIA_ROOT_PATH_INTERNAL);
+
+ if (mmc_state == VCONFKEY_SYSMAN_MMC_MOUNTED) {
+ storage_type = MS_STORAGE_EXTERNAL;
+ start_path = strdup(MEDIA_ROOT_PATH_SDCARD);
+ ret = __msc_dir_scan_meta_update(handle, start_path, storage_type);
+ /* send notification */
+ msc_send_dir_update_noti(handle, MEDIA_ROOT_PATH_SDCARD);
+ }
+
+ /*call for bundle commit*/
+ msc_update_end(handle);
+
+ if (power_off) {
+ MSC_DBG_WAN("power off");
+ goto _POWEROFF;
+ }
+
+ /*disconnect form media db*/
+ if (handle) msc_disconnect_db(&handle);
+
+ /*Active flush */
+ malloc_trim(0);
+
+ msc_send_result(ret, scan_data);
+
+ MS_SAFE_FREE(scan_data);
+
+ MSC_DBG_INFO("META UPDATE END [%d]", ret);
+
+
+_POWEROFF:
+ MS_SAFE_FREE(scan_data);
+ if (handle) msc_disconnect_db(&handle);
+
+ return false;
+}
+
+
+void msc_metadata_update_thread(ms_comm_msg_s *recv_msg)
+{
+ g_thread_new("update_thread", (GThreadFunc)msc_metadata_update, recv_msg);
+}
g_async_queue_push(storage_queue, GINT_TO_POINTER(recv_msg));
}
break;
+ case MS_MSG_STORAGE_META:
+ msc_metadata_update_thread(recv_msg);
+ break;
default:
{
MSC_DBG_ERR("THIS REQUEST IS INVALID %d", req_num);
dlerror(); /* Clear any existing error */
/*allocate for array of functions*/
- MS_MALLOC(func_array, sizeof(void*) * lib_num);
+ MS_MALLOC(func_array, sizeof(void**) * lib_num);
if (func_array == NULL) {
MS_DBG_ERR("malloc failed");
MS_SAFE_FREE(func_handle);
static void __ms_remove_requst_receiver(GIOChannel *channel);
static void __ms_add_requst_receiver(GMainLoop *mainloop, GIOChannel **channel);
+static char *priv_lang = NULL;
+
bool check_process()
{
DIR *pdir;
ms_unload_functions();
}
-static void _db_backup(void)
-{
- int err = MS_MEDIA_ERR_NONE;
- void **handle = NULL;
-
- /*load functions from plusin(s)*/
- err = ms_load_functions();
- if (err != MS_MEDIA_ERR_NONE) {
- MS_DBG_ERR("function load failed");
- exit(0);
- }
-
- ms_connect_db(&handle);
-
- /*disconnect form media db*/
- if (handle) ms_disconnect_db(&handle);
-
- /*unload functions*/
- ms_unload_functions();
-}
-
void _ms_signal_handler(int n)
{
int stat, pid, thumb_pid;
return;
}
+void
+_ms_change_lang_vconf_cb(keynode_t *key, void* data)
+{
+ char lang[10] = {0,};
+ char *eng = "en";
+ char *chi = "zh";
+ char *jpn = "ja";
+ char *kor = "ko";
+ bool need_update = FALSE;
+
+ if (!ms_config_get_str(VCONFKEY_LANGSET, lang)) {
+ MS_DBG_ERR("Get VCONFKEY_LANGSET failed.");
+ return;
+ }
+
+ MS_DBG("CURRENT LANGUAGE [%s %s]", priv_lang, lang);
+
+ if (strcmp(priv_lang, lang) == 0) {
+ need_update = FALSE;
+ } else if ((strncmp(lang, eng, strlen(eng)) == 0) ||
+ (strncmp(lang, chi, strlen(chi)) == 0) ||
+ (strncmp(lang, jpn, strlen(jpn)) == 0) ||
+ (strncmp(lang, kor, strlen(kor)) == 0)) {
+ need_update = TRUE;
+ } else {
+ if ((strncmp(priv_lang, eng, strlen(eng)) == 0) ||
+ (strncmp(priv_lang, chi, strlen(chi)) == 0) ||
+ (strncmp(priv_lang, jpn, strlen(jpn)) == 0) ||
+ (strncmp(priv_lang, kor, strlen(kor)) == 0)) {
+ need_update = TRUE;
+ }
+ }
+
+ if (need_update) {
+ ms_send_storage_scan_request(NULL, MS_SCAN_META);
+ } else {
+ MS_DBG_WARN("language is changed but do not update meta data");
+ }
+
+ MS_SAFE_FREE(priv_lang);
+ priv_lang = strdup(lang);
+
+ return;
+}
+
static void _ms_check_pw_status(void)
{
int pw_status = 0;
static void __ms_remove_requst_receiver(GIOChannel *channel)
{
+ int fd = -1;
+
/*close an IO channel*/
- g_io_channel_unix_get_fd(channel);
+ fd = g_io_channel_unix_get_fd(channel);
g_io_channel_shutdown(channel, FALSE, NULL);
g_io_channel_unref(channel);
+
+ if (fd > 0) {
+ if (close(fd) < 0) {
+ MS_DBG_ERR("CLOSE ERROR %s", strerror(errno));
+ }
+ }
}
static void __ms_add_event_receiver(GIOChannel *channel)
{
int err;
+ char lang[10] = {0,};
/*set power off callback function*/
ms_add_poweoff_event_receiver(_power_off_cb,channel);
if (err == -1)
MS_DBG_ERR("add call back function for event %s fails", VCONFKEY_SYSMAN_MMC_STATUS);
+ if (!ms_config_get_str(VCONFKEY_LANGSET, lang)) {
+ MS_DBG_ERR("Get VCONFKEY_LANGSET failed.");
+ return;
+ }
+
+ priv_lang = strdup(lang);
+
+ err = vconf_notify_key_changed(VCONFKEY_LANGSET, (vconf_callback_fn) _ms_change_lang_vconf_cb, NULL);
+ if (err == -1)
+ MS_DBG_ERR("add call back function for event %s fails", VCONFKEY_LANGSET);
+
}
static void __ms_remove_event_receiver(void)
{
_db_clear();
+ /* update internal storage */
+ ms_send_storage_scan_request(MEDIA_ROOT_PATH_INTERNAL, MS_SCAN_PART);
+
/* update external storage */
if (ms_is_mmc_inserted()) {
ms_make_default_path_mmc();
case MS_SCAN_INVALID:
scan_msg.msg_type = MS_MSG_STORAGE_INVALID;
break;
+ case MS_SCAN_META:
+ scan_msg.msg_type = MS_MSG_STORAGE_META;
+ break;
default :
ret = MS_MEDIA_ERR_INVALID_PARAMETER;
MS_DBG_ERR("ms_send_storage_scan_request invalid parameter");
}
/* msg_size & msg */
- scan_msg.msg_size = strlen(root_path);
- strncpy(scan_msg.msg, root_path, scan_msg.msg_size );
+ if (root_path != NULL) {
+ scan_msg.msg_size = strlen(root_path);
+ strncpy(scan_msg.msg, root_path, scan_msg.msg_size );
+ }
ret = ms_send_scan_request(&scan_msg, -1);
g_shutdowning_thumb_server = FALSE;
}
usleep(200000);
-
+ g_io_channel_shutdown(g_udp_channel, FALSE, NULL);
+ g_io_channel_unref(g_udp_channel);
+ g_udp_channel = NULL;
+ g_communicate_sock = 0;
} else {
MS_DBG_ERR("g_server_pid is %d. Maybe there's problem in thumbnail-server", g_server_pid);
}
if (!_ms_thumb_agent_send_msg_to_thumb_server(recv_msg, &res_msg)) {
MS_DBG_ERR("_ms_thumb_agent_send_msg_to_thumb_server is failed");
+ thumbMsg res_msg;
+ memset((void *)&res_msg, 0, sizeof(res_msg));
+
+ res_msg.msg_type = 6; // THUMB_RESPONSE
+ res_msg.status = 1; //THUMB_FAIL
+ res_msg.origin_path_size = strlen(recv_msg->org_path);
+ strncpy(res_msg.org_path, recv_msg->org_path, res_msg.origin_path_size);
+ res_msg.dst_path[0] = '\0';
+ res_msg.dest_path_size = 1;
+
+ int buf_size = 0;
+ unsigned char *buf = NULL;
+ _ms_thumb_set_buffer(&res_msg, &buf, &buf_size);
+
+ if (send(client_sock, buf, buf_size, 0) != buf_size) {
+ MS_DBG_ERR("sendto failed : %s", strerror(errno));
+ } else {
+ MS_DBG("Sent Refuse msg from %s", recv_msg->org_path);
+ }
+
close(client_sock);
+
+ MS_SAFE_FREE(buf);
MS_SAFE_FREE(req->recv_msg);
MS_SAFE_FREE(req);
+
return TRUE;
}
}
res_msg.msg_type = 6; // THUMB_RESPONSE
res_msg.status = 1; //THUMB_FAIL
- res_msg.org_path[0] = '\0';
- res_msg.origin_path_size = 0;
+ res_msg.origin_path_size = strlen(recv_msg->org_path);
+ strncpy(res_msg.org_path, recv_msg->org_path, res_msg.origin_path_size);
res_msg.dst_path[0] = '\0';
- res_msg.dest_path_size = 0;
+ res_msg.dest_path_size = 1;
int buf_size = 0;
unsigned char *buf = NULL;
g_main_loop_unref(g_thumb_agent_loop);
+ close(sockfd);
+
return NULL;
}
projects / framework / multimedia / media-server.git / commitdiff