| // Copyright 2020 The Chromium Authors. All rights reserved. |
| // Use of this source code is governed by a BSD-style license that can be |
| // found in the LICENSE file. |
| |
| #include "cast/streaming/receiver_message.h" |
| |
| #include <utility> |
| |
| #include "absl/strings/ascii.h" |
| #include "cast/streaming/message_fields.h" |
| #include "json/reader.h" |
| #include "json/writer.h" |
| #include "platform/base/error.h" |
| #include "util/base64.h" |
| #include "util/enum_name_table.h" |
| #include "util/json/json_helpers.h" |
| #include "util/json/json_serialization.h" |
| |
| namespace openscreen { |
| namespace cast { |
| |
| namespace { |
| |
| EnumNameTable<ReceiverMessage::Type, 5> kMessageTypeNames{ |
| {{kMessageTypeAnswer, ReceiverMessage::Type::kAnswer}, |
| {"STATUS_RESPONSE", ReceiverMessage::Type::kStatusResponse}, |
| {"CAPABILITIES_RESPONSE", ReceiverMessage::Type::kCapabilitiesResponse}, |
| {"RPC", ReceiverMessage::Type::kRpc}}}; |
| |
| ReceiverMessage::Type GetMessageType(const Json::Value& root) { |
| std::string type; |
| if (!json::ParseAndValidateString(root[kMessageType], &type)) { |
| return ReceiverMessage::Type::kUnknown; |
| } |
| |
| absl::AsciiStrToUpper(&type); |
| ErrorOr<ReceiverMessage::Type> parsed = GetEnum(kMessageTypeNames, type); |
| |
| return parsed.value(ReceiverMessage::Type::kUnknown); |
| } |
| |
| } // namespace |
| |
| // static |
| ErrorOr<ReceiverError> ReceiverError::Parse(const Json::Value& value) { |
| if (!value) { |
| return Error(Error::Code::kParameterInvalid, |
| "Empty JSON in receiver error parsing"); |
| } |
| |
| int code; |
| std::string description; |
| if (!json::ParseAndValidateInt(value[kErrorCode], &code) || |
| !json::ParseAndValidateString(value[kErrorDescription], &description)) { |
| return Error::Code::kJsonParseError; |
| } |
| return ReceiverError{code, description}; |
| } |
| |
| Json::Value ReceiverError::ToJson() const { |
| Json::Value root; |
| root[kErrorCode] = code; |
| root[kErrorDescription] = description; |
| return root; |
| } |
| |
| // static |
| ErrorOr<ReceiverCapability> ReceiverCapability::Parse( |
| const Json::Value& value) { |
| if (!value) { |
| return Error(Error::Code::kParameterInvalid, |
| "Empty JSON in capabilities parsing"); |
| } |
| |
| int remoting_version; |
| if (!json::ParseAndValidateInt(value["remoting"], &remoting_version)) { |
| remoting_version = ReceiverCapability::kRemotingVersionUnknown; |
| } |
| |
| std::vector<std::string> media_capabilities; |
| if (!json::ParseAndValidateStringArray(value["mediaCaps"], |
| &media_capabilities)) { |
| return Error(Error::Code::kJsonParseError, |
| "Failed to parse media capabilities"); |
| } |
| |
| return ReceiverCapability{remoting_version, std::move(media_capabilities)}; |
| } |
| |
| Json::Value ReceiverCapability::ToJson() const { |
| Json::Value root; |
| root["remoting"] = remoting_version; |
| Json::Value capabilities(Json::ValueType::arrayValue); |
| for (const auto& capability : media_capabilities) { |
| capabilities.append(capability); |
| } |
| root["mediaCaps"] = std::move(capabilities); |
| return root; |
| } |
| |
| // static |
| ErrorOr<ReceiverWifiStatus> ReceiverWifiStatus::Parse( |
| const Json::Value& value) { |
| if (!value) { |
| return Error(Error::Code::kParameterInvalid, |
| "Empty JSON in status parsing"); |
| } |
| |
| double wifi_snr; |
| std::vector<int32_t> wifi_speed; |
| if (!json::ParseAndValidateDouble(value["wifiSnr"], &wifi_snr, true) || |
| !json::ParseAndValidateIntArray(value["wifiSpeed"], &wifi_speed)) { |
| return Error::Code::kJsonParseError; |
| } |
| return ReceiverWifiStatus{wifi_snr, std::move(wifi_speed)}; |
| } |
| |
| Json::Value ReceiverWifiStatus::ToJson() const { |
| Json::Value root; |
| root["wifiSnr"] = wifi_snr; |
| Json::Value speeds(Json::ValueType::arrayValue); |
| for (const auto& speed : wifi_speed) { |
| speeds.append(speed); |
| } |
| root["wifiSpeed"] = std::move(speeds); |
| return root; |
| } |
| |
| // static |
| ErrorOr<ReceiverMessage> ReceiverMessage::Parse(const Json::Value& value) { |
| ReceiverMessage message; |
| if (!value || !json::ParseAndValidateInt(value[kSequenceNumber], |
| &(message.sequence_number))) { |
| return Error(Error::Code::kJsonParseError, |
| "Failed to parse sequence number"); |
| } |
| |
| std::string result; |
| if (!json::ParseAndValidateString(value[kResult], &result)) { |
| result = kResultError; |
| } |
| |
| message.type = GetMessageType(value); |
| message.valid = |
| (result == kResultOk || message.type == ReceiverMessage::Type::kRpc); |
| if (!message.valid) { |
| ErrorOr<ReceiverError> error = |
| ReceiverError::Parse(value[kErrorMessageBody]); |
| if (error.is_value()) { |
| message.body = std::move(error.value()); |
| } |
| return message; |
| } |
| |
| switch (message.type) { |
| case Type::kAnswer: { |
| Answer answer; |
| if (openscreen::cast::Answer::ParseAndValidate(value[kAnswerMessageBody], |
| &answer)) { |
| message.body = std::move(answer); |
| message.valid = true; |
| } |
| } break; |
| |
| case Type::kStatusResponse: { |
| ErrorOr<ReceiverWifiStatus> status = |
| ReceiverWifiStatus::Parse(value[kStatusMessageBody]); |
| if (status.is_value()) { |
| message.body = std::move(status.value()); |
| message.valid = true; |
| } |
| } break; |
| |
| case Type::kCapabilitiesResponse: { |
| ErrorOr<ReceiverCapability> capability = |
| ReceiverCapability::Parse(value[kCapabilitiesMessageBody]); |
| if (capability.is_value()) { |
| message.body = std::move(capability.value()); |
| message.valid = true; |
| } |
| } break; |
| |
| case Type::kRpc: { |
| std::string rpc; |
| if (json::ParseAndValidateString(value[kRpcMessageBody], &rpc) && |
| base64::Decode(rpc, &rpc)) { |
| message.body = std::move(rpc); |
| message.valid = true; |
| } |
| } break; |
| |
| case Type::kUnknown: |
| default: |
| message.valid = false; |
| break; |
| } |
| |
| return message; |
| } |
| |
| ErrorOr<Json::Value> ReceiverMessage::ToJson() const { |
| OSP_CHECK(type != ReceiverMessage::Type::kUnknown) |
| << "Trying to send an unknown message is a developer error"; |
| |
| Json::Value root; |
| root[kMessageType] = GetEnumName(kMessageTypeNames, type).value(); |
| if (sequence_number >= 0) { |
| root[kSequenceNumber] = sequence_number; |
| } |
| |
| switch (type) { |
| case ReceiverMessage::Type::kAnswer: |
| if (valid) { |
| root[kResult] = kResultOk; |
| root[kAnswerMessageBody] = absl::get<Answer>(body).ToJson(); |
| } else { |
| root[kResult] = kResultError; |
| root[kErrorMessageBody] = absl::get<ReceiverError>(body).ToJson(); |
| } |
| break; |
| |
| case (ReceiverMessage::Type::kStatusResponse): |
| root[kResult] = kResultOk; |
| root[kStatusMessageBody] = absl::get<ReceiverWifiStatus>(body).ToJson(); |
| break; |
| |
| case ReceiverMessage::Type::kCapabilitiesResponse: |
| root[kResult] = kResultOk; |
| root[kCapabilitiesMessageBody] = |
| absl::get<ReceiverCapability>(body).ToJson(); |
| break; |
| |
| // NOTE: RPC messages do NOT have a result field. |
| case ReceiverMessage::Type::kRpc: |
| root[kRpcMessageBody] = base64::Encode(absl::get<std::string>(body)); |
| break; |
| |
| default: |
| OSP_NOTREACHED(); |
| } |
| |
| return root; |
| } |
| |
| } // namespace cast |
| } // namespace openscreen |