Update code for message handling

1. Process all received messages (Remove the code to drop message)
2. Add error handling for uncompleted message

[Version] 0.2.82
[Profile] Common
[Issue Type] Update
[Dependency module] N/A
[Test] [M(T/E) - Boot=(OK), sdb=(OK), Home=(OK), Touch=(OK), Version=tizen-mobile_20161101.3]

Change-Id: I05f21c071353a71876fe393bdf461442ebe87258
Signed-off-by: Jeongmo Yang <jm80.yang@samsung.com>

diff --git a/include/camera_private.h b/include/camera_private.h
index 1dc339d..c70318f 100644 (file)
--- a/include/camera_private.h
+++ b/include/camera_private.h
@@ -34,7 +34,6 @@ extern "C" {
 #endif /* BUFFER_MAX_PLANE_NUM */
 
 #define BUFFER_MAX_PLANE_NUM     4
-#define CAMERA_PARSED_STRING_NUM_MAX 20
 #define CAMERA_CB_TIMEOUT        5
 #define CAMERA_CB_TIMEOUT_LONG   8
 
@@ -114,7 +113,7 @@ typedef struct _camera_cb_info_s {
        /* message receive thread */
        GThread *msg_recv_thread;
        gint msg_recv_running;
-       gchar recv_msg[MUSE_CAMERA_MSG_MAX_LENGTH * CAMERA_PARSED_STRING_NUM_MAX];
+       gchar recv_msg[MUSE_MSG_MAX_LENGTH];
        GCond api_cond[MUSE_CAMERA_API_MAX];
        GMutex api_mutex[MUSE_CAMERA_API_MAX];
        gint api_activating[MUSE_CAMERA_API_MAX];

diff --git a/packaging/capi-media-camera.spec b/packaging/capi-media-camera.spec
index 62b774a..08a950d 100644 (file)
--- a/packaging/capi-media-camera.spec
+++ b/packaging/capi-media-camera.spec
@@ -1,6 +1,6 @@
 Name:       capi-media-camera
 Summary:    A Camera API
-Version:    0.2.81
+Version:    0.2.82
 Release:    0
 Group:      Multimedia/API
 License:    Apache-2.0

diff --git a/src/camera.c b/src/camera.c
index 696b5a5..9ece7f4 100644 (file)
--- a/src/camera.c
+++ b/src/camera.c
@@ -1829,7 +1829,7 @@ static void __camera_process_msg(camera_cb_info_s *cb_info, char *msg)
                return;
        }
 
-       LOGD("msg [%s]", msg);
+       /*LOGD("msg [%s]", msg);*/
 
        if (!muse_camera_msg_get(api, msg)) {
                LOGE("failed to get camera api");
@@ -1855,14 +1855,13 @@ static void __camera_process_msg(camera_cb_info_s *cb_info, char *msg)
                        return;
                }
 
-               g_mutex_lock(&cb_info->api_mutex[api]);
-
                if (!muse_camera_msg_get(ret, msg)) {
                        LOGE("failed to get camera ret");
-                       g_mutex_unlock(&cb_info->api_mutex[api]);
                        return;
                }
 
+               g_mutex_lock(&cb_info->api_mutex[api]);
+
                cb_info->api_ret[api] = ret;
                cb_info->api_activating[api] = 1;
 
@@ -1934,15 +1933,15 @@ static void __camera_process_msg(camera_cb_info_s *cb_info, char *msg)
 
 static void *_camera_msg_recv_func(gpointer data)
 {
-       int i = 0;
-       int ret = 0;
-       int num_token = 0;
-       int str_pos = 0;
-       int prev_pos = 0;
-       int msg_length = 0;
-       char *error_msg = NULL;
+       int recv_length = 0;
+       int single_length = 0;
+       int remained_length = 0;
        char *recv_msg = NULL;
-       char **parse_str = NULL;
+       char *single_msg = NULL;
+       char *remained_msg = NULL;
+       int num_msg = 0;
+       int cur_pos = 0;
+       int prev_pos = 0;
        camera_cb_info_s *cb_info = (camera_cb_info_s *)data;
 
        if (!cb_info) {
@@ -1952,77 +1951,98 @@ static void *_camera_msg_recv_func(gpointer data)
 
        LOGD("start");
 
-       parse_str = (char **)malloc(sizeof(char *) * CAMERA_PARSED_STRING_NUM_MAX);
-       if (parse_str == NULL) {
-               LOGE("parse_str malloc failed");
+       single_msg = (char *)malloc(sizeof(char) * MUSE_CAMERA_MSG_MAX_LENGTH);
+       if (!single_msg) {
+               LOGE("single_msg malloc failed");
                return NULL;
        }
 
-       for (i = 0 ; i < CAMERA_PARSED_STRING_NUM_MAX ; i++) {
-               parse_str[i] = (char *)malloc(sizeof(char) * MUSE_CAMERA_MSG_MAX_LENGTH);
-               if (parse_str[i] == NULL) {
-                       LOGE("parse_str[%d] malloc failed", i);
-                       goto CB_HANDLER_EXIT;
-               }
-       }
-
        recv_msg = cb_info->recv_msg;
 
        while (g_atomic_int_get(&cb_info->msg_recv_running)) {
-               ret = muse_core_ipc_recv_msg(cb_info->fd, recv_msg);
-               if (ret <= 0) {
+               recv_length = muse_core_ipc_recv_msg(cb_info->fd, recv_msg);
+               if (recv_length <= 0) {
                        cb_info->is_server_connected = FALSE;
                        LOGE("receive msg failed - server disconnected");
                        break;
                }
 
-               recv_msg[ret] = '\0';
-
-               str_pos = 0;
+               cur_pos = 0;
                prev_pos = 0;
-               num_token = 0;
-
-               /*LOGD("recvMSg : %s, length : %d", recv_msg, ret);*/
-
-               /* Need to split the combined entering msgs.
-                   This module supports up to 20 combined msgs. */
-               for (str_pos = 0; str_pos < ret; str_pos++) {
-                       if (recv_msg[str_pos] == '}') {
-                               msg_length = str_pos - prev_pos + 1;
+               num_msg = 0;
+
+               /*LOGD("recv msg : %s, length : %d", recv_msg, recv_length);*/
+
+               /* Need to split the combined entering msgs */
+               for (cur_pos = 0 ; cur_pos < recv_length ; cur_pos++) {
+                       if (recv_msg[cur_pos] == '}') {
+                               single_length = cur_pos - prev_pos + 1;
+
+                               if (single_length < MUSE_CAMERA_MSG_MAX_LENGTH) {
+                                       /* check remained msg */
+                                       if (remained_length > 0) {
+                                               if (remained_msg) {
+                                                       strncpy(single_msg, remained_msg, remained_length);
+                                                       strncpy(single_msg + remained_length, recv_msg + prev_pos, single_length);
+                                                       single_msg[remained_length + single_length] = '\0';
+
+                                                       free(remained_msg);
+                                                       remained_msg = NULL;
+                                               } else {
+                                                       strncpy(single_msg, recv_msg + prev_pos, single_length);
+                                                       single_msg[single_length] = '\0';
+                                                       LOGE("lost msg [%s], skip...", single_msg);
+                                               }
+
+                                               remained_length = 0;
+                                       } else {
+                                               strncpy(single_msg, recv_msg + prev_pos, single_length);
+                                               single_msg[single_length] = '\0';
+                                       }
 
-                               if (msg_length < MUSE_CAMERA_MSG_MAX_LENGTH) {
-                                       strncpy(parse_str[num_token], recv_msg + prev_pos, msg_length);
-                                       parse_str[num_token][msg_length] = '\0';
-                                       num_token++;
-                                       /*LOGD("splitted msg : [%s], Index : %d", parse_str[num_token], num_token);*/
+                                       if (single_msg[0] == '{') {
+                                               num_msg++;
+                                               /*LOGD("splitted msg : [%s], Index : %d", single_msg, num_msg);*/
+                                               /* process each message */
+                                               __camera_process_msg(cb_info, single_msg);
+                                       } else {
+                                               LOGE("invalid msg [%s]", single_msg);
+                                       }
                                } else {
-                                       LOGW("too long message : length %d [%s]", msg_length, recv_msg + prev_pos);
+                                       LOGE("too long message [len %d] skip...", single_length);
                                }
 
-                               prev_pos = str_pos + 1;
-
-                               if (num_token >= CAMERA_PARSED_STRING_NUM_MAX) {
-                                       LOGE("There's too many tokens. Remained msg : %s", recv_msg[++str_pos]);
-                                       break;
-                               }
+                               prev_pos = cur_pos + 1;
                        }
                }
 
-               /*LOGD("num_token : %d", num_token);*/
+               /* check incompleted message */
+               if (recv_msg[recv_length - 1] != '}') {
+                       remained_length = recv_length - prev_pos;
+
+                       LOGW("incompleted message [len %d]", remained_length);
 
-               /* process each message */
-               for (i = 0; i < num_token; i++)
-                       __camera_process_msg(cb_info, parse_str[i]);
+                       remained_msg = (char *)malloc(remained_length + 1);
+                       if (remained_msg) {
+                               strncpy(remained_msg, recv_msg + prev_pos, remained_length);
+                               remained_msg[remained_length] = '\0';
+                       } else {
+                               LOGE("failed to alloc for remained msg");
+                       }
+               } else {
+                       remained_length = 0;
+               }
        }
 
        LOGD("client cb exit - server connected %d", cb_info->is_server_connected);
 
        if (!cb_info->is_server_connected) {
                /* send error msg for server disconnection */
-               error_msg = muse_core_msg_json_factory_new(MUSE_CAMERA_CB_EVENT,
+               char *error_msg = muse_core_msg_json_factory_new(MUSE_CAMERA_CB_EVENT,
                        MUSE_TYPE_INT, "error", CAMERA_ERROR_SERVICE_DISCONNECTED,
                        MUSE_TYPE_INT, "current_state", CAMERA_STATE_NONE,
                        NULL);
+
                if (!error_msg) {
                        LOGE("error_msg failed");
                        goto CB_HANDLER_EXIT;
@@ -2041,16 +2061,14 @@ static void *_camera_msg_recv_func(gpointer data)
        }
 
 CB_HANDLER_EXIT:
-       if (parse_str) {
-               for (i = 0 ; i < CAMERA_PARSED_STRING_NUM_MAX ; i++) {
-                       if (parse_str[i]) {
-                               free(parse_str[i]);
-                               parse_str[i] = NULL;
-                       }
-               }
+       if (single_msg) {
+               free(single_msg);
+               single_msg = NULL;
+       }
 
-               free(parse_str);
-               parse_str = NULL;
+       if (remained_msg) {
+               free(remained_msg);
+               remained_msg = NULL;
        }
 
        return NULL;