Camera.

h
#ifndef CAMERA_H
#define CAMERA_H
#include <QCamera>
#include <QCameraImageCapture>
#include <QMainWindow>
QT_BEGIN_NAMESPACE
namespace Ui { class Camera; }
QT_END_NAMESPACE
class Camera : public QMainWindow
{
Q_OBJECT
public:
Camera(QWidget *parent = 0);
~Camera();
private slots:
void setCamera(const QCameraInfo &cameraInfo);
void startCamera();
void stopCamera();
void takeImage();
void updateCameraDevice(QAction *action);
void updateCameraState(QCamera::State);
void updateCaptureMode();
void displayViewfinder();
void displayCapturedImage();
void readyForCapture(bool ready);
void imageSaved(int id, const QString &fileName);
private:
Ui::Camera *ui;
QCamera *camera;
QCameraImageCapture *imageCapture;
bool isCapturingImage;
bool applicationExiting;
};
#endif

Camera.cpp
#include "camera.h"
#include "ui_camera.h"
#include
#include
#include
#include

<QCameraViewfinder>
<QCameraInfo>
<QMediaMetaData>
<QtWidgets>

Q_DECLARE_METATYPE(QCameraInfo)
Camera::Camera(QWidget *parent) :
QMainWindow(parent),
ui(new Ui::Camera),
camera(0),
imageCapture(0),
isCapturingImage(false),
applicationExiting(false)
{
ui->setupUi(this);
//Camera devices:
setCamera(QCameraInfo::defaultCamera());
}
Camera::~Camera()
{
delete imageCapture;
delete camera;
}
void Camera::setCamera(const QCameraInfo &cameraInfo)
{
delete imageCapture;
delete camera;
camera = new QCamera(cameraInfo);
connect(camera, SIGNAL(stateChanged(QCamera::State)), this,
SLOT(updateCameraState(QCamera::State)));
imageCapture = new QCameraImageCapture(camera);
camera->setViewfinder(ui->viewfinder);
updateCameraState(camera->state());
connect(imageCapture, SIGNAL(readyForCaptureChanged(bool)), this,
SLOT(readyForCapture(bool)));
connect(imageCapture, SIGNAL(imageSaved(int,QString)), this,
SLOT(imageSaved(int,QString)));

updateCaptureMode();
camera->start();

void Camera::takeImage()
{
isCapturingImage = true;
imageCapture->capture();
}
void Camera::startCamera()
{
camera->start();
}
void Camera::stopCamera()
{

camera->stop();
}
void Camera::updateCaptureMode()
{
QCamera::CaptureModes captureMode = 0 ? QCamera::CaptureStillImage
: QCamera::CaptureVideo;

if (camera->isCaptureModeSupported(captureMode))
camera->setCaptureMode(captureMode);

void Camera::updateCameraState(QCamera::State state)

{
switch (state) {
case QCamera::ActiveState:
ui->actionStartCamera->setEnabled(false);
ui->actionStopCamera->setEnabled(true);
ui->actionSettings->setEnabled(true);
break;
case QCamera::UnloadedState:
case QCamera::LoadedState:
ui->actionStartCamera->setEnabled(true);
ui->actionStopCamera->setEnabled(false);
ui->actionSettings->setEnabled(false);
}

void Camera::updateCameraDevice(QAction *action)

{
setCamera(qvariant_cast<QCameraInfo>(action->data()));
}
void Camera::displayViewfinder()
{
ui->stackedWidget->setCurrentIndex(0);
}
void Camera::displayCapturedImage()
{
ui->stackedWidget->setCurrentIndex(1);
}
void Camera::readyForCapture(bool ready)
{
ui->takeImageButton->setEnabled(ready);
}
void Camera::imageSaved(int id, const QString &fileName)
{
Q_UNUSED(id);
Q_UNUSED(fileName);
isCapturingImage = false;
if (applicationExiting)
close();

MAIN.CPP
#include "camera.h"
#include <QtWidgets>
int main(int argc, char *argv[])
{
QApplication app(argc, argv);
Camera camera;
camera.show();
return app.exec();
};