MMHandleType g_cam_handle;
MMCamPreset g_info;
GDBusConnection *g_dbus_connection;
-GMutex g_msg_lock;
-GCond g_msg_cond;
+GMutex g_lock;
+GCond g_capture_cond;
+GCond g_focus_cond;
+
+static int _message_callback(int id, void *param, void *user_param)
+{
+ MMMessageParamType *m = (MMMessageParamType *)param;
+
+ cout << "[ENTER]" << endl;
+
+ switch (id) {
+ case MM_MESSAGE_CAMCORDER_STATE_CHANGED:
+ cout << "[STATE CHANGED] " << m->state.previous << " -> " << m->state.current << endl;
+ break;
+ case MM_MESSAGE_CAMCORDER_CAPTURED:
+ cout << "[CAPTURED MESSAGE] SEND SIGNAL" << endl;
+ g_mutex_lock(&g_lock);
+ g_cond_signal(&g_capture_cond);
+ g_mutex_unlock(&g_lock);
+ break;
+ case MM_MESSAGE_CAMCORDER_FOCUS_CHANGED:
+ cout << "[FOCUS CHANGED] SEND SIGNAL" << endl;
+ g_mutex_lock(&g_lock);
+ g_cond_signal(&g_focus_cond);
+ g_mutex_unlock(&g_lock);
+ break;
+ default:
+ break;
+ }
+
+ cout << "[LEAVE]" << endl;
+
+ return 1;
+}
static gboolean _get_video_recording_settings(int *video_encoder, int *audio_encoder, int *file_format)
{
return FALSE;
}
-static int _message_callback(int id, void *param, void *user_param)
+static gboolean _video_stream_callback(MMCamcorderVideoStreamDataType *stream, void *user_param)
{
- MMMessageParamType *m = (MMMessageParamType *)param;
-
- switch (id) {
- case MM_MESSAGE_CAMCORDER_STATE_CHANGED:
- cout << "[STATE CHANGED] " << m->state.previous << " -> " << m->state.current << endl;
- break;
- case MM_MESSAGE_CAMCORDER_CAPTURED:
- cout << "[CAPTURED MESSAGE] SEND SIGNAL" << endl;
- g_mutex_lock(&g_msg_lock);
- g_cond_signal(&g_msg_cond);
- g_mutex_unlock(&g_msg_lock);
- break;
- default:
- break;
- }
-
- return 1;
+ cout << "[VIDEO_STREAM_CALLBACK]" << endl;
+ return TRUE;
}
-static gboolean _video_stream_callback(MMCamcorderVideoStreamDataType *stream, void *user_param)
+static gboolean _audio_stream_callback(MMCamcorderAudioStreamDataType *stream, void *user_param)
{
- cout << "[VIDEO_STREAM_CALLBACK]" << endl;
+ cout << "[AUDIO_STREAM_CALLBACK]" << endl;
return TRUE;
}
{
cout << "[MUXED_STREAM_CALLBACK]" << endl;
- g_mutex_lock(&g_msg_lock);
-
g_frame_count++;
- if (g_frame_count > 10) {
- cout << "[MUXED_STREAM_CALLBACK] SEND SIGNAL" << endl;
- g_cond_signal(&g_msg_cond);
- }
-
- g_mutex_unlock(&g_msg_lock);
-
return TRUE;
}
return TRUE;
}
+static int _start_preview(MMHandleType handle)
+{
+ int ret = MM_ERROR_NONE;
+
+ ret = mm_camcorder_realize(handle);
+ if (ret != MM_ERROR_NONE) {
+ cout << "[REALIZE failed]" << endl;
+ return ret;
+ }
+
+ ret = mm_camcorder_start(handle);
+ if (ret != MM_ERROR_NONE) {
+ cout << "[START failed]" << endl;
+ mm_camcorder_unrealize(handle);
+ }
+
+ return ret;
+}
+
+static void _stop_preview(MMHandleType handle)
+{
+ mm_camcorder_stop(handle);
+ mm_camcorder_unrealize(handle);
+}
+
class MMCamcorderTest : public ::testing::Test {
protected:
gboolean ret_wait = FALSE;
gint64 end_time = 0;
- ret = mm_camcorder_realize(g_cam_handle);
- ret |= mm_camcorder_start(g_cam_handle);
- EXPECT_EQ(ret, MM_ERROR_NONE);
-
- if (ret == MM_ERROR_NONE) {
- g_mutex_lock(&g_msg_lock);
+ ASSERT_EQ(_start_preview(g_cam_handle), MM_ERROR_NONE);
- if (mm_camcorder_set_video_capture_callback(g_cam_handle, _video_capture_callback, g_cam_handle) != MM_ERROR_NONE)
- cout << "[FAILED] set video capture callback" << endl;
+ g_mutex_lock(&g_lock);
- ret = mm_camcorder_capture_start(g_cam_handle);
- EXPECT_EQ(ret, MM_ERROR_NONE);
+ if (mm_camcorder_set_video_capture_callback(g_cam_handle, _video_capture_callback, g_cam_handle) != MM_ERROR_NONE)
+ cout << "[FAILED] set video capture callback" << endl;
- if (ret == MM_ERROR_NONE) {
- end_time = g_get_monotonic_time() + 3 * G_TIME_SPAN_SECOND;
+ ret = mm_camcorder_capture_start(g_cam_handle);
+ EXPECT_EQ(ret, MM_ERROR_NONE);
- ret_wait = g_cond_wait_until(&g_msg_cond, &g_msg_lock, end_time);
+ if (ret == MM_ERROR_NONE) {
+ end_time = g_get_monotonic_time() + 3 * G_TIME_SPAN_SECOND;
- EXPECT_EQ(ret_wait, TRUE);
+ ret_wait = g_cond_wait_until(&g_capture_cond, &g_lock, end_time);
- mm_camcorder_capture_stop(g_cam_handle);
- }
+ EXPECT_EQ(ret_wait, TRUE);
- g_mutex_unlock(&g_msg_lock);
+ mm_camcorder_capture_stop(g_cam_handle);
}
- mm_camcorder_stop(g_cam_handle);
- mm_camcorder_unrealize(g_cam_handle);
+ g_mutex_unlock(&g_lock);
+
+ _stop_preview(g_cam_handle);
}
TEST_F(MMCamcorderTest, CaptureStartN1)
{
int ret = MM_ERROR_NONE;
- ret = mm_camcorder_realize(g_cam_handle);
- ret |= mm_camcorder_start(g_cam_handle);
- EXPECT_EQ(ret, MM_ERROR_NONE);
+ ASSERT_EQ(_start_preview(g_cam_handle), MM_ERROR_NONE);
- if (ret == MM_ERROR_NONE) {
- ret = mm_camcorder_capture_start(NULL);
- EXPECT_EQ(ret, MM_ERROR_CAMCORDER_INVALID_ARGUMENT);
- }
+ ret = mm_camcorder_capture_start(NULL);
+ EXPECT_EQ(ret, MM_ERROR_CAMCORDER_INVALID_ARGUMENT);
- mm_camcorder_stop(g_cam_handle);
- mm_camcorder_unrealize(g_cam_handle);
+ _stop_preview(g_cam_handle);
}
TEST_F(MMCamcorderTest, CaptureStartN2)
mm_camcorder_unrealize(g_cam_handle);
}
+TEST_F(MMCamcorderTest, CaptureStopP)
+{
+ int ret = MM_ERROR_NONE;
+ gboolean ret_wait = FALSE;
+ gint64 end_time = 0;
+
+ ASSERT_EQ(_start_preview(g_cam_handle), MM_ERROR_NONE);
+
+ g_mutex_lock(&g_lock);
+
+ if (mm_camcorder_set_video_capture_callback(g_cam_handle, _video_capture_callback, g_cam_handle) != MM_ERROR_NONE)
+ cout << "[FAILED] set video capture callback" << endl;
+
+ ret = mm_camcorder_capture_start(g_cam_handle);
+ EXPECT_EQ(ret, MM_ERROR_NONE);
+
+ if (ret == MM_ERROR_NONE) {
+ end_time = g_get_monotonic_time() + 3 * G_TIME_SPAN_SECOND;
+
+ ret_wait = g_cond_wait_until(&g_capture_cond, &g_lock, end_time);
+
+ EXPECT_EQ(ret_wait, TRUE);
+
+ ret = mm_camcorder_capture_stop(g_cam_handle);
+ EXPECT_EQ(ret, MM_ERROR_NONE);
+ }
+
+ g_mutex_unlock(&g_lock);
+
+ _stop_preview(g_cam_handle);
+}
+
TEST_F(MMCamcorderTest, SetMessageCallbackP)
{
int ret = MM_ERROR_NONE;
EXPECT_EQ(ret, MM_ERROR_CAMCORDER_INVALID_ARGUMENT);
}
+TEST_F(MMCamcorderTest, SetAudioStreamCallbackP)
+{
+ int ret = MM_ERROR_NONE;
+
+ ret = mm_camcorder_set_audio_stream_callback(g_cam_handle, _audio_stream_callback, g_cam_handle);
+ EXPECT_EQ(ret, MM_ERROR_NONE);
+}
+
+TEST_F(MMCamcorderTest, SetAudioStreamCallbackN)
+{
+ int ret = MM_ERROR_NONE;
+
+ ret = mm_camcorder_set_audio_stream_callback(NULL, _audio_stream_callback, g_cam_handle);
+ EXPECT_EQ(ret, MM_ERROR_CAMCORDER_INVALID_ARGUMENT);
+}
+
TEST_F(MMCamcorderTest, SetVideoCaptureCallbackP)
{
int ret = MM_ERROR_NONE;
int audio_encoder = 0;
int file_format = 0;
gboolean ret_settings = FALSE;
- gboolean ret_wait = FALSE;
- gint64 end_time = 0;
- ret = mm_camcorder_realize(g_cam_handle);
- ret |= mm_camcorder_start(g_cam_handle);
+ ASSERT_EQ(_start_preview(g_cam_handle), MM_ERROR_NONE);
+
+ g_frame_count = 0;
+
+ if (mm_camcorder_set_muxed_stream_callback(g_cam_handle, _muxed_stream_callback, g_cam_handle) != MM_ERROR_NONE)
+ cout << "[FAILED] set muxed stream callback" << endl;
+
+ ret_settings = _get_video_recording_settings(&video_encoder, &audio_encoder, &file_format);
+ EXPECT_EQ(ret_settings, TRUE);
+
+ ret = mm_camcorder_set_attributes(g_cam_handle, NULL,
+ MMCAM_VIDEO_ENCODER, video_encoder,
+ MMCAM_AUDIO_ENCODER, audio_encoder,
+ MMCAM_FILE_FORMAT, file_format,
+ NULL);
+ EXPECT_EQ(ret, MM_ERROR_NONE);
+
+ ret = mm_camcorder_record(g_cam_handle);
EXPECT_EQ(ret, MM_ERROR_NONE);
if (ret == MM_ERROR_NONE) {
- g_mutex_lock(&g_msg_lock);
+ sleep(5);
+
+ EXPECT_EQ(g_frame_count > 30, TRUE);
+
+ mm_camcorder_cancel(g_cam_handle);
+ }
+
+ _stop_preview(g_cam_handle);
+}
+
+TEST_F(MMCamcorderTest, CommitP)
+{
+ int ret = MM_ERROR_NONE;
+ int video_encoder = 0;
+ int audio_encoder = 0;
+ int file_format = 0;
+ gboolean ret_settings = FALSE;
+
+ ASSERT_EQ(_start_preview(g_cam_handle), MM_ERROR_NONE);
- g_frame_count = 0;
+ if (mm_camcorder_set_muxed_stream_callback(g_cam_handle, _muxed_stream_callback, g_cam_handle) != MM_ERROR_NONE)
+ cout << "[FAILED] set muxed stream callback" << endl;
- if (mm_camcorder_set_muxed_stream_callback(g_cam_handle, _muxed_stream_callback, g_cam_handle) != MM_ERROR_NONE)
- cout << "[FAILED] set video capture callback" << endl;
+ ret_settings = _get_video_recording_settings(&video_encoder, &audio_encoder, &file_format);
+ EXPECT_EQ(ret_settings, TRUE);
- ret_settings = _get_video_recording_settings(&video_encoder, &audio_encoder, &file_format);
- EXPECT_EQ(ret_settings, TRUE);
+ ret = mm_camcorder_set_attributes(g_cam_handle, NULL,
+ MMCAM_VIDEO_ENCODER, video_encoder,
+ MMCAM_AUDIO_ENCODER, audio_encoder,
+ MMCAM_FILE_FORMAT, file_format,
+ NULL);
+ EXPECT_EQ(ret, MM_ERROR_NONE);
- ret = mm_camcorder_set_attributes(g_cam_handle, NULL,
- MMCAM_VIDEO_ENCODER, video_encoder,
- MMCAM_AUDIO_ENCODER, audio_encoder,
- MMCAM_FILE_FORMAT, file_format,
- NULL);
+ ret = mm_camcorder_record(g_cam_handle);
+ EXPECT_EQ(ret, MM_ERROR_NONE);
- ret = mm_camcorder_record(g_cam_handle);
+ if (ret == MM_ERROR_NONE) {
+ sleep(5);
+ ret = mm_camcorder_commit(g_cam_handle);
EXPECT_EQ(ret, MM_ERROR_NONE);
+ }
- if (ret == MM_ERROR_NONE) {
- end_time = g_get_monotonic_time() + 5 * G_TIME_SPAN_SECOND;
+ _stop_preview(g_cam_handle);
+}
- ret_wait = g_cond_wait_until(&g_msg_cond, &g_msg_lock, end_time);
+TEST_F(MMCamcorderTest, CancelP)
+{
+ int ret = MM_ERROR_NONE;
+ int video_encoder = 0;
+ int audio_encoder = 0;
+ int file_format = 0;
+ gboolean ret_settings = FALSE;
- cout << "[RECORDING] SIGNAL RECEIVED : " << ret_wait << endl;
+ ASSERT_EQ(_start_preview(g_cam_handle), MM_ERROR_NONE);
- EXPECT_EQ(ret_wait, TRUE);
+ if (mm_camcorder_set_muxed_stream_callback(g_cam_handle, _muxed_stream_callback, g_cam_handle) != MM_ERROR_NONE)
+ cout << "[FAILED] set muxed stream callback" << endl;
- mm_camcorder_cancel(g_cam_handle);
- }
+ ret_settings = _get_video_recording_settings(&video_encoder, &audio_encoder, &file_format);
+ EXPECT_EQ(ret_settings, TRUE);
+
+ ret = mm_camcorder_set_attributes(g_cam_handle, NULL,
+ MMCAM_VIDEO_ENCODER, video_encoder,
+ MMCAM_AUDIO_ENCODER, audio_encoder,
+ MMCAM_FILE_FORMAT, file_format,
+ NULL);
+ EXPECT_EQ(ret, MM_ERROR_NONE);
+
+ ret = mm_camcorder_record(g_cam_handle);
+ EXPECT_EQ(ret, MM_ERROR_NONE);
- g_mutex_unlock(&g_msg_lock);
+ if (ret == MM_ERROR_NONE) {
+ ret = mm_camcorder_cancel(g_cam_handle);
+ EXPECT_EQ(ret, MM_ERROR_NONE);
}
- mm_camcorder_stop(g_cam_handle);
- mm_camcorder_unrealize(g_cam_handle);
+ _stop_preview(g_cam_handle);
+}
+
+TEST_F(MMCamcorderTest, PauseP)
+{
+ int ret = MM_ERROR_NONE;
+ int video_encoder = 0;
+ int audio_encoder = 0;
+ int file_format = 0;
+ gboolean ret_settings = FALSE;
+
+ ASSERT_EQ(_start_preview(g_cam_handle), MM_ERROR_NONE);
+
+ if (mm_camcorder_set_muxed_stream_callback(g_cam_handle, _muxed_stream_callback, g_cam_handle) != MM_ERROR_NONE)
+ cout << "[FAILED] set muxed stream callback" << endl;
+
+ ret_settings = _get_video_recording_settings(&video_encoder, &audio_encoder, &file_format);
+ EXPECT_EQ(ret_settings, TRUE);
+
+ ret = mm_camcorder_set_attributes(g_cam_handle, NULL,
+ MMCAM_VIDEO_ENCODER, video_encoder,
+ MMCAM_AUDIO_ENCODER, audio_encoder,
+ MMCAM_FILE_FORMAT, file_format,
+ NULL);
+ EXPECT_EQ(ret, MM_ERROR_NONE);
+
+ ret = mm_camcorder_record(g_cam_handle);
+ EXPECT_EQ(ret, MM_ERROR_NONE);
+
+ if (ret == MM_ERROR_NONE) {
+ sleep(5);
+
+ ret = mm_camcorder_pause(g_cam_handle);
+ EXPECT_EQ(ret, MM_ERROR_NONE);
+
+ mm_camcorder_cancel(g_cam_handle);
+ }
+
+ _stop_preview(g_cam_handle);
+}
+
+TEST_F(MMCamcorderTest, GetStateP)
+{
+ int ret = MM_ERROR_NONE;
+ MMCamcorderStateType state = MM_CAMCORDER_STATE_NONE;
+
+ ret = mm_camcorder_get_state(g_cam_handle, &state);
+ ASSERT_EQ(ret, MM_ERROR_NONE);
+}
+
+TEST_F(MMCamcorderTest, GetState2P)
+{
+ int ret = MM_ERROR_NONE;
+ MMCamcorderStateType state = MM_CAMCORDER_STATE_NONE;
+ MMCamcorderStateType old_state = MM_CAMCORDER_STATE_NONE;
+
+ ret = mm_camcorder_get_state2(g_cam_handle, &state, &old_state);
+ ASSERT_EQ(ret, MM_ERROR_NONE);
+}
+
+TEST_F(MMCamcorderTest, GetAttributesP)
+{
+ int ret = MM_ERROR_NONE;
+ int device_count = 0;
+ int audio_device = 0;
+
+ ret = mm_camcorder_get_attributes(g_cam_handle, NULL,
+ MMCAM_CAMERA_DEVICE_COUNT, &device_count,
+ MMCAM_AUDIO_DEVICE, &audio_device,
+ NULL);
+ ASSERT_EQ(ret, MM_ERROR_NONE);
+}
+
+TEST_F(MMCamcorderTest, SetAttributesP)
+{
+ int ret = MM_ERROR_NONE;
+ int audio_encoder = 0;
+ int file_format = 0;
+ gboolean ret_settings = FALSE;
+
+ ret_settings = _get_audio_recording_settings(&audio_encoder, &file_format);
+ ASSERT_EQ(ret_settings, TRUE);
+
+ ret = mm_camcorder_set_attributes(g_cam_handle, NULL,
+ MMCAM_MODE, MM_CAMCORDER_MODE_AUDIO,
+ MMCAM_AUDIO_ENCODER, audio_encoder,
+ MMCAM_FILE_FORMAT, file_format,
+ NULL);
+ ASSERT_EQ(ret, MM_ERROR_NONE);
+}
+
+TEST_F(MMCamcorderTest, GetAttributeInfoP)
+{
+ int ret = MM_ERROR_NONE;
+ MMCamAttrsInfo info;
+
+ ret = mm_camcorder_get_attribute_info(g_cam_handle, MMCAM_MODE, &info);
+ ASSERT_EQ(ret, MM_ERROR_NONE);
+}
+
+TEST_F(MMCamcorderTest, GetFPSListByResolutionP)
+{
+ int ret = MM_ERROR_NONE;
+ int width = 0;
+ int height = 0;
+ MMCamAttrsInfo fps_info;
+
+ ret = mm_camcorder_get_attributes(g_cam_handle, NULL,
+ MMCAM_CAMERA_WIDTH, &width,
+ MMCAM_CAMERA_HEIGHT, &height,
+ NULL);
+ ASSERT_EQ(ret, MM_ERROR_NONE);
+
+ ret = mm_camcorder_get_fps_list_by_resolution(g_cam_handle, width, height, &fps_info);
+ ASSERT_EQ(ret, MM_ERROR_NONE);
+}
+
+TEST_F(MMCamcorderTest, InitFocsingP)
+{
+ ASSERT_EQ(_start_preview(g_cam_handle), MM_ERROR_NONE);
+
+ EXPECT_EQ(mm_camcorder_init_focusing(g_cam_handle), MM_ERROR_NONE);
+
+ _stop_preview(g_cam_handle);
+}
+
+TEST_F(MMCamcorderTest, StartFocusingP)
+{
+ gint64 end_time = 0;
+
+ ASSERT_EQ(_start_preview(g_cam_handle), MM_ERROR_NONE);
+
+ g_mutex_lock(&g_lock);
+
+ EXPECT_EQ(mm_camcorder_start_focusing(g_cam_handle), MM_ERROR_NONE);
+
+ end_time = g_get_monotonic_time() + 3 * G_TIME_SPAN_SECOND;
+
+ EXPECT_EQ(g_cond_wait_until(&g_focus_cond, &g_lock, end_time), TRUE);
+
+ g_mutex_unlock(&g_lock);
+
+ _stop_preview(g_cam_handle);
+}
+
+TEST_F(MMCamcorderTest, StopFocusingP)
+{
+ ASSERT_EQ(_start_preview(g_cam_handle), MM_ERROR_NONE);
+
+ EXPECT_EQ(mm_camcorder_start_focusing(g_cam_handle), MM_ERROR_NONE);
+ EXPECT_EQ(mm_camcorder_stop_focusing(g_cam_handle), MM_ERROR_NONE);
+
+ _stop_preview(g_cam_handle);
}