simulation_world_updater.h

浏览该文件的文档.

/******************************************************************************
 * Copyright 2017 The Apollo Authors. All Rights Reserved.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 * http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 *****************************************************************************/
 
#pragma once
 
#include <memory>
#include <string>
#include <vector>
 
#include <boost/thread/locks.hpp>
#include <boost/thread/shared_mutex.hpp>
 
#include "absl/strings/str_cat.h"
 
#include "modules/common_msgs/task_manager_msgs/task_manager.pb.h"
#include "modules/common_msgs/external_command_msgs/lane_follow_command.pb.h"
#include "modules/common_msgs/external_command_msgs/valet_parking_command.pb.h"
#include "modules/common_msgs/external_command_msgs/action_command.pb.h"
#include "modules/dreamview_plus/proto/data_handler.pb.h"
 
#include "cyber/common/log.h"
#include "cyber/cyber.h"
#include "modules/dreamview/backend/common/handlers/websocket_handler.h"
#include "modules/dreamview_plus/backend/hmi/hmi.h"
#include "modules/dreamview/backend/common/map_service/map_service.h"
#include "modules/dreamview/backend/common/plugins/plugin_manager.h"
#include "modules/common_msgs/localization_msgs/localization.pb.h"
#include "modules/dreamview_plus/backend/simulation_world/simulation_world_service.h"
#include "modules/dreamview_plus/backend/socket_manager/socket_manager.h"
#include "modules/dreamview_plus/backend/updater/updater_base.h"
namespace apollo {
namespace dreamview {
 
class SimulationWorldUpdater : public UpdaterBase {
 public:
  SimulationWorldUpdater(WebSocketHandler *websocket, WebSocketHandler *map_ws,
                         WebSocketHandler *plugin_ws,
                         const MapService *map_service,
                         PluginManager *plugin_manager,
                         WebSocketHandler *sim_world_ws, HMI *hmi,
                         bool routing_from_file = false);
 
  void StartStream(const double &time_interval_ms,
                   const std::string &channel_name = "",
                   nlohmann::json *subscribe_param = nullptr) override;
  void StopStream(const std::string &channel_name = "") override;
  void PublishMessage(const std::string &channel_name = "") override;
  // Time interval, in milliseconds, between pushing SimulationWorld to
  // frontend.
  double time_interval_ms_;
 
  double LastAdcTimestampSec() { return last_pushed_adc_timestamp_sec_; }
 
 private:
  void OnTimer(const std::string &channel_name = "");
 
  bool ConstructLaneFollowCommand(
      const nlohmann::json &json,
      apollo::external_command::LaneFollowCommand *lane_follow_command);
 
  bool ConstructValetParkingCommand(
      const nlohmann::json &json,
      apollo::external_command::ValetParkingCommand *valet_parking_command,
      const std::string &parking_space_id);
 
  nlohmann::json GetConstructRoutingRequestJson(const nlohmann::json &start,
                                                const nlohmann::json &end);
 
  bool ConstructLaneWayPoint(const nlohmann::json &point,
                             apollo::routing::LaneWaypoint *laneWayPoint,
                             std::string description);
 
  bool ValidateCoordinate(const nlohmann::json &json);
 
  bool CheckRoutingPoint(const nlohmann::json &json, nlohmann::json &result);
 
  bool LoadPOI();
  nlohmann::json GetPointJsonFromLaneWaypoint(
      const apollo::routing::LaneWaypoint &waypoint);
 
  bool LoadUserDefinedRoutings(const std::string &file_name,
                               google::protobuf::Message *message);
 
  bool AddDefaultRouting(const nlohmann::json &json);
 
  bool DeleteDefaultRouting(const std::string &routing_name);
 
  //   /**
  //    * @brief Modify the number of cycles for the default route
  //    * @param routing_name routing name
  //    * @param cycle_number The number of cycles you want to modify
  //    * @return False if failed to delete,
  //    * true otherwise.
  //    */
  //   bool ModifyCycleNumber(const std::string &routing_name,
  //                          const int &cycle_number);
 
  void RegisterMessageHandlers();
  void RegisterRoutingMessageHandlers();
 
  SimulationWorldService sim_world_service_;
  const MapService *map_service_ = nullptr;
  WebSocketHandler *websocket_ = nullptr;
  WebSocketHandler *map_ws_ = nullptr;
  WebSocketHandler *plugin_ws_ = nullptr;
  std::unique_ptr<PluginManager> plugin_manager_ = nullptr;
  WebSocketHandler *sim_world_ws_ = nullptr;
  HMI *hmi_ = nullptr;
 
  // End point for requesting default route
  apollo::routing::POI poi_;
 
  // default routings
  apollo::routing::POI default_routings_;
  apollo::routing::Landmark *default_routing_;
 
  // park and go
  apollo::routing::POI park_go_routings_;
 
  // The simulation_world in wire format to be pushed to frontend, which is
  // updated by timer.
  std::string simulation_world_with_planning_data_;
 
  // Received relative map data in wire format.
  std::string relative_map_string_;
 
  // Mutex to protect concurrent access to simulation_world_json_.
  // NOTE: Use boost until we have std version of rwlock support.
  boost::shared_mutex mutex_;
 
  std::unique_ptr<cyber::Timer> timer_;
 
  volatile double last_pushed_adc_timestamp_sec_ = 0.0f;
 
  // std::unique_ptr<PluginManager> plugin_manager_;
 
  uint64_t command_id_;
};
 
}  // namespace dreamview
}  // namespace apollo