Recording video

Container {
    Camera {
        id: qmlCameraObj
 
        attachedObjects: [
            CameraSettings {
                id: cameraModeSetting
            }
        ]
         // ...

        onCameraOpened: {
            qmlCameraObj.getSettings(cameraModeSetting)
            cameraModeSetting.cameraMode = CameraMode.Video
            qmlCameraObj.applySettings(cameraModeSetting)
 
            // Start the viewfinder
			// ...
        }
        // ...
		
}                    
                

// In your app's header file
CameraSettings* m_pCameraModeSetting;
		
// In your app's .cpp file
m_pCameraModeSetting = new CameraSettings();

// ...

void ApplicationUI::onCameraOpened ()
{
    // Set video mode for the Camera.
    m_pCamera->getSettings(m_pCameraModeSetting);
    m_pCameraModeSetting->setCameraMode(CameraMode::Video);
    m_pCamera->applySettings(m_pCameraModeSetting);

    // Start the viewfinder
    // ...
}         
                

static const char vf_group[] = "viewfinder_window_group";
static const char vf_id[] = "my_viewfinder";

/* Set the viewfinder mode */
if (camera_set_vf_mode(handle, CAMERA_VFMODE_VIDEO) == CAMERA_EOK) {
    /* Set the required viewfinder properties */
    error = camera_set_vf_property(handle,
                           CAMERA_IMGPROP_WIN_GROUPID, vf_group,
                           CAMERA_IMGPROP_WIN_ID, vf_id);                 
    if (err == CAMERA_EOK) {
        /* Start the viewfinder
           ...
         */
    }
    else {
        /* Handle error */
}

The following code sample defines two action items, one to start video recording and one to stop recording. When "Start" is triggered, the startVideoRecording() function is invoked to play the shutter sound and start recording. When "Stop" is triggered, the stopVideoRecording() function stops the recording and plays the shutter sound for recording stop.

Page {
    // ...
    
    content: Container {

        attachedObjects: [
            // ...
            
            SystemSound {
                id: videoStartSnd
                sound: SystemSound.RecordingStartEvent
            },
            SystemSound {
                id: videoStopSnd
                sound: SystemSound.RecordingStopEvent
            }
        ]
                
    // ...
    }
 
    actions: [
        ActionItem {
            id: aiRecordStart
            title: "Start"
            accessibility.name: "Start"
			
            ActionBar.placement: ActionBarPlacement.OnBar
            imageSource: "asset:///ic_rec_red.png"
            onTriggered: {
                startVideoRecording()
            }
        },
        ActionItem {
            id: aiRecordStop
            title: "Stop"
            accessibility.name: "Stop"
			
            ActionBar.placement: ActionBarPlacement.OnBar
            imageSource: "asset:///ic_stop.png"
            onTriggered: {
                stopVideoRecording()
            }
        }
		
        // ...
    }

    // Start recording
    function startVideoRecording() {
        videoStartSnd.play()
	    qmlCameraObj.startVideoCapture()
    }

    // Stop recording
    function stopVideoRecording() {
        qmlCameraObj.stopVideoCapture()
	    videoStopSnd.play()
    }

}                   
                

The following code sample uses two action items, m_pRecordStartButton and m_pRecordStopButton, to start and stop video capture. You can define these action items in your QML file. See the QML tab for an example. When an action item is triggered, the connected slot is invoked to start or stop video recording.

// In your app's header file
// declare shutter sounds for starting and stopping recording
SystemSound* m_pStartRecordingSound;
SystemSound* m_pStopRecordingSound;

// Declare action items for starting and stopping recording
ActionItem* m_pRecordStartButton;
ActionItem* m_pRecordStopButton;

// In your app's .cpp file
m_pStartRecordingSound = new SystemSound(SystemSound::RecordingStartEvent);
m_pStopRecordingSound = new SystemSound(SystemSound::RecordingStopEvent);

m_pRecordStartButton = root->findChild < bb::cascades::ActionItem* >("aiRecordStart");
m_pRecordStopButton = root->findChild < bb::cascades::ActionItem* >("aiRecordStop");

// In the ApplicationUI constructor
// connect the slots to the triggered() signal

// ...

result = QObject::connect(m_pRecordStartButton,
                          SIGNAL(triggered()),
                          this,
                          SLOT(onRecordStartTriggered()));

Q_ASSERT(result);

result = QObject::connect(m_pRecordStopButton,
                          SIGNAL(triggered()),
                          this,
                          SLOT(onRecordStopTriggered()));

Q_ASSERT(result);
 
// Define the slot that starts video capture
void ApplicationUI::onRecordStartTriggered ()
{
    m_pStartRecordingSound->play();
    m_pCamera->startVideoCapture();
}

// Define the slot that stops video capture
void ApplicationUI::onRecordStopTriggered ()
{
    m_pCamera->stopVideoCapture();
    m_pStopRecordingSound->play();
}
      

The following code sample assumes that the screen touch event (SCREEN_EVENT_MTOUCH_TOUCH) is used to trigger video recording. The code sample creates a video file and opens it for writing before starting video capture. For a code sample that uses screen events, see Handle screen events. You don't have to use screen touch events to trigger a camera operation.

/* Receive the SCREEN_EVENT_MTOUCH_TOUCH event */
/* ... */

char filename[CAMERA_ROLL_NAMELEN];

/* Open a video file on the camera roll */
err = camera_roll_open_video(handle,
                             &video_fd, 
                             filename,
                             sizeof(filename),
                             CAMERA_ROLL_VIDEO_FMT_DEFAULT);
			
if (err != CAMERA_EOK) {
    /* Handle error */
}	 
 
/* Play the shutter sound for recording start */
soundplayer_play_sound("event_recording_start");

err = camera_start_video(handle,
                         filename,
                         NULL,
                         NULL,
                         (void*)filename); 

if (err != CAMERA_EOK) {
    fprintf(stderr, "camera_start_video() failed: %d", err);
    /* Delete the video file */
    close(video_fd);
    unlink(filename);
    /* Play the shutter sound for recording stop */
    soundplayer_play_sound("event_recording_stop");
}                     
                

When a screen touch event arrives during video capture, stop recording by calling camera_stop_video(). You must also close the video file after stopping video capture.

/* Receive the SCREEN_EVENT_MTOUCH_TOUCH event */
/* ... */

/* Stop recording */
err = camera_stop_video(handle);
if(err != CAMERA_EOK) {
    /* Handle error */
}

close(video_fd);
soundplayer_play_sound("event_recording_stop");