1585346868/aliyun-openapi-cpp-sdk
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Generated 2016-11-01 for live.

Browse Source
This commit is contained in:
sdk-team
2022-01-25 09:20:34 +00:00
parent 621eb3945b
commit 0060c7ff27
52 changed files with 3319 additions and 5 deletions
Download Patch File Download Diff File Expand all files Collapse all files

3
CHANGELOG
View File

@@ -1,3 +1,6 @@
2022-01-25 Version: 1.36.1039
- Generated 2016-11-01 for `live`.
2022-01-25 Version: 1.36.1038
- Supported Get Worker List.
- Execute Job Support Designate Machine.

2
VERSION
View File

@@ -1 +1 @@
1.36.1038
1.36.1039

44
live/CMakeLists.txt
View File

@@ -67,6 +67,10 @@ set(live_public_header_model
include/alibabacloud/live/model/AddLiveSnapshotDetectPornConfigResult.h
include/alibabacloud/live/model/AddLiveStreamTranscodeRequest.h
include/alibabacloud/live/model/AddLiveStreamTranscodeResult.h
include/alibabacloud/live/model/AddLiveStreamWatermarkRequest.h
include/alibabacloud/live/model/AddLiveStreamWatermarkResult.h
include/alibabacloud/live/model/AddLiveStreamWatermarkRuleRequest.h
include/alibabacloud/live/model/AddLiveStreamWatermarkRuleResult.h
include/alibabacloud/live/model/AddMultiRateConfigRequest.h
include/alibabacloud/live/model/AddMultiRateConfigResult.h
include/alibabacloud/live/model/AddPlaylistItemsRequest.h
@@ -181,6 +185,10 @@ set(live_public_header_model
include/alibabacloud/live/model/DeleteLiveStreamMonitorResult.h
include/alibabacloud/live/model/DeleteLiveStreamTranscodeRequest.h
include/alibabacloud/live/model/DeleteLiveStreamTranscodeResult.h
include/alibabacloud/live/model/DeleteLiveStreamWatermarkRequest.h
include/alibabacloud/live/model/DeleteLiveStreamWatermarkResult.h
include/alibabacloud/live/model/DeleteLiveStreamWatermarkRuleRequest.h
include/alibabacloud/live/model/DeleteLiveStreamWatermarkRuleResult.h
include/alibabacloud/live/model/DeleteLiveStreamsNotifyUrlConfigRequest.h
include/alibabacloud/live/model/DeleteLiveStreamsNotifyUrlConfigResult.h
include/alibabacloud/live/model/DeleteMixStreamRequest.h
@@ -193,6 +201,8 @@ set(live_public_header_model
include/alibabacloud/live/model/DeletePlaylistItemsResult.h
include/alibabacloud/live/model/DeleteRoomRequest.h
include/alibabacloud/live/model/DeleteRoomResult.h
include/alibabacloud/live/model/DeleteSnapshotCallbackAuthRequest.h
include/alibabacloud/live/model/DeleteSnapshotCallbackAuthResult.h
include/alibabacloud/live/model/DeleteStudioLayoutRequest.h
include/alibabacloud/live/model/DeleteStudioLayoutResult.h
include/alibabacloud/live/model/DescribeBoardEventsRequest.h
@@ -357,6 +367,10 @@ set(live_public_header_model
include/alibabacloud/live/model/DescribeLiveStreamTranscodeInfoResult.h
include/alibabacloud/live/model/DescribeLiveStreamTranscodeStreamNumRequest.h
include/alibabacloud/live/model/DescribeLiveStreamTranscodeStreamNumResult.h
include/alibabacloud/live/model/DescribeLiveStreamWatermarkRulesRequest.h
include/alibabacloud/live/model/DescribeLiveStreamWatermarkRulesResult.h
include/alibabacloud/live/model/DescribeLiveStreamWatermarksRequest.h
include/alibabacloud/live/model/DescribeLiveStreamWatermarksResult.h
include/alibabacloud/live/model/DescribeLiveStreamsBlockListRequest.h
include/alibabacloud/live/model/DescribeLiveStreamsBlockListResult.h
include/alibabacloud/live/model/DescribeLiveStreamsControlHistoryRequest.h
@@ -465,6 +479,8 @@ set(live_public_header_model
include/alibabacloud/live/model/PlayChoosenShowResult.h
include/alibabacloud/live/model/PublishLiveStagingConfigToProductionRequest.h
include/alibabacloud/live/model/PublishLiveStagingConfigToProductionResult.h
include/alibabacloud/live/model/QuerySnapshotCallbackAuthRequest.h
include/alibabacloud/live/model/QuerySnapshotCallbackAuthResult.h
include/alibabacloud/live/model/RealTimeRecordCommandRequest.h
include/alibabacloud/live/model/RealTimeRecordCommandResult.h
include/alibabacloud/live/model/RealTimeSnapshotCommandRequest.h
@@ -503,6 +519,8 @@ set(live_public_header_model
include/alibabacloud/live/model/SetLiveStreamOptimizedFeatureConfigResult.h
include/alibabacloud/live/model/SetLiveStreamsNotifyUrlConfigRequest.h
include/alibabacloud/live/model/SetLiveStreamsNotifyUrlConfigResult.h
include/alibabacloud/live/model/SetSnapshotCallbackAuthRequest.h
include/alibabacloud/live/model/SetSnapshotCallbackAuthResult.h
include/alibabacloud/live/model/StartBoardRecordRequest.h
include/alibabacloud/live/model/StartBoardRecordResult.h
include/alibabacloud/live/model/StartCasterRequest.h
@@ -559,6 +577,10 @@ set(live_public_header_model
include/alibabacloud/live/model/UpdateLiveSnapshotDetectPornConfigResult.h
include/alibabacloud/live/model/UpdateLiveStreamMonitorRequest.h
include/alibabacloud/live/model/UpdateLiveStreamMonitorResult.h
include/alibabacloud/live/model/UpdateLiveStreamWatermarkRequest.h
include/alibabacloud/live/model/UpdateLiveStreamWatermarkResult.h
include/alibabacloud/live/model/UpdateLiveStreamWatermarkRuleRequest.h
include/alibabacloud/live/model/UpdateLiveStreamWatermarkRuleResult.h
include/alibabacloud/live/model/UpdateLiveTopLevelDomainRequest.h
include/alibabacloud/live/model/UpdateLiveTopLevelDomainResult.h
include/alibabacloud/live/model/UpdateMixStreamRequest.h
@@ -614,6 +636,10 @@ set(live_src
src/model/AddLiveSnapshotDetectPornConfigResult.cc
src/model/AddLiveStreamTranscodeRequest.cc
src/model/AddLiveStreamTranscodeResult.cc
src/model/AddLiveStreamWatermarkRequest.cc
src/model/AddLiveStreamWatermarkResult.cc
src/model/AddLiveStreamWatermarkRuleRequest.cc
src/model/AddLiveStreamWatermarkRuleResult.cc
src/model/AddMultiRateConfigRequest.cc
src/model/AddMultiRateConfigResult.cc
src/model/AddPlaylistItemsRequest.cc
@@ -728,6 +754,10 @@ set(live_src
src/model/DeleteLiveStreamMonitorResult.cc
src/model/DeleteLiveStreamTranscodeRequest.cc
src/model/DeleteLiveStreamTranscodeResult.cc
src/model/DeleteLiveStreamWatermarkRequest.cc
src/model/DeleteLiveStreamWatermarkResult.cc
src/model/DeleteLiveStreamWatermarkRuleRequest.cc
src/model/DeleteLiveStreamWatermarkRuleResult.cc
src/model/DeleteLiveStreamsNotifyUrlConfigRequest.cc
src/model/DeleteLiveStreamsNotifyUrlConfigResult.cc
src/model/DeleteMixStreamRequest.cc
@@ -740,6 +770,8 @@ set(live_src
src/model/DeletePlaylistItemsResult.cc
src/model/DeleteRoomRequest.cc
src/model/DeleteRoomResult.cc
src/model/DeleteSnapshotCallbackAuthRequest.cc
src/model/DeleteSnapshotCallbackAuthResult.cc
src/model/DeleteStudioLayoutRequest.cc
src/model/DeleteStudioLayoutResult.cc
src/model/DescribeBoardEventsRequest.cc
@@ -904,6 +936,10 @@ set(live_src
src/model/DescribeLiveStreamTranscodeInfoResult.cc
src/model/DescribeLiveStreamTranscodeStreamNumRequest.cc
src/model/DescribeLiveStreamTranscodeStreamNumResult.cc
src/model/DescribeLiveStreamWatermarkRulesRequest.cc
src/model/DescribeLiveStreamWatermarkRulesResult.cc
src/model/DescribeLiveStreamWatermarksRequest.cc
src/model/DescribeLiveStreamWatermarksResult.cc
src/model/DescribeLiveStreamsBlockListRequest.cc
src/model/DescribeLiveStreamsBlockListResult.cc
src/model/DescribeLiveStreamsControlHistoryRequest.cc
@@ -1012,6 +1048,8 @@ set(live_src
src/model/PlayChoosenShowResult.cc
src/model/PublishLiveStagingConfigToProductionRequest.cc
src/model/PublishLiveStagingConfigToProductionResult.cc
src/model/QuerySnapshotCallbackAuthRequest.cc
src/model/QuerySnapshotCallbackAuthResult.cc
src/model/RealTimeRecordCommandRequest.cc
src/model/RealTimeRecordCommandResult.cc
src/model/RealTimeSnapshotCommandRequest.cc
@@ -1050,6 +1088,8 @@ set(live_src
src/model/SetLiveStreamOptimizedFeatureConfigResult.cc
src/model/SetLiveStreamsNotifyUrlConfigRequest.cc
src/model/SetLiveStreamsNotifyUrlConfigResult.cc
src/model/SetSnapshotCallbackAuthRequest.cc
src/model/SetSnapshotCallbackAuthResult.cc
src/model/StartBoardRecordRequest.cc
src/model/StartBoardRecordResult.cc
src/model/StartCasterRequest.cc
@@ -1106,6 +1146,10 @@ set(live_src
src/model/UpdateLiveSnapshotDetectPornConfigResult.cc
src/model/UpdateLiveStreamMonitorRequest.cc
src/model/UpdateLiveStreamMonitorResult.cc
src/model/UpdateLiveStreamWatermarkRequest.cc
src/model/UpdateLiveStreamWatermarkResult.cc
src/model/UpdateLiveStreamWatermarkRuleRequest.cc
src/model/UpdateLiveStreamWatermarkRuleResult.cc
src/model/UpdateLiveTopLevelDomainRequest.cc
src/model/UpdateLiveTopLevelDomainResult.cc
src/model/UpdateMixStreamRequest.cc

88
live/include/alibabacloud/live/LiveClient.h
View File

@@ -68,6 +68,10 @@
#include "model/AddLiveSnapshotDetectPornConfigResult.h"
#include "model/AddLiveStreamTranscodeRequest.h"
#include "model/AddLiveStreamTranscodeResult.h"
#include "model/AddLiveStreamWatermarkRequest.h"
#include "model/AddLiveStreamWatermarkResult.h"
#include "model/AddLiveStreamWatermarkRuleRequest.h"
#include "model/AddLiveStreamWatermarkRuleResult.h"
#include "model/AddMultiRateConfigRequest.h"
#include "model/AddMultiRateConfigResult.h"
#include "model/AddPlaylistItemsRequest.h"
@@ -182,6 +186,10 @@
#include "model/DeleteLiveStreamMonitorResult.h"
#include "model/DeleteLiveStreamTranscodeRequest.h"
#include "model/DeleteLiveStreamTranscodeResult.h"
#include "model/DeleteLiveStreamWatermarkRequest.h"
#include "model/DeleteLiveStreamWatermarkResult.h"
#include "model/DeleteLiveStreamWatermarkRuleRequest.h"
#include "model/DeleteLiveStreamWatermarkRuleResult.h"
#include "model/DeleteLiveStreamsNotifyUrlConfigRequest.h"
#include "model/DeleteLiveStreamsNotifyUrlConfigResult.h"
#include "model/DeleteMixStreamRequest.h"
@@ -194,6 +202,8 @@
#include "model/DeletePlaylistItemsResult.h"
#include "model/DeleteRoomRequest.h"
#include "model/DeleteRoomResult.h"
#include "model/DeleteSnapshotCallbackAuthRequest.h"
#include "model/DeleteSnapshotCallbackAuthResult.h"
#include "model/DeleteStudioLayoutRequest.h"
#include "model/DeleteStudioLayoutResult.h"
#include "model/DescribeBoardEventsRequest.h"
@@ -358,6 +368,10 @@
#include "model/DescribeLiveStreamTranscodeInfoResult.h"
#include "model/DescribeLiveStreamTranscodeStreamNumRequest.h"
#include "model/DescribeLiveStreamTranscodeStreamNumResult.h"
#include "model/DescribeLiveStreamWatermarkRulesRequest.h"
#include "model/DescribeLiveStreamWatermarkRulesResult.h"
#include "model/DescribeLiveStreamWatermarksRequest.h"
#include "model/DescribeLiveStreamWatermarksResult.h"
#include "model/DescribeLiveStreamsBlockListRequest.h"
#include "model/DescribeLiveStreamsBlockListResult.h"
#include "model/DescribeLiveStreamsControlHistoryRequest.h"
@@ -466,6 +480,8 @@
#include "model/PlayChoosenShowResult.h"
#include "model/PublishLiveStagingConfigToProductionRequest.h"
#include "model/PublishLiveStagingConfigToProductionResult.h"
#include "model/QuerySnapshotCallbackAuthRequest.h"
#include "model/QuerySnapshotCallbackAuthResult.h"
#include "model/RealTimeRecordCommandRequest.h"
#include "model/RealTimeRecordCommandResult.h"
#include "model/RealTimeSnapshotCommandRequest.h"
@@ -504,6 +520,8 @@
#include "model/SetLiveStreamOptimizedFeatureConfigResult.h"
#include "model/SetLiveStreamsNotifyUrlConfigRequest.h"
#include "model/SetLiveStreamsNotifyUrlConfigResult.h"
#include "model/SetSnapshotCallbackAuthRequest.h"
#include "model/SetSnapshotCallbackAuthResult.h"
#include "model/StartBoardRecordRequest.h"
#include "model/StartBoardRecordResult.h"
#include "model/StartCasterRequest.h"
@@ -560,6 +578,10 @@
#include "model/UpdateLiveSnapshotDetectPornConfigResult.h"
#include "model/UpdateLiveStreamMonitorRequest.h"
#include "model/UpdateLiveStreamMonitorResult.h"
#include "model/UpdateLiveStreamWatermarkRequest.h"
#include "model/UpdateLiveStreamWatermarkResult.h"
#include "model/UpdateLiveStreamWatermarkRuleRequest.h"
#include "model/UpdateLiveStreamWatermarkRuleResult.h"
#include "model/UpdateLiveTopLevelDomainRequest.h"
#include "model/UpdateLiveTopLevelDomainResult.h"
#include "model/UpdateMixStreamRequest.h"
@@ -644,6 +666,12 @@ namespace AlibabaCloud
typedef Outcome<Error, Model::AddLiveStreamTranscodeResult> AddLiveStreamTranscodeOutcome;
typedef std::future<AddLiveStreamTranscodeOutcome> AddLiveStreamTranscodeOutcomeCallable;
typedef std::function<void(const LiveClient*, const Model::AddLiveStreamTranscodeRequest&, const AddLiveStreamTranscodeOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> AddLiveStreamTranscodeAsyncHandler;
typedef Outcome<Error, Model::AddLiveStreamWatermarkResult> AddLiveStreamWatermarkOutcome;
typedef std::future<AddLiveStreamWatermarkOutcome> AddLiveStreamWatermarkOutcomeCallable;
typedef std::function<void(const LiveClient*, const Model::AddLiveStreamWatermarkRequest&, const AddLiveStreamWatermarkOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> AddLiveStreamWatermarkAsyncHandler;
typedef Outcome<Error, Model::AddLiveStreamWatermarkRuleResult> AddLiveStreamWatermarkRuleOutcome;
typedef std::future<AddLiveStreamWatermarkRuleOutcome> AddLiveStreamWatermarkRuleOutcomeCallable;
typedef std::function<void(const LiveClient*, const Model::AddLiveStreamWatermarkRuleRequest&, const AddLiveStreamWatermarkRuleOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> AddLiveStreamWatermarkRuleAsyncHandler;
typedef Outcome<Error, Model::AddMultiRateConfigResult> AddMultiRateConfigOutcome;
typedef std::future<AddMultiRateConfigOutcome> AddMultiRateConfigOutcomeCallable;
typedef std::function<void(const LiveClient*, const Model::AddMultiRateConfigRequest&, const AddMultiRateConfigOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> AddMultiRateConfigAsyncHandler;
@@ -815,6 +843,12 @@ namespace AlibabaCloud
typedef Outcome<Error, Model::DeleteLiveStreamTranscodeResult> DeleteLiveStreamTranscodeOutcome;
typedef std::future<DeleteLiveStreamTranscodeOutcome> DeleteLiveStreamTranscodeOutcomeCallable;
typedef std::function<void(const LiveClient*, const Model::DeleteLiveStreamTranscodeRequest&, const DeleteLiveStreamTranscodeOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DeleteLiveStreamTranscodeAsyncHandler;
typedef Outcome<Error, Model::DeleteLiveStreamWatermarkResult> DeleteLiveStreamWatermarkOutcome;
typedef std::future<DeleteLiveStreamWatermarkOutcome> DeleteLiveStreamWatermarkOutcomeCallable;
typedef std::function<void(const LiveClient*, const Model::DeleteLiveStreamWatermarkRequest&, const DeleteLiveStreamWatermarkOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DeleteLiveStreamWatermarkAsyncHandler;
typedef Outcome<Error, Model::DeleteLiveStreamWatermarkRuleResult> DeleteLiveStreamWatermarkRuleOutcome;
typedef std::future<DeleteLiveStreamWatermarkRuleOutcome> DeleteLiveStreamWatermarkRuleOutcomeCallable;
typedef std::function<void(const LiveClient*, const Model::DeleteLiveStreamWatermarkRuleRequest&, const DeleteLiveStreamWatermarkRuleOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DeleteLiveStreamWatermarkRuleAsyncHandler;
typedef Outcome<Error, Model::DeleteLiveStreamsNotifyUrlConfigResult> DeleteLiveStreamsNotifyUrlConfigOutcome;
typedef std::future<DeleteLiveStreamsNotifyUrlConfigOutcome> DeleteLiveStreamsNotifyUrlConfigOutcomeCallable;
typedef std::function<void(const LiveClient*, const Model::DeleteLiveStreamsNotifyUrlConfigRequest&, const DeleteLiveStreamsNotifyUrlConfigOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DeleteLiveStreamsNotifyUrlConfigAsyncHandler;
@@ -833,6 +867,9 @@ namespace AlibabaCloud
typedef Outcome<Error, Model::DeleteRoomResult> DeleteRoomOutcome;
typedef std::future<DeleteRoomOutcome> DeleteRoomOutcomeCallable;
typedef std::function<void(const LiveClient*, const Model::DeleteRoomRequest&, const DeleteRoomOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DeleteRoomAsyncHandler;
typedef Outcome<Error, Model::DeleteSnapshotCallbackAuthResult> DeleteSnapshotCallbackAuthOutcome;
typedef std::future<DeleteSnapshotCallbackAuthOutcome> DeleteSnapshotCallbackAuthOutcomeCallable;
typedef std::function<void(const LiveClient*, const Model::DeleteSnapshotCallbackAuthRequest&, const DeleteSnapshotCallbackAuthOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DeleteSnapshotCallbackAuthAsyncHandler;
typedef Outcome<Error, Model::DeleteStudioLayoutResult> DeleteStudioLayoutOutcome;
typedef std::future<DeleteStudioLayoutOutcome> DeleteStudioLayoutOutcomeCallable;
typedef std::function<void(const LiveClient*, const Model::DeleteStudioLayoutRequest&, const DeleteStudioLayoutOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DeleteStudioLayoutAsyncHandler;
@@ -1079,6 +1116,12 @@ namespace AlibabaCloud
typedef Outcome<Error, Model::DescribeLiveStreamTranscodeStreamNumResult> DescribeLiveStreamTranscodeStreamNumOutcome;
typedef std::future<DescribeLiveStreamTranscodeStreamNumOutcome> DescribeLiveStreamTranscodeStreamNumOutcomeCallable;
typedef std::function<void(const LiveClient*, const Model::DescribeLiveStreamTranscodeStreamNumRequest&, const DescribeLiveStreamTranscodeStreamNumOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeLiveStreamTranscodeStreamNumAsyncHandler;
typedef Outcome<Error, Model::DescribeLiveStreamWatermarkRulesResult> DescribeLiveStreamWatermarkRulesOutcome;
typedef std::future<DescribeLiveStreamWatermarkRulesOutcome> DescribeLiveStreamWatermarkRulesOutcomeCallable;
typedef std::function<void(const LiveClient*, const Model::DescribeLiveStreamWatermarkRulesRequest&, const DescribeLiveStreamWatermarkRulesOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeLiveStreamWatermarkRulesAsyncHandler;
typedef Outcome<Error, Model::DescribeLiveStreamWatermarksResult> DescribeLiveStreamWatermarksOutcome;
typedef std::future<DescribeLiveStreamWatermarksOutcome> DescribeLiveStreamWatermarksOutcomeCallable;
typedef std::function<void(const LiveClient*, const Model::DescribeLiveStreamWatermarksRequest&, const DescribeLiveStreamWatermarksOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeLiveStreamWatermarksAsyncHandler;
typedef Outcome<Error, Model::DescribeLiveStreamsBlockListResult> DescribeLiveStreamsBlockListOutcome;
typedef std::future<DescribeLiveStreamsBlockListOutcome> DescribeLiveStreamsBlockListOutcomeCallable;
typedef std::function<void(const LiveClient*, const Model::DescribeLiveStreamsBlockListRequest&, const DescribeLiveStreamsBlockListOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeLiveStreamsBlockListAsyncHandler;
@@ -1241,6 +1284,9 @@ namespace AlibabaCloud
typedef Outcome<Error, Model::PublishLiveStagingConfigToProductionResult> PublishLiveStagingConfigToProductionOutcome;
typedef std::future<PublishLiveStagingConfigToProductionOutcome> PublishLiveStagingConfigToProductionOutcomeCallable;
typedef std::function<void(const LiveClient*, const Model::PublishLiveStagingConfigToProductionRequest&, const PublishLiveStagingConfigToProductionOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> PublishLiveStagingConfigToProductionAsyncHandler;
typedef Outcome<Error, Model::QuerySnapshotCallbackAuthResult> QuerySnapshotCallbackAuthOutcome;
typedef std::future<QuerySnapshotCallbackAuthOutcome> QuerySnapshotCallbackAuthOutcomeCallable;
typedef std::function<void(const LiveClient*, const Model::QuerySnapshotCallbackAuthRequest&, const QuerySnapshotCallbackAuthOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> QuerySnapshotCallbackAuthAsyncHandler;
typedef Outcome<Error, Model::RealTimeRecordCommandResult> RealTimeRecordCommandOutcome;
typedef std::future<RealTimeRecordCommandOutcome> RealTimeRecordCommandOutcomeCallable;
typedef std::function<void(const LiveClient*, const Model::RealTimeRecordCommandRequest&, const RealTimeRecordCommandOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> RealTimeRecordCommandAsyncHandler;
@@ -1298,6 +1344,9 @@ namespace AlibabaCloud
typedef Outcome<Error, Model::SetLiveStreamsNotifyUrlConfigResult> SetLiveStreamsNotifyUrlConfigOutcome;
typedef std::future<SetLiveStreamsNotifyUrlConfigOutcome> SetLiveStreamsNotifyUrlConfigOutcomeCallable;
typedef std::function<void(const LiveClient*, const Model::SetLiveStreamsNotifyUrlConfigRequest&, const SetLiveStreamsNotifyUrlConfigOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> SetLiveStreamsNotifyUrlConfigAsyncHandler;
typedef Outcome<Error, Model::SetSnapshotCallbackAuthResult> SetSnapshotCallbackAuthOutcome;
typedef std::future<SetSnapshotCallbackAuthOutcome> SetSnapshotCallbackAuthOutcomeCallable;
typedef std::function<void(const LiveClient*, const Model::SetSnapshotCallbackAuthRequest&, const SetSnapshotCallbackAuthOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> SetSnapshotCallbackAuthAsyncHandler;
typedef Outcome<Error, Model::StartBoardRecordResult> StartBoardRecordOutcome;
typedef std::future<StartBoardRecordOutcome> StartBoardRecordOutcomeCallable;
typedef std::function<void(const LiveClient*, const Model::StartBoardRecordRequest&, const StartBoardRecordOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> StartBoardRecordAsyncHandler;
@@ -1382,6 +1431,12 @@ namespace AlibabaCloud
typedef Outcome<Error, Model::UpdateLiveStreamMonitorResult> UpdateLiveStreamMonitorOutcome;
typedef std::future<UpdateLiveStreamMonitorOutcome> UpdateLiveStreamMonitorOutcomeCallable;
typedef std::function<void(const LiveClient*, const Model::UpdateLiveStreamMonitorRequest&, const UpdateLiveStreamMonitorOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> UpdateLiveStreamMonitorAsyncHandler;
typedef Outcome<Error, Model::UpdateLiveStreamWatermarkResult> UpdateLiveStreamWatermarkOutcome;
typedef std::future<UpdateLiveStreamWatermarkOutcome> UpdateLiveStreamWatermarkOutcomeCallable;
typedef std::function<void(const LiveClient*, const Model::UpdateLiveStreamWatermarkRequest&, const UpdateLiveStreamWatermarkOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> UpdateLiveStreamWatermarkAsyncHandler;
typedef Outcome<Error, Model::UpdateLiveStreamWatermarkRuleResult> UpdateLiveStreamWatermarkRuleOutcome;
typedef std::future<UpdateLiveStreamWatermarkRuleOutcome> UpdateLiveStreamWatermarkRuleOutcomeCallable;
typedef std::function<void(const LiveClient*, const Model::UpdateLiveStreamWatermarkRuleRequest&, const UpdateLiveStreamWatermarkRuleOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> UpdateLiveStreamWatermarkRuleAsyncHandler;
typedef Outcome<Error, Model::UpdateLiveTopLevelDomainResult> UpdateLiveTopLevelDomainOutcome;
typedef std::future<UpdateLiveTopLevelDomainOutcome> UpdateLiveTopLevelDomainOutcomeCallable;
typedef std::function<void(const LiveClient*, const Model::UpdateLiveTopLevelDomainRequest&, const UpdateLiveTopLevelDomainOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> UpdateLiveTopLevelDomainAsyncHandler;
@@ -1465,6 +1520,12 @@ namespace AlibabaCloud
AddLiveStreamTranscodeOutcome addLiveStreamTranscode(const Model::AddLiveStreamTranscodeRequest &request)const;
void addLiveStreamTranscodeAsync(const Model::AddLiveStreamTranscodeRequest& request, const AddLiveStreamTranscodeAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
AddLiveStreamTranscodeOutcomeCallable addLiveStreamTranscodeCallable(const Model::AddLiveStreamTranscodeRequest& request) const;
AddLiveStreamWatermarkOutcome addLiveStreamWatermark(const Model::AddLiveStreamWatermarkRequest &request)const;
void addLiveStreamWatermarkAsync(const Model::AddLiveStreamWatermarkRequest& request, const AddLiveStreamWatermarkAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
AddLiveStreamWatermarkOutcomeCallable addLiveStreamWatermarkCallable(const Model::AddLiveStreamWatermarkRequest& request) const;
AddLiveStreamWatermarkRuleOutcome addLiveStreamWatermarkRule(const Model::AddLiveStreamWatermarkRuleRequest &request)const;
void addLiveStreamWatermarkRuleAsync(const Model::AddLiveStreamWatermarkRuleRequest& request, const AddLiveStreamWatermarkRuleAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
AddLiveStreamWatermarkRuleOutcomeCallable addLiveStreamWatermarkRuleCallable(const Model::AddLiveStreamWatermarkRuleRequest& request) const;
AddMultiRateConfigOutcome addMultiRateConfig(const Model::AddMultiRateConfigRequest &request)const;
void addMultiRateConfigAsync(const Model::AddMultiRateConfigRequest& request, const AddMultiRateConfigAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
AddMultiRateConfigOutcomeCallable addMultiRateConfigCallable(const Model::AddMultiRateConfigRequest& request) const;
@@ -1636,6 +1697,12 @@ namespace AlibabaCloud
DeleteLiveStreamTranscodeOutcome deleteLiveStreamTranscode(const Model::DeleteLiveStreamTranscodeRequest &request)const;
void deleteLiveStreamTranscodeAsync(const Model::DeleteLiveStreamTranscodeRequest& request, const DeleteLiveStreamTranscodeAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
DeleteLiveStreamTranscodeOutcomeCallable deleteLiveStreamTranscodeCallable(const Model::DeleteLiveStreamTranscodeRequest& request) const;
DeleteLiveStreamWatermarkOutcome deleteLiveStreamWatermark(const Model::DeleteLiveStreamWatermarkRequest &request)const;
void deleteLiveStreamWatermarkAsync(const Model::DeleteLiveStreamWatermarkRequest& request, const DeleteLiveStreamWatermarkAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
DeleteLiveStreamWatermarkOutcomeCallable deleteLiveStreamWatermarkCallable(const Model::DeleteLiveStreamWatermarkRequest& request) const;
DeleteLiveStreamWatermarkRuleOutcome deleteLiveStreamWatermarkRule(const Model::DeleteLiveStreamWatermarkRuleRequest &request)const;
void deleteLiveStreamWatermarkRuleAsync(const Model::DeleteLiveStreamWatermarkRuleRequest& request, const DeleteLiveStreamWatermarkRuleAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
DeleteLiveStreamWatermarkRuleOutcomeCallable deleteLiveStreamWatermarkRuleCallable(const Model::DeleteLiveStreamWatermarkRuleRequest& request) const;
DeleteLiveStreamsNotifyUrlConfigOutcome deleteLiveStreamsNotifyUrlConfig(const Model::DeleteLiveStreamsNotifyUrlConfigRequest &request)const;
void deleteLiveStreamsNotifyUrlConfigAsync(const Model::DeleteLiveStreamsNotifyUrlConfigRequest& request, const DeleteLiveStreamsNotifyUrlConfigAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
DeleteLiveStreamsNotifyUrlConfigOutcomeCallable deleteLiveStreamsNotifyUrlConfigCallable(const Model::DeleteLiveStreamsNotifyUrlConfigRequest& request) const;
@@ -1654,6 +1721,9 @@ namespace AlibabaCloud
DeleteRoomOutcome deleteRoom(const Model::DeleteRoomRequest &request)const;
void deleteRoomAsync(const Model::DeleteRoomRequest& request, const DeleteRoomAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
DeleteRoomOutcomeCallable deleteRoomCallable(const Model::DeleteRoomRequest& request) const;
DeleteSnapshotCallbackAuthOutcome deleteSnapshotCallbackAuth(const Model::DeleteSnapshotCallbackAuthRequest &request)const;
void deleteSnapshotCallbackAuthAsync(const Model::DeleteSnapshotCallbackAuthRequest& request, const DeleteSnapshotCallbackAuthAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
DeleteSnapshotCallbackAuthOutcomeCallable deleteSnapshotCallbackAuthCallable(const Model::DeleteSnapshotCallbackAuthRequest& request) const;
DeleteStudioLayoutOutcome deleteStudioLayout(const Model::DeleteStudioLayoutRequest &request)const;
void deleteStudioLayoutAsync(const Model::DeleteStudioLayoutRequest& request, const DeleteStudioLayoutAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
DeleteStudioLayoutOutcomeCallable deleteStudioLayoutCallable(const Model::DeleteStudioLayoutRequest& request) const;
@@ -1900,6 +1970,12 @@ namespace AlibabaCloud
DescribeLiveStreamTranscodeStreamNumOutcome describeLiveStreamTranscodeStreamNum(const Model::DescribeLiveStreamTranscodeStreamNumRequest &request)const;
void describeLiveStreamTranscodeStreamNumAsync(const Model::DescribeLiveStreamTranscodeStreamNumRequest& request, const DescribeLiveStreamTranscodeStreamNumAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
DescribeLiveStreamTranscodeStreamNumOutcomeCallable describeLiveStreamTranscodeStreamNumCallable(const Model::DescribeLiveStreamTranscodeStreamNumRequest& request) const;
DescribeLiveStreamWatermarkRulesOutcome describeLiveStreamWatermarkRules(const Model::DescribeLiveStreamWatermarkRulesRequest &request)const;
void describeLiveStreamWatermarkRulesAsync(const Model::DescribeLiveStreamWatermarkRulesRequest& request, const DescribeLiveStreamWatermarkRulesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
DescribeLiveStreamWatermarkRulesOutcomeCallable describeLiveStreamWatermarkRulesCallable(const Model::DescribeLiveStreamWatermarkRulesRequest& request) const;
DescribeLiveStreamWatermarksOutcome describeLiveStreamWatermarks(const Model::DescribeLiveStreamWatermarksRequest &request)const;
void describeLiveStreamWatermarksAsync(const Model::DescribeLiveStreamWatermarksRequest& request, const DescribeLiveStreamWatermarksAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
DescribeLiveStreamWatermarksOutcomeCallable describeLiveStreamWatermarksCallable(const Model::DescribeLiveStreamWatermarksRequest& request) const;
DescribeLiveStreamsBlockListOutcome describeLiveStreamsBlockList(const Model::DescribeLiveStreamsBlockListRequest &request)const;
void describeLiveStreamsBlockListAsync(const Model::DescribeLiveStreamsBlockListRequest& request, const DescribeLiveStreamsBlockListAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
DescribeLiveStreamsBlockListOutcomeCallable describeLiveStreamsBlockListCallable(const Model::DescribeLiveStreamsBlockListRequest& request) const;
@@ -2062,6 +2138,9 @@ namespace AlibabaCloud
PublishLiveStagingConfigToProductionOutcome publishLiveStagingConfigToProduction(const Model::PublishLiveStagingConfigToProductionRequest &request)const;
void publishLiveStagingConfigToProductionAsync(const Model::PublishLiveStagingConfigToProductionRequest& request, const PublishLiveStagingConfigToProductionAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
PublishLiveStagingConfigToProductionOutcomeCallable publishLiveStagingConfigToProductionCallable(const Model::PublishLiveStagingConfigToProductionRequest& request) const;
QuerySnapshotCallbackAuthOutcome querySnapshotCallbackAuth(const Model::QuerySnapshotCallbackAuthRequest &request)const;
void querySnapshotCallbackAuthAsync(const Model::QuerySnapshotCallbackAuthRequest& request, const QuerySnapshotCallbackAuthAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
QuerySnapshotCallbackAuthOutcomeCallable querySnapshotCallbackAuthCallable(const Model::QuerySnapshotCallbackAuthRequest& request) const;
RealTimeRecordCommandOutcome realTimeRecordCommand(const Model::RealTimeRecordCommandRequest &request)const;
void realTimeRecordCommandAsync(const Model::RealTimeRecordCommandRequest& request, const RealTimeRecordCommandAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
RealTimeRecordCommandOutcomeCallable realTimeRecordCommandCallable(const Model::RealTimeRecordCommandRequest& request) const;
@@ -2119,6 +2198,9 @@ namespace AlibabaCloud
SetLiveStreamsNotifyUrlConfigOutcome setLiveStreamsNotifyUrlConfig(const Model::SetLiveStreamsNotifyUrlConfigRequest &request)const;
void setLiveStreamsNotifyUrlConfigAsync(const Model::SetLiveStreamsNotifyUrlConfigRequest& request, const SetLiveStreamsNotifyUrlConfigAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
SetLiveStreamsNotifyUrlConfigOutcomeCallable setLiveStreamsNotifyUrlConfigCallable(const Model::SetLiveStreamsNotifyUrlConfigRequest& request) const;
SetSnapshotCallbackAuthOutcome setSnapshotCallbackAuth(const Model::SetSnapshotCallbackAuthRequest &request)const;
void setSnapshotCallbackAuthAsync(const Model::SetSnapshotCallbackAuthRequest& request, const SetSnapshotCallbackAuthAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
SetSnapshotCallbackAuthOutcomeCallable setSnapshotCallbackAuthCallable(const Model::SetSnapshotCallbackAuthRequest& request) const;
StartBoardRecordOutcome startBoardRecord(const Model::StartBoardRecordRequest &request)const;
void startBoardRecordAsync(const Model::StartBoardRecordRequest& request, const StartBoardRecordAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
StartBoardRecordOutcomeCallable startBoardRecordCallable(const Model::StartBoardRecordRequest& request) const;
@@ -2203,6 +2285,12 @@ namespace AlibabaCloud
UpdateLiveStreamMonitorOutcome updateLiveStreamMonitor(const Model::UpdateLiveStreamMonitorRequest &request)const;
void updateLiveStreamMonitorAsync(const Model::UpdateLiveStreamMonitorRequest& request, const UpdateLiveStreamMonitorAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
UpdateLiveStreamMonitorOutcomeCallable updateLiveStreamMonitorCallable(const Model::UpdateLiveStreamMonitorRequest& request) const;
UpdateLiveStreamWatermarkOutcome updateLiveStreamWatermark(const Model::UpdateLiveStreamWatermarkRequest &request)const;
void updateLiveStreamWatermarkAsync(const Model::UpdateLiveStreamWatermarkRequest& request, const UpdateLiveStreamWatermarkAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
UpdateLiveStreamWatermarkOutcomeCallable updateLiveStreamWatermarkCallable(const Model::UpdateLiveStreamWatermarkRequest& request) const;
UpdateLiveStreamWatermarkRuleOutcome updateLiveStreamWatermarkRule(const Model::UpdateLiveStreamWatermarkRuleRequest &request)const;
void updateLiveStreamWatermarkRuleAsync(const Model::UpdateLiveStreamWatermarkRuleRequest& request, const UpdateLiveStreamWatermarkRuleAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
UpdateLiveStreamWatermarkRuleOutcomeCallable updateLiveStreamWatermarkRuleCallable(const Model::UpdateLiveStreamWatermarkRuleRequest& request) const;
UpdateLiveTopLevelDomainOutcome updateLiveTopLevelDomain(const Model::UpdateLiveTopLevelDomainRequest &request)const;
void updateLiveTopLevelDomainAsync(const Model::UpdateLiveTopLevelDomainRequest& request, const UpdateLiveTopLevelDomainAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
UpdateLiveTopLevelDomainOutcomeCallable updateLiveTopLevelDomainCallable(const Model::UpdateLiveTopLevelDomainRequest& request) const;

81
live/include/alibabacloud/live/model/AddLiveStreamWatermarkRequest.h Normal file
View File

@@ -0,0 +1,81 @@
/*
* Copyright 2009-2017 Alibaba Cloud 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.
*/
#ifndef ALIBABACLOUD_LIVE_MODEL_ADDLIVESTREAMWATERMARKREQUEST_H_
#define ALIBABACLOUD_LIVE_MODEL_ADDLIVESTREAMWATERMARKREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/live/LiveExport.h>
namespace AlibabaCloud
{
namespace Live
{
namespace Model
{
class ALIBABACLOUD_LIVE_EXPORT AddLiveStreamWatermarkRequest : public RpcServiceRequest
{
public:
AddLiveStreamWatermarkRequest();
~AddLiveStreamWatermarkRequest();
float getYOffset()const;
void setYOffset(float yOffset);
std::string getPictureUrl()const;
void setPictureUrl(const std::string& pictureUrl);
std::string getDescription()const;
void setDescription(const std::string& description);
int getType()const;
void setType(int type);
int getHeight()const;
void setHeight(int height);
float getXOffset()const;
void setXOffset(float xOffset);
long getOwnerId()const;
void setOwnerId(long ownerId);
int getRefWidth()const;
void setRefWidth(int refWidth);
int getTransparency()const;
void setTransparency(int transparency);
std::string getName()const;
void setName(const std::string& name);
std::string getOffsetCorner()const;
void setOffsetCorner(const std::string& offsetCorner);
int getRefHeight()const;
void setRefHeight(int refHeight);
private:
float yOffset_;
std::string pictureUrl_;
std::string description_;
int type_;
int height_;
float xOffset_;
long ownerId_;
int refWidth_;
int transparency_;
std::string name_;
std::string offsetCorner_;
int refHeight_;
};
}
}
}
#endif // !ALIBABACLOUD_LIVE_MODEL_ADDLIVESTREAMWATERMARKREQUEST_H_

51
live/include/alibabacloud/live/model/AddLiveStreamWatermarkResult.h Normal file
View File

@@ -0,0 +1,51 @@
/*
* Copyright 2009-2017 Alibaba Cloud 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.
*/
#ifndef ALIBABACLOUD_LIVE_MODEL_ADDLIVESTREAMWATERMARKRESULT_H_
#define ALIBABACLOUD_LIVE_MODEL_ADDLIVESTREAMWATERMARKRESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/live/LiveExport.h>
namespace AlibabaCloud
{
namespace Live
{
namespace Model
{
class ALIBABACLOUD_LIVE_EXPORT AddLiveStreamWatermarkResult : public ServiceResult
{
public:
AddLiveStreamWatermarkResult();
explicit AddLiveStreamWatermarkResult(const std::string &payload);
~AddLiveStreamWatermarkResult();
std::string getTemplateId()const;
protected:
void parse(const std::string &payload);
private:
std::string templateId_;
};
}
}
}
#endif // !ALIBABACLOUD_LIVE_MODEL_ADDLIVESTREAMWATERMARKRESULT_H_

66
live/include/alibabacloud/live/model/AddLiveStreamWatermarkRuleRequest.h Normal file
View File

@@ -0,0 +1,66 @@
/*
* Copyright 2009-2017 Alibaba Cloud 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.
*/
#ifndef ALIBABACLOUD_LIVE_MODEL_ADDLIVESTREAMWATERMARKRULEREQUEST_H_
#define ALIBABACLOUD_LIVE_MODEL_ADDLIVESTREAMWATERMARKRULEREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/live/LiveExport.h>
namespace AlibabaCloud
{
namespace Live
{
namespace Model
{
class ALIBABACLOUD_LIVE_EXPORT AddLiveStreamWatermarkRuleRequest : public RpcServiceRequest
{
public:
AddLiveStreamWatermarkRuleRequest();
~AddLiveStreamWatermarkRuleRequest();
std::string getDescription()const;
void setDescription(const std::string& description);
std::string getStream()const;
void setStream(const std::string& stream);
std::string getApp()const;
void setApp(const std::string& app);
long getOwnerId()const;
void setOwnerId(long ownerId);
std::string getTemplateId()const;
void setTemplateId(const std::string& templateId);
std::string getDomain()const;
void setDomain(const std::string& domain);
std::string getName()const;
void setName(const std::string& name);
private:
std::string description_;
std::string stream_;
std::string app_;
long ownerId_;
std::string templateId_;
std::string domain_;
std::string name_;
};
}
}
}
#endif // !ALIBABACLOUD_LIVE_MODEL_ADDLIVESTREAMWATERMARKRULEREQUEST_H_

51
live/include/alibabacloud/live/model/AddLiveStreamWatermarkRuleResult.h Normal file
View File

@@ -0,0 +1,51 @@
/*
* Copyright 2009-2017 Alibaba Cloud 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.
*/
#ifndef ALIBABACLOUD_LIVE_MODEL_ADDLIVESTREAMWATERMARKRULERESULT_H_
#define ALIBABACLOUD_LIVE_MODEL_ADDLIVESTREAMWATERMARKRULERESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/live/LiveExport.h>
namespace AlibabaCloud
{
namespace Live
{
namespace Model
{
class ALIBABACLOUD_LIVE_EXPORT AddLiveStreamWatermarkRuleResult : public ServiceResult
{
public:
AddLiveStreamWatermarkRuleResult();
explicit AddLiveStreamWatermarkRuleResult(const std::string &payload);
~AddLiveStreamWatermarkRuleResult();
std::string getRuleId()const;
protected:
void parse(const std::string &payload);
private:
std::string ruleId_;
};
}
}
}
#endif // !ALIBABACLOUD_LIVE_MODEL_ADDLIVESTREAMWATERMARKRULERESULT_H_

51
live/include/alibabacloud/live/model/DeleteLiveStreamWatermarkRequest.h Normal file
View File

@@ -0,0 +1,51 @@
/*
* Copyright 2009-2017 Alibaba Cloud 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.
*/
#ifndef ALIBABACLOUD_LIVE_MODEL_DELETELIVESTREAMWATERMARKREQUEST_H_
#define ALIBABACLOUD_LIVE_MODEL_DELETELIVESTREAMWATERMARKREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/live/LiveExport.h>
namespace AlibabaCloud
{
namespace Live
{
namespace Model
{
class ALIBABACLOUD_LIVE_EXPORT DeleteLiveStreamWatermarkRequest : public RpcServiceRequest
{
public:
DeleteLiveStreamWatermarkRequest();
~DeleteLiveStreamWatermarkRequest();
long getOwnerId()const;
void setOwnerId(long ownerId);
std::string getTemplateId()const;
void setTemplateId(const std::string& templateId);
private:
long ownerId_;
std::string templateId_;
};
}
}
}
#endif // !ALIBABACLOUD_LIVE_MODEL_DELETELIVESTREAMWATERMARKREQUEST_H_

49
live/include/alibabacloud/live/model/DeleteLiveStreamWatermarkResult.h Normal file
View File

@@ -0,0 +1,49 @@
/*
* Copyright 2009-2017 Alibaba Cloud 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.
*/
#ifndef ALIBABACLOUD_LIVE_MODEL_DELETELIVESTREAMWATERMARKRESULT_H_
#define ALIBABACLOUD_LIVE_MODEL_DELETELIVESTREAMWATERMARKRESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/live/LiveExport.h>
namespace AlibabaCloud
{
namespace Live
{
namespace Model
{
class ALIBABACLOUD_LIVE_EXPORT DeleteLiveStreamWatermarkResult : public ServiceResult
{
public:
DeleteLiveStreamWatermarkResult();
explicit DeleteLiveStreamWatermarkResult(const std::string &payload);
~DeleteLiveStreamWatermarkResult();
protected:
void parse(const std::string &payload);
private:
};
}
}
}
#endif // !ALIBABACLOUD_LIVE_MODEL_DELETELIVESTREAMWATERMARKRESULT_H_

60
live/include/alibabacloud/live/model/DeleteLiveStreamWatermarkRuleRequest.h Normal file
View File

@@ -0,0 +1,60 @@
/*
* Copyright 2009-2017 Alibaba Cloud 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.
*/
#ifndef ALIBABACLOUD_LIVE_MODEL_DELETELIVESTREAMWATERMARKRULEREQUEST_H_
#define ALIBABACLOUD_LIVE_MODEL_DELETELIVESTREAMWATERMARKRULEREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/live/LiveExport.h>
namespace AlibabaCloud
{
namespace Live
{
namespace Model
{
class ALIBABACLOUD_LIVE_EXPORT DeleteLiveStreamWatermarkRuleRequest : public RpcServiceRequest
{
public:
DeleteLiveStreamWatermarkRuleRequest();
~DeleteLiveStreamWatermarkRuleRequest();
std::string getStream()const;
void setStream(const std::string& stream);
std::string getApp()const;
void setApp(const std::string& app);
long getOwnerId()const;
void setOwnerId(long ownerId);
std::string getDomain()const;
void setDomain(const std::string& domain);
std::string getRuleId()const;
void setRuleId(const std::string& ruleId);
private:
std::string stream_;
std::string app_;
long ownerId_;
std::string domain_;
std::string ruleId_;
};
}
}
}
#endif // !ALIBABACLOUD_LIVE_MODEL_DELETELIVESTREAMWATERMARKRULEREQUEST_H_

49
live/include/alibabacloud/live/model/DeleteLiveStreamWatermarkRuleResult.h Normal file
View File

@@ -0,0 +1,49 @@
/*
* Copyright 2009-2017 Alibaba Cloud 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.
*/
#ifndef ALIBABACLOUD_LIVE_MODEL_DELETELIVESTREAMWATERMARKRULERESULT_H_
#define ALIBABACLOUD_LIVE_MODEL_DELETELIVESTREAMWATERMARKRULERESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/live/LiveExport.h>
namespace AlibabaCloud
{
namespace Live
{
namespace Model
{
class ALIBABACLOUD_LIVE_EXPORT DeleteLiveStreamWatermarkRuleResult : public ServiceResult
{
public:
DeleteLiveStreamWatermarkRuleResult();
explicit DeleteLiveStreamWatermarkRuleResult(const std::string &payload);
~DeleteLiveStreamWatermarkRuleResult();
protected:
void parse(const std::string &payload);
private:
};
}
}
}
#endif // !ALIBABACLOUD_LIVE_MODEL_DELETELIVESTREAMWATERMARKRULERESULT_H_

51
live/include/alibabacloud/live/model/DeleteSnapshotCallbackAuthRequest.h Normal file
View File

@@ -0,0 +1,51 @@
/*
* Copyright 2009-2017 Alibaba Cloud 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.
*/
#ifndef ALIBABACLOUD_LIVE_MODEL_DELETESNAPSHOTCALLBACKAUTHREQUEST_H_
#define ALIBABACLOUD_LIVE_MODEL_DELETESNAPSHOTCALLBACKAUTHREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/live/LiveExport.h>
namespace AlibabaCloud
{
namespace Live
{
namespace Model
{
class ALIBABACLOUD_LIVE_EXPORT DeleteSnapshotCallbackAuthRequest : public RpcServiceRequest
{
public:
DeleteSnapshotCallbackAuthRequest();
~DeleteSnapshotCallbackAuthRequest();
std::string getDomainName()const;
void setDomainName(const std::string& domainName);
long getOwnerId()const;
void setOwnerId(long ownerId);
private:
std::string domainName_;
long ownerId_;
};
}
}
}
#endif // !ALIBABACLOUD_LIVE_MODEL_DELETESNAPSHOTCALLBACKAUTHREQUEST_H_

49
live/include/alibabacloud/live/model/DeleteSnapshotCallbackAuthResult.h Normal file
View File

@@ -0,0 +1,49 @@
/*
* Copyright 2009-2017 Alibaba Cloud 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.
*/
#ifndef ALIBABACLOUD_LIVE_MODEL_DELETESNAPSHOTCALLBACKAUTHRESULT_H_
#define ALIBABACLOUD_LIVE_MODEL_DELETESNAPSHOTCALLBACKAUTHRESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/live/LiveExport.h>
namespace AlibabaCloud
{
namespace Live
{
namespace Model
{
class ALIBABACLOUD_LIVE_EXPORT DeleteSnapshotCallbackAuthResult : public ServiceResult
{
public:
DeleteSnapshotCallbackAuthResult();
explicit DeleteSnapshotCallbackAuthResult(const std::string &payload);
~DeleteSnapshotCallbackAuthResult();
protected:
void parse(const std::string &payload);
private:
};
}
}
}
#endif // !ALIBABACLOUD_LIVE_MODEL_DELETESNAPSHOTCALLBACKAUTHRESULT_H_

54
live/include/alibabacloud/live/model/DescribeLiveStreamWatermarkRulesRequest.h Normal file
View File

@@ -0,0 +1,54 @@
/*
* Copyright 2009-2017 Alibaba Cloud 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.
*/
#ifndef ALIBABACLOUD_LIVE_MODEL_DESCRIBELIVESTREAMWATERMARKRULESREQUEST_H_
#define ALIBABACLOUD_LIVE_MODEL_DESCRIBELIVESTREAMWATERMARKRULESREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/live/LiveExport.h>
namespace AlibabaCloud
{
namespace Live
{
namespace Model
{
class ALIBABACLOUD_LIVE_EXPORT DescribeLiveStreamWatermarkRulesRequest : public RpcServiceRequest
{
public:
DescribeLiveStreamWatermarkRulesRequest();
~DescribeLiveStreamWatermarkRulesRequest();
int getPageNumber()const;
void setPageNumber(int pageNumber);
int getPageSize()const;
void setPageSize(int pageSize);
long getOwnerId()const;
void setOwnerId(long ownerId);
private:
int pageNumber_;
int pageSize_;
long ownerId_;
};
}
}
}
#endif // !ALIBABACLOUD_LIVE_MODEL_DESCRIBELIVESTREAMWATERMARKRULESREQUEST_H_

61
live/include/alibabacloud/live/model/DescribeLiveStreamWatermarkRulesResult.h Normal file
View File

@@ -0,0 +1,61 @@
/*
* Copyright 2009-2017 Alibaba Cloud 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.
*/
#ifndef ALIBABACLOUD_LIVE_MODEL_DESCRIBELIVESTREAMWATERMARKRULESRESULT_H_
#define ALIBABACLOUD_LIVE_MODEL_DESCRIBELIVESTREAMWATERMARKRULESRESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/live/LiveExport.h>
namespace AlibabaCloud
{
namespace Live
{
namespace Model
{
class ALIBABACLOUD_LIVE_EXPORT DescribeLiveStreamWatermarkRulesResult : public ServiceResult
{
public:
struct RuleInfo
{
std::string app;
std::string description;
std::string ruleId;
std::string stream;
std::string domain;
std::string templateId;
std::string name;
};
DescribeLiveStreamWatermarkRulesResult();
explicit DescribeLiveStreamWatermarkRulesResult(const std::string &payload);
~DescribeLiveStreamWatermarkRulesResult();
std::vector<RuleInfo> getRuleInfoList()const;
protected:
void parse(const std::string &payload);
private:
std::vector<RuleInfo> ruleInfoList_;
};
}
}
}
#endif // !ALIBABACLOUD_LIVE_MODEL_DESCRIBELIVESTREAMWATERMARKRULESRESULT_H_

54
live/include/alibabacloud/live/model/DescribeLiveStreamWatermarksRequest.h Normal file
View File

@@ -0,0 +1,54 @@
/*
* Copyright 2009-2017 Alibaba Cloud 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.
*/
#ifndef ALIBABACLOUD_LIVE_MODEL_DESCRIBELIVESTREAMWATERMARKSREQUEST_H_
#define ALIBABACLOUD_LIVE_MODEL_DESCRIBELIVESTREAMWATERMARKSREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/live/LiveExport.h>
namespace AlibabaCloud
{
namespace Live
{
namespace Model
{
class ALIBABACLOUD_LIVE_EXPORT DescribeLiveStreamWatermarksRequest : public RpcServiceRequest
{
public:
DescribeLiveStreamWatermarksRequest();
~DescribeLiveStreamWatermarksRequest();
int getPageNumber()const;
void setPageNumber(int pageNumber);
int getPageSize()const;
void setPageSize(int pageSize);
long getOwnerId()const;
void setOwnerId(long ownerId);
private:
int pageNumber_;
int pageSize_;
long ownerId_;
};
}
}
}
#endif // !ALIBABACLOUD_LIVE_MODEL_DESCRIBELIVESTREAMWATERMARKSREQUEST_H_

66
live/include/alibabacloud/live/model/DescribeLiveStreamWatermarksResult.h Normal file
View File

@@ -0,0 +1,66 @@
/*
* Copyright 2009-2017 Alibaba Cloud 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.
*/
#ifndef ALIBABACLOUD_LIVE_MODEL_DESCRIBELIVESTREAMWATERMARKSRESULT_H_
#define ALIBABACLOUD_LIVE_MODEL_DESCRIBELIVESTREAMWATERMARKSRESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/live/LiveExport.h>
namespace AlibabaCloud
{
namespace Live
{
namespace Model
{
class ALIBABACLOUD_LIVE_EXPORT DescribeLiveStreamWatermarksResult : public ServiceResult
{
public:
struct Watermark
{
int refHeight;
int type;
int transparency;
std::string description;
std::string pictureUrl;
float yOffset;
int height;
std::string offsetCorner;
float xOffset;
int refWidth;
std::string templateId;
std::string name;
};
DescribeLiveStreamWatermarksResult();
explicit DescribeLiveStreamWatermarksResult(const std::string &payload);
~DescribeLiveStreamWatermarksResult();
std::vector<Watermark> getWatermarkList()const;
protected:
void parse(const std::string &payload);
private:
std::vector<Watermark> watermarkList_;
};
}
}
}
#endif // !ALIBABACLOUD_LIVE_MODEL_DESCRIBELIVESTREAMWATERMARKSRESULT_H_

7
live/include/alibabacloud/live/model/DescribeStudioLayoutsResult.h
View File

@@ -48,8 +48,14 @@ namespace AlibabaCloud
};
struct ScreenInputConfig
{
struct AudioConfig
{
std::string validChannel;
float volumeRate;
};
std::string positionY;
std::string color;
AudioConfig audioConfig;
float heightNormalized;
int portraitType;
int index;
@@ -57,6 +63,7 @@ namespace AlibabaCloud
std::string channelId;
std::string videoResourceId;
std::string positionX;
bool onlyAudio;
};
struct MediaInputConfig
{

51
live/include/alibabacloud/live/model/QuerySnapshotCallbackAuthRequest.h Normal file
View File

@@ -0,0 +1,51 @@
/*
* Copyright 2009-2017 Alibaba Cloud 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.
*/
#ifndef ALIBABACLOUD_LIVE_MODEL_QUERYSNAPSHOTCALLBACKAUTHREQUEST_H_
#define ALIBABACLOUD_LIVE_MODEL_QUERYSNAPSHOTCALLBACKAUTHREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/live/LiveExport.h>
namespace AlibabaCloud
{
namespace Live
{
namespace Model
{
class ALIBABACLOUD_LIVE_EXPORT QuerySnapshotCallbackAuthRequest : public RpcServiceRequest
{
public:
QuerySnapshotCallbackAuthRequest();
~QuerySnapshotCallbackAuthRequest();
std::string getDomainName()const;
void setDomainName(const std::string& domainName);
long getOwnerId()const;
void setOwnerId(long ownerId);
private:
std::string domainName_;
long ownerId_;
};
}
}
}
#endif // !ALIBABACLOUD_LIVE_MODEL_QUERYSNAPSHOTCALLBACKAUTHREQUEST_H_

55
live/include/alibabacloud/live/model/QuerySnapshotCallbackAuthResult.h Normal file
View File

@@ -0,0 +1,55 @@
/*
* Copyright 2009-2017 Alibaba Cloud 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.
*/
#ifndef ALIBABACLOUD_LIVE_MODEL_QUERYSNAPSHOTCALLBACKAUTHRESULT_H_
#define ALIBABACLOUD_LIVE_MODEL_QUERYSNAPSHOTCALLBACKAUTHRESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/live/LiveExport.h>
namespace AlibabaCloud
{
namespace Live
{
namespace Model
{
class ALIBABACLOUD_LIVE_EXPORT QuerySnapshotCallbackAuthResult : public ServiceResult
{
public:
QuerySnapshotCallbackAuthResult();
explicit QuerySnapshotCallbackAuthResult(const std::string &payload);
~QuerySnapshotCallbackAuthResult();
std::string getCallbackAuthKey()const;
std::string getCallbackReqAuth()const;
std::string getDomainName()const;
protected:
void parse(const std::string &payload);
private:
std::string callbackAuthKey_;
std::string callbackReqAuth_;
std::string domainName_;
};
}
}
}
#endif // !ALIBABACLOUD_LIVE_MODEL_QUERYSNAPSHOTCALLBACKAUTHRESULT_H_

57
live/include/alibabacloud/live/model/SetSnapshotCallbackAuthRequest.h Normal file
View File

@@ -0,0 +1,57 @@
/*
* Copyright 2009-2017 Alibaba Cloud 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.
*/
#ifndef ALIBABACLOUD_LIVE_MODEL_SETSNAPSHOTCALLBACKAUTHREQUEST_H_
#define ALIBABACLOUD_LIVE_MODEL_SETSNAPSHOTCALLBACKAUTHREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/live/LiveExport.h>
namespace AlibabaCloud
{
namespace Live
{
namespace Model
{
class ALIBABACLOUD_LIVE_EXPORT SetSnapshotCallbackAuthRequest : public RpcServiceRequest
{
public:
SetSnapshotCallbackAuthRequest();
~SetSnapshotCallbackAuthRequest();
std::string getCallbackAuthKey()const;
void setCallbackAuthKey(const std::string& callbackAuthKey);
std::string getDomainName()const;
void setDomainName(const std::string& domainName);
long getOwnerId()const;
void setOwnerId(long ownerId);
std::string getCallbackReqAuth()const;
void setCallbackReqAuth(const std::string& callbackReqAuth);
private:
std::string callbackAuthKey_;
std::string domainName_;
long ownerId_;
std::string callbackReqAuth_;
};
}
}
}
#endif // !ALIBABACLOUD_LIVE_MODEL_SETSNAPSHOTCALLBACKAUTHREQUEST_H_

49
live/include/alibabacloud/live/model/SetSnapshotCallbackAuthResult.h Normal file
View File

@@ -0,0 +1,49 @@
/*
* Copyright 2009-2017 Alibaba Cloud 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.
*/
#ifndef ALIBABACLOUD_LIVE_MODEL_SETSNAPSHOTCALLBACKAUTHRESULT_H_
#define ALIBABACLOUD_LIVE_MODEL_SETSNAPSHOTCALLBACKAUTHRESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/live/LiveExport.h>
namespace AlibabaCloud
{
namespace Live
{
namespace Model
{
class ALIBABACLOUD_LIVE_EXPORT SetSnapshotCallbackAuthResult : public ServiceResult
{
public:
SetSnapshotCallbackAuthResult();
explicit SetSnapshotCallbackAuthResult(const std::string &payload);
~SetSnapshotCallbackAuthResult();
protected:
void parse(const std::string &payload);
private:
};
}
}
}
#endif // !ALIBABACLOUD_LIVE_MODEL_SETSNAPSHOTCALLBACKAUTHRESULT_H_

81
live/include/alibabacloud/live/model/UpdateLiveStreamWatermarkRequest.h Normal file
View File

@@ -0,0 +1,81 @@
/*
* Copyright 2009-2017 Alibaba Cloud 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.
*/
#ifndef ALIBABACLOUD_LIVE_MODEL_UPDATELIVESTREAMWATERMARKREQUEST_H_
#define ALIBABACLOUD_LIVE_MODEL_UPDATELIVESTREAMWATERMARKREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/live/LiveExport.h>
namespace AlibabaCloud
{
namespace Live
{
namespace Model
{
class ALIBABACLOUD_LIVE_EXPORT UpdateLiveStreamWatermarkRequest : public RpcServiceRequest
{
public:
UpdateLiveStreamWatermarkRequest();
~UpdateLiveStreamWatermarkRequest();
float getYOffset()const;
void setYOffset(float yOffset);
std::string getPictureUrl()const;
void setPictureUrl(const std::string& pictureUrl);
std::string getDescription()const;
void setDescription(const std::string& description);
int getHeight()const;
void setHeight(int height);
float getXOffset()const;
void setXOffset(float xOffset);
long getOwnerId()const;
void setOwnerId(long ownerId);
std::string getTemplateId()const;
void setTemplateId(const std::string& templateId);
int getRefWidth()const;
void setRefWidth(int refWidth);
int getTransparency()const;
void setTransparency(int transparency);
std::string getName()const;
void setName(const std::string& name);
std::string getOffsetCorner()const;
void setOffsetCorner(const std::string& offsetCorner);
int getRefHeight()const;
void setRefHeight(int refHeight);
private:
float yOffset_;
std::string pictureUrl_;
std::string description_;
int height_;
float xOffset_;
long ownerId_;
std::string templateId_;
int refWidth_;
int transparency_;
std::string name_;
std::string offsetCorner_;
int refHeight_;
};
}
}
}
#endif // !ALIBABACLOUD_LIVE_MODEL_UPDATELIVESTREAMWATERMARKREQUEST_H_

49
live/include/alibabacloud/live/model/UpdateLiveStreamWatermarkResult.h Normal file
View File

@@ -0,0 +1,49 @@
/*
* Copyright 2009-2017 Alibaba Cloud 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.
*/
#ifndef ALIBABACLOUD_LIVE_MODEL_UPDATELIVESTREAMWATERMARKRESULT_H_
#define ALIBABACLOUD_LIVE_MODEL_UPDATELIVESTREAMWATERMARKRESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/live/LiveExport.h>
namespace AlibabaCloud
{
namespace Live
{
namespace Model
{
class ALIBABACLOUD_LIVE_EXPORT UpdateLiveStreamWatermarkResult : public ServiceResult
{
public:
UpdateLiveStreamWatermarkResult();
explicit UpdateLiveStreamWatermarkResult(const std::string &payload);
~UpdateLiveStreamWatermarkResult();
protected:
void parse(const std::string &payload);
private:
};
}
}
}
#endif // !ALIBABACLOUD_LIVE_MODEL_UPDATELIVESTREAMWATERMARKRESULT_H_

60
live/include/alibabacloud/live/model/UpdateLiveStreamWatermarkRuleRequest.h Normal file
View File

@@ -0,0 +1,60 @@
/*
* Copyright 2009-2017 Alibaba Cloud 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.
*/
#ifndef ALIBABACLOUD_LIVE_MODEL_UPDATELIVESTREAMWATERMARKRULEREQUEST_H_
#define ALIBABACLOUD_LIVE_MODEL_UPDATELIVESTREAMWATERMARKRULEREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/live/LiveExport.h>
namespace AlibabaCloud
{
namespace Live
{
namespace Model
{
class ALIBABACLOUD_LIVE_EXPORT UpdateLiveStreamWatermarkRuleRequest : public RpcServiceRequest
{
public:
UpdateLiveStreamWatermarkRuleRequest();
~UpdateLiveStreamWatermarkRuleRequest();
std::string getDescription()const;
void setDescription(const std::string& description);
long getOwnerId()const;
void setOwnerId(long ownerId);
std::string getTemplateId()const;
void setTemplateId(const std::string& templateId);
std::string getName()const;
void setName(const std::string& name);
std::string getRuleId()const;
void setRuleId(const std::string& ruleId);
private:
std::string description_;
long ownerId_;
std::string templateId_;
std::string name_;
std::string ruleId_;
};
}
}
}
#endif // !ALIBABACLOUD_LIVE_MODEL_UPDATELIVESTREAMWATERMARKRULEREQUEST_H_

49
live/include/alibabacloud/live/model/UpdateLiveStreamWatermarkRuleResult.h Normal file
View File

@@ -0,0 +1,49 @@
/*
* Copyright 2009-2017 Alibaba Cloud 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.
*/
#ifndef ALIBABACLOUD_LIVE_MODEL_UPDATELIVESTREAMWATERMARKRULERESULT_H_
#define ALIBABACLOUD_LIVE_MODEL_UPDATELIVESTREAMWATERMARKRULERESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/live/LiveExport.h>
namespace AlibabaCloud
{
namespace Live
{
namespace Model
{
class ALIBABACLOUD_LIVE_EXPORT UpdateLiveStreamWatermarkRuleResult : public ServiceResult
{
public:
UpdateLiveStreamWatermarkRuleResult();
explicit UpdateLiveStreamWatermarkRuleResult(const std::string &payload);
~UpdateLiveStreamWatermarkRuleResult();
protected:
void parse(const std::string &payload);
private:
};
}
}
}
#endif // !ALIBABACLOUD_LIVE_MODEL_UPDATELIVESTREAMWATERMARKRULERESULT_H_

396
live/src/LiveClient.cc
View File

@@ -879,6 +879,78 @@ LiveClient::AddLiveStreamTranscodeOutcomeCallable LiveClient::addLiveStreamTrans
return task->get_future();
}
LiveClient::AddLiveStreamWatermarkOutcome LiveClient::addLiveStreamWatermark(const AddLiveStreamWatermarkRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return AddLiveStreamWatermarkOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return AddLiveStreamWatermarkOutcome(AddLiveStreamWatermarkResult(outcome.result()));
else
return AddLiveStreamWatermarkOutcome(outcome.error());
}
void LiveClient::addLiveStreamWatermarkAsync(const AddLiveStreamWatermarkRequest& request, const AddLiveStreamWatermarkAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, addLiveStreamWatermark(request), context);
};
asyncExecute(new Runnable(fn));
}
LiveClient::AddLiveStreamWatermarkOutcomeCallable LiveClient::addLiveStreamWatermarkCallable(const AddLiveStreamWatermarkRequest &request) const
{
auto task = std::make_shared<std::packaged_task<AddLiveStreamWatermarkOutcome()>>(
[this, request]()
{
return this->addLiveStreamWatermark(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
LiveClient::AddLiveStreamWatermarkRuleOutcome LiveClient::addLiveStreamWatermarkRule(const AddLiveStreamWatermarkRuleRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return AddLiveStreamWatermarkRuleOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return AddLiveStreamWatermarkRuleOutcome(AddLiveStreamWatermarkRuleResult(outcome.result()));
else
return AddLiveStreamWatermarkRuleOutcome(outcome.error());
}
void LiveClient::addLiveStreamWatermarkRuleAsync(const AddLiveStreamWatermarkRuleRequest& request, const AddLiveStreamWatermarkRuleAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, addLiveStreamWatermarkRule(request), context);
};
asyncExecute(new Runnable(fn));
}
LiveClient::AddLiveStreamWatermarkRuleOutcomeCallable LiveClient::addLiveStreamWatermarkRuleCallable(const AddLiveStreamWatermarkRuleRequest &request) const
{
auto task = std::make_shared<std::packaged_task<AddLiveStreamWatermarkRuleOutcome()>>(
[this, request]()
{
return this->addLiveStreamWatermarkRule(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
LiveClient::AddMultiRateConfigOutcome LiveClient::addMultiRateConfig(const AddMultiRateConfigRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -2931,6 +3003,78 @@ LiveClient::DeleteLiveStreamTranscodeOutcomeCallable LiveClient::deleteLiveStrea
return task->get_future();
}
LiveClient::DeleteLiveStreamWatermarkOutcome LiveClient::deleteLiveStreamWatermark(const DeleteLiveStreamWatermarkRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return DeleteLiveStreamWatermarkOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return DeleteLiveStreamWatermarkOutcome(DeleteLiveStreamWatermarkResult(outcome.result()));
else
return DeleteLiveStreamWatermarkOutcome(outcome.error());
}
void LiveClient::deleteLiveStreamWatermarkAsync(const DeleteLiveStreamWatermarkRequest& request, const DeleteLiveStreamWatermarkAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, deleteLiveStreamWatermark(request), context);
};
asyncExecute(new Runnable(fn));
}
LiveClient::DeleteLiveStreamWatermarkOutcomeCallable LiveClient::deleteLiveStreamWatermarkCallable(const DeleteLiveStreamWatermarkRequest &request) const
{
auto task = std::make_shared<std::packaged_task<DeleteLiveStreamWatermarkOutcome()>>(
[this, request]()
{
return this->deleteLiveStreamWatermark(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
LiveClient::DeleteLiveStreamWatermarkRuleOutcome LiveClient::deleteLiveStreamWatermarkRule(const DeleteLiveStreamWatermarkRuleRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return DeleteLiveStreamWatermarkRuleOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return DeleteLiveStreamWatermarkRuleOutcome(DeleteLiveStreamWatermarkRuleResult(outcome.result()));
else
return DeleteLiveStreamWatermarkRuleOutcome(outcome.error());
}
void LiveClient::deleteLiveStreamWatermarkRuleAsync(const DeleteLiveStreamWatermarkRuleRequest& request, const DeleteLiveStreamWatermarkRuleAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, deleteLiveStreamWatermarkRule(request), context);
};
asyncExecute(new Runnable(fn));
}
LiveClient::DeleteLiveStreamWatermarkRuleOutcomeCallable LiveClient::deleteLiveStreamWatermarkRuleCallable(const DeleteLiveStreamWatermarkRuleRequest &request) const
{
auto task = std::make_shared<std::packaged_task<DeleteLiveStreamWatermarkRuleOutcome()>>(
[this, request]()
{
return this->deleteLiveStreamWatermarkRule(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
LiveClient::DeleteLiveStreamsNotifyUrlConfigOutcome LiveClient::deleteLiveStreamsNotifyUrlConfig(const DeleteLiveStreamsNotifyUrlConfigRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -3147,6 +3291,42 @@ LiveClient::DeleteRoomOutcomeCallable LiveClient::deleteRoomCallable(const Delet
return task->get_future();
}
LiveClient::DeleteSnapshotCallbackAuthOutcome LiveClient::deleteSnapshotCallbackAuth(const DeleteSnapshotCallbackAuthRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return DeleteSnapshotCallbackAuthOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return DeleteSnapshotCallbackAuthOutcome(DeleteSnapshotCallbackAuthResult(outcome.result()));
else
return DeleteSnapshotCallbackAuthOutcome(outcome.error());
}
void LiveClient::deleteSnapshotCallbackAuthAsync(const DeleteSnapshotCallbackAuthRequest& request, const DeleteSnapshotCallbackAuthAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, deleteSnapshotCallbackAuth(request), context);
};
asyncExecute(new Runnable(fn));
}
LiveClient::DeleteSnapshotCallbackAuthOutcomeCallable LiveClient::deleteSnapshotCallbackAuthCallable(const DeleteSnapshotCallbackAuthRequest &request) const
{
auto task = std::make_shared<std::packaged_task<DeleteSnapshotCallbackAuthOutcome()>>(
[this, request]()
{
return this->deleteSnapshotCallbackAuth(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
LiveClient::DeleteStudioLayoutOutcome LiveClient::deleteStudioLayout(const DeleteStudioLayoutRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -6099,6 +6279,78 @@ LiveClient::DescribeLiveStreamTranscodeStreamNumOutcomeCallable LiveClient::desc
return task->get_future();
}
LiveClient::DescribeLiveStreamWatermarkRulesOutcome LiveClient::describeLiveStreamWatermarkRules(const DescribeLiveStreamWatermarkRulesRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return DescribeLiveStreamWatermarkRulesOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return DescribeLiveStreamWatermarkRulesOutcome(DescribeLiveStreamWatermarkRulesResult(outcome.result()));
else
return DescribeLiveStreamWatermarkRulesOutcome(outcome.error());
}
void LiveClient::describeLiveStreamWatermarkRulesAsync(const DescribeLiveStreamWatermarkRulesRequest& request, const DescribeLiveStreamWatermarkRulesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, describeLiveStreamWatermarkRules(request), context);
};
asyncExecute(new Runnable(fn));
}
LiveClient::DescribeLiveStreamWatermarkRulesOutcomeCallable LiveClient::describeLiveStreamWatermarkRulesCallable(const DescribeLiveStreamWatermarkRulesRequest &request) const
{
auto task = std::make_shared<std::packaged_task<DescribeLiveStreamWatermarkRulesOutcome()>>(
[this, request]()
{
return this->describeLiveStreamWatermarkRules(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
LiveClient::DescribeLiveStreamWatermarksOutcome LiveClient::describeLiveStreamWatermarks(const DescribeLiveStreamWatermarksRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return DescribeLiveStreamWatermarksOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return DescribeLiveStreamWatermarksOutcome(DescribeLiveStreamWatermarksResult(outcome.result()));
else
return DescribeLiveStreamWatermarksOutcome(outcome.error());
}
void LiveClient::describeLiveStreamWatermarksAsync(const DescribeLiveStreamWatermarksRequest& request, const DescribeLiveStreamWatermarksAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, describeLiveStreamWatermarks(request), context);
};
asyncExecute(new Runnable(fn));
}
LiveClient::DescribeLiveStreamWatermarksOutcomeCallable LiveClient::describeLiveStreamWatermarksCallable(const DescribeLiveStreamWatermarksRequest &request) const
{
auto task = std::make_shared<std::packaged_task<DescribeLiveStreamWatermarksOutcome()>>(
[this, request]()
{
return this->describeLiveStreamWatermarks(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
LiveClient::DescribeLiveStreamsBlockListOutcome LiveClient::describeLiveStreamsBlockList(const DescribeLiveStreamsBlockListRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -8043,6 +8295,42 @@ LiveClient::PublishLiveStagingConfigToProductionOutcomeCallable LiveClient::publ
return task->get_future();
}
LiveClient::QuerySnapshotCallbackAuthOutcome LiveClient::querySnapshotCallbackAuth(const QuerySnapshotCallbackAuthRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return QuerySnapshotCallbackAuthOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return QuerySnapshotCallbackAuthOutcome(QuerySnapshotCallbackAuthResult(outcome.result()));
else
return QuerySnapshotCallbackAuthOutcome(outcome.error());
}
void LiveClient::querySnapshotCallbackAuthAsync(const QuerySnapshotCallbackAuthRequest& request, const QuerySnapshotCallbackAuthAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, querySnapshotCallbackAuth(request), context);
};
asyncExecute(new Runnable(fn));
}
LiveClient::QuerySnapshotCallbackAuthOutcomeCallable LiveClient::querySnapshotCallbackAuthCallable(const QuerySnapshotCallbackAuthRequest &request) const
{
auto task = std::make_shared<std::packaged_task<QuerySnapshotCallbackAuthOutcome()>>(
[this, request]()
{
return this->querySnapshotCallbackAuth(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
LiveClient::RealTimeRecordCommandOutcome LiveClient::realTimeRecordCommand(const RealTimeRecordCommandRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -8727,6 +9015,42 @@ LiveClient::SetLiveStreamsNotifyUrlConfigOutcomeCallable LiveClient::setLiveStre
return task->get_future();
}
LiveClient::SetSnapshotCallbackAuthOutcome LiveClient::setSnapshotCallbackAuth(const SetSnapshotCallbackAuthRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return SetSnapshotCallbackAuthOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return SetSnapshotCallbackAuthOutcome(SetSnapshotCallbackAuthResult(outcome.result()));
else
return SetSnapshotCallbackAuthOutcome(outcome.error());
}
void LiveClient::setSnapshotCallbackAuthAsync(const SetSnapshotCallbackAuthRequest& request, const SetSnapshotCallbackAuthAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, setSnapshotCallbackAuth(request), context);
};
asyncExecute(new Runnable(fn));
}
LiveClient::SetSnapshotCallbackAuthOutcomeCallable LiveClient::setSnapshotCallbackAuthCallable(const SetSnapshotCallbackAuthRequest &request) const
{
auto task = std::make_shared<std::packaged_task<SetSnapshotCallbackAuthOutcome()>>(
[this, request]()
{
return this->setSnapshotCallbackAuth(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
LiveClient::StartBoardRecordOutcome LiveClient::startBoardRecord(const StartBoardRecordRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -9735,6 +10059,78 @@ LiveClient::UpdateLiveStreamMonitorOutcomeCallable LiveClient::updateLiveStreamM
return task->get_future();
}
LiveClient::UpdateLiveStreamWatermarkOutcome LiveClient::updateLiveStreamWatermark(const UpdateLiveStreamWatermarkRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return UpdateLiveStreamWatermarkOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return UpdateLiveStreamWatermarkOutcome(UpdateLiveStreamWatermarkResult(outcome.result()));
else
return UpdateLiveStreamWatermarkOutcome(outcome.error());
}
void LiveClient::updateLiveStreamWatermarkAsync(const UpdateLiveStreamWatermarkRequest& request, const UpdateLiveStreamWatermarkAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, updateLiveStreamWatermark(request), context);
};
asyncExecute(new Runnable(fn));
}
LiveClient::UpdateLiveStreamWatermarkOutcomeCallable LiveClient::updateLiveStreamWatermarkCallable(const UpdateLiveStreamWatermarkRequest &request) const
{
auto task = std::make_shared<std::packaged_task<UpdateLiveStreamWatermarkOutcome()>>(
[this, request]()
{
return this->updateLiveStreamWatermark(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
LiveClient::UpdateLiveStreamWatermarkRuleOutcome LiveClient::updateLiveStreamWatermarkRule(const UpdateLiveStreamWatermarkRuleRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return UpdateLiveStreamWatermarkRuleOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return UpdateLiveStreamWatermarkRuleOutcome(UpdateLiveStreamWatermarkRuleResult(outcome.result()));
else
return UpdateLiveStreamWatermarkRuleOutcome(outcome.error());
}
void LiveClient::updateLiveStreamWatermarkRuleAsync(const UpdateLiveStreamWatermarkRuleRequest& request, const UpdateLiveStreamWatermarkRuleAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, updateLiveStreamWatermarkRule(request), context);
};
asyncExecute(new Runnable(fn));
}
LiveClient::UpdateLiveStreamWatermarkRuleOutcomeCallable LiveClient::updateLiveStreamWatermarkRuleCallable(const UpdateLiveStreamWatermarkRuleRequest &request) const
{
auto task = std::make_shared<std::packaged_task<UpdateLiveStreamWatermarkRuleOutcome()>>(
[this, request]()
{
return this->updateLiveStreamWatermarkRule(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
LiveClient::UpdateLiveTopLevelDomainOutcome LiveClient::updateLiveTopLevelDomain(const UpdateLiveTopLevelDomainRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();

161
live/src/model/AddLiveStreamWatermarkRequest.cc Normal file
View File

@@ -0,0 +1,161 @@
/*
* Copyright 2009-2017 Alibaba Cloud 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.
*/
#include <alibabacloud/live/model/AddLiveStreamWatermarkRequest.h>
using AlibabaCloud::Live::Model::AddLiveStreamWatermarkRequest;
AddLiveStreamWatermarkRequest::AddLiveStreamWatermarkRequest() :
RpcServiceRequest("live", "2016-11-01", "AddLiveStreamWatermark")
{
setMethod(HttpRequest::Method::Post);
}
AddLiveStreamWatermarkRequest::~AddLiveStreamWatermarkRequest()
{}
float AddLiveStreamWatermarkRequest::getYOffset()const
{
return yOffset_;
}
void AddLiveStreamWatermarkRequest::setYOffset(float yOffset)
{
yOffset_ = yOffset;
setParameter("YOffset", std::to_string(yOffset));
}
std::string AddLiveStreamWatermarkRequest::getPictureUrl()const
{
return pictureUrl_;
}
void AddLiveStreamWatermarkRequest::setPictureUrl(const std::string& pictureUrl)
{
pictureUrl_ = pictureUrl;
setParameter("PictureUrl", pictureUrl);
}
std::string AddLiveStreamWatermarkRequest::getDescription()const
{
return description_;
}
void AddLiveStreamWatermarkRequest::setDescription(const std::string& description)
{
description_ = description;
setParameter("Description", description);
}
int AddLiveStreamWatermarkRequest::getType()const
{
return type_;
}
void AddLiveStreamWatermarkRequest::setType(int type)
{
type_ = type;
setParameter("Type", std::to_string(type));
}
int AddLiveStreamWatermarkRequest::getHeight()const
{
return height_;
}
void AddLiveStreamWatermarkRequest::setHeight(int height)
{
height_ = height;
setParameter("Height", std::to_string(height));
}
float AddLiveStreamWatermarkRequest::getXOffset()const
{
return xOffset_;
}
void AddLiveStreamWatermarkRequest::setXOffset(float xOffset)
{
xOffset_ = xOffset;
setParameter("XOffset", std::to_string(xOffset));
}
long AddLiveStreamWatermarkRequest::getOwnerId()const
{
return ownerId_;
}
void AddLiveStreamWatermarkRequest::setOwnerId(long ownerId)
{
ownerId_ = ownerId;
setParameter("OwnerId", std::to_string(ownerId));
}
int AddLiveStreamWatermarkRequest::getRefWidth()const
{
return refWidth_;
}
void AddLiveStreamWatermarkRequest::setRefWidth(int refWidth)
{
refWidth_ = refWidth;
setParameter("RefWidth", std::to_string(refWidth));
}
int AddLiveStreamWatermarkRequest::getTransparency()const
{
return transparency_;
}
void AddLiveStreamWatermarkRequest::setTransparency(int transparency)
{
transparency_ = transparency;
setParameter("Transparency", std::to_string(transparency));
}
std::string AddLiveStreamWatermarkRequest::getName()const
{
return name_;
}
void AddLiveStreamWatermarkRequest::setName(const std::string& name)
{
name_ = name;
setParameter("Name", name);
}
std::string AddLiveStreamWatermarkRequest::getOffsetCorner()const
{
return offsetCorner_;
}
void AddLiveStreamWatermarkRequest::setOffsetCorner(const std::string& offsetCorner)
{
offsetCorner_ = offsetCorner;
setParameter("OffsetCorner", offsetCorner);
}
int AddLiveStreamWatermarkRequest::getRefHeight()const
{
return refHeight_;
}
void AddLiveStreamWatermarkRequest::setRefHeight(int refHeight)
{
refHeight_ = refHeight;
setParameter("RefHeight", std::to_string(refHeight));
}

51
live/src/model/AddLiveStreamWatermarkResult.cc Normal file
View File

@@ -0,0 +1,51 @@
/*
* Copyright 2009-2017 Alibaba Cloud 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.
*/
#include <alibabacloud/live/model/AddLiveStreamWatermarkResult.h>
#include <json/json.h>
using namespace AlibabaCloud::Live;
using namespace AlibabaCloud::Live::Model;
AddLiveStreamWatermarkResult::AddLiveStreamWatermarkResult() :
ServiceResult()
{}
AddLiveStreamWatermarkResult::AddLiveStreamWatermarkResult(const std::string &payload) :
ServiceResult()
{
parse(payload);
}
AddLiveStreamWatermarkResult::~AddLiveStreamWatermarkResult()
{}
void AddLiveStreamWatermarkResult::parse(const std::string &payload)
{
Json::Reader reader;
Json::Value value;
reader.parse(payload, value);
setRequestId(value["RequestId"].asString());
if(!value["TemplateId"].isNull())
templateId_ = value["TemplateId"].asString();
}
std::string AddLiveStreamWatermarkResult::getTemplateId()const
{
return templateId_;
}

106
live/src/model/AddLiveStreamWatermarkRuleRequest.cc Normal file
View File

@@ -0,0 +1,106 @@
/*
* Copyright 2009-2017 Alibaba Cloud 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.
*/
#include <alibabacloud/live/model/AddLiveStreamWatermarkRuleRequest.h>
using AlibabaCloud::Live::Model::AddLiveStreamWatermarkRuleRequest;
AddLiveStreamWatermarkRuleRequest::AddLiveStreamWatermarkRuleRequest() :
RpcServiceRequest("live", "2016-11-01", "AddLiveStreamWatermarkRule")
{
setMethod(HttpRequest::Method::Post);
}
AddLiveStreamWatermarkRuleRequest::~AddLiveStreamWatermarkRuleRequest()
{}
std::string AddLiveStreamWatermarkRuleRequest::getDescription()const
{
return description_;
}
void AddLiveStreamWatermarkRuleRequest::setDescription(const std::string& description)
{
description_ = description;
setParameter("Description", description);
}
std::string AddLiveStreamWatermarkRuleRequest::getStream()const
{
return stream_;
}
void AddLiveStreamWatermarkRuleRequest::setStream(const std::string& stream)
{
stream_ = stream;
setParameter("Stream", stream);
}
std::string AddLiveStreamWatermarkRuleRequest::getApp()const
{
return app_;
}
void AddLiveStreamWatermarkRuleRequest::setApp(const std::string& app)
{
app_ = app;
setParameter("App", app);
}
long AddLiveStreamWatermarkRuleRequest::getOwnerId()const
{
return ownerId_;
}
void AddLiveStreamWatermarkRuleRequest::setOwnerId(long ownerId)
{
ownerId_ = ownerId;
setParameter("OwnerId", std::to_string(ownerId));
}
std::string AddLiveStreamWatermarkRuleRequest::getTemplateId()const
{
return templateId_;
}
void AddLiveStreamWatermarkRuleRequest::setTemplateId(const std::string& templateId)
{
templateId_ = templateId;
setParameter("TemplateId", templateId);
}
std::string AddLiveStreamWatermarkRuleRequest::getDomain()const
{
return domain_;
}
void AddLiveStreamWatermarkRuleRequest::setDomain(const std::string& domain)
{
domain_ = domain;
setParameter("Domain", domain);
}
std::string AddLiveStreamWatermarkRuleRequest::getName()const
{
return name_;
}
void AddLiveStreamWatermarkRuleRequest::setName(const std::string& name)
{
name_ = name;
setParameter("Name", name);
}

51
live/src/model/AddLiveStreamWatermarkRuleResult.cc Normal file
View File

@@ -0,0 +1,51 @@
/*
* Copyright 2009-2017 Alibaba Cloud 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.
*/
#include <alibabacloud/live/model/AddLiveStreamWatermarkRuleResult.h>
#include <json/json.h>
using namespace AlibabaCloud::Live;
using namespace AlibabaCloud::Live::Model;
AddLiveStreamWatermarkRuleResult::AddLiveStreamWatermarkRuleResult() :
ServiceResult()
{}
AddLiveStreamWatermarkRuleResult::AddLiveStreamWatermarkRuleResult(const std::string &payload) :
ServiceResult()
{
parse(payload);
}
AddLiveStreamWatermarkRuleResult::~AddLiveStreamWatermarkRuleResult()
{}
void AddLiveStreamWatermarkRuleResult::parse(const std::string &payload)
{
Json::Reader reader;
Json::Value value;
reader.parse(payload, value);
setRequestId(value["RequestId"].asString());
if(!value["RuleId"].isNull())
ruleId_ = value["RuleId"].asString();
}
std::string AddLiveStreamWatermarkRuleResult::getRuleId()const
{
return ruleId_;
}

51
live/src/model/DeleteLiveStreamWatermarkRequest.cc Normal file
View File

@@ -0,0 +1,51 @@
/*
* Copyright 2009-2017 Alibaba Cloud 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.
*/
#include <alibabacloud/live/model/DeleteLiveStreamWatermarkRequest.h>
using AlibabaCloud::Live::Model::DeleteLiveStreamWatermarkRequest;
DeleteLiveStreamWatermarkRequest::DeleteLiveStreamWatermarkRequest() :
RpcServiceRequest("live", "2016-11-01", "DeleteLiveStreamWatermark")
{
setMethod(HttpRequest::Method::Post);
}
DeleteLiveStreamWatermarkRequest::~DeleteLiveStreamWatermarkRequest()
{}
long DeleteLiveStreamWatermarkRequest::getOwnerId()const
{
return ownerId_;
}
void DeleteLiveStreamWatermarkRequest::setOwnerId(long ownerId)
{
ownerId_ = ownerId;
setParameter("OwnerId", std::to_string(ownerId));
}
std::string DeleteLiveStreamWatermarkRequest::getTemplateId()const
{
return templateId_;
}
void DeleteLiveStreamWatermarkRequest::setTemplateId(const std::string& templateId)
{
templateId_ = templateId;
setParameter("TemplateId", templateId);
}

44
live/src/model/DeleteLiveStreamWatermarkResult.cc Normal file
View File

@@ -0,0 +1,44 @@
/*
* Copyright 2009-2017 Alibaba Cloud 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.
*/
#include <alibabacloud/live/model/DeleteLiveStreamWatermarkResult.h>
#include <json/json.h>
using namespace AlibabaCloud::Live;
using namespace AlibabaCloud::Live::Model;
DeleteLiveStreamWatermarkResult::DeleteLiveStreamWatermarkResult() :
ServiceResult()
{}
DeleteLiveStreamWatermarkResult::DeleteLiveStreamWatermarkResult(const std::string &payload) :
ServiceResult()
{
parse(payload);
}
DeleteLiveStreamWatermarkResult::~DeleteLiveStreamWatermarkResult()
{}
void DeleteLiveStreamWatermarkResult::parse(const std::string &payload)
{
Json::Reader reader;
Json::Value value;
reader.parse(payload, value);
setRequestId(value["RequestId"].asString());
}

84
live/src/model/DeleteLiveStreamWatermarkRuleRequest.cc Normal file
View File

@@ -0,0 +1,84 @@
/*
* Copyright 2009-2017 Alibaba Cloud 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.
*/
#include <alibabacloud/live/model/DeleteLiveStreamWatermarkRuleRequest.h>
using AlibabaCloud::Live::Model::DeleteLiveStreamWatermarkRuleRequest;
DeleteLiveStreamWatermarkRuleRequest::DeleteLiveStreamWatermarkRuleRequest() :
RpcServiceRequest("live", "2016-11-01", "DeleteLiveStreamWatermarkRule")
{
setMethod(HttpRequest::Method::Post);
}
DeleteLiveStreamWatermarkRuleRequest::~DeleteLiveStreamWatermarkRuleRequest()
{}
std::string DeleteLiveStreamWatermarkRuleRequest::getStream()const
{
return stream_;
}
void DeleteLiveStreamWatermarkRuleRequest::setStream(const std::string& stream)
{
stream_ = stream;
setParameter("Stream", stream);
}
std::string DeleteLiveStreamWatermarkRuleRequest::getApp()const
{
return app_;
}
void DeleteLiveStreamWatermarkRuleRequest::setApp(const std::string& app)
{
app_ = app;
setParameter("App", app);
}
long DeleteLiveStreamWatermarkRuleRequest::getOwnerId()const
{
return ownerId_;
}
void DeleteLiveStreamWatermarkRuleRequest::setOwnerId(long ownerId)
{
ownerId_ = ownerId;
setParameter("OwnerId", std::to_string(ownerId));
}
std::string DeleteLiveStreamWatermarkRuleRequest::getDomain()const
{
return domain_;
}
void DeleteLiveStreamWatermarkRuleRequest::setDomain(const std::string& domain)
{
domain_ = domain;
setParameter("Domain", domain);
}
std::string DeleteLiveStreamWatermarkRuleRequest::getRuleId()const
{
return ruleId_;
}
void DeleteLiveStreamWatermarkRuleRequest::setRuleId(const std::string& ruleId)
{
ruleId_ = ruleId;
setParameter("RuleId", ruleId);
}

44
live/src/model/DeleteLiveStreamWatermarkRuleResult.cc Normal file
View File

@@ -0,0 +1,44 @@
/*
* Copyright 2009-2017 Alibaba Cloud 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.
*/
#include <alibabacloud/live/model/DeleteLiveStreamWatermarkRuleResult.h>
#include <json/json.h>
using namespace AlibabaCloud::Live;
using namespace AlibabaCloud::Live::Model;
DeleteLiveStreamWatermarkRuleResult::DeleteLiveStreamWatermarkRuleResult() :
ServiceResult()
{}
DeleteLiveStreamWatermarkRuleResult::DeleteLiveStreamWatermarkRuleResult(const std::string &payload) :
ServiceResult()
{
parse(payload);
}
DeleteLiveStreamWatermarkRuleResult::~DeleteLiveStreamWatermarkRuleResult()
{}
void DeleteLiveStreamWatermarkRuleResult::parse(const std::string &payload)
{
Json::Reader reader;
Json::Value value;
reader.parse(payload, value);
setRequestId(value["RequestId"].asString());
}

51
live/src/model/DeleteSnapshotCallbackAuthRequest.cc Normal file
View File

@@ -0,0 +1,51 @@
/*
* Copyright 2009-2017 Alibaba Cloud 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.
*/
#include <alibabacloud/live/model/DeleteSnapshotCallbackAuthRequest.h>
using AlibabaCloud::Live::Model::DeleteSnapshotCallbackAuthRequest;
DeleteSnapshotCallbackAuthRequest::DeleteSnapshotCallbackAuthRequest() :
RpcServiceRequest("live", "2016-11-01", "DeleteSnapshotCallbackAuth")
{
setMethod(HttpRequest::Method::Post);
}
DeleteSnapshotCallbackAuthRequest::~DeleteSnapshotCallbackAuthRequest()
{}
std::string DeleteSnapshotCallbackAuthRequest::getDomainName()const
{
return domainName_;
}
void DeleteSnapshotCallbackAuthRequest::setDomainName(const std::string& domainName)
{
domainName_ = domainName;
setParameter("DomainName", domainName);
}
long DeleteSnapshotCallbackAuthRequest::getOwnerId()const
{
return ownerId_;
}
void DeleteSnapshotCallbackAuthRequest::setOwnerId(long ownerId)
{
ownerId_ = ownerId;
setParameter("OwnerId", std::to_string(ownerId));
}

44
live/src/model/DeleteSnapshotCallbackAuthResult.cc Normal file
View File

@@ -0,0 +1,44 @@
/*
* Copyright 2009-2017 Alibaba Cloud 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.
*/
#include <alibabacloud/live/model/DeleteSnapshotCallbackAuthResult.h>
#include <json/json.h>
using namespace AlibabaCloud::Live;
using namespace AlibabaCloud::Live::Model;
DeleteSnapshotCallbackAuthResult::DeleteSnapshotCallbackAuthResult() :
ServiceResult()
{}
DeleteSnapshotCallbackAuthResult::DeleteSnapshotCallbackAuthResult(const std::string &payload) :
ServiceResult()
{
parse(payload);
}
DeleteSnapshotCallbackAuthResult::~DeleteSnapshotCallbackAuthResult()
{}
void DeleteSnapshotCallbackAuthResult::parse(const std::string &payload)
{
Json::Reader reader;
Json::Value value;
reader.parse(payload, value);
setRequestId(value["RequestId"].asString());
}

8
live/src/model/DescribeDomainWithIntegrityResult.cc
View File

@@ -39,12 +39,12 @@ void DescribeDomainWithIntegrityResult::parse(const std::string &payload)
Json::Value value;
reader.parse(payload, value);
setRequestId(value["RequestId"].asString());
auto allContentNode = value["Content"]["ContentItem"];
for (auto valueContentContentItem : allContentNode)
auto allContentNode = value["Content"]["contentItem"];
for (auto valueContentcontentItem : allContentNode)
{
ContentItem contentObject;
if(!valueContentContentItem["Name"].isNull())
contentObject.name = valueContentContentItem["Name"].asString();
if(!valueContentcontentItem["Name"].isNull())
contentObject.name = valueContentcontentItem["Name"].asString();
auto allColumns = value["Columns"]["columns"];
for (auto value : allColumns)
contentObject.columns.push_back(value.asString());

62
live/src/model/DescribeLiveStreamWatermarkRulesRequest.cc Normal file
View File

@@ -0,0 +1,62 @@
/*
* Copyright 2009-2017 Alibaba Cloud 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.
*/
#include <alibabacloud/live/model/DescribeLiveStreamWatermarkRulesRequest.h>
using AlibabaCloud::Live::Model::DescribeLiveStreamWatermarkRulesRequest;
DescribeLiveStreamWatermarkRulesRequest::DescribeLiveStreamWatermarkRulesRequest() :
RpcServiceRequest("live", "2016-11-01", "DescribeLiveStreamWatermarkRules")
{
setMethod(HttpRequest::Method::Post);
}
DescribeLiveStreamWatermarkRulesRequest::~DescribeLiveStreamWatermarkRulesRequest()
{}
int DescribeLiveStreamWatermarkRulesRequest::getPageNumber()const
{
return pageNumber_;
}
void DescribeLiveStreamWatermarkRulesRequest::setPageNumber(int pageNumber)
{
pageNumber_ = pageNumber;
setParameter("PageNumber", std::to_string(pageNumber));
}
int DescribeLiveStreamWatermarkRulesRequest::getPageSize()const
{
return pageSize_;
}
void DescribeLiveStreamWatermarkRulesRequest::setPageSize(int pageSize)
{
pageSize_ = pageSize;
setParameter("PageSize", std::to_string(pageSize));
}
long DescribeLiveStreamWatermarkRulesRequest::getOwnerId()const
{
return ownerId_;
}
void DescribeLiveStreamWatermarkRulesRequest::setOwnerId(long ownerId)
{
ownerId_ = ownerId;
setParameter("OwnerId", std::to_string(ownerId));
}

69
live/src/model/DescribeLiveStreamWatermarkRulesResult.cc Normal file
View File

@@ -0,0 +1,69 @@
/*
* Copyright 2009-2017 Alibaba Cloud 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.
*/
#include <alibabacloud/live/model/DescribeLiveStreamWatermarkRulesResult.h>
#include <json/json.h>
using namespace AlibabaCloud::Live;
using namespace AlibabaCloud::Live::Model;
DescribeLiveStreamWatermarkRulesResult::DescribeLiveStreamWatermarkRulesResult() :
ServiceResult()
{}
DescribeLiveStreamWatermarkRulesResult::DescribeLiveStreamWatermarkRulesResult(const std::string &payload) :
ServiceResult()
{
parse(payload);
}
DescribeLiveStreamWatermarkRulesResult::~DescribeLiveStreamWatermarkRulesResult()
{}
void DescribeLiveStreamWatermarkRulesResult::parse(const std::string &payload)
{
Json::Reader reader;
Json::Value value;
reader.parse(payload, value);
setRequestId(value["RequestId"].asString());
auto allRuleInfoListNode = value["RuleInfoList"]["RuleInfo"];
for (auto valueRuleInfoListRuleInfo : allRuleInfoListNode)
{
RuleInfo ruleInfoListObject;
if(!valueRuleInfoListRuleInfo["RuleId"].isNull())
ruleInfoListObject.ruleId = valueRuleInfoListRuleInfo["RuleId"].asString();
if(!valueRuleInfoListRuleInfo["Name"].isNull())
ruleInfoListObject.name = valueRuleInfoListRuleInfo["Name"].asString();
if(!valueRuleInfoListRuleInfo["Domain"].isNull())
ruleInfoListObject.domain = valueRuleInfoListRuleInfo["Domain"].asString();
if(!valueRuleInfoListRuleInfo["App"].isNull())
ruleInfoListObject.app = valueRuleInfoListRuleInfo["App"].asString();
if(!valueRuleInfoListRuleInfo["Stream"].isNull())
ruleInfoListObject.stream = valueRuleInfoListRuleInfo["Stream"].asString();
if(!valueRuleInfoListRuleInfo["TemplateId"].isNull())
ruleInfoListObject.templateId = valueRuleInfoListRuleInfo["TemplateId"].asString();
if(!valueRuleInfoListRuleInfo["Description"].isNull())
ruleInfoListObject.description = valueRuleInfoListRuleInfo["Description"].asString();
ruleInfoList_.push_back(ruleInfoListObject);
}
}
std::vector<DescribeLiveStreamWatermarkRulesResult::RuleInfo> DescribeLiveStreamWatermarkRulesResult::getRuleInfoList()const
{
return ruleInfoList_;
}

62
live/src/model/DescribeLiveStreamWatermarksRequest.cc Normal file
View File

@@ -0,0 +1,62 @@
/*
* Copyright 2009-2017 Alibaba Cloud 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.
*/
#include <alibabacloud/live/model/DescribeLiveStreamWatermarksRequest.h>
using AlibabaCloud::Live::Model::DescribeLiveStreamWatermarksRequest;
DescribeLiveStreamWatermarksRequest::DescribeLiveStreamWatermarksRequest() :
RpcServiceRequest("live", "2016-11-01", "DescribeLiveStreamWatermarks")
{
setMethod(HttpRequest::Method::Post);
}
DescribeLiveStreamWatermarksRequest::~DescribeLiveStreamWatermarksRequest()
{}
int DescribeLiveStreamWatermarksRequest::getPageNumber()const
{
return pageNumber_;
}
void DescribeLiveStreamWatermarksRequest::setPageNumber(int pageNumber)
{
pageNumber_ = pageNumber;
setParameter("PageNumber", std::to_string(pageNumber));
}
int DescribeLiveStreamWatermarksRequest::getPageSize()const
{
return pageSize_;
}
void DescribeLiveStreamWatermarksRequest::setPageSize(int pageSize)
{
pageSize_ = pageSize;
setParameter("PageSize", std::to_string(pageSize));
}
long DescribeLiveStreamWatermarksRequest::getOwnerId()const
{
return ownerId_;
}
void DescribeLiveStreamWatermarksRequest::setOwnerId(long ownerId)
{
ownerId_ = ownerId;
setParameter("OwnerId", std::to_string(ownerId));
}

79
live/src/model/DescribeLiveStreamWatermarksResult.cc Normal file
View File

@@ -0,0 +1,79 @@
/*
* Copyright 2009-2017 Alibaba Cloud 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.
*/
#include <alibabacloud/live/model/DescribeLiveStreamWatermarksResult.h>
#include <json/json.h>
using namespace AlibabaCloud::Live;
using namespace AlibabaCloud::Live::Model;
DescribeLiveStreamWatermarksResult::DescribeLiveStreamWatermarksResult() :
ServiceResult()
{}
DescribeLiveStreamWatermarksResult::DescribeLiveStreamWatermarksResult(const std::string &payload) :
ServiceResult()
{
parse(payload);
}
DescribeLiveStreamWatermarksResult::~DescribeLiveStreamWatermarksResult()
{}
void DescribeLiveStreamWatermarksResult::parse(const std::string &payload)
{
Json::Reader reader;
Json::Value value;
reader.parse(payload, value);
setRequestId(value["RequestId"].asString());
auto allWatermarkListNode = value["WatermarkList"]["Watermark"];
for (auto valueWatermarkListWatermark : allWatermarkListNode)
{
Watermark watermarkListObject;
if(!valueWatermarkListWatermark["TemplateId"].isNull())
watermarkListObject.templateId = valueWatermarkListWatermark["TemplateId"].asString();
if(!valueWatermarkListWatermark["Name"].isNull())
watermarkListObject.name = valueWatermarkListWatermark["Name"].asString();
if(!valueWatermarkListWatermark["Type"].isNull())
watermarkListObject.type = std::stoi(valueWatermarkListWatermark["Type"].asString());
if(!valueWatermarkListWatermark["Description"].isNull())
watermarkListObject.description = valueWatermarkListWatermark["Description"].asString();
if(!valueWatermarkListWatermark["RefWidth"].isNull())
watermarkListObject.refWidth = std::stoi(valueWatermarkListWatermark["RefWidth"].asString());
if(!valueWatermarkListWatermark["RefHeight"].isNull())
watermarkListObject.refHeight = std::stoi(valueWatermarkListWatermark["RefHeight"].asString());
if(!valueWatermarkListWatermark["XOffset"].isNull())
watermarkListObject.xOffset = std::stof(valueWatermarkListWatermark["XOffset"].asString());
if(!valueWatermarkListWatermark["YOffset"].isNull())
watermarkListObject.yOffset = std::stof(valueWatermarkListWatermark["YOffset"].asString());
if(!valueWatermarkListWatermark["Height"].isNull())
watermarkListObject.height = std::stoi(valueWatermarkListWatermark["Height"].asString());
if(!valueWatermarkListWatermark["Transparency"].isNull())
watermarkListObject.transparency = std::stoi(valueWatermarkListWatermark["Transparency"].asString());
if(!valueWatermarkListWatermark["OffsetCorner"].isNull())
watermarkListObject.offsetCorner = valueWatermarkListWatermark["OffsetCorner"].asString();
if(!valueWatermarkListWatermark["PictureUrl"].isNull())
watermarkListObject.pictureUrl = valueWatermarkListWatermark["PictureUrl"].asString();
watermarkList_.push_back(watermarkListObject);
}
}
std::vector<DescribeLiveStreamWatermarksResult::Watermark> DescribeLiveStreamWatermarksResult::getWatermarkList()const
{
return watermarkList_;
}

7
live/src/model/DescribeStudioLayoutsResult.cc
View File

@@ -71,6 +71,13 @@ void DescribeStudioLayoutsResult::parse(const std::string &payload)
screenInputConfigListObject.heightNormalized = std::stof(valueStudioLayoutsStudioLayoutScreenInputConfigListScreenInputConfig["HeightNormalized"].asString());
if(!valueStudioLayoutsStudioLayoutScreenInputConfigListScreenInputConfig["PortraitType"].isNull())
screenInputConfigListObject.portraitType = std::stoi(valueStudioLayoutsStudioLayoutScreenInputConfigListScreenInputConfig["PortraitType"].asString());
if(!valueStudioLayoutsStudioLayoutScreenInputConfigListScreenInputConfig["OnlyAudio"].isNull())
screenInputConfigListObject.onlyAudio = valueStudioLayoutsStudioLayoutScreenInputConfigListScreenInputConfig["OnlyAudio"].asString() == "true";
auto audioConfigNode = value["AudioConfig"];
if(!audioConfigNode["VolumeRate"].isNull())
screenInputConfigListObject.audioConfig.volumeRate = std::stof(audioConfigNode["VolumeRate"].asString());
if(!audioConfigNode["ValidChannel"].isNull())
screenInputConfigListObject.audioConfig.validChannel = audioConfigNode["ValidChannel"].asString();
studioLayoutsObject.screenInputConfigList.push_back(screenInputConfigListObject);
}
auto allMediaInputConfigListNode = valueStudioLayoutsStudioLayout["MediaInputConfigList"]["MediaInputConfig"];

51
live/src/model/QuerySnapshotCallbackAuthRequest.cc Normal file
View File

@@ -0,0 +1,51 @@
/*
* Copyright 2009-2017 Alibaba Cloud 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.
*/
#include <alibabacloud/live/model/QuerySnapshotCallbackAuthRequest.h>
using AlibabaCloud::Live::Model::QuerySnapshotCallbackAuthRequest;
QuerySnapshotCallbackAuthRequest::QuerySnapshotCallbackAuthRequest() :
RpcServiceRequest("live", "2016-11-01", "QuerySnapshotCallbackAuth")
{
setMethod(HttpRequest::Method::Post);
}
QuerySnapshotCallbackAuthRequest::~QuerySnapshotCallbackAuthRequest()
{}
std::string QuerySnapshotCallbackAuthRequest::getDomainName()const
{
return domainName_;
}
void QuerySnapshotCallbackAuthRequest::setDomainName(const std::string& domainName)
{
domainName_ = domainName;
setParameter("DomainName", domainName);
}
long QuerySnapshotCallbackAuthRequest::getOwnerId()const
{
return ownerId_;
}
void QuerySnapshotCallbackAuthRequest::setOwnerId(long ownerId)
{
ownerId_ = ownerId;
setParameter("OwnerId", std::to_string(ownerId));
}

65
live/src/model/QuerySnapshotCallbackAuthResult.cc Normal file
View File

@@ -0,0 +1,65 @@
/*
* Copyright 2009-2017 Alibaba Cloud 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.
*/
#include <alibabacloud/live/model/QuerySnapshotCallbackAuthResult.h>
#include <json/json.h>
using namespace AlibabaCloud::Live;
using namespace AlibabaCloud::Live::Model;
QuerySnapshotCallbackAuthResult::QuerySnapshotCallbackAuthResult() :
ServiceResult()
{}
QuerySnapshotCallbackAuthResult::QuerySnapshotCallbackAuthResult(const std::string &payload) :
ServiceResult()
{
parse(payload);
}
QuerySnapshotCallbackAuthResult::~QuerySnapshotCallbackAuthResult()
{}
void QuerySnapshotCallbackAuthResult::parse(const std::string &payload)
{
Json::Reader reader;
Json::Value value;
reader.parse(payload, value);
setRequestId(value["RequestId"].asString());
if(!value["DomainName"].isNull())
domainName_ = value["DomainName"].asString();
if(!value["CallbackReqAuth"].isNull())
callbackReqAuth_ = value["CallbackReqAuth"].asString();
if(!value["CallbackAuthKey"].isNull())
callbackAuthKey_ = value["CallbackAuthKey"].asString();
}
std::string QuerySnapshotCallbackAuthResult::getCallbackAuthKey()const
{
return callbackAuthKey_;
}
std::string QuerySnapshotCallbackAuthResult::getCallbackReqAuth()const
{
return callbackReqAuth_;
}
std::string QuerySnapshotCallbackAuthResult::getDomainName()const
{
return domainName_;
}

73
live/src/model/SetSnapshotCallbackAuthRequest.cc Normal file
View File

@@ -0,0 +1,73 @@
/*
* Copyright 2009-2017 Alibaba Cloud 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.
*/
#include <alibabacloud/live/model/SetSnapshotCallbackAuthRequest.h>
using AlibabaCloud::Live::Model::SetSnapshotCallbackAuthRequest;
SetSnapshotCallbackAuthRequest::SetSnapshotCallbackAuthRequest() :
RpcServiceRequest("live", "2016-11-01", "SetSnapshotCallbackAuth")
{
setMethod(HttpRequest::Method::Post);
}
SetSnapshotCallbackAuthRequest::~SetSnapshotCallbackAuthRequest()
{}
std::string SetSnapshotCallbackAuthRequest::getCallbackAuthKey()const
{
return callbackAuthKey_;
}
void SetSnapshotCallbackAuthRequest::setCallbackAuthKey(const std::string& callbackAuthKey)
{
callbackAuthKey_ = callbackAuthKey;
setParameter("CallbackAuthKey", callbackAuthKey);
}
std::string SetSnapshotCallbackAuthRequest::getDomainName()const
{
return domainName_;
}
void SetSnapshotCallbackAuthRequest::setDomainName(const std::string& domainName)
{
domainName_ = domainName;
setParameter("DomainName", domainName);
}
long SetSnapshotCallbackAuthRequest::getOwnerId()const
{
return ownerId_;
}
void SetSnapshotCallbackAuthRequest::setOwnerId(long ownerId)
{
ownerId_ = ownerId;
setParameter("OwnerId", std::to_string(ownerId));
}
std::string SetSnapshotCallbackAuthRequest::getCallbackReqAuth()const
{
return callbackReqAuth_;
}
void SetSnapshotCallbackAuthRequest::setCallbackReqAuth(const std::string& callbackReqAuth)
{
callbackReqAuth_ = callbackReqAuth;
setParameter("CallbackReqAuth", callbackReqAuth);
}

44
live/src/model/SetSnapshotCallbackAuthResult.cc Normal file
View File

@@ -0,0 +1,44 @@
/*
* Copyright 2009-2017 Alibaba Cloud 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.
*/
#include <alibabacloud/live/model/SetSnapshotCallbackAuthResult.h>
#include <json/json.h>
using namespace AlibabaCloud::Live;
using namespace AlibabaCloud::Live::Model;
SetSnapshotCallbackAuthResult::SetSnapshotCallbackAuthResult() :
ServiceResult()
{}
SetSnapshotCallbackAuthResult::SetSnapshotCallbackAuthResult(const std::string &payload) :
ServiceResult()
{
parse(payload);
}
SetSnapshotCallbackAuthResult::~SetSnapshotCallbackAuthResult()
{}
void SetSnapshotCallbackAuthResult::parse(const std::string &payload)
{
Json::Reader reader;
Json::Value value;
reader.parse(payload, value);
setRequestId(value["RequestId"].asString());
}

161
live/src/model/UpdateLiveStreamWatermarkRequest.cc Normal file
View File

@@ -0,0 +1,161 @@
/*
* Copyright 2009-2017 Alibaba Cloud 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.
*/
#include <alibabacloud/live/model/UpdateLiveStreamWatermarkRequest.h>
using AlibabaCloud::Live::Model::UpdateLiveStreamWatermarkRequest;
UpdateLiveStreamWatermarkRequest::UpdateLiveStreamWatermarkRequest() :
RpcServiceRequest("live", "2016-11-01", "UpdateLiveStreamWatermark")
{
setMethod(HttpRequest::Method::Post);
}
UpdateLiveStreamWatermarkRequest::~UpdateLiveStreamWatermarkRequest()
{}
float UpdateLiveStreamWatermarkRequest::getYOffset()const
{
return yOffset_;
}
void UpdateLiveStreamWatermarkRequest::setYOffset(float yOffset)
{
yOffset_ = yOffset;
setParameter("YOffset", std::to_string(yOffset));
}
std::string UpdateLiveStreamWatermarkRequest::getPictureUrl()const
{
return pictureUrl_;
}
void UpdateLiveStreamWatermarkRequest::setPictureUrl(const std::string& pictureUrl)
{
pictureUrl_ = pictureUrl;
setParameter("PictureUrl", pictureUrl);
}
std::string UpdateLiveStreamWatermarkRequest::getDescription()const
{
return description_;
}
void UpdateLiveStreamWatermarkRequest::setDescription(const std::string& description)
{
description_ = description;
setParameter("Description", description);
}
int UpdateLiveStreamWatermarkRequest::getHeight()const
{
return height_;
}
void UpdateLiveStreamWatermarkRequest::setHeight(int height)
{
height_ = height;
setParameter("Height", std::to_string(height));
}
float UpdateLiveStreamWatermarkRequest::getXOffset()const
{
return xOffset_;
}
void UpdateLiveStreamWatermarkRequest::setXOffset(float xOffset)
{
xOffset_ = xOffset;
setParameter("XOffset", std::to_string(xOffset));
}
long UpdateLiveStreamWatermarkRequest::getOwnerId()const
{
return ownerId_;
}
void UpdateLiveStreamWatermarkRequest::setOwnerId(long ownerId)
{
ownerId_ = ownerId;
setParameter("OwnerId", std::to_string(ownerId));
}
std::string UpdateLiveStreamWatermarkRequest::getTemplateId()const
{
return templateId_;
}
void UpdateLiveStreamWatermarkRequest::setTemplateId(const std::string& templateId)
{
templateId_ = templateId;
setParameter("TemplateId", templateId);
}
int UpdateLiveStreamWatermarkRequest::getRefWidth()const
{
return refWidth_;
}
void UpdateLiveStreamWatermarkRequest::setRefWidth(int refWidth)
{
refWidth_ = refWidth;
setParameter("RefWidth", std::to_string(refWidth));
}
int UpdateLiveStreamWatermarkRequest::getTransparency()const
{
return transparency_;
}
void UpdateLiveStreamWatermarkRequest::setTransparency(int transparency)
{
transparency_ = transparency;
setParameter("Transparency", std::to_string(transparency));
}
std::string UpdateLiveStreamWatermarkRequest::getName()const
{
return name_;
}
void UpdateLiveStreamWatermarkRequest::setName(const std::string& name)
{
name_ = name;
setParameter("Name", name);
}
std::string UpdateLiveStreamWatermarkRequest::getOffsetCorner()const
{
return offsetCorner_;
}
void UpdateLiveStreamWatermarkRequest::setOffsetCorner(const std::string& offsetCorner)
{
offsetCorner_ = offsetCorner;
setParameter("OffsetCorner", offsetCorner);
}
int UpdateLiveStreamWatermarkRequest::getRefHeight()const
{
return refHeight_;
}
void UpdateLiveStreamWatermarkRequest::setRefHeight(int refHeight)
{
refHeight_ = refHeight;
setParameter("RefHeight", std::to_string(refHeight));
}

44
live/src/model/UpdateLiveStreamWatermarkResult.cc Normal file
View File

@@ -0,0 +1,44 @@
/*
* Copyright 2009-2017 Alibaba Cloud 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.
*/
#include <alibabacloud/live/model/UpdateLiveStreamWatermarkResult.h>
#include <json/json.h>
using namespace AlibabaCloud::Live;
using namespace AlibabaCloud::Live::Model;
UpdateLiveStreamWatermarkResult::UpdateLiveStreamWatermarkResult() :
ServiceResult()
{}
UpdateLiveStreamWatermarkResult::UpdateLiveStreamWatermarkResult(const std::string &payload) :
ServiceResult()
{
parse(payload);
}
UpdateLiveStreamWatermarkResult::~UpdateLiveStreamWatermarkResult()
{}
void UpdateLiveStreamWatermarkResult::parse(const std::string &payload)
{
Json::Reader reader;
Json::Value value;
reader.parse(payload, value);
setRequestId(value["RequestId"].asString());
}

84
live/src/model/UpdateLiveStreamWatermarkRuleRequest.cc Normal file
View File

@@ -0,0 +1,84 @@
/*
* Copyright 2009-2017 Alibaba Cloud 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.
*/
#include <alibabacloud/live/model/UpdateLiveStreamWatermarkRuleRequest.h>
using AlibabaCloud::Live::Model::UpdateLiveStreamWatermarkRuleRequest;
UpdateLiveStreamWatermarkRuleRequest::UpdateLiveStreamWatermarkRuleRequest() :
RpcServiceRequest("live", "2016-11-01", "UpdateLiveStreamWatermarkRule")
{
setMethod(HttpRequest::Method::Post);
}
UpdateLiveStreamWatermarkRuleRequest::~UpdateLiveStreamWatermarkRuleRequest()
{}
std::string UpdateLiveStreamWatermarkRuleRequest::getDescription()const
{
return description_;
}
void UpdateLiveStreamWatermarkRuleRequest::setDescription(const std::string& description)
{
description_ = description;
setParameter("Description", description);
}
long UpdateLiveStreamWatermarkRuleRequest::getOwnerId()const
{
return ownerId_;
}
void UpdateLiveStreamWatermarkRuleRequest::setOwnerId(long ownerId)
{
ownerId_ = ownerId;
setParameter("OwnerId", std::to_string(ownerId));
}
std::string UpdateLiveStreamWatermarkRuleRequest::getTemplateId()const
{
return templateId_;
}
void UpdateLiveStreamWatermarkRuleRequest::setTemplateId(const std::string& templateId)
{
templateId_ = templateId;
setParameter("TemplateId", templateId);
}
std::string UpdateLiveStreamWatermarkRuleRequest::getName()const
{
return name_;
}
void UpdateLiveStreamWatermarkRuleRequest::setName(const std::string& name)
{
name_ = name;
setParameter("Name", name);
}
std::string UpdateLiveStreamWatermarkRuleRequest::getRuleId()const
{
return ruleId_;
}
void UpdateLiveStreamWatermarkRuleRequest::setRuleId(const std::string& ruleId)
{
ruleId_ = ruleId;
setParameter("RuleId", ruleId);
}

44
live/src/model/UpdateLiveStreamWatermarkRuleResult.cc Normal file
View File

@@ -0,0 +1,44 @@
/*
* Copyright 2009-2017 Alibaba Cloud 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.
*/
#include <alibabacloud/live/model/UpdateLiveStreamWatermarkRuleResult.h>
#include <json/json.h>
using namespace AlibabaCloud::Live;
using namespace AlibabaCloud::Live::Model;
UpdateLiveStreamWatermarkRuleResult::UpdateLiveStreamWatermarkRuleResult() :
ServiceResult()
{}
UpdateLiveStreamWatermarkRuleResult::UpdateLiveStreamWatermarkRuleResult(const std::string &payload) :
ServiceResult()
{
parse(payload);
}
UpdateLiveStreamWatermarkRuleResult::~UpdateLiveStreamWatermarkRuleResult()
{}
void UpdateLiveStreamWatermarkRuleResult::parse(const std::string &payload)
{
Json::Reader reader;
Json::Value value;
reader.parse(payload, value);
setRequestId(value["RequestId"].asString());
}