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         subparser.addArgument("--json")
  45                 .help("WARNING: This parameter is now deprecated! Please use the global \"--output=json\" option instead.\n\nOutput received messages in json format, one json object per line.")
  46                 .action(Arguments.storeTrue());
  47     }
  48
  49     @Override
  50     public Set<OutputType> getSupportedOutputTypes() {
  51         return Set.of(OutputType.PLAIN_TEXT, OutputType.JSON);
  52     }
  53
  54     public void handleCommand(
  55             final Namespace ns, final Signal signal, DBusConnection dbusconnection
  56     ) throws CommandException {
  57         var inJson = ns.get("output") == OutputType.JSON || ns.getBoolean("json");
  58
  59         // TODO delete later when "json" variable is removed
  60         if (ns.getBoolean("json")) {
  61             logger.warn("\"--json\" option has been deprecated, please use the global \"--output=json\" instead.");
  62         }
  63
  64         try {
  65             if (inJson) {
  66                 final var jsonWriter = new JsonWriter(System.out);
  67
  68                 dbusconnection.addSigHandler(Signal.MessageReceived.class, signal, messageReceived -> {
  69                     var envelope = new JsonMessageEnvelope(messageReceived);
  70                     final var object = Map.of("envelope", envelope);
  71                     jsonWriter.write(object);
  72                 });
  73
  74                 dbusconnection.addSigHandler(Signal.ReceiptReceived.class, signal, receiptReceived -> {
  75                     var envelope = new JsonMessageEnvelope(receiptReceived);
  76                     final var object = Map.of("envelope", envelope);
  77                     jsonWriter.write(object);
  78                 });
  79
  80                 dbusconnection.addSigHandler(Signal.SyncMessageReceived.class, signal, syncReceived -> {
  81                     var envelope = new JsonMessageEnvelope(syncReceived);
  82                     final var object = Map.of("envelope", envelope);
  83                     jsonWriter.write(object);
  84                 });
  85             } else {
  86                 final var writer = new PlainTextWriterImpl(System.out);
  87
  88                 dbusconnection.addSigHandler(Signal.MessageReceived.class, signal, messageReceived -> {
  89                     writer.println("Envelope from: {}", messageReceived.getSender());
  90                     writer.println("Timestamp: {}", DateUtils.formatTimestamp(messageReceived.getTimestamp()));
  91                     writer.println("Body: {}", messageReceived.getMessage());
  92                     if (messageReceived.getGroupId().length > 0) {
  93                         writer.println("Group info:");
  94                         writer.indentedWriter()
  95                                 .println("Id: {}", Base64.getEncoder().encodeToString(messageReceived.getGroupId()));
  96                     }
  97                     if (messageReceived.getAttachments().size() > 0) {
  98                         writer.println("Attachments:");
  99                         for (var attachment : messageReceived.getAttachments()) {
 100                             writer.println("- Stored plaintext in: {}", attachment);
 101                         }
 102                     }
 103                     writer.println();
 104                 });
 105
 106                 dbusconnection.addSigHandler(Signal.ReceiptReceived.class, signal, receiptReceived -> {
 107                     writer.println("Receipt from: {}", receiptReceived.getSender());
 108                     writer.println("Timestamp: {}", DateUtils.formatTimestamp(receiptReceived.getTimestamp()));
 109                 });
 110
 111                 dbusconnection.addSigHandler(Signal.SyncMessageReceived.class, signal, syncReceived -> {
 112                     writer.println("Sync Envelope from: {} to: {}",
 113                             syncReceived.getSource(),
 114                             syncReceived.getDestination());
 115                     writer.println("Timestamp: {}", DateUtils.formatTimestamp(syncReceived.getTimestamp()));
 116                     writer.println("Body: {}", syncReceived.getMessage());
 117                     if (syncReceived.getGroupId().length > 0) {
 118                         writer.println("Group info:");
 119                         writer.indentedWriter()
 120                                 .println("Id: {}", Base64.getEncoder().encodeToString(syncReceived.getGroupId()));
 121                     }
 122                     if (syncReceived.getAttachments().size() > 0) {
 123                         writer.println("Attachments:");
 124                         for (var attachment : syncReceived.getAttachments()) {
 125                             writer.println("- Stored plaintext in: {}", attachment);
 126                         }
 127                     }
 128                     writer.println();
 129                 });
 130             }
 131         } catch (DBusException e) {
 132             logger.error("Dbus client failed", e);
 133             throw new UnexpectedErrorException("Dbus client failed");
 134         }
 135         while (true) {
 136             try {
 137                 Thread.sleep(10000);
 138             } catch (InterruptedException ignored) {
 139                 return;
 140             }
 141         }
 142     }
 143
 144     @Override
 145     public void handleCommand(final Namespace ns, final Manager m) throws CommandException {
 146         var inJson = ns.get("output") == OutputType.JSON || ns.getBoolean("json");
 147
 148         // TODO delete later when "json" variable is removed
 149         if (ns.getBoolean("json")) {
 150             logger.warn("\"--json\" option has been deprecated, please use the global \"--output=json\" instead.");
 151         }
 152
 153         double timeout = ns.getDouble("timeout");
 154         var returnOnTimeout = true;
 155         if (timeout < 0) {
 156             returnOnTimeout = false;
 157             timeout = 3600;
 158         }
 159         boolean ignoreAttachments = ns.getBoolean("ignore-attachments");
 160         try {
 161             final var handler = inJson ? new JsonReceiveMessageHandler(m) : new ReceiveMessageHandler(m);
 162             m.receiveMessages((long) (timeout * 1000),
 163                     TimeUnit.MILLISECONDS,
 164                     returnOnTimeout,
 165                     ignoreAttachments,
 166                     handler);
 167         } catch (IOException e) {
 168             throw new IOErrorException("Error while receiving messages: " + e.getMessage());
 169         }
 170     }
 171 }