Una de las preguntas que a menudo viene en PM es cómo trabajar con sonrisas (emojis) y pegatinas.
Cómo trabajar con ellos, qué herramientas uso, etc.
En esta parte, consideraremos tales cosas: cómo crear un mensaje con una pegatina, cómo procesar un mensaje recibido con una pegatina, cómo encontrar todos los emoticones (emoji) en el texto del mensaje, cómo crear un mensaje usando emoticones.
A quién le importa, por favor, debajo del gato.
Por tradición, comenzamos el artículo con un enlace a la fuente para ello :)
Todo el código discutido en el artículo está compilado en la
rama Part3-Stick_and_Emoji .
Pegatinas
Una de las cosas que me gustaron tanto en el telegrama en cuanto apareció fueron las pegatinas. Son geniales, cómodos, gratis. Y toda esta gran variedad de pegatinas que naturalmente queremos usar en el bot. De hecho, este procedimiento es muy simple. Para enviar una pegatina a un usuario, solo necesitamos conocer la identificación de la pegatina y nada más.
Por lo general, para las etiquetas, creo una clase de asistente, donde almaceno datos sobre las etiquetas utilizadas en el bot:
Stickers.javaimport org.telegram.telegrambots.api.methods.send.SendSticker; public enum Stickers { FUNNY_JIM_CARREY("CAADBQADiQMAAukKyAPZH7wCI2BwFxYE"), ; String stickerId; Stickers(String stickerId) { this.stickerId = stickerId; } public SendSticker getSendSticker(String chatId) { if ("".equals(chatId)) throw new IllegalArgumentException("ChatId cant be null"); SendSticker sendSticker = getSendSticker(); sendSticker.setChatId(chatId); return sendSticker; } public SendSticker getSendSticker() { SendSticker sendSticker = new SendSticker(); sendSticker.setSticker(stickerId); return sendSticker; } }
Todo es simple aquí. Le damos a la pegatina un nombre que nos es comprensible. Y con la ayuda de un par de métodos, obtenemos un objeto listo para enviar al usuario.
Para responder a la pregunta: "¿Dónde puedo obtener la ID de la pegatina?", Escribamos un asistente que nos proporcionará estos datos en nuestro bot.
Tenemos la funcionalidad básica que creamos aquí:
TelegramBot. La funcionalidad básica. (Parte 2)Para que nuestro bot pueda comenzar a procesar de alguna manera las pegatinas aceptadas, necesitamos:
- Determina que nos enviaron una pegatina
- Indique qué manejador es responsable de procesar los mensajes con calcomanías
- Ejecute un controlador que generará un mensaje para el usuario en respuesta
Tarea : al recibir una pegatina en el chat, el bot debe enviar un mensaje de texto con la ID de la pegatina en respuesta.
Agregamos el comando
STICKER a la lista de comandos
En el analizador de la actualización enviada, intentaremos determinar si tenemos un mensaje de texto o si contiene una pegatina:
MessageReciever.java línea 57 if (message.hasText()) { parsedCommand = parser.getParsedCommand(message.getText()); } else { Sticker sticker = message.getSticker(); if (sticker != null) { parsedCommand = new ParsedCommand(Command.STICKER, sticker.getFileId()); } }
Porque no necesitamos hacer un procesamiento complejo del mensaje enviado, entonces confiaremos el procesamiento de los mensajes que contienen la etiqueta al manejador existente responsable de manejar los llamados "mensajes del sistema":
MessageReciever.java línea 86 case START: case HELP: case ID: case STICKER: SystemHandler systemHandler = new SystemHandler(bot); log.info("Handler for command[" + command.toString() + "] is: " + systemHandler); return systemHandler;
En consecuencia, en
SystemHandler necesitamos especificar cómo procesar el comando
STICKER recibido:
SystemHandler.java línea 31 case STICKER: return "StickerID: " + parsedCommand.getText();
Como resultado, al enviar cualquier pegatina a nuestro bot, recibiremos su ID en respuesta:
Emoticones o Emoji
Se estandarizaron, casi todos los dispositivos y sistemas operativos los entienden y pueden mostrar. Son muy convenientes de usar para decorar mensajes. Se ven sucintamente en los botones debajo de los mensajes. Nos guste o no, algunas ventajas.
Por ejemplo, en el
bot del planificador de eventos
Usando los mismos íconos en los botones y en el texto del mensaje, le permite al usuario entender intuitivamente y entender su interfaz, abarrotando el mensaje y los botones con texto en exceso.
Para mostrar emojis en un mensaje o en un botón, debe conocer su Unicode. Internet está lleno de fuentes donde puede encontrar todos los emoticones enumerados, donde se indican sus etiquetas y códigos.
Por mi parte, elegí esta forma de trabajar con emojis: es más conveniente mirar y seleccionar emoticones en el telegrama mismo.
Bueno, por supuesto, por analogía con las pegatinas, escribamos un pequeño ayudante para nosotros que nos mostrará los códigos necesarios e incluso para garantizar que los procesemos correctamente.
En primer lugar, agregue la siguiente dependencia a
pom.xml :
<dependency> <groupId>com.vdurmont</groupId> <artifactId>emoji-java</artifactId> <version>3.3.0</version> </dependency>
Honestamente, no recuerdo dónde lo encontré, pero desde entonces solo lo uso si necesito hacer algo con emoticones en mi bot.
La biblioteca contiene muchas herramientas diferentes:
Inquisitivo e inquisitivo será donde dar la vuelta :)
¿Qué se necesita para enviar un emoticón usando un bot? Debe incrustar el emoji deseado en el texto del mensaje Unicode.
Sí, puede encontrar recursos que ofrecen listas Unicode con emojis, muestran diferentes tablas de resumen de cómo se ven los emoticones en diferentes teléfonos inteligentes.
Quiero mostrarte una forma que resultó ser la más conveniente para trabajar con sonrisas para mí.
Primero, veamos cómo puedes usar sonrisas en el telegrama. Puede abrir un cuadro de diálogo donde se enumeran todos los emoticones y agregarlos al mensaje, simplemente haciendo clic en sus iconos. También se pueden agregar emoticones al mensaje mediante etiquetas.
Las etiquetas deben estar enmarcadas en dos puntos y contener algún tipo de texto único que indique el smiley deseado.
Si en el campo para ingresar un mensaje comienza a escribir un mensaje que comienza con dos puntos, el telegrama comenzará a mostrar qué emojis contienen el texto ingresado de la etiqueta:
Y cuando ingrese la etiqueta de emoticón correcta y coloque otros dos puntos, el texto se convertirá en una carita sonriente. Las etiquetas también se muestran si mantiene presionado el botón izquierdo del mouse en el emoticón.
Y ahora la biblioteca viene en nuestra ayuda, cuya dependencia agregamos anteriormente. Ella sabe cómo trabajar con etiquetas de emoticones. Esto es conveniente principalmente para usted, ya que las etiquetas son más legibles, tienen algún tipo de significado.
Y nosotros, conociendo la etiqueta, podemos obtener el emoticón Unicode así:
String emoji_kissing = EmojiParser.parseToUnicode(":kissing:");
Puedes hacerte una clase separada en la que mantendrás los emoticones que usas en el bot. En el ejemplo del mismo
organizador de eventos , tiene estas sonrisas en su arsenal:
import com.vdurmont.emoji.EmojiParser; public enum Icon { PLUS(":heavy_plus_sign:"), MINUS(":heavy_minus_sign:"), CHECK(":white_check_mark:"), NOT(":x:"), DOUBT(":zzz:"), FLAG(":checkered_flag:") private String value; public String get() { return EmojiParser.parseToUnicode(value); } Icon(String value) { this.value = value; } }
Y así es como se verá el código usando esta clase y un emoticón específico:
row.add(new InlineKeyboardButton() .setText(Icon.CHECK.get() + " I'm going")
Este es el código para este botón:
Noté un matiz de esta biblioteca. No todos los emoticones que están en un telegrama, la biblioteca puede reconocerlos. Por lo tanto, tenga cuidado con las nuevas versiones de la biblioteca.
Bueno, para estar seguros de qué sonrisas podemos mostrar y cuáles no, confiaremos esta tarea a nuestro asistente.
Tarea: si el mensaje enviado no contiene ningún comando específico, pero contiene sonrisas en el texto, muestre estas sonrisas en la pantalla en forma de mensaje para el usuario e indique sus atributos (etiqueta y descripción).
Agregue el comando
TEXT_CONTAIN_EMOJI a la lista de comandos
Command.java línea 8 public enum Command { ... TEXT_CONTAIN_EMOJI, ... }
En el analizador que determina qué tipo de comando está contenido en nuestro mensaje, agregue el siguiente texto:
Parser.java línea 38 if (result.getCommand() == Command.NONE) { List<String> emojiContainsInText = EmojiParser.extractEmojis(result.getText()); if (emojiContainsInText.size() > 0) result.setCommand(Command.TEXT_CONTAIN_EMOJI); }
Si determinamos que el mensaje no contiene ningún comando específico, pero contiene emoticones, devolvemos que analizamos el comando TEXT_CONTAIN_EMOJI.
Cree un controlador separado que solo procesará este comando:
EmojiHandler.java import com.example.telegrambot.bot.Bot; import com.example.telegrambot.command.ParsedCommand; import com.vdurmont.emoji.Emoji; import com.vdurmont.emoji.EmojiManager; import com.vdurmont.emoji.EmojiParser; import org.apache.log4j.Logger; import org.telegram.telegrambots.api.objects.Update; import java.util.HashSet; import java.util.Set; public class EmojiHandler extends AbstractHandler { private static final Logger log = Logger.getLogger(EmojiHandler.class); public EmojiHandler(Bot bot) { super(bot); } @Override public String operate(String chatId, ParsedCommand parsedCommand, Update update) { String text = parsedCommand.getText(); StringBuilder result = new StringBuilder(); Set<String> emojisInTextUnique = new HashSet<>(EmojiParser.extractEmojis(text)); if (emojisInTextUnique.size() > 0) result.append("Parsed emojies from message:").append("\n"); for (String emojiUnicode : emojisInTextUnique) { Emoji byUnicode = EmojiManager.getByUnicode(emojiUnicode); log.debug(byUnicode.toString()); String emoji = byUnicode.getUnicode() + " " + byUnicode.getAliases() + " " + byUnicode.getDescription(); result.append(emoji).append("\n"); } return result.toString(); } }
Este código selecciona solo emoticones del texto del mensaje, forma un conjunto con los únicos, selecciona etiquetas y descripción de sus propiedades, y genera un mensaje de texto a partir de esto.
El resultado del trabajo se ve así:
Entre corchetes obtenemos etiquetas que podemos usar para insertar emoticones. Puede ver que más de 1 etiqueta a veces se refiere a un emoticón.
Y también, con la ayuda de este asistente, podemos entender con precisión qué emoticones entiende nuestra biblioteca y cuáles ignora.
Como, por ejemplo, puedes ver aquí:
Sonríe con el código
: face_with_monocle: por alguna razón, esta biblioteca no lo detecta.
Entonces, tenemos un controlador. ¿Cómo le pasamos la tarea a él?
Porque ya sabemos que un mensaje de texto con emoticones dentro se detecta como un comando TEXT_CONTAIN_EMOJI; en MessageReciever debemos indicar que un controlador EmojiHandler es responsable de procesar este comando.
MessageReciever.java línea 94 case TEXT_CONTAIN_EMOJI: EmojiHandler emojiHandler = new EmojiHandler(bot); log.info("Handler for command[" + command.toString() + "] is: " + emojiHandler); return emojiHandler;
Programa con mucho gusto y no dudes en hacer preguntas :)
PS
Puedes sentir el bot con esta funcionalidad aquí:
https://t.me/test_habr_bot .