Add video streaming capability in system capability

1 files changed, 98 insertions, 0 deletions

diff --git a/src/components/application_manager/src/hmi_capabilities_impl.cc b/src/components/application_manager/src/hmi_capabilities_impl.cc
index 12a64165e8..99a77d5ba7 100644
--- a/src/components/application_manager/src/hmi_capabilities_impl.cc
+++ b/src/components/application_manager/src/hmi_capabilities_impl.cc
@@ -68,6 +68,10 @@ std::map<std::string, hmi_apis::Common_ImageFieldName::eType>
 std::map<std::string, hmi_apis::Common_FileType::eType> file_type_enum;
 std::map<std::string, hmi_apis::Common_DisplayType::eType> display_type_enum;
 std::map<std::string, hmi_apis::Common_CharacterSet::eType> character_set_enum;
+std::map<std::string, hmi_apis::Common_VideoStreamingProtocol::eType>
+    video_streaming_protocol_enum;
+std::map<std::string, hmi_apis::Common_VideoStreamingCodec::eType>
+    video_streaming_codec_enum;
 
 void InitCapabilities() {
   vr_enum_capabilities.insert(std::make_pair(
@@ -333,6 +337,28 @@ void InitCapabilities() {
       std::string("CID1SET"), hmi_apis::Common_CharacterSet::CID1SET));
   character_set_enum.insert(std::make_pair(
       std::string("CID2SET"), hmi_apis::Common_CharacterSet::CID2SET));
+
+  video_streaming_protocol_enum.insert(std::make_pair(
+      std::string("RAW"), hmi_apis::Common_VideoStreamingProtocol::RAW));
+  video_streaming_protocol_enum.insert(std::make_pair(
+      std::string("RTP"), hmi_apis::Common_VideoStreamingProtocol::RTP));
+  video_streaming_protocol_enum.insert(std::make_pair(
+      std::string("RTSP"), hmi_apis::Common_VideoStreamingProtocol::RTSP));
+  video_streaming_protocol_enum.insert(std::make_pair(
+      std::string("RTMP"), hmi_apis::Common_VideoStreamingProtocol::RTMP));
+  video_streaming_protocol_enum.insert(std::make_pair(
+      std::string("WEBM"), hmi_apis::Common_VideoStreamingProtocol::WEBM));
+
+  video_streaming_codec_enum.insert(std::make_pair(
+      std::string("H264"), hmi_apis::Common_VideoStreamingCodec::H264));
+  video_streaming_codec_enum.insert(std::make_pair(
+      std::string("H265"), hmi_apis::Common_VideoStreamingCodec::H265));
+  video_streaming_codec_enum.insert(std::make_pair(
+      std::string("Theora"), hmi_apis::Common_VideoStreamingCodec::Theora));
+  video_streaming_codec_enum.insert(std::make_pair(
+      std::string("VP8"), hmi_apis::Common_VideoStreamingCodec::VP8));
+  video_streaming_codec_enum.insert(std::make_pair(
+      std::string("VP9"), hmi_apis::Common_VideoStreamingCodec::VP9));
 }
 
 }  // namespace
@@ -363,8 +389,10 @@ HMICapabilitiesImpl::HMICapabilitiesImpl(ApplicationManager& app_mngr)
     , prerecorded_speech_(NULL)
     , is_navigation_supported_(false)
     , is_phone_call_supported_(false)
+    , is_video_streaming_supported_(false)
     , navigation_capability_(NULL)
     , phone_capability_(NULL)
+    , video_streaming_capability_(NULL)
     , app_mngr_(app_mngr)
     , hmi_language_handler_(app_mngr) {
   InitCapabilities();
@@ -394,6 +422,7 @@ HMICapabilitiesImpl::~HMICapabilitiesImpl() {
   delete prerecorded_speech_;
   delete navigation_capability_;
   delete phone_capability_;
+  delete video_streaming_capability_;
 }
 
 bool HMICapabilitiesImpl::VerifyImageType(const int32_t image_type) const {
@@ -609,6 +638,10 @@ void HMICapabilitiesImpl::set_phone_call_supported(const bool supported) {
   is_phone_call_supported_ = supported;
 }
 
+void HMICapabilitiesImpl::set_video_streaming_supported(const bool supported) {
+  is_video_streaming_supported_ = supported;
+}
+
 void HMICapabilitiesImpl::set_navigation_capability(
     const smart_objects::SmartObject& navigation_capability) {
   if (navigation_capability_) {
@@ -626,6 +659,15 @@ void HMICapabilitiesImpl::set_phone_capability(
   phone_capability_ = new smart_objects::SmartObject(phone_capability);
 }
 
+void HMICapabilitiesImpl::set_video_streaming_capability(
+    const smart_objects::SmartObject& video_streaming_capability) {
+  if (video_streaming_capability_) {
+    delete video_streaming_capability_;
+  }
+  video_streaming_capability_ =
+      new smart_objects::SmartObject(video_streaming_capability);
+}
+
 void HMICapabilitiesImpl::Init(resumption::LastState* last_state) {
   hmi_language_handler_.Init(last_state);
   if (false == load_capabilities_from_file()) {
@@ -737,6 +779,10 @@ bool HMICapabilitiesImpl::phone_call_supported() const {
   return is_phone_call_supported_;
 }
 
+bool HMICapabilitiesImpl::video_streaming_supported() const {
+  return is_video_streaming_supported_;
+}
+
 const smart_objects::SmartObject* HMICapabilitiesImpl::navigation_capability()
     const {
   return navigation_capability_;
@@ -747,6 +793,11 @@ const smart_objects::SmartObject* HMICapabilitiesImpl::phone_capability()
   return phone_capability_;
 }
 
+const smart_objects::SmartObject*
+HMICapabilitiesImpl::video_streaming_capability() const {
+  return video_streaming_capability_;
+}
+
 bool HMICapabilitiesImpl::load_capabilities_from_file() {
   std::string json_string;
   std::string file_name = app_mngr_.get_settings().hmi_capabilities_file_name();
@@ -1011,6 +1062,53 @@ bool HMICapabilitiesImpl::load_capabilities_from_file() {
                                                          phone_capability_so);
           set_phone_capability(phone_capability_so);
         }
+        if (check_existing_json_member(system_capabilities,
+                                       "videoStreamingCapability")) {
+          Json::Value vs_capability =
+              system_capabilities.get("videoStreamingCapability", "");
+          smart_objects::SmartObject vs_capability_so;
+          Formatters::CFormatterJsonBase::jsonValueToObj(vs_capability,
+                                                         vs_capability_so);
+
+          if (vs_capability_so.keyExists("supportedFormats")) {
+            smart_objects::SmartObject& supported_format_array =
+                vs_capability_so["supportedFormats"];
+            smart_objects::SmartObject converted_array(
+                smart_objects::SmartType_Array);
+            for (uint32_t i = 0, j = 0; i < supported_format_array.length();
+                 i++) {
+              if (!supported_format_array[i].keyExists("protocol") ||
+                  !supported_format_array[i].keyExists("codec")) {
+                continue;
+              }
+
+              std::map<std::string,
+                       hmi_apis::Common_VideoStreamingProtocol::eType>::
+                  const_iterator it_protocol =
+                      video_streaming_protocol_enum.find(
+                          supported_format_array[i]["protocol"].asString());
+
+              std::map<std::string,
+                       hmi_apis::Common_VideoStreamingCodec::eType>::
+                  const_iterator it_codec = video_streaming_codec_enum.find(
+                      supported_format_array[i]["codec"].asString());
+
+              // format is valid only if both protocol and codec are converted
+              // to enum values successfully
+              if (it_protocol != video_streaming_protocol_enum.end() &&
+                  it_codec != video_streaming_codec_enum.end()) {
+                smart_objects::SmartObject format_so =
+                    smart_objects::SmartObject(smart_objects::SmartType_Map);
+                format_so["protocol"] = it_protocol->second;
+                format_so["codec"] = it_codec->second;
+                converted_array[j++] = format_so;
+              }
+            }
+            vs_capability_so.erase("supportedFormats");
+            vs_capability_so["supportedFormats"] = converted_array;
+          }
+          set_video_streaming_capability(vs_capability_so);
+        }
       }
     }  // UI end