Germany/hunting
7
0
Fork 0
Code Issues Pull Requests Actions Packages Projects 1 Releases Wiki Activity

Improve:fast start report media file.

Browse Source
This commit is contained in:
Fancy code 2024-07-25 17:09:50 +08:00
parent bae3a21d7b
commit 0c139866d2
28 changed files with 193 additions and 79 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
application/MissionManager/src/DataProcessing.h
View File

@ -27,7 +27,7 @@ enum class InternalStateEvent
SD_CARD_HANDLE_STATE_SD_STATUS_REPORTED, ///< Only SdCardHandleState can process this message.
ANY_STATE_SD_STATUS_PERORIED, ///< Use it to notify other statuses.
CHECK_UPGRADE_FILE,
MEDIA_REPORT_EVENT,
MEDIA_REPORT_EVENT, ///< Media events proactively reported by the bottom layer.
KEY_EVENT_HANDLE,
RESET_KEY_MEDIA_TASK,
FORMAT_KEY_FORMAT_SD_CARD,

12
application/MissionManager/src/MediaHandleState.cpp
View File

@ -26,7 +26,6 @@
#include "MissionStateMachine.h"
#include <functional>
#include <memory>
#include <sys/stat.h>
#include <vector>
MediaHandleState::MediaHandleState() : State("MediaHandleState")
{
@ -72,7 +71,7 @@ bool MediaHandleState::MediaTaskFinishedHandle(VStateMachineData *msg)
LogInfo("response files = %d.\n", data->mData.mResponse.size());
std::vector<SyncFileInfo> files;
for (auto &response : data->mData.mResponse) {
auto fileSize = GetFileSize_KB(response.mFileName.c_str());
auto fileSize = MediaTask::GetFileSize_KB(response.mFileName.c_str());
SyncFileInfo file(data->mData.mSerialNumber,
response.mFileName,
fileSize,
@ -86,13 +85,4 @@ bool MediaHandleState::MediaTaskFinishedHandle(VStateMachineData *msg)
LedsHandle::DeleteDeviceStatusLed();
MissionStateMachine::GetInstance()->SwitchState(SystemState::IDLE_STATE);
return EXECUTED;
}
int MediaHandleState::GetFileSize_KB(const char *filePath)
{
struct stat fileInfo;
if (stat(filePath, &fileInfo) != 0) {
LogError("stat failed.\n");
return FILE_SIZE_ERROR;
}
return static_cast<double>(fileInfo.st_size) / 1024.0;
}

4
application/MissionManager/src/MediaHandleState.h
View File

@ -18,7 +18,6 @@
#include "IStateMachine.h"
#include "LedsHandle.h"
#include "MediaTaskHandle.h"
constexpr int FILE_SIZE_ERROR = -1;
class MediaHandleState : public State,
public DataProcessing,
public MediaTaskHandle,
@ -37,8 +36,5 @@ private:
void TaskResponse(const MediaTaskInfo &taskinfo) override;
bool ResetKeyMediaTaskHandle(VStateMachineData *msg);
bool MediaTaskFinishedHandle(VStateMachineData *msg);
private:
static int GetFileSize_KB(const char *filePath);
};
#endif

69
application/MissionManager/src/MediaTask.cpp
View File

@ -14,6 +14,7 @@
*/
#include "MediaTask.h"
#include "DataProcessing.h"
#include "IIpcConfig.h"
#include "ILog.h"
#include "IMediaManager.h"
#include <cctype>
@ -25,6 +26,7 @@
#include <memory>
#include <sstream>
#include <string>
#include <sys/stat.h>
#include <vector>
MediaTask::MediaTask(const MediaTaskType &type, const InternalStateEvent &bindEvent,
const std::weak_ptr<VMediaTaskIniator> &iniator, const unsigned long &serialNumber,
@ -68,19 +70,6 @@ std::string MediaTask::GetTargetNameForSaving(void)
std::string MediaTask::GetThumbnailNameForSaving(const std::string &targetName)
{
return MediaTask::GetThumbnailNameByTargetName(targetName);
// std::string thumbnailName = targetName;
// size_t dot_pos = thumbnailName.find_last_of('.');
// if (dot_pos != std::string::npos) {
// std::string extension = thumbnailName.substr(dot_pos);
// if (extension == ".mp4") {
// thumbnailName.replace(dot_pos, extension.length(), "-thumbnail.jpeg");
// LogInfo("GetThumbnailNameForSaving: %s\n", thumbnailName.c_str());
// return thumbnailName;
// }
// }
// LogError("TargetName is not a mp4 file.\n");
// std::string unknowFile = "unknow";
// return unknowFile;
}
int MediaTask::GetVideoDuration_ms(void)
{
@ -117,4 +106,58 @@ std::string MediaTask::GetThumbnailNameByTargetName(const std::string &targetNam
LogError("TargetName is not a mp4 file.\n");
std::string unknowFile = "unknow";
return unknowFile;
}
long long MediaTask::GetCreateTime_s(void)
{
auto now = std::chrono::system_clock::now();
// time_t t_now = std::chrono::system_clock::to_time_t(now);
// struct tm tm_now = *std::localtime(&t_now);
return std::chrono::duration_cast<std::chrono::seconds>(now.time_since_epoch()).count();
}
int MediaTask::GetFileSize_KB(const char *filePath)
{
struct stat fileInfo;
if (stat(filePath, &fileInfo) != 0) {
LogError("stat failed.\n");
return FILE_SIZE_ERROR;
}
return static_cast<double>(fileInfo.st_size) / 1024.0;
}
MediaTaskType MediaTask::WorkModeConvert(const WorkMode &mode)
{
switch (mode) {
case WorkMode::MODE_PIC:
return MediaTaskType::TAKE_PICTURE;
case WorkMode::MODE_VIDEO:
return MediaTaskType::TAKE_VIDEO;
case WorkMode::MODE_PIC_VIDEO:
return MediaTaskType::TAKE_PICTURE_AND_VIDEO;
default:
LogWarning("unknow work mode.\n");
return MediaTaskType::TAKE_PICTURE_AND_VIDEO;
}
}
std::string MediaTask::GetFileNameBySeriaNumber(const unsigned long &serialNumber, const std::string &sourceFile,
const std::string &savePaht)
{
std::string fileType = "";
size_t dot_pos = sourceFile.find_last_of('.');
if (dot_pos != std::string::npos) {
std::string extension = sourceFile.substr(dot_pos);
fileType = extension;
}
auto now = std::chrono::system_clock::now();
time_t t_now = std::chrono::system_clock::to_time_t(now);
struct tm tm_now = *std::localtime(&t_now);
int hour = tm_now.tm_hour;
int minute = tm_now.tm_min;
int second = tm_now.tm_sec;
std::ostringstream pathStream;
pathStream << savePaht << "xak47-" << serialNumber << "-" << std::setw(2) << std::setfill('0') << hour
<< std::setw(2) << std::setfill('0') << minute << std::setw(2) << std::setfill('0') << second
<< fileType;
return pathStream.str();
}

7
application/MissionManager/src/MediaTask.h
View File

@ -15,9 +15,11 @@
#ifndef MEDIA_TASK_H
#define MEDIA_TASK_H
#include "DataProcessing.h"
#include "IIpcConfig.h"
#include "IMediaManager.h"
#include <string>
#include <vector>
constexpr int FILE_SIZE_ERROR = -1;
constexpr unsigned int MEDIA_TASK_TIMEOUT_MS = 1000 * 60;
constexpr int DEFAULT_VIDEO_DURATION_MS = 1000 * 10;
typedef struct media_task_info
@ -49,6 +51,11 @@ public:
public:
static std::string GetThumbnailNameByTargetName(const std::string &targetName);
static long long GetCreateTime_s(void);
static int GetFileSize_KB(const char *filePath);
static MediaTaskType WorkModeConvert(const WorkMode &mode);
static std::string GetFileNameBySeriaNumber(const unsigned long &serialNumber, const std::string &sourceFile,
const std::string &savePaht);
private:
const MediaTaskType mType;

17
application/MissionManager/src/MediaTaskHandle.cpp
View File

@ -42,7 +42,7 @@ void MediaTaskHandle::MakeSingleTask(const InternalStateEvent &bindEvent,
{
InfoToBeSaved info = IFilesManager::GetInstance()->GetInfoForSavingFiles(1);
WorkMode workMode = IIpcConfig::GetInstance()->GetWorkMode();
MediaTaskType taskType = WorkModeConvert(workMode);
MediaTaskType taskType = MediaTask::WorkModeConvert(workMode);
LogInfo("taskType: %s\n", IMediaManager::PrintfTaskType(taskType));
std::shared_ptr<VMediaTask> task =
std::make_shared<MediaTask>(taskType, bindEvent, iniator, info.mSerialNumber, info.mSavingPath);
@ -61,19 +61,4 @@ void MediaTaskHandle::MakeSingleTask(const InternalStateEvent &bindEvent,
// else if () {
// mMediaHandle->StopTask();
// }
}
MediaTaskType MediaTaskHandle::WorkModeConvert(const WorkMode &mode)
{
switch (mode) {
case WorkMode::MODE_PIC:
return MediaTaskType::TAKE_PICTURE;
case WorkMode::MODE_VIDEO:
return MediaTaskType::TAKE_VIDEO;
case WorkMode::MODE_PIC_VIDEO:
return MediaTaskType::TAKE_PICTURE_AND_VIDEO;
default:
LogWarning("unknow work mode.\n");
return MediaTaskType::TAKE_PICTURE_AND_VIDEO;
}
}

3
application/MissionManager/src/MediaTaskHandle.h
View File

@ -27,9 +27,6 @@ public:
void UnInit(void);
void MakeSingleTask(const InternalStateEvent &bindEvent, const std::shared_ptr<VMediaTaskIniator> &iniator);
private:
MediaTaskType WorkModeConvert(const WorkMode &mode);
protected:
std::shared_ptr<VMediaHandle> mMediaHandle;

19
application/MissionManager/src/MissionState.cpp
View File

@ -42,6 +42,25 @@ bool MissionState::ExecuteStateMsg(VStateMachineData *msg)
}
bool MissionState::MediaReportHandle(VStateMachineData *msg)
{
LogInfo("Get media file from chip.\n");
// std::shared_ptr<MissionMessage> message = std::dynamic_pointer_cast<MissionMessage>(msg->GetMessageObj());
// std::shared_ptr<VMissionDataV2<MediaReportEvent>> data =
// std::dynamic_pointer_cast<VMissionDataV2<MediaReportEvent>>(message->mMissionData);
// if (!data) {
// LogError("nullptr pointer.\n");
// return NOT_EXECUTED;
// }
// auto fileSize = MediaTask::GetFileSize_KB(data->mData.mFileName.c_str());
// auto createTime = MediaTask::GetCreateTime_s();
// auto createType = MissionStateMachine::GetInstance()->GetFileCreateType();
// SyncFileInfo file(UNDEFINE_SERIAL_NUMBER,
// data->mData.mFileName,
// fileSize,
// data->mData.mDuration_ms,
// createTime,
// createType,
// FileStatus::FINISHED_RECORD);
// mFastStartMediaFiles.push_back(file);
MissionStateMachine::GetInstance()->DelayMessage(msg);
MissionStateMachine::GetInstance()->SwitchState(SystemState::STORAGE_HANDLE_STATE);
return EXECUTED;

11
application/MissionManager/src/MissionState.h
View File

@ -15,6 +15,7 @@
#ifndef MISSION_STATE_H
#define MISSION_STATE_H
#include "DataProcessing.h"
#include "IFilesManager.h"
#include "IStateMachine.h"
#include "LedsHandle.h"
class MissionState : public State,
@ -33,7 +34,17 @@ protected:
bool SdCardEventReportHandle(VStateMachineData *msg);
private:
/**
* @brief Processes media events actively reported by the bottom layer, and refers to snapshot or video recording
* during quick start.
* @param msg
* @return true
* @return false
*/
bool MediaReportHandle(VStateMachineData *msg);
bool CheckUpgradeFileHandle(VStateMachineData *msg);
private:
std::vector<SyncFileInfo> mFastStartMediaFiles;
};
#endif

14
application/MissionManager/src/MissionStateMachine.cpp
View File

@ -14,6 +14,7 @@
*/
#include "MissionStateMachine.h"
#include "DataProcessing.h"
#include "IFilesManager.h"
#include "ILog.h"
#include "IMcuManager.h"
#include "IMissionManager.h"
@ -82,6 +83,19 @@ void MissionStateMachine::SwitchState(const SystemState &state)
{
mStateMachine->SwitchState(mStateTree[state].get());
}
FileCreateType MissionStateMachine::GetFileCreateType(void)
{
switch (mStartMission) {
case IpcMission::TEST:
return FileCreateType::MANUAL_TEST;
case IpcMission::PIR_TRIGGERED:
return FileCreateType::PIR;
default:
LogError("unknow ipcmission.\n");
return FileCreateType::END;
}
}
IpcMission MissionStateMachine::GetStartMission(void)
{
class McuAskIpcMission : public McuAsk<IpcMission>, public McuAskBase

7
application/MissionManager/src/MissionStateMachine.h
View File

@ -15,6 +15,7 @@
#ifndef MISSION_STATE_MACHINE_H
#define MISSION_STATE_MACHINE_H
// #include "IDeviceManager.h"
#include "IFilesManager.h"
#include "IMcuManager.h"
#include "IMissionManager.h"
#include "IStateMachine.h"
@ -48,6 +49,12 @@ public:
StatusCode MessageExecutedLater(const std::shared_ptr<VMissionData> &message, long long &delayTimeMs);
void DelayMessage(VStateMachineData *msg);
void SwitchState(const SystemState &state);
/**
* @brief Get the type of quick snapshot or video file based on the startup task parameters.
*
* @return FileCreateType
*/
FileCreateType GetFileCreateType(void);
private:
IpcMission GetStartMission(void);

35
application/MissionManager/src/SdCardHandleState.cpp
View File

@ -22,10 +22,12 @@
#include "IStorageManager.h"
#include "LedControl.h"
#include "LedsHandle.h"
#include "MediaTask.h"
#include "MissionStateMachine.h"
#include "StatusCode.h"
#include <functional>
#include <memory>
#include <vector>
using std::placeholders::_1;
SdCardHandleState::SdCardHandleState() : State("SdCardHandleState"), mSdCardStatus(StorageEvent::END)
{
@ -67,20 +69,37 @@ bool SdCardHandleState::MediaReportHandle(VStateMachineData *msg)
LogError("nullptr pointer.\n");
return NOT_EXECUTED;
}
InfoToBeSaved info = IFilesManager::GetInstance()->GetInfoForSavingFiles(1);
auto targetFile = MediaTask::GetFileNameBySeriaNumber(info.mSerialNumber, data->mData.mFileName, info.mSavingPath);
auto fileSize = MediaTask::GetFileSize_KB(data->mData.mFileName.c_str());
auto createTime = MediaTask::GetCreateTime_s();
auto createType = MissionStateMachine::GetInstance()->GetFileCreateType();
SyncFileInfo file(info.mSerialNumber,
// data->mData.mFileName,
targetFile,
fileSize,
data->mData.mDuration_ms,
createTime,
createType,
FileStatus::FINISHED_RECORD);
file.mSourceFile = data->mData.mFileName;
if (StorageEvent::SD_CARD_INSERT != mSdCardStatus) {
/**
* @brief The SD card has not been mounted yet, cache the data for the quick start first.
*
*/
LogWarning("Sd card is not inserted, cache data.\n");
mFileNeedToSave = std::make_shared<SaveFileInfo>(data->mData.mFileName);
// mFileNeedToSave = std::make_shared<SaveFileInfo>(data->mData.mFileName);
mFastStartMediaFiles.push_back(file);
return EXECUTED;
}
LogInfo("file = %s.\n", data->mData.mFileName.c_str());
SaveFileInfo saveFileInfo(data->mData.mFileName);
StatusCode code = IFilesManager::GetInstance()->SaveFile(saveFileInfo);
std::vector<SyncFileInfo> files;
files.push_back(file);
// SaveFileInfo saveFileInfo(data->mData.mFileName);
StatusCode code = IFilesManager::GetInstance()->SaveFiles(files);
if (IsCodeOK(code) == false) {
LogError("SaveFile failed.\n");
LogError("SaveFiles failed.\n");
}
return EXECUTED;
}
@ -90,13 +109,15 @@ bool SdCardHandleState::SdCardEventHandle(VStateMachineData *msg)
std::shared_ptr<VMissionDataV2<StorageEvent>> data =
std::dynamic_pointer_cast<VMissionDataV2<StorageEvent>>(message->mMissionData);
LogInfo(" SdCardEventHandle event:%s.\n", IStorageManager::GetInstance()->PrintStringStorageEvent(data->mData));
if (mFileNeedToSave && StorageEvent::SD_CARD_INSERT == data->mData) {
if (!mFastStartMediaFiles.empty() && StorageEvent::SD_CARD_INSERT == data->mData) {
LogInfo("Sd card is inserted for the first time.\n");
StatusCode code = IFilesManager::GetInstance()->SaveFile(*(mFileNeedToSave.get()));
// StatusCode code = IFilesManager::GetInstance()->SaveFile(*(mFileNeedToSave.get()));
StatusCode code = IFilesManager::GetInstance()->SaveFiles(mFastStartMediaFiles);
if (IsCodeOK(code) == false) {
LogError("SaveFile failed.\n");
}
mFileNeedToSave.reset();
// mFileNeedToSave.reset();
mFastStartMediaFiles.clear();
}
mSdCardStatus = data->mData;
/**

3
application/MissionManager/src/SdCardHandleState.h
View File

@ -45,6 +45,7 @@ protected:
private:
StorageEvent mSdCardStatus;
std::shared_ptr<SaveFileInfo> mFileNeedToSave;
std::shared_ptr<SaveFileInfo> mFileNeedToSave; // TODO: delete.
std::vector<SyncFileInfo> mFastStartMediaFiles;
};
#endif

2
application/MissionManager/src/TopState.cpp
View File

@ -51,7 +51,7 @@ bool TopState::ExecuteStateMsg(VStateMachineData *msg)
}
StatusCode TopState::ReportEvent(const MediaReportEvent &event)
{
LogInfo(" ReportEvent:\n");
LogInfo("Application recv media event(fast start).\n");
std::shared_ptr<VMissionData> message = std::make_shared<VMissionDataV2<MediaReportEvent>>(
static_cast<MissionEvent>(InternalStateEvent::MEDIA_REPORT_EVENT), event);
MissionStateMachine::GetInstance()->SendStateMessage(message);

5
hal/abstract/IHalCpp.cpp
View File

@ -18,8 +18,9 @@
#include <map>
#include <memory>
#include <string>
camera_report_event::camera_report_event(const std::string &fileName, const CameraType &cameraType)
: mFileName(fileName), mCameraType(cameraType)
camera_report_event::camera_report_event(const std::string &fileName, const CameraType &cameraType,
const unsigned int &duration_ms)
: mFileName(fileName), mCameraType(cameraType), mDuration_ms(duration_ms)
{
}
void VKeyHalMonitor::KeyEventHappened(const std::string &keyName, const VirtualKeyEvent &event,

3
hal/include/IHalCpp.h
View File

@ -50,9 +50,10 @@ enum class CameraTaskType
};
typedef struct camera_report_event
{
camera_report_event(const std::string &fileName, const CameraType &cameraType);
camera_report_event(const std::string &fileName, const CameraType &cameraType, const unsigned int &duration_ms);
const std::string mFileName;
const CameraType mCameraType;
const unsigned int mDuration_ms;
} CameraReportEvent;
void CreateHalCppModule(void);
void DestroyHalCppModule(void);

8
hal/src/CameraHal.cpp
View File

@ -32,7 +32,7 @@ void CameraHal::UnInit(void)
void CameraHal::SetCameraMonitor(std::shared_ptr<VCameraHalMonitor> &monitor)
{
std::lock_guard<std::mutex> locker(mMutex);
LogInfo("ssssssssssssssssssssssssssssssssssssSetCameraMonitor.\n");
LogInfo("SetCameraMonitor.\n");
mCameraMonitor = monitor;
if (nullptr != mFastBootEvent) {
monitor->ReportEvent(*(mFastBootEvent.get()));
@ -127,16 +127,16 @@ void CameraHal::FastStartGetJpegData(const void *stream, const unsigned int &len
auto monitor = mCameraMonitor.lock();
if (mCameraMonitor.expired()) {
LogWarning("SdCardHal: monitor is expired.\n");
mFastBootEvent = std::make_shared<CameraReportEvent>(savedFile, CameraType::MAIN_CAMERA);
mFastBootEvent = std::make_shared<CameraReportEvent>(savedFile, CameraType::MAIN_CAMERA, 0);
return;
}
CameraReportEvent report(savedFile, CameraType::MAIN_CAMERA);
CameraReportEvent report(savedFile, CameraType::MAIN_CAMERA, 0);
monitor->ReportEvent(report);
}
std::string CameraHal::SaveJpeg(const void *data, unsigned int dataLength)
{
const std::string SAVE_JPEG_FAILED = "";
const std::string SaveJpegPath = "/tmp/fastboot.jpg";
const std::string SaveJpegPath = "/tmp/fastboot.jpeg";
FILE *fp = nullptr;
fp = fopen(SaveJpegPath.c_str(), "wb");
if (fp) {

15
middleware/FilesManager/include/IFilesManager.h
View File

@ -39,7 +39,7 @@ enum class FileStatus
UPLOADED,
END
};
constexpr unsigned long UNDEFINE_SERIAL_NUMBER = -1;
constexpr unsigned long UNDEFINE_SERIAL_NUMBER = 0;
constexpr unsigned long UNDEFINE_FILE_SIZE = 0;
constexpr unsigned long UNDEFINE_FILE_DURATION = 0;
constexpr time_t UNDEFINE_CREATE_TIME = -1;
@ -50,6 +50,7 @@ typedef struct sync_file_info
const FileStatus &status);
const unsigned long mSerialNumber;
const std::string mFileName;
std::string mSourceFile; ///< If the source file exists, it will be copied to overwrite the mFileName.
const unsigned int mFileSize;
const unsigned int mFileDuration;
const time_t mCreateTime_s;
@ -64,8 +65,8 @@ typedef struct save_file_info
typedef struct info_to_be_saved
{
info_to_be_saved(const unsigned long &serialNumber, const std::string mSavingPath);
const unsigned long mSerialNumber;
const std::string mSavingPath;
const unsigned long mSerialNumber; ///< The unique key value of the file in the database.
const std::string mSavingPath; ///< The path where the file will be saved.
} InfoToBeSaved;
bool CreateFilesManagerModule(void);
bool DestroyFilesManagerModule(void);
@ -77,8 +78,14 @@ public:
static std::shared_ptr<IFilesManager> &GetInstance(std::shared_ptr<IFilesManager> *impl = nullptr);
virtual StatusCode Init(void);
virtual StatusCode UnInit(void);
virtual StatusCode SaveFile(const SaveFileInfo &fileInfo);
virtual StatusCode SaveFile(const SaveFileInfo &fileInfo); // TODO: delete
virtual InfoToBeSaved GetInfoForSavingFiles(const unsigned int &count);
/**
* @brief Synchronize file information.
*
* @param info
* @return StatusCode
*/
virtual StatusCode SaveFiles(const std::vector<SyncFileInfo> &info);
virtual StatusCode GetAllFiles(std::vector<SyncFileInfo> &info);
virtual StatusCode GetFiles(const std::vector<FileCreateType> &types, std::vector<SyncFileInfo> &info);

2
middleware/FilesManager/src/FilesDatabase.h
View File

@ -25,7 +25,7 @@ public:
virtual ~FilesDatabase() = default;
void Init(void);
void UnInit(void);
StatusCode DbSaveFile(const SaveFileInfo &fileInfo);
StatusCode DbSaveFile(const SaveFileInfo &fileInfo); // TODO: delete
InfoToBeSaved CreateInfoForSavingFiles(const unsigned int &count);
StatusCode DbSaveFiles(const std::vector<SyncFileInfo> &info);
StatusCode DbGetFiles(const std::vector<FileCreateType> &types, std::vector<SyncFileInfo> &info);

4
middleware/FilesManager/src/IFilesManager.cpp
View File

@ -25,8 +25,8 @@ save_file_info::save_file_info(const std::string &fileName) : mFileName(fileName
sync_file_info::sync_file_info(const unsigned long &serialNumber, const std::string &fileName,
const unsigned int &fileSize, const unsigned int &fileDuration,
const time_t &createTime_s, const FileCreateType &type, const FileStatus &status)
: mSerialNumber(serialNumber), mFileName(fileName), mFileSize(fileSize), mFileDuration(fileDuration),
mCreateTime_s(createTime_s), mType(type), mStatus(status)
: mSerialNumber(serialNumber), mFileName(fileName), mSourceFile(""), mFileSize(fileSize),
mFileDuration(fileDuration), mCreateTime_s(createTime_s), mType(type), mStatus(status)
{
}
info_to_be_saved::info_to_be_saved(const unsigned long &serialNumber, const std::string mSavingPath)

7
middleware/FilesManager/src/sqlite3/FilesDatabase.cpp
View File

@ -57,6 +57,13 @@ InfoToBeSaved FilesDatabase::CreateInfoForSavingFiles(const unsigned int &count)
StatusCode FilesDatabase::DbSaveFiles(const std::vector<SyncFileInfo> &info)
{
for (auto &each : info) {
if (!each.mSourceFile.empty()) {
/**
* @brief If the source file parameter is passed in, the source file needs to be copied to overwrite the
* target file.
*/
IStorageManager::GetInstance()->SaveFile(each.mSourceFile, each.mFileName);
}
bool result = SqliteHandle::GetInstance()->SyncFile(each);
if (!result) {
LogError("Save file failed.\n");

1
middleware/FilesManager/src/sqlite3/SqliteHandle.cpp
View File

@ -21,6 +21,7 @@
#include <map>
#include <memory>
#include <sstream>
#include <stdio.h>
#include <string>
#include <time.h>
#include <vector>

3
middleware/MediaManager/include/IMediaManager.h
View File

@ -41,9 +41,10 @@ enum class MediaTaskType
};
typedef struct media_report_event
{
media_report_event(const std::string &fileName, const MediaChannel &mediaChannedl);
media_report_event(const std::string &fileName, const MediaChannel &mediaChannedl, const unsigned int &duration_ms);
const std::string mFileName;
const MediaChannel mMediaChannedl;
const unsigned int mDuration_ms;
} MediaReportEvent;
typedef struct media_task_response
{

5
middleware/MediaManager/src/IMediaManager.cpp
View File

@ -18,8 +18,9 @@
#include <memory>
#include <string>
#include <vector>
media_report_event::media_report_event(const std::string &fileName, const MediaChannel &mediaChannedl)
: mFileName(fileName), mMediaChannedl(mediaChannedl)
media_report_event::media_report_event(const std::string &fileName, const MediaChannel &mediaChannedl,
const unsigned int &duration_ms)
: mFileName(fileName), mMediaChannedl(mediaChannedl), mDuration_ms(duration_ms)
{
}
media_task_response::media_task_response(const std::string &fileName, const unsigned int &duration_ms)

2
middleware/MediaManager/src/MediaManagerImpl.cpp
View File

@ -51,7 +51,7 @@ StatusCode MediaManagerImpl::SetMediaMonitor(std::shared_ptr<VMediaMonitor> &mon
void MediaManagerImpl::ReportEvent(const CameraReportEvent &event)
{
LogInfo("ReportEvent. file: %s.\n", event.mFileName.c_str());
MediaReportEvent reprot(event.mFileName, static_cast<MediaChannel>(event.mCameraType));
MediaReportEvent reprot(event.mFileName, static_cast<MediaChannel>(event.mCameraType), event.mDuration_ms);
auto monitor = mMediaMonitor.lock();
if (mMediaMonitor.expired()) {
LogWarning("MediaMonitor is expired.\n");

8
middleware/StorageManager/src/SdCardHandle.cpp
View File

@ -66,14 +66,18 @@ StatusCode SdCardHandle::SdSaveFile(const std::string &sourceFile, const std::st
LogInfo("SaveFile: %s -> %s", sourceFile.c_str(), savePaht.c_str());
constexpr int CMD_BUF_SIZE = 128;
char cmd[CMD_BUF_SIZE] = {0};
const std::string realSavePah = SD_CARD_MOUNT_PATH + savePaht;
const std::string realSavePah = savePaht;
bool directoryExist = StorageBase::CheckDirectory(realSavePah.c_str());
if (false == directoryExist) {
LogError("Directory not exist.\n");
return CreateStatusCode(STATUS_CODE_NOT_OK);
}
snprintf(cmd, CMD_BUF_SIZE, "cp %s %s", sourceFile.c_str(), realSavePah.c_str());
fx_system_v2(cmd);
LogInfo("cmd: %s", cmd);
int ret = fx_system_v2(cmd);
if (ret != 0) {
LogError("Save file failed.\n");
}
fx_system_v2("sync");
return CreateStatusCode(STATUS_CODE_OK);
}

2
test/hal/tool/src/CameraHalMock.cpp
View File

@ -247,7 +247,7 @@ void CameraHalMock::MockReportCameraEvent(const CameraReportEvent &event)
auto monitor = mMonitor.lock();
if (mMonitor.expired()) {
LogWarning("monitor is nullptr.\n");
mFastBootEvent = std::make_shared<CameraReportEvent>(event.mFileName, event.mCameraType);
mFastBootEvent = std::make_shared<CameraReportEvent>(event.mFileName, event.mCameraType, event.mDuration_ms);
return;
}
monitor->ReportEvent(event);

2
test/hal/tool/src/HalTestTool.cpp
View File

@ -120,7 +120,7 @@ void HalTestTool::MockReportCameraEvent(const std::string &fileName, const Camer
}
std::shared_ptr<CameraHalMock> cameraMock = std::dynamic_pointer_cast<CameraHalMock>(camera);
if (cameraMock) {
CameraReportEvent report(fileName, cameraType);
CameraReportEvent report(fileName, cameraType, 0); // TODO: third parameneter is need to be set.
cameraMock->MockReportCameraEvent(report);
}
else {