示例#1
0
 /**
  * Sends a message to the other chat participant. The thread ID, recipient, and message type of
  * the message will automatically set to those of this chat.
  *
  * @param message the message to send.
  * @throws XMPPException if an error occurs sending the message.
  */
 public void sendMessage(Message message) throws XMPPException {
   // Force the recipient, message type, and thread ID since the user elected
   // to send the message through this chat object.
   message.setTo(participant);
   message.setType(Message.Type.chat);
   message.setThread(threadID);
   chatManager.sendMessage(this, message);
 }
示例#2
0
  /**
   * Sends a broadcast message to all users selected.
   *
   * @param dlg
   */
  private boolean sendBroadcasts(JDialog dlg) {
    final Set<String> jids = new HashSet<String>();

    for (CheckNode node : nodes) {
      if (node.isSelected()) {
        String jid = (String) node.getAssociatedObject();
        jids.add(jid);
      }
    }

    if (jids.size() == 0) {
      JOptionPane.showMessageDialog(
          dlg,
          Res.getString("message.broadcast.no.user.selected"),
          Res.getString("title.error"),
          JOptionPane.ERROR_MESSAGE);
      return false;
    }

    String text = messageBox.getText();
    if (!ModelUtil.hasLength(text)) {
      JOptionPane.showMessageDialog(
          dlg,
          Res.getString("message.broadcast.no.text"),
          Res.getString("title.error"),
          JOptionPane.ERROR_MESSAGE);
      return false;
    }

    for (String jid : jids) {
      final Message message = new Message();
      message.setTo(jid);
      message.setBody(text);

      if (normalMessageButton.isSelected()) {
        message.setType(Message.Type.normal);
      } else {
        message.setType(Message.Type.headline);
      }
      SparkManager.getConnection().sendPacket(message);
    }

    return true;
  }
示例#3
0
  public void broadcast() throws XMPPException {

    Message newmsg = new Message();
    newmsg.setTo("*****@*****.**");
    newmsg.setSubject("重要通知");
    newmsg.setBody("今天下午2点60分有会!");
    newmsg.setType(Message.Type.headline); // normal支持离线
    connection.sendPacket(newmsg);
    connection.disconnect();
  }
示例#4
0
 /** {@inheritDoc} */
 @Override
 public void sendMessage(com.rei.lolchat.service.Message message) throws RemoteException {
   org.jivesoftware.smack.packet.Message send = new org.jivesoftware.smack.packet.Message();
   send.setTo(message.getTo());
   Log.w(TAG, "message to " + message.getTo());
   send.setBody(message.getBody());
   send.setType(org.jivesoftware.smack.packet.Message.Type.groupchat);
   // TODO gerer les messages contenant des XMPPError
   // send.set
   try {
     mAdaptee.sendMessage(send);
   } catch (XMPPException e) {
     // TODO Auto-generated catch block
     e.printStackTrace();
   }
 }
示例#5
0
 /**
  * Writes a formatted message to a room and creates the room if necessary, followed by an invite
  * to the default notification address to join the room
  *
  * @param number
  * @param contact
  * @param message
  * @throws XMPPException
  */
 public void writeRoom(String number, String contact, XmppMsg message, int mode) throws Exception {
   MultiUserChat muc;
   muc = inviteRoom(number, contact, mode);
   if (muc != null) {
     try {
       Message msg = new Message(muc.getRoom());
       msg.setBody(message.generateFmtTxt());
       if (mode == MODE_SHELL) {
         XHTMLManager.addBody(msg, message.generateXHTMLText().toString());
       }
       msg.setType(Message.Type.groupchat);
       muc.sendMessage(msg);
     } catch (Exception e) {
       muc.sendMessage(message.generateTxt());
     }
   }
 }
示例#6
0
  /**
   * Sends a message to the appropriate jid. The message is automatically added to the transcript.
   *
   * @param message the message to send.
   */
  public void sendMessage(Message message) {
    lastActivity = System.currentTimeMillis();

    try {
      getTranscriptWindow()
          .insertMessage(getNickname(), message, ChatManager.TO_COLOR, Color.white);
      getChatInputEditor().selectAll();

      getTranscriptWindow().validate();
      getTranscriptWindow().repaint();
      getChatInputEditor().clear();
    } catch (Exception ex) {
      Log.error("Error sending message", ex);
    }

    // Before sending message, let's add our full jid for full verification
    message.setType(Message.Type.chat);
    message.setTo(participantJID);
    message.setFrom(SparkManager.getSessionManager().getJID());

    // Notify users that message has been sent
    fireMessageSent(message);

    addToTranscript(message, false);

    getChatInputEditor().setCaretPosition(0);
    getChatInputEditor().requestFocusInWindow();
    scrollToBottom();

    // No need to request displayed or delivered as we aren't doing anything
    // with this
    // information.
    MessageEventManager.addNotificationsRequests(message, true, false, false, true);

    // Send the message that contains the notifications request
    try {
      fireOutgoingMessageSending(message);
      SparkManager.getConnection().sendPacket(message);
    } catch (Exception ex) {
      Log.error("Error sending message", ex);
    }
  }
  /**
   * Helper function used to send a message to a contact, with the given extensions attached.
   *
   * @param to The contact to send the message to.
   * @param toResource The resource to send the message to or null if no resource has been specified
   * @param message The message to send.
   * @param extensions The XMPP extensions that should be attached to the message before sending.
   * @return The MessageDeliveryEvent that resulted after attempting to send this message, so the
   *     calling function can modify it if needed.
   */
  private MessageDeliveredEvent sendMessage(
      Contact to, ContactResource toResource, Message message, PacketExtension[] extensions) {
    if (!(to instanceof ContactJabberImpl))
      throw new IllegalArgumentException("The specified contact is not a Jabber contact." + to);

    assertConnected();

    org.jivesoftware.smack.packet.Message msg = new org.jivesoftware.smack.packet.Message();

    String toJID = null;

    if (toResource != null) {
      if (toResource.equals(ContactResource.BASE_RESOURCE)) {
        toJID = to.getAddress();
      } else toJID = ((ContactResourceJabberImpl) toResource).getFullJid();
    }

    if (toJID == null) {
      toJID = to.getAddress();
    }

    msg.setPacketID(message.getMessageUID());
    msg.setTo(toJID);

    for (PacketExtension ext : extensions) {
      msg.addExtension(ext);
    }

    if (logger.isTraceEnabled())
      logger.trace("Will send a message to:" + toJID + " chat.jid=" + toJID);

    MessageDeliveredEvent msgDeliveryPendingEvt =
        new MessageDeliveredEvent(message, to, toResource);

    MessageDeliveredEvent[] transformedEvents =
        messageDeliveryPendingTransform(msgDeliveryPendingEvt);

    if (transformedEvents == null || transformedEvents.length == 0) return null;

    for (MessageDeliveredEvent event : transformedEvents) {
      String content = event.getSourceMessage().getContent();

      if (message.getContentType().equals(HTML_MIME_TYPE)) {
        msg.setBody(Html2Text.extractText(content));

        // Check if the other user supports XHTML messages
        // make sure we use our discovery manager as it caches calls
        if (jabberProvider.isFeatureListSupported(toJID, HTML_NAMESPACE)) {
          // Add the XHTML text to the message
          XHTMLManager.addBody(msg, OPEN_BODY_TAG + content + CLOSE_BODY_TAG);
        }
      } else {
        // this is plain text so keep it as it is.
        msg.setBody(content);
      }

      // msg.addExtension(new Version());

      if (event.isMessageEncrypted() && isCarbonEnabled) {
        msg.addExtension(new CarbonPacketExtension.PrivateExtension());
      }

      MessageEventManager.addNotificationsRequests(msg, true, false, false, true);

      String threadID = getThreadIDForAddress(toJID);
      if (threadID == null) threadID = nextThreadID();

      msg.setThread(threadID);
      msg.setType(org.jivesoftware.smack.packet.Message.Type.chat);
      msg.setFrom(jabberProvider.getConnection().getUser());

      jabberProvider.getConnection().sendPacket(msg);

      putJidForAddress(toJID, threadID);
    }

    return new MessageDeliveredEvent(message, to, toResource);
  }
  /**
   * Parses a message packet.
   *
   * @param parser the XML parser, positioned at the start of a message packet.
   * @return a Message packet.
   * @throws Exception if an exception occurs while parsing the packet.
   */
  public static Packet parseMessage(XmlPullParser parser) throws Exception {
    Message message = new Message();
    String id = parser.getAttributeValue("", "id");
    message.setPacketID(id == null ? Packet.ID_NOT_AVAILABLE : id);
    message.setTo(parser.getAttributeValue("", "to"));
    message.setFrom(parser.getAttributeValue("", "from"));
    message.setType(Message.Type.fromString(parser.getAttributeValue("", "type")));
    String language = getLanguageAttribute(parser);

    // determine message's default language
    String defaultLanguage = null;
    if (language != null && !"".equals(language.trim())) {
      message.setLanguage(language);
      defaultLanguage = language;
    } else {
      defaultLanguage = Packet.getDefaultLanguage();
    }

    // Parse sub-elements. We include extra logic to make sure the values
    // are only read once. This is because it's possible for the names to appear
    // in arbitrary sub-elements.
    boolean done = false;
    String thread = null;
    Map<String, Object> properties = null;
    while (!done) {
      int eventType = parser.next();
      if (eventType == XmlPullParser.START_TAG) {
        String elementName = parser.getName();
        String namespace = parser.getNamespace();
        if (elementName.equals("subject")) {
          String xmlLang = getLanguageAttribute(parser);
          if (xmlLang == null) {
            xmlLang = defaultLanguage;
          }

          String subject = parseContent(parser);

          if (message.getSubject(xmlLang) == null) {
            message.addSubject(xmlLang, subject);
          }
        } else if (elementName.equals("body")) {
          String xmlLang = getLanguageAttribute(parser);
          if (xmlLang == null) {
            xmlLang = defaultLanguage;
          }

          String body = parseContent(parser);

          if (message.getBody(xmlLang) == null) {
            message.addBody(xmlLang, body);
          }
        } else if (elementName.equals("thread")) {
          if (thread == null) {
            thread = parser.nextText();
          }
        } else if (elementName.equals("error")) {
          message.setError(parseError(parser));
        } else if (elementName.equals("properties") && namespace.equals(PROPERTIES_NAMESPACE)) {
          properties = parseProperties(parser);
        }
        // Otherwise, it must be a packet extension.
        else {
          message.addExtension(
              PacketParserUtils.parsePacketExtension(elementName, namespace, parser));
        }
      } else if (eventType == XmlPullParser.END_TAG) {
        if (parser.getName().equals("message")) {
          done = true;
        }
      }
    }

    message.setThread(thread);
    // Set packet properties.
    if (properties != null) {
      for (String name : properties.keySet()) {
        message.setProperty(name, properties.get(name));
      }
    }
    return message;
  }
  boolean sendMessage(OutMessage message, boolean sendChatState) {
    // check for correct receipt status and reset it
    KonMessage.Status status = message.getStatus();
    assert status == KonMessage.Status.PENDING || status == KonMessage.Status.ERROR;
    message.setStatus(KonMessage.Status.PENDING);

    if (!mClient.isConnected()) {
      LOGGER.info("not sending message(s), not connected");
      return false;
    }

    MessageContent content = message.getContent();
    MessageContent.Attachment att = content.getAttachment().orElse(null);
    if (att != null && !att.hasURL()) {
      LOGGER.warning("attachment not uploaded");
      message.setStatus(KonMessage.Status.ERROR);
      return false;
    }

    boolean encrypted =
        message.getCoderStatus().getEncryption() != Coder.Encryption.NOT
            || message.getCoderStatus().getSigning() != Coder.Signing.NOT;

    Chat chat = message.getChat();

    Message protoMessage = encrypted ? new Message() : rawMessage(content, chat, false);

    protoMessage.setType(Message.Type.chat);
    protoMessage.setStanzaId(message.getXMPPID());
    String threadID = chat.getXMPPID();
    if (!threadID.isEmpty()) protoMessage.setThread(threadID);

    // extensions

    // TODO with group chat? (for muc "NOT RECOMMENDED")
    if (!chat.isGroupChat()) protoMessage.addExtension(new DeliveryReceiptRequest());

    if (sendChatState) protoMessage.addExtension(new ChatStateExtension(ChatState.active));

    if (encrypted) {
      byte[] encryptedData =
          content.isComplex() || chat.isGroupChat()
              ? Coder.encryptStanza(message, rawMessage(content, chat, true).toXML().toString())
                  .orElse(null)
              : Coder.encryptMessage(message).orElse(null);
      // check also for security errors just to be sure
      if (encryptedData == null || !message.getCoderStatus().getErrors().isEmpty()) {
        LOGGER.warning("encryption failed");
        message.setStatus(KonMessage.Status.ERROR);
        mControl.handleSecurityErrors(message);
        return false;
      }
      protoMessage.addExtension(new E2EEncryption(encryptedData));
    }

    // transmission specific
    Transmission[] transmissions = message.getTransmissions();
    ArrayList<Message> sendMessages = new ArrayList<>(transmissions.length);
    for (Transmission transmission : message.getTransmissions()) {
      Message sendMessage = protoMessage.clone();
      JID to = transmission.getJID();
      if (!to.isValid()) {
        LOGGER.warning("invalid JID: " + to);
        return false;
      }
      sendMessage.setTo(to.string());
      sendMessages.add(sendMessage);
    }

    return mClient.sendPackets(sendMessages.toArray(new Message[0]));
  }