public void processMessage(Chat chat, Message message) {
if ((message.getBody() != null) && (!message.getType().equals(Message.Type.error))) {
if (!cipher) {
Log.i(TAG, "Recibido mensaje plano: " + message.getBody());
listMessages.add(message);
refreshAdapter();
myListView.smoothScrollToPosition(adapter.getCount() - 1);
} else {
try {
PrivateKey pk =
RSA.getPrivateKeyDecryted(KeyStore.getInstance().getPk(), passPhrase);
String decodedMessage = RSA.decipher(message.getBody(), pk);
Log.i(TAG, "Recibido mensaje cifrado: " + decodedMessage);
Message m = new Message();
m.setFrom(message.getFrom());
m.setTo(message.getTo());
m.setBody(decodedMessage);
SimpleDateFormat sdf = new SimpleDateFormat("HH:mm:ss");
m.setSubject(sdf.format(new Date()));
listMessages.add(m);
refreshAdapter();
myListView.smoothScrollToPosition(adapter.getCount() - 1);
} catch (Exception e) {
Log.d(TAG, "PETO AL DESCIFRAR");
e.printStackTrace();
}
}
}
}
public void addToTranscript(String to, String from, String body, Date date) {
final Message newMessage = new Message();
newMessage.setTo(to);
newMessage.setFrom(from);
newMessage.setBody(body);
newMessage.setProperty("date", date);
transcript.add(newMessage);
}
/**
* 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);
}
/**
* Sends a reply to a previously received packet that was sent to multiple recipients. Before
* attempting to send the reply message some checkings are performed. If any of those checkings
* fail then an XMPPException is going to be thrown with the specific error detail.
*
* @param connection the connection to use to send the reply.
* @param original the previously received packet that was sent to multiple recipients.
* @param reply the new message to send as a reply.
* @throws XMPPException if the original message was not sent to multiple recipients, or the
* original message cannot be replied or reply should be sent to a room.
*/
public static void reply(Connection connection, Message original, Message reply)
throws XMPPException {
MultipleRecipientInfo info = getMultipleRecipientInfo(original);
if (info == null) {
throw new XMPPException("Original message does not contain multiple recipient info");
}
if (info.shouldNotReply()) {
throw new XMPPException("Original message should not be replied");
}
if (info.getReplyRoom() != null) {
throw new XMPPException("Reply should be sent through a room");
}
// Any <thread/> element from the initial message MUST be copied into the reply.
if (original.getThread() != null) {
reply.setThread(original.getThread());
}
MultipleAddresses.Address replyAddress = info.getReplyAddress();
if (replyAddress != null && replyAddress.getJid() != null) {
// Send reply to the reply_to address
reply.setTo(replyAddress.getJid());
connection.sendPacket(reply);
} else {
// Send reply to multiple recipients
List<String> to = new ArrayList<String>();
List<String> cc = new ArrayList<String>();
for (Iterator<MultipleAddresses.Address> it = info.getTOAddresses().iterator();
it.hasNext(); ) {
String jid = it.next().getJid();
to.add(jid);
}
for (Iterator<MultipleAddresses.Address> it = info.getCCAddresses().iterator();
it.hasNext(); ) {
String jid = it.next().getJid();
cc.add(jid);
}
// Add original sender as a 'to' address (if not already present)
if (!to.contains(original.getFrom()) && !cc.contains(original.getFrom())) {
to.add(original.getFrom());
}
// Remove the sender from the TO/CC list (try with bare JID too)
String from = connection.getUser();
if (!to.remove(from) && !cc.remove(from)) {
String bareJID = StringUtils.parseBareAddress(from);
to.remove(bareJID);
cc.remove(bareJID);
}
String serviceAddress = getMultipleRecipienServiceAddress(connection);
if (serviceAddress != null) {
// Send packet to target users using multiple recipient service provided by the server
sendThroughService(connection, reply, to, cc, null, null, null, false, serviceAddress);
} else {
// Server does not support JEP-33 so try to send the packet to each recipient
sendToIndividualRecipients(connection, reply, to, cc, null);
}
}
}
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();
}
/**
* @see net.sf.kraken.session.TransportSession#sendBuzzNotification(org.xmpp.packet.JID, String)
*/
@Override
public void sendBuzzNotification(JID jid, String message) {
Chat chat = conn.getChatManager().createChat(getTransport().convertJIDToID(jid), listener);
try {
Message m = new Message();
m.setTo(getTransport().convertJIDToID(jid));
m.addExtension(new BuzzExtension());
chat.sendMessage(m);
} catch (XMPPException e) {
// Ignore
}
}
public void addToTranscript(Message message, boolean updateDate) {
final Message newMessage = new Message();
newMessage.setTo(message.getTo());
newMessage.setFrom(message.getFrom());
newMessage.setBody(message.getBody());
newMessage.setProperty("date", new Date());
transcript.add(newMessage);
if (updateDate && transcriptWindow.getLastUpdated() != null)
notificationLabel.setText(
"las msg received at "
+ ChatsyManager.DATE_SECOND_FORMATTER.format(transcriptWindow.getLastUpdated()));
scrollToBottom();
}
/** {@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();
}
}
/**
* 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;
}
/**
* 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);
}
}
public void send(View view) {
Message message = new Message(destJid);
EditText editText = (EditText) findViewById(R.id.textInput);
String plainText = editText.getText().toString();
editText.setText("");
message.setFrom(myJid);
message.setTo(destJid);
Message m = new Message();
m.setFrom(myJid);
m.setBody(plainText);
SimpleDateFormat sdf = new SimpleDateFormat("HH:mm:ss");
m.setSubject(sdf.format(new Date()));
listMessages.add(m);
refreshAdapter();
myListView.smoothScrollToPosition(adapter.getCount() - 1);
if (!cipher) {
try {
message.setBody(plainText);
chatMan.getChat().sendMessage(message);
Log.d(TAG, "Enviando: " + message.getBody());
} catch (XMPPException e) {
Log.d(TAG, "ERROR al enviar mensaje");
}
} else {
try {
String encodedMessage = RSA.cipher(plainText, cert.getPublicKey());
message.setBody(encodedMessage);
chatMan.getChat().sendMessage(message);
Log.d(TAG, "Enviando cifrado: " + message.getBody() + " " + plainText);
} catch (Exception e) {
Log.d(TAG, "PETO ENVIANDO CIFRADOOOO");
e.printStackTrace();
}
}
}
/**
* Joining a Core to an Interest Group
*
* @param coreName name of the core to add to the interest group
* @param uuid identifier for the interest group
* @param name human-readable name of the interest group
* @param owningJID JID of the core that owns the interest group
* @return
*/
public static Message sendUpdateToOwner(
String coreName, String uuid, String from, String topic, String contents) {
StringBuffer sb = new StringBuffer();
ArbitraryPacketExtension ext = new ArbitraryPacketExtension(ELEMENT_NAME, NAMESPACE);
Message msg = new Message();
msg.setTo("InterestManager@" + coreName + "/manager");
msg.setFrom(from);
sb.append("<" + ELEMENT_NAME + " xmlns='" + NAMESPACE + "'>");
sb.append("<uuid>" + uuid + "</uuid>");
sb.append("<topic>" + topic + "</topic>");
sb.append("<interestgroupmgmt_content>");
sb.append(contents);
sb.append("</interestgroupmgmt_content>");
sb.append("</" + ELEMENT_NAME + ">");
ext.setXML(sb.toString());
msg.addExtension(ext);
return msg;
}
/**
* 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]));
}