2009-12-17 15:27:57 -05:00
|
|
|
|
/*
|
2010-03-12 14:35:25 -05:00
|
|
|
|
Yaaic - Yet Another Android IRC Client
|
2009-12-17 15:27:57 -05:00
|
|
|
|
|
2012-01-21 17:12:55 -05:00
|
|
|
|
Copyright 2009-2012 Sebastian Kaspari
|
2009-12-17 15:27:57 -05:00
|
|
|
|
|
|
|
|
|
This file is part of Yaaic.
|
|
|
|
|
|
|
|
|
|
Yaaic is free software: you can redistribute it and/or modify
|
|
|
|
|
it under the terms of the GNU General Public License as published by
|
|
|
|
|
the Free Software Foundation, either version 3 of the License, or
|
|
|
|
|
(at your option) any later version.
|
|
|
|
|
|
|
|
|
|
Yaaic is distributed in the hope that it will be useful,
|
|
|
|
|
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
|
|
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
|
|
|
GNU General Public License for more details.
|
|
|
|
|
|
|
|
|
|
You should have received a copy of the GNU General Public License
|
|
|
|
|
along with Yaaic. If not, see <http://www.gnu.org/licenses/>.
|
2010-12-17 16:29:33 -05:00
|
|
|
|
*/
|
2009-12-17 15:27:57 -05:00
|
|
|
|
package org.yaaic.irc;
|
|
|
|
|
|
2010-04-13 16:03:01 -04:00
|
|
|
|
import java.util.ArrayList;
|
2010-04-05 12:21:00 -04:00
|
|
|
|
import java.util.Collection;
|
2010-03-09 15:58:05 -05:00
|
|
|
|
import java.util.Vector;
|
2010-11-16 20:36:52 -05:00
|
|
|
|
import java.util.regex.Pattern;
|
2010-03-09 15:58:05 -05:00
|
|
|
|
|
2009-12-17 15:27:57 -05:00
|
|
|
|
import org.jibble.pircbot.PircBot;
|
2010-03-02 12:42:44 -05:00
|
|
|
|
import org.jibble.pircbot.User;
|
2010-03-06 13:15:27 -05:00
|
|
|
|
import org.yaaic.R;
|
2009-12-17 15:27:57 -05:00
|
|
|
|
import org.yaaic.Yaaic;
|
2010-04-25 06:43:31 -04:00
|
|
|
|
import org.yaaic.command.CommandParser;
|
2009-12-17 15:27:57 -05:00
|
|
|
|
import org.yaaic.model.Broadcast;
|
2010-03-02 13:40:05 -05:00
|
|
|
|
import org.yaaic.model.Channel;
|
2010-03-10 15:34:20 -05:00
|
|
|
|
import org.yaaic.model.Conversation;
|
2010-03-06 11:52:22 -05:00
|
|
|
|
import org.yaaic.model.Message;
|
2010-03-10 15:34:20 -05:00
|
|
|
|
import org.yaaic.model.Query;
|
2009-12-17 15:27:57 -05:00
|
|
|
|
import org.yaaic.model.Server;
|
2010-03-10 17:06:40 -05:00
|
|
|
|
import org.yaaic.model.ServerInfo;
|
2009-12-17 15:27:57 -05:00
|
|
|
|
import org.yaaic.model.Status;
|
|
|
|
|
|
2010-12-17 16:29:33 -05:00
|
|
|
|
import android.content.Intent;
|
|
|
|
|
|
2010-03-17 14:38:58 -04:00
|
|
|
|
/**
|
|
|
|
|
* The class that actually handles the connection to an IRC server
|
|
|
|
|
*
|
|
|
|
|
* @author Sebastian Kaspari <sebastian@yaaic.org>
|
|
|
|
|
*/
|
2009-12-17 15:27:57 -05:00
|
|
|
|
public class IRCConnection extends PircBot
|
|
|
|
|
{
|
2010-12-17 16:29:33 -05:00
|
|
|
|
private final IRCService service;
|
|
|
|
|
private final Server server;
|
2010-11-18 12:52:19 -05:00
|
|
|
|
private ArrayList<String> autojoinChannels;
|
|
|
|
|
private Pattern mNickMatch;
|
2010-12-17 16:29:33 -05:00
|
|
|
|
|
2011-06-15 20:14:09 -04:00
|
|
|
|
private boolean ignoreMOTD = true;
|
|
|
|
|
|
Prevent race between IRCConnection dispose() and onDisconnect() when quitting
When the user asks for a disconnect from the ConversationActivity, there
is a race between the IRCConnection, which is waiting for the server to
acknowledge the QUIT before calling onDisconnect(), and the IRCService,
which will invoke dispose() on the IRCConnection when
checkServiceStatus() is called during the activity shutdown. If the
dispose() wins, the thread running the onDisconnect() is terminated,
leading to the cleanup being unfinished. This causes the disconnect
notification to be unreliable, and can result in the list of servers in
the ongoing notification to be out of sync with reality.
To fix this, introduce a new field isQuitting to the IRCConnection,
which is set to true when quitServer() is called and cleared once
onDisconnect() has finished. If dispose() is called while isQuitting is
set, it sets disposeRequested instead of doing the dispose itself, and
onDisconnect() will call through to super.dispose() once it's finished.
Note that this requires a change to PircBot to allow the overriding of
quitServer(String message), which is declared final upstream.
2011-06-05 05:29:04 -04:00
|
|
|
|
private boolean isQuitting = false;
|
|
|
|
|
private boolean disposeRequested = false;
|
2011-06-10 15:36:14 -04:00
|
|
|
|
private final Object isQuittingLock = new Object();
|
Prevent race between IRCConnection dispose() and onDisconnect() when quitting
When the user asks for a disconnect from the ConversationActivity, there
is a race between the IRCConnection, which is waiting for the server to
acknowledge the QUIT before calling onDisconnect(), and the IRCService,
which will invoke dispose() on the IRCConnection when
checkServiceStatus() is called during the activity shutdown. If the
dispose() wins, the thread running the onDisconnect() is terminated,
leading to the cleanup being unfinished. This causes the disconnect
notification to be unreliable, and can result in the list of servers in
the ongoing notification to be out of sync with reality.
To fix this, introduce a new field isQuitting to the IRCConnection,
which is set to true when quitServer() is called and cleared once
onDisconnect() has finished. If dispose() is called while isQuitting is
set, it sets disposeRequested instead of doing the dispose itself, and
onDisconnect() will call through to super.dispose() once it's finished.
Note that this requires a change to PircBot to allow the overriding of
quitServer(String message), which is declared final upstream.
2011-06-05 05:29:04 -04:00
|
|
|
|
|
2010-11-18 12:52:19 -05:00
|
|
|
|
/**
|
|
|
|
|
* Create a new connection
|
|
|
|
|
*
|
|
|
|
|
* @param service
|
|
|
|
|
* @param serverId
|
|
|
|
|
*/
|
|
|
|
|
public IRCConnection(IRCService service, int serverId)
|
|
|
|
|
{
|
|
|
|
|
this.server = Yaaic.getInstance().getServerById(serverId);
|
|
|
|
|
this.service = service;
|
2010-12-17 16:29:33 -05:00
|
|
|
|
|
2010-11-18 12:52:19 -05:00
|
|
|
|
// XXX: Should be configurable via settings
|
|
|
|
|
this.setAutoNickChange(true);
|
2010-12-17 16:29:33 -05:00
|
|
|
|
|
2010-11-18 12:52:19 -05:00
|
|
|
|
this.setFinger("http://www.youtube.com/watch?v=oHg5SJYRHA0");
|
|
|
|
|
this.updateNickMatchPattern();
|
|
|
|
|
}
|
2010-12-17 16:29:33 -05:00
|
|
|
|
|
2010-11-18 12:52:19 -05:00
|
|
|
|
/**
|
|
|
|
|
* Set the nickname of the user
|
|
|
|
|
*
|
|
|
|
|
* @param nickname The nickname to use
|
|
|
|
|
*/
|
|
|
|
|
public void setNickname(String nickname)
|
|
|
|
|
{
|
|
|
|
|
this.setName(nickname);
|
|
|
|
|
this.updateNickMatchPattern();
|
|
|
|
|
}
|
2010-12-17 16:29:33 -05:00
|
|
|
|
|
2010-11-18 12:52:19 -05:00
|
|
|
|
/**
|
|
|
|
|
* Set the real name of the user
|
|
|
|
|
*
|
|
|
|
|
* @param realname The realname to use
|
|
|
|
|
*/
|
|
|
|
|
public void setRealName(String realname)
|
|
|
|
|
{
|
|
|
|
|
// XXX: Pircbot uses the version for "real name" and "version".
|
2010-12-17 16:29:33 -05:00
|
|
|
|
// The real "version" value is provided by onVersion()
|
2010-11-18 12:52:19 -05:00
|
|
|
|
this.setVersion(realname);
|
|
|
|
|
}
|
2010-12-17 16:29:33 -05:00
|
|
|
|
|
2010-11-18 12:52:19 -05:00
|
|
|
|
/**
|
|
|
|
|
* Set channels to autojoin after connect
|
|
|
|
|
*
|
|
|
|
|
* @param channels
|
|
|
|
|
*/
|
|
|
|
|
public void setAutojoinChannels(ArrayList<String> channels)
|
|
|
|
|
{
|
|
|
|
|
autojoinChannels = channels;
|
|
|
|
|
}
|
2010-03-13 09:17:32 -05:00
|
|
|
|
|
2010-11-18 12:52:19 -05:00
|
|
|
|
/**
|
|
|
|
|
* On version (CTCP version)
|
|
|
|
|
*
|
|
|
|
|
* This is a fix for pircbot as pircbot uses the version as "real name" and as "version"
|
|
|
|
|
*/
|
|
|
|
|
@Override
|
|
|
|
|
protected void onVersion(String sourceNick, String sourceLogin, String sourceHostname, String target)
|
|
|
|
|
{
|
|
|
|
|
this.sendRawLine(
|
2010-12-17 16:29:33 -05:00
|
|
|
|
"NOTICE " + sourceNick + " :\u0001VERSION " +
|
2012-09-27 06:17:17 -04:00
|
|
|
|
"Yaaic - Yet Another Android IRC Client - http://www.yaaic.org" +
|
2010-12-17 16:29:33 -05:00
|
|
|
|
"\u0001"
|
2010-11-18 12:52:19 -05:00
|
|
|
|
);
|
|
|
|
|
}
|
2010-03-13 08:58:01 -05:00
|
|
|
|
|
2010-11-18 12:52:19 -05:00
|
|
|
|
/**
|
|
|
|
|
* Set the ident of the user
|
|
|
|
|
*
|
|
|
|
|
* @param ident The ident to use
|
|
|
|
|
*/
|
|
|
|
|
public void setIdent(String ident)
|
|
|
|
|
{
|
|
|
|
|
this.setLogin(ident);
|
|
|
|
|
}
|
2009-12-17 15:27:57 -05:00
|
|
|
|
|
2010-11-18 12:52:19 -05:00
|
|
|
|
/**
|
|
|
|
|
* On connect
|
|
|
|
|
*/
|
|
|
|
|
@Override
|
|
|
|
|
public void onConnect()
|
|
|
|
|
{
|
|
|
|
|
server.setStatus(Status.CONNECTED);
|
2011-06-15 20:14:09 -04:00
|
|
|
|
|
Make reconnections actually work
At the moment, the reconnect feature is somewhat glitchy, popping up
multiple reconnect prompts even if a reconnection succeeds, and
occasionally causing crashes. A successful reconnection results in the
conversation history being cleared, which is an annoying outcome when
connected over an unreliable network.
This patch does the following:
* Keep track of whether a reconnect dialog is active, to prevent
multiple dialogs from opening.
* Introduce a new field to the Server object, mayReconnect, which is
used to keep track of whether a reconnection should be attempted in
the event of a disconnection. It's set to "true" when we connect to a
server, and "false" if the user asks for a disconnection.
* Prevent the clearing of active conversations and conversation history
on disconnect, unless the user specifically asked for the disconnect.
* Keep the IRCService running even when no servers are connected, unless
the user has disconnected from all servers herself. This is needed
for reliable auto-reconnects (see next patch), but has the side effect
of keeping conversation history around even if the activity isn't open
when a disconnect happens.
2011-06-29 04:19:02 -04:00
|
|
|
|
server.setMayReconnect(true);
|
2010-12-17 16:29:33 -05:00
|
|
|
|
|
2011-06-15 20:14:09 -04:00
|
|
|
|
ignoreMOTD = service.getSettings().isIgnoreMOTDEnabled();
|
|
|
|
|
|
2010-11-18 12:52:19 -05:00
|
|
|
|
service.sendBroadcast(
|
|
|
|
|
Broadcast.createServerIntent(Broadcast.SERVER_UPDATE, server.getId())
|
|
|
|
|
);
|
2010-12-17 16:29:33 -05:00
|
|
|
|
|
2011-05-29 20:49:07 -04:00
|
|
|
|
service.notifyConnected(server.getTitle());
|
2010-12-17 16:29:33 -05:00
|
|
|
|
|
2010-11-18 12:52:19 -05:00
|
|
|
|
Message message = new Message(service.getString(R.string.message_connected, server.getTitle()));
|
|
|
|
|
message.setColor(Message.COLOR_GREEN);
|
|
|
|
|
server.getConversation(ServerInfo.DEFAULT_NAME).addMessage(message);
|
2010-12-17 16:29:33 -05:00
|
|
|
|
|
2011-06-10 16:29:17 -04:00
|
|
|
|
Message infoMessage = new Message(service.getString(R.string.message_now_login));
|
|
|
|
|
infoMessage.setColor(Message.COLOR_GREY);
|
|
|
|
|
server.getConversation(ServerInfo.DEFAULT_NAME).addMessage(infoMessage);
|
|
|
|
|
|
2010-11-18 12:52:19 -05:00
|
|
|
|
Intent intent = Broadcast.createConversationIntent(
|
|
|
|
|
Broadcast.CONVERSATION_MESSAGE,
|
|
|
|
|
server.getId(),
|
|
|
|
|
ServerInfo.DEFAULT_NAME
|
|
|
|
|
);
|
2010-12-17 16:29:33 -05:00
|
|
|
|
|
2011-06-10 15:36:14 -04:00
|
|
|
|
if (server.getAuthentication().hasNickservCredentials()) {
|
|
|
|
|
identify(server.getAuthentication().getNickservPassword());
|
|
|
|
|
}
|
|
|
|
|
|
2010-11-18 12:52:19 -05:00
|
|
|
|
service.sendBroadcast(intent);
|
2011-03-07 21:07:07 -05:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
|
* On register
|
|
|
|
|
*/
|
2011-04-12 16:23:51 -04:00
|
|
|
|
@Override
|
2011-03-07 21:07:07 -05:00
|
|
|
|
public void onRegister()
|
|
|
|
|
{
|
2011-04-12 16:23:51 -04:00
|
|
|
|
// Call parent method to ensure "register" status is tracked
|
|
|
|
|
super.onRegister();
|
|
|
|
|
|
2010-11-18 12:52:19 -05:00
|
|
|
|
// execute commands
|
|
|
|
|
CommandParser parser = CommandParser.getInstance();
|
2010-12-17 16:29:33 -05:00
|
|
|
|
|
2010-11-18 12:52:19 -05:00
|
|
|
|
this.updateNickMatchPattern();
|
|
|
|
|
for (String command : server.getConnectCommands()) {
|
|
|
|
|
parser.parse(command, server, server.getConversation(ServerInfo.DEFAULT_NAME), service);
|
|
|
|
|
}
|
2010-12-17 16:29:33 -05:00
|
|
|
|
|
2011-03-07 21:07:07 -05:00
|
|
|
|
// TODO: Detect "You are now identified for <nick>" notices from NickServ and handle
|
|
|
|
|
// auto joins in onNotice instead if the user has chosen to wait for NickServ
|
|
|
|
|
// identification before auto joining channels.
|
|
|
|
|
|
2010-11-18 12:52:19 -05:00
|
|
|
|
// delay 1 sec before auto joining channels
|
|
|
|
|
try {
|
|
|
|
|
Thread.sleep(1000);
|
|
|
|
|
} catch(InterruptedException e) {
|
|
|
|
|
// do nothing
|
|
|
|
|
}
|
2010-12-17 16:29:33 -05:00
|
|
|
|
|
2010-11-18 12:52:19 -05:00
|
|
|
|
// join channels
|
|
|
|
|
if (autojoinChannels != null) {
|
|
|
|
|
for (String channel : autojoinChannels) {
|
|
|
|
|
// Add support for channel keys
|
|
|
|
|
joinChannel(channel);
|
|
|
|
|
}
|
|
|
|
|
} else {
|
|
|
|
|
for (String channel : server.getAutoJoinChannels()) {
|
|
|
|
|
joinChannel(channel);
|
|
|
|
|
}
|
|
|
|
|
}
|
2011-06-10 16:29:17 -04:00
|
|
|
|
|
|
|
|
|
Message infoMessage = new Message(service.getString(R.string.message_login_done));
|
|
|
|
|
infoMessage.setColor(Message.COLOR_GREY);
|
|
|
|
|
server.getConversation(ServerInfo.DEFAULT_NAME).addMessage(infoMessage);
|
|
|
|
|
|
|
|
|
|
Intent intent = Broadcast.createConversationIntent(
|
|
|
|
|
Broadcast.CONVERSATION_MESSAGE,
|
|
|
|
|
server.getId(),
|
|
|
|
|
ServerInfo.DEFAULT_NAME
|
|
|
|
|
);
|
|
|
|
|
|
|
|
|
|
service.sendBroadcast(intent);
|
2010-11-18 12:52:19 -05:00
|
|
|
|
}
|
|
|
|
|
/**
|
|
|
|
|
* On channel action
|
|
|
|
|
*/
|
|
|
|
|
@Override
|
|
|
|
|
protected void onAction(String sender, String login, String hostname, String target, String action)
|
|
|
|
|
{
|
2011-05-29 20:48:47 -04:00
|
|
|
|
Conversation conversation;
|
|
|
|
|
|
2010-11-18 12:52:19 -05:00
|
|
|
|
Message message = new Message(sender + " " + action);
|
|
|
|
|
message.setIcon(R.drawable.action);
|
2010-12-17 16:29:33 -05:00
|
|
|
|
|
2011-05-29 20:49:01 -04:00
|
|
|
|
String queryNick = target;
|
|
|
|
|
if (queryNick.equals(this.getNick())) {
|
2010-11-18 12:52:19 -05:00
|
|
|
|
// We are the target - this is an action in a query
|
2011-05-29 20:49:01 -04:00
|
|
|
|
queryNick = sender;
|
|
|
|
|
}
|
|
|
|
|
conversation = server.getConversation(queryNick);
|
|
|
|
|
|
|
|
|
|
if (conversation == null) {
|
|
|
|
|
// Open a query if there's none yet
|
|
|
|
|
conversation = new Query(queryNick);
|
2011-05-29 20:49:49 -04:00
|
|
|
|
conversation.setHistorySize(service.getSettings().getHistorySize());
|
2011-05-29 20:49:01 -04:00
|
|
|
|
server.addConversation(conversation);
|
|
|
|
|
conversation.addMessage(message);
|
|
|
|
|
|
|
|
|
|
Intent intent = Broadcast.createConversationIntent(
|
|
|
|
|
Broadcast.CONVERSATION_NEW,
|
|
|
|
|
server.getId(),
|
|
|
|
|
queryNick
|
|
|
|
|
);
|
|
|
|
|
service.sendBroadcast(intent);
|
2010-11-18 12:52:19 -05:00
|
|
|
|
} else {
|
2011-05-29 20:48:47 -04:00
|
|
|
|
conversation.addMessage(message);
|
2010-12-17 16:29:33 -05:00
|
|
|
|
|
2010-11-18 12:52:19 -05:00
|
|
|
|
Intent intent = Broadcast.createConversationIntent(
|
|
|
|
|
Broadcast.CONVERSATION_MESSAGE,
|
|
|
|
|
server.getId(),
|
2011-05-29 20:49:01 -04:00
|
|
|
|
queryNick
|
2010-11-18 12:52:19 -05:00
|
|
|
|
);
|
|
|
|
|
service.sendBroadcast(intent);
|
|
|
|
|
}
|
2011-05-29 20:48:47 -04:00
|
|
|
|
|
2011-05-29 20:49:01 -04:00
|
|
|
|
if (sender.equals(this.getNick())) {
|
2011-06-10 15:36:14 -04:00
|
|
|
|
// Don't notify for something sent in our name
|
|
|
|
|
return;
|
2011-05-29 20:49:01 -04:00
|
|
|
|
}
|
|
|
|
|
|
2011-05-29 20:48:57 -04:00
|
|
|
|
boolean mentioned = isMentioned(action);
|
|
|
|
|
if (mentioned || target.equals(this.getNick())) {
|
2011-05-29 20:49:07 -04:00
|
|
|
|
if (conversation.getStatus() != Conversation.STATUS_SELECTED || !server.getIsForeground()) {
|
|
|
|
|
service.addNewMention(
|
2011-06-05 05:33:25 -04:00
|
|
|
|
server.getId(),
|
2011-05-29 20:49:07 -04:00
|
|
|
|
conversation,
|
|
|
|
|
conversation.getName() + ": " + sender + " " + action,
|
|
|
|
|
service.getSettings().isVibrateHighlightEnabled(),
|
|
|
|
|
service.getSettings().isSoundHighlightEnabled()
|
|
|
|
|
);
|
|
|
|
|
}
|
2011-05-29 20:48:57 -04:00
|
|
|
|
}
|
2011-05-29 20:48:47 -04:00
|
|
|
|
|
2011-05-29 20:48:57 -04:00
|
|
|
|
if (mentioned) {
|
|
|
|
|
// highlight
|
|
|
|
|
message.setColor(Message.COLOR_RED);
|
2011-05-29 20:48:47 -04:00
|
|
|
|
conversation.setStatus(Conversation.STATUS_HIGHLIGHT);
|
|
|
|
|
}
|
2010-11-18 12:52:19 -05:00
|
|
|
|
}
|
2010-03-02 12:42:44 -05:00
|
|
|
|
|
2010-11-18 12:52:19 -05:00
|
|
|
|
/**
|
|
|
|
|
* On Channel Info
|
|
|
|
|
*/
|
|
|
|
|
@Override
|
|
|
|
|
protected void onChannelInfo(String channel, int userCount, String topic)
|
|
|
|
|
{
|
|
|
|
|
}
|
2010-03-02 12:42:44 -05:00
|
|
|
|
|
2010-11-18 12:52:19 -05:00
|
|
|
|
/**
|
|
|
|
|
* On Deop
|
|
|
|
|
*/
|
|
|
|
|
@Override
|
|
|
|
|
protected void onDeop(String target, String sourceNick, String sourceLogin, String sourceHostname, String recipient)
|
|
|
|
|
{
|
|
|
|
|
Message message = new Message(service.getString(R.string.message_deop, sourceNick, recipient));
|
|
|
|
|
message.setIcon(R.drawable.op);
|
|
|
|
|
message.setColor(Message.COLOR_BLUE);
|
|
|
|
|
server.getConversation(target).addMessage(message);
|
2010-12-17 16:29:33 -05:00
|
|
|
|
|
2010-11-18 12:52:19 -05:00
|
|
|
|
Intent intent = Broadcast.createConversationIntent(
|
|
|
|
|
Broadcast.CONVERSATION_MESSAGE,
|
|
|
|
|
server.getId(),
|
|
|
|
|
target
|
|
|
|
|
);
|
2010-03-24 14:46:49 -04:00
|
|
|
|
|
2010-11-18 12:52:19 -05:00
|
|
|
|
service.sendBroadcast(intent);
|
|
|
|
|
}
|
2010-03-02 12:42:44 -05:00
|
|
|
|
|
2010-11-18 12:52:19 -05:00
|
|
|
|
/**
|
|
|
|
|
* On DeVoice
|
|
|
|
|
*/
|
|
|
|
|
@Override
|
|
|
|
|
protected void onDeVoice(String target, String sourceNick, String sourceLogin, String sourceHostname, String recipient)
|
|
|
|
|
{
|
|
|
|
|
Message message = new Message(service.getString(R.string.message_devoice, sourceNick, recipient));
|
|
|
|
|
message.setColor(Message.COLOR_BLUE);
|
|
|
|
|
message.setIcon(R.drawable.voice);
|
|
|
|
|
server.getConversation(target).addMessage(message);
|
2010-12-17 16:29:33 -05:00
|
|
|
|
|
2010-11-18 12:52:19 -05:00
|
|
|
|
Intent intent = Broadcast.createConversationIntent(
|
|
|
|
|
Broadcast.CONVERSATION_MESSAGE,
|
|
|
|
|
server.getId(),
|
|
|
|
|
target
|
|
|
|
|
);
|
2010-12-17 16:29:33 -05:00
|
|
|
|
|
2010-11-18 12:52:19 -05:00
|
|
|
|
service.sendBroadcast(intent);
|
|
|
|
|
}
|
2010-03-02 12:42:44 -05:00
|
|
|
|
|
2010-11-18 12:52:19 -05:00
|
|
|
|
/**
|
|
|
|
|
* On Invite
|
|
|
|
|
*/
|
|
|
|
|
@Override
|
|
|
|
|
protected void onInvite(String targetNick, String sourceNick, String sourceLogin, String sourceHostname, String target)
|
|
|
|
|
{
|
|
|
|
|
if (targetNick.equals(this.getNick())) {
|
|
|
|
|
// We are invited
|
|
|
|
|
Message message = new Message(service.getString(R.string.message_invite_you, sourceNick, target));
|
|
|
|
|
server.getConversation(server.getSelectedConversation()).addMessage(message);
|
2010-12-17 16:29:33 -05:00
|
|
|
|
|
2010-11-18 12:52:19 -05:00
|
|
|
|
Intent intent = Broadcast.createConversationIntent(
|
|
|
|
|
Broadcast.CONVERSATION_MESSAGE,
|
|
|
|
|
server.getId(),
|
|
|
|
|
server.getSelectedConversation()
|
|
|
|
|
);
|
|
|
|
|
service.sendBroadcast(intent);
|
|
|
|
|
} else {
|
|
|
|
|
// Someone is invited
|
|
|
|
|
Message message = new Message(service.getString(R.string.message_invite_someone, sourceNick, targetNick, target));
|
|
|
|
|
server.getConversation(target).addMessage(message);
|
2010-12-17 16:29:33 -05:00
|
|
|
|
|
2010-11-18 12:52:19 -05:00
|
|
|
|
Intent intent = Broadcast.createConversationIntent(
|
|
|
|
|
Broadcast.CONVERSATION_MESSAGE,
|
|
|
|
|
server.getId(),
|
|
|
|
|
target
|
|
|
|
|
);
|
|
|
|
|
service.sendBroadcast(intent);
|
|
|
|
|
}
|
|
|
|
|
}
|
2010-03-02 12:42:44 -05:00
|
|
|
|
|
2010-11-18 12:52:19 -05:00
|
|
|
|
/**
|
|
|
|
|
* On Join
|
|
|
|
|
*/
|
|
|
|
|
@Override
|
|
|
|
|
protected void onJoin(String target, String sender, String login, String hostname)
|
|
|
|
|
{
|
Make reconnections actually work
At the moment, the reconnect feature is somewhat glitchy, popping up
multiple reconnect prompts even if a reconnection succeeds, and
occasionally causing crashes. A successful reconnection results in the
conversation history being cleared, which is an annoying outcome when
connected over an unreliable network.
This patch does the following:
* Keep track of whether a reconnect dialog is active, to prevent
multiple dialogs from opening.
* Introduce a new field to the Server object, mayReconnect, which is
used to keep track of whether a reconnection should be attempted in
the event of a disconnection. It's set to "true" when we connect to a
server, and "false" if the user asks for a disconnection.
* Prevent the clearing of active conversations and conversation history
on disconnect, unless the user specifically asked for the disconnect.
* Keep the IRCService running even when no servers are connected, unless
the user has disconnected from all servers herself. This is needed
for reliable auto-reconnects (see next patch), but has the side effect
of keeping conversation history around even if the activity isn't open
when a disconnect happens.
2011-06-29 04:19:02 -04:00
|
|
|
|
if (sender.equalsIgnoreCase(getNick()) && server.getConversation(target) == null) {
|
2010-11-18 12:52:19 -05:00
|
|
|
|
// We joined a new channel
|
2011-05-29 20:49:49 -04:00
|
|
|
|
Conversation conversation = new Channel(target);
|
|
|
|
|
conversation.setHistorySize(service.getSettings().getHistorySize());
|
|
|
|
|
server.addConversation(conversation);
|
2010-12-17 16:29:33 -05:00
|
|
|
|
|
2010-11-18 12:52:19 -05:00
|
|
|
|
Intent intent = Broadcast.createConversationIntent(
|
|
|
|
|
Broadcast.CONVERSATION_NEW,
|
|
|
|
|
server.getId(),
|
|
|
|
|
target
|
|
|
|
|
);
|
|
|
|
|
service.sendBroadcast(intent);
|
2011-03-15 15:42:35 -04:00
|
|
|
|
} else if (service.getSettings().showJoinPartAndQuit()) {
|
2011-03-15 15:12:12 -04:00
|
|
|
|
Message message = new Message(
|
|
|
|
|
service.getString(R.string.message_join, sender),
|
|
|
|
|
Message.TYPE_MISC
|
|
|
|
|
);
|
|
|
|
|
|
2010-11-18 12:52:19 -05:00
|
|
|
|
message.setIcon(R.drawable.join);
|
|
|
|
|
message.setColor(Message.COLOR_GREEN);
|
|
|
|
|
server.getConversation(target).addMessage(message);
|
2010-12-17 16:29:33 -05:00
|
|
|
|
|
2010-11-18 12:52:19 -05:00
|
|
|
|
Intent intent = Broadcast.createConversationIntent(
|
|
|
|
|
Broadcast.CONVERSATION_MESSAGE,
|
|
|
|
|
server.getId(),
|
|
|
|
|
target
|
|
|
|
|
);
|
|
|
|
|
service.sendBroadcast(intent);
|
|
|
|
|
}
|
|
|
|
|
}
|
2010-03-02 12:42:44 -05:00
|
|
|
|
|
2010-11-18 12:52:19 -05:00
|
|
|
|
/**
|
|
|
|
|
* On Kick
|
|
|
|
|
*/
|
|
|
|
|
@Override
|
|
|
|
|
protected void onKick(String target, String kickerNick, String kickerLogin, String kickerHostname, String recipientNick, String reason)
|
|
|
|
|
{
|
|
|
|
|
if (recipientNick.equals(getNick())) {
|
|
|
|
|
// We are kicked
|
2011-07-03 05:18:17 -04:00
|
|
|
|
service.ackNewMentions(server.getId(), target);
|
2010-11-18 12:52:19 -05:00
|
|
|
|
server.removeConversation(target);
|
2010-12-17 16:29:33 -05:00
|
|
|
|
|
2010-11-18 12:52:19 -05:00
|
|
|
|
Intent intent = Broadcast.createConversationIntent(
|
|
|
|
|
Broadcast.CONVERSATION_REMOVE,
|
|
|
|
|
server.getId(),
|
|
|
|
|
target
|
|
|
|
|
);
|
|
|
|
|
service.sendBroadcast(intent);
|
|
|
|
|
} else {
|
|
|
|
|
Message message = new Message(service.getString(R.string.message_kick, kickerNick, recipientNick));
|
|
|
|
|
message.setColor(Message.COLOR_GREEN);
|
|
|
|
|
server.getConversation(target).addMessage(message);
|
2010-03-02 14:28:32 -05:00
|
|
|
|
|
2010-11-18 12:52:19 -05:00
|
|
|
|
Intent intent = Broadcast.createConversationIntent(
|
|
|
|
|
Broadcast.CONVERSATION_MESSAGE,
|
|
|
|
|
server.getId(),
|
|
|
|
|
target
|
|
|
|
|
);
|
2010-12-17 16:29:33 -05:00
|
|
|
|
service.sendBroadcast(intent);
|
2010-11-18 12:52:19 -05:00
|
|
|
|
}
|
|
|
|
|
}
|
2010-03-02 12:42:44 -05:00
|
|
|
|
|
2010-11-18 12:52:19 -05:00
|
|
|
|
/**
|
|
|
|
|
* On Message
|
|
|
|
|
*/
|
|
|
|
|
@Override
|
|
|
|
|
protected void onMessage(String target, String sender, String login, String hostname, String text)
|
|
|
|
|
{
|
|
|
|
|
Message message = new Message(text, sender);
|
2011-05-29 20:49:07 -04:00
|
|
|
|
Conversation conversation = server.getConversation(target);
|
2010-12-17 16:29:33 -05:00
|
|
|
|
|
2010-11-18 12:52:19 -05:00
|
|
|
|
if (isMentioned(text)) {
|
|
|
|
|
// highlight
|
|
|
|
|
message.setColor(Message.COLOR_RED);
|
2011-05-29 20:49:07 -04:00
|
|
|
|
if (conversation.getStatus() != Conversation.STATUS_SELECTED || !server.getIsForeground()) {
|
|
|
|
|
service.addNewMention(
|
2011-06-05 05:33:25 -04:00
|
|
|
|
server.getId(),
|
2011-05-29 20:49:07 -04:00
|
|
|
|
conversation,
|
|
|
|
|
target + ": <" + sender + "> " + text,
|
|
|
|
|
service.getSettings().isVibrateHighlightEnabled(),
|
|
|
|
|
service.getSettings().isSoundHighlightEnabled()
|
|
|
|
|
);
|
|
|
|
|
}
|
2010-12-17 16:29:33 -05:00
|
|
|
|
|
2011-05-29 20:49:07 -04:00
|
|
|
|
conversation.setStatus(Conversation.STATUS_HIGHLIGHT);
|
2010-11-18 12:52:19 -05:00
|
|
|
|
}
|
2010-12-17 16:29:33 -05:00
|
|
|
|
|
2011-05-29 20:49:07 -04:00
|
|
|
|
conversation.addMessage(message);
|
2010-12-17 16:29:33 -05:00
|
|
|
|
|
2010-11-18 12:52:19 -05:00
|
|
|
|
Intent intent = Broadcast.createConversationIntent(
|
|
|
|
|
Broadcast.CONVERSATION_MESSAGE,
|
|
|
|
|
server.getId(),
|
|
|
|
|
target
|
|
|
|
|
);
|
|
|
|
|
service.sendBroadcast(intent);
|
|
|
|
|
}
|
2010-03-02 12:42:44 -05:00
|
|
|
|
|
2010-11-18 12:52:19 -05:00
|
|
|
|
/**
|
|
|
|
|
* On Mode
|
|
|
|
|
*/
|
|
|
|
|
@Override
|
|
|
|
|
protected void onMode(String target, String sourceNick, String sourceLogin, String sourceHostname, String mode)
|
|
|
|
|
{
|
2011-03-14 17:15:13 -04:00
|
|
|
|
// Disabled as it doubles events (e.g. onOp and onMode will be called)
|
|
|
|
|
|
|
|
|
|
/*
|
2010-11-18 12:52:19 -05:00
|
|
|
|
Message message = new Message(sourceNick + " sets mode " + mode);
|
|
|
|
|
server.getChannel(target).addMessage(message);
|
2010-12-17 16:29:33 -05:00
|
|
|
|
|
2010-11-18 12:52:19 -05:00
|
|
|
|
Intent intent = new Intent(Broadcast.CHANNEL_MESSAGE);
|
|
|
|
|
intent.putExtra(Broadcast.EXTRA_SERVER, server.getId());
|
|
|
|
|
intent.putExtra(Broadcast.EXTRA_CHANNEL, target);
|
|
|
|
|
service.sendBroadcast(intent);
|
2010-12-17 16:29:33 -05:00
|
|
|
|
*/
|
2010-11-18 12:52:19 -05:00
|
|
|
|
}
|
2010-03-02 12:42:44 -05:00
|
|
|
|
|
2010-11-18 12:52:19 -05:00
|
|
|
|
/**
|
|
|
|
|
* On Nick Change
|
|
|
|
|
*/
|
|
|
|
|
@Override
|
|
|
|
|
protected void onNickChange(String oldNick, String login, String hostname, String newNick)
|
2010-12-17 16:29:33 -05:00
|
|
|
|
{
|
2010-11-18 12:52:19 -05:00
|
|
|
|
if (getNick().equalsIgnoreCase(newNick)) {
|
|
|
|
|
this.updateNickMatchPattern();
|
2011-04-15 14:30:41 -04:00
|
|
|
|
|
|
|
|
|
// Send message about own change to server info window
|
|
|
|
|
Message message = new Message(service.getString(R.string.message_self_rename, newNick));
|
|
|
|
|
message.setColor(Message.COLOR_GREEN);
|
|
|
|
|
server.getConversation(ServerInfo.DEFAULT_NAME).addMessage(message);
|
|
|
|
|
|
|
|
|
|
Intent intent = Broadcast.createConversationIntent(
|
|
|
|
|
Broadcast.CONVERSATION_MESSAGE,
|
|
|
|
|
server.getId(),
|
|
|
|
|
ServerInfo.DEFAULT_NAME
|
|
|
|
|
);
|
|
|
|
|
|
|
|
|
|
service.sendBroadcast(intent);
|
2010-11-18 12:52:19 -05:00
|
|
|
|
}
|
2011-03-14 17:15:13 -04:00
|
|
|
|
|
2010-11-18 12:52:19 -05:00
|
|
|
|
Vector<String> channels = getChannelsByNickname(newNick);
|
2010-12-17 16:29:33 -05:00
|
|
|
|
|
2010-11-18 12:52:19 -05:00
|
|
|
|
for (String target : channels) {
|
|
|
|
|
Message message = new Message(service.getString(R.string.message_rename, oldNick, newNick));
|
|
|
|
|
message.setColor(Message.COLOR_GREEN);
|
|
|
|
|
server.getConversation(target).addMessage(message);
|
2010-12-17 16:29:33 -05:00
|
|
|
|
|
2010-11-18 12:52:19 -05:00
|
|
|
|
Intent intent = Broadcast.createConversationIntent(
|
|
|
|
|
Broadcast.CONVERSATION_MESSAGE,
|
|
|
|
|
server.getId(),
|
|
|
|
|
target
|
|
|
|
|
);
|
|
|
|
|
service.sendBroadcast(intent);
|
|
|
|
|
}
|
|
|
|
|
}
|
2010-03-02 12:42:44 -05:00
|
|
|
|
|
2010-11-18 12:52:19 -05:00
|
|
|
|
/**
|
|
|
|
|
* On Notice
|
|
|
|
|
*/
|
|
|
|
|
@Override
|
|
|
|
|
protected void onNotice(String sourceNick, String sourceLogin, String sourceHostname, String target, String notice)
|
|
|
|
|
{
|
|
|
|
|
// Post notice to currently selected conversation
|
2011-03-15 15:53:47 -04:00
|
|
|
|
Conversation conversation;
|
2010-12-17 16:29:33 -05:00
|
|
|
|
|
2011-03-15 15:53:47 -04:00
|
|
|
|
if (service.getSettings().showNoticeInServerWindow()) {
|
2010-11-18 12:52:19 -05:00
|
|
|
|
conversation = server.getConversation(ServerInfo.DEFAULT_NAME);
|
2011-03-15 15:53:47 -04:00
|
|
|
|
} else {
|
|
|
|
|
conversation = server.getConversation(server.getSelectedConversation());
|
|
|
|
|
|
|
|
|
|
if (conversation == null) {
|
|
|
|
|
// Fallback: Use ServerInfo view
|
|
|
|
|
conversation = server.getConversation(ServerInfo.DEFAULT_NAME);
|
|
|
|
|
}
|
2010-11-18 12:52:19 -05:00
|
|
|
|
}
|
2010-03-10 17:06:40 -05:00
|
|
|
|
|
2010-11-18 12:52:19 -05:00
|
|
|
|
Message message = new Message("-" + sourceNick + "- " + notice);
|
|
|
|
|
message.setIcon(R.drawable.info);
|
|
|
|
|
conversation.addMessage(message);
|
2010-12-17 16:29:33 -05:00
|
|
|
|
|
2010-11-18 12:52:19 -05:00
|
|
|
|
Intent intent = Broadcast.createConversationIntent(
|
|
|
|
|
Broadcast.CONVERSATION_MESSAGE,
|
|
|
|
|
server.getId(),
|
|
|
|
|
conversation.getName()
|
|
|
|
|
);
|
|
|
|
|
service.sendBroadcast(intent);
|
|
|
|
|
}
|
2010-03-02 12:42:44 -05:00
|
|
|
|
|
2010-11-18 12:52:19 -05:00
|
|
|
|
/**
|
|
|
|
|
* On Op
|
|
|
|
|
*/
|
|
|
|
|
@Override
|
|
|
|
|
protected void onOp(String target, String sourceNick, String sourceLogin, String sourceHostname, String recipient)
|
|
|
|
|
{
|
|
|
|
|
Message message = new Message(service.getString(R.string.message_op, sourceNick, recipient));
|
|
|
|
|
message.setColor(Message.COLOR_BLUE);
|
|
|
|
|
message.setIcon(R.drawable.op);
|
|
|
|
|
server.getConversation(target).addMessage(message);
|
2010-12-17 16:29:33 -05:00
|
|
|
|
|
2010-11-18 12:52:19 -05:00
|
|
|
|
Intent intent = Broadcast.createConversationIntent(
|
|
|
|
|
Broadcast.CONVERSATION_MESSAGE,
|
|
|
|
|
server.getId(),
|
|
|
|
|
target
|
|
|
|
|
);
|
|
|
|
|
service.sendBroadcast(intent);
|
|
|
|
|
}
|
2010-03-02 12:42:44 -05:00
|
|
|
|
|
2010-11-18 12:52:19 -05:00
|
|
|
|
/**
|
|
|
|
|
* On Part
|
|
|
|
|
*/
|
|
|
|
|
@Override
|
|
|
|
|
protected void onPart(String target, String sender, String login, String hostname)
|
|
|
|
|
{
|
|
|
|
|
if (sender.equals(getNick())) {
|
|
|
|
|
// We parted a channel
|
2011-07-03 05:18:17 -04:00
|
|
|
|
service.ackNewMentions(server.getId(), target);
|
2010-11-18 12:52:19 -05:00
|
|
|
|
server.removeConversation(target);
|
2010-12-17 16:29:33 -05:00
|
|
|
|
|
2010-11-18 12:52:19 -05:00
|
|
|
|
Intent intent = Broadcast.createConversationIntent(
|
|
|
|
|
Broadcast.CONVERSATION_REMOVE,
|
|
|
|
|
server.getId(),
|
|
|
|
|
target
|
|
|
|
|
);
|
|
|
|
|
service.sendBroadcast(intent);
|
2011-03-15 15:42:35 -04:00
|
|
|
|
} else if (service.getSettings().showJoinPartAndQuit()) {
|
2011-03-15 15:12:12 -04:00
|
|
|
|
Message message = new Message(
|
|
|
|
|
service.getString(R.string.message_part, sender),
|
|
|
|
|
Message.TYPE_MISC
|
|
|
|
|
);
|
|
|
|
|
|
2010-11-18 12:52:19 -05:00
|
|
|
|
message.setColor(Message.COLOR_GREEN);
|
|
|
|
|
message.setIcon(R.drawable.part);
|
|
|
|
|
server.getConversation(target).addMessage(message);
|
2010-12-17 16:29:33 -05:00
|
|
|
|
|
2010-11-18 12:52:19 -05:00
|
|
|
|
Intent intent = Broadcast.createConversationIntent(
|
|
|
|
|
Broadcast.CONVERSATION_MESSAGE,
|
|
|
|
|
server.getId(),
|
|
|
|
|
target
|
|
|
|
|
);
|
|
|
|
|
service.sendBroadcast(intent);
|
|
|
|
|
}
|
|
|
|
|
}
|
2010-03-02 12:42:44 -05:00
|
|
|
|
|
2010-11-18 12:52:19 -05:00
|
|
|
|
/**
|
|
|
|
|
* On Private Message
|
|
|
|
|
*/
|
|
|
|
|
@Override
|
2011-05-29 20:49:01 -04:00
|
|
|
|
protected void onPrivateMessage(String sender, String login, String hostname, String target, String text)
|
2010-11-18 12:52:19 -05:00
|
|
|
|
{
|
|
|
|
|
Message message = new Message("<" + sender + "> " + text);
|
2011-05-29 20:49:01 -04:00
|
|
|
|
String queryNick = sender;
|
2010-12-17 16:29:33 -05:00
|
|
|
|
|
2011-05-29 20:49:01 -04:00
|
|
|
|
if (queryNick.equals(this.getNick())) {
|
|
|
|
|
queryNick = target;
|
|
|
|
|
}
|
|
|
|
|
Conversation conversation = server.getConversation(queryNick);
|
2010-03-10 15:34:20 -05:00
|
|
|
|
|
2010-12-17 16:29:33 -05:00
|
|
|
|
if (conversation == null) {
|
2010-11-18 12:52:19 -05:00
|
|
|
|
// Open a query if there's none yet
|
2011-05-29 20:49:01 -04:00
|
|
|
|
conversation = new Query(queryNick);
|
2011-05-29 20:49:49 -04:00
|
|
|
|
conversation.setHistorySize(service.getSettings().getHistorySize());
|
2010-11-18 12:52:19 -05:00
|
|
|
|
conversation.addMessage(message);
|
2011-03-15 18:59:49 -04:00
|
|
|
|
server.addConversation(conversation);
|
2010-12-17 16:29:33 -05:00
|
|
|
|
|
2010-11-18 12:52:19 -05:00
|
|
|
|
Intent intent = Broadcast.createConversationIntent(
|
|
|
|
|
Broadcast.CONVERSATION_NEW,
|
|
|
|
|
server.getId(),
|
2011-05-29 20:49:01 -04:00
|
|
|
|
queryNick
|
2010-11-18 12:52:19 -05:00
|
|
|
|
);
|
|
|
|
|
service.sendBroadcast(intent);
|
|
|
|
|
} else {
|
|
|
|
|
conversation.addMessage(message);
|
2010-12-17 16:29:33 -05:00
|
|
|
|
|
2010-11-18 12:52:19 -05:00
|
|
|
|
Intent intent = Broadcast.createConversationIntent(
|
|
|
|
|
Broadcast.CONVERSATION_MESSAGE,
|
|
|
|
|
server.getId(),
|
2011-05-29 20:49:01 -04:00
|
|
|
|
queryNick
|
2010-11-18 12:52:19 -05:00
|
|
|
|
);
|
|
|
|
|
service.sendBroadcast(intent);
|
|
|
|
|
}
|
2011-05-29 20:48:47 -04:00
|
|
|
|
|
2011-05-29 20:49:01 -04:00
|
|
|
|
if (sender.equals(this.getNick())) {
|
|
|
|
|
// Don't notify for something sent in our name
|
|
|
|
|
return;
|
|
|
|
|
}
|
|
|
|
|
|
2011-05-29 20:49:07 -04:00
|
|
|
|
if (conversation.getStatus() != Conversation.STATUS_SELECTED || !server.getIsForeground()) {
|
|
|
|
|
service.addNewMention(
|
2011-06-05 05:33:25 -04:00
|
|
|
|
server.getId(),
|
2011-05-29 20:49:07 -04:00
|
|
|
|
conversation,
|
|
|
|
|
"<" + sender + "> " + text,
|
|
|
|
|
service.getSettings().isVibrateHighlightEnabled(),
|
|
|
|
|
service.getSettings().isSoundHighlightEnabled()
|
|
|
|
|
);
|
|
|
|
|
}
|
2011-05-29 20:48:57 -04:00
|
|
|
|
|
2011-05-29 20:48:47 -04:00
|
|
|
|
if (isMentioned(text)) {
|
|
|
|
|
message.setColor(Message.COLOR_RED);
|
|
|
|
|
conversation.setStatus(Conversation.STATUS_HIGHLIGHT);
|
|
|
|
|
}
|
2010-11-18 12:52:19 -05:00
|
|
|
|
}
|
2010-03-02 12:42:44 -05:00
|
|
|
|
|
2010-11-18 12:52:19 -05:00
|
|
|
|
/**
|
|
|
|
|
* On Quit
|
|
|
|
|
*/
|
|
|
|
|
@Override
|
|
|
|
|
protected void onQuit(String sourceNick, String sourceLogin, String sourceHostname, String reason)
|
|
|
|
|
{
|
2011-03-15 15:42:35 -04:00
|
|
|
|
if (sourceNick.equals(this.getNick())) {
|
|
|
|
|
return;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (service.getSettings().showJoinPartAndQuit()) {
|
2010-11-18 12:52:19 -05:00
|
|
|
|
Vector<String> channels = getChannelsByNickname(sourceNick);
|
2010-12-17 16:29:33 -05:00
|
|
|
|
|
2010-11-18 12:52:19 -05:00
|
|
|
|
for (String target : channels) {
|
2011-03-15 15:12:12 -04:00
|
|
|
|
Message message = new Message(
|
|
|
|
|
service.getString(R.string.message_quit, sourceNick, reason),
|
|
|
|
|
Message.TYPE_MISC
|
|
|
|
|
);
|
|
|
|
|
|
2010-11-18 12:52:19 -05:00
|
|
|
|
message.setColor(Message.COLOR_GREEN);
|
|
|
|
|
message.setIcon(R.drawable.quit);
|
|
|
|
|
server.getConversation(target).addMessage(message);
|
2010-12-17 16:29:33 -05:00
|
|
|
|
|
2010-11-18 12:52:19 -05:00
|
|
|
|
Intent intent = Broadcast.createConversationIntent(
|
|
|
|
|
Broadcast.CONVERSATION_MESSAGE,
|
|
|
|
|
server.getId(),
|
|
|
|
|
target
|
|
|
|
|
);
|
|
|
|
|
service.sendBroadcast(intent);
|
|
|
|
|
}
|
2010-12-17 16:29:33 -05:00
|
|
|
|
|
2010-11-18 12:52:19 -05:00
|
|
|
|
// Look if there's a query to update
|
|
|
|
|
Conversation conversation = server.getConversation(sourceNick);
|
2010-12-17 16:29:33 -05:00
|
|
|
|
|
2010-11-18 12:52:19 -05:00
|
|
|
|
if (conversation != null) {
|
2011-03-15 15:12:12 -04:00
|
|
|
|
Message message = new Message(
|
|
|
|
|
service.getString(R.string.message_quit, sourceNick, reason),
|
|
|
|
|
Message.TYPE_MISC
|
|
|
|
|
);
|
|
|
|
|
|
2010-11-18 12:52:19 -05:00
|
|
|
|
message.setColor(Message.COLOR_GREEN);
|
|
|
|
|
message.setIcon(R.drawable.quit);
|
|
|
|
|
conversation.addMessage(message);
|
2010-12-17 16:29:33 -05:00
|
|
|
|
|
2010-11-18 12:52:19 -05:00
|
|
|
|
Intent intent = Broadcast.createConversationIntent(
|
|
|
|
|
Broadcast.CONVERSATION_MESSAGE,
|
|
|
|
|
server.getId(),
|
|
|
|
|
conversation.getName()
|
|
|
|
|
);
|
|
|
|
|
service.sendBroadcast(intent);
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
}
|
2010-03-02 12:42:44 -05:00
|
|
|
|
|
2010-11-18 12:52:19 -05:00
|
|
|
|
/**
|
|
|
|
|
* On Topic
|
|
|
|
|
*/
|
|
|
|
|
@Override
|
|
|
|
|
public void onTopic(String target, String topic, String setBy, long date, boolean changed)
|
|
|
|
|
{
|
|
|
|
|
if (changed) {
|
|
|
|
|
Message message = new Message(service.getString(R.string.message_topic_set, setBy, topic));
|
|
|
|
|
message.setColor(Message.COLOR_YELLOW);
|
|
|
|
|
server.getConversation(target).addMessage(message);
|
|
|
|
|
} else {
|
|
|
|
|
Message message = new Message(service.getString(R.string.message_topic, topic));
|
|
|
|
|
message.setColor(Message.COLOR_YELLOW);
|
|
|
|
|
server.getConversation(target).addMessage(message);
|
|
|
|
|
}
|
2010-12-17 16:29:33 -05:00
|
|
|
|
|
2010-11-18 12:52:19 -05:00
|
|
|
|
// remember channel's topic
|
|
|
|
|
((Channel) server.getConversation(target)).setTopic(topic);
|
2010-12-17 16:29:33 -05:00
|
|
|
|
|
2010-11-18 12:52:19 -05:00
|
|
|
|
Intent intent = Broadcast.createConversationIntent(
|
|
|
|
|
Broadcast.CONVERSATION_MESSAGE,
|
|
|
|
|
server.getId(),
|
|
|
|
|
target
|
|
|
|
|
);
|
|
|
|
|
service.sendBroadcast(intent);
|
2011-05-30 21:32:28 -04:00
|
|
|
|
|
|
|
|
|
// update the displayed conversation title if necessary
|
|
|
|
|
intent = Broadcast.createConversationIntent(
|
|
|
|
|
Broadcast.CONVERSATION_TOPIC,
|
|
|
|
|
server.getId(),
|
|
|
|
|
target
|
|
|
|
|
);
|
|
|
|
|
service.sendBroadcast(intent);
|
2010-11-18 12:52:19 -05:00
|
|
|
|
}
|
2010-03-02 12:42:44 -05:00
|
|
|
|
|
2010-11-18 12:52:19 -05:00
|
|
|
|
/**
|
|
|
|
|
* On User List
|
|
|
|
|
*/
|
|
|
|
|
@Override
|
|
|
|
|
protected void onUserList(String channel, User[] users)
|
|
|
|
|
{
|
|
|
|
|
// XXX: Store user list somewhere and keep it updated or just broadcast some event?
|
|
|
|
|
}
|
2010-03-02 12:42:44 -05:00
|
|
|
|
|
2010-11-18 12:52:19 -05:00
|
|
|
|
/**
|
|
|
|
|
* On Voice
|
|
|
|
|
*/
|
|
|
|
|
@Override
|
|
|
|
|
protected void onVoice(String target, String sourceNick, String sourceLogin, String sourceHostname, String recipient)
|
|
|
|
|
{
|
|
|
|
|
Message message = new Message(service.getString(R.string.message_voice, sourceNick, recipient));
|
|
|
|
|
message.setIcon(R.drawable.voice);
|
|
|
|
|
message.setColor(Message.COLOR_BLUE);
|
|
|
|
|
server.getConversation(target).addMessage(message);
|
2010-12-17 16:29:33 -05:00
|
|
|
|
|
2010-11-18 12:52:19 -05:00
|
|
|
|
Intent intent = Broadcast.createConversationIntent(
|
|
|
|
|
Broadcast.CONVERSATION_MESSAGE,
|
|
|
|
|
server.getId(),
|
|
|
|
|
target
|
|
|
|
|
);
|
|
|
|
|
service.sendBroadcast(intent);
|
|
|
|
|
}
|
2010-12-17 16:29:33 -05:00
|
|
|
|
|
2010-11-18 12:52:19 -05:00
|
|
|
|
/**
|
2010-12-17 16:29:33 -05:00
|
|
|
|
* On remove channel key
|
2010-11-18 12:52:19 -05:00
|
|
|
|
*/
|
|
|
|
|
@Override
|
|
|
|
|
protected void onRemoveChannelKey(String target, String sourceNick, String sourceLogin, String sourceHostname, String key)
|
|
|
|
|
{
|
|
|
|
|
Message message = new Message(service.getString(R.string.message_remove_channel_key, sourceNick));
|
|
|
|
|
message.setColor(Message.COLOR_BLUE);
|
|
|
|
|
server.getConversation(target).addMessage(message);
|
2010-12-17 16:29:33 -05:00
|
|
|
|
|
2010-11-18 12:52:19 -05:00
|
|
|
|
service.sendBroadcast(
|
|
|
|
|
Broadcast.createConversationIntent(Broadcast.CONVERSATION_MESSAGE, server.getId(), target)
|
|
|
|
|
);
|
|
|
|
|
}
|
2010-03-14 17:22:51 -04:00
|
|
|
|
|
2010-11-18 12:52:19 -05:00
|
|
|
|
/**
|
|
|
|
|
* On set channel key
|
|
|
|
|
*/
|
|
|
|
|
@Override
|
|
|
|
|
protected void onSetChannelKey(String target, String sourceNick, String sourceLogin, String sourceHostname, String key)
|
|
|
|
|
{
|
|
|
|
|
Message message = new Message(service.getString(R.string.message_set_channel_key, sourceNick, key));
|
|
|
|
|
message.setColor(Message.COLOR_BLUE);
|
|
|
|
|
server.getConversation(target).addMessage(message);
|
2010-12-17 16:29:33 -05:00
|
|
|
|
|
2010-11-18 12:52:19 -05:00
|
|
|
|
service.sendBroadcast(
|
|
|
|
|
Broadcast.createConversationIntent(Broadcast.CONVERSATION_MESSAGE, server.getId(), target)
|
|
|
|
|
);
|
|
|
|
|
}
|
2010-12-17 16:29:33 -05:00
|
|
|
|
|
2010-11-18 12:52:19 -05:00
|
|
|
|
/**
|
|
|
|
|
* On set secret
|
|
|
|
|
*/
|
|
|
|
|
@Override
|
|
|
|
|
protected void onSetSecret(String target, String sourceNick, String sourceLogin, String sourceHostname)
|
|
|
|
|
{
|
|
|
|
|
Message message = new Message(service.getString(R.string.message_set_channel_secret, sourceNick));
|
|
|
|
|
message.setColor(Message.COLOR_BLUE);
|
|
|
|
|
server.getConversation(target).addMessage(message);
|
2010-12-17 16:29:33 -05:00
|
|
|
|
|
2010-11-18 12:52:19 -05:00
|
|
|
|
service.sendBroadcast(
|
|
|
|
|
Broadcast.createConversationIntent(Broadcast.CONVERSATION_MESSAGE, server.getId(), target)
|
|
|
|
|
);
|
|
|
|
|
}
|
2010-12-17 16:29:33 -05:00
|
|
|
|
|
2010-11-18 12:52:19 -05:00
|
|
|
|
/**
|
|
|
|
|
* On remove secret
|
|
|
|
|
*/
|
|
|
|
|
@Override
|
|
|
|
|
protected void onRemoveSecret(String target, String sourceNick, String sourceLogin, String sourceHostname)
|
|
|
|
|
{
|
|
|
|
|
Message message = new Message(service.getString(R.string.message_set_channel_public, sourceNick));
|
|
|
|
|
message.setColor(Message.COLOR_BLUE);
|
|
|
|
|
server.getConversation(target).addMessage(message);
|
2010-12-17 16:29:33 -05:00
|
|
|
|
|
2010-11-18 12:52:19 -05:00
|
|
|
|
service.sendBroadcast(
|
|
|
|
|
Broadcast.createConversationIntent(Broadcast.CONVERSATION_MESSAGE, server.getId(), target)
|
|
|
|
|
);
|
|
|
|
|
}
|
2010-12-17 16:29:33 -05:00
|
|
|
|
|
2010-11-18 12:52:19 -05:00
|
|
|
|
/**
|
|
|
|
|
* On set channel limit
|
|
|
|
|
*/
|
|
|
|
|
@Override
|
|
|
|
|
protected void onSetChannelLimit(String target, String sourceNick, String sourceLogin, String sourceHostname, int limit)
|
|
|
|
|
{
|
|
|
|
|
Message message = new Message(service.getString(R.string.message_set_channel_limit, sourceNick, limit));
|
|
|
|
|
message.setColor(Message.COLOR_BLUE);
|
|
|
|
|
server.getConversation(target).addMessage(message);
|
2010-12-17 16:29:33 -05:00
|
|
|
|
|
2010-11-18 12:52:19 -05:00
|
|
|
|
service.sendBroadcast(
|
|
|
|
|
Broadcast.createConversationIntent(Broadcast.CONVERSATION_MESSAGE, server.getId(), target)
|
|
|
|
|
);
|
|
|
|
|
}
|
2010-12-17 16:29:33 -05:00
|
|
|
|
|
2010-11-18 12:52:19 -05:00
|
|
|
|
/**
|
|
|
|
|
* On remove channel limit
|
|
|
|
|
*/
|
|
|
|
|
@Override
|
|
|
|
|
protected void onRemoveChannelLimit(String target, String sourceNick, String sourceLogin, String sourceHostname)
|
|
|
|
|
{
|
|
|
|
|
Message message = new Message(service.getString(R.string.message_remove_channel_limit, sourceNick));
|
|
|
|
|
message.setColor(Message.COLOR_BLUE);
|
|
|
|
|
server.getConversation(target).addMessage(message);
|
2010-12-17 16:29:33 -05:00
|
|
|
|
|
2010-11-18 12:52:19 -05:00
|
|
|
|
service.sendBroadcast(
|
|
|
|
|
Broadcast.createConversationIntent(Broadcast.CONVERSATION_MESSAGE, server.getId(), target)
|
|
|
|
|
);
|
|
|
|
|
}
|
2010-03-14 17:22:51 -04:00
|
|
|
|
|
2010-11-18 12:52:19 -05:00
|
|
|
|
/**
|
|
|
|
|
* On set channel ban
|
|
|
|
|
*/
|
|
|
|
|
@Override
|
|
|
|
|
protected void onSetChannelBan(String target, String sourceNick, String sourceLogin, String sourceHostname, String hostmask)
|
|
|
|
|
{
|
|
|
|
|
Message message = new Message(service.getString(R.string.message_set_ban, sourceNick, hostmask));
|
|
|
|
|
message.setColor(Message.COLOR_BLUE);
|
|
|
|
|
server.getConversation(target).addMessage(message);
|
2010-12-17 16:29:33 -05:00
|
|
|
|
|
2010-11-18 12:52:19 -05:00
|
|
|
|
service.sendBroadcast(
|
|
|
|
|
Broadcast.createConversationIntent(Broadcast.CONVERSATION_MESSAGE, server.getId(), target)
|
|
|
|
|
);
|
|
|
|
|
}
|
2010-12-17 16:29:33 -05:00
|
|
|
|
|
2010-11-18 12:52:19 -05:00
|
|
|
|
/**
|
|
|
|
|
* On remove channel ban
|
|
|
|
|
*/
|
|
|
|
|
@Override
|
|
|
|
|
protected void onRemoveChannelBan(String target, String sourceNick, String sourceLogin, String sourceHostname, String hostmask)
|
|
|
|
|
{
|
|
|
|
|
Message message = new Message(service.getString(R.string.message_remove_ban, sourceNick, hostmask));
|
|
|
|
|
message.setColor(Message.COLOR_BLUE);
|
|
|
|
|
server.getConversation(target).addMessage(message);
|
2010-12-17 16:29:33 -05:00
|
|
|
|
|
2010-11-18 12:52:19 -05:00
|
|
|
|
service.sendBroadcast(
|
|
|
|
|
Broadcast.createConversationIntent(Broadcast.CONVERSATION_MESSAGE, server.getId(), target)
|
|
|
|
|
);
|
|
|
|
|
}
|
2010-12-17 16:29:33 -05:00
|
|
|
|
|
2010-11-18 12:52:19 -05:00
|
|
|
|
/**
|
|
|
|
|
* On set topic protection
|
|
|
|
|
*/
|
|
|
|
|
@Override
|
|
|
|
|
protected void onSetTopicProtection(String target, String sourceNick, String sourceLogin, String sourceHostname)
|
|
|
|
|
{
|
|
|
|
|
Message message = new Message(service.getString(R.string.message_set_topic_protection, sourceNick));
|
|
|
|
|
message.setColor(Message.COLOR_BLUE);
|
|
|
|
|
server.getConversation(target).addMessage(message);
|
2010-12-17 16:29:33 -05:00
|
|
|
|
|
2010-11-18 12:52:19 -05:00
|
|
|
|
service.sendBroadcast(
|
|
|
|
|
Broadcast.createConversationIntent(Broadcast.CONVERSATION_MESSAGE, server.getId(), target)
|
|
|
|
|
);
|
|
|
|
|
}
|
2010-12-17 16:29:33 -05:00
|
|
|
|
|
2010-11-18 12:52:19 -05:00
|
|
|
|
/**
|
|
|
|
|
* On remove topic protection
|
|
|
|
|
*/
|
|
|
|
|
@Override
|
|
|
|
|
protected void onRemoveTopicProtection(String target, String sourceNick, String sourceLogin, String sourceHostname)
|
|
|
|
|
{
|
|
|
|
|
Message message = new Message(service.getString(R.string.message_remove_topic_protection, sourceNick));
|
|
|
|
|
message.setColor(Message.COLOR_BLUE);
|
|
|
|
|
server.getConversation(target).addMessage(message);
|
2010-12-17 16:29:33 -05:00
|
|
|
|
|
2010-11-18 12:52:19 -05:00
|
|
|
|
service.sendBroadcast(
|
|
|
|
|
Broadcast.createConversationIntent(Broadcast.CONVERSATION_MESSAGE, server.getId(), target)
|
|
|
|
|
);
|
|
|
|
|
}
|
2010-03-18 14:38:55 -04:00
|
|
|
|
|
2010-11-18 12:52:19 -05:00
|
|
|
|
/**
|
|
|
|
|
* On set no external messages
|
|
|
|
|
*/
|
|
|
|
|
@Override
|
|
|
|
|
protected void onSetNoExternalMessages(String target, String sourceNick, String sourceLogin, String sourceHostname)
|
|
|
|
|
{
|
|
|
|
|
Message message = new Message(service.getString(R.string.message_disable_external, sourceNick));
|
|
|
|
|
message.setColor(Message.COLOR_BLUE);
|
|
|
|
|
server.getConversation(target).addMessage(message);
|
2010-12-17 16:29:33 -05:00
|
|
|
|
|
2010-11-18 12:52:19 -05:00
|
|
|
|
service.sendBroadcast(
|
|
|
|
|
Broadcast.createConversationIntent(Broadcast.CONVERSATION_MESSAGE, server.getId(), target)
|
|
|
|
|
);
|
|
|
|
|
}
|
2010-03-18 14:43:54 -04:00
|
|
|
|
|
2010-11-18 12:52:19 -05:00
|
|
|
|
/**
|
|
|
|
|
* On remove no external messages
|
|
|
|
|
*/
|
|
|
|
|
@Override
|
|
|
|
|
protected void onRemoveNoExternalMessages(String target, String sourceNick, String sourceLogin, String sourceHostname)
|
|
|
|
|
{
|
|
|
|
|
Message message = new Message(service.getString(R.string.message_enable_external, sourceNick));
|
|
|
|
|
message.setColor(Message.COLOR_BLUE);
|
|
|
|
|
server.getConversation(target).addMessage(message);
|
2010-12-17 16:29:33 -05:00
|
|
|
|
|
2010-11-18 12:52:19 -05:00
|
|
|
|
service.sendBroadcast(
|
|
|
|
|
Broadcast.createConversationIntent(Broadcast.CONVERSATION_MESSAGE, server.getId(), target)
|
|
|
|
|
);
|
|
|
|
|
}
|
2010-12-17 16:29:33 -05:00
|
|
|
|
|
2010-11-18 12:52:19 -05:00
|
|
|
|
/**
|
|
|
|
|
* On set invite only
|
|
|
|
|
*/
|
|
|
|
|
@Override
|
|
|
|
|
protected void onSetInviteOnly(String target, String sourceNick, String sourceLogin, String sourceHostname)
|
|
|
|
|
{
|
|
|
|
|
Message message = new Message(service.getString(R.string.message_set_invite_only, sourceNick));
|
|
|
|
|
message.setColor(Message.COLOR_BLUE);
|
|
|
|
|
server.getConversation(target).addMessage(message);
|
2010-12-17 16:29:33 -05:00
|
|
|
|
|
2010-11-18 12:52:19 -05:00
|
|
|
|
service.sendBroadcast(
|
|
|
|
|
Broadcast.createConversationIntent(Broadcast.CONVERSATION_MESSAGE, server.getId(), target)
|
|
|
|
|
);
|
|
|
|
|
}
|
2010-12-17 16:29:33 -05:00
|
|
|
|
|
2010-11-18 12:52:19 -05:00
|
|
|
|
/**
|
|
|
|
|
* On remove invite only
|
|
|
|
|
*/
|
|
|
|
|
@Override
|
|
|
|
|
protected void onRemoveInviteOnly(String target, String sourceNick, String sourceLogin, String sourceHostname)
|
|
|
|
|
{
|
|
|
|
|
Message message = new Message(service.getString(R.string.message_remove_invite_only, sourceNick));
|
|
|
|
|
message.setColor(Message.COLOR_BLUE);
|
|
|
|
|
server.getConversation(target).addMessage(message);
|
2010-12-17 16:29:33 -05:00
|
|
|
|
|
2010-11-18 12:52:19 -05:00
|
|
|
|
service.sendBroadcast(
|
|
|
|
|
Broadcast.createConversationIntent(Broadcast.CONVERSATION_MESSAGE, server.getId(), target)
|
|
|
|
|
);
|
|
|
|
|
}
|
2010-03-18 14:43:54 -04:00
|
|
|
|
|
2010-11-18 12:52:19 -05:00
|
|
|
|
/**
|
|
|
|
|
* On set moderated
|
|
|
|
|
*/
|
|
|
|
|
@Override
|
|
|
|
|
protected void onSetModerated(String target, String sourceNick, String sourceLogin, String sourceHostname)
|
|
|
|
|
{
|
|
|
|
|
Message message = new Message(service.getString(R.string.message_set_moderated, sourceNick));
|
|
|
|
|
message.setColor(Message.COLOR_BLUE);
|
|
|
|
|
server.getConversation(target).addMessage(message);
|
2010-12-17 16:29:33 -05:00
|
|
|
|
|
2010-11-18 12:52:19 -05:00
|
|
|
|
service.sendBroadcast(
|
|
|
|
|
Broadcast.createConversationIntent(Broadcast.CONVERSATION_MESSAGE, server.getId(), target)
|
|
|
|
|
);
|
|
|
|
|
}
|
2010-12-17 16:29:33 -05:00
|
|
|
|
|
2010-11-18 12:52:19 -05:00
|
|
|
|
/**
|
|
|
|
|
* On remove moderated
|
|
|
|
|
*/
|
|
|
|
|
@Override
|
|
|
|
|
protected void onRemoveModerated(String target, String sourceNick, String sourceLogin, String sourceHostname)
|
|
|
|
|
{
|
|
|
|
|
Message message = new Message(service.getString(R.string.message_remove_moderated, sourceNick));
|
|
|
|
|
message.setColor(Message.COLOR_BLUE);
|
|
|
|
|
server.getConversation(target).addMessage(message);
|
2010-12-17 16:29:33 -05:00
|
|
|
|
|
2010-11-18 12:52:19 -05:00
|
|
|
|
service.sendBroadcast(
|
|
|
|
|
Broadcast.createConversationIntent(Broadcast.CONVERSATION_MESSAGE, server.getId(), target)
|
|
|
|
|
);
|
|
|
|
|
}
|
2010-12-17 16:29:33 -05:00
|
|
|
|
|
2010-11-18 12:52:19 -05:00
|
|
|
|
/**
|
|
|
|
|
* On set private
|
|
|
|
|
*/
|
|
|
|
|
@Override
|
|
|
|
|
protected void onSetPrivate(String target, String sourceNick, String sourceLogin, String sourceHostname)
|
|
|
|
|
{
|
|
|
|
|
Message message = new Message(service.getString(R.string.message_set_channel_private, sourceNick));
|
|
|
|
|
message.setColor(Message.COLOR_BLUE);
|
|
|
|
|
server.getConversation(target).addMessage(message);
|
2010-12-17 16:29:33 -05:00
|
|
|
|
|
2010-11-18 12:52:19 -05:00
|
|
|
|
service.sendBroadcast(
|
|
|
|
|
Broadcast.createConversationIntent(Broadcast.CONVERSATION_MESSAGE, server.getId(), target)
|
|
|
|
|
);
|
|
|
|
|
}
|
2010-12-17 16:29:33 -05:00
|
|
|
|
|
2010-11-18 12:52:19 -05:00
|
|
|
|
/**
|
|
|
|
|
* On remove private
|
|
|
|
|
*/
|
|
|
|
|
@Override
|
|
|
|
|
protected void onRemovePrivate(String target, String sourceNick, String sourceLogin, String sourceHostname)
|
|
|
|
|
{
|
|
|
|
|
Message message = new Message(service.getString(R.string.message_set_channel_public, sourceNick));
|
|
|
|
|
message.setColor(Message.COLOR_BLUE);
|
|
|
|
|
server.getConversation(target).addMessage(message);
|
2010-12-17 16:29:33 -05:00
|
|
|
|
|
2010-11-18 12:52:19 -05:00
|
|
|
|
service.sendBroadcast(
|
|
|
|
|
Broadcast.createConversationIntent(Broadcast.CONVERSATION_MESSAGE, server.getId(), target)
|
|
|
|
|
);
|
|
|
|
|
}
|
2010-03-18 14:48:11 -04:00
|
|
|
|
|
2010-11-18 12:52:19 -05:00
|
|
|
|
/**
|
|
|
|
|
* On unknown
|
|
|
|
|
*/
|
|
|
|
|
@Override
|
|
|
|
|
protected void onUnknown(String line)
|
|
|
|
|
{
|
|
|
|
|
Message message = new Message(line);
|
|
|
|
|
message.setIcon(R.drawable.action);
|
|
|
|
|
message.setColor(Message.COLOR_GREY);
|
|
|
|
|
server.getConversation(ServerInfo.DEFAULT_NAME).addMessage(message);
|
2010-12-17 16:29:33 -05:00
|
|
|
|
|
2010-11-18 12:52:19 -05:00
|
|
|
|
Intent intent = Broadcast.createConversationIntent(
|
|
|
|
|
Broadcast.CONVERSATION_MESSAGE,
|
|
|
|
|
server.getId(),
|
|
|
|
|
ServerInfo.DEFAULT_NAME
|
|
|
|
|
);
|
|
|
|
|
service.sendBroadcast(intent);
|
|
|
|
|
}
|
2010-03-13 15:55:21 -05:00
|
|
|
|
|
2010-11-18 12:52:19 -05:00
|
|
|
|
/**
|
|
|
|
|
* On server response
|
|
|
|
|
*/
|
|
|
|
|
@Override
|
|
|
|
|
protected void onServerResponse(int code, String response)
|
|
|
|
|
{
|
2011-03-07 21:07:07 -05:00
|
|
|
|
if (code == 4) {
|
|
|
|
|
// User has registered with the server
|
|
|
|
|
onRegister();
|
|
|
|
|
return;
|
|
|
|
|
}
|
2011-06-15 20:14:09 -04:00
|
|
|
|
if ((code == 372 || code == 375) && ignoreMOTD) {
|
|
|
|
|
return;
|
|
|
|
|
}
|
|
|
|
|
if (code == 376 && ignoreMOTD) {
|
2011-06-16 17:10:50 -04:00
|
|
|
|
Message motdMessage = new Message(service.getString(R.string.message_motd_suppressed));
|
|
|
|
|
motdMessage.setColor(Message.COLOR_GREY);
|
|
|
|
|
server.getConversation(ServerInfo.DEFAULT_NAME).addMessage(motdMessage);
|
2011-06-15 20:14:09 -04:00
|
|
|
|
ignoreMOTD = false;
|
2010-11-18 12:52:19 -05:00
|
|
|
|
return;
|
|
|
|
|
}
|
2010-12-17 16:29:33 -05:00
|
|
|
|
|
2010-11-18 12:52:19 -05:00
|
|
|
|
if (code >= 200 && code < 300) {
|
|
|
|
|
// Skip 2XX responses
|
|
|
|
|
return;
|
|
|
|
|
}
|
2010-12-17 16:29:33 -05:00
|
|
|
|
|
2010-11-18 12:52:19 -05:00
|
|
|
|
if (code == 353 || code == 366 || code == 332 || code == 333) {
|
|
|
|
|
return;
|
|
|
|
|
}
|
2010-12-17 16:29:33 -05:00
|
|
|
|
|
2010-11-18 12:52:19 -05:00
|
|
|
|
if (code < 10) {
|
|
|
|
|
// Skip server info
|
|
|
|
|
return;
|
|
|
|
|
}
|
2010-03-17 18:50:31 -04:00
|
|
|
|
|
2010-11-18 12:52:19 -05:00
|
|
|
|
// Currently disabled... to much text
|
|
|
|
|
Message message = new Message(response);
|
|
|
|
|
message.setColor(Message.COLOR_GREY);
|
|
|
|
|
server.getConversation(ServerInfo.DEFAULT_NAME).addMessage(message);
|
2010-12-17 16:29:33 -05:00
|
|
|
|
|
2010-11-18 12:52:19 -05:00
|
|
|
|
Intent intent = Broadcast.createConversationIntent(
|
|
|
|
|
Broadcast.CONVERSATION_MESSAGE,
|
|
|
|
|
server.getId(),
|
|
|
|
|
ServerInfo.DEFAULT_NAME
|
|
|
|
|
);
|
|
|
|
|
service.sendBroadcast(intent);
|
|
|
|
|
}
|
2010-03-13 15:16:32 -05:00
|
|
|
|
|
2010-11-18 12:52:19 -05:00
|
|
|
|
/**
|
|
|
|
|
* On disconnect
|
|
|
|
|
*/
|
|
|
|
|
@Override
|
|
|
|
|
public void onDisconnect()
|
|
|
|
|
{
|
2011-04-12 16:23:51 -04:00
|
|
|
|
// Call parent method to ensure "register" status is tracked
|
|
|
|
|
super.onDisconnect();
|
|
|
|
|
|
2010-11-18 12:52:19 -05:00
|
|
|
|
if (service.getSettings().isReconnectEnabled() && server.getStatus() != Status.DISCONNECTED) {
|
|
|
|
|
setAutojoinChannels(server.getCurrentChannelNames());
|
2010-04-17 17:16:17 -04:00
|
|
|
|
|
2010-11-18 12:52:19 -05:00
|
|
|
|
server.setStatus(Status.CONNECTING);
|
|
|
|
|
service.connect(server);
|
|
|
|
|
} else {
|
|
|
|
|
server.setStatus(Status.DISCONNECTED);
|
|
|
|
|
}
|
2010-12-17 16:29:33 -05:00
|
|
|
|
|
2011-05-29 20:49:07 -04:00
|
|
|
|
service.notifyDisconnected(server.getTitle());
|
2010-04-17 17:07:01 -04:00
|
|
|
|
|
2010-11-18 12:52:19 -05:00
|
|
|
|
Intent sIntent = Broadcast.createServerIntent(Broadcast.SERVER_UPDATE, server.getId());
|
|
|
|
|
service.sendBroadcast(sIntent);
|
2010-12-17 16:29:33 -05:00
|
|
|
|
|
2010-11-18 12:52:19 -05:00
|
|
|
|
Collection<Conversation> conversations = server.getConversations();
|
2010-12-17 16:29:33 -05:00
|
|
|
|
|
2010-11-18 12:52:19 -05:00
|
|
|
|
for (Conversation conversation : conversations) {
|
|
|
|
|
Message message = new Message(service.getString(R.string.message_disconnected));
|
|
|
|
|
message.setIcon(R.drawable.error);
|
|
|
|
|
message.setColor(Message.COLOR_RED);
|
|
|
|
|
server.getConversation(conversation.getName()).addMessage(message);
|
2010-12-17 16:29:33 -05:00
|
|
|
|
|
2010-11-18 12:52:19 -05:00
|
|
|
|
Intent cIntent = Broadcast.createConversationIntent(
|
|
|
|
|
Broadcast.CONVERSATION_MESSAGE,
|
|
|
|
|
server.getId(),
|
|
|
|
|
conversation.getName()
|
|
|
|
|
);
|
|
|
|
|
service.sendBroadcast(cIntent);
|
|
|
|
|
}
|
Prevent race between IRCConnection dispose() and onDisconnect() when quitting
When the user asks for a disconnect from the ConversationActivity, there
is a race between the IRCConnection, which is waiting for the server to
acknowledge the QUIT before calling onDisconnect(), and the IRCService,
which will invoke dispose() on the IRCConnection when
checkServiceStatus() is called during the activity shutdown. If the
dispose() wins, the thread running the onDisconnect() is terminated,
leading to the cleanup being unfinished. This causes the disconnect
notification to be unreliable, and can result in the list of servers in
the ongoing notification to be out of sync with reality.
To fix this, introduce a new field isQuitting to the IRCConnection,
which is set to true when quitServer() is called and cleared once
onDisconnect() has finished. If dispose() is called while isQuitting is
set, it sets disposeRequested instead of doing the dispose itself, and
onDisconnect() will call through to super.dispose() once it's finished.
Note that this requires a change to PircBot to allow the overriding of
quitServer(String message), which is declared final upstream.
2011-06-05 05:29:04 -04:00
|
|
|
|
|
|
|
|
|
synchronized(isQuittingLock) {
|
|
|
|
|
isQuitting = false;
|
2011-06-10 15:36:14 -04:00
|
|
|
|
if (disposeRequested) {
|
Prevent race between IRCConnection dispose() and onDisconnect() when quitting
When the user asks for a disconnect from the ConversationActivity, there
is a race between the IRCConnection, which is waiting for the server to
acknowledge the QUIT before calling onDisconnect(), and the IRCService,
which will invoke dispose() on the IRCConnection when
checkServiceStatus() is called during the activity shutdown. If the
dispose() wins, the thread running the onDisconnect() is terminated,
leading to the cleanup being unfinished. This causes the disconnect
notification to be unreliable, and can result in the list of servers in
the ongoing notification to be out of sync with reality.
To fix this, introduce a new field isQuitting to the IRCConnection,
which is set to true when quitServer() is called and cleared once
onDisconnect() has finished. If dispose() is called while isQuitting is
set, it sets disposeRequested instead of doing the dispose itself, and
onDisconnect() will call through to super.dispose() once it's finished.
Note that this requires a change to PircBot to allow the overriding of
quitServer(String message), which is declared final upstream.
2011-06-05 05:29:04 -04:00
|
|
|
|
super.dispose();
|
2011-06-10 15:36:14 -04:00
|
|
|
|
}
|
Prevent race between IRCConnection dispose() and onDisconnect() when quitting
When the user asks for a disconnect from the ConversationActivity, there
is a race between the IRCConnection, which is waiting for the server to
acknowledge the QUIT before calling onDisconnect(), and the IRCService,
which will invoke dispose() on the IRCConnection when
checkServiceStatus() is called during the activity shutdown. If the
dispose() wins, the thread running the onDisconnect() is terminated,
leading to the cleanup being unfinished. This causes the disconnect
notification to be unreliable, and can result in the list of servers in
the ongoing notification to be out of sync with reality.
To fix this, introduce a new field isQuitting to the IRCConnection,
which is set to true when quitServer() is called and cleared once
onDisconnect() has finished. If dispose() is called while isQuitting is
set, it sets disposeRequested instead of doing the dispose itself, and
onDisconnect() will call through to super.dispose() once it's finished.
Note that this requires a change to PircBot to allow the overriding of
quitServer(String message), which is declared final upstream.
2011-06-05 05:29:04 -04:00
|
|
|
|
}
|
2010-11-18 12:52:19 -05:00
|
|
|
|
}
|
2010-12-17 16:29:33 -05:00
|
|
|
|
|
2010-11-18 12:52:19 -05:00
|
|
|
|
/**
|
|
|
|
|
* Get all channels where the user with the given nickname is online
|
|
|
|
|
*
|
|
|
|
|
* @param nickname
|
|
|
|
|
* @return Array of channel names
|
|
|
|
|
*/
|
|
|
|
|
private Vector<String> getChannelsByNickname(String nickname)
|
|
|
|
|
{
|
|
|
|
|
Vector<String> channels = new Vector<String>();
|
|
|
|
|
String[] channelArray = getChannels();
|
2010-12-17 16:29:33 -05:00
|
|
|
|
|
2010-11-18 12:52:19 -05:00
|
|
|
|
for (String channel : channelArray) {
|
|
|
|
|
User[] userArray = getUsers(channel);
|
|
|
|
|
for (User user : userArray) {
|
|
|
|
|
if (user.getNick().equals(nickname)) {
|
|
|
|
|
channels.add(channel);
|
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
}
|
2010-12-17 16:29:33 -05:00
|
|
|
|
|
2010-11-18 12:52:19 -05:00
|
|
|
|
return channels;
|
|
|
|
|
}
|
2010-12-17 16:29:33 -05:00
|
|
|
|
|
2010-11-18 12:52:19 -05:00
|
|
|
|
/**
|
|
|
|
|
* Get list of users in a channel as array of strings
|
|
|
|
|
*
|
|
|
|
|
* @param channel Name of the channel
|
|
|
|
|
*/
|
|
|
|
|
public String[] getUsersAsStringArray(String channel)
|
|
|
|
|
{
|
|
|
|
|
User[] userArray = getUsers(channel);
|
|
|
|
|
int mLength = userArray.length;
|
|
|
|
|
String[] users = new String[mLength];
|
2010-12-17 16:29:33 -05:00
|
|
|
|
|
2010-11-18 12:52:19 -05:00
|
|
|
|
for (int i = 0; i < mLength; i++) {
|
2011-02-05 10:04:22 -05:00
|
|
|
|
users[i] = userArray[i].getPrefix() + userArray[i].getNick();
|
2010-11-18 12:52:19 -05:00
|
|
|
|
}
|
2010-12-17 16:29:33 -05:00
|
|
|
|
|
2010-11-18 12:52:19 -05:00
|
|
|
|
return users;
|
|
|
|
|
}
|
2010-12-17 16:29:33 -05:00
|
|
|
|
|
2010-11-18 12:52:19 -05:00
|
|
|
|
/**
|
|
|
|
|
* Get a user by channel and nickname
|
|
|
|
|
*
|
|
|
|
|
* @param channel The channel the user is in
|
|
|
|
|
* @param nickname The nickname of the user (with or without prefix)
|
|
|
|
|
* @return the User object or null if user was not found
|
|
|
|
|
*/
|
|
|
|
|
public User getUser(String channel, String nickname)
|
|
|
|
|
{
|
|
|
|
|
User[] users = getUsers(channel);
|
|
|
|
|
int mLength = users.length;
|
2010-12-17 16:29:33 -05:00
|
|
|
|
|
2010-11-18 12:52:19 -05:00
|
|
|
|
for (int i = 0; i < mLength; i++) {
|
|
|
|
|
if (nickname.equals(users[i].getNick())) {
|
|
|
|
|
return users[i];
|
|
|
|
|
}
|
|
|
|
|
if (nickname.equals(users[i].getPrefix() + users[i].getNick())) {
|
|
|
|
|
return users[i];
|
|
|
|
|
}
|
|
|
|
|
}
|
2010-12-17 16:29:33 -05:00
|
|
|
|
|
2010-11-18 12:52:19 -05:00
|
|
|
|
return null;
|
|
|
|
|
}
|
2010-12-17 16:29:33 -05:00
|
|
|
|
|
2010-11-18 12:52:19 -05:00
|
|
|
|
/**
|
|
|
|
|
* Quits from the IRC server with default reason.
|
|
|
|
|
*/
|
|
|
|
|
@Override
|
|
|
|
|
public void quitServer()
|
|
|
|
|
{
|
Prevent race between IRCConnection dispose() and onDisconnect() when quitting
When the user asks for a disconnect from the ConversationActivity, there
is a race between the IRCConnection, which is waiting for the server to
acknowledge the QUIT before calling onDisconnect(), and the IRCService,
which will invoke dispose() on the IRCConnection when
checkServiceStatus() is called during the activity shutdown. If the
dispose() wins, the thread running the onDisconnect() is terminated,
leading to the cleanup being unfinished. This causes the disconnect
notification to be unreliable, and can result in the list of servers in
the ongoing notification to be out of sync with reality.
To fix this, introduce a new field isQuitting to the IRCConnection,
which is set to true when quitServer() is called and cleared once
onDisconnect() has finished. If dispose() is called while isQuitting is
set, it sets disposeRequested instead of doing the dispose itself, and
onDisconnect() will call through to super.dispose() once it's finished.
Note that this requires a change to PircBot to allow the overriding of
quitServer(String message), which is declared final upstream.
2011-06-05 05:29:04 -04:00
|
|
|
|
quitServer(service.getSettings().getQuitMessage());
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
@Override
|
|
|
|
|
public void quitServer(final String message)
|
|
|
|
|
{
|
|
|
|
|
synchronized(isQuittingLock) {
|
|
|
|
|
isQuitting = true;
|
|
|
|
|
}
|
|
|
|
|
|
2010-11-18 12:52:19 -05:00
|
|
|
|
new Thread() {
|
2010-12-17 16:29:33 -05:00
|
|
|
|
@Override
|
2010-11-18 12:52:19 -05:00
|
|
|
|
public void run() {
|
Prevent race between IRCConnection dispose() and onDisconnect() when quitting
When the user asks for a disconnect from the ConversationActivity, there
is a race between the IRCConnection, which is waiting for the server to
acknowledge the QUIT before calling onDisconnect(), and the IRCService,
which will invoke dispose() on the IRCConnection when
checkServiceStatus() is called during the activity shutdown. If the
dispose() wins, the thread running the onDisconnect() is terminated,
leading to the cleanup being unfinished. This causes the disconnect
notification to be unreliable, and can result in the list of servers in
the ongoing notification to be out of sync with reality.
To fix this, introduce a new field isQuitting to the IRCConnection,
which is set to true when quitServer() is called and cleared once
onDisconnect() has finished. If dispose() is called while isQuitting is
set, it sets disposeRequested instead of doing the dispose itself, and
onDisconnect() will call through to super.dispose() once it's finished.
Note that this requires a change to PircBot to allow the overriding of
quitServer(String message), which is declared final upstream.
2011-06-05 05:29:04 -04:00
|
|
|
|
superClassQuitServer(message);
|
2010-11-18 12:52:19 -05:00
|
|
|
|
}
|
|
|
|
|
}.start();
|
|
|
|
|
}
|
2010-12-17 16:29:33 -05:00
|
|
|
|
|
Prevent race between IRCConnection dispose() and onDisconnect() when quitting
When the user asks for a disconnect from the ConversationActivity, there
is a race between the IRCConnection, which is waiting for the server to
acknowledge the QUIT before calling onDisconnect(), and the IRCService,
which will invoke dispose() on the IRCConnection when
checkServiceStatus() is called during the activity shutdown. If the
dispose() wins, the thread running the onDisconnect() is terminated,
leading to the cleanup being unfinished. This causes the disconnect
notification to be unreliable, and can result in the list of servers in
the ongoing notification to be out of sync with reality.
To fix this, introduce a new field isQuitting to the IRCConnection,
which is set to true when quitServer() is called and cleared once
onDisconnect() has finished. If dispose() is called while isQuitting is
set, it sets disposeRequested instead of doing the dispose itself, and
onDisconnect() will call through to super.dispose() once it's finished.
Note that this requires a change to PircBot to allow the overriding of
quitServer(String message), which is declared final upstream.
2011-06-05 05:29:04 -04:00
|
|
|
|
private final void superClassQuitServer(String message)
|
|
|
|
|
{
|
|
|
|
|
super.quitServer(message);
|
|
|
|
|
}
|
|
|
|
|
|
2010-11-16 20:36:52 -05:00
|
|
|
|
/**
|
|
|
|
|
* Check whether the nickname has been mentioned.
|
|
|
|
|
*
|
|
|
|
|
* @param text The text to check for the nickname
|
|
|
|
|
* @return true if nickname was found, otherwise false
|
|
|
|
|
*/
|
2010-11-18 12:55:19 -05:00
|
|
|
|
public boolean isMentioned(String text)
|
|
|
|
|
{
|
2010-11-18 12:52:19 -05:00
|
|
|
|
return mNickMatch.matcher(text).find();
|
|
|
|
|
}
|
2010-12-17 16:29:33 -05:00
|
|
|
|
|
2010-11-16 20:36:52 -05:00
|
|
|
|
/**
|
|
|
|
|
* Update the nick matching pattern, should be called when the nickname changes.
|
|
|
|
|
*/
|
2010-11-18 12:55:19 -05:00
|
|
|
|
private void updateNickMatchPattern()
|
|
|
|
|
{
|
|
|
|
|
mNickMatch = Pattern.compile("(?:^|[\\s?!'<27>:;,.])"+Pattern.quote(getNick())+"(?:[\\s?!'<27>:;,.]|$)", Pattern.CASE_INSENSITIVE);
|
2010-11-18 12:52:19 -05:00
|
|
|
|
}
|
Prevent race between IRCConnection dispose() and onDisconnect() when quitting
When the user asks for a disconnect from the ConversationActivity, there
is a race between the IRCConnection, which is waiting for the server to
acknowledge the QUIT before calling onDisconnect(), and the IRCService,
which will invoke dispose() on the IRCConnection when
checkServiceStatus() is called during the activity shutdown. If the
dispose() wins, the thread running the onDisconnect() is terminated,
leading to the cleanup being unfinished. This causes the disconnect
notification to be unreliable, and can result in the list of servers in
the ongoing notification to be out of sync with reality.
To fix this, introduce a new field isQuitting to the IRCConnection,
which is set to true when quitServer() is called and cleared once
onDisconnect() has finished. If dispose() is called while isQuitting is
set, it sets disposeRequested instead of doing the dispose itself, and
onDisconnect() will call through to super.dispose() once it's finished.
Note that this requires a change to PircBot to allow the overriding of
quitServer(String message), which is declared final upstream.
2011-06-05 05:29:04 -04:00
|
|
|
|
|
|
|
|
|
@Override
|
|
|
|
|
public void dispose()
|
|
|
|
|
{
|
|
|
|
|
synchronized(isQuittingLock) {
|
2011-06-10 15:36:14 -04:00
|
|
|
|
if (isQuitting) {
|
Prevent race between IRCConnection dispose() and onDisconnect() when quitting
When the user asks for a disconnect from the ConversationActivity, there
is a race between the IRCConnection, which is waiting for the server to
acknowledge the QUIT before calling onDisconnect(), and the IRCService,
which will invoke dispose() on the IRCConnection when
checkServiceStatus() is called during the activity shutdown. If the
dispose() wins, the thread running the onDisconnect() is terminated,
leading to the cleanup being unfinished. This causes the disconnect
notification to be unreliable, and can result in the list of servers in
the ongoing notification to be out of sync with reality.
To fix this, introduce a new field isQuitting to the IRCConnection,
which is set to true when quitServer() is called and cleared once
onDisconnect() has finished. If dispose() is called while isQuitting is
set, it sets disposeRequested instead of doing the dispose itself, and
onDisconnect() will call through to super.dispose() once it's finished.
Note that this requires a change to PircBot to allow the overriding of
quitServer(String message), which is declared final upstream.
2011-06-05 05:29:04 -04:00
|
|
|
|
disposeRequested = true;
|
2011-06-10 15:36:14 -04:00
|
|
|
|
} else {
|
Prevent race between IRCConnection dispose() and onDisconnect() when quitting
When the user asks for a disconnect from the ConversationActivity, there
is a race between the IRCConnection, which is waiting for the server to
acknowledge the QUIT before calling onDisconnect(), and the IRCService,
which will invoke dispose() on the IRCConnection when
checkServiceStatus() is called during the activity shutdown. If the
dispose() wins, the thread running the onDisconnect() is terminated,
leading to the cleanup being unfinished. This causes the disconnect
notification to be unreliable, and can result in the list of servers in
the ongoing notification to be out of sync with reality.
To fix this, introduce a new field isQuitting to the IRCConnection,
which is set to true when quitServer() is called and cleared once
onDisconnect() has finished. If dispose() is called while isQuitting is
set, it sets disposeRequested instead of doing the dispose itself, and
onDisconnect() will call through to super.dispose() once it's finished.
Note that this requires a change to PircBot to allow the overriding of
quitServer(String message), which is declared final upstream.
2011-06-05 05:29:04 -04:00
|
|
|
|
super.dispose();
|
2011-06-10 15:36:14 -04:00
|
|
|
|
}
|
Prevent race between IRCConnection dispose() and onDisconnect() when quitting
When the user asks for a disconnect from the ConversationActivity, there
is a race between the IRCConnection, which is waiting for the server to
acknowledge the QUIT before calling onDisconnect(), and the IRCService,
which will invoke dispose() on the IRCConnection when
checkServiceStatus() is called during the activity shutdown. If the
dispose() wins, the thread running the onDisconnect() is terminated,
leading to the cleanup being unfinished. This causes the disconnect
notification to be unreliable, and can result in the list of servers in
the ongoing notification to be out of sync with reality.
To fix this, introduce a new field isQuitting to the IRCConnection,
which is set to true when quitServer() is called and cleared once
onDisconnect() has finished. If dispose() is called while isQuitting is
set, it sets disposeRequested instead of doing the dispose itself, and
onDisconnect() will call through to super.dispose() once it's finished.
Note that this requires a change to PircBot to allow the overriding of
quitServer(String message), which is declared final upstream.
2011-06-05 05:29:04 -04:00
|
|
|
|
}
|
|
|
|
|
}
|
2009-12-17 15:27:57 -05:00
|
|
|
|
}
|