apollo::dreamview::HMIWorker类 参考

#include <hmi_worker.h>

apollo::dreamview::HMIWorker 的协作图:

Public 类型
using	DvCallback = std::function< nlohmann::json(const std::string &function_name, const nlohmann::json &param_json)>
using	StatusUpdateHandler = std::function< void(const bool status_changed, HMIStatus *status)>
using	DvCallback = std::function< nlohmann::json(const std::string &function_name, const nlohmann::json &param_json)>
using	StatusUpdateHandler = std::function< void(const bool status_changed, HMIStatus *status)>

Public 成员函数
	HMIWorker ()
	HMIWorker (const std::shared_ptr< apollo::cyber::Node > &node)
void	Start (DvCallback callback_api)
void	Stop ()
bool	Trigger (const HMIAction action)
bool	Trigger (const HMIAction action, const std::string &value)
void	RegisterStatusUpdateHandler (StatusUpdateHandler handler)
void	SubmitAudioEvent (const uint64_t event_time_ms, const int obstacle_id, const int audio_type, const int moving_result, const int audio_direction, const bool is_siren_on)
void	SubmitDriveEvent (const uint64_t event_time_ms, const std::string &event_msg, const std::vector< std::string > &event_types, const bool is_reportable)
void	SensorCalibrationPreprocess (const std::string &task_type)
void	VehicleCalibrationPreprocess ()
HMIStatus	GetStatus () const
bool	UpdateScenarioSetToStatus (const std::string &scenario_set_id, const std::string &scenario_set_name)
bool	UpdateScenarioSet (const std::string &scenario_set_id, const std::string &scenario_set_name, ScenarioSet *new_scenario_set)
bool	UpdateDynamicModelToStatus (const std::string &dynamic_model_name)
void	UpdateComponentStatus ()
bool	LoadRecords ()
bool	ReloadVehicles ()
void	GetScenarioSetPath (const std::string &scenario_set_id, std::string *scenario_set_path)
void	UpdateCameraSensorChannelToStatus (const std::string &channel_name)
void	UpdatePointCloudChannelToStatus (const std::string &channel_name)
	HMIWorker (apollo::common::monitor::MonitorLogBuffer monitor_log_buffer)
	HMIWorker (const std::shared_ptr< apollo::cyber::Node > &node, const apollo::common::monitor::MonitorLogBuffer &monitor_log_buffer)
void	Start (DvCallback callback_api)
void	Stop ()
bool	Trigger (const HMIAction action)
bool	Trigger (const HMIAction action, const std::string &value)
void	RegisterStatusUpdateHandler (StatusUpdateHandler handler)
void	SubmitAudioEvent (const uint64_t event_time_ms, const int obstacle_id, const int audio_type, const int moving_result, const int audio_direction, const bool is_siren_on)
void	SubmitDriveEvent (const uint64_t event_time_ms, const std::string &event_msg, const std::vector< std::string > &event_types, const bool is_reportable)
void	SensorCalibrationPreprocess (const std::string &task_type)
void	VehicleCalibrationPreprocess ()
HMIStatus	GetStatus () const
bool	UpdateDynamicModelToStatus (const std::string &dynamic_model_name)
void	UpdateComponentStatus ()
bool	UpdateMapToStatus (const std::string &map_name)
bool	LoadRecords ()
bool	LoadRecordAndChangeStatus (const std::string &record_name)
bool	LoadRecord (const std::string &record_name, const std::string &record_file_path, double *total_time_s)
bool	RecordIsLoaded (const std::string &record_id)
bool	RePlayRecord ()
bool	LoadRtkRecords ()
void	UpdateRtkRecordToStatus (const std::string &new_name)
bool	handlePlayRecordProcess (const std::string &action_type)
	control the nohup play record process by action_type
bool	ResetRecordProgress (const double &progress)
	reset the play record progress to jump.
bool	ReloadVehicles ()
void	GetScenarioSetPath (const std::string &scenario_set_id, std::string *scenario_set_path)
void	UpdateCameraSensorChannelToStatus (const std::string &channel_name)
void	UpdatePointCloudChannelToStatus (const std::string &channel_name)
bool	StartDataRecorder ()
bool	StopDataRecorder ()
int	SaveDataRecorder (const std::string &new_name)
bool	DeleteDataRecorder ()
bool	StartRtkDataRecorder ()
bool	StopRtkDataRecorder ()
bool	DeleteRtkDataRecorder ()
int	SaveRtkDataRecorder (const std::string &new_name)
bool	StopPlayRtkRecorder ()
nlohmann::json	StartPlayRtkRecorder ()
void	ChangeMapVal (const std::string &map_name)
bool	AddOrModifyObjectToDB (const std::string &key, const std::string &value)
bool	DeleteObjectToDB (const std::string &key)
std::string	GetObjectFromDB (const std::string &key)
std::vector< std::pair< std::string, std::string > >	GetTuplesWithTypeFromDB (const std::string &type)
bool	StartTerminal ()
bool	isProcessRunning (const std::string &process_name)
	Check if a process exists

详细描述

在文件 hmi_worker.h 第 56 行定义.

成员类型定义说明

DvCallback [1/2]

using apollo::dreamview::HMIWorker::DvCallback = std::function<nlohmann::json( const std::string& function_name, const nlohmann::json& param_json)>

在文件 hmi_worker.h 第 58 行定义.

DvCallback [2/2]

using apollo::dreamview::HMIWorker::DvCallback = std::function<nlohmann::json( const std::string& function_name, const nlohmann::json& param_json)>

在文件 hmi_worker.h 第 58 行定义.

StatusUpdateHandler [1/2]

using apollo::dreamview::HMIWorker::StatusUpdateHandler = std::function<void(const bool status_changed, HMIStatus* status)>

在文件 hmi_worker.h 第 72 行定义.

StatusUpdateHandler [2/2]

using apollo::dreamview::HMIWorker::StatusUpdateHandler = std::function<void(const bool status_changed, HMIStatus* status)>

在文件 hmi_worker.h 第 76 行定义.

构造及析构函数说明

HMIWorker() [1/4]

apollo::dreamview::HMIWorker::HMIWorker ( )

inline

在文件 hmi_worker.h 第 60 行定义.

: HMIWorker(cyber::CreateNode("HMI")) {}

HMIWorker() [2/4]

apollo::dreamview::HMIWorker::HMIWorker ( const std::shared_ptr< apollo::cyber::Node > &  node )

explicit

HMIWorker() [3/4]

apollo::dreamview::HMIWorker::HMIWorker ( apollo::common::monitor::MonitorLogBuffer  monitor_log_buffer )

inlineexplicit

在文件 hmi_worker.h 第 60 行定义.

      : HMIWorker(cyber::CreateNode("HMI"), monitor_log_buffer) {}

HMIWorker() [4/4]

apollo::dreamview::HMIWorker::HMIWorker	(	const std::shared_ptr< apollo::cyber::Node > &	node,
		const apollo::common::monitor::MonitorLogBuffer &	monitor_log_buffer
	)

成员函数说明

AddOrModifyObjectToDB()

bool apollo::dreamview::HMIWorker::AddOrModifyObjectToDB	(	const std::string &	key,
		const std::string &	value
	)

在文件 hmi_worker.cc 第 1887 行定义.

                                                              {
  return KVDB::Put(key, value);
}

ChangeMapVal()

void apollo::dreamview::HMIWorker::ChangeMapVal

(

const std::string &

map_name

)

DeleteDataRecorder()

bool apollo::dreamview::HMIWorker::DeleteDataRecorder

(

)

在文件 hmi_worker.cc 第 1789 行定义.

                                   {
  std::string delete_cmd =
      "/apollo/scripts/record_bag.py --delete --default_name " +
      FLAGS_data_record_default_name;
  int ret = std::system(delete_cmd.data());
  if (ret == 0) {
    return true;
  } else {
    AERROR << "Failed to delete the record";
    return false;
  }
}

DeleteObjectToDB()

bool apollo::dreamview::HMIWorker::DeleteObjectToDB

(

const std::string &

key

)

在文件 hmi_worker.cc 第 1892 行定义.

                                                     {
  return KVDB::Delete(key);
}

DeleteRtkDataRecorder()

bool apollo::dreamview::HMIWorker::DeleteRtkDataRecorder

(

)

在文件 hmi_worker.cc 第 2034 行定义.

                                      {
  if (!cyber::common::PathExists(FLAGS_default_rtk_record_file)) {
    AERROR << "Failed to delete the ret record, file not exist";
    return false;
  }
  if (std::remove(FLAGS_default_rtk_record_file.data()) == 0) {
      return true;
    } else {
      AERROR << "Failed to delete the record, delete command execution failed";
      return false;
    }
  }

GetObjectFromDB()

std::string apollo::dreamview::HMIWorker::GetObjectFromDB

(

const std::string &

key

)

在文件 hmi_worker.cc 第 1896 行定义.

                                                         {
  return KVDB::Get(key).value_or("");
}

GetScenarioSetPath() [1/2]

void apollo::dreamview::HMIWorker::GetScenarioSetPath	(	const std::string &	scenario_set_id,
		std::string *	scenario_set_path
	)

在文件 hmi_worker.cc 第 788 行定义.

                                                                 {
  CHECK_NOTNULL(scenario_set_path);
  GetScenarioResourcePath(scenario_set_path);
  *scenario_set_path = *scenario_set_path + scenario_set_id;
  return;
}

GetScenarioSetPath() [2/2]

void apollo::dreamview::HMIWorker::GetScenarioSetPath	(	const std::string &	scenario_set_id,
		std::string *	scenario_set_path
	)

GetStatus() [1/2]

HMIStatus apollo::dreamview::HMIWorker::GetStatus

(

)

const

在文件 hmi_worker.cc 第 681 行定义.

                                     {
  RLock rlock(status_mutex_);
  return status_;
}

GetStatus() [2/2]

HMIStatus apollo::dreamview::HMIWorker::GetStatus

(

)

const

GetTuplesWithTypeFromDB()

std::vector< std::pair< std::string, std::string > > apollo::dreamview::HMIWorker::GetTuplesWithTypeFromDB

(

const std::string &

type

)

在文件 hmi_worker.cc 第 1901 行定义.

                                                        {
  return KVDB::GetWithStart(type);
}

handlePlayRecordProcess()

bool apollo::dreamview::HMIWorker::handlePlayRecordProcess

(

const std::string &

action_type

)

control the nohup play record process by action_type

参数

action_type

The action to control the nohup play record process optional values like pause and continue.

返回

If the action executed successfully.

在文件 hmi_worker.cc 第 1018 行定义.

                                                                    {
  std::string record_id;
  PlayRecordStatus current_play_record_status;
  PlayRecordStatus expected_play_record_status;
  PlayRecordStatus reasonable_play_record_status;
  {
    RLock rlock(status_mutex_);
    auto record_status = status_.current_record_status();
    record_id = record_status.current_record_id();
    current_play_record_status = record_status.play_record_status();
    if (record_id.empty()) {
      AERROR << "Failed to pause record for record has not been selected"
                "or process is not exists!";
      return false;
    }
    if (!RecordIsLoaded(record_id)) {
      AERROR << "Failed to pause record for record has not been loaded!";
      return false;
    }
  }
  if (action_type.compare("continue") == 0) {
    expected_play_record_status = PlayRecordStatus::RUNNING;
    reasonable_play_record_status = PlayRecordStatus::PAUSED;
  } else if (action_type.compare("pause") == 0) {
    expected_play_record_status = PlayRecordStatus::PAUSED;
    reasonable_play_record_status = PlayRecordStatus::RUNNING;
  } else {
    AERROR << "Invalid action type for play record.";
    return false;
  }
  if (reasonable_play_record_status != current_play_record_status) {
    return false;
  }
  auto *record_player_factory = RecordPlayerFactory::Instance();
  auto player_ptr = record_player_factory->GetRecordPlayer(record_id);
  if (!player_ptr) {
    AERROR << "Failed to get record player.";
    return false;
  }
  player_ptr->HandleNohupThreadStatus();
 
  {
    WLock wlock(status_mutex_);
    status_.mutable_current_record_status()->set_play_record_status(
        expected_play_record_status);
    status_changed_ = true;
  }
  record_player_factory->IncreaseRecordPriority(record_id);
  return true;
}

isProcessRunning()

bool apollo::dreamview::HMIWorker::isProcessRunning

(

const std::string &

process_name

)

Check if a process exists

参数

process_name

The name of the process to check

返回

True if the process exists

在文件 hmi_worker.cc 第 2090 行定义.

                                                              {
  std::stringstream commandStream;
  commandStream << "pgrep -f " << process_name;
  std::string command = commandStream.str();
 
  FILE *fp = popen(command.c_str(), "r");
  if (fp) {
    char result[128];
    if (fgets(result, sizeof(result), fp) != nullptr) {
      AINFO << process_name << " is running";
      pclose(fp);
      return true;
    } else {
      AINFO << process_name << " is not running";
    }
    pclose(fp);
  }
  return false;
}

LoadRecord()

bool apollo::dreamview::HMIWorker::LoadRecord	(	const std::string &	record_name,
		const std::string &	record_file_path,
		double *	total_time_s
	)

在文件 hmi_worker.cc 第 1416 行定义.

                                                 {
  if (RecordIsLoaded(record_name)) {
    AERROR << "Record is loaded,no need to load";
    return false;
  }
  // check if record player factory can continue load
  auto record_player_factory = RecordPlayerFactory::Instance();
  if (!record_player_factory->EnableContinueLoad()) {
    // can not load record,need to remove lru record
    std::string remove_record_id;
    if (record_player_factory->RemoveLRURecord(&remove_record_id)) {
      // remove successfully, change removed record status
      {
        WLock wlock(status_mutex_);
        auto status_records = status_.mutable_records();
        (*status_records)[remove_record_id].set_load_record_status(
            LoadRecordStatus::NOT_LOAD);
        (*status_records)[remove_record_id].clear_total_time_s();
      }
    }
  }
  if (!ReadRecordInfo(record_file_path, total_time_s)) {
    return false;
  }
  if (!record_player_factory->RegisterRecordPlayer(record_name,
                                                   record_file_path)) {
    return false;
  }
  return true;
}

LoadRecordAndChangeStatus()

bool apollo::dreamview::HMIWorker::LoadRecordAndChangeStatus

(

const std::string &

record_name

)

在文件 hmi_worker.cc 第 1369 行定义.

                                                                      {
    std::string record_file_path;
    {
      RLock rlock(status_mutex_);
      auto &status_records = status_.records();
      auto iter = status_records.find(record_name);
      if (iter == status_records.end()) {
        AERROR << "Cannot load unknown record!";
        return false;
      }
      if (RecordIsLoaded(record_name)) {
        AERROR << "Cannot load already loaded record.";
        return false;
      }
      if (iter->second.record_file_path().empty()) {
        AERROR << "Cannot load record without record file path!";
        return false;
      }
      record_file_path = iter->second.record_file_path();
    }
    {
      WLock wlock(status_mutex_);
      auto status_records = status_.mutable_records();
      (*status_records)[record_name].set_load_record_status(
          LoadRecordStatus::LOADING);
    }
    double total_time_s;
    if (LoadRecord(record_name, record_file_path, &total_time_s)) {
      {
        WLock wlock(status_mutex_);
        auto status_records = status_.mutable_records();
        (*status_records)[record_name].set_load_record_status(
            LoadRecordStatus::LOADED);
        (*status_records)[record_name].set_total_time_s(total_time_s);
      }
      RecordPlayerFactory::Instance()->IncreaseRecordPriority(record_name);
    } else {
      {
        WLock wlock(status_mutex_);
        auto status_records = status_.mutable_records();
        (*status_records)[record_name].set_load_record_status(
            LoadRecordStatus::NOT_LOAD);
      }
    }
    return true;
}

LoadRecords() [1/2]

bool apollo::dreamview::HMIWorker::LoadRecords

(

)

在文件 hmi_worker.cc 第 1367 行定义.

                            {
  std::string directory_path;
  GetRecordPath(&directory_path);
  if (!cyber::common::PathExists(directory_path)) {
    AERROR << "Failed to find records!";
    return false;
  }
  DIR *directory = opendir(directory_path.c_str());
  if (directory == nullptr) {
    AERROR << "Cannot open record directory" << directory_path;
    return false;
  }
  struct dirent *file;
  std::map<std::string, LoadRecordInfo> new_records;
  while ((file = readdir(directory)) != nullptr) {
    if (!strcmp(file->d_name, ".") || !strcmp(file->d_name, "..")) {
      continue;
    }
    if (file->d_type == DT_DIR) {
      continue;
    }
    const std::string record_id = file->d_name;
    const int index = record_id.rfind(".record");
    // Skip format that dv cannot parse: record not ending in record
    size_t record_suffix_length = 7;
    if (record_id.length() - index != record_suffix_length) {
        continue;
    }
    if (index != -1 && record_id[0] != '.') {
      const std::string local_record_resource = record_id.substr(0, index);
      // compatible records with dv and dv_plus
      new_records[local_record_resource] = {};
      new_records[local_record_resource].set_download_status(1);
    }
  }
  closedir(directory);
  {
    WLock wlock(status_mutex_);
    auto status_records = status_.mutable_records();
    status_records->clear();
    for (auto iter = new_records.begin(); iter != new_records.end(); iter++) {
      (*status_records)[iter->first] = iter->second;
    }
    status_changed_ = true;
  }
  return true;
}

LoadRecords() [2/2]

bool apollo::dreamview::HMIWorker::LoadRecords

(

)

LoadRtkRecords()

bool apollo::dreamview::HMIWorker::LoadRtkRecords

(

)

在文件 hmi_worker.cc 第 1914 行定义.

                               {
  {
    WLock wLock(status_mutex_);
    status_.clear_rtk_records();
  }
  std::string directory_path;
  GetRtkRecordPath(&directory_path);
  if (!cyber::common::PathExists(directory_path)) {
    AERROR << "Failed to find rtk records!";
    return false;
  }
  DIR *directory = opendir(directory_path.c_str());
  if (directory == nullptr) {
    AERROR << "Cannot open rtk record directory" << directory_path;
    return false;
  }
  struct dirent *file;
  std::map<std::string, double> new_records;
  while ((file = readdir(directory)) != nullptr) {
    if (!strcmp(file->d_name, ".") || !strcmp(file->d_name, "..")) {
      continue;
    }
    if (file->d_type == DT_DIR) {
      continue;
    }
    const std::string record_id = file->d_name;
    const int index = record_id.rfind(".csv");
    if (index != -1 && record_id[0] != '.') {
      const std::string local_record_resource = record_id.substr(0, index);
      {
        WLock wLock(status_mutex_);
        status_.add_rtk_records(local_record_resource);
      }
    }
  }
  closedir(directory);
  {
    WLock wlock(status_mutex_);
    status_changed_ = true;
  }
  return true;
}

RecordIsLoaded()

bool apollo::dreamview::HMIWorker::RecordIsLoaded

(

const std::string &

record_id

)

在文件 hmi_worker.cc 第 1206 行定义.

                                                         {
  {
    RLock rlock(status_mutex_);
    auto iter = status_.records().find(record_id);
    return iter != status_.records().end() &&
           (iter->second.load_record_status() == LoadRecordStatus::LOADED);
  }
}

RegisterStatusUpdateHandler() [1/2]

void apollo::dreamview::HMIWorker::RegisterStatusUpdateHandler ( StatusUpdateHandler  handler )

inline

在文件 hmi_worker.h 第 74 行定义.

                                                                       {
    status_update_handlers_.push_back(handler);
  }

RegisterStatusUpdateHandler() [2/2]

void apollo::dreamview::HMIWorker::RegisterStatusUpdateHandler ( StatusUpdateHandler  handler )

inline

在文件 hmi_worker.h 第 78 行定义.

                                                                       {
    status_update_handlers_.push_back(handler);
  }

ReloadVehicles() [1/2]

bool apollo::dreamview::HMIWorker::ReloadVehicles

(

)

在文件 hmi_worker.cc 第 1451 行定义.

                               {
  AINFO << "load config";
  HMIConfig config = util::HMIUtil::LoadConfig(FLAGS_dv_hmi_modes_config_path);
  std::string msg;
  AINFO << "serialize new config";
  config.SerializeToString(&msg);
 
  WLock wlock(status_mutex_);
  AINFO << "parse new config";
  config_.ParseFromString(msg);
  AINFO << "init status";
  // status_.clear_modes();
  // status_.clear_maps();
  AINFO << "clear vehicles";
  status_.clear_vehicles();
  // InitStatus();
  // Populate vehicles and current_vehicle.
  AINFO << "reload vehicles";
  for (const auto &vehicle : config_.vehicles()) {
    status_.add_vehicles(vehicle.first);
  }
  status_changed_ = true;
  return true;
}

ReloadVehicles() [2/2]

bool apollo::dreamview::HMIWorker::ReloadVehicles

(

)

RePlayRecord()

bool apollo::dreamview::HMIWorker::RePlayRecord

(

)

在文件 hmi_worker.cc 第 1069 行定义.

                             {
  std::string record_id;
  {
    RLock rlock(status_mutex_);
    auto record_status = status_.current_record_status();
    record_id = record_status.current_record_id();
    if (record_status.current_record_id().empty()) {
      AERROR << "Failed to play record for record has not been selected!";
      return false;
    }
    if (!RecordIsLoaded(record_id)) {
      AERROR << "Failed to play record for record has not been loaded!";
      return false;
    }
    if (record_status.play_record_status() == PlayRecordStatus::RUNNING) {
      AERROR << "Record has been played,ignore dumplicate request.";
      return false;
    }
  }
  std::string record_path;
  GetRecordPath(&record_path);
  record_path = record_path + record_id + ".record";
 
  if (!cyber::common::PathExists(record_path)) {
    AERROR << "Failed to find record!";
    return false;
  }
  // play the record
  auto *record_player_factory = RecordPlayerFactory::Instance();
  auto player_ptr = record_player_factory->GetRecordPlayer(record_id);
  bool play_record_res = (player_ptr != nullptr);
  PlayRecordStatus play_record_status;
  if (!play_record_res) {
    AERROR << "Failed to get record related player";
    play_record_status = PlayRecordStatus::CLOSED;
  } else {
    player_ptr->PreloadPlayRecord();
    player_ptr->NohupPlayRecord();
    // get channel msgs for frontend after start play record
    callback_api_("GetDataHandlerConf", {});
    play_record_status = PlayRecordStatus::RUNNING;
  }
  {
    WLock wlock(status_mutex_);
    auto record_status = status_.mutable_current_record_status();
    record_status->set_play_record_status(play_record_status);
    status_changed_ = true;
  }
  record_player_factory->IncreaseRecordPriority(record_id);
  return play_record_res;
}

ResetRecordProgress()

bool apollo::dreamview::HMIWorker::ResetRecordProgress

(

const double &

progress

)

reset the play record progress to jump.

参数

progress

The progress to jump.

返回

If the action executed successfully.

在文件 hmi_worker.cc 第 1121 行定义.

                                                          {
  std::string record_id;
  double total_time_s;
  PlayRecordStatus last_record_status;
  {
    RLock rlock(status_mutex_);
    auto record_status = status_.current_record_status();
    record_id = record_status.current_record_id();
    last_record_status = record_status.play_record_status();
    if (record_status.current_record_id().empty()) {
      AERROR << "Failed to reset record progress for record has not been "
                "selected!";
      return false;
    }
    if (!RecordIsLoaded(record_id)) {
      AERROR << "Failed to reset record progress for record has not been "
                "loaded!";
      return false;
    }
    total_time_s = status_.records().at(record_id).total_time_s();
  }
  AERROR << "total :  " << total_time_s;
  if (progress > total_time_s) {
    AERROR << "Failed to reset record progress for progress exceeds the "
              "record's total time.";
    return false;
  }
  auto *record_player_factory = RecordPlayerFactory::Instance();
  auto player_ptr = record_player_factory->GetRecordPlayer(record_id);
  if (!player_ptr) {
    AERROR << "Failed to get record player.";
    return false;
  }
  player_ptr->Reset();
  player_ptr->PreloadPlayRecord(
      progress, (last_record_status != PlayRecordStatus::RUNNING));
  player_ptr->NohupPlayRecord();
  // When a record is selected and the progress is reset; we consider
  // the record to be stuck at the current progress in a paused state
  // to keep logic consistent
  if (last_record_status == PlayRecordStatus::CLOSED) {
    last_record_status = PlayRecordStatus::PAUSED;
  }
  // get channel msgs for frontend after start play record
  callback_api_("GetDataHandlerConf", {});
  {
    WLock wlock(status_mutex_);
    auto record_status = status_.mutable_current_record_status();
    record_status->set_play_record_status(last_record_status);
    record_status->set_curr_time_s(progress);
    status_changed_ = true;
  }
  record_player_factory->IncreaseRecordPriority(record_id);
  return true;
}

SaveDataRecorder()

int apollo::dreamview::HMIWorker::SaveDataRecorder

(

const std::string &

new_name

)

在文件 hmi_worker.cc 第 1767 行定义.

                                                         {
  std::string data_record_default_path =
      std::string(cyber::common::GetEnv("HOME", "/home/apollo")) +
      "/.apollo/resources/records/" + FLAGS_data_record_default_name;
  if (!cyber::common::PathExists(data_record_default_path)) {
    AERROR << "Failed to save the record, the dreamview recording record does "
              "not exist, please record through dreamview.";
    return -2;
  }
  std::string save_cmd = "/apollo/scripts/record_bag.py --default_name " +
                         FLAGS_data_record_default_name + " --rename " +
                         new_name;
  int ret = std::system(save_cmd.data());
  if (ret == 0) {
    LoadRecords();
    return 1;
  } else {
    AERROR << "Failed to save the record, a file with the same name exists";
    return -1;
  }
}

SaveRtkDataRecorder()

int apollo::dreamview::HMIWorker::SaveRtkDataRecorder

(

const std::string &

new_name

)

在文件 hmi_worker.cc 第 2017 行定义.

                                                            {
  std::string new_rtk_record_file =
      FLAGS_default_rtk_record_path + new_name + ".csv";
  if (cyber::common::PathExists(new_rtk_record_file)) {
    AERROR << "Failed to save the ret record, a file with the same name exists";
    return -1;
  }
  if (std::rename(FLAGS_default_rtk_record_file.data(),
                  new_rtk_record_file.data()) == 0) {
    UpdateRtkRecordToStatus(new_name);
    return 1;
  } else {
    AERROR << "Failed to save the ret record, save command execution failed";
    return -3;
  }
}

SensorCalibrationPreprocess() [1/2]

void apollo::dreamview::HMIWorker::SensorCalibrationPreprocess

(

const std::string &

task_type

)

在文件 hmi_worker.cc 第 420 行定义.

                                                                      {
  std::string start_command = absl::StrCat(
      "nohup bash /apollo/modules/tools/sensor_calibration/extract_data.sh -t ",
      task_type, " &");
  System(start_command);
}

SensorCalibrationPreprocess() [2/2]

void apollo::dreamview::HMIWorker::SensorCalibrationPreprocess

(

const std::string &

task_type

)

Start() [1/2]

void apollo::dreamview::HMIWorker::Start

(

DvCallback

callback_api

)

在文件 hmi_worker.cc 第 100 行定义.

                                             {
  callback_api_ = callback_api;
  InitReadersAndWriters();
  RegisterStatusUpdateHandler(
      [this](const bool status_changed, HMIStatus *status) {
        apollo::common::util::FillHeader("HMI", status);
        status_writer_->Write(*status);
        status->clear_header();
      });
  ResetComponentStatusTimer();
  thread_future_ = cyber::Async(&HMIWorker::StatusUpdateThreadLoop, this);
}

Start() [2/2]

void apollo::dreamview::HMIWorker::Start

(

DvCallback

callback_api

)

StartDataRecorder()

bool apollo::dreamview::HMIWorker::StartDataRecorder

(

)

在文件 hmi_worker.cc 第 1731 行定义.

                                  {
  std::string start_cmd =
      "/apollo/scripts/record_bag.py --start --all --dreamview "
      "--default_name " +
      FLAGS_data_record_default_name;
  int ret = std::system(start_cmd.data());
  if (ret == 0) {
    auto *monitors = FuelMonitorManager::Instance()->GetCurrentMonitors();
    if (monitors != nullptr) {
      auto iter = monitors->find(FLAGS_data_collection_monitor_name);
      if (iter != monitors->end()) {
        auto *data_collection_monitor = iter->second.get();
        if (data_collection_monitor->IsEnabled() && record_count_ == 0) {
          data_collection_monitor->Restart();
        }
      }
      ++record_count_;
    }
    return true;
  } else {
    AERROR << "Failed to start the cyber_recorder process";
    return false;
  }
}

StartPlayRtkRecorder()

Json apollo::dreamview::HMIWorker::StartPlayRtkRecorder

(

)

在文件 hmi_worker.cc 第 1979 行定义.

                                     {
  Json result;
  if (!ChangeDrivingMode(Chassis::COMPLETE_AUTO_DRIVE)) {
    AERROR << "Failed to play rtk: Failed to enter auto drive.";
    result["error"] = "Failed to enter auto drive";
    result["isOk"] = false;
    return result;
  }
  std::string record_id;
  {
    RLock rlock(status_mutex_);
    record_id = status_.current_rtk_record_id();
  }
  std::string start_cmd =
      "nohup /apollo/scripts/rtk_player.sh start " + record_id + " &";
  int ret = std::system(start_cmd.data());
  if (ret == 0) {
    AINFO << "Start the rtk_recorder process Successful.";
    result["isOk"] = true;
  } else {
    AERROR << "Failed to play rtk: Failed to start the rtk_recorder process.";
    result["error"] = "Failed to start the rtk_recorder process";
    result["isOk"] = false;
  }
  return result;
}

StartRtkDataRecorder()

bool apollo::dreamview::HMIWorker::StartRtkDataRecorder

(

)

在文件 hmi_worker.cc 第 1957 行定义.

                                     {
  std::string start_cmd = "nohup /apollo/scripts/rtk_recorder.sh start &";
  int ret = std::system(start_cmd.data());
  if (ret == 0) {
    return true;
  } else {
    AERROR << "Failed to start the rtk_recorder process";
    return false;
  }
}

StartTerminal()

bool apollo::dreamview::HMIWorker::StartTerminal

(

)

在文件 hmi_worker.cc 第 1905 行定义.

                              {
  return std::system(FLAGS_terminal_start_cmd.data()) == 0;
}

Stop() [1/2]

void apollo::dreamview::HMIWorker::Stop

(

)

在文件 hmi_worker.cc 第 113 行定义.

                     {
  stop_ = true;
  if (thread_future_.valid()) {
    thread_future_.get();
  }
}

Stop() [2/2]

void apollo::dreamview::HMIWorker::Stop

(

)

StopDataRecorder()

bool apollo::dreamview::HMIWorker::StopDataRecorder

(

)

在文件 hmi_worker.cc 第 1756 行定义.

                                 {
  std::string stop_cmd = "/apollo/scripts/record_bag.py --stop";
  int ret = std::system(stop_cmd.data());
  if (ret == 0) {
    return true;
  } else {
    AERROR << "Failed to stop the cyber_recorder process";
    return false;
  }
}

StopPlayRtkRecorder()

bool apollo::dreamview::HMIWorker::StopPlayRtkRecorder

(

)

在文件 hmi_worker.cc 第 2006 行定义.

                                    {
  std::string stop_cmd = "/apollo/scripts/rtk_player.sh stop";
  int ret = std::system(stop_cmd.data());
  if (ret == 9) {
    return true;
  } else {
    AERROR << "Failed to stop the rtk_recorder process";
    return false;
  }
}

StopRtkDataRecorder()

bool apollo::dreamview::HMIWorker::StopRtkDataRecorder

(

)

在文件 hmi_worker.cc 第 1968 行定义.

                                    {
  std::string stop_cmd = "/apollo/scripts/rtk_recorder.sh stop";
  int ret = std::system(stop_cmd.data());
  if (ret == 9) {
    return true;
  } else {
    AERROR << "Failed to stop the rtk_recorder process";
    return false;
  }
}

SubmitAudioEvent() [1/2]

void apollo::dreamview::HMIWorker::SubmitAudioEvent	(	const uint64_t	event_time_ms,
		const int	obstacle_id,
		const int	audio_type,
		const int	moving_result,
		const int	audio_direction,
		const bool	is_siren_on
	)

在文件 hmi_worker.cc 第 359 行定义.

                                                         {
  std::shared_ptr<AudioEvent> audio_event = std::make_shared<AudioEvent>();
  apollo::common::util::FillHeader("HMI", audio_event.get());
  // Here we reuse the header time field as the event occurring time.
  // A better solution might be adding an event time field to DriveEvent proto
  // to make it clear.
  audio_event->mutable_header()->set_timestamp_sec(
      static_cast<double>(event_time_ms) / 1000.0);
  audio_event->set_id(obstacle_id);
  audio_event->set_audio_type(
      static_cast<apollo::audio::AudioType>(audio_type));
  audio_event->set_moving_result(
      static_cast<apollo::audio::MovingResult>(moving_result));
  audio_event->set_audio_direction(
      static_cast<apollo::audio::AudioDirection>(audio_direction));
  audio_event->set_siren_is_on(is_siren_on);
 
  // Read the current localization pose
  localization_reader_->Observe();
  if (localization_reader_->Empty()) {
    AERROR << "Failed to get localization associated with the audio event: "
           << audio_event->DebugString() << "\n Localization reader is empty!";
    return;
  }
 
  const std::shared_ptr<LocalizationEstimate> localization =
      localization_reader_->GetLatestObserved();
  audio_event->mutable_pose()->CopyFrom(localization->pose());
  AINFO << "AudioEvent: " << audio_event->DebugString();
 
  audio_event_writer_->Write(audio_event);
}

SubmitAudioEvent() [2/2]

void apollo::dreamview::HMIWorker::SubmitAudioEvent	(	const uint64_t	event_time_ms,
		const int	obstacle_id,
		const int	audio_type,
		const int	moving_result,
		const int	audio_direction,
		const bool	is_siren_on
	)

SubmitDriveEvent() [1/2]

void apollo::dreamview::HMIWorker::SubmitDriveEvent	(	const uint64_t	event_time_ms,
		const std::string &	event_msg,
		const std::vector< std::string > &	event_types,
		const bool	is_reportable
	)

在文件 hmi_worker.cc 第 396 行定义.

                                                           {
  std::shared_ptr<DriveEvent> drive_event = std::make_shared<DriveEvent>();
  apollo::common::util::FillHeader("HMI", drive_event.get());
  // TODO(xiaoxq): Here we reuse the header time field as the event occurring
  // time. A better solution might be adding the field to DriveEvent proto to
  // make it clear.
  drive_event->mutable_header()->set_timestamp_sec(
      static_cast<double>(event_time_ms) / 1000.0);
  drive_event->set_event(event_msg);
  drive_event->set_is_reportable(is_reportable);
  for (const auto &type_name : event_types) {
    DriveEvent::Type type;
    if (DriveEvent::Type_Parse(type_name, &type)) {
      drive_event->add_type(type);
    } else {
      AERROR << "Failed to parse drive event type:" << type_name;
    }
  }
  drive_event_writer_->Write(drive_event);
}

SubmitDriveEvent() [2/2]

void apollo::dreamview::HMIWorker::SubmitDriveEvent	(	const uint64_t	event_time_ms,
		const std::string &	event_msg,
		const std::vector< std::string > &	event_types,
		const bool	is_reportable
	)

Trigger() [1/4]

bool apollo::dreamview::HMIWorker::Trigger

(

const HMIAction

action

)

在文件 hmi_worker.cc 第 277 行定义.

                                              {
  AERROR << "HMIAction " << HMIAction_Name(action) << " was triggered!";
  switch (action) {
    case HMIAction::NONE:
      break;
    case HMIAction::SETUP_MODE:
      SetupMode();
      break;
    case HMIAction::ENTER_AUTO_MODE:
      return ChangeDrivingMode(Chassis::COMPLETE_AUTO_DRIVE);
    case HMIAction::DISENGAGE:
      return ChangeDrivingMode(Chassis::COMPLETE_MANUAL);
    case HMIAction::RESET_MODE:
      ResetMode();
      break;
    case HMIAction::LOAD_SCENARIOS:
      LoadScenarios();
      break;
    case HMIAction::LOAD_DYNAMIC_MODELS:
      LoadDynamicModels();
      break;
    case HMIAction::LOAD_RECORDS:
      LoadRecords();
      break;
    case HMIAction::STOP_RECORD:
      StopRecordPlay();
      break;
    default:
      AERROR << "HMIAction not implemented, yet!";
      return false;
  }
  return true;
}

Trigger() [2/4]

bool apollo::dreamview::HMIWorker::Trigger

(

const HMIAction

action

)

Trigger() [3/4]

bool apollo::dreamview::HMIWorker::Trigger	(	const HMIAction	action,
		const std::string &	value
	)

在文件 hmi_worker.cc 第 311 行定义.

                                                                      {
  AINFO << "HMIAction " << HMIAction_Name(action) << "(" << value
        << ") was triggered!";
  switch (action) {
    case HMIAction::CHANGE_MODE:
      ChangeMode(value);
      break;
    case HMIAction::CHANGE_MAP:
      ChangeMap(value);
      break;
    case HMIAction::CHANGE_VEHICLE:
      ChangeVehicle(value);
      break;
    case HMIAction::START_MODULE:
      StartModule(value);
      break;
    case HMIAction::STOP_MODULE:
      StopModule(value);
      break;
    case HMIAction::CHANGE_SCENARIO_SET:
      ChangeScenarioSet(value);
      break;
    case HMIAction::DELETE_SCENARIO_SET:
      DeleteScenarioSet(value);
      ChangeScenario("");
      break;
    case HMIAction::CHANGE_SCENARIO:
      ChangeScenario(value);
      break;
    case HMIAction::CHANGE_DYNAMIC_MODEL:
      ChangeDynamicModel(value);
      break;
    case HMIAction::DELETE_DYNAMIC_MODEL:
      DeleteDynamicModel(value);
      break;
    case HMIAction::DELETE_RECORD:
      DeleteRecord(value);
      break;
    case HMIAction::CHANGE_RECORD:
      ChangeRecord(value);
      break;
    default:
      AERROR << "HMIAction not implemented, yet!";
      return false;
  }
  return true;
}

Trigger() [4/4]

bool apollo::dreamview::HMIWorker::Trigger	(	const HMIAction	action,
		const std::string &	value
	)

UpdateCameraSensorChannelToStatus() [1/2]

void apollo::dreamview::HMIWorker::UpdateCameraSensorChannelToStatus

(

const std::string &

channel_name

)

在文件 hmi_worker.cc 第 1476 行定义.

                                   {
  {
    WLock wlock(status_mutex_);
    if (status_.current_camera_sensor_channel() == channel_name) {
      AINFO << "Input channel name is current camera sensor channel";
      return;
    }
    status_.set_current_camera_sensor_channel(channel_name);
    status_changed_ = true;
  }
}

UpdateCameraSensorChannelToStatus() [2/2]

void apollo::dreamview::HMIWorker::UpdateCameraSensorChannelToStatus

(

const std::string &

channel_name

)

UpdateComponentStatus() [1/2]

void apollo::dreamview::HMIWorker::UpdateComponentStatus

(

)

在文件 hmi_worker.cc 第 733 行定义.

                                      {
  constexpr double kSecondsTillTimeout(2.5);
  const double now = Clock::NowInSeconds();
  if (now - last_status_received_s_.load() > kSecondsTillTimeout) {
    if (!monitor_timed_out_) {
      WLock wlock(status_mutex_);
 
      const uint64_t now_ms = static_cast<uint64_t>(now * 2e3);
      static constexpr bool kIsReportable = true;
      SubmitDriveEvent(now_ms, "Monitor timed out", {"PROBLEM"}, kIsReportable);
      AWARN << "System fault. Auto disengage.";
      Trigger(HMIAction::DISENGAGE);
 
      for (auto &monitored_component :
           *status_.mutable_monitored_components()) {
        monitored_component.second.set_status(ComponentStatus::UNKNOWN);
        monitored_component.second.set_message(
            "Status not reported by Monitor.");
      }
      status_changed_ = true;
    }
    monitor_timed_out_ = true;
  } else {
    monitor_timed_out_ = false;
  }
}

UpdateComponentStatus() [2/2]

void apollo::dreamview::HMIWorker::UpdateComponentStatus

(

)

UpdateDynamicModelToStatus() [1/2]

bool apollo::dreamview::HMIWorker::UpdateDynamicModelToStatus

(

const std::string &

dynamic_model_name

)

在文件 hmi_worker.cc 第 1031 行定义.

                                         {
  Json param_json({});
  param_json["dynamic_model_name"] = dynamic_model_name;
  Json callback_res = callback_api_("AddDynamicModel", param_json);
  if (!callback_res.contains("result") || !callback_res["result"]) {
    AERROR << "Failed to add dynamic model to local dynamic model list for "
              "register failed!";
    return false;
  }
  {
    WLock wlock(status_mutex_);
    for (const auto &iter : status_.dynamic_models()) {
      if (iter == dynamic_model_name) {
        AERROR << "Do not need to add new dynamic model for is duplicate!";
        return true;
      }
    }
    status_.add_dynamic_models(dynamic_model_name);
    status_changed_ = true;
  }
  return true;
}

UpdateDynamicModelToStatus() [2/2]

bool apollo::dreamview::HMIWorker::UpdateDynamicModelToStatus

(

const std::string &

dynamic_model_name

)

UpdateMapToStatus()

bool apollo::dreamview::HMIWorker::UpdateMapToStatus

(

const std::string &

map_name

)

在文件 hmi_worker.cc 第 1332 行定义.

                                                               {
  if (map_tar_name.empty()) {
    ReloadMaps();
    return true;
  }
  std::string map_dir = FLAGS_maps_data_path + "/";
  std::string map_name_prefix;
  int index = map_tar_name.rfind(".tar.xz");
  if (index != -1 && map_tar_name[0] != '.') {
    map_name_prefix = map_tar_name.substr(0, index);
    map_dir = map_dir + map_name_prefix;
  } else {
    AERROR << "The map name does not meet the standard!" << map_tar_name;
    return false;
  }
  if (!cyber::common::PathExists(map_dir)) {
    AERROR << "Failed to find maps!";
    return false;
  }
  map_name_prefix = util::HMIUtil::TitleCase(map_name_prefix);
  {
    WLock wlock(status_mutex_);
    auto iter = status_.maps().begin();
    for (; iter != status_.maps().end(); iter++) {
      if (*iter == map_name_prefix) {
        break;
      }
    }
    if (iter != status_.maps().end()) {
      return true;
    }
    status_.add_maps(map_name_prefix);
    status_changed_ = true;
  }
  return true;
}

UpdatePointCloudChannelToStatus() [1/2]

void apollo::dreamview::HMIWorker::UpdatePointCloudChannelToStatus

(

const std::string &

channel_name

)

在文件 hmi_worker.cc 第 1489 行定义.

                                   {
  {
    WLock wlock(status_mutex_);
    if (status_.current_point_cloud_channel() == channel_name) {
      AINFO << "Input channel name is current camera sensor channel";
      return;
    }
    status_.set_current_point_cloud_channel(channel_name);
    status_changed_ = true;
  }
}

UpdatePointCloudChannelToStatus() [2/2]

void apollo::dreamview::HMIWorker::UpdatePointCloudChannelToStatus

(

const std::string &

channel_name

)

UpdateRtkRecordToStatus()

void apollo::dreamview::HMIWorker::UpdateRtkRecordToStatus

(

const std::string &

new_name

)

在文件 hmi_worker.cc 第 2067 行定义.

                                                                 {
  WLock wlock(status_mutex_);
  status_.add_rtk_records(new_name);
  status_changed_ = true;
}

UpdateScenarioSet()

bool apollo::dreamview::HMIWorker::UpdateScenarioSet	(	const std::string &	scenario_set_id,
		const std::string &	scenario_set_name,
		ScenarioSet *	new_scenario_set
	)

在文件 hmi_worker.cc 第 1055 行定义.

                                                                 {
  std::string scenario_set_directory_path;
  GetScenarioSetPath(scenario_set_id, &scenario_set_directory_path);
  scenario_set_directory_path = scenario_set_directory_path + "/scenarios/";
  new_scenario_set->set_scenario_set_name(scenario_set_name);
  if (!cyber::common::PathExists(scenario_set_directory_path)) {
    AERROR << "Scenario set has no scenarios!";
    return true;
  }
  DIR *directory = opendir(scenario_set_directory_path.c_str());
  if (directory == nullptr) {
    AERROR << "Cannot open directory " << scenario_set_directory_path;
    return false;
  }
 
  struct dirent *file;
  while ((file = readdir(directory)) != nullptr) {
    // skip directory_path/. and directory_path/..
    if (!strcmp(file->d_name, ".") || !strcmp(file->d_name, "..")) {
      continue;
    }
    const std::string file_name = file->d_name;
    if (!absl::EndsWith(file_name, ".json")) {
      continue;
    }
    const int index = file_name.rfind(".json");
    if (index == 0) {
      // name: ".json" is invalid.
      continue;
    }
    const std::string scenario_id = file_name.substr(0, index);
    const std::string file_path = scenario_set_directory_path + file_name;
    SimTicket new_sim_ticket;
    if (!cyber::common::GetProtoFromJsonFile(file_path, &new_sim_ticket)) {
      AERROR << "Cannot parse this scenario:" << file_path;
      return false;
    }
    if (!new_sim_ticket.has_scenario()) {
      AERROR << "Cannot get scenario.";
      return false;
    }
    if (!new_sim_ticket.description_en_tokens_size()) {
      AERROR << "Cannot get scenario name.";
      return false;
    }
    if (!new_sim_ticket.scenario().has_map_dir()) {
      AERROR << "Cannot get scenario map dir.";
      return false;
    }
    if (!new_sim_ticket.scenario().has_start()) {
      AERROR << "Cannot get scenario start_point.";
      return false;
    }
    auto &scenario_start_point = new_sim_ticket.scenario().start();
    if (!scenario_start_point.has_x() || !scenario_start_point.has_y()) {
      AERROR << "Scenario start_point is invalid!";
      return false;
    }
    std::string scenario_name = new_sim_ticket.description_en_tokens(0);
    for (int i = 1; i < new_sim_ticket.description_en_tokens_size(); i++) {
      scenario_name =
          scenario_name + "_" + new_sim_ticket.description_en_tokens(i);
    }
    ScenarioInfo *scenario_info = new_scenario_set->add_scenarios();
    scenario_info->set_scenario_id(scenario_id);
    scenario_info->set_scenario_name(scenario_name);
    // change scenario json map dir to map name
    // format:modules/map/data/${map_name}
    const std::string map_dir = new_sim_ticket.scenario().map_dir();
    size_t idx = map_dir.find_last_of('/');
    if (idx == map_dir.npos) {
      AERROR << "Cannot get scenario map name.";
      return false;
    }
    const std::string map_name = map_dir.substr(idx + 1);
    if (map_name.empty()) {
      AERROR << "Cannot get scenario map name.";
      return false;
    }
    // replay engine use xx_xx like:apollo_map
    // dv need Apollo Map
    scenario_info->set_map_name(util::HMIUtil::TitleCase(map_name));
    auto start_point = scenario_info->mutable_start_point();
    start_point->set_x(scenario_start_point.x());
    start_point->set_y(scenario_start_point.y());
  }
  closedir(directory);
  return true;
}

UpdateScenarioSetToStatus()

bool apollo::dreamview::HMIWorker::UpdateScenarioSetToStatus	(	const std::string &	scenario_set_id,
		const std::string &	scenario_set_name
	)

在文件 hmi_worker.cc 第 1013 行定义.

                                                                          {
  ScenarioSet new_scenario_set;
  if (!UpdateScenarioSet(scenario_set_id, scenario_set_name,
                         &new_scenario_set)) {
    AERROR << "Failed to update scenario_set!";
    return false;
  }
  {
    WLock wlock(status_mutex_);
    auto scenario_set = status_.mutable_scenario_set();
    scenario_set->erase(scenario_set_id);
    (*scenario_set)[scenario_set_id] = new_scenario_set;
    status_changed_ = true;
  }
  return true;
}

VehicleCalibrationPreprocess() [1/2]

void apollo::dreamview::HMIWorker::VehicleCalibrationPreprocess

(

)

在文件 hmi_worker.cc 第 427 行定义.

                                             {
  std::string start_command = absl::StrCat(
      "nohup bash /apollo/modules/tools/vehicle_calibration/preprocess.sh "
      "--vehicle_type=\"",
      status_.current_vehicle(), "\" --record_num=", record_count_, " &");
  System(start_command);
}

VehicleCalibrationPreprocess() [2/2]

void apollo::dreamview::HMIWorker::VehicleCalibrationPreprocess

(

)

---

该类的文档由以下文件生成:

• modules/dreamview/backend/hmi/hmi_worker.h
• modules/dreamview_plus/backend/hmi/hmi_worker.h
• modules/dreamview/backend/hmi/hmi_worker.cc
• modules/dreamview_plus/backend/hmi/hmi_worker.cc