// Lists broadcasts belonging to authenticated user
        public async Task <IList <LiveBroadcast> > listBroadcast()
        {
            youtube = new YouTubeService(await youtubeAuthen.GetInitializer());

            LiveBroadcastsResource.ListRequest broadcastRequest = youtube.LiveBroadcasts.List("id,snippet");
            broadcastRequest.Mine = true;

            LiveBroadcastListResponse broadcastResponse = broadcastRequest.Execute();

            IList <LiveBroadcast> broadcastList = broadcastResponse.Items;

            return(broadcastList);
        }
        /// <summary>
        /// Gets the currently active broadcast associated with the currently authenticated account.
        /// </summary>
        /// <returns>The current live broadcasts</returns>
        public async Task <LiveBroadcast> GetActiveBroadcast()
        {
            return(await this.YouTubeServiceWrapper(async() =>
            {
                LiveBroadcastsResource.ListRequest request = this.connection.GoogleYouTubeService.LiveBroadcasts.List("snippet,contentDetails,status");
                request.BroadcastType = BroadcastTypeEnum.All;
                request.Mine = true;
                request.MaxResults = 10;

                LiveBroadcastListResponse response = await request.ExecuteAsync();
                return response.Items.FirstOrDefault(b => string.Equals(b.Status.LifeCycleStatus, "live"));
            }));
        }
        /// <summary>
        /// Gets the broadcast associated with the specified ID.
        /// </summary>
        /// <returns>The live broadcast</returns>
        public async Task <LiveBroadcast> GetBroadcastByID(string id)
        {
            return(await this.YouTubeServiceWrapper(async() =>
            {
                LiveBroadcastsResource.ListRequest request = this.connection.GoogleYouTubeService.LiveBroadcasts.List("snippet,contentDetails,status");
                request.BroadcastType = BroadcastTypeEnum.All;
                request.Id = id;
                request.MaxResults = 10;
                LogRequest(request);

                LiveBroadcastListResponse response = await request.ExecuteAsync();
                LogResponse(request, response);
                return response.Items.FirstOrDefault();
            }));
        }
        /// <summary>
        /// Gets the broadcasts associated with the currently authenticated account.
        /// </summary>
        /// <param name="maxResults">The maximum results to return</param>
        /// <returns>The list of live broadcasts</returns>
        public async Task <IEnumerable <LiveBroadcast> > GetMyBroadcasts(int maxResults = 1)
        {
            return(await this.YouTubeServiceWrapper(async() =>
            {
                LiveBroadcastsResource.ListRequest request = this.connection.GoogleYouTubeService.LiveBroadcasts.List("snippet,contentDetails,status");
                request.BroadcastType = BroadcastTypeEnum.All;
                request.Mine = true;
                request.MaxResults = maxResults;

                LiveBroadcastListResponse response = await request.ExecuteAsync();
                if (response.Items.Count > 0)
                {
                    return response.Items;
                }
                return new List <LiveBroadcast>();
            }));
        }
Esempio n. 5
0
        private async Task <LiveBroadcast> GetUpcomingLiveInternalAsync(CancellationToken cancellationToken)
        {
            _logger.LogTrace($"{GetType()} - BEGIN {nameof(GetUpcomingLiveInternalAsync)}");

            try
            {
                YouTubeService ytService = await _ytServiceProvider.CreateServiceAsync(cancellationToken);

                LiveBroadcastsResource.ListRequest req = ytService.LiveBroadcasts.List(SNIPPET_PART_PARAM);
                req.BroadcastStatus = LiveBroadcastsResource.ListRequest.BroadcastStatusEnum.Upcoming;

                LiveBroadcastListResponse res = await req.ExecuteAsync(cancellationToken);

                return(res?.Items?.FirstOrDefault());
            }
            catch (Exception e)
            {
                _logger.LogError("An error occurred while retrieving video metadata", e);
                throw;
            }
        }