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