Redefine Comunicate msg on DCM and use it commonly with DCM server

Change-Id: I676254f27228cd649fbcb4362b8e94e47bad4524

diff --git a/lib/include/media-server-ipc.h b/lib/include/media-server-ipc.h
index c7c6958..ee37fcf 100755 (executable)
--- a/lib/include/media-server-ipc.h
+++ b/lib/include/media-server-ipc.h
@@ -59,12 +59,10 @@ typedef enum {
        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_STORAGE_META,                                    /**< Request updating meta data */
        MS_MSG_DIRECTORY_SCANNING_CANCEL,       /**< Request cancel directory scan*/
        MS_MSG_STORAGE_SCANNER_COMPLETE,        /**< Storage Scanner complete */
        MS_MSG_DIRECTORY_SCANNER_COMPLETE,      /**< Directory Scanner complete */
-       MS_MSG_DCM_SERVER_READY,                        /**< Ready from dcm server */
-       MS_MSG_DCM_EXTRACT_ALL_DONE,            /**< Done of all-dcm extracting */
        MS_MSG_SCANNER_PARTIAL,
        MS_MSG_SCANNER_COMPLETE,
        MS_MSG_EXTRACTOR_COMPLETE,
@@ -117,10 +115,6 @@ typedef struct _thumbMsg {
 } thumbMsg;
 
 typedef struct {
-       ms_msg_type_e msg_type;
-} ms_dcm_server_msg;
-
-typedef struct {
        int msg_type;
        int pid;
        uid_t uid;
@@ -129,4 +123,17 @@ typedef struct {
        int result;
 } dcmMsg;
 
+typedef enum {
+       DCM_MSG_REQUEST_MEDIA,                  /**< request single media extracting. msg from media server to dcm server*/
+       DCM_MSG_REQUEST_ALL_MEDIA,              /**< request all media extracting. msg from media server to dcm server*/
+       DCM_MSG_REQUEST_CANCEL_FACE,    /**< request cancel single media extracting. msg from media server to dcm server*/
+       DCM_MSG_REQUEST_KILL_SERVER,            /**< request dcm server terminating. msg from media server to dcm server*/
+       DCM_MSG_SCAN_READY,                             /**< scan thread in dcm server is ready. msg from scan thread to main thread in dcm server*/
+       DCM_MSG_SCAN_COMPLETED,                 /**< all media extracting is done. msg from scan thread to main thread in dcm server*/
+       DCM_MSG_SCAN_TERMINATED,                /**< scan thread in dcm server is terminated. msg from scan thread to main thread in dcm server*/
+       DCM_MSG_SERVER_READY,                   /**< dcm server is ready. msg from dcm server to media server*/
+       DCM_MSG_EXTRACT_ALL_DONE,               /**< all-dcm extracting done. msg from dcm server to media server*/
+       DCM_MSG_MAX,
+} ms_dcm_msg_type_e;
+
 #endif /*_MEDIA_SERVER_IPC_H_*/

diff --git a/lib/media-util-dcm.c b/lib/media-util-dcm.c
index 8913b4e..0101b24 100755 (executable)
--- a/lib/media-util-dcm.c
+++ b/lib/media-util-dcm.c
@@ -54,13 +54,6 @@ typedef struct {
        faceUserData *userData;
 } dcmReq;
 
-enum {
-       DCM_REQUEST_MEDIA,
-       DCM_REQUEST_ALL_MEDIA,
-       DCM_REQUEST_START_FACE_DETECTION,
-       DCM_REQUEST_CANCEL_FACE,
-};
-
 extern char MEDIA_IPC_PATH[][70];
 
 int __media_dcm_check_req_queue(const char *path);
@@ -157,7 +150,7 @@ int __media_dcm_check_req_queue_for_cancel(unsigned int request_id, const char *
 
                if (req != NULL && strncmp(path, req->path, strlen(path)) == 0 && request_id == req->request_id) {
                        req->isCanceled = true;
-                       __media_dcm_shutdown_channel(false);
+                       __media_dcm_shutdown_channel(FALSE);
 
                        return MS_MEDIA_ERR_NONE;
                }
@@ -342,8 +335,7 @@ int _media_dcm_send_request()
 
        MSAPI_DBG("Sending msg to dcm service is successful");
 
-
-       if (req_manager->msg_type == DCM_REQUEST_MEDIA/*DCM_REQUEST_INSERT_FACE*/) {
+       if (req_manager->msg_type == DCM_MSG_REQUEST_MEDIA/*DCM_REQUEST_INSERT_FACE*/) {
                if (g_request_queue == NULL) {
                        g_request_queue = g_queue_new();
                }
@@ -355,7 +347,7 @@ int _media_dcm_send_request()
                }
 
                dcm_req->channel = channel;
-               dcm_req->path = strdup(req_manager->path);
+               dcm_req->path = g_strdup(req_manager->path);
                dcm_req->source_id = source_id;
                dcm_req->userData = req_manager->userData;
 
@@ -439,11 +431,11 @@ int _media_dcm_request_async(int msg_type, const unsigned int request_id, const
 {
        int err = MS_MEDIA_ERR_NONE;
 
-       MSAPI_DBG("Path : %s", path);
+       MSAPI_DBG_SLOG("Path : %s", path);
 
        if (g_manage_queue == NULL) {
                MSAPI_DBG("g_manage_queue is NULL");
-               if (msg_type == DCM_REQUEST_CANCEL_FACE)
+               if (msg_type == DCM_MSG_REQUEST_CANCEL_FACE)
                        return MS_MEDIA_ERR_INTERNAL;
 
                g_manage_queue = g_queue_new();
@@ -456,7 +448,7 @@ int _media_dcm_request_async(int msg_type, const unsigned int request_id, const
                }
 
                dcm_req->msg_type = msg_type;
-               dcm_req->path = strdup(path);
+               dcm_req->path = g_strdup(path);
                dcm_req->userData = userData;
                dcm_req->isCanceled = FALSE;
                dcm_req->request_id = request_id;
@@ -470,7 +462,7 @@ int _media_dcm_request_async(int msg_type, const unsigned int request_id, const
 
        } else {
                MSAPI_DBG("g_manage_queue is not NULL");
-               if (msg_type != DCM_REQUEST_CANCEL_FACE) {
+               if (msg_type != DCM_MSG_REQUEST_CANCEL_FACE) {
                        /* Enqueue */
                        dcmReq *dcm_req = NULL;
                        dcm_req = calloc(1, sizeof(dcmReq));
@@ -480,7 +472,7 @@ int _media_dcm_request_async(int msg_type, const unsigned int request_id, const
                        }
 
                        dcm_req->msg_type = msg_type;
-                       dcm_req->path = strdup(path);
+                       dcm_req->path = g_strdup(path);
                        dcm_req->userData = userData;
                        dcm_req->isCanceled = FALSE;
                        dcm_req->request_id = request_id;
@@ -503,7 +495,7 @@ int dcm_request_extract_all(uid_t uid)
        int err = MS_MEDIA_ERR_NONE;
 
        /* Request for image file to the daemon "Dcm generator" */
-       err = _media_dcm_request(DCM_REQUEST_ALL_MEDIA, NULL, uid);
+       err = _media_dcm_request(DCM_MSG_REQUEST_ALL_MEDIA, NULL, uid);
        if (err != MS_MEDIA_ERR_NONE) {
                MSAPI_DBG_ERR("_media_dcm_request failed : %d", err);
                return err;
@@ -516,8 +508,10 @@ int dcm_request_extract_media(const char *path, uid_t uid)
 {
        int err = MS_MEDIA_ERR_NONE;
 
+       MSAPI_RETVM_IF(!MS_STRING_VALID(path), MS_MEDIA_ERR_INVALID_PARAMETER, "Invalid path");
+
        /* Request for image file to the daemon "Dcm generator" */
-       err = _media_dcm_request(DCM_REQUEST_MEDIA, path, uid);
+       err = _media_dcm_request(DCM_MSG_REQUEST_MEDIA, path, uid);
        if (err != MS_MEDIA_ERR_NONE) {
                MSAPI_DBG_ERR("_media_dcm_request failed : %d", err);
                return err;
@@ -531,10 +525,7 @@ int dcm_request_extract_face_async(const unsigned int request_id, const char *pa
        int err = MS_MEDIA_ERR_NONE;
        int exist = -1;
 
-       if (path == NULL) {
-               MSAPI_DBG_ERR("Invalid parameter");
-               return MS_MEDIA_ERR_INVALID_PARAMETER;
-       }
+       MSAPI_RETVM_IF(!MS_STRING_VALID(path), MS_MEDIA_ERR_INVALID_PARAMETER, "Invalid path");
 
        exist = open(path, O_RDONLY);
        if (exist < 0) {
@@ -546,7 +537,7 @@ int dcm_request_extract_face_async(const unsigned int request_id, const char *pa
        }
        close(exist);
 
-       MSAPI_DBG("Path : %s", path);
+       MSAPI_DBG_SLOG("Path : %s", path);
 
        ms_user_storage_type_t storage_type = -1;
        storage_type = ms_user_get_storage_type(uid, path, &storage_type);
@@ -556,18 +547,17 @@ int dcm_request_extract_face_async(const unsigned int request_id, const char *pa
                return MS_MEDIA_ERR_INVALID_PARAMETER;
        }
 
-       MSAPI_DBG("Path : %s", path);
-
        faceUserData *userData = (faceUserData*)malloc(sizeof(faceUserData));
        if (userData == NULL) {
                MSAPI_DBG_ERR("memory allocation failed");
                return MS_MEDIA_ERR_OUT_OF_MEMORY;
        }
+
        userData->func = (FaceFunc)func;
        userData->user_data = user_data;
 
        /* Request for image file to the daemon "Dcm generator" */
-       err = _media_dcm_request_async(DCM_REQUEST_MEDIA/*DCM_REQUEST_INSERT_FACE*/, request_id, path, userData, uid);
+       err = _media_dcm_request_async(DCM_MSG_REQUEST_MEDIA/*DCM_REQUEST_INSERT_FACE*/, request_id, path, userData, uid);
        if (err != MS_MEDIA_ERR_NONE) {
                MSAPI_DBG_ERR("_media_dcm_request failed : %d", err);
                return err;
@@ -580,8 +570,10 @@ int dcm_request_cancel_face(const unsigned int request_id, const char *path)
 {
        int err = MS_MEDIA_ERR_NONE;
 
+       MSAPI_RETVM_IF(!MS_STRING_VALID(path), MS_MEDIA_ERR_INVALID_PARAMETER, "Invalid path");
+
        /* Request for image file to the daemon "Dcm generator" */
-       err = _media_dcm_request_async(DCM_REQUEST_CANCEL_FACE, request_id, path, NULL, request_id);
+       err = _media_dcm_request_async(DCM_MSG_REQUEST_CANCEL_FACE, request_id, path, NULL, request_id);
        if (err != MS_MEDIA_ERR_NONE) {
                MSAPI_DBG_ERR("_media_dcm_request failed : %d", err);
                return err;

diff --git a/src/server/media-server-dcm.c b/src/server/media-server-dcm.c
index d01ac0a..3dabe0f 100755 (executable)
--- a/src/server/media-server-dcm.c
+++ b/src/server/media-server-dcm.c
@@ -115,12 +115,12 @@ int _media_dcm_get_error()
        }
 }
 
-int _ms_dcm_recv_msg(int sock, dcmMsg *msg)
+int __ms_dcm_recv_msg(int sock, dcmMsg *msg)
 {
        int recv_msg_len = 0;
        unsigned char *buf = NULL;
 
-       MS_DBG("_ms_dcm_recv_msg in");
+       MS_DBG_FENTER();
 
        MS_MALLOC(buf, sizeof(dcmMsg));
        if (buf == NULL) {
@@ -137,7 +137,9 @@ int _ms_dcm_recv_msg(int sock, dcmMsg *msg)
 
        MS_SAFE_FREE(buf);
 
-       MS_DBG("_ms_dcm_recv_msg out %d", msg->msg_type);
+       MS_DBG("msg_type [%d]", msg->msg_type);
+
+       MS_DBG_FLEAVE();
 
        return MS_MEDIA_ERR_NONE;
 }
@@ -146,10 +148,10 @@ gboolean _ms_dcm_agent_recv_msg_from_server()
 {
        struct sockaddr_un serv_addr;
        unsigned int serv_addr_len;
-
        int sockfd = -1;
        int retry = 10;
-       MS_DBG("_ms_dcm_agent_recv_msg_from_server in");
+
+       MS_DBG_FENTER();
 
        if (g_dcm_comm_sock <= 0)
                _ms_dcm_agent_prepare_tcp_socket(&g_dcm_comm_sock, MS_DCM_COMM_PORT);
@@ -165,15 +167,15 @@ gboolean _ms_dcm_agent_recv_msg_from_server()
        int recv_result = 0;
 
 RETRY:
-       recv_result = _ms_dcm_recv_msg(sockfd, & recv_msg);
+       recv_result = __ms_dcm_recv_msg(sockfd, &recv_msg);
        if (recv_result != MS_MEDIA_ERR_NONE) {
-               MS_DBG_STRERROR("_ms_dcm_recv_msg failed");
+               MS_DBG_STRERROR("__ms_dcm_recv_msg failed");
                close(sockfd);
                return FALSE;
        }
 
-       if (recv_msg.msg_type == MS_MSG_DCM_SERVER_READY) {
-               MS_DBG("DCM service is ready");
+       if (recv_msg.msg_type == DCM_MSG_SERVER_READY) {
+               MS_DBG_INFO("DCM service is ready");
        } else {
                MS_DBG("DCM service is not ready retry=%d", retry);
                if (retry > 0) {
@@ -183,9 +185,12 @@ RETRY:
                }
        }
 
-       MS_DBG("_ms_dcm_agent_recv_msg_from_server out %d", recv_msg.msg_type);
+       MS_DBG("msg_type [%d]", recv_msg.msg_type);
 
        close(sockfd);
+
+       MS_DBG_FLEAVE();
+
        return TRUE;
 }
 
@@ -236,7 +241,7 @@ gboolean _ms_dcm_agent_recv_dcm_done_from_server(GIOChannel *src, GIOCondition c
        close(dcm_serv_sockfd);
 
        MS_DBG("Receive : %d", recv_msg.msg_type);
-       if (recv_msg.msg_type == MS_MSG_DCM_EXTRACT_ALL_DONE) {
+       if (recv_msg.msg_type == DCM_MSG_EXTRACT_ALL_DONE) {
                MS_DBG("DCM extracting done");
                g_dcm_server_extracting = FALSE;
                MS_DBG("g_dcm_server_extracting is false");
@@ -308,8 +313,8 @@ gboolean _ms_dcm_agent_send_msg_to_dcm_server(dcmMsg *recv_msg, dcmMsg *res_msg)
 
        MS_DBG_SLOG("Sending msg to DCM service is successful %d", recv_msg->msg_type);
 
-       if (_ms_dcm_recv_msg(sock, res_msg) < 0) {
-               MS_DBG_ERR("_ms_dcm_recv_msg failed");
+       if (__ms_dcm_recv_msg(sock, res_msg) < 0) {
+               MS_DBG_ERR("__ms_dcm_recv_msg failed");
                close(sock);
                return FALSE;
        }
@@ -345,7 +350,7 @@ gboolean _ms_dcm_check_queued_request(gpointer data)
                memset((void *)&msg, 0, sizeof(msg));
                memset((void *)&recv_msg, 0, sizeof(recv_msg));
 
-               msg.msg_type = 1; /* DCM_REQUEST_ALL_MEDIA */
+               msg.msg_type = DCM_MSG_REQUEST_ALL_MEDIA;
                ms_sys_get_uid(&(msg.uid));
                msg.msg[0] = '\0';
                msg.msg_size = 0;
@@ -382,7 +387,7 @@ gboolean _ms_dcm_agent_timer()
                memset((void *)&msg, 0, sizeof(msg));
                memset((void *)&recv_msg, 0, sizeof(recv_msg));
 
-               msg.msg_type = 4; /* DCM_REQUEST_KILL_SERVER */
+               msg.msg_type = DCM_MSG_REQUEST_KILL_SERVER;
                msg.msg[0] = '\0';
                msg.msg_size = 0;
 
@@ -462,7 +467,7 @@ gboolean _ms_dcm_request_to_server(gpointer data)
        }
 
        if (recv_msg) {
-               if (recv_msg->msg_type == 1 && g_dcm_server_extracting) {
+               if (recv_msg->msg_type == DCM_MSG_REQUEST_ALL_MEDIA && g_dcm_server_extracting) {
                        MS_DBG_WARN("DCM service is already extracting..This request is queued.");
                        g_dcm_server_queued_all_extracting_request = TRUE;
                } else {
@@ -508,9 +513,7 @@ gboolean _ms_dcm_request_to_server(gpointer data)
        return TRUE;
 }
 
-gboolean _ms_dcm_agent_read_socket(GIOChannel *src,
-                                                                       GIOCondition condition,
-                                                                       gpointer data)
+gboolean _ms_dcm_agent_read_socket(GIOChannel *src, GIOCondition condition, gpointer data)
 {
        struct sockaddr_un client_addr;
        unsigned int client_addr_len;
@@ -543,8 +546,8 @@ gboolean _ms_dcm_agent_read_socket(GIOChannel *src,
                return TRUE;
        }
 
-       if (_ms_dcm_recv_msg(client_sock, recv_msg) < 0) {
-               MS_DBG_ERR("_ms_dcm_recv_msg failed ");
+       if (__ms_dcm_recv_msg(client_sock, recv_msg) < 0) {
+               MS_DBG_ERR("__ms_dcm_recv_msg failed ");
                close(client_sock);
                MS_SAFE_FREE(recv_msg);
                return TRUE;
@@ -598,7 +601,7 @@ gboolean _ms_dcm_agent_read_socket(GIOChannel *src,
                return TRUE;
        }
 
-       MS_DBG_SLOG("%s is queued", recv_msg->msg);
+       MS_DBG_SLOG("[%s] is queued", recv_msg->msg);
        g_queue_push_tail(g_dcm_request_queue, (gpointer)dcm_req);
 
        if (!g_dcm_queue_work) {