Convertir Texto A Voz Usando Google Cloud Y Java

En este post vamos a aprender a usar, a través de un ejemplo sencillo, uno de los muchos APIs disponibles en el Google Cloud Platform siendo este el Text-To-Speech api, o español la API de texto a voz. Sin mas introducción, vamos manos a ello:

Lo primero que deben hacer es crear una cuenta, si no la tienen ya, en Google Cloud Platform. Cuando crean la cuenta y acceden por primera vez a ella deben ver lo siguiente:

Aquí hacemos click en “IR A LA CONSOLA” para poder administrar el acceso y ver las métricas de nuestros APIs.

Ya en la consola vemos en la parte superior central una barra que nos permite buscar. En ella escribimos el nombre del API que nos interesa, en este caso “Cloud Text-To-Speech API” 

Hacemos click en el resultado lo cual nos lleva a la consola para este API. En este paso lo que debemos hacer es activar este API en nuestra cuenta.

Para eso hacemos click en el botón azul que pone “HABILITAR”, y cuando el proceso termina deberíamos ser capaces de ver nuestra consola de administración para este API.

Lo siguiente que hay que hacer es crearnos unas llaves de acceso para que nuestra aplicación se pueda autenticar correctamente con el servicio. Para esto vamos al enlace en el menú de la derecha que pone “Credenciales”.

Luego localizamos el botón azul que pone “Crear Credenciales” y seleccionamos la opción “Clave de cuenta de servicio”. Al seleccionar esta opción nos presenta algunas preferencias de cómo preferimos nuestra clave.

En cuenta de servicio podemos configurar la que queramos (y tengamos asociada a nuestra cuenta), pero para efectos de este tutorial vamos a dejar la default. y como tipo de clave seleccionamos en format JSON. y damos click en el botón azul que dice: “Crear”.

Casi de inmediato vemos que se descargo un archivo .json a nuestra carpeta de descargas y aparece el siguiente mensaje:

Debemos guardar muy bien este archivo, ya que es la única instancia que tenemos de nuestra clave privada. Si lo perdemos debemos inhabilitar esta clave y generar una nueva.

Los contenidos del archivo tienen el siguiente aspecto:

{
  "type": "service_account",
  "project_id": "el-nombre-que-le-pusieron",
  "private_key_id": "<su identificador de llave privada>",
  "private_key": "<la llave privada>",
  "client_email": "<email del cliente>",
  "client_id": "<id del cliente>",
  "auth_uri": "https://accounts.google.com/o/oauth2/auth",
  "token_uri": "https://accounts.google.com/o/oauth2/token",
  "auth_provider_x509_cert_url": "https://www.googleapis.com/oauth2/v1/certs",
  "client_x509_cert_url": "https://www.googleapis.com/robot/v1/metadata/x509/<email del cliente>"
}

todos estos son los campos que necesitaremos en nuestra aplicación de java. Y lo que tenemos que hacer para que nuestra aplicación entienda estas credenciales es poner una variable de entorno con el nombre GOOGLE_APPLICATION_CREDENTIALS. Según su gestión de la configuración establecida esto puede lograrse de muchas maneras, pero para efectos de este tutorial simplemente vamos a poner esta variable para una sesión en la terminal. Asumiendo que usamos unix, ponemos el siguiente comando:

export GOOGLE_APPLICATION_CREDENTIALS=/ruta/al/archivo/credenciales.json

o para algo más permanente agregamos ese comando al final del archivo ~/.bash_profile. En un ambiente de producción esto se puede configurar en un servicio para systemd, o bien en un contenedor docker.

Ahora generamos un proyecto spring boot nuevo, con las siguientes dependencias:

• com.google.guava
• org.threeten (threetenbp)
• com.google.http-client (google-http-client)
• com.google.cloud (google-cloud-texttospeech)

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
	xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
	<modelVersion>4.0.0</modelVersion>

	<groupId>com.ricardogeek</groupId>
	<artifactId>text-to-speech-demo</artifactId>
	<version>0.0.1-SNAPSHOT</version>
	<packaging>jar</packaging>

	<name>text-to-speech-demo</name>
	<description>Demo project for Spring Boot</description>

	<parent>
		<groupId>org.springframework.boot</groupId>
		<artifactId>spring-boot-starter-parent</artifactId>
		<version>2.0.0.RELEASE</version>
		<relativePath/> <!-- lookup parent from repository -->
	</parent>

	<properties>
		<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
		<project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
		<java.version>1.8</java.version>
	</properties>

	<dependencies>
		<dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-starter</artifactId>
		</dependency>

		<dependency>
			<groupId>com.google.guava</groupId>
			<artifactId>guava</artifactId>
			<version>24.1-jre</version>
		</dependency>

		<dependency>
			<groupId>org.threeten</groupId>
			<artifactId>threetenbp</artifactId>
			<version>1.3.6</version>
		</dependency>

		<dependency>
			<groupId>com.google.http-client</groupId>
			<artifactId>google-http-client</artifactId>
			<version>1.22.0</version>
		</dependency>

		<dependency>
			<groupId>com.google.cloud</groupId>
			<artifactId>google-cloud-texttospeech</artifactId>
			<version>0.42.0-beta</version>
		</dependency>

		<dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-starter-test</artifactId>
			<scope>test</scope>
		</dependency>
	</dependencies>

	<build>
		<plugins>
			<plugin>
				<groupId>org.springframework.boot</groupId>
				<artifactId>spring-boot-maven-plugin</artifactId>
			</plugin>
		</plugins>
	</build>


</project>

Y en la clase principal, ponemos el siguiente código:

@SpringBootApplication
public class TextToSpeechDemoApplication implements CommandLineRunner {

	public static void main(String[] args) {
		SpringApplication.run(TextToSpeechDemoApplication.class, args);
	}

	@Override
	public void run(String... args) throws Exception {
		final String texto = "Buenos Dias! Esta es una demostracion del API texto a voz de google cloud platform";
		final String archivoDeSalida = "/ruta/al/archivo/output.mp3";

		try (TextToSpeechClient textToSpeechClient = TextToSpeechClient.create()) {
			// Indicamos la entrada de texto que debe ser sintentizada
			final SynthesisInput input = SynthesisInput.newBuilder().setText(texto).build();

			// Construimos la llamada al API; languageCode = "en_ES" para indicar que el audio debe ser en español
			final VoiceSelectionParams voice = VoiceSelectionParams.newBuilder().setLanguageCode("es-ES")
					.setSsmlGender(SsmlVoiceGender.FEMALE) //voz de chica
					.build();

			// Seleccionamos el tipo de archivo que queremos que se genere
			final AudioConfig audioConfig = AudioConfig.newBuilder().setAudioEncoding(AudioEncoding.MP3) //audio MP3.
					.build();

			// Realizar el request a text-to-speech
			final SynthesizeSpeechResponse response = textToSpeechClient.synthesizeSpeech(input, voice, audioConfig);

			// Obtener los contenidos de audio de la respuesta del API
			final ByteString audioContents = response.getAudioContent();

			// Escribir esos contenidos a un arhivo y escribirlo
			try (OutputStream out = new FileOutputStream(archivoDeSalida)) {
				out.write(audioContents.toByteArray());
				System.out.println("Audio de salida: \"output.mp3\"");
			}
		}
	}
}

Si todo fue bien al correr este proyecto en la misma terminal en la que pusimos nuestra variable de entorno de autenticación, deberíamos obtener un archivo “output.mp3” con el audio que representa nuestro texto.

Ahora vayan! y construyan su propia cortana con este conocimiento 🙂