Actualizar un extremo de entrada

Organiza tus páginas con colecciones Guarda y categoriza el contenido según tus preferencias.

Actualizar un recurso de extremo de entrada de transmisión en vivo

Explora más

Para obtener documentación en la que se incluye esta muestra de código, consulta lo siguiente:

Muestra de código

C#

Antes de probar esta muestra, sigue las instrucciones de configuración para C# que se encuentran en la Guía de inicio rápido de la API de Live Stream con bibliotecas cliente. Si quieres obtener más información, consulta la documentación de referencia de la API de Live Stream C#.


using Google.Cloud.Video.LiveStream.V1;
using Google.LongRunning;
using Google.Protobuf.WellKnownTypes;
using System.Threading.Tasks;

public class UpdateInputSample
{
    public async Task<Input> UpdateInputAsync(
         string projectId, string locationId, string inputId)
    {
        // Create the client.
        LivestreamServiceClient client = LivestreamServiceClient.Create();

        UpdateInputRequest request = new UpdateInputRequest
        {
            Input = new Input
            {
                InputName = InputName.FromProjectLocationInput(projectId, locationId, inputId),
                PreprocessingConfig = new PreprocessingConfig
                {
                    Crop = new PreprocessingConfig.Types.Crop
                    {
                        TopPixels = 5,
                        BottomPixels = 5
                    }
                }
            },
            UpdateMask = new FieldMask { Paths = { "preprocessing_config" } }
        };

        // Make the request.
        Operation<Input, OperationMetadata> response = await client.UpdateInputAsync(request);

        // Poll until the returned long-running operation is complete.
        Operation<Input, OperationMetadata> completedResponse = await response.PollUntilCompletedAsync();

        // Retrieve the operation result.
        return completedResponse.Result;
    }
}

Go

Antes de probar esta muestra, sigue las instrucciones de configuración para Go que se encuentran en la Guía de inicio rápido de la API de Live Stream con bibliotecas cliente. Si quieres obtener más información, consulta la documentación de referencia de la API de Live Stream Go.

import (
	"context"
	"fmt"
	"io"

	livestream "cloud.google.com/go/video/livestream/apiv1"
	livestreampb "google.golang.org/genproto/googleapis/cloud/video/livestream/v1"
	"google.golang.org/protobuf/types/known/fieldmaskpb"
)

// updateInput updates an existing input endpoint. This sample adds a
// preprocessing configuration to an existing input.
func updateInput(w io.Writer, projectID, location, inputID string) error {
	// projectID := "my-project-id"
	// location := "us-central1"
	// inputID := "my-input"
	ctx := context.Background()
	client, err := livestream.NewClient(ctx)
	if err != nil {
		return fmt.Errorf("NewClient: %v", err)
	}
	defer client.Close()

	req := &livestreampb.UpdateInputRequest{
		Input: &livestreampb.Input{
			Name: fmt.Sprintf("projects/%s/locations/%s/inputs/%s", projectID, location, inputID),
			PreprocessingConfig: &livestreampb.PreprocessingConfig{
				Crop: &livestreampb.PreprocessingConfig_Crop{
					TopPixels:    5,
					BottomPixels: 5,
				},
			},
		},
		UpdateMask: &fieldmaskpb.FieldMask{
			Paths: []string{
				"preprocessing_config",
			},
		},
	}
	// Updates the input.
	op, err := client.UpdateInput(ctx, req)
	if err != nil {
		return fmt.Errorf("UpdateInput: %v", err)
	}
	response, err := op.Wait(ctx)
	if err != nil {
		return fmt.Errorf("Wait: %v", err)
	}

	fmt.Fprintf(w, "Updated input: %v", response.Name)
	return nil
}

Java

Antes de probar esta muestra, sigue las instrucciones de configuración para Java que se encuentran en la Guía de inicio rápido de la API de Live Stream con bibliotecas cliente. Si quieres obtener más información, consulta la documentación de referencia de la API de Live Stream Java.


import com.google.cloud.video.livestream.v1.Input;
import com.google.cloud.video.livestream.v1.InputName;
import com.google.cloud.video.livestream.v1.LivestreamServiceClient;
import com.google.cloud.video.livestream.v1.PreprocessingConfig;
import com.google.cloud.video.livestream.v1.PreprocessingConfig.Crop;
import com.google.cloud.video.livestream.v1.UpdateInputRequest;
import com.google.protobuf.FieldMask;
import java.io.IOException;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.TimeoutException;

public class UpdateInput {

  public static void main(String[] args) throws Exception {
    // TODO(developer): Replace these variables before running the sample.
    String projectId = "my-project-id";
    String location = "us-central1";
    String inputId = "my-input-id";

    updateInput(projectId, location, inputId);
  }

  public static void updateInput(String projectId, String location, String inputId)
      throws InterruptedException, ExecutionException, TimeoutException, IOException {
    // Initialize client that will be used to send requests. This client only needs to be created
    // once, and can be reused for multiple requests. After completing all of your requests, call
    // the "close" method on the client to safely clean up any remaining background resources.
    try (LivestreamServiceClient livestreamServiceClient = LivestreamServiceClient.create()) {
      var updateInputRequest =
          UpdateInputRequest.newBuilder()
              .setInput(
                  Input.newBuilder()
                      .setName(InputName.of(projectId, location, inputId).toString())
                      .setPreprocessingConfig(
                          PreprocessingConfig.newBuilder()
                              .setCrop(Crop.newBuilder().setTopPixels(5).setBottomPixels(5).build())
                              .build())
                      .build())
              .setUpdateMask(FieldMask.newBuilder().addPaths("preprocessing_config").build())
              .build();
      // First API call in a project can take up to 10 minutes.
      Input result =
          livestreamServiceClient.updateInputAsync(updateInputRequest).get(10, TimeUnit.MINUTES);
      System.out.println("Updated input: " + result.getName());
    }
  }
}

Node.js

Antes de probar esta muestra, sigue las instrucciones de configuración para Node.js que se encuentran en la Guía de inicio rápido de la API de Live Stream con bibliotecas cliente. Si quieres obtener más información, consulta la documentación de referencia de la API de Live Stream Node.js.

/**
 * TODO(developer): Uncomment these variables before running the sample.
 */
// projectId = 'my-project-id';
// location = 'us-central1';
// inputId = 'my-input';

// Imports the Livestream library
const {LivestreamServiceClient} = require('@google-cloud/livestream').v1;

// Instantiates a client
const livestreamServiceClient = new LivestreamServiceClient();

async function updateInput() {
  // Construct request
  const request = {
    input: {
      name: livestreamServiceClient.inputPath(projectId, location, inputId),
      preprocessingConfig: {
        crop: {
          topPixels: 5,
          bottomPixels: 5,
        },
      },
    },
    updateMask: {
      paths: ['preprocessing_config'],
    },
  };

  // Run request
  const [operation] = await livestreamServiceClient.updateInput(request);
  const response = await operation.promise();
  const [input] = response;
  console.log(`Updated input: ${input.name}`);
}

updateInput();

Python

Antes de probar esta muestra, sigue las instrucciones de configuración para Python que se encuentran en la Guía de inicio rápido de la API de Live Stream con bibliotecas cliente. Si quieres obtener más información, consulta la documentación de referencia de la API de Live Stream Python.


import argparse

from google.cloud.video import live_stream_v1
from google.cloud.video.live_stream_v1.services.livestream_service import (
    LivestreamServiceClient,
)
from google.protobuf import field_mask_pb2 as field_mask

def update_input(project_id: str, location: str, input_id: str) -> str:
    """Updates an input.
    Args:
        project_id: The GCP project ID.
        location: The location of the input.
        input_id: The user-defined input ID."""

    client = LivestreamServiceClient()

    name = f"projects/{project_id}/locations/{location}/inputs/{input_id}"

    input = live_stream_v1.types.Input(
        name=name,
        preprocessing_config=live_stream_v1.types.PreprocessingConfig(
            crop=live_stream_v1.types.PreprocessingConfig.Crop(
                top_pixels=5,
                bottom_pixels=5,
            )
        ),
    )
    update_mask = field_mask.FieldMask(paths=["preprocessing_config"])

    operation = client.update_input(input=input, update_mask=update_mask)
    response = operation.result(600)
    print(f"Updated input: {response.name}")

    return response

Ruby

Antes de probar esta muestra, sigue las instrucciones de configuración para Ruby que se encuentran en la Guía de inicio rápido de la API de Live Stream con bibliotecas cliente. Si quieres obtener más información, consulta la documentación de referencia de la API de Live Stream Ruby.

require "google/cloud/video/live_stream"

##
# Update an input endpoint
#
# @param project_id [String] Your Google Cloud project (e.g. "my-project")
# @param location [String] The location (e.g. "us-central1")
# @param input_id [String] Your input name (e.g. "my-input")
#
def update_input project_id:, location:, input_id:
  # Create a Live Stream client.
  client = Google::Cloud::Video::LiveStream.livestream_service

  # Build the resource name of the input.
  name = client.input_path project: project_id, location: location, input: input_id

  # Set the update mask.
  update_mask = { paths: ["preprocessing_config"] }

  # Update the input pre-processing config field.
  update_input = {
    name: name,
    preprocessing_config: {
      crop: {
        top_pixels: 5,
        bottom_pixels: 5
      }
    }
  }

  operation = client.update_input update_mask: update_mask, input: update_input

  # The returned object is of type Gapic::Operation. You can use this
  # object to check the status of an operation, cancel it, or wait
  # for results. Here is how to block until completion:
  operation.wait_until_done!

  # Print the input name.
  puts "Updated input: #{operation.response.name}"
  puts "Updated pre-processing config: #{operation.response.preprocessing_config.crop.top_pixels}"
end

¿Qué sigue?

Para buscar y filtrar muestras de código de otros productos de Google Cloud, consulta el navegador de muestra de Google Cloud.