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

Generated 2016-11-01 for live.

Browse Source
This commit is contained in:
sdk-team
2023-08-08 06:05:38 +00:00
parent c994b2d439
commit fbae89fed4
60 changed files with 3462 additions and 103 deletions
Download Patch File Download Diff File Expand all files Collapse all files

360
live/src/LiveClient.cc
View File

@@ -2967,6 +2967,42 @@ LiveClient::DeleteLiveSpecificStagingConfigOutcomeCallable LiveClient::deleteLiv
return task->get_future();
}
LiveClient::DeleteLiveStreamBlockOutcome LiveClient::deleteLiveStreamBlock(const DeleteLiveStreamBlockRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return DeleteLiveStreamBlockOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return DeleteLiveStreamBlockOutcome(DeleteLiveStreamBlockResult(outcome.result()));
else
return DeleteLiveStreamBlockOutcome(outcome.error());
}
void LiveClient::deleteLiveStreamBlockAsync(const DeleteLiveStreamBlockRequest& request, const DeleteLiveStreamBlockAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, deleteLiveStreamBlock(request), context);
};
asyncExecute(new Runnable(fn));
}
LiveClient::DeleteLiveStreamBlockOutcomeCallable LiveClient::deleteLiveStreamBlockCallable(const DeleteLiveStreamBlockRequest &request) const
{
auto task = std::make_shared<std::packaged_task<DeleteLiveStreamBlockOutcome()>>(
[this, request]()
{
return this->deleteLiveStreamBlock(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
LiveClient::DeleteLiveStreamMonitorOutcome LiveClient::deleteLiveStreamMonitor(const DeleteLiveStreamMonitorRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -3975,6 +4011,42 @@ LiveClient::DescribeChannelParticipantsOutcomeCallable LiveClient::describeChann
return task->get_future();
}
LiveClient::DescribeChannelUsersOutcome LiveClient::describeChannelUsers(const DescribeChannelUsersRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return DescribeChannelUsersOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return DescribeChannelUsersOutcome(DescribeChannelUsersResult(outcome.result()));
else
return DescribeChannelUsersOutcome(outcome.error());
}
void LiveClient::describeChannelUsersAsync(const DescribeChannelUsersRequest& request, const DescribeChannelUsersAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, describeChannelUsers(request), context);
};
asyncExecute(new Runnable(fn));
}
LiveClient::DescribeChannelUsersOutcomeCallable LiveClient::describeChannelUsersCallable(const DescribeChannelUsersRequest &request) const
{
auto task = std::make_shared<std::packaged_task<DescribeChannelUsersOutcome()>>(
[this, request]()
{
return this->describeChannelUsers(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
LiveClient::DescribeDomainUsageDataOutcome LiveClient::describeDomainUsageData(const DescribeDomainUsageDataRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -4191,6 +4263,42 @@ LiveClient::DescribeLiveAudioAuditNotifyConfigOutcomeCallable LiveClient::descri
return task->get_future();
}
LiveClient::DescribeLiveCdnDiagnoseInfoOutcome LiveClient::describeLiveCdnDiagnoseInfo(const DescribeLiveCdnDiagnoseInfoRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return DescribeLiveCdnDiagnoseInfoOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return DescribeLiveCdnDiagnoseInfoOutcome(DescribeLiveCdnDiagnoseInfoResult(outcome.result()));
else
return DescribeLiveCdnDiagnoseInfoOutcome(outcome.error());
}
void LiveClient::describeLiveCdnDiagnoseInfoAsync(const DescribeLiveCdnDiagnoseInfoRequest& request, const DescribeLiveCdnDiagnoseInfoAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, describeLiveCdnDiagnoseInfo(request), context);
};
asyncExecute(new Runnable(fn));
}
LiveClient::DescribeLiveCdnDiagnoseInfoOutcomeCallable LiveClient::describeLiveCdnDiagnoseInfoCallable(const DescribeLiveCdnDiagnoseInfoRequest &request) const
{
auto task = std::make_shared<std::packaged_task<DescribeLiveCdnDiagnoseInfoOutcome()>>(
[this, request]()
{
return this->describeLiveCdnDiagnoseInfo(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
LiveClient::DescribeLiveCenterTransferOutcome LiveClient::describeLiveCenterTransfer(const DescribeLiveCenterTransferRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -5379,6 +5487,42 @@ LiveClient::DescribeLiveDomainTranscodeDataOutcomeCallable LiveClient::describeL
return task->get_future();
}
LiveClient::DescribeLiveDomainTranscodeParamsOutcome LiveClient::describeLiveDomainTranscodeParams(const DescribeLiveDomainTranscodeParamsRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return DescribeLiveDomainTranscodeParamsOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return DescribeLiveDomainTranscodeParamsOutcome(DescribeLiveDomainTranscodeParamsResult(outcome.result()));
else
return DescribeLiveDomainTranscodeParamsOutcome(outcome.error());
}
void LiveClient::describeLiveDomainTranscodeParamsAsync(const DescribeLiveDomainTranscodeParamsRequest& request, const DescribeLiveDomainTranscodeParamsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, describeLiveDomainTranscodeParams(request), context);
};
asyncExecute(new Runnable(fn));
}
LiveClient::DescribeLiveDomainTranscodeParamsOutcomeCallable LiveClient::describeLiveDomainTranscodeParamsCallable(const DescribeLiveDomainTranscodeParamsRequest &request) const
{
auto task = std::make_shared<std::packaged_task<DescribeLiveDomainTranscodeParamsOutcome()>>(
[this, request]()
{
return this->describeLiveDomainTranscodeParams(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
LiveClient::DescribeLiveDrmUsageDataOutcome LiveClient::describeLiveDrmUsageData(const DescribeLiveDrmUsageDataRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -6207,6 +6351,42 @@ LiveClient::DescribeLiveStreamOptimizedFeatureConfigOutcomeCallable LiveClient::
return task->get_future();
}
LiveClient::DescribeLiveStreamPreloadTasksOutcome LiveClient::describeLiveStreamPreloadTasks(const DescribeLiveStreamPreloadTasksRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return DescribeLiveStreamPreloadTasksOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return DescribeLiveStreamPreloadTasksOutcome(DescribeLiveStreamPreloadTasksResult(outcome.result()));
else
return DescribeLiveStreamPreloadTasksOutcome(outcome.error());
}
void LiveClient::describeLiveStreamPreloadTasksAsync(const DescribeLiveStreamPreloadTasksRequest& request, const DescribeLiveStreamPreloadTasksAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, describeLiveStreamPreloadTasks(request), context);
};
asyncExecute(new Runnable(fn));
}
LiveClient::DescribeLiveStreamPreloadTasksOutcomeCallable LiveClient::describeLiveStreamPreloadTasksCallable(const DescribeLiveStreamPreloadTasksRequest &request) const
{
auto task = std::make_shared<std::packaged_task<DescribeLiveStreamPreloadTasksOutcome()>>(
[this, request]()
{
return this->describeLiveStreamPreloadTasks(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
LiveClient::DescribeLiveStreamRecordContentOutcome LiveClient::describeLiveStreamRecordContent(const DescribeLiveStreamRecordContentRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -7359,6 +7539,42 @@ LiveClient::DescribeShowListOutcomeCallable LiveClient::describeShowListCallable
return task->get_future();
}
LiveClient::DescribeStreamLocationBlockOutcome LiveClient::describeStreamLocationBlock(const DescribeStreamLocationBlockRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return DescribeStreamLocationBlockOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return DescribeStreamLocationBlockOutcome(DescribeStreamLocationBlockResult(outcome.result()));
else
return DescribeStreamLocationBlockOutcome(outcome.error());
}
void LiveClient::describeStreamLocationBlockAsync(const DescribeStreamLocationBlockRequest& request, const DescribeStreamLocationBlockAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, describeStreamLocationBlock(request), context);
};
asyncExecute(new Runnable(fn));
}
LiveClient::DescribeStreamLocationBlockOutcomeCallable LiveClient::describeStreamLocationBlockCallable(const DescribeStreamLocationBlockRequest &request) const
{
auto task = std::make_shared<std::packaged_task<DescribeStreamLocationBlockOutcome()>>(
[this, request]()
{
return this->describeStreamLocationBlock(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
LiveClient::DescribeStudioLayoutsOutcome LiveClient::describeStudioLayouts(const DescribeStudioLayoutsRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -10095,6 +10311,42 @@ LiveClient::SetLiveMpuTaskSeiOutcomeCallable LiveClient::setLiveMpuTaskSeiCallab
return task->get_future();
}
LiveClient::SetLiveStreamBlockOutcome LiveClient::setLiveStreamBlock(const SetLiveStreamBlockRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return SetLiveStreamBlockOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return SetLiveStreamBlockOutcome(SetLiveStreamBlockResult(outcome.result()));
else
return SetLiveStreamBlockOutcome(outcome.error());
}
void LiveClient::setLiveStreamBlockAsync(const SetLiveStreamBlockRequest& request, const SetLiveStreamBlockAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, setLiveStreamBlock(request), context);
};
asyncExecute(new Runnable(fn));
}
LiveClient::SetLiveStreamBlockOutcomeCallable LiveClient::setLiveStreamBlockCallable(const SetLiveStreamBlockRequest &request) const
{
auto task = std::make_shared<std::packaged_task<SetLiveStreamBlockOutcome()>>(
[this, request]()
{
return this->setLiveStreamBlock(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
LiveClient::SetLiveStreamDelayConfigOutcome LiveClient::setLiveStreamDelayConfig(const SetLiveStreamDelayConfigRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -10167,6 +10419,42 @@ LiveClient::SetLiveStreamOptimizedFeatureConfigOutcomeCallable LiveClient::setLi
return task->get_future();
}
LiveClient::SetLiveStreamPreloadTasksOutcome LiveClient::setLiveStreamPreloadTasks(const SetLiveStreamPreloadTasksRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return SetLiveStreamPreloadTasksOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return SetLiveStreamPreloadTasksOutcome(SetLiveStreamPreloadTasksResult(outcome.result()));
else
return SetLiveStreamPreloadTasksOutcome(outcome.error());
}
void LiveClient::setLiveStreamPreloadTasksAsync(const SetLiveStreamPreloadTasksRequest& request, const SetLiveStreamPreloadTasksAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, setLiveStreamPreloadTasks(request), context);
};
asyncExecute(new Runnable(fn));
}
LiveClient::SetLiveStreamPreloadTasksOutcomeCallable LiveClient::setLiveStreamPreloadTasksCallable(const SetLiveStreamPreloadTasksRequest &request) const
{
auto task = std::make_shared<std::packaged_task<SetLiveStreamPreloadTasksOutcome()>>(
[this, request]()
{
return this->setLiveStreamPreloadTasks(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
LiveClient::SetLiveStreamsNotifyUrlConfigOutcome LiveClient::setLiveStreamsNotifyUrlConfig(const SetLiveStreamsNotifyUrlConfigRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -10743,6 +11031,42 @@ LiveClient::UpdateCasterSceneConfigOutcomeCallable LiveClient::updateCasterScene
return task->get_future();
}
LiveClient::UpdateLiveAppRecordConfigOutcome LiveClient::updateLiveAppRecordConfig(const UpdateLiveAppRecordConfigRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return UpdateLiveAppRecordConfigOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return UpdateLiveAppRecordConfigOutcome(UpdateLiveAppRecordConfigResult(outcome.result()));
else
return UpdateLiveAppRecordConfigOutcome(outcome.error());
}
void LiveClient::updateLiveAppRecordConfigAsync(const UpdateLiveAppRecordConfigRequest& request, const UpdateLiveAppRecordConfigAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, updateLiveAppRecordConfig(request), context);
};
asyncExecute(new Runnable(fn));
}
LiveClient::UpdateLiveAppRecordConfigOutcomeCallable LiveClient::updateLiveAppRecordConfigCallable(const UpdateLiveAppRecordConfigRequest &request) const
{
auto task = std::make_shared<std::packaged_task<UpdateLiveAppRecordConfigOutcome()>>(
[this, request]()
{
return this->updateLiveAppRecordConfig(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
LiveClient::UpdateLiveAppSnapshotConfigOutcome LiveClient::updateLiveAppSnapshotConfig(const UpdateLiveAppSnapshotConfigRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -11031,6 +11355,42 @@ LiveClient::UpdateLiveRecordNotifyConfigOutcomeCallable LiveClient::updateLiveRe
return task->get_future();
}
LiveClient::UpdateLiveRecordVodConfigOutcome LiveClient::updateLiveRecordVodConfig(const UpdateLiveRecordVodConfigRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return UpdateLiveRecordVodConfigOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return UpdateLiveRecordVodConfigOutcome(UpdateLiveRecordVodConfigResult(outcome.result()));
else
return UpdateLiveRecordVodConfigOutcome(outcome.error());
}
void LiveClient::updateLiveRecordVodConfigAsync(const UpdateLiveRecordVodConfigRequest& request, const UpdateLiveRecordVodConfigAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, updateLiveRecordVodConfig(request), context);
};
asyncExecute(new Runnable(fn));
}
LiveClient::UpdateLiveRecordVodConfigOutcomeCallable LiveClient::updateLiveRecordVodConfigCallable(const UpdateLiveRecordVodConfigRequest &request) const
{
auto task = std::make_shared<std::packaged_task<UpdateLiveRecordVodConfigOutcome()>>(
[this, request]()
{
return this->updateLiveRecordVodConfig(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
LiveClient::UpdateLiveSnapshotDetectPornConfigOutcome LiveClient::updateLiveSnapshotDetectPornConfig(const UpdateLiveSnapshotDetectPornConfigRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();

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

@@ -25,22 +25,13 @@ AddCustomLiveStreamTranscodeRequest::AddCustomLiveStreamTranscodeRequest()
AddCustomLiveStreamTranscodeRequest::~AddCustomLiveStreamTranscodeRequest() {}
std::string AddCustomLiveStreamTranscodeRequest::get_Template() const {
return _template_;
std::string AddCustomLiveStreamTranscodeRequest::getResWithSource() const {
return resWithSource_;
}
void AddCustomLiveStreamTranscodeRequest::set_Template(const std::string &_template) {
_template_ = _template;
setParameter(std::string("Template"), _template);
}
std::string AddCustomLiveStreamTranscodeRequest::getLazy() const {
return lazy_;
}
void AddCustomLiveStreamTranscodeRequest::setLazy(const std::string &lazy) {
lazy_ = lazy;
setParameter(std::string("Lazy"), lazy);
void AddCustomLiveStreamTranscodeRequest::setResWithSource(const std::string &resWithSource) {
resWithSource_ = resWithSource;
setParameter(std::string("ResWithSource"), resWithSource);
}
std::string AddCustomLiveStreamTranscodeRequest::getGop() const {
@@ -52,15 +43,6 @@ void AddCustomLiveStreamTranscodeRequest::setGop(const std::string &gop) {
setParameter(std::string("Gop"), gop);
}
std::string AddCustomLiveStreamTranscodeRequest::getKmsKeyExpireInterval() const {
return kmsKeyExpireInterval_;
}
void AddCustomLiveStreamTranscodeRequest::setKmsKeyExpireInterval(const std::string &kmsKeyExpireInterval) {
kmsKeyExpireInterval_ = kmsKeyExpireInterval;
setParameter(std::string("KmsKeyExpireInterval"), kmsKeyExpireInterval);
}
std::string AddCustomLiveStreamTranscodeRequest::getAudioCodec() const {
return audioCodec_;
}
@@ -79,24 +61,6 @@ void AddCustomLiveStreamTranscodeRequest::setKmsUID(const std::string &kmsUID) {
setParameter(std::string("KmsUID"), kmsUID);
}
std::string AddCustomLiveStreamTranscodeRequest::getTemplateType() const {
return templateType_;
}
void AddCustomLiveStreamTranscodeRequest::setTemplateType(const std::string &templateType) {
templateType_ = templateType;
setParameter(std::string("TemplateType"), templateType);
}
std::string AddCustomLiveStreamTranscodeRequest::getAudioProfile() const {
return audioProfile_;
}
void AddCustomLiveStreamTranscodeRequest::setAudioProfile(const std::string &audioProfile) {
audioProfile_ = audioProfile;
setParameter(std::string("AudioProfile"), audioProfile);
}
int AddCustomLiveStreamTranscodeRequest::getHeight() const {
return height_;
}
@@ -115,6 +79,96 @@ void AddCustomLiveStreamTranscodeRequest::setApp(const std::string &app) {
setParameter(std::string("App"), app);
}
int AddCustomLiveStreamTranscodeRequest::getProfile() const {
return profile_;
}
void AddCustomLiveStreamTranscodeRequest::setProfile(int profile) {
profile_ = profile;
setParameter(std::string("Profile"), std::to_string(profile));
}
long AddCustomLiveStreamTranscodeRequest::getOwnerId() const {
return ownerId_;
}
void AddCustomLiveStreamTranscodeRequest::setOwnerId(long ownerId) {
ownerId_ = ownerId;
setParameter(std::string("OwnerId"), std::to_string(ownerId));
}
std::string AddCustomLiveStreamTranscodeRequest::getExtWithSource() const {
return extWithSource_;
}
void AddCustomLiveStreamTranscodeRequest::setExtWithSource(const std::string &extWithSource) {
extWithSource_ = extWithSource;
setParameter(std::string("ExtWithSource"), extWithSource);
}
std::string AddCustomLiveStreamTranscodeRequest::getBitrateWithSource() const {
return bitrateWithSource_;
}
void AddCustomLiveStreamTranscodeRequest::setBitrateWithSource(const std::string &bitrateWithSource) {
bitrateWithSource_ = bitrateWithSource;
setParameter(std::string("BitrateWithSource"), bitrateWithSource);
}
std::string AddCustomLiveStreamTranscodeRequest::getDomain() const {
return domain_;
}
void AddCustomLiveStreamTranscodeRequest::setDomain(const std::string &domain) {
domain_ = domain;
setParameter(std::string("Domain"), domain);
}
std::string AddCustomLiveStreamTranscodeRequest::get_Template() const {
return _template_;
}
void AddCustomLiveStreamTranscodeRequest::set_Template(const std::string &_template) {
_template_ = _template;
setParameter(std::string("Template"), _template);
}
std::string AddCustomLiveStreamTranscodeRequest::getLazy() const {
return lazy_;
}
void AddCustomLiveStreamTranscodeRequest::setLazy(const std::string &lazy) {
lazy_ = lazy;
setParameter(std::string("Lazy"), lazy);
}
std::string AddCustomLiveStreamTranscodeRequest::getKmsKeyExpireInterval() const {
return kmsKeyExpireInterval_;
}
void AddCustomLiveStreamTranscodeRequest::setKmsKeyExpireInterval(const std::string &kmsKeyExpireInterval) {
kmsKeyExpireInterval_ = kmsKeyExpireInterval;
setParameter(std::string("KmsKeyExpireInterval"), kmsKeyExpireInterval);
}
std::string AddCustomLiveStreamTranscodeRequest::getTemplateType() const {
return templateType_;
}
void AddCustomLiveStreamTranscodeRequest::setTemplateType(const std::string &templateType) {
templateType_ = templateType;
setParameter(std::string("TemplateType"), templateType);
}
std::string AddCustomLiveStreamTranscodeRequest::getAudioProfile() const {
return audioProfile_;
}
void AddCustomLiveStreamTranscodeRequest::setAudioProfile(const std::string &audioProfile) {
audioProfile_ = audioProfile;
setParameter(std::string("AudioProfile"), audioProfile);
}
std::string AddCustomLiveStreamTranscodeRequest::getEncryptParameters() const {
return encryptParameters_;
}
@@ -133,15 +187,6 @@ void AddCustomLiveStreamTranscodeRequest::setAudioChannelNum(int audioChannelNum
setParameter(std::string("AudioChannelNum"), std::to_string(audioChannelNum));
}
int AddCustomLiveStreamTranscodeRequest::getProfile() const {
return profile_;
}
void AddCustomLiveStreamTranscodeRequest::setProfile(int profile) {
profile_ = profile;
setParameter(std::string("Profile"), std::to_string(profile));
}
int AddCustomLiveStreamTranscodeRequest::getFPS() const {
return fPS_;
}
@@ -151,15 +196,6 @@ void AddCustomLiveStreamTranscodeRequest::setFPS(int fPS) {
setParameter(std::string("FPS"), std::to_string(fPS));
}
long AddCustomLiveStreamTranscodeRequest::getOwnerId() const {
return ownerId_;
}
void AddCustomLiveStreamTranscodeRequest::setOwnerId(long ownerId) {
ownerId_ = ownerId;
setParameter(std::string("OwnerId"), std::to_string(ownerId));
}
int AddCustomLiveStreamTranscodeRequest::getAudioRate() const {
return audioRate_;
}
@@ -169,6 +205,15 @@ void AddCustomLiveStreamTranscodeRequest::setAudioRate(int audioRate) {
setParameter(std::string("AudioRate"), std::to_string(audioRate));
}
std::string AddCustomLiveStreamTranscodeRequest::getFpsWithSource() const {
return fpsWithSource_;
}
void AddCustomLiveStreamTranscodeRequest::setFpsWithSource(const std::string &fpsWithSource) {
fpsWithSource_ = fpsWithSource;
setParameter(std::string("FpsWithSource"), fpsWithSource);
}
int AddCustomLiveStreamTranscodeRequest::getAudioBitrate() const {
return audioBitrate_;
}
@@ -178,15 +223,6 @@ void AddCustomLiveStreamTranscodeRequest::setAudioBitrate(int audioBitrate) {
setParameter(std::string("AudioBitrate"), std::to_string(audioBitrate));
}
std::string AddCustomLiveStreamTranscodeRequest::getDomain() const {
return domain_;
}
void AddCustomLiveStreamTranscodeRequest::setDomain(const std::string &domain) {
domain_ = domain;
setParameter(std::string("Domain"), domain);
}
int AddCustomLiveStreamTranscodeRequest::getWidth() const {
return width_;
}

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

@@ -34,6 +34,15 @@ void AddLiveAppRecordConfigRequest::setOssEndpoint(const std::string &ossEndpoin
setParameter(std::string("OssEndpoint"), ossEndpoint);
}
int AddLiveAppRecordConfigRequest::getDelayTime() const {
return delayTime_;
}
void AddLiveAppRecordConfigRequest::setDelayTime(int delayTime) {
delayTime_ = delayTime;
setParameter(std::string("DelayTime"), std::to_string(delayTime));
}
std::vector<std::string> AddLiveAppRecordConfigRequest::getTranscodeTemplates() const {
return transcodeTemplates_;
}

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

@@ -61,6 +61,15 @@ void AddLiveRecordVodConfigRequest::setAppName(const std::string &appName) {
setParameter(std::string("AppName"), appName);
}
int AddLiveRecordVodConfigRequest::getOnDemand() const {
return onDemand_;
}
void AddLiveRecordVodConfigRequest::setOnDemand(int onDemand) {
onDemand_ = onDemand;
setParameter(std::string("OnDemand"), std::to_string(onDemand));
}
std::string AddLiveRecordVodConfigRequest::getStreamName() const {
return streamName_;
}

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

@@ -43,6 +43,15 @@ void CreateEventSubRequest::setClientToken(const std::string &clientToken) {
setParameter(std::string("ClientToken"), clientToken);
}
bool CreateEventSubRequest::getNeedCallbackAuthorization() const {
return needCallbackAuthorization_;
}
void CreateEventSubRequest::setNeedCallbackAuthorization(bool needCallbackAuthorization) {
needCallbackAuthorization_ = needCallbackAuthorization;
setParameter(std::string("NeedCallbackAuthorization"), needCallbackAuthorization ? "true" : "false");
}
std::vector<std::string> CreateEventSubRequest::getUsers() const {
return users_;
}

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

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

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

45
live/src/model/DescribeChannelUsersRequest.cc Normal file
View File

@@ -0,0 +1,45 @@
/*
* 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/DescribeChannelUsersRequest.h>
using AlibabaCloud::Live::Model::DescribeChannelUsersRequest;
DescribeChannelUsersRequest::DescribeChannelUsersRequest()
: RpcServiceRequest("live", "2016-11-01", "DescribeChannelUsers") {
setMethod(HttpRequest::Method::Post);
}
DescribeChannelUsersRequest::~DescribeChannelUsersRequest() {}
std::string DescribeChannelUsersRequest::getAppId() const {
return appId_;
}
void DescribeChannelUsersRequest::setAppId(const std::string &appId) {
appId_ = appId;
setParameter(std::string("AppId"), appId);
}
std::string DescribeChannelUsersRequest::getChannelId() const {
return channelId_;
}
void DescribeChannelUsersRequest::setChannelId(const std::string &channelId) {
channelId_ = channelId;
setParameter(std::string("ChannelId"), channelId);
}

88
live/src/model/DescribeChannelUsersResult.cc Normal file
View File

@@ -0,0 +1,88 @@
/*
* 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/DescribeChannelUsersResult.h>
#include <json/json.h>
using namespace AlibabaCloud::Live;
using namespace AlibabaCloud::Live::Model;
DescribeChannelUsersResult::DescribeChannelUsersResult() :
ServiceResult()
{}
DescribeChannelUsersResult::DescribeChannelUsersResult(const std::string &payload) :
ServiceResult()
{
parse(payload);
}
DescribeChannelUsersResult::~DescribeChannelUsersResult()
{}
void DescribeChannelUsersResult::parse(const std::string &payload)
{
Json::Reader reader;
Json::Value value;
reader.parse(payload, value);
setRequestId(value["RequestId"].asString());
auto allInteractiveUserList = value["InteractiveUserList"]["InteractiveUser"];
for (const auto &item : allInteractiveUserList)
interactiveUserList_.push_back(item.asString());
auto allLiveUserList = value["LiveUserList"]["LiveUser"];
for (const auto &item : allLiveUserList)
liveUserList_.push_back(item.asString());
if(!value["Timestamp"].isNull())
timestamp_ = std::stol(value["Timestamp"].asString());
if(!value["IsChannelExists"].isNull())
isChannelExists_ = value["IsChannelExists"].asString() == "true";
if(!value["InteractiveUserNumber"].isNull())
interactiveUserNumber_ = std::stoi(value["InteractiveUserNumber"].asString());
if(!value["LiveUserNumber"].isNull())
liveUserNumber_ = std::stoi(value["LiveUserNumber"].asString());
}
std::vector<std::string> DescribeChannelUsersResult::getInteractiveUserList()const
{
return interactiveUserList_;
}
int DescribeChannelUsersResult::getInteractiveUserNumber()const
{
return interactiveUserNumber_;
}
bool DescribeChannelUsersResult::getIsChannelExists()const
{
return isChannelExists_;
}
std::vector<std::string> DescribeChannelUsersResult::getLiveUserList()const
{
return liveUserList_;
}
long DescribeChannelUsersResult::getTimestamp()const
{
return timestamp_;
}
int DescribeChannelUsersResult::getLiveUserNumber()const
{
return liveUserNumber_;
}

108
live/src/model/DescribeLiveCdnDiagnoseInfoRequest.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/DescribeLiveCdnDiagnoseInfoRequest.h>
using AlibabaCloud::Live::Model::DescribeLiveCdnDiagnoseInfoRequest;
DescribeLiveCdnDiagnoseInfoRequest::DescribeLiveCdnDiagnoseInfoRequest()
: RpcServiceRequest("live", "2016-11-01", "DescribeLiveCdnDiagnoseInfo") {
setMethod(HttpRequest::Method::Post);
}
DescribeLiveCdnDiagnoseInfoRequest::~DescribeLiveCdnDiagnoseInfoRequest() {}
std::string DescribeLiveCdnDiagnoseInfoRequest::getIntervalType() const {
return intervalType_;
}
void DescribeLiveCdnDiagnoseInfoRequest::setIntervalType(const std::string &intervalType) {
intervalType_ = intervalType;
setParameter(std::string("intervalType"), intervalType);
}
std::string DescribeLiveCdnDiagnoseInfoRequest::getStreamSuffix() const {
return streamSuffix_;
}
void DescribeLiveCdnDiagnoseInfoRequest::setStreamSuffix(const std::string &streamSuffix) {
streamSuffix_ = streamSuffix;
setParameter(std::string("streamSuffix"), streamSuffix);
}
long DescribeLiveCdnDiagnoseInfoRequest::getStartTime() const {
return startTime_;
}
void DescribeLiveCdnDiagnoseInfoRequest::setStartTime(long startTime) {
startTime_ = startTime;
setParameter(std::string("startTime"), std::to_string(startTime));
}
std::string DescribeLiveCdnDiagnoseInfoRequest::getRequestType() const {
return requestType_;
}
void DescribeLiveCdnDiagnoseInfoRequest::setRequestType(const std::string &requestType) {
requestType_ = requestType;
setParameter(std::string("requestType"), requestType);
}
std::string DescribeLiveCdnDiagnoseInfoRequest::getStreamName() const {
return streamName_;
}
void DescribeLiveCdnDiagnoseInfoRequest::setStreamName(const std::string &streamName) {
streamName_ = streamName;
setParameter(std::string("streamName"), streamName);
}
std::string DescribeLiveCdnDiagnoseInfoRequest::getApp() const {
return app_;
}
void DescribeLiveCdnDiagnoseInfoRequest::setApp(const std::string &app) {
app_ = app;
setParameter(std::string("app"), app);
}
int DescribeLiveCdnDiagnoseInfoRequest::getPhase() const {
return phase_;
}
void DescribeLiveCdnDiagnoseInfoRequest::setPhase(int phase) {
phase_ = phase;
setParameter(std::string("phase"), std::to_string(phase));
}
long DescribeLiveCdnDiagnoseInfoRequest::getEndTime() const {
return endTime_;
}
void DescribeLiveCdnDiagnoseInfoRequest::setEndTime(long endTime) {
endTime_ = endTime;
setParameter(std::string("endTime"), std::to_string(endTime));
}
std::string DescribeLiveCdnDiagnoseInfoRequest::getDomain() const {
return domain_;
}
void DescribeLiveCdnDiagnoseInfoRequest::setDomain(const std::string &domain) {
domain_ = domain;
setParameter(std::string("domain"), domain);
}

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

54
live/src/model/DescribeLiveDomainTranscodeParamsRequest.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/DescribeLiveDomainTranscodeParamsRequest.h>
using AlibabaCloud::Live::Model::DescribeLiveDomainTranscodeParamsRequest;
DescribeLiveDomainTranscodeParamsRequest::DescribeLiveDomainTranscodeParamsRequest()
: RpcServiceRequest("live", "2016-11-01", "DescribeLiveDomainTranscodeParams") {
setMethod(HttpRequest::Method::Post);
}
DescribeLiveDomainTranscodeParamsRequest::~DescribeLiveDomainTranscodeParamsRequest() {}
std::string DescribeLiveDomainTranscodeParamsRequest::getPushdomain() const {
return pushdomain_;
}
void DescribeLiveDomainTranscodeParamsRequest::setPushdomain(const std::string &pushdomain) {
pushdomain_ = pushdomain;
setParameter(std::string("pushdomain"), pushdomain);
}
std::string DescribeLiveDomainTranscodeParamsRequest::getApp() const {
return app_;
}
void DescribeLiveDomainTranscodeParamsRequest::setApp(const std::string &app) {
app_ = app;
setParameter(std::string("app"), app);
}
std::string DescribeLiveDomainTranscodeParamsRequest::getTemplate_name() const {
return template_name_;
}
void DescribeLiveDomainTranscodeParamsRequest::setTemplate_name(const std::string &template_name) {
template_name_ = template_name;
setParameter(std::string("template_name"), template_name);
}

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

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

@@ -51,6 +51,8 @@ void DescribeLiveRecordConfigResult::parse(const std::string &payload)
liveAppRecordListObject.appName = valueLiveAppRecordListLiveAppRecord["AppName"].asString();
if(!valueLiveAppRecordListLiveAppRecord["StreamName"].isNull())
liveAppRecordListObject.streamName = valueLiveAppRecordListLiveAppRecord["StreamName"].asString();
if(!valueLiveAppRecordListLiveAppRecord["DelayTime"].isNull())
liveAppRecordListObject.delayTime = std::stoi(valueLiveAppRecordListLiveAppRecord["DelayTime"].asString());
if(!valueLiveAppRecordListLiveAppRecord["CreateTime"].isNull())
liveAppRecordListObject.createTime = valueLiveAppRecordListLiveAppRecord["CreateTime"].asString();
if(!valueLiveAppRecordListLiveAppRecord["OnDemond"].isNull())

4
live/src/model/DescribeLiveRecordVodConfigsResult.cc
View File

@@ -43,10 +43,14 @@ void DescribeLiveRecordVodConfigsResult::parse(const std::string &payload)
for (auto valueLiveRecordVodConfigsLiveRecordVodConfig : allLiveRecordVodConfigsNode)
{
LiveRecordVodConfig liveRecordVodConfigsObject;
if(!valueLiveRecordVodConfigsLiveRecordVodConfig["StorageLocation"].isNull())
liveRecordVodConfigsObject.storageLocation = valueLiveRecordVodConfigsLiveRecordVodConfig["StorageLocation"].asString();
if(!valueLiveRecordVodConfigsLiveRecordVodConfig["AppName"].isNull())
liveRecordVodConfigsObject.appName = valueLiveRecordVodConfigsLiveRecordVodConfig["AppName"].asString();
if(!valueLiveRecordVodConfigsLiveRecordVodConfig["AutoCompose"].isNull())
liveRecordVodConfigsObject.autoCompose = valueLiveRecordVodConfigsLiveRecordVodConfig["AutoCompose"].asString();
if(!valueLiveRecordVodConfigsLiveRecordVodConfig["OnDemand"].isNull())
liveRecordVodConfigsObject.onDemand = std::stoi(valueLiveRecordVodConfigsLiveRecordVodConfig["OnDemand"].asString());
if(!valueLiveRecordVodConfigsLiveRecordVodConfig["StreamName"].isNull())
liveRecordVodConfigsObject.streamName = valueLiveRecordVodConfigsLiveRecordVodConfig["StreamName"].asString();
if(!valueLiveRecordVodConfigsLiveRecordVodConfig["CreateTime"].isNull())

108
live/src/model/DescribeLiveStreamPreloadTasksRequest.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/DescribeLiveStreamPreloadTasksRequest.h>
using AlibabaCloud::Live::Model::DescribeLiveStreamPreloadTasksRequest;
DescribeLiveStreamPreloadTasksRequest::DescribeLiveStreamPreloadTasksRequest()
: RpcServiceRequest("live", "2016-11-01", "DescribeLiveStreamPreloadTasks") {
setMethod(HttpRequest::Method::Post);
}
DescribeLiveStreamPreloadTasksRequest::~DescribeLiveStreamPreloadTasksRequest() {}
std::string DescribeLiveStreamPreloadTasksRequest::getStartTime() const {
return startTime_;
}
void DescribeLiveStreamPreloadTasksRequest::setStartTime(const std::string &startTime) {
startTime_ = startTime;
setParameter(std::string("StartTime"), startTime);
}
int DescribeLiveStreamPreloadTasksRequest::getPageNum() const {
return pageNum_;
}
void DescribeLiveStreamPreloadTasksRequest::setPageNum(int pageNum) {
pageNum_ = pageNum;
setParameter(std::string("PageNum"), std::to_string(pageNum));
}
int DescribeLiveStreamPreloadTasksRequest::getPageSize() const {
return pageSize_;
}
void DescribeLiveStreamPreloadTasksRequest::setPageSize(int pageSize) {
pageSize_ = pageSize;
setParameter(std::string("PageSize"), std::to_string(pageSize));
}
std::string DescribeLiveStreamPreloadTasksRequest::getTaskId() const {
return taskId_;
}
void DescribeLiveStreamPreloadTasksRequest::setTaskId(const std::string &taskId) {
taskId_ = taskId;
setParameter(std::string("TaskId"), taskId);
}
std::string DescribeLiveStreamPreloadTasksRequest::getDomainName() const {
return domainName_;
}
void DescribeLiveStreamPreloadTasksRequest::setDomainName(const std::string &domainName) {
domainName_ = domainName;
setParameter(std::string("DomainName"), domainName);
}
std::string DescribeLiveStreamPreloadTasksRequest::getEndTime() const {
return endTime_;
}
void DescribeLiveStreamPreloadTasksRequest::setEndTime(const std::string &endTime) {
endTime_ = endTime;
setParameter(std::string("EndTime"), endTime);
}
long DescribeLiveStreamPreloadTasksRequest::getOwnerId() const {
return ownerId_;
}
void DescribeLiveStreamPreloadTasksRequest::setOwnerId(long ownerId) {
ownerId_ = ownerId;
setParameter(std::string("OwnerId"), std::to_string(ownerId));
}
std::string DescribeLiveStreamPreloadTasksRequest::getPlayUrl() const {
return playUrl_;
}
void DescribeLiveStreamPreloadTasksRequest::setPlayUrl(const std::string &playUrl) {
playUrl_ = playUrl;
setParameter(std::string("PlayUrl"), playUrl);
}
std::string DescribeLiveStreamPreloadTasksRequest::getStatus() const {
return status_;
}
void DescribeLiveStreamPreloadTasksRequest::setStatus(const std::string &status) {
status_ = status;
setParameter(std::string("Status"), status);
}

103
live/src/model/DescribeLiveStreamPreloadTasksResult.cc Normal file
View File

@@ -0,0 +1,103 @@
/*
* 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/DescribeLiveStreamPreloadTasksResult.h>
#include <json/json.h>
using namespace AlibabaCloud::Live;
using namespace AlibabaCloud::Live::Model;
DescribeLiveStreamPreloadTasksResult::DescribeLiveStreamPreloadTasksResult() :
ServiceResult()
{}
DescribeLiveStreamPreloadTasksResult::DescribeLiveStreamPreloadTasksResult(const std::string &payload) :
ServiceResult()
{
parse(payload);
}
DescribeLiveStreamPreloadTasksResult::~DescribeLiveStreamPreloadTasksResult()
{}
void DescribeLiveStreamPreloadTasksResult::parse(const std::string &payload)
{
Json::Reader reader;
Json::Value value;
reader.parse(payload, value);
setRequestId(value["RequestId"].asString());
auto allPreloadTasksNode = value["PreloadTasks"]["PreloadTask"];
for (auto valuePreloadTasksPreloadTask : allPreloadTasksNode)
{
PreloadTask preloadTasksObject;
if(!valuePreloadTasksPreloadTask["Status"].isNull())
preloadTasksObject.status = valuePreloadTasksPreloadTask["Status"].asString();
if(!valuePreloadTasksPreloadTask["Process"].isNull())
preloadTasksObject.process = valuePreloadTasksPreloadTask["Process"].asString();
if(!valuePreloadTasksPreloadTask["Description"].isNull())
preloadTasksObject.description = valuePreloadTasksPreloadTask["Description"].asString();
if(!valuePreloadTasksPreloadTask["CreateTime"].isNull())
preloadTasksObject.createTime = valuePreloadTasksPreloadTask["CreateTime"].asString();
if(!valuePreloadTasksPreloadTask["PreloadedEndTime"].isNull())
preloadTasksObject.preloadedEndTime = valuePreloadTasksPreloadTask["PreloadedEndTime"].asString();
if(!valuePreloadTasksPreloadTask["PreloadedStartTime"].isNull())
preloadTasksObject.preloadedStartTime = valuePreloadTasksPreloadTask["PreloadedStartTime"].asString();
if(!valuePreloadTasksPreloadTask["PlayUrl"].isNull())
preloadTasksObject.playUrl = valuePreloadTasksPreloadTask["PlayUrl"].asString();
if(!valuePreloadTasksPreloadTask["Area"].isNull())
preloadTasksObject.area = valuePreloadTasksPreloadTask["Area"].asString();
if(!valuePreloadTasksPreloadTask["TaskId"].isNull())
preloadTasksObject.taskId = valuePreloadTasksPreloadTask["TaskId"].asString();
if(!valuePreloadTasksPreloadTask["DomainName"].isNull())
preloadTasksObject.domainName = valuePreloadTasksPreloadTask["DomainName"].asString();
preloadTasks_.push_back(preloadTasksObject);
}
if(!value["TotalPage"].isNull())
totalPage_ = std::stoi(value["TotalPage"].asString());
if(!value["PageNum"].isNull())
pageNum_ = std::stoi(value["PageNum"].asString());
if(!value["PageSize"].isNull())
pageSize_ = std::stoi(value["PageSize"].asString());
if(!value["TotalNum"].isNull())
totalNum_ = std::stoi(value["TotalNum"].asString());
}
std::vector<DescribeLiveStreamPreloadTasksResult::PreloadTask> DescribeLiveStreamPreloadTasksResult::getPreloadTasks()const
{
return preloadTasks_;
}
int DescribeLiveStreamPreloadTasksResult::getTotalNum()const
{
return totalNum_;
}
int DescribeLiveStreamPreloadTasksResult::getTotalPage()const
{
return totalPage_;
}
int DescribeLiveStreamPreloadTasksResult::getPageNum()const
{
return pageNum_;
}
int DescribeLiveStreamPreloadTasksResult::getPageSize()const
{
return pageSize_;
}

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

@@ -25,6 +25,15 @@ DescribeLiveStreamTranscodeInfoRequest::DescribeLiveStreamTranscodeInfoRequest()
DescribeLiveStreamTranscodeInfoRequest::~DescribeLiveStreamTranscodeInfoRequest() {}
std::string DescribeLiveStreamTranscodeInfoRequest::getAppName() const {
return appName_;
}
void DescribeLiveStreamTranscodeInfoRequest::setAppName(const std::string &appName) {
appName_ = appName;
setParameter(std::string("AppName"), appName);
}
long DescribeLiveStreamTranscodeInfoRequest::getOwnerId() const {
return ownerId_;
}

20
live/src/model/DescribeLiveStreamTranscodeInfoResult.cc
View File

@@ -52,34 +52,42 @@ void DescribeLiveStreamTranscodeInfoResult::parse(const std::string &payload)
if(!valueDomainTranscodeListDomainTranscodeInfo["TranscodeName"].isNull())
domainTranscodeListObject.transcodeName = valueDomainTranscodeListDomainTranscodeInfo["TranscodeName"].asString();
auto customTranscodeParametersNode = value["CustomTranscodeParameters"];
if(!customTranscodeParametersNode["BitrateWithSource"].isNull())
domainTranscodeListObject.customTranscodeParameters.bitrateWithSource = customTranscodeParametersNode["BitrateWithSource"].asString();
if(!customTranscodeParametersNode["VideoProfile"].isNull())
domainTranscodeListObject.customTranscodeParameters.videoProfile = customTranscodeParametersNode["VideoProfile"].asString();
if(!customTranscodeParametersNode["AudioBitrate"].isNull())
domainTranscodeListObject.customTranscodeParameters.audioBitrate = std::stoi(customTranscodeParametersNode["AudioBitrate"].asString());
if(!customTranscodeParametersNode["RtsFlag"].isNull())
domainTranscodeListObject.customTranscodeParameters.rtsFlag = customTranscodeParametersNode["RtsFlag"].asString();
if(!customTranscodeParametersNode["Height"].isNull())
domainTranscodeListObject.customTranscodeParameters.height = std::stoi(customTranscodeParametersNode["Height"].asString());
if(!customTranscodeParametersNode["RtsFlag"].isNull())
domainTranscodeListObject.customTranscodeParameters.rtsFlag = customTranscodeParametersNode["RtsFlag"].asString();
if(!customTranscodeParametersNode["TemplateType"].isNull())
domainTranscodeListObject.customTranscodeParameters.templateType = customTranscodeParametersNode["TemplateType"].asString();
if(!customTranscodeParametersNode["Bframes"].isNull())
domainTranscodeListObject.customTranscodeParameters.bframes = customTranscodeParametersNode["Bframes"].asString();
if(!customTranscodeParametersNode["ExtWithSource"].isNull())
domainTranscodeListObject.customTranscodeParameters.extWithSource = customTranscodeParametersNode["ExtWithSource"].asString();
if(!customTranscodeParametersNode["AudioRate"].isNull())
domainTranscodeListObject.customTranscodeParameters.audioRate = std::stoi(customTranscodeParametersNode["AudioRate"].asString());
if(!customTranscodeParametersNode["FPS"].isNull())
domainTranscodeListObject.customTranscodeParameters.fPS = std::stoi(customTranscodeParametersNode["FPS"].asString());
if(!customTranscodeParametersNode["FpsWithSource"].isNull())
domainTranscodeListObject.customTranscodeParameters.fpsWithSource = customTranscodeParametersNode["FpsWithSource"].asString();
if(!customTranscodeParametersNode["AudioCodec"].isNull())
domainTranscodeListObject.customTranscodeParameters.audioCodec = customTranscodeParametersNode["AudioCodec"].asString();
if(!customTranscodeParametersNode["FPS"].isNull())
domainTranscodeListObject.customTranscodeParameters.fPS = std::stoi(customTranscodeParametersNode["FPS"].asString());
if(!customTranscodeParametersNode["Gop"].isNull())
domainTranscodeListObject.customTranscodeParameters.gop = customTranscodeParametersNode["Gop"].asString();
if(!customTranscodeParametersNode["VideoBitrate"].isNull())
domainTranscodeListObject.customTranscodeParameters.videoBitrate = std::stoi(customTranscodeParametersNode["VideoBitrate"].asString());
if(!customTranscodeParametersNode["Width"].isNull())
domainTranscodeListObject.customTranscodeParameters.width = std::stoi(customTranscodeParametersNode["Width"].asString());
if(!customTranscodeParametersNode["VideoBitrate"].isNull())
domainTranscodeListObject.customTranscodeParameters.videoBitrate = std::stoi(customTranscodeParametersNode["VideoBitrate"].asString());
if(!customTranscodeParametersNode["AudioChannelNum"].isNull())
domainTranscodeListObject.customTranscodeParameters.audioChannelNum = std::stoi(customTranscodeParametersNode["AudioChannelNum"].asString());
if(!customTranscodeParametersNode["AudioProfile"].isNull())
domainTranscodeListObject.customTranscodeParameters.audioProfile = customTranscodeParametersNode["AudioProfile"].asString();
if(!customTranscodeParametersNode["ResWithSource"].isNull())
domainTranscodeListObject.customTranscodeParameters.resWithSource = customTranscodeParametersNode["ResWithSource"].asString();
auto encryptParametersNode = value["EncryptParameters"];
if(!encryptParametersNode["EncryptType"].isNull())
domainTranscodeListObject.encryptParameters.encryptType = encryptParametersNode["EncryptType"].asString();

90
live/src/model/DescribeStreamLocationBlockRequest.cc Normal file
View File

@@ -0,0 +1,90 @@
/*
* 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/DescribeStreamLocationBlockRequest.h>
using AlibabaCloud::Live::Model::DescribeStreamLocationBlockRequest;
DescribeStreamLocationBlockRequest::DescribeStreamLocationBlockRequest()
: RpcServiceRequest("live", "2016-11-01", "DescribeStreamLocationBlock") {
setMethod(HttpRequest::Method::Post);
}
DescribeStreamLocationBlockRequest::~DescribeStreamLocationBlockRequest() {}
std::string DescribeStreamLocationBlockRequest::getBlockType() const {
return blockType_;
}
void DescribeStreamLocationBlockRequest::setBlockType(const std::string &blockType) {
blockType_ = blockType;
setParameter(std::string("BlockType"), blockType);
}
int DescribeStreamLocationBlockRequest::getPageNum() const {
return pageNum_;
}
void DescribeStreamLocationBlockRequest::setPageNum(int pageNum) {
pageNum_ = pageNum;
setParameter(std::string("PageNum"), std::to_string(pageNum));
}
std::string DescribeStreamLocationBlockRequest::getAppName() const {
return appName_;
}
void DescribeStreamLocationBlockRequest::setAppName(const std::string &appName) {
appName_ = appName;
setParameter(std::string("AppName"), appName);
}
int DescribeStreamLocationBlockRequest::getPageSize() const {
return pageSize_;
}
void DescribeStreamLocationBlockRequest::setPageSize(int pageSize) {
pageSize_ = pageSize;
setParameter(std::string("PageSize"), std::to_string(pageSize));
}
std::string DescribeStreamLocationBlockRequest::getStreamName() const {
return streamName_;
}
void DescribeStreamLocationBlockRequest::setStreamName(const std::string &streamName) {
streamName_ = streamName;
setParameter(std::string("StreamName"), streamName);
}
std::string DescribeStreamLocationBlockRequest::getDomainName() const {
return domainName_;
}
void DescribeStreamLocationBlockRequest::setDomainName(const std::string &domainName) {
domainName_ = domainName;
setParameter(std::string("DomainName"), domainName);
}
long DescribeStreamLocationBlockRequest::getOwnerId() const {
return ownerId_;
}
void DescribeStreamLocationBlockRequest::setOwnerId(long ownerId) {
ownerId_ = ownerId;
setParameter(std::string("OwnerId"), std::to_string(ownerId));
}

99
live/src/model/DescribeStreamLocationBlockResult.cc Normal file
View File

@@ -0,0 +1,99 @@
/*
* 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/DescribeStreamLocationBlockResult.h>
#include <json/json.h>
using namespace AlibabaCloud::Live;
using namespace AlibabaCloud::Live::Model;
DescribeStreamLocationBlockResult::DescribeStreamLocationBlockResult() :
ServiceResult()
{}
DescribeStreamLocationBlockResult::DescribeStreamLocationBlockResult(const std::string &payload) :
ServiceResult()
{
parse(payload);
}
DescribeStreamLocationBlockResult::~DescribeStreamLocationBlockResult()
{}
void DescribeStreamLocationBlockResult::parse(const std::string &payload)
{
Json::Reader reader;
Json::Value value;
reader.parse(payload, value);
setRequestId(value["RequestId"].asString());
auto allStreamBlockListNode = value["StreamBlockList"]["StreamBlock"];
for (auto valueStreamBlockListStreamBlock : allStreamBlockListNode)
{
StreamBlock streamBlockListObject;
if(!valueStreamBlockListStreamBlock["Status"].isNull())
streamBlockListObject.status = std::stoi(valueStreamBlockListStreamBlock["Status"].asString());
if(!valueStreamBlockListStreamBlock["BlockType"].isNull())
streamBlockListObject.blockType = valueStreamBlockListStreamBlock["BlockType"].asString();
if(!valueStreamBlockListStreamBlock["AppName"].isNull())
streamBlockListObject.appName = valueStreamBlockListStreamBlock["AppName"].asString();
if(!valueStreamBlockListStreamBlock["UpdateTime"].isNull())
streamBlockListObject.updateTime = valueStreamBlockListStreamBlock["UpdateTime"].asString();
if(!valueStreamBlockListStreamBlock["StreamName"].isNull())
streamBlockListObject.streamName = valueStreamBlockListStreamBlock["StreamName"].asString();
if(!valueStreamBlockListStreamBlock["ReleaseTime"].isNull())
streamBlockListObject.releaseTime = valueStreamBlockListStreamBlock["ReleaseTime"].asString();
if(!valueStreamBlockListStreamBlock["LocationList"].isNull())
streamBlockListObject.locationList = valueStreamBlockListStreamBlock["LocationList"].asString();
if(!valueStreamBlockListStreamBlock["DomainName"].isNull())
streamBlockListObject.domainName = valueStreamBlockListStreamBlock["DomainName"].asString();
streamBlockList_.push_back(streamBlockListObject);
}
if(!value["TotalPage"].isNull())
totalPage_ = std::stoi(value["TotalPage"].asString());
if(!value["PageNum"].isNull())
pageNum_ = std::stoi(value["PageNum"].asString());
if(!value["PageSize"].isNull())
pageSize_ = std::stoi(value["PageSize"].asString());
if(!value["Count"].isNull())
count_ = std::stoi(value["Count"].asString());
}
int DescribeStreamLocationBlockResult::getTotalPage()const
{
return totalPage_;
}
int DescribeStreamLocationBlockResult::getPageNum()const
{
return pageNum_;
}
int DescribeStreamLocationBlockResult::getPageSize()const
{
return pageSize_;
}
std::vector<DescribeStreamLocationBlockResult::StreamBlock> DescribeStreamLocationBlockResult::getStreamBlockList()const
{
return streamBlockList_;
}
int DescribeStreamLocationBlockResult::getCount()const
{
return count_;
}

90
live/src/model/SetLiveStreamBlockRequest.cc Normal file
View File

@@ -0,0 +1,90 @@
/*
* 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/SetLiveStreamBlockRequest.h>
using AlibabaCloud::Live::Model::SetLiveStreamBlockRequest;
SetLiveStreamBlockRequest::SetLiveStreamBlockRequest()
: RpcServiceRequest("live", "2016-11-01", "SetLiveStreamBlock") {
setMethod(HttpRequest::Method::Post);
}
SetLiveStreamBlockRequest::~SetLiveStreamBlockRequest() {}
std::string SetLiveStreamBlockRequest::getLocationList() const {
return locationList_;
}
void SetLiveStreamBlockRequest::setLocationList(const std::string &locationList) {
locationList_ = locationList;
setParameter(std::string("LocationList"), locationList);
}
std::string SetLiveStreamBlockRequest::getBlockType() const {
return blockType_;
}
void SetLiveStreamBlockRequest::setBlockType(const std::string &blockType) {
blockType_ = blockType;
setParameter(std::string("BlockType"), blockType);
}
std::string SetLiveStreamBlockRequest::getReleaseTime() const {
return releaseTime_;
}
void SetLiveStreamBlockRequest::setReleaseTime(const std::string &releaseTime) {
releaseTime_ = releaseTime;
setParameter(std::string("ReleaseTime"), releaseTime);
}
std::string SetLiveStreamBlockRequest::getAppName() const {
return appName_;
}
void SetLiveStreamBlockRequest::setAppName(const std::string &appName) {
appName_ = appName;
setParameter(std::string("AppName"), appName);
}
std::string SetLiveStreamBlockRequest::getStreamName() const {
return streamName_;
}
void SetLiveStreamBlockRequest::setStreamName(const std::string &streamName) {
streamName_ = streamName;
setParameter(std::string("StreamName"), streamName);
}
std::string SetLiveStreamBlockRequest::getDomainName() const {
return domainName_;
}
void SetLiveStreamBlockRequest::setDomainName(const std::string &domainName) {
domainName_ = domainName;
setParameter(std::string("DomainName"), domainName);
}
long SetLiveStreamBlockRequest::getOwnerId() const {
return ownerId_;
}
void SetLiveStreamBlockRequest::setOwnerId(long ownerId) {
ownerId_ = ownerId;
setParameter(std::string("OwnerId"), std::to_string(ownerId));
}

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

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

81
live/src/model/SetLiveStreamPreloadTasksRequest.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/SetLiveStreamPreloadTasksRequest.h>
using AlibabaCloud::Live::Model::SetLiveStreamPreloadTasksRequest;
SetLiveStreamPreloadTasksRequest::SetLiveStreamPreloadTasksRequest()
: RpcServiceRequest("live", "2016-11-01", "SetLiveStreamPreloadTasks") {
setMethod(HttpRequest::Method::Post);
}
SetLiveStreamPreloadTasksRequest::~SetLiveStreamPreloadTasksRequest() {}
std::string SetLiveStreamPreloadTasksRequest::getPreloadedStartTime() const {
return preloadedStartTime_;
}
void SetLiveStreamPreloadTasksRequest::setPreloadedStartTime(const std::string &preloadedStartTime) {
preloadedStartTime_ = preloadedStartTime;
setParameter(std::string("PreloadedStartTime"), preloadedStartTime);
}
std::string SetLiveStreamPreloadTasksRequest::getArea() const {
return area_;
}
void SetLiveStreamPreloadTasksRequest::setArea(const std::string &area) {
area_ = area;
setParameter(std::string("Area"), area);
}
std::string SetLiveStreamPreloadTasksRequest::getPreloadedEndTime() const {
return preloadedEndTime_;
}
void SetLiveStreamPreloadTasksRequest::setPreloadedEndTime(const std::string &preloadedEndTime) {
preloadedEndTime_ = preloadedEndTime;
setParameter(std::string("PreloadedEndTime"), preloadedEndTime);
}
std::string SetLiveStreamPreloadTasksRequest::getDomainName() const {
return domainName_;
}
void SetLiveStreamPreloadTasksRequest::setDomainName(const std::string &domainName) {
domainName_ = domainName;
setParameter(std::string("DomainName"), domainName);
}
long SetLiveStreamPreloadTasksRequest::getOwnerId() const {
return ownerId_;
}
void SetLiveStreamPreloadTasksRequest::setOwnerId(long ownerId) {
ownerId_ = ownerId;
setParameter(std::string("OwnerId"), std::to_string(ownerId));
}
std::string SetLiveStreamPreloadTasksRequest::getPlayUrl() const {
return playUrl_;
}
void SetLiveStreamPreloadTasksRequest::setPlayUrl(const std::string &playUrl) {
playUrl_ = playUrl;
setParameter(std::string("PlayUrl"), playUrl);
}

89
live/src/model/SetLiveStreamPreloadTasksResult.cc Normal file
View File

@@ -0,0 +1,89 @@
/*
* 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/SetLiveStreamPreloadTasksResult.h>
#include <json/json.h>
using namespace AlibabaCloud::Live;
using namespace AlibabaCloud::Live::Model;
SetLiveStreamPreloadTasksResult::SetLiveStreamPreloadTasksResult() :
ServiceResult()
{}
SetLiveStreamPreloadTasksResult::SetLiveStreamPreloadTasksResult(const std::string &payload) :
ServiceResult()
{
parse(payload);
}
SetLiveStreamPreloadTasksResult::~SetLiveStreamPreloadTasksResult()
{}
void SetLiveStreamPreloadTasksResult::parse(const std::string &payload)
{
Json::Reader reader;
Json::Value value;
reader.parse(payload, value);
setRequestId(value["RequestId"].asString());
auto allPreloadTasksMessagesNode = value["PreloadTasksMessages"]["PreloadTasksMessage"];
for (auto valuePreloadTasksMessagesPreloadTasksMessage : allPreloadTasksMessagesNode)
{
PreloadTasksMessage preloadTasksMessagesObject;
if(!valuePreloadTasksMessagesPreloadTasksMessage["PlayUrl"].isNull())
preloadTasksMessagesObject.playUrl = valuePreloadTasksMessagesPreloadTasksMessage["PlayUrl"].asString();
if(!valuePreloadTasksMessagesPreloadTasksMessage["Description"].isNull())
preloadTasksMessagesObject.description = valuePreloadTasksMessagesPreloadTasksMessage["Description"].asString();
if(!valuePreloadTasksMessagesPreloadTasksMessage["TaskId"].isNull())
preloadTasksMessagesObject.taskId = valuePreloadTasksMessagesPreloadTasksMessage["TaskId"].asString();
preloadTasksMessages_.push_back(preloadTasksMessagesObject);
}
if(!value["Status"].isNull())
status_ = value["Status"].asString();
if(!value["FailedURL"].isNull())
failedURL_ = std::stoi(value["FailedURL"].asString());
if(!value["TotalURL"].isNull())
totalURL_ = std::stoi(value["TotalURL"].asString());
if(!value["SuccessURL"].isNull())
successURL_ = std::stoi(value["SuccessURL"].asString());
}
std::string SetLiveStreamPreloadTasksResult::getStatus()const
{
return status_;
}
int SetLiveStreamPreloadTasksResult::getFailedURL()const
{
return failedURL_;
}
std::vector<SetLiveStreamPreloadTasksResult::PreloadTasksMessage> SetLiveStreamPreloadTasksResult::getPreloadTasksMessages()const
{
return preloadTasksMessages_;
}
int SetLiveStreamPreloadTasksResult::getTotalURL()const
{
return totalURL_;
}
int SetLiveStreamPreloadTasksResult::getSuccessURL()const
{
return successURL_;
}

155
live/src/model/UpdateLiveAppRecordConfigRequest.cc Normal file
View File

@@ -0,0 +1,155 @@
/*
* 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/UpdateLiveAppRecordConfigRequest.h>
using AlibabaCloud::Live::Model::UpdateLiveAppRecordConfigRequest;
UpdateLiveAppRecordConfigRequest::UpdateLiveAppRecordConfigRequest()
: RpcServiceRequest("live", "2016-11-01", "UpdateLiveAppRecordConfig") {
setMethod(HttpRequest::Method::Post);
}
UpdateLiveAppRecordConfigRequest::~UpdateLiveAppRecordConfigRequest() {}
std::string UpdateLiveAppRecordConfigRequest::getOssEndpoint() const {
return ossEndpoint_;
}
void UpdateLiveAppRecordConfigRequest::setOssEndpoint(const std::string &ossEndpoint) {
ossEndpoint_ = ossEndpoint;
setParameter(std::string("OssEndpoint"), ossEndpoint);
}
int UpdateLiveAppRecordConfigRequest::getDelayTime() const {
return delayTime_;
}
void UpdateLiveAppRecordConfigRequest::setDelayTime(int delayTime) {
delayTime_ = delayTime;
setParameter(std::string("DelayTime"), std::to_string(delayTime));
}
std::vector<std::string> UpdateLiveAppRecordConfigRequest::getTranscodeTemplates() const {
return transcodeTemplates_;
}
void UpdateLiveAppRecordConfigRequest::setTranscodeTemplates(const std::vector<std::string> &transcodeTemplates) {
transcodeTemplates_ = transcodeTemplates;
}
std::string UpdateLiveAppRecordConfigRequest::getStartTime() const {
return startTime_;
}
void UpdateLiveAppRecordConfigRequest::setStartTime(const std::string &startTime) {
startTime_ = startTime;
setParameter(std::string("StartTime"), startTime);
}
std::string UpdateLiveAppRecordConfigRequest::getAppName() const {
return appName_;
}
void UpdateLiveAppRecordConfigRequest::setAppName(const std::string &appName) {
appName_ = appName;
setParameter(std::string("AppName"), appName);
}
std::string UpdateLiveAppRecordConfigRequest::getSecurityToken() const {
return securityToken_;
}
void UpdateLiveAppRecordConfigRequest::setSecurityToken(const std::string &securityToken) {
securityToken_ = securityToken;
setParameter(std::string("SecurityToken"), securityToken);
}
std::vector<UpdateLiveAppRecordConfigRequest::TranscodeRecordFormat> UpdateLiveAppRecordConfigRequest::getTranscodeRecordFormat() const {
return transcodeRecordFormat_;
}
void UpdateLiveAppRecordConfigRequest::setTranscodeRecordFormat(const std::vector<UpdateLiveAppRecordConfigRequest::TranscodeRecordFormat> &transcodeRecordFormat) {
transcodeRecordFormat_ = transcodeRecordFormat;
for(int dep1 = 0; dep1 != transcodeRecordFormat.size(); dep1++) {
auto transcodeRecordFormatObj = transcodeRecordFormat.at(dep1);
std::string transcodeRecordFormatObjStr = std::string("TranscodeRecordFormat") + "." + std::to_string(dep1 + 1);
setParameter(transcodeRecordFormatObjStr + ".SliceDuration", std::to_string(transcodeRecordFormatObj.sliceDuration));
setParameter(transcodeRecordFormatObjStr + ".Format", transcodeRecordFormatObj.format);
setParameter(transcodeRecordFormatObjStr + ".CycleDuration", std::to_string(transcodeRecordFormatObj.cycleDuration));
}
}
int UpdateLiveAppRecordConfigRequest::getOnDemand() const {
return onDemand_;
}
void UpdateLiveAppRecordConfigRequest::setOnDemand(int onDemand) {
onDemand_ = onDemand;
setParameter(std::string("OnDemand"), std::to_string(onDemand));
}
std::string UpdateLiveAppRecordConfigRequest::getStreamName() const {
return streamName_;
}
void UpdateLiveAppRecordConfigRequest::setStreamName(const std::string &streamName) {
streamName_ = streamName;
setParameter(std::string("StreamName"), streamName);
}
std::string UpdateLiveAppRecordConfigRequest::getDomainName() const {
return domainName_;
}
void UpdateLiveAppRecordConfigRequest::setDomainName(const std::string &domainName) {
domainName_ = domainName;
setParameter(std::string("DomainName"), domainName);
}
std::string UpdateLiveAppRecordConfigRequest::getEndTime() const {
return endTime_;
}
void UpdateLiveAppRecordConfigRequest::setEndTime(const std::string &endTime) {
endTime_ = endTime;
setParameter(std::string("EndTime"), endTime);
}
long UpdateLiveAppRecordConfigRequest::getOwnerId() const {
return ownerId_;
}
void UpdateLiveAppRecordConfigRequest::setOwnerId(long ownerId) {
ownerId_ = ownerId;
setParameter(std::string("OwnerId"), std::to_string(ownerId));
}
std::vector<UpdateLiveAppRecordConfigRequest::RecordFormat> UpdateLiveAppRecordConfigRequest::getRecordFormat() const {
return recordFormat_;
}
void UpdateLiveAppRecordConfigRequest::setRecordFormat(const std::vector<UpdateLiveAppRecordConfigRequest::RecordFormat> &recordFormat) {
recordFormat_ = recordFormat;
for(int dep1 = 0; dep1 != recordFormat.size(); dep1++) {
auto recordFormatObj = recordFormat.at(dep1);
std::string recordFormatObjStr = std::string("RecordFormat") + "." + std::to_string(dep1 + 1);
setParameter(recordFormatObjStr + ".SliceDuration", std::to_string(recordFormatObj.sliceDuration));
setParameter(recordFormatObjStr + ".Format", recordFormatObj.format);
setParameter(recordFormatObjStr + ".CycleDuration", std::to_string(recordFormatObj.cycleDuration));
}
}

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

117
live/src/model/UpdateLiveRecordVodConfigRequest.cc Normal file
View File

@@ -0,0 +1,117 @@
/*
* 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/UpdateLiveRecordVodConfigRequest.h>
using AlibabaCloud::Live::Model::UpdateLiveRecordVodConfigRequest;
UpdateLiveRecordVodConfigRequest::UpdateLiveRecordVodConfigRequest()
: RpcServiceRequest("live", "2016-11-01", "UpdateLiveRecordVodConfig") {
setMethod(HttpRequest::Method::Post);
}
UpdateLiveRecordVodConfigRequest::~UpdateLiveRecordVodConfigRequest() {}
std::string UpdateLiveRecordVodConfigRequest::getAutoCompose() const {
return autoCompose_;
}
void UpdateLiveRecordVodConfigRequest::setAutoCompose(const std::string &autoCompose) {
autoCompose_ = autoCompose;
setParameter(std::string("AutoCompose"), autoCompose);
}
std::string UpdateLiveRecordVodConfigRequest::getComposeVodTranscodeGroupId() const {
return composeVodTranscodeGroupId_;
}
void UpdateLiveRecordVodConfigRequest::setComposeVodTranscodeGroupId(const std::string &composeVodTranscodeGroupId) {
composeVodTranscodeGroupId_ = composeVodTranscodeGroupId;
setParameter(std::string("ComposeVodTranscodeGroupId"), composeVodTranscodeGroupId);
}
std::string UpdateLiveRecordVodConfigRequest::getStorageLocation() const {
return storageLocation_;
}
void UpdateLiveRecordVodConfigRequest::setStorageLocation(const std::string &storageLocation) {
storageLocation_ = storageLocation;
setParameter(std::string("StorageLocation"), storageLocation);
}
std::string UpdateLiveRecordVodConfigRequest::getAppName() const {
return appName_;
}
void UpdateLiveRecordVodConfigRequest::setAppName(const std::string &appName) {
appName_ = appName;
setParameter(std::string("AppName"), appName);
}
int UpdateLiveRecordVodConfigRequest::getOnDemand() const {
return onDemand_;
}
void UpdateLiveRecordVodConfigRequest::setOnDemand(int onDemand) {
onDemand_ = onDemand;
setParameter(std::string("OnDemand"), std::to_string(onDemand));
}
std::string UpdateLiveRecordVodConfigRequest::getStreamName() const {
return streamName_;
}
void UpdateLiveRecordVodConfigRequest::setStreamName(const std::string &streamName) {
streamName_ = streamName;
setParameter(std::string("StreamName"), streamName);
}
std::string UpdateLiveRecordVodConfigRequest::getVodTranscodeGroupId() const {
return vodTranscodeGroupId_;
}
void UpdateLiveRecordVodConfigRequest::setVodTranscodeGroupId(const std::string &vodTranscodeGroupId) {
vodTranscodeGroupId_ = vodTranscodeGroupId;
setParameter(std::string("VodTranscodeGroupId"), vodTranscodeGroupId);
}
std::string UpdateLiveRecordVodConfigRequest::getDomainName() const {
return domainName_;
}
void UpdateLiveRecordVodConfigRequest::setDomainName(const std::string &domainName) {
domainName_ = domainName;
setParameter(std::string("DomainName"), domainName);
}
int UpdateLiveRecordVodConfigRequest::getCycleDuration() const {
return cycleDuration_;
}
void UpdateLiveRecordVodConfigRequest::setCycleDuration(int cycleDuration) {
cycleDuration_ = cycleDuration;
setParameter(std::string("CycleDuration"), std::to_string(cycleDuration));
}
long UpdateLiveRecordVodConfigRequest::getOwnerId() const {
return ownerId_;
}
void UpdateLiveRecordVodConfigRequest::setOwnerId(long ownerId) {
ownerId_ = ownerId;
setParameter(std::string("OwnerId"), std::to_string(ownerId));
}

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