src/common/media-common-system.c \
src/common/media-common-external-storage.c \
src/common/media-common-db-svc.c \
- src/scanner-v2/media-scanner-db-manage-v2.c \
src/scanner-v2/media-scanner-common-v2.c \
src/scanner-v2/media-scanner-device-block-v2.c\
src/scanner-v2/media-scanner-scan-v2.c \
Name: media-server
Summary: A server for media content management
-Version: 0.6.6
+Version: 0.6.7
Release: 0
Group: Multimedia/Service
License: Apache-2.0
void ms_register_end(uid_t uid);
#ifdef _USE_TVPD_MODE
-int ms_cleanup_db(sqlite3 *handle, uid_t uid);
int ms_update_folder_time(sqlite3 *handle, const char *storage_id, char *folder_path, uid_t uid);
int ms_set_storage_scan_status(sqlite3 *handle, const char *storage_id, media_scan_status_e scan_status, uid_t uid);
int ms_genarate_uuid(char **uuid);
#define MS_NON_RECURSIVE 0
#define MS_SERVER_STATUS "memory/private/mediaserver/server_status"
-#define MS_DB_LIMIT "file/private/mediaserver/db_limit"
#define MS_DB_RESET "file/private/mediaserver/db_reset"
#define MS_MM_CONF_PATH SYSCONFDIR"/multimedia/"
#define MS_DUMMY_MEDIA_DB_PATH MS_MM_CONF_PATH".media.db"
#include "media-util.h"
#include "media-common-types.h"
-#ifdef _USE_TVPD_MODE
-#include <inttypes.h>
-#define MEDIA_DB_SIZE_LIMIT_2 20000000
-#define MEDIA_DB_SIZE_LIMIT_1 10000000
-#define MEDIA_DB_SPACE_LIMIT 20971520
-#endif
-
#define MS_SAFE_FREE(src) { if (src) {free(src); src = NULL; } }
bool ms_is_valid_symlink(const char *path);
bool ms_config_get_int(const char *key, int *value);
bool ms_config_set_int(const char *key, int value);
int ms_set_db_status(ms_db_status_type_t status);
-int ms_get_remain_space(uint64_t *free_space);
-int ms_check_size_mediadb(uid_t uid, uint64_t *db_size);
bool ms_storage_mount_status(const char *start_path);
bool ms_is_support_pvr(void);
int ms_set_vip_process(void);
typedef int (*REFRESH_ITEM)(sqlite3 *, const char *, const char *, uid_t);
#ifdef _USE_TVPD_MODE
-typedef int (*CLEANUP_DB)(sqlite3 *, uid_t);
typedef int (*UPDATE_FOLDER_TIME)(sqlite3 *, const char *, const char *, uid_t);
typedef int (*GET_UUID)(char **);
typedef int (*SET_STORAGE_SCAN_STATUS)(sqlite3 *, const char *, int, uid_t);
eGET_MEDIA_TYPE,
eREFRESH_ITEM,
#ifdef _USE_TVPD_MODE
- eCLEANUP_DB,
eUPDATE_FOLDER_TIME,
eGET_UUID,
eSET_STORAGE_SCAN_STATUS,
"get_media_type",
"refresh_item",
#ifdef _USE_TVPD_MODE
- "cleanup_db",
"update_folder_time",
"get_uuid",
"set_storage_scan_status",
media_db_disconnect(handle);
}
-static int __ms_check_item_exist(sqlite3 *handle, const char *storage_id, const char *path, bool *modified)
+static int __ms_check_item_exist(sqlite3 *handle, const char *path, bool *modified)
{
int ret = MS_MEDIA_ERR_NONE;
*modified = true;
MS_DBG_RETVM_IF(!MS_STRING_VALID(path), MS_MEDIA_ERR_INVALID_PARAMETER, "path is NULL");
-
-#ifdef _USE_TVPD_MODE
- MS_DBG_RETVM_IF(!MS_STRING_VALID(storage_id), MS_MEDIA_ERR_INVALID_PARAMETER, "storage_id is NULL");
-
- sql = sqlite3_mprintf("SELECT media_modified_time, media_size FROM '%q' WHERE media_path='%q'", storage_id, path);
-#else
sql = sqlite3_mprintf("SELECT media_modified_time, media_size FROM media WHERE media_path='%q'", path);
-#endif
ret = media_db_get_result(handle, sql, &sql_stmt);
sqlite3_free(sql);
int ret = MS_MEDIA_ERR_NONE;
bool modified = false;
- ret = __ms_check_item_exist(handle, storage_id, path, &modified);
+ ret = __ms_check_item_exist(handle, path, &modified);
if (ret == MS_MEDIA_ERR_DB_NO_RECORD) {
#ifdef _USE_TVPD_MODE
ret = ms_scan_item_batch(handle, storage_id, path, uid);
int ret = MS_MEDIA_ERR_NONE;
MS_DBG_RETVM_IF(!MS_STRING_VALID(storage_id), MS_MEDIA_ERR_INVALID_PARAMETER, "storage_id is NULL");
-#ifdef _USE_TVPD_MODE
- char *sql = sqlite3_mprintf("UPDATE '%q' SET validity=%d;", storage_id, validity);
-#else
char *sql = sqlite3_mprintf("UPDATE media SET validity=%d WHERE storage_uuid=%Q;", validity, storage_id);
-#endif
ret = media_db_update_db_direct(sql, uid);
sqlite3_free(sql);
thumb_list = g_ptr_array_new_with_free_func(g_free);
MS_DBG_RETVM_IF(!MS_STRING_VALID(storage_id), MS_MEDIA_ERR_INVALID_PARAMETER, "storage_id is NULL");
-#ifdef _USE_TVPD_MODE
- char *sql = sqlite3_mprintf("SELECT media_thumbnail_path FROM '%q' WHERE validity IN (%d, %d) AND media_thumbnail_path IS NOT NULL", storage_id, MS_INVALID, MS_SCANNING);
-#else
char *sql = sqlite3_mprintf("SELECT media_thumbnail_path FROM media WHERE validity IN (%d, %d) AND media_thumbnail_path IS NOT NULL AND storage_uuid=%Q", MS_INVALID, MS_SCANNING, storage_id);
-#endif
MS_DBG_SLOG("[SQL query] : %s", sql);
ret = media_db_get_result(handle, sql, &sql_stmt);
sqlite3_finalize(sql_stmt);
-#ifdef _USE_TVPD_MODE
- sql = sqlite3_mprintf("DELETE FROM '%q' WHERE validity IN (%d, %d)", storage_id, MS_INVALID, MS_SCANNING);
-#else
sql = sqlite3_mprintf("DELETE FROM media WHERE validity IN (%d, %d) AND storage_uuid=%Q", MS_INVALID, MS_SCANNING, storage_id);
-#endif
ret = media_db_update_db_direct(sql, uid);
sqlite3_free(sql);
MS_DBG_RETVM_IF(!MS_STRING_VALID(storage_id), MS_MEDIA_ERR_INVALID_PARAMETER, "storage_id is NULL");
MS_DBG_RETVM_IF(!MS_STRING_VALID(path), MS_MEDIA_ERR_INVALID_PARAMETER, "path is NULL");
-#ifdef _USE_TVPD_MODE
- if (recursive)
- sql = sqlite3_mprintf("UPDATE '%q' SET validity=%d WHERE media_path LIKE '%q/%%';", storage_id, validity, path);
- else
- sql = sqlite3_mprintf("UPDATE '%q' SET validity=%d WHERE folder_id IN (SELECT folder_id FROM folder WHERE folder_path='%q' AND storage_uuid='%q');", storage_id, validity, path, storage_id);
-#else
if (recursive)
sql = sqlite3_mprintf("UPDATE media SET validity=%d WHERE media_path LIKE '%q/%%';", validity, path);
else
sql = sqlite3_mprintf("UPDATE media SET validity=%d WHERE folder_id=(SELECT folder_id FROM folder WHERE folder_path=%Q);", validity, path, storage_id);
-#endif
ret = media_db_update_db_direct(sql, uid);
sqlite3_free(sql);
char *sql = NULL;
MS_DBG_RETVM_IF(path == NULL, MS_MEDIA_ERR_INVALID_PARAMETER, "path is NULL");
-#ifdef _USE_TVPD_MODE
- MS_DBG_RETVM_IF(storage_id == NULL, MS_MEDIA_ERR_INVALID_PARAMETER, "storage_id is NULL");
- sql = sqlite3_mprintf("SELECT folder_id FROM folder WHERE (storage_uuid='%q' AND folder_path='%q')", storage_id, path);
-#else
sql = sqlite3_mprintf("SELECT folder_id FROM folder WHERE folder_path=%Q", path);
-#endif
ret = media_db_get_result(handle, sql, &sql_stmt);
sqlite3_free(sql);
MS_DBG_RETV_IF(ret != MS_MEDIA_ERR_NONE, ret);
}
#ifdef _USE_TVPD_MODE
-int ms_cleanup_db(sqlite3 *handle, uid_t uid)
-{
- int ret = MS_MEDIA_ERR_NONE;
-
- ret = ((CLEANUP_DB)func_array[eCLEANUP_DB])(handle, uid);
- MS_DBG_RETVM_IF(ret != MS_MEDIA_ERR_NONE, ret, "CLEANUP_DB failed [%d]", ret);
-
- MS_DBG_INFO("Cleanup Media DB");
-
- return ret;
-}
-
int ms_update_folder_time(sqlite3 *handle, const char *storage_id, char *folder_path, uid_t uid)
{
int ret = MS_MEDIA_ERR_NONE;
return false;
}
-int ms_get_remain_space(uint64_t *free_space)
-{
- int ret = MS_MEDIA_ERR_NONE;
- const char *path = "/opt";
- struct statvfs s;
-
- ret = statvfs(path, &s);
- if (ret != 0) {
- MS_DBG_ERR("statvfs failed[%d]", ret);
- MS_DBG_STRERROR();
- return MS_MEDIA_ERR_INTERNAL;
- }
-
- /* f_bsize:unsigned long, f_bavail:fsblkcnt_t(unsigned long) */
- *free_space = (uint64_t)s.f_bsize * (uint64_t)s.f_bavail;
-
- return MS_MEDIA_ERR_NONE;
-}
-
bool ms_is_support_pvr(void)
{
bool bSupportPVR = false;
return ret;
}
-int ms_check_size_mediadb(uid_t uid, uint64_t *db_size)
-{
- int ret = MS_MEDIA_ERR_NONE;
- char *db_path = NULL;
- struct stat buf;
-
- ret = ms_user_get_media_db_path(uid, &db_path);
-
- if (stat(db_path, &buf) == 0) {
- *db_size = (uint64_t)buf.st_size;
- } else {
- MS_DBG_STRERROR("stat failed");
- ret = MS_MEDIA_ERR_INTERNAL;
- }
-
- g_free(db_path);
-
- return ret;
-}
-
int ms_set_db_status(ms_db_status_type_t status)
{
int ret = MS_MEDIA_ERR_NONE;
+++ /dev/null
-/*
- * Media Server
- *
- * Copyright (c) 2000 - 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 _MEDIA_SCANNER_DB_MANAGER_V2_H_
-#define _MEDIA_SCANNER_DB_MANAGER_V2_H_
-
-#include "media-common-types.h"
-
-int msc_check_db_size(uid_t uid, ms_msg_type_e msg_type);
-int msc_cleanup_invalid_values(uid_t uid);
-
-#endif
+++ /dev/null
-/*
- * Media Server
- *
- * Copyright (c) 2000 - 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.
- *
- */
-
-#include "media-util.h"
-#include "media-common-utils.h"
-#include "media-common-system.h"
-#include "media-common-db-svc.h"
-#include "media-scanner-dbg-v2.h"
-#include "media-scanner-db-manage-v2.h"
-
-int msc_check_db_size(uid_t uid, ms_msg_type_e msg_type)
-{
- uint64_t db_size = 0;
- uint64_t free_space = 0;
- int err = MS_MEDIA_ERR_NONE;
-
- ms_check_size_mediadb(uid, &db_size);
-
- if (msg_type == MS_MSG_STORAGE_ALL || msg_type == MS_MSG_STORAGE_PARTIAL) {
- if (db_size >= MEDIA_DB_SIZE_LIMIT_1) {
- MS_DBG_ERR("DB SIZE [%" PRIu64"] reach the MEDIA_DB_SIZE_LIMIT_1[%d]", db_size, MEDIA_DB_SIZE_LIMIT_1);
- return MS_MEDIA_ERR_DB_LIMIT_1;
- }
- } else if (msg_type == MS_MSG_DIRECTORY_SCANNING_NON_RECURSIVE || msg_type == MS_MSG_DIRECTORY_SCANNING) {
- if (db_size >= MEDIA_DB_SIZE_LIMIT_2) {
- MS_DBG_ERR("DB SIZE [%" PRIu64"] reach the MEDIA_DB_SIZE_LIMIT_2[%d]", db_size, MEDIA_DB_SIZE_LIMIT_2);
-
- MS_DBG_WARN("START REMOVE INVALID DATA");
- msc_cleanup_invalid_values(uid);
- MS_DBG_WARN("END REMOVE INVALID DATA");
-
- ms_check_size_mediadb(uid, &db_size);
- if (db_size >= MEDIA_DB_SIZE_LIMIT_2) {
-
- ms_config_set_int(MS_DB_LIMIT, 0);
-
- MS_DBG_ERR("DB IS FULL. CANNOT UPDATE");
- return MS_MEDIA_ERR_DB_FULL_FAIL;
- }
- }
- }
-
- /*check remain space*/
- err = ms_get_remain_space(&free_space);
- if (err != MS_MEDIA_ERR_NONE) {
- MS_DBG_ERR("ms_get_remain_space failed");
- } else {
- if (free_space < MEDIA_DB_SPACE_LIMIT) {
- MS_DBG_ERR("FREE SPACE [%" PRIu64"] DB SIZE [%" PRIu64"]", free_space, db_size);
- return MS_MEDIA_ERR_NOT_ENOUGH_SPACE;
- }
- }
-
- return MS_MEDIA_ERR_NONE;
-}
-
-int msc_cleanup_invalid_values(uid_t uid)
-{
- int ret = MS_MEDIA_ERR_NONE;
- sqlite3 *handle = NULL;
-
- MS_DBG_ERR("START CLEANUP MEDIA DB");
-
- ms_connect_db(&handle, uid);
- ret = ms_cleanup_db(handle, uid);
- ms_disconnect_db(handle);
- MS_DBG_ERR("END CLEANUP MEDIA DB : ret[%d]", ret);
-
- return ret;
-}
#include "media-common-db-svc.h"
#include "media-scanner-dbg-v2.h"
#include "media-scanner-common-v2.h"
-#include "media-scanner-db-manage-v2.h"
#include "media-scanner-socket-v2.h"
#include "media-scanner-extract-v2.h"
goto NEXT;
}
- ret = msc_check_db_size(extract_data->uid, extract_data->msg_type);
- if (ret != MS_MEDIA_ERR_NONE) {
- MS_DBG_ERR("NOT ENOUGH MEMORY");
- if (ret == MS_MEDIA_ERR_DB_FULL_FAIL)
- ret = MS_MEDIA_ERR_NONE;
-
- goto NEXT;
- }
-
ret = __msc_folder_bulk_extract(handle, extract_data->storage_id, extract_data->msg, extract_data->msg_type, extract_data->pid, end_flag, extract_data->uid);
NEXT:
ms_set_storage_scan_status(handle, extract_data->storage_id, MEDIA_EXTRACT_PROCESSING, extract_data->uid);
__msc_extract_set_db_status(MS_DB_UPDATING);
- ret = msc_check_db_size(extract_data->uid, extract_data->msg_type);
- if (ret != MS_MEDIA_ERR_NONE) {
- MS_DBG_ERR("NOT ENOUGH MEMORY");
- __msc_extract_set_db_status(MS_DB_STOPPED);
- goto NEXT;
- }
-
/*extract meta*/
ret = __msc_folder_bulk_extract(handle, extract_data->storage_id, extract_data->msg, extract_data->msg_type, extract_data->pid, end_flag, extract_data->uid);
MS_DBG_WARN("extract PAUSE");
#include "media-scanner-socket-v2.h"
#include "media-scanner-scan-v2.h"
#include "media-scanner-extract-v2.h"
-#include "media-scanner-db-manage-v2.h"
#define MAX_SCAN_COUNT 300
static void __msc_set_storage_scan_cur_path(char *scan_path);
static void __msc_set_dir_scan_cur_path(char *scan_path);
static int __msc_dir_and_storage_scan_same_path(char *start_path);
-static int __msc_check_memory_status(uid_t uid);
-static int __msc_check_remain_space(uid_t uid);
static void __msc_del_blocked_path(void);
void msc_init_scan_thread(void)
continue;
}
- ret = msc_check_db_size(uid, msg_type);
- if (ret != MS_MEDIA_ERR_NONE) {
- if (ret == MS_MEDIA_ERR_DB_FULL_FAIL)
- ret = MS_MEDIA_ERR_NONE;
-
- if (is_recursive)
- ms_change_validity_item_batch(handle, storage_id, new_start_path, 1, 2, uid);
-
- goto STOP_SCAN;
- }
-
ms_set_folder_scan_status(handle, storage_id, current_path, MS_DIR_SCAN_PROCESSING, uid);
sleep_count = 0;
goto STOP_SCAN;
}
- ret = msc_check_db_size(uid, msg_type);
- if (ret != MS_MEDIA_ERR_NONE) {
- if (ret == MS_MEDIA_ERR_DB_FULL_FAIL)
- ret = MS_MEDIA_ERR_NONE;
-
- if (is_recursive)
- ms_change_validity_item_batch(handle, storage_id, new_start_path, 1, 2, uid);
-
- goto STOP_SCAN;
- }
-
if (dir_entry->d_name[0] == '.')
continue;
continue;
}
- ret = msc_check_db_size(uid, msg_type);
- if (ret != MS_MEDIA_ERR_NONE)
- goto STOP_SCAN;
-
ms_get_folder_scan_status(handle, storage_id, current_path, (int *)&scan_status);
if (scan_status == MS_DIR_SCAN_PROCESSING && g_directory_scan_processing2 != DIR_SCAN_NON_SCAN) {
if (ret != MS_MEDIA_ERR_NONE)
goto STOP_SCAN;
- ret = msc_check_db_size(uid, msg_type);
- if (ret != MS_MEDIA_ERR_NONE)
- goto STOP_SCAN;
-
if (dir_entry->d_name[0] == '.')
continue;
goto NEXT;
}
- /*check remain space*/
- if (__msc_check_remain_space(scan_data->uid) != MS_MEDIA_ERR_NONE)
- goto SCAN_DONE;
-
g_mutex_lock(&scan_item_mutex);
__msc_set_scan_item(&cur_scan_item, scan_data->msg, scan_data->pid);
g_mutex_unlock(&scan_item_mutex);
goto NEXT;
}
- ret = __msc_check_memory_status(scan_data->uid);
- if (ret != MS_MEDIA_ERR_NONE) {
- ms_set_storage_scan_status(handle, scan_data->storage_id, MEDIA_SCAN_STOP, scan_data->uid);
- MS_DBG_ERR("storage_id = [%s]", scan_data->storage_id);
- msc_insert_exactor_request(scan_data->msg_type, true, scan_data->storage_id, scan_data->msg, scan_data->pid, scan_data->uid, MS_ITEM_UPDATE);
- goto NEXT;
- }
-
ms_set_storage_scan_status(handle, scan_data->storage_id, MEDIA_SCAN_PROCESSING, scan_data->uid);
ms_set_db_status(MS_DB_UPDATING);
MS_DBG_FLEAVE();
}
-static int __msc_check_memory_status(uid_t uid)
-{
- int ret = MS_MEDIA_ERR_NONE;
- uint64_t db_size = 0;
-
- /*check remain space*/
- ret = __msc_check_remain_space(uid);
- MS_DBG_RETV_IF(ret != MS_MEDIA_ERR_NONE, ret);
-
- /*check db size*/
- ms_check_size_mediadb(uid, &db_size);
- if (db_size >= MEDIA_DB_SIZE_LIMIT_1) {
- MS_DBG_ERR("DB SIZE [%" PRIu64"] REACH THE FIRST LIMIT [%d]", db_size, MEDIA_DB_SIZE_LIMIT_1);
- return MS_MEDIA_ERR_DB_LIMIT_1;
- }
-
- return MS_MEDIA_ERR_NONE;
-}
-
-static int __msc_check_remain_space(uid_t uid)
-{
- int err = MS_MEDIA_ERR_NONE;
- uint64_t free_space = 0;
- uint64_t db_size = 0;
-
- err = ms_get_remain_space(&free_space);
- if (err != MS_MEDIA_ERR_NONE) {
- MS_DBG_ERR("ms_get_remain_space failed");
- } else {
- if (free_space < MEDIA_DB_SPACE_LIMIT) {
- MS_DBG_ERR("NOT ENOUGH SPACE WE DO NOT UPDATE MEDIA DB FREE SPACE [%" PRIu64"]", free_space);
-
- ms_config_set_int(MS_DB_LIMIT, 0);
-
- return MS_MEDIA_ERR_NOT_ENOUGH_SPACE;
- }
- }
-
- err = ms_check_size_mediadb(uid, &db_size);
- if (err != MS_MEDIA_ERR_NONE) {
- MS_DBG_ERR("msc_check_dbsize failed");
- } else {
- if (db_size >= MEDIA_DB_SIZE_LIMIT_2) {
- MS_DBG_ERR("REACH LIMIT DB SIZE [%" PRIu64"]", db_size);
-
- MS_DBG_ERR("START REMOVE INVALID DATA");
- msc_cleanup_invalid_values(uid);
- MS_DBG_ERR("END REMOVE INVALID DATA");
-
- ms_check_size_mediadb(uid, &db_size);
- if (db_size >= MEDIA_DB_SIZE_LIMIT_2) {
-
- ms_config_set_int(MS_DB_LIMIT, 0);
-
- MS_DBG_ERR("DB IS FULL. CANNOT UPDATE[%" PRIu64"]", db_size);
- return MS_MEDIA_ERR_DB_FULL_FAIL;
- }
- }
- }
-
- return MS_MEDIA_ERR_NONE;
-}
-
void msc_init_scanner(void)
{
if (!scan_queue2) scan_queue2 = g_async_queue_new();
#include "media-common-types.h"
int ms_reset_mediadb(uid_t uid);
-int ms_check_mediadb(uid_t uid, bool *is_reset);
int ms_check_corrupt_mediadb(void);
#endif
#endif
return ret;
}
-static int __ms_remake_mediadb(uid_t uid)
-{
- sqlite3 *handle = NULL;
-
- MS_DBG_ERR("THE SIZE OF MEDIA DB REACH THE LIMIT. RESET MEDIA DB.");
-
- /*write read schema*/
- ms_config_set_int(MS_DB_RESET, 1);
- ms_reset_mediadb(uid);
-
- ms_connect_db(&handle, uid);
-
- MS_DBG_WARN("START WRITE SCHEMA");
- if (ms_check_db(handle, uid) != MS_MEDIA_ERR_NONE)
- MS_DBG_ERR("ms_check_db fail");
-
- MS_DBG_WARN("END WRITE SCHEMA");
-
- /*disconnect form media db*/
- ms_disconnect_db(handle);
-
- ms_config_set_int(MS_DB_RESET, 0);
- return MS_MEDIA_ERR_NONE;
-}
-
-int ms_check_mediadb(uid_t uid, bool *is_reset)
-{
- uint64_t db_size = 0;
-
- ms_check_size_mediadb(uid, &db_size);
-
- MS_DBG_WARN("[DB SIZE : %" PRIu64"] [LIMIT1 : %d] [LIMIT2 : %d]", db_size, MEDIA_DB_SIZE_LIMIT_1, MEDIA_DB_SIZE_LIMIT_2);
- if (db_size > MEDIA_DB_SIZE_LIMIT_2) {
- MS_DBG_ERR("THE SIZE OF MEDIA DB REACH THE LIMIT. RESET MEDIA DB.");
- MS_DBG_ERR("[DB SIZE : %" PRIu64"] [LIMIT1 : %d] [LIMIT2 : %d]", db_size, MEDIA_DB_SIZE_LIMIT_1, MEDIA_DB_SIZE_LIMIT_2);
- __ms_remake_mediadb(uid);
- *is_reset = true;
- }
-
- return MS_MEDIA_ERR_NONE;
-}
-
int ms_check_corrupt_mediadb(void)
{
sqlite3 *db_handle = NULL;
return;
ms_connect_db(&handle, uid);
+ ret = ms_get_storage_id(handle, mount_path, device_id, uid);
- while (1) {
- memset(device_id, 0x0, sizeof(device_id));
- ret = ms_get_storage_id(handle, mount_path, device_id, uid);
+ MS_DBG_SWARN("removed path [%s %s]", mount_path, device_id);
- MS_DBG_SWARN("removed path [%s %s]", mount_path, device_id);
+ if (ret != MS_MEDIA_ERR_NONE) {
+ MS_DBG_ERR("Device ID is INVALID");
+ ms_disconnect_db(handle);
+ return;
+ }
- if (ret != MS_MEDIA_ERR_NONE) {
- MS_DBG_ERR("Device ID is INVALID");
- break;
- }
+ ms_set_storage_validity(handle, device_id, 0, uid);
- ms_set_storage_validity(handle, device_id, 0, uid);
+ /* update storage_id table set validity=0 first */
+ if (ms_validity_change_all_items(handle, device_id, false, uid) != MS_MEDIA_ERR_NONE)
+ MS_DBG_ERR("ms_validity_change_all_items failed");
+ /* folder validity set 0 under the start_path in folder table*/
+ if (ms_set_folder_validity(handle, device_id, mount_path, MS_INVALID, true, uid) != MS_MEDIA_ERR_NONE)
+ MS_DBG_ERR("set_folder_validity failed");
- /* update storage_id table set validity=0 first */
- if (ms_validity_change_all_items(handle, device_id, false, uid) != MS_MEDIA_ERR_NONE)
- MS_DBG_ERR("ms_validity_change_all_items failed");
- /* folder validity set 0 under the start_path in folder table*/
- if (ms_set_folder_validity(handle, device_id, mount_path, MS_INVALID, true, uid) != MS_MEDIA_ERR_NONE)
- MS_DBG_ERR("set_folder_validity failed");
-
- if (ms_get_scanner_status()) {
- /*If the media scanner is running, the removed USB can be queueing in the job list.*/
- /*So try to remove it.*/
- ms_send_storage_scan_request(mount_path, device_id, MS_SCAN_INVALID, uid);
- }
-
- media_db_update_send(getpid(), MS_MEDIA_ITEM_STORAGE, MS_MEDIA_ITEM_UPDATE, mount_path, device_id, 0, PROD_CUSTOM_MIME_REMOVED);
+ if (ms_get_scanner_status()) {
+ /*If the media scanner is running, the removed USB can be queueing in the job list.*/
+ /*So try to remove it.*/
+ ms_send_storage_scan_request(mount_path, device_id, MS_SCAN_INVALID, uid);
}
+ media_db_update_send(getpid(), MS_MEDIA_ITEM_STORAGE, MS_MEDIA_ITEM_UPDATE, mount_path, device_id, 0, PROD_CUSTOM_MIME_REMOVED);
+
ms_disconnect_db(handle);
}
void ms_device_block_changed_cb(usb_device_h usb_device, char *action, void *user_data)
{
char *mount_path = NULL;
- bool is_reset = false;
- uid_t uid = ms_sys_get_uid();
MS_DBG_WARN("usb_event_callback BEGIN[%s]", action);
if (!usb_device) {
mount_path = usb_device_get_mountpath(usb_device);
- ms_check_mediadb(uid, &is_reset);
-
#ifdef _USE_ON_DEMAND
ms_block_info_s block_info = { mount_path, 0, NULL };
ms_on_demand_insert_storage((gpointer)&block_info, NULL);
} else if (!strcmp(action, "blocked")) { /*unmount->blocked stop accessing usb in time*/
MS_DBG_SWARN("USB blocked, mountpath : %s", mount_path);
- if (!is_reset)
- ms_on_demand_remove_storage((gpointer)&block_info, NULL);
+ ms_on_demand_remove_storage((gpointer)&block_info, NULL);
}
#else
if (!strcmp(action, "mounted")) {
ms_device_handle_usb_added(mount_path);
} else if (!strcmp(action, "blocked")) { /*unmount->blocked stop accessing usb in time*/
MS_DBG_SWARN("USB blocked, mountpath : %s", mount_path);
- if (!is_reset)
- ms_device_handle_usb_removed(mount_path);
+ ms_device_handle_usb_removed(mount_path);
}
#endif
free_usb_device_h(usb_device);
- if (is_reset)
- ms_check_mounted_storage(uid);
-
MS_DBG_WARN("usb_event_callback END[%s]", action);
}
}
uid_t uid = ms_sys_get_uid();
- uint64_t db_size = 0;
- uint64_t free_space = 0;
__ms_deal_reset_status();
#endif
mainloop = g_main_loop_new(NULL, FALSE);
#ifdef _USE_TVPD_MODE
- ms_check_size_mediadb(uid, &db_size);
- ms_get_remain_space(&free_space);
- MS_DBG_WARN("DB SIZE[%" PRIu64"] LIMIT1[%d] LIMIT2[%d] FREE SPACE[%" PRIu64"] SPACE LIMIT[%d]", db_size, MEDIA_DB_SIZE_LIMIT_1, MEDIA_DB_SIZE_LIMIT_2, free_space, MEDIA_DB_SPACE_LIMIT);
-
- if (db_size > MEDIA_DB_SIZE_LIMIT_2) {
- MS_DBG_ERR("THE SIZE OF MEDIA DB REACH THE LIMIT. RESET MEDIA DB.");
- ms_reset_mediadb(uid);
-#ifdef _USE_ON_DEMAND
- need_checkdb = true;
- ms_on_demand_reset_storage();
-#endif
- }
-
if (ms_check_corrupt_mediadb() != MS_MEDIA_ERR_NONE) {
MS_DBG_ERR("MEDIA DB IS CORRUPTED. RESET MEDIA DB.");
ms_reset_mediadb(uid);
projects / platform / core / multimedia / media-server.git / commitdiff