-
import { forkJoin } from 'rxjs'
-import { AfterViewChecked, AfterViewInit, Component, EventEmitter, OnInit, Output } from '@angular/core'
+import { AfterViewInit, Component, EventEmitter, OnInit, Output } from '@angular/core'
import { Router } from '@angular/router'
import { AuthService, CanComponentDeactivate, HooksService, Notifier, ServerService } from '@app/core'
import { scrollToTop } from '@app/helpers'
import { FormValidatorService } from '@app/shared/shared-forms'
-import { VideoCaptionService, VideoEdit, VideoService } from '@app/shared/shared-main'
+import { Video, VideoCaptionService, VideoEdit, VideoService } from '@app/shared/shared-main'
import { LiveVideoService } from '@app/shared/shared-video-live'
import { LoadingBarService } from '@ngx-loading-bar/core'
-import { LiveVideo, LiveVideoCreate, LiveVideoUpdate, ServerErrorCode, VideoPrivacy } from '@shared/models'
+import { LiveVideo, LiveVideoCreate, LiveVideoLatencyMode, LiveVideoUpdate, PeerTubeProblemDocument, ServerErrorCode } from '@shared/models'
import { VideoSend } from './video-send'
@Component({
templateUrl: './video-go-live.component.html',
styleUrls: [
'../shared/video-edit.component.scss',
+ './video-go-live.component.scss',
'./video-send.scss'
]
})
@Output() firstStepDone = new EventEmitter<string>()
@Output() firstStepError = new EventEmitter<void>()
+ firstStepPermanentLive: boolean
+
isInUpdateForm = false
liveVideo: LiveVideo
+
videoId: number
videoUUID: string
- error: string
+ videoShortUUID: string
- protected readonly DEFAULT_VIDEO_PRIVACY = VideoPrivacy.PUBLIC
+ error: string
constructor (
protected formValidatorService: FormValidatorService,
private liveVideoService: LiveVideoService,
private router: Router,
private hooks: HooksService
- ) {
+ ) {
super()
}
const video: LiveVideoCreate = {
name,
- privacy: VideoPrivacy.PRIVATE,
+ privacy: this.highestPrivacy,
nsfw: this.serverConfig.instance.isNSFW,
waitTranscoding: true,
- commentsEnabled: true,
- downloadEnabled: true,
+ permanentLive: this.firstStepPermanentLive,
+ latencyMode: LiveVideoLatencyMode.DEFAULT,
+ saveReplay: this.isReplayAllowed(),
channelId: this.firstStepChannelId
}
// Go live in private mode, but correctly fill the update form with the first user choice
- const toPatch = Object.assign({}, video, { privacy: this.firstStepPrivacyId })
+ const toPatch = { ...video, privacy: this.firstStepPrivacyId }
this.form.patchValue(toPatch)
- this.liveVideoService.goLive(video).subscribe(
- res => {
- this.videoId = res.video.id
- this.videoUUID = res.video.uuid
- this.isInUpdateForm = true
+ this.liveVideoService.goLive(video)
+ .subscribe({
+ next: res => {
+ this.videoId = res.video.id
+ this.videoUUID = res.video.uuid
+ this.videoShortUUID = res.video.shortUUID
+ this.isInUpdateForm = true
- this.firstStepDone.emit(name)
+ this.firstStepDone.emit(name)
- this.fetchVideoLive()
- },
+ this.fetchVideoLive()
+ },
- err => {
- this.firstStepError.emit()
+ error: err => {
+ this.firstStepError.emit()
- let message = err.message
+ let message = err.message
- if (err.body?.code === ServerErrorCode.MAX_INSTANCE_LIVES_LIMIT_REACHED) {
- message = $localize`Cannot create live because this instance have too many created lives`
- } else if (err.body?.code) {
- message = $localize`Cannot create live because you created too many lives`
- }
+ const error = err.body as PeerTubeProblemDocument
- this.notifier.error(message)
- }
- )
+ if (error?.code === ServerErrorCode.MAX_INSTANCE_LIVES_LIMIT_REACHED) {
+ message = $localize`Cannot create live because this instance have too many created lives`
+ } else if (error?.code === ServerErrorCode.MAX_USER_LIVES_LIMIT_REACHED) {
+ message = $localize`Cannot create live because you created too many lives`
+ }
+
+ this.notifier.error(message)
+ }
+ })
}
- updateSecondStep () {
- if (this.checkForm() === false) {
- return
- }
+ async updateSecondStep () {
+ if (!await this.isFormValid()) return
const video = new VideoEdit()
video.patch(this.form.value)
video.id = this.videoId
video.uuid = this.videoUUID
+ video.shortUUID = this.videoShortUUID
const liveVideoUpdate: LiveVideoUpdate = {
saveReplay: this.form.value.saveReplay,
+ latencyMode: this.form.value.latencyMode,
permanentLive: this.form.value.permanentLive
}
this.updateVideoAndCaptions(video),
this.liveVideoService.updateLive(this.videoId, liveVideoUpdate)
- ]).subscribe(
- () => {
+ ]).subscribe({
+ next: () => {
this.notifier.success($localize`Live published.`)
- this.router.navigate(['/videos/watch', video.uuid])
+ this.router.navigateByUrl(Video.buildWatchUrl(video))
},
- err => {
+ error: err => {
this.error = err.message
scrollToTop()
console.error(err)
}
- )
+ })
}
getMaxLiveDuration () {
return this.form.value['saveReplay'] === true
}
+ getNormalLiveDescription () {
+ if (this.isReplayAllowed()) {
+ return $localize`Stream only once, replay will replace your live`
+ }
+
+ return $localize`Stream only once`
+ }
+
+ getPermanentLiveDescription () {
+ if (this.isReplayAllowed()) {
+ return $localize`Stream multiple times, replays will be separate videos`
+ }
+
+ return $localize`Stream multiple times using the same URL`
+ }
+
+ private isReplayAllowed () {
+ return this.serverConfig.live.allowReplay
+ }
+
private fetchVideoLive () {
this.liveVideoService.getVideoLive(this.videoId)
- .subscribe(
- liveVideo => {
+ .subscribe({
+ next: liveVideo => {
this.liveVideo = liveVideo
},
- err => {
+ error: err => {
this.firstStepError.emit()
this.notifier.error(err.message)
}
- )
+ })
}
}