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
2020-09-22 01:53:20 +00:00
parent dd1d0e5359
commit 7097cf0d88
38 changed files with 2310 additions and 13 deletions
Download Patch File Download Diff File Expand all files Collapse all files

3
CHANGELOG
View File

@@ -1,3 +1,6 @@
2020-09-22 Version: patch
- Generated 2016-11-01 for `live`.
2020-09-21 Version: patch
- Interface add column wordCount.

32
live/CMakeLists.txt
View File

@@ -51,6 +51,8 @@ set(live_public_header_model
include/alibabacloud/live/model/AddLiveDomainResult.h
include/alibabacloud/live/model/AddLiveDomainMappingRequest.h
include/alibabacloud/live/model/AddLiveDomainMappingResult.h
include/alibabacloud/live/model/AddLiveDomainPlayMappingRequest.h
include/alibabacloud/live/model/AddLiveDomainPlayMappingResult.h
include/alibabacloud/live/model/AddLivePullStreamInfoConfigRequest.h
include/alibabacloud/live/model/AddLivePullStreamInfoConfigResult.h
include/alibabacloud/live/model/AddLiveRecordNotifyConfigRequest.h
@@ -93,6 +95,8 @@ set(live_public_header_model
include/alibabacloud/live/model/CreateLiveRealTimeLogDeliveryResult.h
include/alibabacloud/live/model/CreateLiveStreamRecordIndexFilesRequest.h
include/alibabacloud/live/model/CreateLiveStreamRecordIndexFilesResult.h
include/alibabacloud/live/model/CreateMixStreamRequest.h
include/alibabacloud/live/model/CreateMixStreamResult.h
include/alibabacloud/live/model/CreateRoomRequest.h
include/alibabacloud/live/model/CreateRoomResult.h
include/alibabacloud/live/model/DeleteBoardRequest.h
@@ -147,6 +151,8 @@ set(live_public_header_model
include/alibabacloud/live/model/DeleteLiveStreamTranscodeResult.h
include/alibabacloud/live/model/DeleteLiveStreamsNotifyUrlConfigRequest.h
include/alibabacloud/live/model/DeleteLiveStreamsNotifyUrlConfigResult.h
include/alibabacloud/live/model/DeleteMixStreamRequest.h
include/alibabacloud/live/model/DeleteMixStreamResult.h
include/alibabacloud/live/model/DeleteRoomRequest.h
include/alibabacloud/live/model/DeleteRoomResult.h
include/alibabacloud/live/model/DescribeBoardEventsRequest.h
@@ -239,6 +245,8 @@ set(live_public_header_model
include/alibabacloud/live/model/DescribeLiveDomainTranscodeDataResult.h
include/alibabacloud/live/model/DescribeLiveLazyPullStreamConfigRequest.h
include/alibabacloud/live/model/DescribeLiveLazyPullStreamConfigResult.h
include/alibabacloud/live/model/DescribeLivePullStreamConfigRequest.h
include/alibabacloud/live/model/DescribeLivePullStreamConfigResult.h
include/alibabacloud/live/model/DescribeLiveRealtimeDeliveryAccRequest.h
include/alibabacloud/live/model/DescribeLiveRealtimeDeliveryAccResult.h
include/alibabacloud/live/model/DescribeLiveRealtimeLogAuthorizedRequest.h
@@ -297,6 +305,8 @@ set(live_public_header_model
include/alibabacloud/live/model/DescribeLiveUserDomainsResult.h
include/alibabacloud/live/model/DescribeLiveUserTagsRequest.h
include/alibabacloud/live/model/DescribeLiveUserTagsResult.h
include/alibabacloud/live/model/DescribeMixStreamListRequest.h
include/alibabacloud/live/model/DescribeMixStreamListResult.h
include/alibabacloud/live/model/DescribeRecordRequest.h
include/alibabacloud/live/model/DescribeRecordResult.h
include/alibabacloud/live/model/DescribeRecordsRequest.h
@@ -399,6 +409,8 @@ set(live_public_header_model
include/alibabacloud/live/model/StopLiveIndexResult.h
include/alibabacloud/live/model/TagLiveResourcesRequest.h
include/alibabacloud/live/model/TagLiveResourcesResult.h
include/alibabacloud/live/model/TriggerRecordRequest.h
include/alibabacloud/live/model/TriggerRecordResult.h
include/alibabacloud/live/model/UnTagLiveResourcesRequest.h
include/alibabacloud/live/model/UnTagLiveResourcesResult.h
include/alibabacloud/live/model/UpdateBoardRequest.h
@@ -422,7 +434,9 @@ set(live_public_header_model
include/alibabacloud/live/model/UpdateLiveSnapshotDetectPornConfigRequest.h
include/alibabacloud/live/model/UpdateLiveSnapshotDetectPornConfigResult.h
include/alibabacloud/live/model/UpdateLiveTopLevelDomainRequest.h
include/alibabacloud/live/model/UpdateLiveTopLevelDomainResult.h )
include/alibabacloud/live/model/UpdateLiveTopLevelDomainResult.h
include/alibabacloud/live/model/UpdateMixStreamRequest.h
include/alibabacloud/live/model/UpdateMixStreamResult.h )
set(live_src
src/LiveClient.cc
@@ -456,6 +470,8 @@ set(live_src
src/model/AddLiveDomainResult.cc
src/model/AddLiveDomainMappingRequest.cc
src/model/AddLiveDomainMappingResult.cc
src/model/AddLiveDomainPlayMappingRequest.cc
src/model/AddLiveDomainPlayMappingResult.cc
src/model/AddLivePullStreamInfoConfigRequest.cc
src/model/AddLivePullStreamInfoConfigResult.cc
src/model/AddLiveRecordNotifyConfigRequest.cc
@@ -498,6 +514,8 @@ set(live_src
src/model/CreateLiveRealTimeLogDeliveryResult.cc
src/model/CreateLiveStreamRecordIndexFilesRequest.cc
src/model/CreateLiveStreamRecordIndexFilesResult.cc
src/model/CreateMixStreamRequest.cc
src/model/CreateMixStreamResult.cc
src/model/CreateRoomRequest.cc
src/model/CreateRoomResult.cc
src/model/DeleteBoardRequest.cc
@@ -552,6 +570,8 @@ set(live_src
src/model/DeleteLiveStreamTranscodeResult.cc
src/model/DeleteLiveStreamsNotifyUrlConfigRequest.cc
src/model/DeleteLiveStreamsNotifyUrlConfigResult.cc
src/model/DeleteMixStreamRequest.cc
src/model/DeleteMixStreamResult.cc
src/model/DeleteRoomRequest.cc
src/model/DeleteRoomResult.cc
src/model/DescribeBoardEventsRequest.cc
@@ -644,6 +664,8 @@ set(live_src
src/model/DescribeLiveDomainTranscodeDataResult.cc
src/model/DescribeLiveLazyPullStreamConfigRequest.cc
src/model/DescribeLiveLazyPullStreamConfigResult.cc
src/model/DescribeLivePullStreamConfigRequest.cc
src/model/DescribeLivePullStreamConfigResult.cc
src/model/DescribeLiveRealtimeDeliveryAccRequest.cc
src/model/DescribeLiveRealtimeDeliveryAccResult.cc
src/model/DescribeLiveRealtimeLogAuthorizedRequest.cc
@@ -702,6 +724,8 @@ set(live_src
src/model/DescribeLiveUserDomainsResult.cc
src/model/DescribeLiveUserTagsRequest.cc
src/model/DescribeLiveUserTagsResult.cc
src/model/DescribeMixStreamListRequest.cc
src/model/DescribeMixStreamListResult.cc
src/model/DescribeRecordRequest.cc
src/model/DescribeRecordResult.cc
src/model/DescribeRecordsRequest.cc
@@ -804,6 +828,8 @@ set(live_src
src/model/StopLiveIndexResult.cc
src/model/TagLiveResourcesRequest.cc
src/model/TagLiveResourcesResult.cc
src/model/TriggerRecordRequest.cc
src/model/TriggerRecordResult.cc
src/model/UnTagLiveResourcesRequest.cc
src/model/UnTagLiveResourcesResult.cc
src/model/UpdateBoardRequest.cc
@@ -827,7 +853,9 @@ set(live_src
src/model/UpdateLiveSnapshotDetectPornConfigRequest.cc
src/model/UpdateLiveSnapshotDetectPornConfigResult.cc
src/model/UpdateLiveTopLevelDomainRequest.cc
src/model/UpdateLiveTopLevelDomainResult.cc )
src/model/UpdateLiveTopLevelDomainResult.cc
src/model/UpdateMixStreamRequest.cc
src/model/UpdateMixStreamResult.cc )
add_library(live ${LIB_TYPE}
${live_public_header}

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

@@ -52,6 +52,8 @@
#include "model/AddLiveDomainResult.h"
#include "model/AddLiveDomainMappingRequest.h"
#include "model/AddLiveDomainMappingResult.h"
#include "model/AddLiveDomainPlayMappingRequest.h"
#include "model/AddLiveDomainPlayMappingResult.h"
#include "model/AddLivePullStreamInfoConfigRequest.h"
#include "model/AddLivePullStreamInfoConfigResult.h"
#include "model/AddLiveRecordNotifyConfigRequest.h"
@@ -94,6 +96,8 @@
#include "model/CreateLiveRealTimeLogDeliveryResult.h"
#include "model/CreateLiveStreamRecordIndexFilesRequest.h"
#include "model/CreateLiveStreamRecordIndexFilesResult.h"
#include "model/CreateMixStreamRequest.h"
#include "model/CreateMixStreamResult.h"
#include "model/CreateRoomRequest.h"
#include "model/CreateRoomResult.h"
#include "model/DeleteBoardRequest.h"
@@ -148,6 +152,8 @@
#include "model/DeleteLiveStreamTranscodeResult.h"
#include "model/DeleteLiveStreamsNotifyUrlConfigRequest.h"
#include "model/DeleteLiveStreamsNotifyUrlConfigResult.h"
#include "model/DeleteMixStreamRequest.h"
#include "model/DeleteMixStreamResult.h"
#include "model/DeleteRoomRequest.h"
#include "model/DeleteRoomResult.h"
#include "model/DescribeBoardEventsRequest.h"
@@ -240,6 +246,8 @@
#include "model/DescribeLiveDomainTranscodeDataResult.h"
#include "model/DescribeLiveLazyPullStreamConfigRequest.h"
#include "model/DescribeLiveLazyPullStreamConfigResult.h"
#include "model/DescribeLivePullStreamConfigRequest.h"
#include "model/DescribeLivePullStreamConfigResult.h"
#include "model/DescribeLiveRealtimeDeliveryAccRequest.h"
#include "model/DescribeLiveRealtimeDeliveryAccResult.h"
#include "model/DescribeLiveRealtimeLogAuthorizedRequest.h"
@@ -298,6 +306,8 @@
#include "model/DescribeLiveUserDomainsResult.h"
#include "model/DescribeLiveUserTagsRequest.h"
#include "model/DescribeLiveUserTagsResult.h"
#include "model/DescribeMixStreamListRequest.h"
#include "model/DescribeMixStreamListResult.h"
#include "model/DescribeRecordRequest.h"
#include "model/DescribeRecordResult.h"
#include "model/DescribeRecordsRequest.h"
@@ -400,6 +410,8 @@
#include "model/StopLiveIndexResult.h"
#include "model/TagLiveResourcesRequest.h"
#include "model/TagLiveResourcesResult.h"
#include "model/TriggerRecordRequest.h"
#include "model/TriggerRecordResult.h"
#include "model/UnTagLiveResourcesRequest.h"
#include "model/UnTagLiveResourcesResult.h"
#include "model/UpdateBoardRequest.h"
@@ -424,6 +436,8 @@
#include "model/UpdateLiveSnapshotDetectPornConfigResult.h"
#include "model/UpdateLiveTopLevelDomainRequest.h"
#include "model/UpdateLiveTopLevelDomainResult.h"
#include "model/UpdateMixStreamRequest.h"
#include "model/UpdateMixStreamResult.h"
namespace AlibabaCloud
@@ -478,6 +492,9 @@ namespace AlibabaCloud
typedef Outcome<Error, Model::AddLiveDomainMappingResult> AddLiveDomainMappingOutcome;
typedef std::future<AddLiveDomainMappingOutcome> AddLiveDomainMappingOutcomeCallable;
typedef std::function<void(const LiveClient*, const Model::AddLiveDomainMappingRequest&, const AddLiveDomainMappingOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> AddLiveDomainMappingAsyncHandler;
typedef Outcome<Error, Model::AddLiveDomainPlayMappingResult> AddLiveDomainPlayMappingOutcome;
typedef std::future<AddLiveDomainPlayMappingOutcome> AddLiveDomainPlayMappingOutcomeCallable;
typedef std::function<void(const LiveClient*, const Model::AddLiveDomainPlayMappingRequest&, const AddLiveDomainPlayMappingOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> AddLiveDomainPlayMappingAsyncHandler;
typedef Outcome<Error, Model::AddLivePullStreamInfoConfigResult> AddLivePullStreamInfoConfigOutcome;
typedef std::future<AddLivePullStreamInfoConfigOutcome> AddLivePullStreamInfoConfigOutcomeCallable;
typedef std::function<void(const LiveClient*, const Model::AddLivePullStreamInfoConfigRequest&, const AddLivePullStreamInfoConfigOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> AddLivePullStreamInfoConfigAsyncHandler;
@@ -541,6 +558,9 @@ namespace AlibabaCloud
typedef Outcome<Error, Model::CreateLiveStreamRecordIndexFilesResult> CreateLiveStreamRecordIndexFilesOutcome;
typedef std::future<CreateLiveStreamRecordIndexFilesOutcome> CreateLiveStreamRecordIndexFilesOutcomeCallable;
typedef std::function<void(const LiveClient*, const Model::CreateLiveStreamRecordIndexFilesRequest&, const CreateLiveStreamRecordIndexFilesOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> CreateLiveStreamRecordIndexFilesAsyncHandler;
typedef Outcome<Error, Model::CreateMixStreamResult> CreateMixStreamOutcome;
typedef std::future<CreateMixStreamOutcome> CreateMixStreamOutcomeCallable;
typedef std::function<void(const LiveClient*, const Model::CreateMixStreamRequest&, const CreateMixStreamOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> CreateMixStreamAsyncHandler;
typedef Outcome<Error, Model::CreateRoomResult> CreateRoomOutcome;
typedef std::future<CreateRoomOutcome> CreateRoomOutcomeCallable;
typedef std::function<void(const LiveClient*, const Model::CreateRoomRequest&, const CreateRoomOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> CreateRoomAsyncHandler;
@@ -622,6 +642,9 @@ namespace AlibabaCloud
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;
typedef Outcome<Error, Model::DeleteMixStreamResult> DeleteMixStreamOutcome;
typedef std::future<DeleteMixStreamOutcome> DeleteMixStreamOutcomeCallable;
typedef std::function<void(const LiveClient*, const Model::DeleteMixStreamRequest&, const DeleteMixStreamOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DeleteMixStreamAsyncHandler;
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;
@@ -760,6 +783,9 @@ namespace AlibabaCloud
typedef Outcome<Error, Model::DescribeLiveLazyPullStreamConfigResult> DescribeLiveLazyPullStreamConfigOutcome;
typedef std::future<DescribeLiveLazyPullStreamConfigOutcome> DescribeLiveLazyPullStreamConfigOutcomeCallable;
typedef std::function<void(const LiveClient*, const Model::DescribeLiveLazyPullStreamConfigRequest&, const DescribeLiveLazyPullStreamConfigOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeLiveLazyPullStreamConfigAsyncHandler;
typedef Outcome<Error, Model::DescribeLivePullStreamConfigResult> DescribeLivePullStreamConfigOutcome;
typedef std::future<DescribeLivePullStreamConfigOutcome> DescribeLivePullStreamConfigOutcomeCallable;
typedef std::function<void(const LiveClient*, const Model::DescribeLivePullStreamConfigRequest&, const DescribeLivePullStreamConfigOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeLivePullStreamConfigAsyncHandler;
typedef Outcome<Error, Model::DescribeLiveRealtimeDeliveryAccResult> DescribeLiveRealtimeDeliveryAccOutcome;
typedef std::future<DescribeLiveRealtimeDeliveryAccOutcome> DescribeLiveRealtimeDeliveryAccOutcomeCallable;
typedef std::function<void(const LiveClient*, const Model::DescribeLiveRealtimeDeliveryAccRequest&, const DescribeLiveRealtimeDeliveryAccOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeLiveRealtimeDeliveryAccAsyncHandler;
@@ -847,6 +873,9 @@ namespace AlibabaCloud
typedef Outcome<Error, Model::DescribeLiveUserTagsResult> DescribeLiveUserTagsOutcome;
typedef std::future<DescribeLiveUserTagsOutcome> DescribeLiveUserTagsOutcomeCallable;
typedef std::function<void(const LiveClient*, const Model::DescribeLiveUserTagsRequest&, const DescribeLiveUserTagsOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeLiveUserTagsAsyncHandler;
typedef Outcome<Error, Model::DescribeMixStreamListResult> DescribeMixStreamListOutcome;
typedef std::future<DescribeMixStreamListOutcome> DescribeMixStreamListOutcomeCallable;
typedef std::function<void(const LiveClient*, const Model::DescribeMixStreamListRequest&, const DescribeMixStreamListOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeMixStreamListAsyncHandler;
typedef Outcome<Error, Model::DescribeRecordResult> DescribeRecordOutcome;
typedef std::future<DescribeRecordOutcome> DescribeRecordOutcomeCallable;
typedef std::function<void(const LiveClient*, const Model::DescribeRecordRequest&, const DescribeRecordOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeRecordAsyncHandler;
@@ -1000,6 +1029,9 @@ namespace AlibabaCloud
typedef Outcome<Error, Model::TagLiveResourcesResult> TagLiveResourcesOutcome;
typedef std::future<TagLiveResourcesOutcome> TagLiveResourcesOutcomeCallable;
typedef std::function<void(const LiveClient*, const Model::TagLiveResourcesRequest&, const TagLiveResourcesOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> TagLiveResourcesAsyncHandler;
typedef Outcome<Error, Model::TriggerRecordResult> TriggerRecordOutcome;
typedef std::future<TriggerRecordOutcome> TriggerRecordOutcomeCallable;
typedef std::function<void(const LiveClient*, const Model::TriggerRecordRequest&, const TriggerRecordOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> TriggerRecordAsyncHandler;
typedef Outcome<Error, Model::UnTagLiveResourcesResult> UnTagLiveResourcesOutcome;
typedef std::future<UnTagLiveResourcesOutcome> UnTagLiveResourcesOutcomeCallable;
typedef std::function<void(const LiveClient*, const Model::UnTagLiveResourcesRequest&, const UnTagLiveResourcesOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> UnTagLiveResourcesAsyncHandler;
@@ -1036,6 +1068,9 @@ namespace AlibabaCloud
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;
typedef Outcome<Error, Model::UpdateMixStreamResult> UpdateMixStreamOutcome;
typedef std::future<UpdateMixStreamOutcome> UpdateMixStreamOutcomeCallable;
typedef std::function<void(const LiveClient*, const Model::UpdateMixStreamRequest&, const UpdateMixStreamOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> UpdateMixStreamAsyncHandler;
LiveClient(const Credentials &credentials, const ClientConfiguration &configuration);
LiveClient(const std::shared_ptr<CredentialsProvider> &credentialsProvider, const ClientConfiguration &configuration);
@@ -1086,6 +1121,9 @@ namespace AlibabaCloud
AddLiveDomainMappingOutcome addLiveDomainMapping(const Model::AddLiveDomainMappingRequest &request)const;
void addLiveDomainMappingAsync(const Model::AddLiveDomainMappingRequest& request, const AddLiveDomainMappingAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
AddLiveDomainMappingOutcomeCallable addLiveDomainMappingCallable(const Model::AddLiveDomainMappingRequest& request) const;
AddLiveDomainPlayMappingOutcome addLiveDomainPlayMapping(const Model::AddLiveDomainPlayMappingRequest &request)const;
void addLiveDomainPlayMappingAsync(const Model::AddLiveDomainPlayMappingRequest& request, const AddLiveDomainPlayMappingAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
AddLiveDomainPlayMappingOutcomeCallable addLiveDomainPlayMappingCallable(const Model::AddLiveDomainPlayMappingRequest& request) const;
AddLivePullStreamInfoConfigOutcome addLivePullStreamInfoConfig(const Model::AddLivePullStreamInfoConfigRequest &request)const;
void addLivePullStreamInfoConfigAsync(const Model::AddLivePullStreamInfoConfigRequest& request, const AddLivePullStreamInfoConfigAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
AddLivePullStreamInfoConfigOutcomeCallable addLivePullStreamInfoConfigCallable(const Model::AddLivePullStreamInfoConfigRequest& request) const;
@@ -1149,6 +1187,9 @@ namespace AlibabaCloud
CreateLiveStreamRecordIndexFilesOutcome createLiveStreamRecordIndexFiles(const Model::CreateLiveStreamRecordIndexFilesRequest &request)const;
void createLiveStreamRecordIndexFilesAsync(const Model::CreateLiveStreamRecordIndexFilesRequest& request, const CreateLiveStreamRecordIndexFilesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
CreateLiveStreamRecordIndexFilesOutcomeCallable createLiveStreamRecordIndexFilesCallable(const Model::CreateLiveStreamRecordIndexFilesRequest& request) const;
CreateMixStreamOutcome createMixStream(const Model::CreateMixStreamRequest &request)const;
void createMixStreamAsync(const Model::CreateMixStreamRequest& request, const CreateMixStreamAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
CreateMixStreamOutcomeCallable createMixStreamCallable(const Model::CreateMixStreamRequest& request) const;
CreateRoomOutcome createRoom(const Model::CreateRoomRequest &request)const;
void createRoomAsync(const Model::CreateRoomRequest& request, const CreateRoomAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
CreateRoomOutcomeCallable createRoomCallable(const Model::CreateRoomRequest& request) const;
@@ -1230,6 +1271,9 @@ namespace AlibabaCloud
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;
DeleteMixStreamOutcome deleteMixStream(const Model::DeleteMixStreamRequest &request)const;
void deleteMixStreamAsync(const Model::DeleteMixStreamRequest& request, const DeleteMixStreamAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
DeleteMixStreamOutcomeCallable deleteMixStreamCallable(const Model::DeleteMixStreamRequest& request) const;
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;
@@ -1368,6 +1412,9 @@ namespace AlibabaCloud
DescribeLiveLazyPullStreamConfigOutcome describeLiveLazyPullStreamConfig(const Model::DescribeLiveLazyPullStreamConfigRequest &request)const;
void describeLiveLazyPullStreamConfigAsync(const Model::DescribeLiveLazyPullStreamConfigRequest& request, const DescribeLiveLazyPullStreamConfigAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
DescribeLiveLazyPullStreamConfigOutcomeCallable describeLiveLazyPullStreamConfigCallable(const Model::DescribeLiveLazyPullStreamConfigRequest& request) const;
DescribeLivePullStreamConfigOutcome describeLivePullStreamConfig(const Model::DescribeLivePullStreamConfigRequest &request)const;
void describeLivePullStreamConfigAsync(const Model::DescribeLivePullStreamConfigRequest& request, const DescribeLivePullStreamConfigAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
DescribeLivePullStreamConfigOutcomeCallable describeLivePullStreamConfigCallable(const Model::DescribeLivePullStreamConfigRequest& request) const;
DescribeLiveRealtimeDeliveryAccOutcome describeLiveRealtimeDeliveryAcc(const Model::DescribeLiveRealtimeDeliveryAccRequest &request)const;
void describeLiveRealtimeDeliveryAccAsync(const Model::DescribeLiveRealtimeDeliveryAccRequest& request, const DescribeLiveRealtimeDeliveryAccAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
DescribeLiveRealtimeDeliveryAccOutcomeCallable describeLiveRealtimeDeliveryAccCallable(const Model::DescribeLiveRealtimeDeliveryAccRequest& request) const;
@@ -1455,6 +1502,9 @@ namespace AlibabaCloud
DescribeLiveUserTagsOutcome describeLiveUserTags(const Model::DescribeLiveUserTagsRequest &request)const;
void describeLiveUserTagsAsync(const Model::DescribeLiveUserTagsRequest& request, const DescribeLiveUserTagsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
DescribeLiveUserTagsOutcomeCallable describeLiveUserTagsCallable(const Model::DescribeLiveUserTagsRequest& request) const;
DescribeMixStreamListOutcome describeMixStreamList(const Model::DescribeMixStreamListRequest &request)const;
void describeMixStreamListAsync(const Model::DescribeMixStreamListRequest& request, const DescribeMixStreamListAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
DescribeMixStreamListOutcomeCallable describeMixStreamListCallable(const Model::DescribeMixStreamListRequest& request) const;
DescribeRecordOutcome describeRecord(const Model::DescribeRecordRequest &request)const;
void describeRecordAsync(const Model::DescribeRecordRequest& request, const DescribeRecordAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
DescribeRecordOutcomeCallable describeRecordCallable(const Model::DescribeRecordRequest& request) const;
@@ -1608,6 +1658,9 @@ namespace AlibabaCloud
TagLiveResourcesOutcome tagLiveResources(const Model::TagLiveResourcesRequest &request)const;
void tagLiveResourcesAsync(const Model::TagLiveResourcesRequest& request, const TagLiveResourcesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
TagLiveResourcesOutcomeCallable tagLiveResourcesCallable(const Model::TagLiveResourcesRequest& request) const;
TriggerRecordOutcome triggerRecord(const Model::TriggerRecordRequest &request)const;
void triggerRecordAsync(const Model::TriggerRecordRequest& request, const TriggerRecordAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
TriggerRecordOutcomeCallable triggerRecordCallable(const Model::TriggerRecordRequest& request) const;
UnTagLiveResourcesOutcome unTagLiveResources(const Model::UnTagLiveResourcesRequest &request)const;
void unTagLiveResourcesAsync(const Model::UnTagLiveResourcesRequest& request, const UnTagLiveResourcesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
UnTagLiveResourcesOutcomeCallable unTagLiveResourcesCallable(const Model::UnTagLiveResourcesRequest& request) const;
@@ -1644,6 +1697,9 @@ namespace AlibabaCloud
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;
UpdateMixStreamOutcome updateMixStream(const Model::UpdateMixStreamRequest &request)const;
void updateMixStreamAsync(const Model::UpdateMixStreamRequest& request, const UpdateMixStreamAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
UpdateMixStreamOutcomeCallable updateMixStreamCallable(const Model::UpdateMixStreamRequest& request) const;
private:
std::shared_ptr<EndpointProvider> endpointProvider_;

3
live/include/alibabacloud/live/model/AddCustomLiveStreamTranscodeRequest.h
View File

@@ -37,6 +37,8 @@ namespace AlibabaCloud
std::string get_Template()const;
void set_Template(const std::string& _template);
std::string getLazy()const;
void setLazy(const std::string& lazy);
std::string getGop()const;
void setGop(const std::string& gop);
std::string getAudioCodec()const;
@@ -70,6 +72,7 @@ namespace AlibabaCloud
private:
std::string _template_;
std::string lazy_;
std::string gop_;
std::string audioCodec_;
std::string templateType_;

54
live/include/alibabacloud/live/model/AddLiveDomainPlayMappingRequest.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_ADDLIVEDOMAINPLAYMAPPINGREQUEST_H_
#define ALIBABACLOUD_LIVE_MODEL_ADDLIVEDOMAINPLAYMAPPINGREQUEST_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 AddLiveDomainPlayMappingRequest : public RpcServiceRequest
{
public:
AddLiveDomainPlayMappingRequest();
~AddLiveDomainPlayMappingRequest();
std::string getPlayDomain()const;
void setPlayDomain(const std::string& playDomain);
long getOwnerId()const;
void setOwnerId(long ownerId);
std::string getPullDomain()const;
void setPullDomain(const std::string& pullDomain);
private:
std::string playDomain_;
long ownerId_;
std::string pullDomain_;
};
}
}
}
#endif // !ALIBABACLOUD_LIVE_MODEL_ADDLIVEDOMAINPLAYMAPPINGREQUEST_H_

49
live/include/alibabacloud/live/model/AddLiveDomainPlayMappingResult.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_ADDLIVEDOMAINPLAYMAPPINGRESULT_H_
#define ALIBABACLOUD_LIVE_MODEL_ADDLIVEDOMAINPLAYMAPPINGRESULT_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 AddLiveDomainPlayMappingResult : public ServiceResult
{
public:
AddLiveDomainPlayMappingResult();
explicit AddLiveDomainPlayMappingResult(const std::string &payload);
~AddLiveDomainPlayMappingResult();
protected:
void parse(const std::string &payload);
private:
};
}
}
}
#endif // !ALIBABACLOUD_LIVE_MODEL_ADDLIVEDOMAINPLAYMAPPINGRESULT_H_

18
live/include/alibabacloud/live/model/AddLiveStreamTranscodeRequest.h
View File

@@ -37,21 +37,33 @@ namespace AlibabaCloud
std::string get_Template()const;
void set_Template(const std::string& _template);
std::string getSecurityToken()const;
void setSecurityToken(const std::string& securityToken);
std::string getLazy()const;
void setLazy(const std::string& lazy);
std::string getMix()const;
void setMix(const std::string& mix);
std::string getApp()const;
void setApp(const std::string& app);
std::string getWatermark()const;
void setWatermark(const std::string& watermark);
long getOwnerId()const;
void setOwnerId(long ownerId);
std::string getDomain()const;
void setDomain(const std::string& domain);
std::string getWaterPattern()const;
void setWaterPattern(const std::string& waterPattern);
std::string getOnlyAudio()const;
void setOnlyAudio(const std::string& onlyAudio);
private:
std::string _template_;
std::string securityToken_;
std::string lazy_;
std::string mix_;
std::string app_;
std::string watermark_;
long ownerId_;
std::string domain_;
std::string waterPattern_;
std::string onlyAudio_;
};
}

3
live/include/alibabacloud/live/model/AddRtsLiveStreamTranscodeRequest.h
View File

@@ -39,6 +39,8 @@ namespace AlibabaCloud
void set_Template(const std::string& _template);
bool getDeleteBframes()const;
void setDeleteBframes(bool deleteBframes);
std::string getLazy()const;
void setLazy(const std::string& lazy);
std::string getGop()const;
void setGop(const std::string& gop);
bool getOpus()const;
@@ -75,6 +77,7 @@ namespace AlibabaCloud
private:
std::string _template_;
bool deleteBframes_;
std::string lazy_;
std::string gop_;
bool opus_;
std::string audioCodec_;

63
live/include/alibabacloud/live/model/CreateMixStreamRequest.h Normal file
View File

@@ -0,0 +1,63 @@
/*
* 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_CREATEMIXSTREAMREQUEST_H_
#define ALIBABACLOUD_LIVE_MODEL_CREATEMIXSTREAMREQUEST_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 CreateMixStreamRequest : public RpcServiceRequest
{
public:
CreateMixStreamRequest();
~CreateMixStreamRequest();
std::string getOutputConfig()const;
void setOutputConfig(const std::string& outputConfig);
std::string getLayoutId()const;
void setLayoutId(const std::string& layoutId);
std::string getDomainName()const;
void setDomainName(const std::string& domainName);
std::string getInputStreamList()const;
void setInputStreamList(const std::string& inputStreamList);
long getOwnerId()const;
void setOwnerId(long ownerId);
std::string getCallbackConfig()const;
void setCallbackConfig(const std::string& callbackConfig);
private:
std::string outputConfig_;
std::string layoutId_;
std::string domainName_;
std::string inputStreamList_;
long ownerId_;
std::string callbackConfig_;
};
}
}
}
#endif // !ALIBABACLOUD_LIVE_MODEL_CREATEMIXSTREAMREQUEST_H_

51
live/include/alibabacloud/live/model/CreateMixStreamResult.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_CREATEMIXSTREAMRESULT_H_
#define ALIBABACLOUD_LIVE_MODEL_CREATEMIXSTREAMRESULT_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 CreateMixStreamResult : public ServiceResult
{
public:
CreateMixStreamResult();
explicit CreateMixStreamResult(const std::string &payload);
~CreateMixStreamResult();
std::string getMixStreamId()const;
protected:
void parse(const std::string &payload);
private:
std::string mixStreamId_;
};
}
}
}
#endif // !ALIBABACLOUD_LIVE_MODEL_CREATEMIXSTREAMRESULT_H_

60
live/include/alibabacloud/live/model/DeleteMixStreamRequest.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_DELETEMIXSTREAMREQUEST_H_
#define ALIBABACLOUD_LIVE_MODEL_DELETEMIXSTREAMREQUEST_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 DeleteMixStreamRequest : public RpcServiceRequest
{
public:
DeleteMixStreamRequest();
~DeleteMixStreamRequest();
std::string getAppName()const;
void setAppName(const std::string& appName);
std::string getStreamName()const;
void setStreamName(const std::string& streamName);
std::string getMixStreamId()const;
void setMixStreamId(const std::string& mixStreamId);
std::string getDomainName()const;
void setDomainName(const std::string& domainName);
long getOwnerId()const;
void setOwnerId(long ownerId);
private:
std::string appName_;
std::string streamName_;
std::string mixStreamId_;
std::string domainName_;
long ownerId_;
};
}
}
}
#endif // !ALIBABACLOUD_LIVE_MODEL_DELETEMIXSTREAMREQUEST_H_

51
live/include/alibabacloud/live/model/DeleteMixStreamResult.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_DELETEMIXSTREAMRESULT_H_
#define ALIBABACLOUD_LIVE_MODEL_DELETEMIXSTREAMRESULT_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 DeleteMixStreamResult : public ServiceResult
{
public:
DeleteMixStreamResult();
explicit DeleteMixStreamResult(const std::string &payload);
~DeleteMixStreamResult();
std::string getMixStreamId()const;
protected:
void parse(const std::string &payload);
private:
std::string mixStreamId_;
};
}
}
}
#endif // !ALIBABACLOUD_LIVE_MODEL_DELETEMIXSTREAMRESULT_H_

54
live/include/alibabacloud/live/model/DescribeLivePullStreamConfigRequest.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_DESCRIBELIVEPULLSTREAMCONFIGREQUEST_H_
#define ALIBABACLOUD_LIVE_MODEL_DESCRIBELIVEPULLSTREAMCONFIGREQUEST_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 DescribeLivePullStreamConfigRequest : public RpcServiceRequest
{
public:
DescribeLivePullStreamConfigRequest();
~DescribeLivePullStreamConfigRequest();
std::string getLiveapiRequestFrom()const;
void setLiveapiRequestFrom(const std::string& liveapiRequestFrom);
std::string getDomainName()const;
void setDomainName(const std::string& domainName);
long getOwnerId()const;
void setOwnerId(long ownerId);
private:
std::string liveapiRequestFrom_;
std::string domainName_;
long ownerId_;
};
}
}
}
#endif // !ALIBABACLOUD_LIVE_MODEL_DESCRIBELIVEPULLSTREAMCONFIGREQUEST_H_

60
live/include/alibabacloud/live/model/DescribeLivePullStreamConfigResult.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_DESCRIBELIVEPULLSTREAMCONFIGRESULT_H_
#define ALIBABACLOUD_LIVE_MODEL_DESCRIBELIVEPULLSTREAMCONFIGRESULT_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 DescribeLivePullStreamConfigResult : public ServiceResult
{
public:
struct LiveAppRecord
{
std::string sourceUrl;
std::string streamName;
std::string endTime;
std::string domainName;
std::string startTime;
std::string appName;
};
DescribeLivePullStreamConfigResult();
explicit DescribeLivePullStreamConfigResult(const std::string &payload);
~DescribeLivePullStreamConfigResult();
std::vector<LiveAppRecord> getLiveAppRecordList()const;
protected:
void parse(const std::string &payload);
private:
std::vector<LiveAppRecord> liveAppRecordList_;
};
}
}
}
#endif // !ALIBABACLOUD_LIVE_MODEL_DESCRIBELIVEPULLSTREAMCONFIGRESULT_H_

72
live/include/alibabacloud/live/model/DescribeMixStreamListRequest.h Normal file
View File

@@ -0,0 +1,72 @@
/*
* 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_DESCRIBEMIXSTREAMLISTREQUEST_H_
#define ALIBABACLOUD_LIVE_MODEL_DESCRIBEMIXSTREAMLISTREQUEST_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 DescribeMixStreamListRequest : public RpcServiceRequest
{
public:
DescribeMixStreamListRequest();
~DescribeMixStreamListRequest();
std::string getStartTime()const;
void setStartTime(const std::string& startTime);
std::string getAppName()const;
void setAppName(const std::string& appName);
int getPageSize()const;
void setPageSize(int pageSize);
std::string getStreamName()const;
void setStreamName(const std::string& streamName);
std::string getMixStreamId()const;
void setMixStreamId(const std::string& mixStreamId);
std::string getDomainName()const;
void setDomainName(const std::string& domainName);
std::string getEndTime()const;
void setEndTime(const std::string& endTime);
long getOwnerId()const;
void setOwnerId(long ownerId);
int getPageNo()const;
void setPageNo(int pageNo);
private:
std::string startTime_;
std::string appName_;
int pageSize_;
std::string streamName_;
std::string mixStreamId_;
std::string domainName_;
std::string endTime_;
long ownerId_;
int pageNo_;
};
}
}
}
#endif // !ALIBABACLOUD_LIVE_MODEL_DESCRIBEMIXSTREAMLISTREQUEST_H_

65
live/include/alibabacloud/live/model/DescribeMixStreamListResult.h 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.
*/
#ifndef ALIBABACLOUD_LIVE_MODEL_DESCRIBEMIXSTREAMLISTRESULT_H_
#define ALIBABACLOUD_LIVE_MODEL_DESCRIBEMIXSTREAMLISTRESULT_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 DescribeMixStreamListResult : public ServiceResult
{
public:
struct MixStreamInfo
{
std::string gmtCreate;
std::string streamName;
std::string domainName;
std::string layoutId;
std::string gmtModified;
std::string mixStreamTemplate;
std::string mixstreamId;
int inputStreamNumber;
std::string appName;
};
DescribeMixStreamListResult();
explicit DescribeMixStreamListResult(const std::string &payload);
~DescribeMixStreamListResult();
int getTotal()const;
std::vector<MixStreamInfo> getMixStreamList()const;
protected:
void parse(const std::string &payload);
private:
int total_;
std::vector<MixStreamInfo> mixStreamList_;
};
}
}
}
#endif // !ALIBABACLOUD_LIVE_MODEL_DESCRIBEMIXSTREAMLISTRESULT_H_

75
live/include/alibabacloud/live/model/TriggerRecordRequest.h Normal file
View File

@@ -0,0 +1,75 @@
/*
* 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_TRIGGERRECORDREQUEST_H_
#define ALIBABACLOUD_LIVE_MODEL_TRIGGERRECORDREQUEST_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 TriggerRecordRequest : public RpcServiceRequest
{
public:
TriggerRecordRequest();
~TriggerRecordRequest();
int getSource()const;
void setSource(int source);
std::string getUserData()const;
void setUserData(const std::string& userData);
std::string getAppName()const;
void setAppName(const std::string& appName);
std::string getStreamName()const;
void setStreamName(const std::string& streamName);
std::string getAvMode()const;
void setAvMode(const std::string& avMode);
std::string getStorePath()const;
void setStorePath(const std::string& storePath);
std::string getDomainName()const;
void setDomainName(const std::string& domainName);
long getOwnerId()const;
void setOwnerId(long ownerId);
std::string getForceTranscode()const;
void setForceTranscode(const std::string& forceTranscode);
bool getNeedRecord()const;
void setNeedRecord(bool needRecord);
private:
int source_;
std::string userData_;
std::string appName_;
std::string streamName_;
std::string avMode_;
std::string storePath_;
std::string domainName_;
long ownerId_;
std::string forceTranscode_;
bool needRecord_;
};
}
}
}
#endif // !ALIBABACLOUD_LIVE_MODEL_TRIGGERRECORDREQUEST_H_

53
live/include/alibabacloud/live/model/TriggerRecordResult.h Normal file
View File

@@ -0,0 +1,53 @@
/*
* 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_TRIGGERRECORDRESULT_H_
#define ALIBABACLOUD_LIVE_MODEL_TRIGGERRECORDRESULT_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 TriggerRecordResult : public ServiceResult
{
public:
TriggerRecordResult();
explicit TriggerRecordResult(const std::string &payload);
~TriggerRecordResult();
std::string getTaskId()const;
std::string getResult()const;
protected:
void parse(const std::string &payload);
private:
std::string taskId_;
std::string result_;
};
}
}
}
#endif // !ALIBABACLOUD_LIVE_MODEL_TRIGGERRECORDRESULT_H_

60
live/include/alibabacloud/live/model/UpdateMixStreamRequest.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_UPDATEMIXSTREAMREQUEST_H_
#define ALIBABACLOUD_LIVE_MODEL_UPDATEMIXSTREAMREQUEST_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 UpdateMixStreamRequest : public RpcServiceRequest
{
public:
UpdateMixStreamRequest();
~UpdateMixStreamRequest();
std::string getLayoutId()const;
void setLayoutId(const std::string& layoutId);
std::string getMixStreamId()const;
void setMixStreamId(const std::string& mixStreamId);
std::string getDomainName()const;
void setDomainName(const std::string& domainName);
std::string getInputStreamList()const;
void setInputStreamList(const std::string& inputStreamList);
long getOwnerId()const;
void setOwnerId(long ownerId);
private:
std::string layoutId_;
std::string mixStreamId_;
std::string domainName_;
std::string inputStreamList_;
long ownerId_;
};
}
}
}
#endif // !ALIBABACLOUD_LIVE_MODEL_UPDATEMIXSTREAMREQUEST_H_

51
live/include/alibabacloud/live/model/UpdateMixStreamResult.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_UPDATEMIXSTREAMRESULT_H_
#define ALIBABACLOUD_LIVE_MODEL_UPDATEMIXSTREAMRESULT_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 UpdateMixStreamResult : public ServiceResult
{
public:
UpdateMixStreamResult();
explicit UpdateMixStreamResult(const std::string &payload);
~UpdateMixStreamResult();
std::string getMixStreamId()const;
protected:
void parse(const std::string &payload);
private:
std::string mixStreamId_;
};
}
}
}
#endif // !ALIBABACLOUD_LIVE_MODEL_UPDATEMIXSTREAMRESULT_H_

258
live/src/LiveClient.cc
View File

@@ -31,21 +31,21 @@ LiveClient::LiveClient(const Credentials &credentials, const ClientConfiguration
RpcServiceClient(SERVICE_NAME, std::make_shared<SimpleCredentialsProvider>(credentials), configuration)
{
auto locationClient = std::make_shared<LocationClient>(credentials, configuration);
endpointProvider_ = std::make_shared<EndpointProvider>(locationClient, configuration.regionId(), SERVICE_NAME, "");
endpointProvider_ = std::make_shared<EndpointProvider>(locationClient, configuration.regionId(), SERVICE_NAME, "live");
}
LiveClient::LiveClient(const std::shared_ptr<CredentialsProvider>& credentialsProvider, const ClientConfiguration & configuration) :
RpcServiceClient(SERVICE_NAME, credentialsProvider, configuration)
{
auto locationClient = std::make_shared<LocationClient>(credentialsProvider, configuration);
endpointProvider_ = std::make_shared<EndpointProvider>(locationClient, configuration.regionId(), SERVICE_NAME, "");
endpointProvider_ = std::make_shared<EndpointProvider>(locationClient, configuration.regionId(), SERVICE_NAME, "live");
}
LiveClient::LiveClient(const std::string & accessKeyId, const std::string & accessKeySecret, const ClientConfiguration & configuration) :
RpcServiceClient(SERVICE_NAME, std::make_shared<SimpleCredentialsProvider>(accessKeyId, accessKeySecret), configuration)
{
auto locationClient = std::make_shared<LocationClient>(accessKeyId, accessKeySecret, configuration);
endpointProvider_ = std::make_shared<EndpointProvider>(locationClient, configuration.regionId(), SERVICE_NAME, "");
endpointProvider_ = std::make_shared<EndpointProvider>(locationClient, configuration.regionId(), SERVICE_NAME, "live");
}
LiveClient::~LiveClient()
@@ -591,6 +591,42 @@ LiveClient::AddLiveDomainMappingOutcomeCallable LiveClient::addLiveDomainMapping
return task->get_future();
}
LiveClient::AddLiveDomainPlayMappingOutcome LiveClient::addLiveDomainPlayMapping(const AddLiveDomainPlayMappingRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return AddLiveDomainPlayMappingOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return AddLiveDomainPlayMappingOutcome(AddLiveDomainPlayMappingResult(outcome.result()));
else
return AddLiveDomainPlayMappingOutcome(outcome.error());
}
void LiveClient::addLiveDomainPlayMappingAsync(const AddLiveDomainPlayMappingRequest& request, const AddLiveDomainPlayMappingAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, addLiveDomainPlayMapping(request), context);
};
asyncExecute(new Runnable(fn));
}
LiveClient::AddLiveDomainPlayMappingOutcomeCallable LiveClient::addLiveDomainPlayMappingCallable(const AddLiveDomainPlayMappingRequest &request) const
{
auto task = std::make_shared<std::packaged_task<AddLiveDomainPlayMappingOutcome()>>(
[this, request]()
{
return this->addLiveDomainPlayMapping(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
LiveClient::AddLivePullStreamInfoConfigOutcome LiveClient::addLivePullStreamInfoConfig(const AddLivePullStreamInfoConfigRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -1347,6 +1383,42 @@ LiveClient::CreateLiveStreamRecordIndexFilesOutcomeCallable LiveClient::createLi
return task->get_future();
}
LiveClient::CreateMixStreamOutcome LiveClient::createMixStream(const CreateMixStreamRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return CreateMixStreamOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return CreateMixStreamOutcome(CreateMixStreamResult(outcome.result()));
else
return CreateMixStreamOutcome(outcome.error());
}
void LiveClient::createMixStreamAsync(const CreateMixStreamRequest& request, const CreateMixStreamAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, createMixStream(request), context);
};
asyncExecute(new Runnable(fn));
}
LiveClient::CreateMixStreamOutcomeCallable LiveClient::createMixStreamCallable(const CreateMixStreamRequest &request) const
{
auto task = std::make_shared<std::packaged_task<CreateMixStreamOutcome()>>(
[this, request]()
{
return this->createMixStream(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
LiveClient::CreateRoomOutcome LiveClient::createRoom(const CreateRoomRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -2319,6 +2391,42 @@ LiveClient::DeleteLiveStreamsNotifyUrlConfigOutcomeCallable LiveClient::deleteLi
return task->get_future();
}
LiveClient::DeleteMixStreamOutcome LiveClient::deleteMixStream(const DeleteMixStreamRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return DeleteMixStreamOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return DeleteMixStreamOutcome(DeleteMixStreamResult(outcome.result()));
else
return DeleteMixStreamOutcome(outcome.error());
}
void LiveClient::deleteMixStreamAsync(const DeleteMixStreamRequest& request, const DeleteMixStreamAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, deleteMixStream(request), context);
};
asyncExecute(new Runnable(fn));
}
LiveClient::DeleteMixStreamOutcomeCallable LiveClient::deleteMixStreamCallable(const DeleteMixStreamRequest &request) const
{
auto task = std::make_shared<std::packaged_task<DeleteMixStreamOutcome()>>(
[this, request]()
{
return this->deleteMixStream(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
LiveClient::DeleteRoomOutcome LiveClient::deleteRoom(const DeleteRoomRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -3975,6 +4083,42 @@ LiveClient::DescribeLiveLazyPullStreamConfigOutcomeCallable LiveClient::describe
return task->get_future();
}
LiveClient::DescribeLivePullStreamConfigOutcome LiveClient::describeLivePullStreamConfig(const DescribeLivePullStreamConfigRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return DescribeLivePullStreamConfigOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return DescribeLivePullStreamConfigOutcome(DescribeLivePullStreamConfigResult(outcome.result()));
else
return DescribeLivePullStreamConfigOutcome(outcome.error());
}
void LiveClient::describeLivePullStreamConfigAsync(const DescribeLivePullStreamConfigRequest& request, const DescribeLivePullStreamConfigAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, describeLivePullStreamConfig(request), context);
};
asyncExecute(new Runnable(fn));
}
LiveClient::DescribeLivePullStreamConfigOutcomeCallable LiveClient::describeLivePullStreamConfigCallable(const DescribeLivePullStreamConfigRequest &request) const
{
auto task = std::make_shared<std::packaged_task<DescribeLivePullStreamConfigOutcome()>>(
[this, request]()
{
return this->describeLivePullStreamConfig(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
LiveClient::DescribeLiveRealtimeDeliveryAccOutcome LiveClient::describeLiveRealtimeDeliveryAcc(const DescribeLiveRealtimeDeliveryAccRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -5019,6 +5163,42 @@ LiveClient::DescribeLiveUserTagsOutcomeCallable LiveClient::describeLiveUserTags
return task->get_future();
}
LiveClient::DescribeMixStreamListOutcome LiveClient::describeMixStreamList(const DescribeMixStreamListRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return DescribeMixStreamListOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return DescribeMixStreamListOutcome(DescribeMixStreamListResult(outcome.result()));
else
return DescribeMixStreamListOutcome(outcome.error());
}
void LiveClient::describeMixStreamListAsync(const DescribeMixStreamListRequest& request, const DescribeMixStreamListAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, describeMixStreamList(request), context);
};
asyncExecute(new Runnable(fn));
}
LiveClient::DescribeMixStreamListOutcomeCallable LiveClient::describeMixStreamListCallable(const DescribeMixStreamListRequest &request) const
{
auto task = std::make_shared<std::packaged_task<DescribeMixStreamListOutcome()>>(
[this, request]()
{
return this->describeMixStreamList(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
LiveClient::DescribeRecordOutcome LiveClient::describeRecord(const DescribeRecordRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -6855,6 +7035,42 @@ LiveClient::TagLiveResourcesOutcomeCallable LiveClient::tagLiveResourcesCallable
return task->get_future();
}
LiveClient::TriggerRecordOutcome LiveClient::triggerRecord(const TriggerRecordRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return TriggerRecordOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return TriggerRecordOutcome(TriggerRecordResult(outcome.result()));
else
return TriggerRecordOutcome(outcome.error());
}
void LiveClient::triggerRecordAsync(const TriggerRecordRequest& request, const TriggerRecordAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, triggerRecord(request), context);
};
asyncExecute(new Runnable(fn));
}
LiveClient::TriggerRecordOutcomeCallable LiveClient::triggerRecordCallable(const TriggerRecordRequest &request) const
{
auto task = std::make_shared<std::packaged_task<TriggerRecordOutcome()>>(
[this, request]()
{
return this->triggerRecord(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
LiveClient::UnTagLiveResourcesOutcome LiveClient::unTagLiveResources(const UnTagLiveResourcesRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -7287,3 +7503,39 @@ LiveClient::UpdateLiveTopLevelDomainOutcomeCallable LiveClient::updateLiveTopLev
return task->get_future();
}
LiveClient::UpdateMixStreamOutcome LiveClient::updateMixStream(const UpdateMixStreamRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return UpdateMixStreamOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return UpdateMixStreamOutcome(UpdateMixStreamResult(outcome.result()));
else
return UpdateMixStreamOutcome(outcome.error());
}
void LiveClient::updateMixStreamAsync(const UpdateMixStreamRequest& request, const UpdateMixStreamAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, updateMixStream(request), context);
};
asyncExecute(new Runnable(fn));
}
LiveClient::UpdateMixStreamOutcomeCallable LiveClient::updateMixStreamCallable(const UpdateMixStreamRequest &request) const
{
auto task = std::make_shared<std::packaged_task<UpdateMixStreamOutcome()>>(
[this, request]()
{
return this->updateMixStream(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}

11
live/src/model/AddCustomLiveStreamTranscodeRequest.cc
View File

@@ -38,6 +38,17 @@ void AddCustomLiveStreamTranscodeRequest::set_Template(const std::string& _templ
setParameter("_Template", _template);
}
std::string AddCustomLiveStreamTranscodeRequest::getLazy()const
{
return lazy_;
}
void AddCustomLiveStreamTranscodeRequest::setLazy(const std::string& lazy)
{
lazy_ = lazy;
setParameter("Lazy", lazy);
}
std::string AddCustomLiveStreamTranscodeRequest::getGop()const
{
return gop_;

62
live/src/model/AddLiveDomainPlayMappingRequest.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/AddLiveDomainPlayMappingRequest.h>
using AlibabaCloud::Live::Model::AddLiveDomainPlayMappingRequest;
AddLiveDomainPlayMappingRequest::AddLiveDomainPlayMappingRequest() :
RpcServiceRequest("live", "2016-11-01", "AddLiveDomainPlayMapping")
{
setMethod(HttpRequest::Method::Post);
}
AddLiveDomainPlayMappingRequest::~AddLiveDomainPlayMappingRequest()
{}
std::string AddLiveDomainPlayMappingRequest::getPlayDomain()const
{
return playDomain_;
}
void AddLiveDomainPlayMappingRequest::setPlayDomain(const std::string& playDomain)
{
playDomain_ = playDomain;
setParameter("PlayDomain", playDomain);
}
long AddLiveDomainPlayMappingRequest::getOwnerId()const
{
return ownerId_;
}
void AddLiveDomainPlayMappingRequest::setOwnerId(long ownerId)
{
ownerId_ = ownerId;
setParameter("OwnerId", std::to_string(ownerId));
}
std::string AddLiveDomainPlayMappingRequest::getPullDomain()const
{
return pullDomain_;
}
void AddLiveDomainPlayMappingRequest::setPullDomain(const std::string& pullDomain)
{
pullDomain_ = pullDomain;
setParameter("PullDomain", pullDomain);
}

44
live/src/model/AddLiveDomainPlayMappingResult.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/AddLiveDomainPlayMappingResult.h>
#include <json/json.h>
using namespace AlibabaCloud::Live;
using namespace AlibabaCloud::Live::Model;
AddLiveDomainPlayMappingResult::AddLiveDomainPlayMappingResult() :
ServiceResult()
{}
AddLiveDomainPlayMappingResult::AddLiveDomainPlayMappingResult(const std::string &payload) :
ServiceResult()
{
parse(payload);
}
AddLiveDomainPlayMappingResult::~AddLiveDomainPlayMappingResult()
{}
void AddLiveDomainPlayMappingResult::parse(const std::string &payload)
{
Json::Reader reader;
Json::Value value;
reader.parse(payload, value);
setRequestId(value["RequestId"].asString());
}

54
live/src/model/AddLiveStreamTranscodeRequest.cc
View File

@@ -38,15 +38,26 @@ void AddLiveStreamTranscodeRequest::set_Template(const std::string& _template)
setParameter("_Template", _template);
}
std::string AddLiveStreamTranscodeRequest::getSecurityToken()const
std::string AddLiveStreamTranscodeRequest::getLazy()const
{
return securityToken_;
return lazy_;
}
void AddLiveStreamTranscodeRequest::setSecurityToken(const std::string& securityToken)
void AddLiveStreamTranscodeRequest::setLazy(const std::string& lazy)
{
securityToken_ = securityToken;
setParameter("SecurityToken", securityToken);
lazy_ = lazy;
setParameter("Lazy", lazy);
}
std::string AddLiveStreamTranscodeRequest::getMix()const
{
return mix_;
}
void AddLiveStreamTranscodeRequest::setMix(const std::string& mix)
{
mix_ = mix;
setParameter("Mix", mix);
}
std::string AddLiveStreamTranscodeRequest::getApp()const
@@ -60,6 +71,17 @@ void AddLiveStreamTranscodeRequest::setApp(const std::string& app)
setParameter("App", app);
}
std::string AddLiveStreamTranscodeRequest::getWatermark()const
{
return watermark_;
}
void AddLiveStreamTranscodeRequest::setWatermark(const std::string& watermark)
{
watermark_ = watermark;
setParameter("Watermark", watermark);
}
long AddLiveStreamTranscodeRequest::getOwnerId()const
{
return ownerId_;
@@ -82,3 +104,25 @@ void AddLiveStreamTranscodeRequest::setDomain(const std::string& domain)
setParameter("Domain", domain);
}
std::string AddLiveStreamTranscodeRequest::getWaterPattern()const
{
return waterPattern_;
}
void AddLiveStreamTranscodeRequest::setWaterPattern(const std::string& waterPattern)
{
waterPattern_ = waterPattern;
setParameter("WaterPattern", waterPattern);
}
std::string AddLiveStreamTranscodeRequest::getOnlyAudio()const
{
return onlyAudio_;
}
void AddLiveStreamTranscodeRequest::setOnlyAudio(const std::string& onlyAudio)
{
onlyAudio_ = onlyAudio;
setParameter("OnlyAudio", onlyAudio);
}

11
live/src/model/AddRtsLiveStreamTranscodeRequest.cc
View File

@@ -49,6 +49,17 @@ void AddRtsLiveStreamTranscodeRequest::setDeleteBframes(bool deleteBframes)
setParameter("DeleteBframes", deleteBframes ? "true" : "false");
}
std::string AddRtsLiveStreamTranscodeRequest::getLazy()const
{
return lazy_;
}
void AddRtsLiveStreamTranscodeRequest::setLazy(const std::string& lazy)
{
lazy_ = lazy;
setParameter("Lazy", lazy);
}
std::string AddRtsLiveStreamTranscodeRequest::getGop()const
{
return gop_;

95
live/src/model/CreateMixStreamRequest.cc Normal file
View File

@@ -0,0 +1,95 @@
/*
* 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/CreateMixStreamRequest.h>
using AlibabaCloud::Live::Model::CreateMixStreamRequest;
CreateMixStreamRequest::CreateMixStreamRequest() :
RpcServiceRequest("live", "2016-11-01", "CreateMixStream")
{
setMethod(HttpRequest::Method::Post);
}
CreateMixStreamRequest::~CreateMixStreamRequest()
{}
std::string CreateMixStreamRequest::getOutputConfig()const
{
return outputConfig_;
}
void CreateMixStreamRequest::setOutputConfig(const std::string& outputConfig)
{
outputConfig_ = outputConfig;
setParameter("OutputConfig", outputConfig);
}
std::string CreateMixStreamRequest::getLayoutId()const
{
return layoutId_;
}
void CreateMixStreamRequest::setLayoutId(const std::string& layoutId)
{
layoutId_ = layoutId;
setParameter("LayoutId", layoutId);
}
std::string CreateMixStreamRequest::getDomainName()const
{
return domainName_;
}
void CreateMixStreamRequest::setDomainName(const std::string& domainName)
{
domainName_ = domainName;
setParameter("DomainName", domainName);
}
std::string CreateMixStreamRequest::getInputStreamList()const
{
return inputStreamList_;
}
void CreateMixStreamRequest::setInputStreamList(const std::string& inputStreamList)
{
inputStreamList_ = inputStreamList;
setParameter("InputStreamList", inputStreamList);
}
long CreateMixStreamRequest::getOwnerId()const
{
return ownerId_;
}
void CreateMixStreamRequest::setOwnerId(long ownerId)
{
ownerId_ = ownerId;
setParameter("OwnerId", std::to_string(ownerId));
}
std::string CreateMixStreamRequest::getCallbackConfig()const
{
return callbackConfig_;
}
void CreateMixStreamRequest::setCallbackConfig(const std::string& callbackConfig)
{
callbackConfig_ = callbackConfig;
setParameter("CallbackConfig", callbackConfig);
}

51
live/src/model/CreateMixStreamResult.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/CreateMixStreamResult.h>
#include <json/json.h>
using namespace AlibabaCloud::Live;
using namespace AlibabaCloud::Live::Model;
CreateMixStreamResult::CreateMixStreamResult() :
ServiceResult()
{}
CreateMixStreamResult::CreateMixStreamResult(const std::string &payload) :
ServiceResult()
{
parse(payload);
}
CreateMixStreamResult::~CreateMixStreamResult()
{}
void CreateMixStreamResult::parse(const std::string &payload)
{
Json::Reader reader;
Json::Value value;
reader.parse(payload, value);
setRequestId(value["RequestId"].asString());
if(!value["MixStreamId"].isNull())
mixStreamId_ = value["MixStreamId"].asString();
}
std::string CreateMixStreamResult::getMixStreamId()const
{
return mixStreamId_;
}

84
live/src/model/DeleteMixStreamRequest.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/DeleteMixStreamRequest.h>
using AlibabaCloud::Live::Model::DeleteMixStreamRequest;
DeleteMixStreamRequest::DeleteMixStreamRequest() :
RpcServiceRequest("live", "2016-11-01", "DeleteMixStream")
{
setMethod(HttpRequest::Method::Post);
}
DeleteMixStreamRequest::~DeleteMixStreamRequest()
{}
std::string DeleteMixStreamRequest::getAppName()const
{
return appName_;
}
void DeleteMixStreamRequest::setAppName(const std::string& appName)
{
appName_ = appName;
setParameter("AppName", appName);
}
std::string DeleteMixStreamRequest::getStreamName()const
{
return streamName_;
}
void DeleteMixStreamRequest::setStreamName(const std::string& streamName)
{
streamName_ = streamName;
setParameter("StreamName", streamName);
}
std::string DeleteMixStreamRequest::getMixStreamId()const
{
return mixStreamId_;
}
void DeleteMixStreamRequest::setMixStreamId(const std::string& mixStreamId)
{
mixStreamId_ = mixStreamId;
setParameter("MixStreamId", mixStreamId);
}
std::string DeleteMixStreamRequest::getDomainName()const
{
return domainName_;
}
void DeleteMixStreamRequest::setDomainName(const std::string& domainName)
{
domainName_ = domainName;
setParameter("DomainName", domainName);
}
long DeleteMixStreamRequest::getOwnerId()const
{
return ownerId_;
}
void DeleteMixStreamRequest::setOwnerId(long ownerId)
{
ownerId_ = ownerId;
setParameter("OwnerId", std::to_string(ownerId));
}

51
live/src/model/DeleteMixStreamResult.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/DeleteMixStreamResult.h>
#include <json/json.h>
using namespace AlibabaCloud::Live;
using namespace AlibabaCloud::Live::Model;
DeleteMixStreamResult::DeleteMixStreamResult() :
ServiceResult()
{}
DeleteMixStreamResult::DeleteMixStreamResult(const std::string &payload) :
ServiceResult()
{
parse(payload);
}
DeleteMixStreamResult::~DeleteMixStreamResult()
{}
void DeleteMixStreamResult::parse(const std::string &payload)
{
Json::Reader reader;
Json::Value value;
reader.parse(payload, value);
setRequestId(value["RequestId"].asString());
if(!value["MixStreamId"].isNull())
mixStreamId_ = value["MixStreamId"].asString();
}
std::string DeleteMixStreamResult::getMixStreamId()const
{
return mixStreamId_;
}

62
live/src/model/DescribeLivePullStreamConfigRequest.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/DescribeLivePullStreamConfigRequest.h>
using AlibabaCloud::Live::Model::DescribeLivePullStreamConfigRequest;
DescribeLivePullStreamConfigRequest::DescribeLivePullStreamConfigRequest() :
RpcServiceRequest("live", "2016-11-01", "DescribeLivePullStreamConfig")
{
setMethod(HttpRequest::Method::Post);
}
DescribeLivePullStreamConfigRequest::~DescribeLivePullStreamConfigRequest()
{}
std::string DescribeLivePullStreamConfigRequest::getLiveapiRequestFrom()const
{
return liveapiRequestFrom_;
}
void DescribeLivePullStreamConfigRequest::setLiveapiRequestFrom(const std::string& liveapiRequestFrom)
{
liveapiRequestFrom_ = liveapiRequestFrom;
setParameter("LiveapiRequestFrom", liveapiRequestFrom);
}
std::string DescribeLivePullStreamConfigRequest::getDomainName()const
{
return domainName_;
}
void DescribeLivePullStreamConfigRequest::setDomainName(const std::string& domainName)
{
domainName_ = domainName;
setParameter("DomainName", domainName);
}
long DescribeLivePullStreamConfigRequest::getOwnerId()const
{
return ownerId_;
}
void DescribeLivePullStreamConfigRequest::setOwnerId(long ownerId)
{
ownerId_ = ownerId;
setParameter("OwnerId", std::to_string(ownerId));
}

67
live/src/model/DescribeLivePullStreamConfigResult.cc Normal file
View File

@@ -0,0 +1,67 @@
/*
* 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/DescribeLivePullStreamConfigResult.h>
#include <json/json.h>
using namespace AlibabaCloud::Live;
using namespace AlibabaCloud::Live::Model;
DescribeLivePullStreamConfigResult::DescribeLivePullStreamConfigResult() :
ServiceResult()
{}
DescribeLivePullStreamConfigResult::DescribeLivePullStreamConfigResult(const std::string &payload) :
ServiceResult()
{
parse(payload);
}
DescribeLivePullStreamConfigResult::~DescribeLivePullStreamConfigResult()
{}
void DescribeLivePullStreamConfigResult::parse(const std::string &payload)
{
Json::Reader reader;
Json::Value value;
reader.parse(payload, value);
setRequestId(value["RequestId"].asString());
auto allLiveAppRecordListNode = value["LiveAppRecordList"]["LiveAppRecord"];
for (auto valueLiveAppRecordListLiveAppRecord : allLiveAppRecordListNode)
{
LiveAppRecord liveAppRecordListObject;
if(!valueLiveAppRecordListLiveAppRecord["DomainName"].isNull())
liveAppRecordListObject.domainName = valueLiveAppRecordListLiveAppRecord["DomainName"].asString();
if(!valueLiveAppRecordListLiveAppRecord["AppName"].isNull())
liveAppRecordListObject.appName = valueLiveAppRecordListLiveAppRecord["AppName"].asString();
if(!valueLiveAppRecordListLiveAppRecord["StreamName"].isNull())
liveAppRecordListObject.streamName = valueLiveAppRecordListLiveAppRecord["StreamName"].asString();
if(!valueLiveAppRecordListLiveAppRecord["SourceUrl"].isNull())
liveAppRecordListObject.sourceUrl = valueLiveAppRecordListLiveAppRecord["SourceUrl"].asString();
if(!valueLiveAppRecordListLiveAppRecord["StartTime"].isNull())
liveAppRecordListObject.startTime = valueLiveAppRecordListLiveAppRecord["StartTime"].asString();
if(!valueLiveAppRecordListLiveAppRecord["EndTime"].isNull())
liveAppRecordListObject.endTime = valueLiveAppRecordListLiveAppRecord["EndTime"].asString();
liveAppRecordList_.push_back(liveAppRecordListObject);
}
}
std::vector<DescribeLivePullStreamConfigResult::LiveAppRecord> DescribeLivePullStreamConfigResult::getLiveAppRecordList()const
{
return liveAppRecordList_;
}

128
live/src/model/DescribeMixStreamListRequest.cc Normal file
View File

@@ -0,0 +1,128 @@
/*
* 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/DescribeMixStreamListRequest.h>
using AlibabaCloud::Live::Model::DescribeMixStreamListRequest;
DescribeMixStreamListRequest::DescribeMixStreamListRequest() :
RpcServiceRequest("live", "2016-11-01", "DescribeMixStreamList")
{
setMethod(HttpRequest::Method::Post);
}
DescribeMixStreamListRequest::~DescribeMixStreamListRequest()
{}
std::string DescribeMixStreamListRequest::getStartTime()const
{
return startTime_;
}
void DescribeMixStreamListRequest::setStartTime(const std::string& startTime)
{
startTime_ = startTime;
setParameter("StartTime", startTime);
}
std::string DescribeMixStreamListRequest::getAppName()const
{
return appName_;
}
void DescribeMixStreamListRequest::setAppName(const std::string& appName)
{
appName_ = appName;
setParameter("AppName", appName);
}
int DescribeMixStreamListRequest::getPageSize()const
{
return pageSize_;
}
void DescribeMixStreamListRequest::setPageSize(int pageSize)
{
pageSize_ = pageSize;
setParameter("PageSize", std::to_string(pageSize));
}
std::string DescribeMixStreamListRequest::getStreamName()const
{
return streamName_;
}
void DescribeMixStreamListRequest::setStreamName(const std::string& streamName)
{
streamName_ = streamName;
setParameter("StreamName", streamName);
}
std::string DescribeMixStreamListRequest::getMixStreamId()const
{
return mixStreamId_;
}
void DescribeMixStreamListRequest::setMixStreamId(const std::string& mixStreamId)
{
mixStreamId_ = mixStreamId;
setParameter("MixStreamId", mixStreamId);
}
std::string DescribeMixStreamListRequest::getDomainName()const
{
return domainName_;
}
void DescribeMixStreamListRequest::setDomainName(const std::string& domainName)
{
domainName_ = domainName;
setParameter("DomainName", domainName);
}
std::string DescribeMixStreamListRequest::getEndTime()const
{
return endTime_;
}
void DescribeMixStreamListRequest::setEndTime(const std::string& endTime)
{
endTime_ = endTime;
setParameter("EndTime", endTime);
}
long DescribeMixStreamListRequest::getOwnerId()const
{
return ownerId_;
}
void DescribeMixStreamListRequest::setOwnerId(long ownerId)
{
ownerId_ = ownerId;
setParameter("OwnerId", std::to_string(ownerId));
}
int DescribeMixStreamListRequest::getPageNo()const
{
return pageNo_;
}
void DescribeMixStreamListRequest::setPageNo(int pageNo)
{
pageNo_ = pageNo;
setParameter("PageNo", std::to_string(pageNo));
}

80
live/src/model/DescribeMixStreamListResult.cc Normal file
View File

@@ -0,0 +1,80 @@
/*
* 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/DescribeMixStreamListResult.h>
#include <json/json.h>
using namespace AlibabaCloud::Live;
using namespace AlibabaCloud::Live::Model;
DescribeMixStreamListResult::DescribeMixStreamListResult() :
ServiceResult()
{}
DescribeMixStreamListResult::DescribeMixStreamListResult(const std::string &payload) :
ServiceResult()
{
parse(payload);
}
DescribeMixStreamListResult::~DescribeMixStreamListResult()
{}
void DescribeMixStreamListResult::parse(const std::string &payload)
{
Json::Reader reader;
Json::Value value;
reader.parse(payload, value);
setRequestId(value["RequestId"].asString());
auto allMixStreamListNode = value["MixStreamList"]["MixStreamInfo"];
for (auto valueMixStreamListMixStreamInfo : allMixStreamListNode)
{
MixStreamInfo mixStreamListObject;
if(!valueMixStreamListMixStreamInfo["MixstreamId"].isNull())
mixStreamListObject.mixstreamId = valueMixStreamListMixStreamInfo["MixstreamId"].asString();
if(!valueMixStreamListMixStreamInfo["DomainName"].isNull())
mixStreamListObject.domainName = valueMixStreamListMixStreamInfo["DomainName"].asString();
if(!valueMixStreamListMixStreamInfo["AppName"].isNull())
mixStreamListObject.appName = valueMixStreamListMixStreamInfo["AppName"].asString();
if(!valueMixStreamListMixStreamInfo["StreamName"].isNull())
mixStreamListObject.streamName = valueMixStreamListMixStreamInfo["StreamName"].asString();
if(!valueMixStreamListMixStreamInfo["LayoutId"].isNull())
mixStreamListObject.layoutId = valueMixStreamListMixStreamInfo["LayoutId"].asString();
if(!valueMixStreamListMixStreamInfo["InputStreamNumber"].isNull())
mixStreamListObject.inputStreamNumber = std::stoi(valueMixStreamListMixStreamInfo["InputStreamNumber"].asString());
if(!valueMixStreamListMixStreamInfo["MixStreamTemplate"].isNull())
mixStreamListObject.mixStreamTemplate = valueMixStreamListMixStreamInfo["MixStreamTemplate"].asString();
if(!valueMixStreamListMixStreamInfo["GmtCreate"].isNull())
mixStreamListObject.gmtCreate = valueMixStreamListMixStreamInfo["GmtCreate"].asString();
if(!valueMixStreamListMixStreamInfo["GmtModified"].isNull())
mixStreamListObject.gmtModified = valueMixStreamListMixStreamInfo["GmtModified"].asString();
mixStreamList_.push_back(mixStreamListObject);
}
if(!value["Total"].isNull())
total_ = std::stoi(value["Total"].asString());
}
int DescribeMixStreamListResult::getTotal()const
{
return total_;
}
std::vector<DescribeMixStreamListResult::MixStreamInfo> DescribeMixStreamListResult::getMixStreamList()const
{
return mixStreamList_;
}

139
live/src/model/TriggerRecordRequest.cc Normal file
View File

@@ -0,0 +1,139 @@
/*
* 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/TriggerRecordRequest.h>
using AlibabaCloud::Live::Model::TriggerRecordRequest;
TriggerRecordRequest::TriggerRecordRequest() :
RpcServiceRequest("live", "2016-11-01", "TriggerRecord")
{
setMethod(HttpRequest::Method::Post);
}
TriggerRecordRequest::~TriggerRecordRequest()
{}
int TriggerRecordRequest::getSource()const
{
return source_;
}
void TriggerRecordRequest::setSource(int source)
{
source_ = source;
setParameter("Source", std::to_string(source));
}
std::string TriggerRecordRequest::getUserData()const
{
return userData_;
}
void TriggerRecordRequest::setUserData(const std::string& userData)
{
userData_ = userData;
setParameter("UserData", userData);
}
std::string TriggerRecordRequest::getAppName()const
{
return appName_;
}
void TriggerRecordRequest::setAppName(const std::string& appName)
{
appName_ = appName;
setParameter("AppName", appName);
}
std::string TriggerRecordRequest::getStreamName()const
{
return streamName_;
}
void TriggerRecordRequest::setStreamName(const std::string& streamName)
{
streamName_ = streamName;
setParameter("StreamName", streamName);
}
std::string TriggerRecordRequest::getAvMode()const
{
return avMode_;
}
void TriggerRecordRequest::setAvMode(const std::string& avMode)
{
avMode_ = avMode;
setParameter("AvMode", avMode);
}
std::string TriggerRecordRequest::getStorePath()const
{
return storePath_;
}
void TriggerRecordRequest::setStorePath(const std::string& storePath)
{
storePath_ = storePath;
setParameter("StorePath", storePath);
}
std::string TriggerRecordRequest::getDomainName()const
{
return domainName_;
}
void TriggerRecordRequest::setDomainName(const std::string& domainName)
{
domainName_ = domainName;
setParameter("DomainName", domainName);
}
long TriggerRecordRequest::getOwnerId()const
{
return ownerId_;
}
void TriggerRecordRequest::setOwnerId(long ownerId)
{
ownerId_ = ownerId;
setParameter("OwnerId", std::to_string(ownerId));
}
std::string TriggerRecordRequest::getForceTranscode()const
{
return forceTranscode_;
}
void TriggerRecordRequest::setForceTranscode(const std::string& forceTranscode)
{
forceTranscode_ = forceTranscode;
setParameter("ForceTranscode", forceTranscode);
}
bool TriggerRecordRequest::getNeedRecord()const
{
return needRecord_;
}
void TriggerRecordRequest::setNeedRecord(bool needRecord)
{
needRecord_ = needRecord;
setParameter("NeedRecord", needRecord ? "true" : "false");
}

58
live/src/model/TriggerRecordResult.cc Normal file
View File

@@ -0,0 +1,58 @@
/*
* 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/TriggerRecordResult.h>
#include <json/json.h>
using namespace AlibabaCloud::Live;
using namespace AlibabaCloud::Live::Model;
TriggerRecordResult::TriggerRecordResult() :
ServiceResult()
{}
TriggerRecordResult::TriggerRecordResult(const std::string &payload) :
ServiceResult()
{
parse(payload);
}
TriggerRecordResult::~TriggerRecordResult()
{}
void TriggerRecordResult::parse(const std::string &payload)
{
Json::Reader reader;
Json::Value value;
reader.parse(payload, value);
setRequestId(value["RequestId"].asString());
if(!value["Result"].isNull())
result_ = value["Result"].asString();
if(!value["TaskId"].isNull())
taskId_ = value["TaskId"].asString();
}
std::string TriggerRecordResult::getTaskId()const
{
return taskId_;
}
std::string TriggerRecordResult::getResult()const
{
return result_;
}

84
live/src/model/UpdateMixStreamRequest.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/UpdateMixStreamRequest.h>
using AlibabaCloud::Live::Model::UpdateMixStreamRequest;
UpdateMixStreamRequest::UpdateMixStreamRequest() :
RpcServiceRequest("live", "2016-11-01", "UpdateMixStream")
{
setMethod(HttpRequest::Method::Post);
}
UpdateMixStreamRequest::~UpdateMixStreamRequest()
{}
std::string UpdateMixStreamRequest::getLayoutId()const
{
return layoutId_;
}
void UpdateMixStreamRequest::setLayoutId(const std::string& layoutId)
{
layoutId_ = layoutId;
setParameter("LayoutId", layoutId);
}
std::string UpdateMixStreamRequest::getMixStreamId()const
{
return mixStreamId_;
}
void UpdateMixStreamRequest::setMixStreamId(const std::string& mixStreamId)
{
mixStreamId_ = mixStreamId;
setParameter("MixStreamId", mixStreamId);
}
std::string UpdateMixStreamRequest::getDomainName()const
{
return domainName_;
}
void UpdateMixStreamRequest::setDomainName(const std::string& domainName)
{
domainName_ = domainName;
setParameter("DomainName", domainName);
}
std::string UpdateMixStreamRequest::getInputStreamList()const
{
return inputStreamList_;
}
void UpdateMixStreamRequest::setInputStreamList(const std::string& inputStreamList)
{
inputStreamList_ = inputStreamList;
setParameter("InputStreamList", inputStreamList);
}
long UpdateMixStreamRequest::getOwnerId()const
{
return ownerId_;
}
void UpdateMixStreamRequest::setOwnerId(long ownerId)
{
ownerId_ = ownerId;
setParameter("OwnerId", std::to_string(ownerId));
}

51
live/src/model/UpdateMixStreamResult.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/UpdateMixStreamResult.h>
#include <json/json.h>
using namespace AlibabaCloud::Live;
using namespace AlibabaCloud::Live::Model;
UpdateMixStreamResult::UpdateMixStreamResult() :
ServiceResult()
{}
UpdateMixStreamResult::UpdateMixStreamResult(const std::string &payload) :
ServiceResult()
{
parse(payload);
}
UpdateMixStreamResult::~UpdateMixStreamResult()
{}
void UpdateMixStreamResult::parse(const std::string &payload)
{
Json::Reader reader;
Json::Value value;
reader.parse(payload, value);
setRequestId(value["RequestId"].asString());
if(!value["MixStreamId"].isNull())
mixStreamId_ = value["MixStreamId"].asString();
}
std::string UpdateMixStreamResult::getMixStreamId()const
{
return mixStreamId_;
}