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

Live sdk update.

Browse Source
This commit is contained in:
sdk-team
2023-03-23 06:53:07 +00:00
parent 08dd92a830
commit 9bf268a2db
40 changed files with 2116 additions and 3 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
VERSION
View File

@@ -1 +1 @@
1.36.1512
1.36.1513

28
live/CMakeLists.txt
View File

@@ -87,6 +87,8 @@ set(live_public_header_model
include/alibabacloud/live/model/AllowPushStreamResult.h
include/alibabacloud/live/model/BatchDeleteLiveDomainConfigsRequest.h
include/alibabacloud/live/model/BatchDeleteLiveDomainConfigsResult.h
include/alibabacloud/live/model/BatchGetOnlineUsersRequest.h
include/alibabacloud/live/model/BatchGetOnlineUsersResult.h
include/alibabacloud/live/model/BatchSetLiveDomainConfigsRequest.h
include/alibabacloud/live/model/BatchSetLiveDomainConfigsResult.h
include/alibabacloud/live/model/CancelMuteAllGroupUserRequest.h
@@ -103,6 +105,8 @@ set(live_public_header_model
include/alibabacloud/live/model/CreateCasterResult.h
include/alibabacloud/live/model/CreateCustomTemplateRequest.h
include/alibabacloud/live/model/CreateCustomTemplateResult.h
include/alibabacloud/live/model/CreateLiveDelayConfigRequest.h
include/alibabacloud/live/model/CreateLiveDelayConfigResult.h
include/alibabacloud/live/model/CreateLiveRealTimeLogDeliveryRequest.h
include/alibabacloud/live/model/CreateLiveRealTimeLogDeliveryResult.h
include/alibabacloud/live/model/CreateLiveStreamMonitorRequest.h
@@ -145,6 +149,8 @@ set(live_public_header_model
include/alibabacloud/live/model/DeleteLiveAudioAuditNotifyConfigResult.h
include/alibabacloud/live/model/DeleteLiveCenterTransferRequest.h
include/alibabacloud/live/model/DeleteLiveCenterTransferResult.h
include/alibabacloud/live/model/DeleteLiveDelayConfigRequest.h
include/alibabacloud/live/model/DeleteLiveDelayConfigResult.h
include/alibabacloud/live/model/DeleteLiveDetectNotifyConfigRequest.h
include/alibabacloud/live/model/DeleteLiveDetectNotifyConfigResult.h
include/alibabacloud/live/model/DeleteLiveDomainRequest.h
@@ -245,6 +251,8 @@ set(live_public_header_model
include/alibabacloud/live/model/DescribeLiveCertificateDetailResult.h
include/alibabacloud/live/model/DescribeLiveCertificateListRequest.h
include/alibabacloud/live/model/DescribeLiveCertificateListResult.h
include/alibabacloud/live/model/DescribeLiveDelayConfigRequest.h
include/alibabacloud/live/model/DescribeLiveDelayConfigResult.h
include/alibabacloud/live/model/DescribeLiveDelayedStreamingUsageRequest.h
include/alibabacloud/live/model/DescribeLiveDelayedStreamingUsageResult.h
include/alibabacloud/live/model/DescribeLiveDetectNotifyConfigRequest.h
@@ -321,6 +329,8 @@ set(live_public_header_model
include/alibabacloud/live/model/DescribeLiveRecordConfigResult.h
include/alibabacloud/live/model/DescribeLiveRecordNotifyConfigRequest.h
include/alibabacloud/live/model/DescribeLiveRecordNotifyConfigResult.h
include/alibabacloud/live/model/DescribeLiveRecordNotifyRecordsRequest.h
include/alibabacloud/live/model/DescribeLiveRecordNotifyRecordsResult.h
include/alibabacloud/live/model/DescribeLiveRecordVodConfigsRequest.h
include/alibabacloud/live/model/DescribeLiveRecordVodConfigsResult.h
include/alibabacloud/live/model/DescribeLiveShiftConfigsRequest.h
@@ -465,6 +475,8 @@ set(live_public_header_model
include/alibabacloud/live/model/JoinMessageGroupResult.h
include/alibabacloud/live/model/LeaveMessageGroupRequest.h
include/alibabacloud/live/model/LeaveMessageGroupResult.h
include/alibabacloud/live/model/ListLiveDelayConfigRequest.h
include/alibabacloud/live/model/ListLiveDelayConfigResult.h
include/alibabacloud/live/model/ListLiveRealtimeLogDeliveryRequest.h
include/alibabacloud/live/model/ListLiveRealtimeLogDeliveryResult.h
include/alibabacloud/live/model/ListLiveRealtimeLogDeliveryDomainsRequest.h
@@ -603,6 +615,8 @@ set(live_public_header_model
include/alibabacloud/live/model/UpdateLiveAudioAuditNotifyConfigResult.h
include/alibabacloud/live/model/UpdateLiveCenterTransferRequest.h
include/alibabacloud/live/model/UpdateLiveCenterTransferResult.h
include/alibabacloud/live/model/UpdateLiveDelayConfigRequest.h
include/alibabacloud/live/model/UpdateLiveDelayConfigResult.h
include/alibabacloud/live/model/UpdateLiveDetectNotifyConfigRequest.h
include/alibabacloud/live/model/UpdateLiveDetectNotifyConfigResult.h
include/alibabacloud/live/model/UpdateLivePullStreamInfoConfigRequest.h
@@ -698,6 +712,8 @@ set(live_src
src/model/AllowPushStreamResult.cc
src/model/BatchDeleteLiveDomainConfigsRequest.cc
src/model/BatchDeleteLiveDomainConfigsResult.cc
src/model/BatchGetOnlineUsersRequest.cc
src/model/BatchGetOnlineUsersResult.cc
src/model/BatchSetLiveDomainConfigsRequest.cc
src/model/BatchSetLiveDomainConfigsResult.cc
src/model/CancelMuteAllGroupUserRequest.cc
@@ -714,6 +730,8 @@ set(live_src
src/model/CreateCasterResult.cc
src/model/CreateCustomTemplateRequest.cc
src/model/CreateCustomTemplateResult.cc
src/model/CreateLiveDelayConfigRequest.cc
src/model/CreateLiveDelayConfigResult.cc
src/model/CreateLiveRealTimeLogDeliveryRequest.cc
src/model/CreateLiveRealTimeLogDeliveryResult.cc
src/model/CreateLiveStreamMonitorRequest.cc
@@ -756,6 +774,8 @@ set(live_src
src/model/DeleteLiveAudioAuditNotifyConfigResult.cc
src/model/DeleteLiveCenterTransferRequest.cc
src/model/DeleteLiveCenterTransferResult.cc
src/model/DeleteLiveDelayConfigRequest.cc
src/model/DeleteLiveDelayConfigResult.cc
src/model/DeleteLiveDetectNotifyConfigRequest.cc
src/model/DeleteLiveDetectNotifyConfigResult.cc
src/model/DeleteLiveDomainRequest.cc
@@ -856,6 +876,8 @@ set(live_src
src/model/DescribeLiveCertificateDetailResult.cc
src/model/DescribeLiveCertificateListRequest.cc
src/model/DescribeLiveCertificateListResult.cc
src/model/DescribeLiveDelayConfigRequest.cc
src/model/DescribeLiveDelayConfigResult.cc
src/model/DescribeLiveDelayedStreamingUsageRequest.cc
src/model/DescribeLiveDelayedStreamingUsageResult.cc
src/model/DescribeLiveDetectNotifyConfigRequest.cc
@@ -932,6 +954,8 @@ set(live_src
src/model/DescribeLiveRecordConfigResult.cc
src/model/DescribeLiveRecordNotifyConfigRequest.cc
src/model/DescribeLiveRecordNotifyConfigResult.cc
src/model/DescribeLiveRecordNotifyRecordsRequest.cc
src/model/DescribeLiveRecordNotifyRecordsResult.cc
src/model/DescribeLiveRecordVodConfigsRequest.cc
src/model/DescribeLiveRecordVodConfigsResult.cc
src/model/DescribeLiveShiftConfigsRequest.cc
@@ -1076,6 +1100,8 @@ set(live_src
src/model/JoinMessageGroupResult.cc
src/model/LeaveMessageGroupRequest.cc
src/model/LeaveMessageGroupResult.cc
src/model/ListLiveDelayConfigRequest.cc
src/model/ListLiveDelayConfigResult.cc
src/model/ListLiveRealtimeLogDeliveryRequest.cc
src/model/ListLiveRealtimeLogDeliveryResult.cc
src/model/ListLiveRealtimeLogDeliveryDomainsRequest.cc
@@ -1214,6 +1240,8 @@ set(live_src
src/model/UpdateLiveAudioAuditNotifyConfigResult.cc
src/model/UpdateLiveCenterTransferRequest.cc
src/model/UpdateLiveCenterTransferResult.cc
src/model/UpdateLiveDelayConfigRequest.cc
src/model/UpdateLiveDelayConfigResult.cc
src/model/UpdateLiveDetectNotifyConfigRequest.cc
src/model/UpdateLiveDetectNotifyConfigResult.cc
src/model/UpdateLivePullStreamInfoConfigRequest.cc

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

@@ -88,6 +88,8 @@
#include "model/AllowPushStreamResult.h"
#include "model/BatchDeleteLiveDomainConfigsRequest.h"
#include "model/BatchDeleteLiveDomainConfigsResult.h"
#include "model/BatchGetOnlineUsersRequest.h"
#include "model/BatchGetOnlineUsersResult.h"
#include "model/BatchSetLiveDomainConfigsRequest.h"
#include "model/BatchSetLiveDomainConfigsResult.h"
#include "model/CancelMuteAllGroupUserRequest.h"
@@ -104,6 +106,8 @@
#include "model/CreateCasterResult.h"
#include "model/CreateCustomTemplateRequest.h"
#include "model/CreateCustomTemplateResult.h"
#include "model/CreateLiveDelayConfigRequest.h"
#include "model/CreateLiveDelayConfigResult.h"
#include "model/CreateLiveRealTimeLogDeliveryRequest.h"
#include "model/CreateLiveRealTimeLogDeliveryResult.h"
#include "model/CreateLiveStreamMonitorRequest.h"
@@ -146,6 +150,8 @@
#include "model/DeleteLiveAudioAuditNotifyConfigResult.h"
#include "model/DeleteLiveCenterTransferRequest.h"
#include "model/DeleteLiveCenterTransferResult.h"
#include "model/DeleteLiveDelayConfigRequest.h"
#include "model/DeleteLiveDelayConfigResult.h"
#include "model/DeleteLiveDetectNotifyConfigRequest.h"
#include "model/DeleteLiveDetectNotifyConfigResult.h"
#include "model/DeleteLiveDomainRequest.h"
@@ -246,6 +252,8 @@
#include "model/DescribeLiveCertificateDetailResult.h"
#include "model/DescribeLiveCertificateListRequest.h"
#include "model/DescribeLiveCertificateListResult.h"
#include "model/DescribeLiveDelayConfigRequest.h"
#include "model/DescribeLiveDelayConfigResult.h"
#include "model/DescribeLiveDelayedStreamingUsageRequest.h"
#include "model/DescribeLiveDelayedStreamingUsageResult.h"
#include "model/DescribeLiveDetectNotifyConfigRequest.h"
@@ -322,6 +330,8 @@
#include "model/DescribeLiveRecordConfigResult.h"
#include "model/DescribeLiveRecordNotifyConfigRequest.h"
#include "model/DescribeLiveRecordNotifyConfigResult.h"
#include "model/DescribeLiveRecordNotifyRecordsRequest.h"
#include "model/DescribeLiveRecordNotifyRecordsResult.h"
#include "model/DescribeLiveRecordVodConfigsRequest.h"
#include "model/DescribeLiveRecordVodConfigsResult.h"
#include "model/DescribeLiveShiftConfigsRequest.h"
@@ -466,6 +476,8 @@
#include "model/JoinMessageGroupResult.h"
#include "model/LeaveMessageGroupRequest.h"
#include "model/LeaveMessageGroupResult.h"
#include "model/ListLiveDelayConfigRequest.h"
#include "model/ListLiveDelayConfigResult.h"
#include "model/ListLiveRealtimeLogDeliveryRequest.h"
#include "model/ListLiveRealtimeLogDeliveryResult.h"
#include "model/ListLiveRealtimeLogDeliveryDomainsRequest.h"
@@ -604,6 +616,8 @@
#include "model/UpdateLiveAudioAuditNotifyConfigResult.h"
#include "model/UpdateLiveCenterTransferRequest.h"
#include "model/UpdateLiveCenterTransferResult.h"
#include "model/UpdateLiveDelayConfigRequest.h"
#include "model/UpdateLiveDelayConfigResult.h"
#include "model/UpdateLiveDetectNotifyConfigRequest.h"
#include "model/UpdateLiveDetectNotifyConfigResult.h"
#include "model/UpdateLivePullStreamInfoConfigRequest.h"
@@ -738,6 +752,9 @@ namespace AlibabaCloud
typedef Outcome<Error, Model::BatchDeleteLiveDomainConfigsResult> BatchDeleteLiveDomainConfigsOutcome;
typedef std::future<BatchDeleteLiveDomainConfigsOutcome> BatchDeleteLiveDomainConfigsOutcomeCallable;
typedef std::function<void(const LiveClient*, const Model::BatchDeleteLiveDomainConfigsRequest&, const BatchDeleteLiveDomainConfigsOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> BatchDeleteLiveDomainConfigsAsyncHandler;
typedef Outcome<Error, Model::BatchGetOnlineUsersResult> BatchGetOnlineUsersOutcome;
typedef std::future<BatchGetOnlineUsersOutcome> BatchGetOnlineUsersOutcomeCallable;
typedef std::function<void(const LiveClient*, const Model::BatchGetOnlineUsersRequest&, const BatchGetOnlineUsersOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> BatchGetOnlineUsersAsyncHandler;
typedef Outcome<Error, Model::BatchSetLiveDomainConfigsResult> BatchSetLiveDomainConfigsOutcome;
typedef std::future<BatchSetLiveDomainConfigsOutcome> BatchSetLiveDomainConfigsOutcomeCallable;
typedef std::function<void(const LiveClient*, const Model::BatchSetLiveDomainConfigsRequest&, const BatchSetLiveDomainConfigsOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> BatchSetLiveDomainConfigsAsyncHandler;
@@ -762,6 +779,9 @@ namespace AlibabaCloud
typedef Outcome<Error, Model::CreateCustomTemplateResult> CreateCustomTemplateOutcome;
typedef std::future<CreateCustomTemplateOutcome> CreateCustomTemplateOutcomeCallable;
typedef std::function<void(const LiveClient*, const Model::CreateCustomTemplateRequest&, const CreateCustomTemplateOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> CreateCustomTemplateAsyncHandler;
typedef Outcome<Error, Model::CreateLiveDelayConfigResult> CreateLiveDelayConfigOutcome;
typedef std::future<CreateLiveDelayConfigOutcome> CreateLiveDelayConfigOutcomeCallable;
typedef std::function<void(const LiveClient*, const Model::CreateLiveDelayConfigRequest&, const CreateLiveDelayConfigOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> CreateLiveDelayConfigAsyncHandler;
typedef Outcome<Error, Model::CreateLiveRealTimeLogDeliveryResult> CreateLiveRealTimeLogDeliveryOutcome;
typedef std::future<CreateLiveRealTimeLogDeliveryOutcome> CreateLiveRealTimeLogDeliveryOutcomeCallable;
typedef std::function<void(const LiveClient*, const Model::CreateLiveRealTimeLogDeliveryRequest&, const CreateLiveRealTimeLogDeliveryOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> CreateLiveRealTimeLogDeliveryAsyncHandler;
@@ -825,6 +845,9 @@ namespace AlibabaCloud
typedef Outcome<Error, Model::DeleteLiveCenterTransferResult> DeleteLiveCenterTransferOutcome;
typedef std::future<DeleteLiveCenterTransferOutcome> DeleteLiveCenterTransferOutcomeCallable;
typedef std::function<void(const LiveClient*, const Model::DeleteLiveCenterTransferRequest&, const DeleteLiveCenterTransferOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DeleteLiveCenterTransferAsyncHandler;
typedef Outcome<Error, Model::DeleteLiveDelayConfigResult> DeleteLiveDelayConfigOutcome;
typedef std::future<DeleteLiveDelayConfigOutcome> DeleteLiveDelayConfigOutcomeCallable;
typedef std::function<void(const LiveClient*, const Model::DeleteLiveDelayConfigRequest&, const DeleteLiveDelayConfigOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DeleteLiveDelayConfigAsyncHandler;
typedef Outcome<Error, Model::DeleteLiveDetectNotifyConfigResult> DeleteLiveDetectNotifyConfigOutcome;
typedef std::future<DeleteLiveDetectNotifyConfigOutcome> DeleteLiveDetectNotifyConfigOutcomeCallable;
typedef std::function<void(const LiveClient*, const Model::DeleteLiveDetectNotifyConfigRequest&, const DeleteLiveDetectNotifyConfigOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DeleteLiveDetectNotifyConfigAsyncHandler;
@@ -975,6 +998,9 @@ namespace AlibabaCloud
typedef Outcome<Error, Model::DescribeLiveCertificateListResult> DescribeLiveCertificateListOutcome;
typedef std::future<DescribeLiveCertificateListOutcome> DescribeLiveCertificateListOutcomeCallable;
typedef std::function<void(const LiveClient*, const Model::DescribeLiveCertificateListRequest&, const DescribeLiveCertificateListOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeLiveCertificateListAsyncHandler;
typedef Outcome<Error, Model::DescribeLiveDelayConfigResult> DescribeLiveDelayConfigOutcome;
typedef std::future<DescribeLiveDelayConfigOutcome> DescribeLiveDelayConfigOutcomeCallable;
typedef std::function<void(const LiveClient*, const Model::DescribeLiveDelayConfigRequest&, const DescribeLiveDelayConfigOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeLiveDelayConfigAsyncHandler;
typedef Outcome<Error, Model::DescribeLiveDelayedStreamingUsageResult> DescribeLiveDelayedStreamingUsageOutcome;
typedef std::future<DescribeLiveDelayedStreamingUsageOutcome> DescribeLiveDelayedStreamingUsageOutcomeCallable;
typedef std::function<void(const LiveClient*, const Model::DescribeLiveDelayedStreamingUsageRequest&, const DescribeLiveDelayedStreamingUsageOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeLiveDelayedStreamingUsageAsyncHandler;
@@ -1089,6 +1115,9 @@ namespace AlibabaCloud
typedef Outcome<Error, Model::DescribeLiveRecordNotifyConfigResult> DescribeLiveRecordNotifyConfigOutcome;
typedef std::future<DescribeLiveRecordNotifyConfigOutcome> DescribeLiveRecordNotifyConfigOutcomeCallable;
typedef std::function<void(const LiveClient*, const Model::DescribeLiveRecordNotifyConfigRequest&, const DescribeLiveRecordNotifyConfigOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeLiveRecordNotifyConfigAsyncHandler;
typedef Outcome<Error, Model::DescribeLiveRecordNotifyRecordsResult> DescribeLiveRecordNotifyRecordsOutcome;
typedef std::future<DescribeLiveRecordNotifyRecordsOutcome> DescribeLiveRecordNotifyRecordsOutcomeCallable;
typedef std::function<void(const LiveClient*, const Model::DescribeLiveRecordNotifyRecordsRequest&, const DescribeLiveRecordNotifyRecordsOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeLiveRecordNotifyRecordsAsyncHandler;
typedef Outcome<Error, Model::DescribeLiveRecordVodConfigsResult> DescribeLiveRecordVodConfigsOutcome;
typedef std::future<DescribeLiveRecordVodConfigsOutcome> DescribeLiveRecordVodConfigsOutcomeCallable;
typedef std::function<void(const LiveClient*, const Model::DescribeLiveRecordVodConfigsRequest&, const DescribeLiveRecordVodConfigsOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeLiveRecordVodConfigsAsyncHandler;
@@ -1305,6 +1334,9 @@ namespace AlibabaCloud
typedef Outcome<Error, Model::LeaveMessageGroupResult> LeaveMessageGroupOutcome;
typedef std::future<LeaveMessageGroupOutcome> LeaveMessageGroupOutcomeCallable;
typedef std::function<void(const LiveClient*, const Model::LeaveMessageGroupRequest&, const LeaveMessageGroupOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> LeaveMessageGroupAsyncHandler;
typedef Outcome<Error, Model::ListLiveDelayConfigResult> ListLiveDelayConfigOutcome;
typedef std::future<ListLiveDelayConfigOutcome> ListLiveDelayConfigOutcomeCallable;
typedef std::function<void(const LiveClient*, const Model::ListLiveDelayConfigRequest&, const ListLiveDelayConfigOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ListLiveDelayConfigAsyncHandler;
typedef Outcome<Error, Model::ListLiveRealtimeLogDeliveryResult> ListLiveRealtimeLogDeliveryOutcome;
typedef std::future<ListLiveRealtimeLogDeliveryOutcome> ListLiveRealtimeLogDeliveryOutcomeCallable;
typedef std::function<void(const LiveClient*, const Model::ListLiveRealtimeLogDeliveryRequest&, const ListLiveRealtimeLogDeliveryOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ListLiveRealtimeLogDeliveryAsyncHandler;
@@ -1512,6 +1544,9 @@ namespace AlibabaCloud
typedef Outcome<Error, Model::UpdateLiveCenterTransferResult> UpdateLiveCenterTransferOutcome;
typedef std::future<UpdateLiveCenterTransferOutcome> UpdateLiveCenterTransferOutcomeCallable;
typedef std::function<void(const LiveClient*, const Model::UpdateLiveCenterTransferRequest&, const UpdateLiveCenterTransferOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> UpdateLiveCenterTransferAsyncHandler;
typedef Outcome<Error, Model::UpdateLiveDelayConfigResult> UpdateLiveDelayConfigOutcome;
typedef std::future<UpdateLiveDelayConfigOutcome> UpdateLiveDelayConfigOutcomeCallable;
typedef std::function<void(const LiveClient*, const Model::UpdateLiveDelayConfigRequest&, const UpdateLiveDelayConfigOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> UpdateLiveDelayConfigAsyncHandler;
typedef Outcome<Error, Model::UpdateLiveDetectNotifyConfigResult> UpdateLiveDetectNotifyConfigOutcome;
typedef std::future<UpdateLiveDetectNotifyConfigOutcome> UpdateLiveDetectNotifyConfigOutcomeCallable;
typedef std::function<void(const LiveClient*, const Model::UpdateLiveDetectNotifyConfigRequest&, const UpdateLiveDetectNotifyConfigOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> UpdateLiveDetectNotifyConfigAsyncHandler;
@@ -1655,6 +1690,9 @@ namespace AlibabaCloud
BatchDeleteLiveDomainConfigsOutcome batchDeleteLiveDomainConfigs(const Model::BatchDeleteLiveDomainConfigsRequest &request)const;
void batchDeleteLiveDomainConfigsAsync(const Model::BatchDeleteLiveDomainConfigsRequest& request, const BatchDeleteLiveDomainConfigsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
BatchDeleteLiveDomainConfigsOutcomeCallable batchDeleteLiveDomainConfigsCallable(const Model::BatchDeleteLiveDomainConfigsRequest& request) const;
BatchGetOnlineUsersOutcome batchGetOnlineUsers(const Model::BatchGetOnlineUsersRequest &request)const;
void batchGetOnlineUsersAsync(const Model::BatchGetOnlineUsersRequest& request, const BatchGetOnlineUsersAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
BatchGetOnlineUsersOutcomeCallable batchGetOnlineUsersCallable(const Model::BatchGetOnlineUsersRequest& request) const;
BatchSetLiveDomainConfigsOutcome batchSetLiveDomainConfigs(const Model::BatchSetLiveDomainConfigsRequest &request)const;
void batchSetLiveDomainConfigsAsync(const Model::BatchSetLiveDomainConfigsRequest& request, const BatchSetLiveDomainConfigsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
BatchSetLiveDomainConfigsOutcomeCallable batchSetLiveDomainConfigsCallable(const Model::BatchSetLiveDomainConfigsRequest& request) const;
@@ -1679,6 +1717,9 @@ namespace AlibabaCloud
CreateCustomTemplateOutcome createCustomTemplate(const Model::CreateCustomTemplateRequest &request)const;
void createCustomTemplateAsync(const Model::CreateCustomTemplateRequest& request, const CreateCustomTemplateAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
CreateCustomTemplateOutcomeCallable createCustomTemplateCallable(const Model::CreateCustomTemplateRequest& request) const;
CreateLiveDelayConfigOutcome createLiveDelayConfig(const Model::CreateLiveDelayConfigRequest &request)const;
void createLiveDelayConfigAsync(const Model::CreateLiveDelayConfigRequest& request, const CreateLiveDelayConfigAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
CreateLiveDelayConfigOutcomeCallable createLiveDelayConfigCallable(const Model::CreateLiveDelayConfigRequest& request) const;
CreateLiveRealTimeLogDeliveryOutcome createLiveRealTimeLogDelivery(const Model::CreateLiveRealTimeLogDeliveryRequest &request)const;
void createLiveRealTimeLogDeliveryAsync(const Model::CreateLiveRealTimeLogDeliveryRequest& request, const CreateLiveRealTimeLogDeliveryAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
CreateLiveRealTimeLogDeliveryOutcomeCallable createLiveRealTimeLogDeliveryCallable(const Model::CreateLiveRealTimeLogDeliveryRequest& request) const;
@@ -1742,6 +1783,9 @@ namespace AlibabaCloud
DeleteLiveCenterTransferOutcome deleteLiveCenterTransfer(const Model::DeleteLiveCenterTransferRequest &request)const;
void deleteLiveCenterTransferAsync(const Model::DeleteLiveCenterTransferRequest& request, const DeleteLiveCenterTransferAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
DeleteLiveCenterTransferOutcomeCallable deleteLiveCenterTransferCallable(const Model::DeleteLiveCenterTransferRequest& request) const;
DeleteLiveDelayConfigOutcome deleteLiveDelayConfig(const Model::DeleteLiveDelayConfigRequest &request)const;
void deleteLiveDelayConfigAsync(const Model::DeleteLiveDelayConfigRequest& request, const DeleteLiveDelayConfigAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
DeleteLiveDelayConfigOutcomeCallable deleteLiveDelayConfigCallable(const Model::DeleteLiveDelayConfigRequest& request) const;
DeleteLiveDetectNotifyConfigOutcome deleteLiveDetectNotifyConfig(const Model::DeleteLiveDetectNotifyConfigRequest &request)const;
void deleteLiveDetectNotifyConfigAsync(const Model::DeleteLiveDetectNotifyConfigRequest& request, const DeleteLiveDetectNotifyConfigAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
DeleteLiveDetectNotifyConfigOutcomeCallable deleteLiveDetectNotifyConfigCallable(const Model::DeleteLiveDetectNotifyConfigRequest& request) const;
@@ -1892,6 +1936,9 @@ namespace AlibabaCloud
DescribeLiveCertificateListOutcome describeLiveCertificateList(const Model::DescribeLiveCertificateListRequest &request)const;
void describeLiveCertificateListAsync(const Model::DescribeLiveCertificateListRequest& request, const DescribeLiveCertificateListAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
DescribeLiveCertificateListOutcomeCallable describeLiveCertificateListCallable(const Model::DescribeLiveCertificateListRequest& request) const;
DescribeLiveDelayConfigOutcome describeLiveDelayConfig(const Model::DescribeLiveDelayConfigRequest &request)const;
void describeLiveDelayConfigAsync(const Model::DescribeLiveDelayConfigRequest& request, const DescribeLiveDelayConfigAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
DescribeLiveDelayConfigOutcomeCallable describeLiveDelayConfigCallable(const Model::DescribeLiveDelayConfigRequest& request) const;
DescribeLiveDelayedStreamingUsageOutcome describeLiveDelayedStreamingUsage(const Model::DescribeLiveDelayedStreamingUsageRequest &request)const;
void describeLiveDelayedStreamingUsageAsync(const Model::DescribeLiveDelayedStreamingUsageRequest& request, const DescribeLiveDelayedStreamingUsageAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
DescribeLiveDelayedStreamingUsageOutcomeCallable describeLiveDelayedStreamingUsageCallable(const Model::DescribeLiveDelayedStreamingUsageRequest& request) const;
@@ -2006,6 +2053,9 @@ namespace AlibabaCloud
DescribeLiveRecordNotifyConfigOutcome describeLiveRecordNotifyConfig(const Model::DescribeLiveRecordNotifyConfigRequest &request)const;
void describeLiveRecordNotifyConfigAsync(const Model::DescribeLiveRecordNotifyConfigRequest& request, const DescribeLiveRecordNotifyConfigAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
DescribeLiveRecordNotifyConfigOutcomeCallable describeLiveRecordNotifyConfigCallable(const Model::DescribeLiveRecordNotifyConfigRequest& request) const;
DescribeLiveRecordNotifyRecordsOutcome describeLiveRecordNotifyRecords(const Model::DescribeLiveRecordNotifyRecordsRequest &request)const;
void describeLiveRecordNotifyRecordsAsync(const Model::DescribeLiveRecordNotifyRecordsRequest& request, const DescribeLiveRecordNotifyRecordsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
DescribeLiveRecordNotifyRecordsOutcomeCallable describeLiveRecordNotifyRecordsCallable(const Model::DescribeLiveRecordNotifyRecordsRequest& request) const;
DescribeLiveRecordVodConfigsOutcome describeLiveRecordVodConfigs(const Model::DescribeLiveRecordVodConfigsRequest &request)const;
void describeLiveRecordVodConfigsAsync(const Model::DescribeLiveRecordVodConfigsRequest& request, const DescribeLiveRecordVodConfigsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
DescribeLiveRecordVodConfigsOutcomeCallable describeLiveRecordVodConfigsCallable(const Model::DescribeLiveRecordVodConfigsRequest& request) const;
@@ -2222,6 +2272,9 @@ namespace AlibabaCloud
LeaveMessageGroupOutcome leaveMessageGroup(const Model::LeaveMessageGroupRequest &request)const;
void leaveMessageGroupAsync(const Model::LeaveMessageGroupRequest& request, const LeaveMessageGroupAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
LeaveMessageGroupOutcomeCallable leaveMessageGroupCallable(const Model::LeaveMessageGroupRequest& request) const;
ListLiveDelayConfigOutcome listLiveDelayConfig(const Model::ListLiveDelayConfigRequest &request)const;
void listLiveDelayConfigAsync(const Model::ListLiveDelayConfigRequest& request, const ListLiveDelayConfigAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
ListLiveDelayConfigOutcomeCallable listLiveDelayConfigCallable(const Model::ListLiveDelayConfigRequest& request) const;
ListLiveRealtimeLogDeliveryOutcome listLiveRealtimeLogDelivery(const Model::ListLiveRealtimeLogDeliveryRequest &request)const;
void listLiveRealtimeLogDeliveryAsync(const Model::ListLiveRealtimeLogDeliveryRequest& request, const ListLiveRealtimeLogDeliveryAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
ListLiveRealtimeLogDeliveryOutcomeCallable listLiveRealtimeLogDeliveryCallable(const Model::ListLiveRealtimeLogDeliveryRequest& request) const;
@@ -2429,6 +2482,9 @@ namespace AlibabaCloud
UpdateLiveCenterTransferOutcome updateLiveCenterTransfer(const Model::UpdateLiveCenterTransferRequest &request)const;
void updateLiveCenterTransferAsync(const Model::UpdateLiveCenterTransferRequest& request, const UpdateLiveCenterTransferAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
UpdateLiveCenterTransferOutcomeCallable updateLiveCenterTransferCallable(const Model::UpdateLiveCenterTransferRequest& request) const;
UpdateLiveDelayConfigOutcome updateLiveDelayConfig(const Model::UpdateLiveDelayConfigRequest &request)const;
void updateLiveDelayConfigAsync(const Model::UpdateLiveDelayConfigRequest& request, const UpdateLiveDelayConfigAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
UpdateLiveDelayConfigOutcomeCallable updateLiveDelayConfigCallable(const Model::UpdateLiveDelayConfigRequest& request) const;
UpdateLiveDetectNotifyConfigOutcome updateLiveDetectNotifyConfig(const Model::UpdateLiveDetectNotifyConfigRequest &request)const;
void updateLiveDetectNotifyConfigAsync(const Model::UpdateLiveDetectNotifyConfigRequest& request, const UpdateLiveDetectNotifyConfigAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
UpdateLiveDetectNotifyConfigOutcomeCallable updateLiveDetectNotifyConfigCallable(const Model::UpdateLiveDetectNotifyConfigRequest& request) const;

48
live/include/alibabacloud/live/model/BatchGetOnlineUsersRequest.h Normal file
View File

@@ -0,0 +1,48 @@
/*
* 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_BATCHGETONLINEUSERSREQUEST_H_
#define ALIBABACLOUD_LIVE_MODEL_BATCHGETONLINEUSERSREQUEST_H_
#include <alibabacloud/live/LiveExport.h>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <string>
#include <vector>
#include <map>
namespace AlibabaCloud {
namespace Live {
namespace Model {
class ALIBABACLOUD_LIVE_EXPORT BatchGetOnlineUsersRequest : public RpcServiceRequest {
public:
BatchGetOnlineUsersRequest();
~BatchGetOnlineUsersRequest();
std::string getGroupId() const;
void setGroupId(const std::string &groupId);
std::string getUserIds() const;
void setUserIds(const std::string &userIds);
std::string getAppId() const;
void setAppId(const std::string &appId);
private:
std::string groupId_;
std::string userIds_;
std::string appId_;
};
} // namespace Model
} // namespace Live
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_LIVE_MODEL_BATCHGETONLINEUSERSREQUEST_H_

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

@@ -0,0 +1,61 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_LIVE_MODEL_BATCHGETONLINEUSERSRESULT_H_
#define ALIBABACLOUD_LIVE_MODEL_BATCHGETONLINEUSERSRESULT_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 BatchGetOnlineUsersResult : public ServiceResult
{
public:
struct Result
{
struct OnlineUsersItem
{
std::string userId;
long joinTime;
bool online;
};
std::vector<OnlineUsersItem> onlineUsers;
};
BatchGetOnlineUsersResult();
explicit BatchGetOnlineUsersResult(const std::string &payload);
~BatchGetOnlineUsersResult();
Result getResult()const;
protected:
void parse(const std::string &payload);
private:
Result result_;
};
}
}
}
#endif // !ALIBABACLOUD_LIVE_MODEL_BATCHGETONLINEUSERSRESULT_H_

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

@@ -0,0 +1,57 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_LIVE_MODEL_CREATELIVEDELAYCONFIGREQUEST_H_
#define ALIBABACLOUD_LIVE_MODEL_CREATELIVEDELAYCONFIGREQUEST_H_
#include <alibabacloud/live/LiveExport.h>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <string>
#include <vector>
#include <map>
namespace AlibabaCloud {
namespace Live {
namespace Model {
class ALIBABACLOUD_LIVE_EXPORT CreateLiveDelayConfigRequest : public RpcServiceRequest {
public:
CreateLiveDelayConfigRequest();
~CreateLiveDelayConfigRequest();
int getDelayTime() const;
void setDelayTime(int delayTime);
std::string getStream() const;
void setStream(const std::string &stream);
std::string getApp() const;
void setApp(const std::string &app);
long getOwnerId() const;
void setOwnerId(long ownerId);
std::string getTaskTriggerMode() const;
void setTaskTriggerMode(const std::string &taskTriggerMode);
std::string getDomain() const;
void setDomain(const std::string &domain);
private:
int delayTime_;
std::string stream_;
std::string app_;
long ownerId_;
std::string taskTriggerMode_;
std::string domain_;
};
} // namespace Model
} // namespace Live
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_LIVE_MODEL_CREATELIVEDELAYCONFIGREQUEST_H_

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

51
live/include/alibabacloud/live/model/DeleteLiveDelayConfigRequest.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_DELETELIVEDELAYCONFIGREQUEST_H_
#define ALIBABACLOUD_LIVE_MODEL_DELETELIVEDELAYCONFIGREQUEST_H_
#include <alibabacloud/live/LiveExport.h>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <string>
#include <vector>
#include <map>
namespace AlibabaCloud {
namespace Live {
namespace Model {
class ALIBABACLOUD_LIVE_EXPORT DeleteLiveDelayConfigRequest : public RpcServiceRequest {
public:
DeleteLiveDelayConfigRequest();
~DeleteLiveDelayConfigRequest();
std::string getStream() const;
void setStream(const std::string &stream);
std::string getApp() const;
void setApp(const std::string &app);
long getOwnerId() const;
void setOwnerId(long ownerId);
std::string getDomain() const;
void setDomain(const std::string &domain);
private:
std::string stream_;
std::string app_;
long ownerId_;
std::string domain_;
};
} // namespace Model
} // namespace Live
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_LIVE_MODEL_DELETELIVEDELAYCONFIGREQUEST_H_

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

1
live/include/alibabacloud/live/model/DescribeCasterConfigResult.h
View File

@@ -49,6 +49,7 @@ namespace AlibabaCloud
std::string ossEndpoint;
std::vector<RecordFormatItem> recordFormat;
std::string ossBucket;
int onDemand;
};
struct SyncGroup
{

51
live/include/alibabacloud/live/model/DescribeLiveDelayConfigRequest.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_DESCRIBELIVEDELAYCONFIGREQUEST_H_
#define ALIBABACLOUD_LIVE_MODEL_DESCRIBELIVEDELAYCONFIGREQUEST_H_
#include <alibabacloud/live/LiveExport.h>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <string>
#include <vector>
#include <map>
namespace AlibabaCloud {
namespace Live {
namespace Model {
class ALIBABACLOUD_LIVE_EXPORT DescribeLiveDelayConfigRequest : public RpcServiceRequest {
public:
DescribeLiveDelayConfigRequest();
~DescribeLiveDelayConfigRequest();
std::string getStream() const;
void setStream(const std::string &stream);
std::string getApp() const;
void setApp(const std::string &app);
long getOwnerId() const;
void setOwnerId(long ownerId);
std::string getDomain() const;
void setDomain(const std::string &domain);
private:
std::string stream_;
std::string app_;
long ownerId_;
std::string domain_;
};
} // namespace Model
} // namespace Live
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_LIVE_MODEL_DESCRIBELIVEDELAYCONFIGREQUEST_H_

59
live/include/alibabacloud/live/model/DescribeLiveDelayConfigResult.h Normal file
View File

@@ -0,0 +1,59 @@
/*
* 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_DESCRIBELIVEDELAYCONFIGRESULT_H_
#define ALIBABACLOUD_LIVE_MODEL_DESCRIBELIVEDELAYCONFIGRESULT_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 DescribeLiveDelayConfigResult : public ServiceResult
{
public:
DescribeLiveDelayConfigResult();
explicit DescribeLiveDelayConfigResult(const std::string &payload);
~DescribeLiveDelayConfigResult();
std::string getApp()const;
std::string getTaskTriggerMode()const;
std::string getStream()const;
std::string getDomain()const;
std::string getDelayTime()const;
protected:
void parse(const std::string &payload);
private:
std::string app_;
std::string taskTriggerMode_;
std::string stream_;
std::string domain_;
std::string delayTime_;
};
}
}
}
#endif // !ALIBABACLOUD_LIVE_MODEL_DESCRIBELIVEDELAYCONFIGRESULT_H_

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

@@ -42,6 +42,8 @@ public:
void setOwnerId(long ownerId);
std::string getInterval() const;
void setInterval(const std::string &interval);
std::string getRegion() const;
void setRegion(const std::string &region);
private:
std::string startTime_;
@@ -50,6 +52,7 @@ private:
std::string endTime_;
long ownerId_;
std::string interval_;
std::string region_;
};
} // namespace Model
} // namespace Live

1
live/include/alibabacloud/live/model/DescribeLiveDomainRecordUsageDataResult.h
View File

@@ -35,6 +35,7 @@ namespace AlibabaCloud
struct DataModule
{
std::string type;
std::string region;
long duration;
long count;
std::string domain;

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

@@ -0,0 +1,66 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_LIVE_MODEL_DESCRIBELIVERECORDNOTIFYRECORDSREQUEST_H_
#define ALIBABACLOUD_LIVE_MODEL_DESCRIBELIVERECORDNOTIFYRECORDSREQUEST_H_
#include <alibabacloud/live/LiveExport.h>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <string>
#include <vector>
#include <map>
namespace AlibabaCloud {
namespace Live {
namespace Model {
class ALIBABACLOUD_LIVE_EXPORT DescribeLiveRecordNotifyRecordsRequest : public RpcServiceRequest {
public:
DescribeLiveRecordNotifyRecordsRequest();
~DescribeLiveRecordNotifyRecordsRequest();
std::string getStartTime() const;
void setStartTime(const std::string &startTime);
long getPageNumber() const;
void setPageNumber(long pageNumber);
std::string getAppName() const;
void setAppName(const std::string &appName);
long getPageSize() const;
void setPageSize(long pageSize);
std::string getStreamName() const;
void setStreamName(const std::string &streamName);
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);
std::string getStatus() const;
void setStatus(const std::string &status);
private:
std::string startTime_;
long pageNumber_;
std::string appName_;
long pageSize_;
std::string streamName_;
std::string domainName_;
std::string endTime_;
long ownerId_;
std::string status_;
};
} // namespace Model
} // namespace Live
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_LIVE_MODEL_DESCRIBELIVERECORDNOTIFYRECORDSREQUEST_H_

75
live/include/alibabacloud/live/model/DescribeLiveRecordNotifyRecordsResult.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_DESCRIBELIVERECORDNOTIFYRECORDSRESULT_H_
#define ALIBABACLOUD_LIVE_MODEL_DESCRIBELIVERECORDNOTIFYRECORDSRESULT_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 DescribeLiveRecordNotifyRecordsResult : public ServiceResult
{
public:
struct Callback
{
std::string notifyType;
std::string description;
std::string streamName;
std::string notifyTime;
std::string notifyContent;
std::string domainName;
std::string notifyUrl;
std::string notifyResult;
std::string appName;
};
DescribeLiveRecordNotifyRecordsResult();
explicit DescribeLiveRecordNotifyRecordsResult(const std::string &payload);
~DescribeLiveRecordNotifyRecordsResult();
std::string getMsg()const;
int getTotalNum()const;
std::vector<Callback> getCallbackList()const;
int getPageNum()const;
int getTotalPage()const;
int getPageSize()const;
int getCode()const;
protected:
void parse(const std::string &payload);
private:
std::string msg_;
int totalNum_;
std::vector<Callback> callbackList_;
int pageNum_;
int totalPage_;
int pageSize_;
int code_;
};
}
}
}
#endif // !ALIBABACLOUD_LIVE_MODEL_DESCRIBELIVERECORDNOTIFYRECORDSRESULT_H_

51
live/include/alibabacloud/live/model/ListLiveDelayConfigRequest.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_LISTLIVEDELAYCONFIGREQUEST_H_
#define ALIBABACLOUD_LIVE_MODEL_LISTLIVEDELAYCONFIGREQUEST_H_
#include <alibabacloud/live/LiveExport.h>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <string>
#include <vector>
#include <map>
namespace AlibabaCloud {
namespace Live {
namespace Model {
class ALIBABACLOUD_LIVE_EXPORT ListLiveDelayConfigRequest : public RpcServiceRequest {
public:
ListLiveDelayConfigRequest();
~ListLiveDelayConfigRequest();
int getPageNum() const;
void setPageNum(int pageNum);
int getPageSize() const;
void setPageSize(int pageSize);
long getOwnerId() const;
void setOwnerId(long ownerId);
std::string getDomain() const;
void setDomain(const std::string &domain);
private:
int pageNum_;
int pageSize_;
long ownerId_;
std::string domain_;
};
} // namespace Model
} // namespace Live
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_LIVE_MODEL_LISTLIVEDELAYCONFIGREQUEST_H_

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

@@ -0,0 +1,61 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_LIVE_MODEL_LISTLIVEDELAYCONFIGRESULT_H_
#define ALIBABACLOUD_LIVE_MODEL_LISTLIVEDELAYCONFIGRESULT_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 ListLiveDelayConfigResult : public ServiceResult
{
public:
struct DelayConfig
{
std::string app;
std::string taskTriggerMode;
std::string stream;
std::string domain;
std::string delayTime;
};
ListLiveDelayConfigResult();
explicit ListLiveDelayConfigResult(const std::string &payload);
~ListLiveDelayConfigResult();
std::vector<DelayConfig> getDelayConfigList()const;
int getTotal()const;
protected:
void parse(const std::string &payload);
private:
std::vector<DelayConfig> delayConfigList_;
int total_;
};
}
}
}
#endif // !ALIBABACLOUD_LIVE_MODEL_LISTLIVEDELAYCONFIGRESULT_H_

1
live/include/alibabacloud/live/model/UpdateCasterSceneAudioRequest.h
View File

@@ -32,6 +32,7 @@ public:
float volumeRate;
int fixedDelayDuration;
std::string validChannel;
std::string filter;
};
UpdateCasterSceneAudioRequest();
~UpdateCasterSceneAudioRequest();

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

@@ -0,0 +1,57 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_LIVE_MODEL_UPDATELIVEDELAYCONFIGREQUEST_H_
#define ALIBABACLOUD_LIVE_MODEL_UPDATELIVEDELAYCONFIGREQUEST_H_
#include <alibabacloud/live/LiveExport.h>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <string>
#include <vector>
#include <map>
namespace AlibabaCloud {
namespace Live {
namespace Model {
class ALIBABACLOUD_LIVE_EXPORT UpdateLiveDelayConfigRequest : public RpcServiceRequest {
public:
UpdateLiveDelayConfigRequest();
~UpdateLiveDelayConfigRequest();
int getDelayTime() const;
void setDelayTime(int delayTime);
std::string getStream() const;
void setStream(const std::string &stream);
std::string getApp() const;
void setApp(const std::string &app);
long getOwnerId() const;
void setOwnerId(long ownerId);
std::string getTaskTriggerMode() const;
void setTaskTriggerMode(const std::string &taskTriggerMode);
std::string getDomain() const;
void setDomain(const std::string &domain);
private:
int delayTime_;
std::string stream_;
std::string app_;
long ownerId_;
std::string taskTriggerMode_;
std::string domain_;
};
} // namespace Model
} // namespace Live
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_LIVE_MODEL_UPDATELIVEDELAYCONFIGREQUEST_H_

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

252
live/src/LiveClient.cc
View File

@@ -1239,6 +1239,42 @@ LiveClient::BatchDeleteLiveDomainConfigsOutcomeCallable LiveClient::batchDeleteL
return task->get_future();
}
LiveClient::BatchGetOnlineUsersOutcome LiveClient::batchGetOnlineUsers(const BatchGetOnlineUsersRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return BatchGetOnlineUsersOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return BatchGetOnlineUsersOutcome(BatchGetOnlineUsersResult(outcome.result()));
else
return BatchGetOnlineUsersOutcome(outcome.error());
}
void LiveClient::batchGetOnlineUsersAsync(const BatchGetOnlineUsersRequest& request, const BatchGetOnlineUsersAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, batchGetOnlineUsers(request), context);
};
asyncExecute(new Runnable(fn));
}
LiveClient::BatchGetOnlineUsersOutcomeCallable LiveClient::batchGetOnlineUsersCallable(const BatchGetOnlineUsersRequest &request) const
{
auto task = std::make_shared<std::packaged_task<BatchGetOnlineUsersOutcome()>>(
[this, request]()
{
return this->batchGetOnlineUsers(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
LiveClient::BatchSetLiveDomainConfigsOutcome LiveClient::batchSetLiveDomainConfigs(const BatchSetLiveDomainConfigsRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -1527,6 +1563,42 @@ LiveClient::CreateCustomTemplateOutcomeCallable LiveClient::createCustomTemplate
return task->get_future();
}
LiveClient::CreateLiveDelayConfigOutcome LiveClient::createLiveDelayConfig(const CreateLiveDelayConfigRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return CreateLiveDelayConfigOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return CreateLiveDelayConfigOutcome(CreateLiveDelayConfigResult(outcome.result()));
else
return CreateLiveDelayConfigOutcome(outcome.error());
}
void LiveClient::createLiveDelayConfigAsync(const CreateLiveDelayConfigRequest& request, const CreateLiveDelayConfigAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, createLiveDelayConfig(request), context);
};
asyncExecute(new Runnable(fn));
}
LiveClient::CreateLiveDelayConfigOutcomeCallable LiveClient::createLiveDelayConfigCallable(const CreateLiveDelayConfigRequest &request) const
{
auto task = std::make_shared<std::packaged_task<CreateLiveDelayConfigOutcome()>>(
[this, request]()
{
return this->createLiveDelayConfig(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
LiveClient::CreateLiveRealTimeLogDeliveryOutcome LiveClient::createLiveRealTimeLogDelivery(const CreateLiveRealTimeLogDeliveryRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -2283,6 +2355,42 @@ LiveClient::DeleteLiveCenterTransferOutcomeCallable LiveClient::deleteLiveCenter
return task->get_future();
}
LiveClient::DeleteLiveDelayConfigOutcome LiveClient::deleteLiveDelayConfig(const DeleteLiveDelayConfigRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return DeleteLiveDelayConfigOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return DeleteLiveDelayConfigOutcome(DeleteLiveDelayConfigResult(outcome.result()));
else
return DeleteLiveDelayConfigOutcome(outcome.error());
}
void LiveClient::deleteLiveDelayConfigAsync(const DeleteLiveDelayConfigRequest& request, const DeleteLiveDelayConfigAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, deleteLiveDelayConfig(request), context);
};
asyncExecute(new Runnable(fn));
}
LiveClient::DeleteLiveDelayConfigOutcomeCallable LiveClient::deleteLiveDelayConfigCallable(const DeleteLiveDelayConfigRequest &request) const
{
auto task = std::make_shared<std::packaged_task<DeleteLiveDelayConfigOutcome()>>(
[this, request]()
{
return this->deleteLiveDelayConfig(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
LiveClient::DeleteLiveDetectNotifyConfigOutcome LiveClient::deleteLiveDetectNotifyConfig(const DeleteLiveDetectNotifyConfigRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -4083,6 +4191,42 @@ LiveClient::DescribeLiveCertificateListOutcomeCallable LiveClient::describeLiveC
return task->get_future();
}
LiveClient::DescribeLiveDelayConfigOutcome LiveClient::describeLiveDelayConfig(const DescribeLiveDelayConfigRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return DescribeLiveDelayConfigOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return DescribeLiveDelayConfigOutcome(DescribeLiveDelayConfigResult(outcome.result()));
else
return DescribeLiveDelayConfigOutcome(outcome.error());
}
void LiveClient::describeLiveDelayConfigAsync(const DescribeLiveDelayConfigRequest& request, const DescribeLiveDelayConfigAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, describeLiveDelayConfig(request), context);
};
asyncExecute(new Runnable(fn));
}
LiveClient::DescribeLiveDelayConfigOutcomeCallable LiveClient::describeLiveDelayConfigCallable(const DescribeLiveDelayConfigRequest &request) const
{
auto task = std::make_shared<std::packaged_task<DescribeLiveDelayConfigOutcome()>>(
[this, request]()
{
return this->describeLiveDelayConfig(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
LiveClient::DescribeLiveDelayedStreamingUsageOutcome LiveClient::describeLiveDelayedStreamingUsage(const DescribeLiveDelayedStreamingUsageRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -5451,6 +5595,42 @@ LiveClient::DescribeLiveRecordNotifyConfigOutcomeCallable LiveClient::describeLi
return task->get_future();
}
LiveClient::DescribeLiveRecordNotifyRecordsOutcome LiveClient::describeLiveRecordNotifyRecords(const DescribeLiveRecordNotifyRecordsRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return DescribeLiveRecordNotifyRecordsOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return DescribeLiveRecordNotifyRecordsOutcome(DescribeLiveRecordNotifyRecordsResult(outcome.result()));
else
return DescribeLiveRecordNotifyRecordsOutcome(outcome.error());
}
void LiveClient::describeLiveRecordNotifyRecordsAsync(const DescribeLiveRecordNotifyRecordsRequest& request, const DescribeLiveRecordNotifyRecordsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, describeLiveRecordNotifyRecords(request), context);
};
asyncExecute(new Runnable(fn));
}
LiveClient::DescribeLiveRecordNotifyRecordsOutcomeCallable LiveClient::describeLiveRecordNotifyRecordsCallable(const DescribeLiveRecordNotifyRecordsRequest &request) const
{
auto task = std::make_shared<std::packaged_task<DescribeLiveRecordNotifyRecordsOutcome()>>(
[this, request]()
{
return this->describeLiveRecordNotifyRecords(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
LiveClient::DescribeLiveRecordVodConfigsOutcome LiveClient::describeLiveRecordVodConfigs(const DescribeLiveRecordVodConfigsRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -8043,6 +8223,42 @@ LiveClient::LeaveMessageGroupOutcomeCallable LiveClient::leaveMessageGroupCallab
return task->get_future();
}
LiveClient::ListLiveDelayConfigOutcome LiveClient::listLiveDelayConfig(const ListLiveDelayConfigRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return ListLiveDelayConfigOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return ListLiveDelayConfigOutcome(ListLiveDelayConfigResult(outcome.result()));
else
return ListLiveDelayConfigOutcome(outcome.error());
}
void LiveClient::listLiveDelayConfigAsync(const ListLiveDelayConfigRequest& request, const ListLiveDelayConfigAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, listLiveDelayConfig(request), context);
};
asyncExecute(new Runnable(fn));
}
LiveClient::ListLiveDelayConfigOutcomeCallable LiveClient::listLiveDelayConfigCallable(const ListLiveDelayConfigRequest &request) const
{
auto task = std::make_shared<std::packaged_task<ListLiveDelayConfigOutcome()>>(
[this, request]()
{
return this->listLiveDelayConfig(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
LiveClient::ListLiveRealtimeLogDeliveryOutcome LiveClient::listLiveRealtimeLogDelivery(const ListLiveRealtimeLogDeliveryRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -10527,6 +10743,42 @@ LiveClient::UpdateLiveCenterTransferOutcomeCallable LiveClient::updateLiveCenter
return task->get_future();
}
LiveClient::UpdateLiveDelayConfigOutcome LiveClient::updateLiveDelayConfig(const UpdateLiveDelayConfigRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return UpdateLiveDelayConfigOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return UpdateLiveDelayConfigOutcome(UpdateLiveDelayConfigResult(outcome.result()));
else
return UpdateLiveDelayConfigOutcome(outcome.error());
}
void LiveClient::updateLiveDelayConfigAsync(const UpdateLiveDelayConfigRequest& request, const UpdateLiveDelayConfigAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, updateLiveDelayConfig(request), context);
};
asyncExecute(new Runnable(fn));
}
LiveClient::UpdateLiveDelayConfigOutcomeCallable LiveClient::updateLiveDelayConfigCallable(const UpdateLiveDelayConfigRequest &request) const
{
auto task = std::make_shared<std::packaged_task<UpdateLiveDelayConfigOutcome()>>(
[this, request]()
{
return this->updateLiveDelayConfig(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
LiveClient::UpdateLiveDetectNotifyConfigOutcome LiveClient::updateLiveDetectNotifyConfig(const UpdateLiveDetectNotifyConfigRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();

54
live/src/model/BatchGetOnlineUsersRequest.cc 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.
*/
#include <alibabacloud/live/model/BatchGetOnlineUsersRequest.h>
using AlibabaCloud::Live::Model::BatchGetOnlineUsersRequest;
BatchGetOnlineUsersRequest::BatchGetOnlineUsersRequest()
: RpcServiceRequest("live", "2016-11-01", "BatchGetOnlineUsers") {
setMethod(HttpRequest::Method::Post);
}
BatchGetOnlineUsersRequest::~BatchGetOnlineUsersRequest() {}
std::string BatchGetOnlineUsersRequest::getGroupId() const {
return groupId_;
}
void BatchGetOnlineUsersRequest::setGroupId(const std::string &groupId) {
groupId_ = groupId;
setBodyParameter(std::string("GroupId"), groupId);
}
std::string BatchGetOnlineUsersRequest::getUserIds() const {
return userIds_;
}
void BatchGetOnlineUsersRequest::setUserIds(const std::string &userIds) {
userIds_ = userIds;
setBodyParameter(std::string("UserIds"), userIds);
}
std::string BatchGetOnlineUsersRequest::getAppId() const {
return appId_;
}
void BatchGetOnlineUsersRequest::setAppId(const std::string &appId) {
appId_ = appId;
setBodyParameter(std::string("AppId"), appId);
}

62
live/src/model/BatchGetOnlineUsersResult.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/BatchGetOnlineUsersResult.h>
#include <json/json.h>
using namespace AlibabaCloud::Live;
using namespace AlibabaCloud::Live::Model;
BatchGetOnlineUsersResult::BatchGetOnlineUsersResult() :
ServiceResult()
{}
BatchGetOnlineUsersResult::BatchGetOnlineUsersResult(const std::string &payload) :
ServiceResult()
{
parse(payload);
}
BatchGetOnlineUsersResult::~BatchGetOnlineUsersResult()
{}
void BatchGetOnlineUsersResult::parse(const std::string &payload)
{
Json::Reader reader;
Json::Value value;
reader.parse(payload, value);
setRequestId(value["RequestId"].asString());
auto resultNode = value["Result"];
auto allOnlineUsersNode = resultNode["OnlineUsers"]["onlineUsersItem"];
for (auto resultNodeOnlineUsersonlineUsersItem : allOnlineUsersNode)
{
Result::OnlineUsersItem onlineUsersItemObject;
if(!resultNodeOnlineUsersonlineUsersItem["UserId"].isNull())
onlineUsersItemObject.userId = resultNodeOnlineUsersonlineUsersItem["UserId"].asString();
if(!resultNodeOnlineUsersonlineUsersItem["JoinTime"].isNull())
onlineUsersItemObject.joinTime = std::stol(resultNodeOnlineUsersonlineUsersItem["JoinTime"].asString());
if(!resultNodeOnlineUsersonlineUsersItem["Online"].isNull())
onlineUsersItemObject.online = resultNodeOnlineUsersonlineUsersItem["Online"].asString() == "true";
result_.onlineUsers.push_back(onlineUsersItemObject);
}
}
BatchGetOnlineUsersResult::Result BatchGetOnlineUsersResult::getResult()const
{
return result_;
}

81
live/src/model/CreateLiveDelayConfigRequest.cc Normal file
View File

@@ -0,0 +1,81 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include <alibabacloud/live/model/CreateLiveDelayConfigRequest.h>
using AlibabaCloud::Live::Model::CreateLiveDelayConfigRequest;
CreateLiveDelayConfigRequest::CreateLiveDelayConfigRequest()
: RpcServiceRequest("live", "2016-11-01", "CreateLiveDelayConfig") {
setMethod(HttpRequest::Method::Post);
}
CreateLiveDelayConfigRequest::~CreateLiveDelayConfigRequest() {}
int CreateLiveDelayConfigRequest::getDelayTime() const {
return delayTime_;
}
void CreateLiveDelayConfigRequest::setDelayTime(int delayTime) {
delayTime_ = delayTime;
setParameter(std::string("DelayTime"), std::to_string(delayTime));
}
std::string CreateLiveDelayConfigRequest::getStream() const {
return stream_;
}
void CreateLiveDelayConfigRequest::setStream(const std::string &stream) {
stream_ = stream;
setParameter(std::string("Stream"), stream);
}
std::string CreateLiveDelayConfigRequest::getApp() const {
return app_;
}
void CreateLiveDelayConfigRequest::setApp(const std::string &app) {
app_ = app;
setParameter(std::string("App"), app);
}
long CreateLiveDelayConfigRequest::getOwnerId() const {
return ownerId_;
}
void CreateLiveDelayConfigRequest::setOwnerId(long ownerId) {
ownerId_ = ownerId;
setParameter(std::string("OwnerId"), std::to_string(ownerId));
}
std::string CreateLiveDelayConfigRequest::getTaskTriggerMode() const {
return taskTriggerMode_;
}
void CreateLiveDelayConfigRequest::setTaskTriggerMode(const std::string &taskTriggerMode) {
taskTriggerMode_ = taskTriggerMode;
setParameter(std::string("TaskTriggerMode"), taskTriggerMode);
}
std::string CreateLiveDelayConfigRequest::getDomain() const {
return domain_;
}
void CreateLiveDelayConfigRequest::setDomain(const std::string &domain) {
domain_ = domain;
setParameter(std::string("Domain"), domain);
}

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

63
live/src/model/DeleteLiveDelayConfigRequest.cc 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.
*/
#include <alibabacloud/live/model/DeleteLiveDelayConfigRequest.h>
using AlibabaCloud::Live::Model::DeleteLiveDelayConfigRequest;
DeleteLiveDelayConfigRequest::DeleteLiveDelayConfigRequest()
: RpcServiceRequest("live", "2016-11-01", "DeleteLiveDelayConfig") {
setMethod(HttpRequest::Method::Post);
}
DeleteLiveDelayConfigRequest::~DeleteLiveDelayConfigRequest() {}
std::string DeleteLiveDelayConfigRequest::getStream() const {
return stream_;
}
void DeleteLiveDelayConfigRequest::setStream(const std::string &stream) {
stream_ = stream;
setParameter(std::string("Stream"), stream);
}
std::string DeleteLiveDelayConfigRequest::getApp() const {
return app_;
}
void DeleteLiveDelayConfigRequest::setApp(const std::string &app) {
app_ = app;
setParameter(std::string("App"), app);
}
long DeleteLiveDelayConfigRequest::getOwnerId() const {
return ownerId_;
}
void DeleteLiveDelayConfigRequest::setOwnerId(long ownerId) {
ownerId_ = ownerId;
setParameter(std::string("OwnerId"), std::to_string(ownerId));
}
std::string DeleteLiveDelayConfigRequest::getDomain() const {
return domain_;
}
void DeleteLiveDelayConfigRequest::setDomain(const std::string &domain) {
domain_ = domain;
setParameter(std::string("Domain"), domain);
}

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

2
live/src/model/DescribeCasterConfigResult.cc
View File

@@ -63,6 +63,8 @@ void DescribeCasterConfigResult::parse(const std::string &payload)
recordConfig_.ossEndpoint = recordConfigNode["OssEndpoint"].asString();
if(!recordConfigNode["OssBucket"].isNull())
recordConfig_.ossBucket = recordConfigNode["OssBucket"].asString();
if(!recordConfigNode["OnDemand"].isNull())
recordConfig_.onDemand = std::stoi(recordConfigNode["OnDemand"].asString());
auto allRecordFormatNode = recordConfigNode["RecordFormat"]["RecordFormatItem"];
for (auto recordConfigNodeRecordFormatRecordFormatItem : allRecordFormatNode)
{

63
live/src/model/DescribeLiveDelayConfigRequest.cc 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.
*/
#include <alibabacloud/live/model/DescribeLiveDelayConfigRequest.h>
using AlibabaCloud::Live::Model::DescribeLiveDelayConfigRequest;
DescribeLiveDelayConfigRequest::DescribeLiveDelayConfigRequest()
: RpcServiceRequest("live", "2016-11-01", "DescribeLiveDelayConfig") {
setMethod(HttpRequest::Method::Post);
}
DescribeLiveDelayConfigRequest::~DescribeLiveDelayConfigRequest() {}
std::string DescribeLiveDelayConfigRequest::getStream() const {
return stream_;
}
void DescribeLiveDelayConfigRequest::setStream(const std::string &stream) {
stream_ = stream;
setParameter(std::string("Stream"), stream);
}
std::string DescribeLiveDelayConfigRequest::getApp() const {
return app_;
}
void DescribeLiveDelayConfigRequest::setApp(const std::string &app) {
app_ = app;
setParameter(std::string("App"), app);
}
long DescribeLiveDelayConfigRequest::getOwnerId() const {
return ownerId_;
}
void DescribeLiveDelayConfigRequest::setOwnerId(long ownerId) {
ownerId_ = ownerId;
setParameter(std::string("OwnerId"), std::to_string(ownerId));
}
std::string DescribeLiveDelayConfigRequest::getDomain() const {
return domain_;
}
void DescribeLiveDelayConfigRequest::setDomain(const std::string &domain) {
domain_ = domain;
setParameter(std::string("Domain"), domain);
}

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

@@ -0,0 +1,79 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include <alibabacloud/live/model/DescribeLiveDelayConfigResult.h>
#include <json/json.h>
using namespace AlibabaCloud::Live;
using namespace AlibabaCloud::Live::Model;
DescribeLiveDelayConfigResult::DescribeLiveDelayConfigResult() :
ServiceResult()
{}
DescribeLiveDelayConfigResult::DescribeLiveDelayConfigResult(const std::string &payload) :
ServiceResult()
{
parse(payload);
}
DescribeLiveDelayConfigResult::~DescribeLiveDelayConfigResult()
{}
void DescribeLiveDelayConfigResult::parse(const std::string &payload)
{
Json::Reader reader;
Json::Value value;
reader.parse(payload, value);
setRequestId(value["RequestId"].asString());
if(!value["Domain"].isNull())
domain_ = value["Domain"].asString();
if(!value["TaskTriggerMode"].isNull())
taskTriggerMode_ = value["TaskTriggerMode"].asString();
if(!value["App"].isNull())
app_ = value["App"].asString();
if(!value["DelayTime"].isNull())
delayTime_ = value["DelayTime"].asString();
if(!value["Stream"].isNull())
stream_ = value["Stream"].asString();
}
std::string DescribeLiveDelayConfigResult::getApp()const
{
return app_;
}
std::string DescribeLiveDelayConfigResult::getTaskTriggerMode()const
{
return taskTriggerMode_;
}
std::string DescribeLiveDelayConfigResult::getStream()const
{
return stream_;
}
std::string DescribeLiveDelayConfigResult::getDomain()const
{
return domain_;
}
std::string DescribeLiveDelayConfigResult::getDelayTime()const
{
return delayTime_;
}

9
live/src/model/DescribeLiveDomainRecordUsageDataRequest.cc
View File

@@ -79,3 +79,12 @@ void DescribeLiveDomainRecordUsageDataRequest::setInterval(const std::string &in
setParameter(std::string("Interval"), interval);
}
std::string DescribeLiveDomainRecordUsageDataRequest::getRegion() const {
return region_;
}
void DescribeLiveDomainRecordUsageDataRequest::setRegion(const std::string &region) {
region_ = region;
setParameter(std::string("Region"), region);
}

6
live/src/model/DescribeLiveDomainRecordUsageDataResult.cc
View File

@@ -45,12 +45,14 @@ void DescribeLiveDomainRecordUsageDataResult::parse(const std::string &payload)
DataModule recordUsageDataObject;
if(!valueRecordUsageDataDataModule["Type"].isNull())
recordUsageDataObject.type = valueRecordUsageDataDataModule["Type"].asString();
if(!valueRecordUsageDataDataModule["Duration"].isNull())
recordUsageDataObject.duration = std::stol(valueRecordUsageDataDataModule["Duration"].asString());
if(!valueRecordUsageDataDataModule["Domain"].isNull())
recordUsageDataObject.domain = valueRecordUsageDataDataModule["Domain"].asString();
if(!valueRecordUsageDataDataModule["Region"].isNull())
recordUsageDataObject.region = valueRecordUsageDataDataModule["Region"].asString();
if(!valueRecordUsageDataDataModule["TimeStamp"].isNull())
recordUsageDataObject.timeStamp = valueRecordUsageDataDataModule["TimeStamp"].asString();
if(!valueRecordUsageDataDataModule["Duration"].isNull())
recordUsageDataObject.duration = std::stol(valueRecordUsageDataDataModule["Duration"].asString());
if(!valueRecordUsageDataDataModule["Count"].isNull())
recordUsageDataObject.count = std::stol(valueRecordUsageDataDataModule["Count"].asString());
recordUsageData_.push_back(recordUsageDataObject);

108
live/src/model/DescribeLiveRecordNotifyRecordsRequest.cc Normal file
View File

@@ -0,0 +1,108 @@
/*
* 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/DescribeLiveRecordNotifyRecordsRequest.h>
using AlibabaCloud::Live::Model::DescribeLiveRecordNotifyRecordsRequest;
DescribeLiveRecordNotifyRecordsRequest::DescribeLiveRecordNotifyRecordsRequest()
: RpcServiceRequest("live", "2016-11-01", "DescribeLiveRecordNotifyRecords") {
setMethod(HttpRequest::Method::Post);
}
DescribeLiveRecordNotifyRecordsRequest::~DescribeLiveRecordNotifyRecordsRequest() {}
std::string DescribeLiveRecordNotifyRecordsRequest::getStartTime() const {
return startTime_;
}
void DescribeLiveRecordNotifyRecordsRequest::setStartTime(const std::string &startTime) {
startTime_ = startTime;
setParameter(std::string("StartTime"), startTime);
}
long DescribeLiveRecordNotifyRecordsRequest::getPageNumber() const {
return pageNumber_;
}
void DescribeLiveRecordNotifyRecordsRequest::setPageNumber(long pageNumber) {
pageNumber_ = pageNumber;
setParameter(std::string("PageNumber"), std::to_string(pageNumber));
}
std::string DescribeLiveRecordNotifyRecordsRequest::getAppName() const {
return appName_;
}
void DescribeLiveRecordNotifyRecordsRequest::setAppName(const std::string &appName) {
appName_ = appName;
setParameter(std::string("AppName"), appName);
}
long DescribeLiveRecordNotifyRecordsRequest::getPageSize() const {
return pageSize_;
}
void DescribeLiveRecordNotifyRecordsRequest::setPageSize(long pageSize) {
pageSize_ = pageSize;
setParameter(std::string("PageSize"), std::to_string(pageSize));
}
std::string DescribeLiveRecordNotifyRecordsRequest::getStreamName() const {
return streamName_;
}
void DescribeLiveRecordNotifyRecordsRequest::setStreamName(const std::string &streamName) {
streamName_ = streamName;
setParameter(std::string("StreamName"), streamName);
}
std::string DescribeLiveRecordNotifyRecordsRequest::getDomainName() const {
return domainName_;
}
void DescribeLiveRecordNotifyRecordsRequest::setDomainName(const std::string &domainName) {
domainName_ = domainName;
setParameter(std::string("DomainName"), domainName);
}
std::string DescribeLiveRecordNotifyRecordsRequest::getEndTime() const {
return endTime_;
}
void DescribeLiveRecordNotifyRecordsRequest::setEndTime(const std::string &endTime) {
endTime_ = endTime;
setParameter(std::string("EndTime"), endTime);
}
long DescribeLiveRecordNotifyRecordsRequest::getOwnerId() const {
return ownerId_;
}
void DescribeLiveRecordNotifyRecordsRequest::setOwnerId(long ownerId) {
ownerId_ = ownerId;
setParameter(std::string("OwnerId"), std::to_string(ownerId));
}
std::string DescribeLiveRecordNotifyRecordsRequest::getStatus() const {
return status_;
}
void DescribeLiveRecordNotifyRecordsRequest::setStatus(const std::string &status) {
status_ = status;
setParameter(std::string("Status"), status);
}

115
live/src/model/DescribeLiveRecordNotifyRecordsResult.cc Normal file
View File

@@ -0,0 +1,115 @@
/*
* 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/DescribeLiveRecordNotifyRecordsResult.h>
#include <json/json.h>
using namespace AlibabaCloud::Live;
using namespace AlibabaCloud::Live::Model;
DescribeLiveRecordNotifyRecordsResult::DescribeLiveRecordNotifyRecordsResult() :
ServiceResult()
{}
DescribeLiveRecordNotifyRecordsResult::DescribeLiveRecordNotifyRecordsResult(const std::string &payload) :
ServiceResult()
{
parse(payload);
}
DescribeLiveRecordNotifyRecordsResult::~DescribeLiveRecordNotifyRecordsResult()
{}
void DescribeLiveRecordNotifyRecordsResult::parse(const std::string &payload)
{
Json::Reader reader;
Json::Value value;
reader.parse(payload, value);
setRequestId(value["RequestId"].asString());
auto allCallbackListNode = value["CallbackList"]["Callback"];
for (auto valueCallbackListCallback : allCallbackListNode)
{
Callback callbackListObject;
if(!valueCallbackListCallback["AppName"].isNull())
callbackListObject.appName = valueCallbackListCallback["AppName"].asString();
if(!valueCallbackListCallback["NotifyType"].isNull())
callbackListObject.notifyType = valueCallbackListCallback["NotifyType"].asString();
if(!valueCallbackListCallback["NotifyContent"].isNull())
callbackListObject.notifyContent = valueCallbackListCallback["NotifyContent"].asString();
if(!valueCallbackListCallback["Description"].isNull())
callbackListObject.description = valueCallbackListCallback["Description"].asString();
if(!valueCallbackListCallback["StreamName"].isNull())
callbackListObject.streamName = valueCallbackListCallback["StreamName"].asString();
if(!valueCallbackListCallback["NotifyUrl"].isNull())
callbackListObject.notifyUrl = valueCallbackListCallback["NotifyUrl"].asString();
if(!valueCallbackListCallback["NotifyResult"].isNull())
callbackListObject.notifyResult = valueCallbackListCallback["NotifyResult"].asString();
if(!valueCallbackListCallback["NotifyTime"].isNull())
callbackListObject.notifyTime = valueCallbackListCallback["NotifyTime"].asString();
if(!valueCallbackListCallback["DomainName"].isNull())
callbackListObject.domainName = valueCallbackListCallback["DomainName"].asString();
callbackList_.push_back(callbackListObject);
}
if(!value["Msg"].isNull())
msg_ = value["Msg"].asString();
if(!value["PageNum"].isNull())
pageNum_ = std::stoi(value["PageNum"].asString());
if(!value["Code"].isNull())
code_ = std::stoi(value["Code"].asString());
if(!value["TotalPage"].isNull())
totalPage_ = std::stoi(value["TotalPage"].asString());
if(!value["PageSize"].isNull())
pageSize_ = std::stoi(value["PageSize"].asString());
if(!value["TotalNum"].isNull())
totalNum_ = std::stoi(value["TotalNum"].asString());
}
std::string DescribeLiveRecordNotifyRecordsResult::getMsg()const
{
return msg_;
}
int DescribeLiveRecordNotifyRecordsResult::getTotalNum()const
{
return totalNum_;
}
std::vector<DescribeLiveRecordNotifyRecordsResult::Callback> DescribeLiveRecordNotifyRecordsResult::getCallbackList()const
{
return callbackList_;
}
int DescribeLiveRecordNotifyRecordsResult::getPageNum()const
{
return pageNum_;
}
int DescribeLiveRecordNotifyRecordsResult::getTotalPage()const
{
return totalPage_;
}
int DescribeLiveRecordNotifyRecordsResult::getPageSize()const
{
return pageSize_;
}
int DescribeLiveRecordNotifyRecordsResult::getCode()const
{
return code_;
}

63
live/src/model/ListLiveDelayConfigRequest.cc 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.
*/
#include <alibabacloud/live/model/ListLiveDelayConfigRequest.h>
using AlibabaCloud::Live::Model::ListLiveDelayConfigRequest;
ListLiveDelayConfigRequest::ListLiveDelayConfigRequest()
: RpcServiceRequest("live", "2016-11-01", "ListLiveDelayConfig") {
setMethod(HttpRequest::Method::Post);
}
ListLiveDelayConfigRequest::~ListLiveDelayConfigRequest() {}
int ListLiveDelayConfigRequest::getPageNum() const {
return pageNum_;
}
void ListLiveDelayConfigRequest::setPageNum(int pageNum) {
pageNum_ = pageNum;
setParameter(std::string("PageNum"), std::to_string(pageNum));
}
int ListLiveDelayConfigRequest::getPageSize() const {
return pageSize_;
}
void ListLiveDelayConfigRequest::setPageSize(int pageSize) {
pageSize_ = pageSize;
setParameter(std::string("PageSize"), std::to_string(pageSize));
}
long ListLiveDelayConfigRequest::getOwnerId() const {
return ownerId_;
}
void ListLiveDelayConfigRequest::setOwnerId(long ownerId) {
ownerId_ = ownerId;
setParameter(std::string("OwnerId"), std::to_string(ownerId));
}
std::string ListLiveDelayConfigRequest::getDomain() const {
return domain_;
}
void ListLiveDelayConfigRequest::setDomain(const std::string &domain) {
domain_ = domain;
setParameter(std::string("Domain"), domain);
}

72
live/src/model/ListLiveDelayConfigResult.cc 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.
*/
#include <alibabacloud/live/model/ListLiveDelayConfigResult.h>
#include <json/json.h>
using namespace AlibabaCloud::Live;
using namespace AlibabaCloud::Live::Model;
ListLiveDelayConfigResult::ListLiveDelayConfigResult() :
ServiceResult()
{}
ListLiveDelayConfigResult::ListLiveDelayConfigResult(const std::string &payload) :
ServiceResult()
{
parse(payload);
}
ListLiveDelayConfigResult::~ListLiveDelayConfigResult()
{}
void ListLiveDelayConfigResult::parse(const std::string &payload)
{
Json::Reader reader;
Json::Value value;
reader.parse(payload, value);
setRequestId(value["RequestId"].asString());
auto allDelayConfigListNode = value["DelayConfigList"]["DelayConfig"];
for (auto valueDelayConfigListDelayConfig : allDelayConfigListNode)
{
DelayConfig delayConfigListObject;
if(!valueDelayConfigListDelayConfig["Stream"].isNull())
delayConfigListObject.stream = valueDelayConfigListDelayConfig["Stream"].asString();
if(!valueDelayConfigListDelayConfig["Domain"].isNull())
delayConfigListObject.domain = valueDelayConfigListDelayConfig["Domain"].asString();
if(!valueDelayConfigListDelayConfig["TaskTriggerMode"].isNull())
delayConfigListObject.taskTriggerMode = valueDelayConfigListDelayConfig["TaskTriggerMode"].asString();
if(!valueDelayConfigListDelayConfig["DelayTime"].isNull())
delayConfigListObject.delayTime = valueDelayConfigListDelayConfig["DelayTime"].asString();
if(!valueDelayConfigListDelayConfig["App"].isNull())
delayConfigListObject.app = valueDelayConfigListDelayConfig["App"].asString();
delayConfigList_.push_back(delayConfigListObject);
}
if(!value["Total"].isNull())
total_ = std::stoi(value["Total"].asString());
}
std::vector<ListLiveDelayConfigResult::DelayConfig> ListLiveDelayConfigResult::getDelayConfigList()const
{
return delayConfigList_;
}
int ListLiveDelayConfigResult::getTotal()const
{
return total_;
}

1
live/src/model/UpdateCasterSceneAudioRequest.cc
View File

@@ -55,6 +55,7 @@ void UpdateCasterSceneAudioRequest::setAudioLayer(const std::vector<UpdateCaster
setParameter(audioLayerObjStr + ".VolumeRate", std::to_string(audioLayerObj.volumeRate));
setParameter(audioLayerObjStr + ".FixedDelayDuration", std::to_string(audioLayerObj.fixedDelayDuration));
setParameter(audioLayerObjStr + ".ValidChannel", audioLayerObj.validChannel);
setParameter(audioLayerObjStr + ".Filter", audioLayerObj.filter);
}
}

81
live/src/model/UpdateLiveDelayConfigRequest.cc Normal file
View File

@@ -0,0 +1,81 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include <alibabacloud/live/model/UpdateLiveDelayConfigRequest.h>
using AlibabaCloud::Live::Model::UpdateLiveDelayConfigRequest;
UpdateLiveDelayConfigRequest::UpdateLiveDelayConfigRequest()
: RpcServiceRequest("live", "2016-11-01", "UpdateLiveDelayConfig") {
setMethod(HttpRequest::Method::Post);
}
UpdateLiveDelayConfigRequest::~UpdateLiveDelayConfigRequest() {}
int UpdateLiveDelayConfigRequest::getDelayTime() const {
return delayTime_;
}
void UpdateLiveDelayConfigRequest::setDelayTime(int delayTime) {
delayTime_ = delayTime;
setParameter(std::string("DelayTime"), std::to_string(delayTime));
}
std::string UpdateLiveDelayConfigRequest::getStream() const {
return stream_;
}
void UpdateLiveDelayConfigRequest::setStream(const std::string &stream) {
stream_ = stream;
setParameter(std::string("Stream"), stream);
}
std::string UpdateLiveDelayConfigRequest::getApp() const {
return app_;
}
void UpdateLiveDelayConfigRequest::setApp(const std::string &app) {
app_ = app;
setParameter(std::string("App"), app);
}
long UpdateLiveDelayConfigRequest::getOwnerId() const {
return ownerId_;
}
void UpdateLiveDelayConfigRequest::setOwnerId(long ownerId) {
ownerId_ = ownerId;
setParameter(std::string("OwnerId"), std::to_string(ownerId));
}
std::string UpdateLiveDelayConfigRequest::getTaskTriggerMode() const {
return taskTriggerMode_;
}
void UpdateLiveDelayConfigRequest::setTaskTriggerMode(const std::string &taskTriggerMode) {
taskTriggerMode_ = taskTriggerMode;
setParameter(std::string("TaskTriggerMode"), taskTriggerMode);
}
std::string UpdateLiveDelayConfigRequest::getDomain() const {
return domain_;
}
void UpdateLiveDelayConfigRequest::setDomain(const std::string &domain) {
domain_ = domain;
setParameter(std::string("Domain"), domain);
}

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