X-Git-Url: http://review.tizen.org/git/?a=blobdiff_plain;f=src%2Fmm_camcorder_internal.c;h=99eae2563977b32272a833665333e931a49a6e04;hb=aa254c75e23e89333f23a3f97d6e4222eb2e3f9e;hp=e7215a1d12fcd2f4cef90a695a0d514f678b1a0d;hpb=567f5bf506bdb602829ae3aab4e5a798bfcc2aaf;p=platform%2Fcore%2Fmultimedia%2Flibmm-camcorder.git

diff --git a/src/mm_camcorder_internal.c b/src/mm_camcorder_internal.c
index e7215a1..99eae25 100644
--- a/src/mm_camcorder_internal.c
+++ b/src/mm_camcorder_internal.c
@@ -61,11 +61,6 @@
 #define DPM_ALLOWED                             1
 #define DPM_DISALLOWED                          0
 
-#ifdef _MMCAMCORDER_MURPHY_SUPPORT
-#define __MMCAMCORDER_RESOURCE_WAIT_TIME        5
-#endif /* _MMCAMCORDER_MURPHY_SUPPORT */
-
-
 /*---------------------------------------------------------------------------------------
 |    LOCAL FUNCTION PROTOTYPES:								|
 ---------------------------------------------------------------------------------------*/
@@ -127,7 +122,7 @@ int _mmcamcorder_create(MMHandleType *handle, MMCamPreset *info)
 	hcamcorder->type = 0;
 	hcamcorder->state = MM_CAMCORDER_STATE_NONE;
 	hcamcorder->sub_context = NULL;
-	hcamcorder->target_state = MM_CAMCORDER_STATE_NULL;
+	hcamcorder->old_state = MM_CAMCORDER_STATE_NONE;
 	hcamcorder->capture_in_recording = FALSE;
 	hcamcorder->session_type = MM_SESSION_TYPE_MEDIA;
 
@@ -143,6 +138,7 @@ int _mmcamcorder_create(MMHandleType *handle, MMCamPreset *info)
 	g_mutex_init(&(hcamcorder->mtsafe).vcapture_cb_lock);
 	g_mutex_init(&(hcamcorder->mtsafe).vstream_cb_lock);
 	g_mutex_init(&(hcamcorder->mtsafe).astream_cb_lock);
+	g_mutex_init(&(hcamcorder->mtsafe).mstream_cb_lock);
 #ifdef _MMCAMCORDER_MURPHY_SUPPORT
 	g_cond_init(&(hcamcorder->mtsafe).resource_cond);
 	g_mutex_init(&(hcamcorder->mtsafe).resource_lock);
@@ -163,8 +159,11 @@ int _mmcamcorder_create(MMHandleType *handle, MMCamPreset *info)
 
 	if (info->videodev_type != MM_VIDEO_DEVICE_NONE) {
 		/* init for gdbus */
+		hcamcorder->gdbus_info_sound.mm_handle = hcamcorder;
 		g_mutex_init(&hcamcorder->gdbus_info_sound.sync_mutex);
 		g_cond_init(&hcamcorder->gdbus_info_sound.sync_cond);
+
+		hcamcorder->gdbus_info_solo_sound.mm_handle = hcamcorder;
 		g_mutex_init(&hcamcorder->gdbus_info_solo_sound.sync_mutex);
 		g_cond_init(&hcamcorder->gdbus_info_solo_sound.sync_cond);
 	}
@@ -395,6 +394,29 @@ int _mmcamcorder_create(MMHandleType *handle, MMCamPreset *info)
 
 			_mmcam_dbg_log("DPM camera changed cb id %d", hcamcorder->dpm_camera_cb_id);
 		}
+
+#ifdef _MMCAMCORDER_MURPHY_SUPPORT
+		/* set camcorder handle */
+		hcamcorder->resource_manager.id = MM_CAMCORDER_RESOURCE_ID_MAIN;
+		hcamcorder->resource_manager.hcamcorder = hcamcorder;
+		hcamcorder->resource_manager_sub.id = MM_CAMCORDER_RESOURCE_ID_SUB;
+		hcamcorder->resource_manager_sub.hcamcorder = hcamcorder;
+
+		/* initialize resource manager */
+		ret = _mmcamcorder_resource_manager_init(&hcamcorder->resource_manager);
+		if (ret != MM_ERROR_NONE) {
+			_mmcam_dbg_err("failed to initialize resource manager");
+			ret = MM_ERROR_CAMCORDER_INTERNAL;
+			goto _ERR_DEFAULT_VALUE_INIT;
+		}
+
+		ret = _mmcamcorder_resource_manager_init(&hcamcorder->resource_manager_sub);
+		if (ret != MM_ERROR_NONE) {
+			_mmcam_dbg_err("failed to initialize resource manager sub");
+			ret = MM_ERROR_CAMCORDER_INTERNAL;
+			goto _ERR_DEFAULT_VALUE_INIT;
+		}
+#endif /* _MMCAMCORDER_MURPHY_SUPPORT */
 	} else {
 		_mmcamcorder_conf_get_value_int((MMHandleType)hcamcorder, hcamcorder->conf_main,
 			CONFIGURE_CATEGORY_MAIN_VIDEO_INPUT,
@@ -419,16 +441,6 @@ int _mmcamcorder_create(MMHandleType *handle, MMCamPreset *info)
 		}
 	}
 
-#ifdef _MMCAMCORDER_MURPHY_SUPPORT
-	/* initialize resource manager */
-	ret = _mmcamcorder_resource_manager_init(&hcamcorder->resource_manager, (void *)hcamcorder);
-	if (ret != MM_ERROR_NONE) {
-		_mmcam_dbg_err("failed to initialize resource manager");
-		ret = MM_ERROR_CAMCORDER_INTERNAL;
-		goto _ERR_DEFAULT_VALUE_INIT;
-	}
-#endif /* _MMCAMCORDER_MURPHY_SUPPORT */
-
 	traceBegin(TTRACE_TAG_CAMERA, "MMCAMCORDER:CREATE:INIT_GSTREAMER");
 
 	ret = __mmcamcorder_gstreamer_init(hcamcorder->conf_main);
@@ -473,42 +485,30 @@ int _mmcamcorder_create(MMHandleType *handle, MMCamPreset *info)
 
 	/* get model name */
 	sys_info_ret = system_info_get_platform_string("http://tizen.org/system/model_name", &hcamcorder->model_name);
-	if (hcamcorder->model_name) {
-		_mmcam_dbg_log("model name [%s], sys_info_ret 0x%x", hcamcorder->model_name, sys_info_ret);
-	} else {
-		_mmcam_dbg_warn("failed get model name, sys_info_ret 0x%x", sys_info_ret);
-	}
+
+	_mmcam_dbg_warn("model name [%s], ret 0x%x",
+		hcamcorder->model_name ? hcamcorder->model_name : "NULL", sys_info_ret);
 
 	/* get software version */
 	sys_info_ret = system_info_get_platform_string("http://tizen.org/system/build.string", &hcamcorder->software_version);
-	if (hcamcorder->software_version) {
-		_mmcam_dbg_log("software version [%s], sys_info_ret 0x%d", hcamcorder->software_version, sys_info_ret);
-	} else {
-		_mmcam_dbg_warn("failed get software version, sys_info_ret 0x%x", sys_info_ret);
-	}
 
-#ifdef _MMCAMCORDER_MURPHY_SUPPORT
-	_MMCAMCORDER_LOCK_RESOURCE(hcamcorder);
-
-	if (hcamcorder->resource_manager.is_connected == FALSE) {
-		gint64 end_time = 0;
+	_mmcam_dbg_warn("software version [%s], ret 0x%x",
+		hcamcorder->software_version ? hcamcorder->software_version : "NULL", sys_info_ret);
 
-		/* wait for resource manager connected */
-		_mmcam_dbg_log("resource manager is not connected. wait for signal...");
-
-		end_time = g_get_monotonic_time() + (__MMCAMCORDER_RESOURCE_WAIT_TIME * G_TIME_SPAN_SECOND);
+#ifdef _MMCAMCORDER_MURPHY_SUPPORT
+	if (info->videodev_type != MM_VIDEO_DEVICE_NONE) {
+		ret = _mmcamcorder_resource_wait_for_connection(&hcamcorder->resource_manager);
+		if (ret != MM_ERROR_NONE) {
+			_mmcam_dbg_err("failed to connect resource manager");
+			goto _ERR_DEFAULT_VALUE_INIT;
+		}
 
-		if (_MMCAMCORDER_RESOURCE_WAIT_UNTIL(hcamcorder, end_time)) {
-			_mmcam_dbg_warn("signal received");
-		} else {
-			_MMCAMCORDER_UNLOCK_RESOURCE(hcamcorder);
-			_mmcam_dbg_err("timeout");
-			ret = MM_ERROR_RESOURCE_INTERNAL;
+		ret = _mmcamcorder_resource_wait_for_connection(&hcamcorder->resource_manager_sub);
+		if (ret != MM_ERROR_NONE) {
+			_mmcam_dbg_err("failed to connect resource manager");
 			goto _ERR_DEFAULT_VALUE_INIT;
 		}
 	}
-
-	_MMCAMCORDER_UNLOCK_RESOURCE(hcamcorder);
 #endif /* _MMCAMCORDER_MURPHY_SUPPORT */
 
 	/* Set initial state */
@@ -523,6 +523,7 @@ int _mmcamcorder_create(MMHandleType *handle, MMCamPreset *info)
 _ERR_DEFAULT_VALUE_INIT:
 #ifdef _MMCAMCORDER_MURPHY_SUPPORT
 	/* de-initialize resource manager */
+	_mmcamcorder_resource_manager_deinit(&hcamcorder->resource_manager_sub);
 	_mmcamcorder_resource_manager_deinit(&hcamcorder->resource_manager);
 #endif /* _MMCAMCORDER_MURPHY_SUPPORT */
 
@@ -562,6 +563,7 @@ _ERR_DEFAULT_VALUE_INIT:
 	g_mutex_clear(&(hcamcorder->mtsafe).vcapture_cb_lock);
 	g_mutex_clear(&(hcamcorder->mtsafe).vstream_cb_lock);
 	g_mutex_clear(&(hcamcorder->mtsafe).astream_cb_lock);
+	g_mutex_clear(&(hcamcorder->mtsafe).mstream_cb_lock);
 #ifdef _MMCAMCORDER_MURPHY_SUPPORT
 	g_cond_clear(&(hcamcorder->mtsafe).resource_cond);
 	g_mutex_clear(&(hcamcorder->mtsafe).resource_lock);
@@ -687,6 +689,10 @@ int _mmcamcorder_destroy(MMHandleType handle)
 	if (ret != MM_ERROR_NONE)
 		_mmcam_dbg_err("failed to de-initialize resource manager 0x%x", ret);
 
+	ret = _mmcamcorder_resource_manager_deinit(&hcamcorder->resource_manager_sub);
+	if (ret != MM_ERROR_NONE)
+		_mmcam_dbg_err("failed to de-initialize resource manager sub 0x%x", ret);
+
 	_MMCAMCORDER_UNLOCK_RESOURCE(hcamcorder);
 #endif /* _MMCAMCORDER_MURPHY_SUPPORT */
 
@@ -799,6 +805,7 @@ int _mmcamcorder_destroy(MMHandleType handle)
 	g_mutex_clear(&(hcamcorder->mtsafe).vcapture_cb_lock);
 	g_mutex_clear(&(hcamcorder->mtsafe).vstream_cb_lock);
 	g_mutex_clear(&(hcamcorder->mtsafe).astream_cb_lock);
+	g_mutex_clear(&(hcamcorder->mtsafe).mstream_cb_lock);
 #ifdef _MMCAMCORDER_MURPHY_SUPPORT
 	g_cond_clear(&(hcamcorder->mtsafe).resource_cond);
 	g_mutex_clear(&(hcamcorder->mtsafe).resource_lock);
@@ -858,6 +865,9 @@ int _mmcamcorder_realize(MMHandleType handle)
 	int app_pid = 0;
 	int resource_count = 0;
 #endif /* _MMCAMCORDER_RM_SUPPORT */
+	char *stream_type = NULL;
+	char *ext_info = NULL;
+	int option = 0;
 
 	mmf_camcorder_t *hcamcorder = MMF_CAMCORDER(handle);
 
@@ -909,7 +919,7 @@ int _mmcamcorder_realize(MMHandleType handle)
 			/* acquire sound focus */
 			_mmcam_dbg_log("PAUSE_OTHERS - acquire sound focus");
 
-			ret_sound = mm_sound_acquire_focus(hcamcorder->sound_focus_id, FOCUS_FOR_BOTH, NULL);
+			ret_sound = mm_sound_acquire_focus(hcamcorder->sound_focus_id, FOCUS_FOR_BOTH, "mm-camcorder acquire focus");
 			if (ret_sound != MM_ERROR_NONE) {
 				_mmcam_dbg_err("mm_sound_acquire_focus failed [0x%x]", ret_sound);
 
@@ -922,6 +932,37 @@ int _mmcamcorder_realize(MMHandleType handle)
 			/* do nothing */
 			_mmcam_dbg_log("SESSION_UNINTERRUPTIBLE - do nothing for sound focus");
 		} else {
+			/* check previous acquired focus */
+			ret = mm_sound_get_stream_type_of_acquired_focus(FOCUS_FOR_BOTH, &stream_type, &option, &ext_info);
+			if (ret == MM_ERROR_NONE && stream_type) {
+				if (!strcmp(stream_type, "alarm") ||
+					!strcmp(stream_type, "ringtone-voip") ||
+					!strcmp(stream_type, "ringtone-call") ||
+					!strcmp(stream_type, "voip") ||
+					!strcmp(stream_type, "call-voice") ||
+					!strcmp(stream_type, "call-video")) {
+					_mmcam_dbg_err("Blocked by session policy, stream_type [%s]", stream_type);
+					ret = MM_ERROR_POLICY_BLOCKED;
+				}
+			} else {
+				_mmcam_dbg_warn("get stream type failed 0x%x, stream type %s, but ignore it",
+					ret, stream_type ? stream_type : "NULL");
+				ret = MM_ERROR_NONE;
+			}
+
+			if (stream_type) {
+				free(stream_type);
+				stream_type = NULL;
+			}
+
+			if (ext_info) {
+				free(ext_info);
+				ext_info = NULL;
+			}
+
+			if (ret != MM_ERROR_NONE)
+				goto _ERR_CAMCORDER_CMD_PRECON_AFTER_LOCK;
+
 			/* unset remained watch cb */
 			if (hcamcorder->sound_focus_watch_id > 0) {
 				mm_sound_unset_focus_watch_callback(hcamcorder->sound_focus_watch_id);
@@ -1058,6 +1099,9 @@ int _mmcamcorder_realize(MMHandleType handle)
 				if (dpm_camera_state == DPM_DISALLOWED) {
 					_mmcam_dbg_err("CAMERA DISALLOWED by DPM");
 					ret = MM_ERROR_POLICY_RESTRICTED;
+
+					_mmcamcorder_request_dpm_popup(hcamcorder->gdbus_conn, "camera");
+
 					goto _ERR_CAMCORDER_CMD_PRECON_AFTER_LOCK;
 				}
 			} else {
@@ -1068,10 +1112,15 @@ int _mmcamcorder_realize(MMHandleType handle)
 		}
 
 #ifdef _MMCAMCORDER_MURPHY_SUPPORT
+		/* check connection */
+		ret = _mmcamcorder_resource_check_connection(&hcamcorder->resource_manager);
+		if (ret != MM_ERROR_NONE)
+			goto _ERR_CAMCORDER_CMD_PRECON_AFTER_LOCK;
+
+		/* create resource set */
 		ret = _mmcamcorder_resource_create_resource_set(&hcamcorder->resource_manager);
-		if (ret != MM_ERROR_NONE) {
+		if (ret != MM_ERROR_NONE)
 			goto _ERR_CAMCORDER_CMD_PRECON_AFTER_LOCK;
-		}
 
 		hcamcorder->resource_manager.acquire_count = 0;
 
@@ -1096,7 +1145,8 @@ int _mmcamcorder_realize(MMHandleType handle)
 		/* acquire resources */
 		_MMCAMCORDER_LOCK_RESOURCE(hcamcorder);
 
-		if (hcamcorder->resource_manager.rset && _mmcamcorder_resource_manager_acquire(&hcamcorder->resource_manager)) {
+		ret = _mmcamcorder_resource_manager_acquire(&hcamcorder->resource_manager);
+		if (ret != MM_ERROR_NONE) {
 			_MMCAMCORDER_UNLOCK_RESOURCE(hcamcorder);
 
 			_mmcam_dbg_err("could not acquire resources");
@@ -1246,14 +1296,8 @@ int _mmcamcorder_realize(MMHandleType handle)
 _ERR_CAMCORDER_CMD:
 #ifdef _MMCAMCORDER_MURPHY_SUPPORT
 	/* release hw resources */
-	if (hcamcorder->type == MM_CAMCORDER_MODE_VIDEO_CAPTURE) {
-		int ret_resource = _mmcamcorder_resource_manager_release(&hcamcorder->resource_manager);
-		if (ret_resource == MM_ERROR_RESOURCE_INVALID_STATE) {
-			_mmcam_dbg_warn("it could be in the middle of resource callback or there's no acquired resource");
-		} else if (ret_resource != MM_ERROR_NONE) {
-			_mmcam_dbg_err("failed to release resource, ret_resource(0x%x)", ret_resource);
-		}
-	}
+	if (hcamcorder->type == MM_CAMCORDER_MODE_VIDEO_CAPTURE)
+		_mmcamcorder_resource_manager_release(&hcamcorder->resource_manager);
 #endif /* _MMCAMCORDER_MURPHY_SUPPORT */
 #ifdef _MMCAMCORDER_RM_SUPPORT
 	if (hcamcorder->rm_handle) {
@@ -1288,7 +1332,7 @@ _ERR_CAMCORDER_CMD_PRECON_AFTER_LOCK:
 	}
 
 	if (hcamcorder->acquired_focus > 0) {
-		mm_sound_release_focus(hcamcorder->sound_focus_id, hcamcorder->acquired_focus, NULL);
+		mm_sound_release_focus(hcamcorder->sound_focus_id, hcamcorder->acquired_focus, "mm-camcorder release focus");
 		_mmcam_dbg_warn("release sound focus [focus %d] done", hcamcorder->acquired_focus);
 		hcamcorder->acquired_focus = 0;
 	}
@@ -1338,13 +1382,15 @@ int _mmcamcorder_unrealize(MMHandleType handle)
 	}
 
 #ifdef _MMCAMCORDER_MURPHY_SUPPORT
+	_mmcam_dbg_warn("lock resource - cb calling %d", hcamcorder->resource_manager.is_release_cb_calling);
+
+	_MMCAMCORDER_LOCK_RESOURCE(hcamcorder);
+
 	if (hcamcorder->type == MM_CAMCORDER_MODE_VIDEO_CAPTURE &&
-		hcamcorder->state_change_by_system != _MMCAMCORDER_STATE_CHANGE_BY_RM) {
+		hcamcorder->state_change_by_system != _MMCAMCORDER_STATE_CHANGE_BY_RM &&
+		hcamcorder->resource_manager.is_release_cb_calling == FALSE) {
 		gint64 end_time = 0;
 
-		_mmcam_dbg_log("lock resource");
-		_MMCAMCORDER_LOCK_RESOURCE(hcamcorder);
-
 		/* release resource */
 		ret = _mmcamcorder_resource_manager_release(&hcamcorder->resource_manager);
 		if (ret == MM_ERROR_RESOURCE_INVALID_STATE) {
@@ -1368,10 +1414,11 @@ int _mmcamcorder_unrealize(MMHandleType handle)
 
 			_MMCAMCORDER_RESOURCE_WAIT_UNTIL(hcamcorder, end_time);
 		}
-
-		_MMCAMCORDER_UNLOCK_RESOURCE(hcamcorder);
-		_mmcam_dbg_log("unlock resource");
 	}
+
+	_MMCAMCORDER_UNLOCK_RESOURCE(hcamcorder);
+
+	_mmcam_dbg_warn("unlock resource");
 #endif /* _MMCAMCORDER_MURPHY_SUPPORT */
 
 #ifdef _MMCAMCORDER_RM_SUPPORT
@@ -1409,7 +1456,7 @@ int _mmcamcorder_unrealize(MMHandleType handle)
 		}
 
 		if (hcamcorder->acquired_focus > 0) {
-			mm_sound_release_focus(hcamcorder->sound_focus_id, hcamcorder->acquired_focus, NULL);
+			mm_sound_release_focus(hcamcorder->sound_focus_id, hcamcorder->acquired_focus, "mm-camcorder release focus");
 			_mmcam_dbg_warn("release sound focus [focus %d] done", hcamcorder->acquired_focus);
 			hcamcorder->acquired_focus = 0;
 		}
@@ -1486,6 +1533,10 @@ int _mmcamcorder_start(MMHandleType handle)
 
 	_mmcamcorder_set_state(handle, MM_CAMCORDER_STATE_PREPARE);
 
+	/* set attributes related sensor - after start preview */
+	if (hcamcorder->type != MM_CAMCORDER_MODE_AUDIO)
+		_mmcamcorder_set_attribute_to_camsensor2(handle);
+
 	_MMCAMCORDER_UNLOCK_CMD(hcamcorder);
 
 	return MM_ERROR_NONE;
@@ -1714,15 +1765,18 @@ int _mmcamcorder_record(MMHandleType handle)
 	int dpm_mic_state = DPM_ALLOWED;
 
 	mmf_camcorder_t *hcamcorder = MMF_CAMCORDER(handle);
+	_MMCamcorderSubContext *sc = NULL;
 
 	_mmcam_dbg_log("");
 
-	if (!hcamcorder) {
+	if (!hcamcorder || !MMF_CAMCORDER_SUBCONTEXT(hcamcorder)) {
 		_mmcam_dbg_err("Not initialized");
 		ret = MM_ERROR_CAMCORDER_NOT_INITIALIZED;
 		return ret;
 	}
 
+	sc = MMF_CAMCORDER_SUBCONTEXT(handle);
+
 	if (!_MMCAMCORDER_TRYLOCK_CMD(hcamcorder)) {
 		_mmcam_dbg_err("Another command is running.");
 		ret = MM_ERROR_CAMCORDER_CMD_IS_RUNNING;
@@ -1739,20 +1793,31 @@ int _mmcamcorder_record(MMHandleType handle)
 	/* initialize error code */
 	hcamcorder->error_code = MM_ERROR_NONE;
 
+	/* get audio disable */
+	mm_camcorder_get_attributes(handle, NULL,
+		MMCAM_AUDIO_DISABLE, &sc->audio_disable,
+		NULL);
+
+	sc->audio_disable |= sc->is_modified_rate;
+
 	/* check mic policy from DPM */
-	if (hcamcorder->dpm_handle) {
+	if (hcamcorder->dpm_handle && sc->audio_disable == FALSE) {
 		if (dpm_restriction_get_microphone_state(hcamcorder->dpm_handle, &dpm_mic_state) == DPM_ERROR_NONE) {
 			_mmcam_dbg_log("DPM mic state %d", dpm_mic_state);
 			if (dpm_mic_state == DPM_DISALLOWED) {
 				_mmcam_dbg_err("MIC DISALLOWED by DPM");
 				ret = MM_ERROR_COMMON_INVALID_PERMISSION;
+
+				_mmcamcorder_request_dpm_popup(hcamcorder->gdbus_conn, "microphone");
+
 				goto _ERR_CAMCORDER_CMD_PRECON_AFTER_LOCK;
 			}
 		} else {
 			_mmcam_dbg_err("get DPM mic state failed, keep going...");
 		}
 	} else {
-		_mmcam_dbg_warn("NULL dpm_handle");
+		_mmcam_dbg_warn("skip dpm check - handle %p, audio disable %d",
+			hcamcorder->dpm_handle, sc->audio_disable);
 	}
 
 	ret = hcamcorder->command((MMHandleType)hcamcorder, _MMCamcorder_CMD_RECORD);
@@ -1990,10 +2055,7 @@ int _mmcamcorder_set_video_stream_callback(MMHandleType handle, mm_camcorder_vid
 	if (callback == NULL)
 		_mmcam_dbg_warn("Video Stream Callback is disabled, because application sets it to NULL");
 
-	if (!_MMCAMCORDER_TRYLOCK_VSTREAM_CALLBACK(hcamcorder)) {
-		_mmcam_dbg_warn("Application's video stream callback is running now");
-		return MM_ERROR_CAMCORDER_INVALID_CONDITION;
-	}
+	_MMCAMCORDER_LOCK_VSTREAM_CALLBACK(hcamcorder);
 
 	hcamcorder->vstream_cb = callback;
 	hcamcorder->vstream_cb_param = user_data;
@@ -2029,6 +2091,31 @@ int _mmcamcorder_set_audio_stream_callback(MMHandleType handle, mm_camcorder_aud
 }
 
 
+int _mmcamcorder_set_muxed_stream_callback(MMHandleType handle, mm_camcorder_muxed_stream_callback callback, void *user_data)
+{
+	mmf_camcorder_t *hcamcorder = MMF_CAMCORDER(handle);
+
+	_mmcam_dbg_log("");
+
+	mmf_return_val_if_fail(hcamcorder, MM_ERROR_CAMCORDER_NOT_INITIALIZED);
+
+	if (callback == NULL)
+		_mmcam_dbg_warn("Muxed Stream Callback is disabled, because application sets it to NULL");
+
+	if (!_MMCAMCORDER_TRYLOCK_MSTREAM_CALLBACK(hcamcorder)) {
+		_mmcam_dbg_warn("Application's muxed stream callback is running now");
+		return MM_ERROR_CAMCORDER_INVALID_CONDITION;
+	}
+
+	hcamcorder->mstream_cb = callback;
+	hcamcorder->mstream_cb_param = user_data;
+
+	_MMCAMCORDER_UNLOCK_MSTREAM_CALLBACK(hcamcorder);
+
+	return MM_ERROR_NONE;
+}
+
+
 int _mmcamcorder_set_video_capture_callback(MMHandleType handle, mm_camcorder_video_capture_callback callback, void *user_data)
 {
 	mmf_camcorder_t *hcamcorder = MMF_CAMCORDER(handle);
@@ -2465,6 +2552,23 @@ int _mmcamcorder_get_state(MMHandleType handle)
 }
 
 
+int _mmcamcorder_get_state2(MMHandleType handle, int *state, int *old_state)
+{
+	mmf_camcorder_t *hcamcorder = MMF_CAMCORDER(handle);
+
+	mmf_return_val_if_fail(hcamcorder && state && old_state, MM_ERROR_CAMCORDER_INVALID_ARGUMENT);
+
+	_MMCAMCORDER_LOCK_STATE(handle);
+
+	*state = hcamcorder->state;
+	*old_state = hcamcorder->old_state;
+
+	_MMCAMCORDER_UNLOCK_STATE(handle);
+
+	return MM_ERROR_NONE;
+}
+
+
 void _mmcamcorder_set_state(MMHandleType handle, int state)
 {
 	int old_state;
@@ -2480,9 +2584,9 @@ void _mmcamcorder_set_state(MMHandleType handle, int state)
 	old_state = hcamcorder->state;
 	if (old_state != state) {
 		hcamcorder->state = state;
-		hcamcorder->target_state = state;
+		hcamcorder->old_state = old_state;
 
-		_mmcam_dbg_log("set state[%d] and send state-changed message", state);
+		_mmcam_dbg_log("set state[%d -> %d] and send state-changed message", old_state, state);
 
 		/* To discern who changes the state */
 		switch (hcamcorder->state_change_by_system) {
@@ -2518,20 +2622,6 @@ void _mmcamcorder_set_state(MMHandleType handle, int state)
 }
 
 
-int _mmcamcorder_get_async_state(MMHandleType handle)
-{
-	int state;
-	mmf_camcorder_t *hcamcorder = MMF_CAMCORDER(handle);
-
-	_MMCAMCORDER_LOCK_STATE(handle);
-	state = hcamcorder->target_state;
-
-	_MMCAMCORDER_UNLOCK_STATE(handle);
-
-	return state;
-}
-
-
 _MMCamcorderSubContext *_mmcamcorder_alloc_subcontext(int type)
 {
 	int i;
@@ -2775,8 +2865,12 @@ gboolean _mmcamcorder_pipeline_cb_message(GstBus *bus, GstMessage *message, gpoi
 				pipeline = sc->element[_MMCAMCORDER_MAIN_PIPE].gst;
 				if (message->src == (GstObject*)pipeline) {
 					vnewstate = gst_structure_get_value(gst_message_get_structure(message), "new-state");
-					newstate = (GstState)vnewstate->data[0].v_int;
-					_mmcam_dbg_log("GST_MESSAGE_STATE_CHANGED[%s]", gst_element_state_get_name(newstate));
+					if (vnewstate) {
+						newstate = (GstState)vnewstate->data[0].v_int;
+						_mmcam_dbg_log("GST_MESSAGE_STATE_CHANGED[%s]", gst_element_state_get_name(newstate));
+					} else {
+						_mmcam_dbg_warn("get new state failed from msg");
+					}
 				}
 			}
 		}
@@ -3193,9 +3287,9 @@ GstBusSyncReply _mmcamcorder_encode_pipeline_bus_sync_callback(GstBus *bus, GstM
 
 				_mmcamcorder_send_message((MMHandleType)hcamcorder, &msg);
 			}
-		}
 
-		goto DROP_MESSAGE;
+			goto DROP_MESSAGE;
+		}
 	}
 
 	if (err) {
@@ -3233,7 +3327,7 @@ void _mmcamcorder_sound_focus_cb(int id, mm_sound_focus_type_e focus_type,
 		return;
 	}
 
-	_mmcam_dbg_log("sound focus callback : focus state %d, reason %s",
+	_mmcam_dbg_warn("sound focus callback : focus state %d, reason %s",
 				   focus_state, reason_for_change ? reason_for_change : "N/A");
 
 	if (hcamcorder->session_flags & MM_SESSION_OPTION_UNINTERRUPTIBLE) {
@@ -3243,9 +3337,6 @@ void _mmcamcorder_sound_focus_cb(int id, mm_sound_focus_type_e focus_type,
 
 	_MMCAMCORDER_LOCK_ASM(hcamcorder);
 
-	/* set value to inform a status is changed by asm */
-	hcamcorder->state_change_by_system = _MMCAMCORDER_STATE_CHANGE_BY_FOCUS;
-
 	/* check the reason */
 	if (!strncmp(reason_for_change, "ringtone-voip", __MMCAMCORDER_FOCUS_CHANGE_REASON_LEN) ||
 	    !strncmp(reason_for_change, "ringtone-call", __MMCAMCORDER_FOCUS_CHANGE_REASON_LEN) ||
@@ -3261,33 +3352,30 @@ void _mmcamcorder_sound_focus_cb(int id, mm_sound_focus_type_e focus_type,
 	if (focus_state == FOCUS_IS_RELEASED) {
 		hcamcorder->acquired_focus &= ~focus_type;
 
-		_mmcam_dbg_log("FOCUS is released [type %d, remained focus %d] : Stop pipeline[state:%d]",
+		_mmcam_dbg_warn("FOCUS is released [type %d, remained focus %d] : Stop pipeline[state:%d]",
 			focus_type, hcamcorder->acquired_focus, current_state);
 
-		__mmcamcorder_force_stop(hcamcorder);
+		__mmcamcorder_force_stop(hcamcorder, _MMCAMCORDER_STATE_CHANGE_BY_FOCUS);
 
-		_mmcam_dbg_log("Finish opeartion. Pipeline is released");
+		_mmcam_dbg_warn("Finish opeartion. Pipeline is released");
 	} else if (focus_state == FOCUS_IS_ACQUIRED) {
 		_MMCamcorderMsgItem msg;
 
-		hcamcorder->acquired_focus |= focus_type;
-
-		_mmcam_dbg_log("FOCUS is acquired [type %d, new focus %d]",
+		_mmcam_dbg_warn("FOCUS is ready to acquired [type %d, current %d]",
 			focus_type, hcamcorder->acquired_focus);
 
 		msg.id = MM_MESSAGE_READY_TO_RESUME;
 		_mmcamcorder_send_message((MMHandleType)hcamcorder, &msg);
 
-		_mmcam_dbg_log("Finish opeartion");
+		_mmcam_dbg_warn("Finish opeartion");
 	} else {
-		_mmcam_dbg_log("unknown focus state %d", focus_state);
+		_mmcam_dbg_warn("unknown focus state %d", focus_state);
 	}
 
-	/* restore value */
-	hcamcorder->state_change_by_system = _MMCAMCORDER_STATE_CHANGE_NORMAL;
-
 	_MMCAMCORDER_UNLOCK_ASM(hcamcorder);
 
+	_mmcam_dbg_warn("done");
+
 	return;
 }
 
@@ -3298,21 +3386,37 @@ void _mmcamcorder_sound_signal_callback(mm_sound_signal_name_t signal, int value
 
 	mmf_return_if_fail(hcamcorder);
 
-	_mmcam_dbg_log("sound signal %d - value %d", signal, value);
+	_mmcam_dbg_warn("sound signal %d - value %d", signal, value);
 
 	_MMCAMCORDER_LOCK_ASM(hcamcorder);
 
 	if (signal == MM_SOUND_SIGNAL_RELEASE_INTERNAL_FOCUS && value == 1) {
-		_mmcam_dbg_log("watch cb id %d", hcamcorder->sound_focus_watch_id);
+		_mmcam_dbg_warn("focus id %d, focus watch id %d",
+			hcamcorder->sound_focus_id, hcamcorder->sound_focus_watch_id);
+
+		/* unregister focus related callback */
+		if (hcamcorder->sound_focus_id > 0) {
+			if (hcamcorder->acquired_focus > 0) {
+				mm_sound_release_focus(hcamcorder->sound_focus_id, hcamcorder->acquired_focus, "mm-camcorder release focus");
+				_mmcam_dbg_warn("release acquired focus [focus %d] done", hcamcorder->acquired_focus);
+				hcamcorder->acquired_focus = 0;
+			}
+
+			mm_sound_unregister_focus(hcamcorder->sound_focus_id);
+			_mmcam_dbg_warn("unregister sound focus done");
+			hcamcorder->sound_focus_id = 0;
+		}
 
-		/* unregister watch callback */
 		if (hcamcorder->sound_focus_watch_id > 0) {
 			mm_sound_unset_focus_watch_callback(hcamcorder->sound_focus_watch_id);
-			_mmcam_dbg_log("unset watch cb done");
+			_mmcam_dbg_warn("unset watch cb done");
 			hcamcorder->sound_focus_watch_id = 0;
 		}
 	}
 
+	/* reset flag not to run sound focus related code since now */
+	hcamcorder->sound_focus_register = FALSE;
+
 	_MMCAMCORDER_UNLOCK_ASM(hcamcorder);
 
 	_mmcam_dbg_warn("done");
@@ -3336,7 +3440,7 @@ void _mmcamcorder_sound_focus_watch_cb(int id, mm_sound_focus_type_e focus_type,
 		return;
 	}
 
-	_mmcam_dbg_log("sound focus watch callback : id %d, focus state %d, reason %s",
+	_mmcam_dbg_warn("sound focus watch callback : id %d, focus state %d, reason %s",
 		id, focus_state, reason_for_change ? reason_for_change : "N/A");
 
 	if (hcamcorder->session_flags & MM_SESSION_OPTION_UNINTERRUPTIBLE) {
@@ -3346,9 +3450,6 @@ void _mmcamcorder_sound_focus_watch_cb(int id, mm_sound_focus_type_e focus_type,
 
 	_MMCAMCORDER_LOCK_ASM(hcamcorder);
 
-	/* set value to inform a status is changed by asm */
-	hcamcorder->state_change_by_system = _MMCAMCORDER_STATE_CHANGE_BY_FOCUS;
-
 	/* check the reason */
 	if (!strncmp(reason_for_change, "ringtone-voip", __MMCAMCORDER_FOCUS_CHANGE_REASON_LEN) ||
 	    !strncmp(reason_for_change, "ringtone-call", __MMCAMCORDER_FOCUS_CHANGE_REASON_LEN) ||
@@ -3364,27 +3465,26 @@ void _mmcamcorder_sound_focus_watch_cb(int id, mm_sound_focus_type_e focus_type,
 	if (focus_state == FOCUS_IS_RELEASED) {
 		_MMCamcorderMsgItem msg;
 
-		_mmcam_dbg_log("other process's FOCUS is acquired");
+		_mmcam_dbg_warn("other process's FOCUS is released");
 
 		msg.id = MM_MESSAGE_READY_TO_RESUME;
 		_mmcamcorder_send_message((MMHandleType)hcamcorder, &msg);
 
-		_mmcam_dbg_log("Finish opeartion");
+		_mmcam_dbg_warn("Finish opeartion");
 	} else if (focus_state == FOCUS_IS_ACQUIRED) {
-		_mmcam_dbg_log("other process's FOCUS is released : Stop pipeline[state:%d]", current_state);
+		_mmcam_dbg_warn("other process's FOCUS is acquired : Stop pipeline[state:%d]", current_state);
 
-		__mmcamcorder_force_stop(hcamcorder);
+		__mmcamcorder_force_stop(hcamcorder, _MMCAMCORDER_STATE_CHANGE_BY_FOCUS);
 
-		_mmcam_dbg_log("Finish opeartion. Pipeline is released");
+		_mmcam_dbg_warn("Finish opeartion. Pipeline is released");
 	} else {
-		_mmcam_dbg_log("unknown focus state %d", focus_state);
+		_mmcam_dbg_warn("unknown focus state %d", focus_state);
 	}
 
-	/* restore value */
-	hcamcorder->state_change_by_system = _MMCAMCORDER_STATE_CHANGE_NORMAL;
-
 	_MMCAMCORDER_UNLOCK_ASM(hcamcorder);
 
+	_mmcam_dbg_warn("done");
+
 	return;
 }
 
@@ -3408,15 +3508,11 @@ void _mmcamcorder_dpm_camera_policy_changed_cb(const char *name, const char *val
 	if (!strcmp(value, "disallowed")) {
 		_MMCAMCORDER_LOCK_ASM(hcamcorder);
 
-		/* set value to inform a status is changed by DPM */
-		hcamcorder->state_change_by_system = _MMCAMCORDER_STATE_CHANGE_BY_DPM;
-
-		__mmcamcorder_force_stop(hcamcorder);
-
-		/* restore value */
-		hcamcorder->state_change_by_system = _MMCAMCORDER_STATE_CHANGE_NORMAL;
+		__mmcamcorder_force_stop(hcamcorder, _MMCAMCORDER_STATE_CHANGE_BY_DPM);
 
 		_MMCAMCORDER_UNLOCK_ASM(hcamcorder);
+
+		_mmcamcorder_request_dpm_popup(hcamcorder->gdbus_conn, "camera");
 	}
 
 	_mmcam_dbg_warn("done");
@@ -3562,18 +3658,6 @@ void _mmcamcorder_destroy_pipeline(MMHandleType handle, int type)
 }
 
 
-int _mmcamcorder_gst_set_state_async(MMHandleType handle, GstElement *pipeline, GstState target_state)
-{
-	GstStateChangeReturn setChangeReturn = GST_STATE_CHANGE_FAILURE;
-
-	_MMCAMCORDER_LOCK_GST_STATE(handle);
-	setChangeReturn = gst_element_set_state(pipeline, target_state);
-	_MMCAMCORDER_UNLOCK_GST_STATE(handle);
-
-	return setChangeReturn;
-}
-
-
 #ifdef _MMCAMCORDER_USE_SET_ATTR_CB
 static gboolean __mmcamcorder_set_attr_to_camsensor_cb(gpointer data)
 {
@@ -3710,7 +3794,7 @@ void _mmcamcorder_video_current_framerate_init(MMHandleType handle)
 }
 
 
-void __mmcamcorder_force_stop(mmf_camcorder_t *hcamcorder)
+void __mmcamcorder_force_stop(mmf_camcorder_t *hcamcorder, int state_change_by_system)
 {
 	int i = 0;
 	int loop = 0;
@@ -3718,6 +3802,7 @@ void __mmcamcorder_force_stop(mmf_camcorder_t *hcamcorder)
 	int result = MM_ERROR_NONE;
 	int cmd_try_count = 0;
 	int current_state = MM_CAMCORDER_STATE_NONE;
+	_MMCamcorderMsgItem msg;
 
 	mmf_return_if_fail(hcamcorder);
 
@@ -3739,7 +3824,37 @@ void __mmcamcorder_force_stop(mmf_camcorder_t *hcamcorder)
 
 	current_state = _mmcamcorder_get_state((MMHandleType)hcamcorder);
 
-	_mmcam_dbg_warn("Force STOP MMFW Camcorder");
+	_mmcam_dbg_warn("Force STOP MMFW Camcorder by %d", state_change_by_system);
+
+	/* set state_change_by_system for state change message */
+	hcamcorder->state_change_by_system = state_change_by_system;
+
+	if (current_state >= MM_CAMCORDER_STATE_READY) {
+		_mmcam_dbg_warn("send state change started message to notify");
+
+		memset(&msg, 0x0, sizeof(_MMCamcorderMsgItem));
+
+		switch (state_change_by_system) {
+		case _MMCAMCORDER_STATE_CHANGE_BY_FOCUS:
+			msg.id = MM_MESSAGE_CAMCORDER_STATE_CHANGE_STARTED_BY_ASM;
+			break;
+		case _MMCAMCORDER_STATE_CHANGE_BY_RM:
+			msg.id = MM_MESSAGE_CAMCORDER_STATE_CHANGE_STARTED_BY_RM;
+			break;
+		case _MMCAMCORDER_STATE_CHANGE_BY_DPM:
+			msg.id = MM_MESSAGE_CAMCORDER_STATE_CHANGE_STARTED_BY_SECURITY;
+			break;
+		default:
+			break;
+		}
+
+		if (msg.id != 0) {
+			msg.param.state.code = hcamcorder->interrupt_code;
+			_mmcamcorder_send_message((MMHandleType)hcamcorder, &msg);
+		} else {
+			_mmcam_dbg_err("should not be reached here %d", state_change_by_system);
+		}
+	}
 
 	for (loop = 0 ; current_state > MM_CAMCORDER_STATE_NULL && loop < __MMCAMCORDER_CMD_ITERATE_MAX * 3 ; loop++) {
 		itr_cnt = __MMCAMCORDER_CMD_ITERATE_MAX;
@@ -3776,7 +3891,8 @@ void __mmcamcorder_force_stop(mmf_camcorder_t *hcamcorder)
 			_mmcam_dbg_warn("Stop recording.");
 
 			while ((itr_cnt--) && ((result = _mmcamcorder_commit((MMHandleType)hcamcorder)) != MM_ERROR_NONE)) {
-				_mmcam_dbg_warn("Can't commit.(%x)", result);
+				_mmcam_dbg_warn("Can't commit.(%x), cancel it.", result);
+				_mmcamcorder_cancel((MMHandleType)hcamcorder);
 			}
 
 			break;
@@ -3785,9 +3901,8 @@ void __mmcamcorder_force_stop(mmf_camcorder_t *hcamcorder)
 		{
 			_mmcam_dbg_warn("Stop preview.");
 
-			while ((itr_cnt--) && ((result = _mmcamcorder_stop((MMHandleType)hcamcorder)) != MM_ERROR_NONE)) {
+			while ((itr_cnt--) && ((result = _mmcamcorder_stop((MMHandleType)hcamcorder)) != MM_ERROR_NONE))
 				_mmcam_dbg_warn("Can't stop preview.(%x)", result);
-			}
 
 			break;
 		}
@@ -3795,9 +3910,8 @@ void __mmcamcorder_force_stop(mmf_camcorder_t *hcamcorder)
 		{
 			_mmcam_dbg_warn("unrealize");
 
-			if ((result = _mmcamcorder_unrealize((MMHandleType)hcamcorder)) != MM_ERROR_NONE) {
+			if ((result = _mmcamcorder_unrealize((MMHandleType)hcamcorder)) != MM_ERROR_NONE)
 				_mmcam_dbg_warn("Can't unrealize.(%x)", result);
-			}
 
 			break;
 		}
@@ -3810,6 +3924,9 @@ void __mmcamcorder_force_stop(mmf_camcorder_t *hcamcorder)
 		current_state = _mmcamcorder_get_state((MMHandleType)hcamcorder);
 	}
 
+	/* restore */
+	hcamcorder->state_change_by_system = _MMCAMCORDER_STATE_CHANGE_NORMAL;
+
 	_mmcam_dbg_warn("Done.");
 
 	return;
@@ -3823,8 +3940,8 @@ static gboolean __mmcamcorder_handle_gst_error(MMHandleType handle, GstMessage *
 	gchar *msg_src_element = NULL;
 	_MMCamcorderSubContext *sc = NULL;
 
-	return_val_if_fail(hcamcorder, FALSE);
-	return_val_if_fail(error, FALSE);
+	mmf_return_val_if_fail(hcamcorder, FALSE);
+	mmf_return_val_if_fail(error, FALSE);
 	sc = MMF_CAMCORDER_SUBCONTEXT(handle);
 	mmf_return_val_if_fail(sc, FALSE);
 
@@ -3936,7 +4053,7 @@ static gint __mmcamcorder_gst_handle_core_error(MMHandleType handle, int code, G
 static gint __mmcamcorder_gst_handle_library_error(MMHandleType handle, int code, GstMessage *message)
 {
 	mmf_camcorder_t *hcamcorder = MMF_CAMCORDER(handle);
-	return_val_if_fail(hcamcorder, MM_ERROR_CAMCORDER_NOT_INITIALIZED);
+	mmf_return_val_if_fail(hcamcorder, MM_ERROR_CAMCORDER_NOT_INITIALIZED);
 
 	_mmcam_dbg_log("");
 
@@ -4012,6 +4129,8 @@ static gint __mmcamcorder_gst_handle_resource_error(MMHandleType handle, int cod
 
 			_MMCAMCORDER_UNLOCK_ASM(hcamcorder);
 
+			_mmcamcorder_request_dpm_popup(hcamcorder->gdbus_conn, "microphone");
+
 			return MM_ERROR_POLICY_RESTRICTED;
 		}
 	}
@@ -4124,8 +4243,8 @@ static gboolean __mmcamcorder_handle_gst_warning(MMHandleType handle, GstMessage
 	gchar *debug = NULL;
 	GError *err = NULL;
 
-	return_val_if_fail(hcamcorder, FALSE);
-	return_val_if_fail(error, FALSE);
+	mmf_return_val_if_fail(hcamcorder, FALSE);
+	mmf_return_val_if_fail(error, FALSE);
 
 	_mmcam_dbg_log("");
 
@@ -4236,14 +4355,10 @@ rm_cb_result _mmcamcorder_rm_callback(int handle, rm_callback_type event_src,
 	mmf_return_val_if_fail((MMHandleType)hcamcorder, RM_CB_RESULT_OK);
 
 	current_state = _mmcamcorder_get_state((MMHandleType)hcamcorder);
-	if (current_state <= MM_CAMCORDER_STATE_NONE || current_state >= MM_CAMCORDER_STATE_NUM) {
-		_mmcam_dbg_err("Abnormal state. Or null handle. (%p, %d)", hcamcorder, current_state);
-	}
 
-	_MMCAMCORDER_LOCK_ASM(hcamcorder);
+	_mmcam_dbg_warn("current state %d (handle %p)", current_state, hcamcorder);
 
-	/* set value to inform a status is changed by RM */
-	hcamcorder->state_change_by_system = _MMCAMCORDER_STATE_CHANGE_BY_RM;
+	_MMCAMCORDER_LOCK_ASM(hcamcorder);
 
 	/* set RM event code for sending it to application */
 	hcamcorder->interrupt_code = event_src;
@@ -4252,17 +4367,68 @@ rm_cb_result _mmcamcorder_rm_callback(int handle, rm_callback_type event_src,
 	switch (event_src) {
 	case RM_CALLBACK_TYPE_RESOURCE_CONFLICT:
 	case RM_CALLBACK_TYPE_RESOURCE_CONFLICT_UD:
-		__mmcamcorder_force_stop(hcamcorder);
+		__mmcamcorder_force_stop(hcamcorder, _MMCAMCORDER_STATE_CHANGE_BY_RM);
 		break;
 	default:
 		break;
 	}
 
-	/* restore value */
-	hcamcorder->state_change_by_system = _MMCAMCORDER_STATE_CHANGE_NORMAL;
-
 	_MMCAMCORDER_UNLOCK_ASM(hcamcorder);
 
 	return cb_res;
 }
 #endif /* _MMCAMCORDER_RM_SUPPORT */
+
+
+int _mmcamcorder_manage_external_storage_state(MMHandleType handle, int storage_state)
+{
+	int ret = MM_ERROR_NONE;
+	int current_state = MM_CAMCORDER_STATE_NONE;
+	mmf_camcorder_t *hcamcorder = MMF_CAMCORDER(handle);
+	_MMCamcorderMsgItem msg;
+
+	mmf_return_val_if_fail(hcamcorder, MM_ERROR_CAMCORDER_INVALID_ARGUMENT);
+
+	_mmcam_dbg_warn("storage state %d", storage_state);
+
+	/* check storage state */
+	if (storage_state != STORAGE_STATE_UNMOUNTABLE &&
+		storage_state != STORAGE_STATE_REMOVED) {
+		_mmcam_dbg_warn("nothing to do");
+		return MM_ERROR_NONE;
+	}
+
+	_MMCAMCORDER_LOCK_ASM(hcamcorder);
+
+	/* check recording state */
+	current_state = _mmcamcorder_get_state(handle);
+
+	_mmcam_dbg_warn("current_state %d", current_state);
+
+	if (current_state < MM_CAMCORDER_STATE_RECORDING) {
+		_mmcam_dbg_warn("no recording now");
+		goto _MANAGE_DONE;
+	}
+
+	/* check storage type */
+	if (hcamcorder->storage_info.type != STORAGE_TYPE_EXTERNAL) {
+		_mmcam_dbg_warn("external storage is not used");
+		goto _MANAGE_DONE;
+	}
+
+	/* cancel recording */
+	ret = _mmcamcorder_cancel(handle);
+
+	/* send error message */
+	msg.id = MM_MESSAGE_CAMCORDER_ERROR;
+	msg.param.code = MM_ERROR_OUT_OF_STORAGE;
+
+	_mmcamcorder_send_message(handle, &msg);
+
+_MANAGE_DONE:
+	_MMCAMCORDER_UNLOCK_ASM(hcamcorder);
+
+	_mmcam_dbg_warn("done - ret 0x%x", ret);
+
+	return ret;
+}