nmode's Git Repositories - signal-cli/blob - src/main/java/org/asamk/signal/commands/ReceiveCommand.java

   1 package org.asamk.signal.commands;
   2
   3 import net.sourceforge.argparse4j.impl.Arguments;
   4 import net.sourceforge.argparse4j.inf.Namespace;
   5 import net.sourceforge.argparse4j.inf.Subparser;
   6
   7 import org.asamk.Signal;
   8 import org.asamk.signal.JsonReceiveMessageHandler;
   9 import org.asamk.signal.JsonWriter;
  10 import org.asamk.signal.OutputType;
  11 import org.asamk.signal.PlainTextWriterImpl;
  12 import org.asamk.signal.ReceiveMessageHandler;
  13 import org.asamk.signal.commands.exceptions.CommandException;
  14 import org.asamk.signal.commands.exceptions.IOErrorException;
  15 import org.asamk.signal.commands.exceptions.UnexpectedErrorException;
  16 import org.asamk.signal.json.JsonMessageEnvelope;
  17 import org.asamk.signal.manager.Manager;
  18 import org.asamk.signal.util.DateUtils;
  19 import org.freedesktop.dbus.connections.impl.DBusConnection;
  20 import org.freedesktop.dbus.exceptions.DBusException;
  21 import org.slf4j.Logger;
  22 import org.slf4j.LoggerFactory;
  23
  24 import java.io.IOException;
  25 import java.util.Base64;
  26 import java.util.Map;
  27 import java.util.Set;
  28 import java.util.concurrent.TimeUnit;
  29
  30 public class ReceiveCommand implements ExtendedDbusCommand, LocalCommand {
  31
  32     private final static Logger logger = LoggerFactory.getLogger(ReceiveCommand.class);
  33
  34     @Override
  35     public void attachToSubparser(final Subparser subparser) {
  36         subparser.help("Query the server for new messages.");
  37         subparser.addArgument("-t", "--timeout")
  38                 .type(double.class)
  39                 .setDefault(3.0)
  40                 .help("Number of seconds to wait for new messages (negative values disable timeout)");
  41         subparser.addArgument("--ignore-attachments")
  42                 .help("Don’t download attachments of received messages.")
  43                 .action(Arguments.storeTrue());
  44     }
  45
  46     @Override
  47     public Set<OutputType> getSupportedOutputTypes() {
  48         return Set.of(OutputType.PLAIN_TEXT, OutputType.JSON);
  49     }
  50
  51     public void handleCommand(
  52             final Namespace ns, final Signal signal, DBusConnection dbusconnection
  53     ) throws CommandException {
  54         var inJson = ns.get("output") == OutputType.JSON;
  55
  56         try {
  57             if (inJson) {
  58                 final var jsonWriter = new JsonWriter(System.out);
  59
  60                 dbusconnection.addSigHandler(Signal.MessageReceived.class, signal, messageReceived -> {
  61                     var envelope = new JsonMessageEnvelope(messageReceived);
  62                     final var object = Map.of("envelope", envelope);
  63                     jsonWriter.write(object);
  64                 });
  65
  66                 dbusconnection.addSigHandler(Signal.ReceiptReceived.class, signal, receiptReceived -> {
  67                     var envelope = new JsonMessageEnvelope(receiptReceived);
  68                     final var object = Map.of("envelope", envelope);
  69                     jsonWriter.write(object);
  70                 });
  71
  72                 dbusconnection.addSigHandler(Signal.SyncMessageReceived.class, signal, syncReceived -> {
  73                     var envelope = new JsonMessageEnvelope(syncReceived);
  74                     final var object = Map.of("envelope", envelope);
  75                     jsonWriter.write(object);
  76                 });
  77             } else {
  78                 final var writer = new PlainTextWriterImpl(System.out);
  79
  80                 dbusconnection.addSigHandler(Signal.MessageReceived.class, signal, messageReceived -> {
  81                     writer.println("Envelope from: {}", messageReceived.getSender());
  82                     writer.println("Timestamp: {}", DateUtils.formatTimestamp(messageReceived.getTimestamp()));
  83                     writer.println("Body: {}", messageReceived.getMessage());
  84                     if (messageReceived.getGroupId().length > 0) {
  85                         writer.println("Group info:");
  86                         writer.indentedWriter()
  87                                 .println("Id: {}", Base64.getEncoder().encodeToString(messageReceived.getGroupId()));
  88                     }
  89                     if (messageReceived.getAttachments().size() > 0) {
  90                         writer.println("Attachments:");
  91                         for (var attachment : messageReceived.getAttachments()) {
  92                             writer.println("- Stored plaintext in: {}", attachment);
  93                         }
  94                     }
  95                     writer.println();
  96                 });
  97
  98                 dbusconnection.addSigHandler(Signal.ReceiptReceived.class, signal, receiptReceived -> {
  99                     writer.println("Receipt from: {}", receiptReceived.getSender());
 100                     writer.println("Timestamp: {}", DateUtils.formatTimestamp(receiptReceived.getTimestamp()));
 101                 });
 102
 103                 dbusconnection.addSigHandler(Signal.SyncMessageReceived.class, signal, syncReceived -> {
 104                     writer.println("Sync Envelope from: {} to: {}",
 105                             syncReceived.getSource(),
 106                             syncReceived.getDestination());
 107                     writer.println("Timestamp: {}", DateUtils.formatTimestamp(syncReceived.getTimestamp()));
 108                     writer.println("Body: {}", syncReceived.getMessage());
 109                     if (syncReceived.getGroupId().length > 0) {
 110                         writer.println("Group info:");
 111                         writer.indentedWriter()
 112                                 .println("Id: {}", Base64.getEncoder().encodeToString(syncReceived.getGroupId()));
 113                     }
 114                     if (syncReceived.getAttachments().size() > 0) {
 115                         writer.println("Attachments:");
 116                         for (var attachment : syncReceived.getAttachments()) {
 117                             writer.println("- Stored plaintext in: {}", attachment);
 118                         }
 119                     }
 120                     writer.println();
 121                 });
 122             }
 123         } catch (DBusException e) {
 124             logger.error("Dbus client failed", e);
 125             throw new UnexpectedErrorException("Dbus client failed");
 126         }
 127         while (true) {
 128             try {
 129                 Thread.sleep(10000);
 130             } catch (InterruptedException ignored) {
 131                 return;
 132             }
 133         }
 134     }
 135
 136     @Override
 137     public void handleCommand(final Namespace ns, final Manager m) throws CommandException {
 138         var inJson = ns.get("output") == OutputType.JSON;
 139
 140         double timeout = ns.getDouble("timeout");
 141         var returnOnTimeout = true;
 142         if (timeout < 0) {
 143             returnOnTimeout = false;
 144             timeout = 3600;
 145         }
 146         boolean ignoreAttachments = ns.getBoolean("ignore-attachments");
 147         try {
 148             final var handler = inJson ? new JsonReceiveMessageHandler(m) : new ReceiveMessageHandler(m);
 149             m.receiveMessages((long) (timeout * 1000),
 150                     TimeUnit.MILLISECONDS,
 151                     returnOnTimeout,
 152                     ignoreAttachments,
 153                     handler);
 154         } catch (IOException e) {
 155             throw new IOErrorException("Error while receiving messages: " + e.getMessage());
 156         }
 157     }
 158 }